"use strict";

Object.defineProperty(exports, "__esModule", { value: true });

function _interopDefault(ex) {
  return ex && typeof ex === "object" && "default" in ex ? ex["default"] : ex;
}

var React = require("react");
var React__default = _interopDefault(React);
var reactDom = require("react-dom");
var reactDom__default = _interopDefault(reactDom);
var styleInject_es = require("../style-inject.es-dcee06b6.js");
var _commonjsHelpers = require("../_commonjsHelpers-72d386ba.js");
var slicedToArray = require("../slicedToArray-172f4624.js");
var server = _interopDefault(require("react-dom/server"));

/*
object-assign
(c) Sindre Sorhus
@license MIT
*/
/* eslint-disable no-unused-vars */
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;

function toObject(val) {
  if (val === null || val === undefined) {
    throw new TypeError(
      "Object.assign cannot be called with null or undefined"
    );
  }

  return Object(val);
}

function shouldUseNative() {
  try {
    if (!Object.assign) {
      return false;
    }

    // Detect buggy property enumeration order in older V8 versions.

    // https://bugs.chromium.org/p/v8/issues/detail?id=4118
    var test1 = new String("abc"); // eslint-disable-line no-new-wrappers
    test1[5] = "de";
    if (Object.getOwnPropertyNames(test1)[0] === "5") {
      return false;
    }

    // https://bugs.chromium.org/p/v8/issues/detail?id=3056
    var test2 = {};
    for (var i = 0; i < 10; i++) {
      test2["_" + String.fromCharCode(i)] = i;
    }
    var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
      return test2[n];
    });
    if (order2.join("") !== "0123456789") {
      return false;
    }

    // https://bugs.chromium.org/p/v8/issues/detail?id=3056
    var test3 = {};
    "abcdefghijklmnopqrst".split("").forEach(function(letter) {
      test3[letter] = letter;
    });
    if (
      Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst"
    ) {
      return false;
    }

    return true;
  } catch (err) {
    // We don't expect any of the above to throw, but better to be safe.
    return false;
  }
}

var objectAssign = shouldUseNative()
  ? Object.assign
  : function(target, source) {
      var from;
      var to = toObject(target);
      var symbols;

      for (var s = 1; s < arguments.length; s++) {
        from = Object(arguments[s]);

        for (var key in from) {
          if (hasOwnProperty.call(from, key)) {
            to[key] = from[key];
          }
        }

        if (getOwnPropertySymbols) {
          symbols = getOwnPropertySymbols(from);
          for (var i = 0; i < symbols.length; i++) {
            if (propIsEnumerable.call(from, symbols[i])) {
              to[symbols[i]] = from[symbols[i]];
            }
          }
        }
      }

      return to;
    };

var immutable = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  /**
   *  Copyright (c) 2014-2015, Facebook, Inc.
   *  All rights reserved.
   *
   *  This source code is licensed under the BSD-style license found in the
   *  LICENSE file in the root directory of this source tree. An additional grant
   *  of patent rights can be found in the PATENTS file in the same directory.
   */

  (function(global, factory) {
    module.exports = factory();
  })(_commonjsHelpers.commonjsGlobal, function() {
    var SLICE$0 = Array.prototype.slice;

    function createClass(ctor, superClass) {
      if (superClass) {
        ctor.prototype = Object.create(superClass.prototype);
      }
      ctor.prototype.constructor = ctor;
    }

    function Iterable(value) {
      return isIterable(value) ? value : Seq(value);
    }

    createClass(KeyedIterable, Iterable);
    function KeyedIterable(value) {
      return isKeyed(value) ? value : KeyedSeq(value);
    }

    createClass(IndexedIterable, Iterable);
    function IndexedIterable(value) {
      return isIndexed(value) ? value : IndexedSeq(value);
    }

    createClass(SetIterable, Iterable);
    function SetIterable(value) {
      return isIterable(value) && !isAssociative(value) ? value : SetSeq(value);
    }

    function isIterable(maybeIterable) {
      return !!(maybeIterable && maybeIterable[IS_ITERABLE_SENTINEL]);
    }

    function isKeyed(maybeKeyed) {
      return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL]);
    }

    function isIndexed(maybeIndexed) {
      return !!(maybeIndexed && maybeIndexed[IS_INDEXED_SENTINEL]);
    }

    function isAssociative(maybeAssociative) {
      return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);
    }

    function isOrdered(maybeOrdered) {
      return !!(maybeOrdered && maybeOrdered[IS_ORDERED_SENTINEL]);
    }

    Iterable.isIterable = isIterable;
    Iterable.isKeyed = isKeyed;
    Iterable.isIndexed = isIndexed;
    Iterable.isAssociative = isAssociative;
    Iterable.isOrdered = isOrdered;

    Iterable.Keyed = KeyedIterable;
    Iterable.Indexed = IndexedIterable;
    Iterable.Set = SetIterable;

    var IS_ITERABLE_SENTINEL = "@@__IMMUTABLE_ITERABLE__@@";
    var IS_KEYED_SENTINEL = "@@__IMMUTABLE_KEYED__@@";
    var IS_INDEXED_SENTINEL = "@@__IMMUTABLE_INDEXED__@@";
    var IS_ORDERED_SENTINEL = "@@__IMMUTABLE_ORDERED__@@";

    // Used for setting prototype methods that IE8 chokes on.
    var DELETE = "delete";

    // Constants describing the size of trie nodes.
    var SHIFT = 5; // Resulted in best performance after ______?
    var SIZE = 1 << SHIFT;
    var MASK = SIZE - 1;

    // A consistent shared value representing "not set" which equals nothing other
    // than itself, and nothing that could be provided externally.
    var NOT_SET = {};

    // Boolean references, Rough equivalent of `bool &`.
    var CHANGE_LENGTH = { value: false };
    var DID_ALTER = { value: false };

    function MakeRef(ref) {
      ref.value = false;
      return ref;
    }

    function SetRef(ref) {
      ref && (ref.value = true);
    }

    // A function which returns a value representing an "owner" for transient writes
    // to tries. The return value will only ever equal itself, and will not equal
    // the return of any subsequent call of this function.
    function OwnerID() {}

    // http://jsperf.com/copy-array-inline
    function arrCopy(arr, offset) {
      offset = offset || 0;
      var len = Math.max(0, arr.length - offset);
      var newArr = new Array(len);
      for (var ii = 0; ii < len; ii++) {
        newArr[ii] = arr[ii + offset];
      }
      return newArr;
    }

    function ensureSize(iter) {
      if (iter.size === undefined) {
        iter.size = iter.__iterate(returnTrue);
      }
      return iter.size;
    }

    function wrapIndex(iter, index) {
      // This implements "is array index" which the ECMAString spec defines as:
      //
      //     A String property name P is an array index if and only if
      //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal
      //     to 2^32−1.
      //
      // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects
      if (typeof index !== "number") {
        var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32
        if ("" + uint32Index !== index || uint32Index === 4294967295) {
          return NaN;
        }
        index = uint32Index;
      }
      return index < 0 ? ensureSize(iter) + index : index;
    }

    function returnTrue() {
      return true;
    }

    function wholeSlice(begin, end, size) {
      return (
        (begin === 0 || (size !== undefined && begin <= -size)) &&
        (end === undefined || (size !== undefined && end >= size))
      );
    }

    function resolveBegin(begin, size) {
      return resolveIndex(begin, size, 0);
    }

    function resolveEnd(end, size) {
      return resolveIndex(end, size, size);
    }

    function resolveIndex(index, size, defaultIndex) {
      return index === undefined
        ? defaultIndex
        : index < 0
        ? Math.max(0, size + index)
        : size === undefined
        ? index
        : Math.min(size, index);
    }

    /* global Symbol */

    var ITERATE_KEYS = 0;
    var ITERATE_VALUES = 1;
    var ITERATE_ENTRIES = 2;

    var REAL_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
    var FAUX_ITERATOR_SYMBOL = "@@iterator";

    var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;

    function Iterator(next) {
      this.next = next;
    }

    Iterator.prototype.toString = function() {
      return "[Iterator]";
    };

    Iterator.KEYS = ITERATE_KEYS;
    Iterator.VALUES = ITERATE_VALUES;
    Iterator.ENTRIES = ITERATE_ENTRIES;

    Iterator.prototype.inspect = Iterator.prototype.toSource = function() {
      return this.toString();
    };
    Iterator.prototype[ITERATOR_SYMBOL] = function() {
      return this;
    };

    function iteratorValue(type, k, v, iteratorResult) {
      var value = type === 0 ? k : type === 1 ? v : [k, v];
      iteratorResult
        ? (iteratorResult.value = value)
        : (iteratorResult = {
            value: value,
            done: false
          });
      return iteratorResult;
    }

    function iteratorDone() {
      return { value: undefined, done: true };
    }

    function hasIterator(maybeIterable) {
      return !!getIteratorFn(maybeIterable);
    }

    function isIterator(maybeIterator) {
      return maybeIterator && typeof maybeIterator.next === "function";
    }

    function getIterator(iterable) {
      var iteratorFn = getIteratorFn(iterable);
      return iteratorFn && iteratorFn.call(iterable);
    }

    function getIteratorFn(iterable) {
      var iteratorFn =
        iterable &&
        ((REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||
          iterable[FAUX_ITERATOR_SYMBOL]);
      if (typeof iteratorFn === "function") {
        return iteratorFn;
      }
    }

    function isArrayLike(value) {
      return value && typeof value.length === "number";
    }

    createClass(Seq, Iterable);
    function Seq(value) {
      return value === null || value === undefined
        ? emptySequence()
        : isIterable(value)
        ? value.toSeq()
        : seqFromValue(value);
    }

    Seq.of = function(/*...values*/) {
      return Seq(arguments);
    };

    Seq.prototype.toSeq = function() {
      return this;
    };

    Seq.prototype.toString = function() {
      return this.__toString("Seq {", "}");
    };

    Seq.prototype.cacheResult = function() {
      if (!this._cache && this.__iterateUncached) {
        this._cache = this.entrySeq().toArray();
        this.size = this._cache.length;
      }
      return this;
    };

    // abstract __iterateUncached(fn, reverse)

    Seq.prototype.__iterate = function(fn, reverse) {
      return seqIterate(this, fn, reverse, true);
    };

    // abstract __iteratorUncached(type, reverse)

    Seq.prototype.__iterator = function(type, reverse) {
      return seqIterator(this, type, reverse, true);
    };

    createClass(KeyedSeq, Seq);
    function KeyedSeq(value) {
      return value === null || value === undefined
        ? emptySequence().toKeyedSeq()
        : isIterable(value)
        ? isKeyed(value)
          ? value.toSeq()
          : value.fromEntrySeq()
        : keyedSeqFromValue(value);
    }

    KeyedSeq.prototype.toKeyedSeq = function() {
      return this;
    };

    createClass(IndexedSeq, Seq);
    function IndexedSeq(value) {
      return value === null || value === undefined
        ? emptySequence()
        : !isIterable(value)
        ? indexedSeqFromValue(value)
        : isKeyed(value)
        ? value.entrySeq()
        : value.toIndexedSeq();
    }

    IndexedSeq.of = function(/*...values*/) {
      return IndexedSeq(arguments);
    };

    IndexedSeq.prototype.toIndexedSeq = function() {
      return this;
    };

    IndexedSeq.prototype.toString = function() {
      return this.__toString("Seq [", "]");
    };

    IndexedSeq.prototype.__iterate = function(fn, reverse) {
      return seqIterate(this, fn, reverse, false);
    };

    IndexedSeq.prototype.__iterator = function(type, reverse) {
      return seqIterator(this, type, reverse, false);
    };

    createClass(SetSeq, Seq);
    function SetSeq(value) {
      return (value === null || value === undefined
        ? emptySequence()
        : !isIterable(value)
        ? indexedSeqFromValue(value)
        : isKeyed(value)
        ? value.entrySeq()
        : value
      ).toSetSeq();
    }

    SetSeq.of = function(/*...values*/) {
      return SetSeq(arguments);
    };

    SetSeq.prototype.toSetSeq = function() {
      return this;
    };

    Seq.isSeq = isSeq;
    Seq.Keyed = KeyedSeq;
    Seq.Set = SetSeq;
    Seq.Indexed = IndexedSeq;

    var IS_SEQ_SENTINEL = "@@__IMMUTABLE_SEQ__@@";

    Seq.prototype[IS_SEQ_SENTINEL] = true;

    createClass(ArraySeq, IndexedSeq);
    function ArraySeq(array) {
      this._array = array;
      this.size = array.length;
    }

    ArraySeq.prototype.get = function(index, notSetValue) {
      return this.has(index)
        ? this._array[wrapIndex(this, index)]
        : notSetValue;
    };

    ArraySeq.prototype.__iterate = function(fn, reverse) {
      var array = this._array;
      var maxIndex = array.length - 1;
      for (var ii = 0; ii <= maxIndex; ii++) {
        if (fn(array[reverse ? maxIndex - ii : ii], ii, this) === false) {
          return ii + 1;
        }
      }
      return ii;
    };

    ArraySeq.prototype.__iterator = function(type, reverse) {
      var array = this._array;
      var maxIndex = array.length - 1;
      var ii = 0;
      return new Iterator(function() {
        return ii > maxIndex
          ? iteratorDone()
          : iteratorValue(type, ii, array[reverse ? maxIndex - ii++ : ii++]);
      });
    };

    createClass(ObjectSeq, KeyedSeq);
    function ObjectSeq(object) {
      var keys = Object.keys(object);
      this._object = object;
      this._keys = keys;
      this.size = keys.length;
    }

    ObjectSeq.prototype.get = function(key, notSetValue) {
      if (notSetValue !== undefined && !this.has(key)) {
        return notSetValue;
      }
      return this._object[key];
    };

    ObjectSeq.prototype.has = function(key) {
      return this._object.hasOwnProperty(key);
    };

    ObjectSeq.prototype.__iterate = function(fn, reverse) {
      var object = this._object;
      var keys = this._keys;
      var maxIndex = keys.length - 1;
      for (var ii = 0; ii <= maxIndex; ii++) {
        var key = keys[reverse ? maxIndex - ii : ii];
        if (fn(object[key], key, this) === false) {
          return ii + 1;
        }
      }
      return ii;
    };

    ObjectSeq.prototype.__iterator = function(type, reverse) {
      var object = this._object;
      var keys = this._keys;
      var maxIndex = keys.length - 1;
      var ii = 0;
      return new Iterator(function() {
        var key = keys[reverse ? maxIndex - ii : ii];
        return ii++ > maxIndex
          ? iteratorDone()
          : iteratorValue(type, key, object[key]);
      });
    };

    ObjectSeq.prototype[IS_ORDERED_SENTINEL] = true;

    createClass(IterableSeq, IndexedSeq);
    function IterableSeq(iterable) {
      this._iterable = iterable;
      this.size = iterable.length || iterable.size;
    }

    IterableSeq.prototype.__iterateUncached = function(fn, reverse) {
      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);
      }
      var iterable = this._iterable;
      var iterator = getIterator(iterable);
      var iterations = 0;
      if (isIterator(iterator)) {
        var step;
        while (!(step = iterator.next()).done) {
          if (fn(step.value, iterations++, this) === false) {
            break;
          }
        }
      }
      return iterations;
    };

    IterableSeq.prototype.__iteratorUncached = function(type, reverse) {
      if (reverse) {
        return this.cacheResult().__iterator(type, reverse);
      }
      var iterable = this._iterable;
      var iterator = getIterator(iterable);
      if (!isIterator(iterator)) {
        return new Iterator(iteratorDone);
      }
      var iterations = 0;
      return new Iterator(function() {
        var step = iterator.next();
        return step.done ? step : iteratorValue(type, iterations++, step.value);
      });
    };

    createClass(IteratorSeq, IndexedSeq);
    function IteratorSeq(iterator) {
      this._iterator = iterator;
      this._iteratorCache = [];
    }

    IteratorSeq.prototype.__iterateUncached = function(fn, reverse) {
      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);
      }
      var iterator = this._iterator;
      var cache = this._iteratorCache;
      var iterations = 0;
      while (iterations < cache.length) {
        if (fn(cache[iterations], iterations++, this) === false) {
          return iterations;
        }
      }
      var step;
      while (!(step = iterator.next()).done) {
        var val = step.value;
        cache[iterations] = val;
        if (fn(val, iterations++, this) === false) {
          break;
        }
      }
      return iterations;
    };

    IteratorSeq.prototype.__iteratorUncached = function(type, reverse) {
      if (reverse) {
        return this.cacheResult().__iterator(type, reverse);
      }
      var iterator = this._iterator;
      var cache = this._iteratorCache;
      var iterations = 0;
      return new Iterator(function() {
        if (iterations >= cache.length) {
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          cache[iterations] = step.value;
        }
        return iteratorValue(type, iterations, cache[iterations++]);
      });
    };

    // # pragma Helper functions

    function isSeq(maybeSeq) {
      return !!(maybeSeq && maybeSeq[IS_SEQ_SENTINEL]);
    }

    var EMPTY_SEQ;

    function emptySequence() {
      return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));
    }

    function keyedSeqFromValue(value) {
      var seq = Array.isArray(value)
        ? new ArraySeq(value).fromEntrySeq()
        : isIterator(value)
        ? new IteratorSeq(value).fromEntrySeq()
        : hasIterator(value)
        ? new IterableSeq(value).fromEntrySeq()
        : typeof value === "object"
        ? new ObjectSeq(value)
        : undefined;
      if (!seq) {
        throw new TypeError(
          "Expected Array or iterable object of [k, v] entries, " +
            "or keyed object: " +
            value
        );
      }
      return seq;
    }

    function indexedSeqFromValue(value) {
      var seq = maybeIndexedSeqFromValue(value);
      if (!seq) {
        throw new TypeError(
          "Expected Array or iterable object of values: " + value
        );
      }
      return seq;
    }

    function seqFromValue(value) {
      var seq =
        maybeIndexedSeqFromValue(value) ||
        (typeof value === "object" && new ObjectSeq(value));
      if (!seq) {
        throw new TypeError(
          "Expected Array or iterable object of values, or keyed object: " +
            value
        );
      }
      return seq;
    }

    function maybeIndexedSeqFromValue(value) {
      return isArrayLike(value)
        ? new ArraySeq(value)
        : isIterator(value)
        ? new IteratorSeq(value)
        : hasIterator(value)
        ? new IterableSeq(value)
        : undefined;
    }

    function seqIterate(seq, fn, reverse, useKeys) {
      var cache = seq._cache;
      if (cache) {
        var maxIndex = cache.length - 1;
        for (var ii = 0; ii <= maxIndex; ii++) {
          var entry = cache[reverse ? maxIndex - ii : ii];
          if (fn(entry[1], useKeys ? entry[0] : ii, seq) === false) {
            return ii + 1;
          }
        }
        return ii;
      }
      return seq.__iterateUncached(fn, reverse);
    }

    function seqIterator(seq, type, reverse, useKeys) {
      var cache = seq._cache;
      if (cache) {
        var maxIndex = cache.length - 1;
        var ii = 0;
        return new Iterator(function() {
          var entry = cache[reverse ? maxIndex - ii : ii];
          return ii++ > maxIndex
            ? iteratorDone()
            : iteratorValue(type, useKeys ? entry[0] : ii - 1, entry[1]);
        });
      }
      return seq.__iteratorUncached(type, reverse);
    }

    function fromJS(json, converter) {
      return converter
        ? fromJSWith(converter, json, "", { "": json })
        : fromJSDefault(json);
    }

    function fromJSWith(converter, json, key, parentJSON) {
      if (Array.isArray(json)) {
        return converter.call(
          parentJSON,
          key,
          IndexedSeq(json).map(function(v, k) {
            return fromJSWith(converter, v, k, json);
          })
        );
      }
      if (isPlainObj(json)) {
        return converter.call(
          parentJSON,
          key,
          KeyedSeq(json).map(function(v, k) {
            return fromJSWith(converter, v, k, json);
          })
        );
      }
      return json;
    }

    function fromJSDefault(json) {
      if (Array.isArray(json)) {
        return IndexedSeq(json)
          .map(fromJSDefault)
          .toList();
      }
      if (isPlainObj(json)) {
        return KeyedSeq(json)
          .map(fromJSDefault)
          .toMap();
      }
      return json;
    }

    function isPlainObj(value) {
      return (
        value &&
        (value.constructor === Object || value.constructor === undefined)
      );
    }

    /**
     * An extension of the "same-value" algorithm as [described for use by ES6 Map
     * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)
     *
     * NaN is considered the same as NaN, however -0 and 0 are considered the same
     * value, which is different from the algorithm described by
     * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
     *
     * This is extended further to allow Objects to describe the values they
     * represent, by way of `valueOf` or `equals` (and `hashCode`).
     *
     * Note: because of this extension, the key equality of Immutable.Map and the
     * value equality of Immutable.Set will differ from ES6 Map and Set.
     *
     * ### Defining custom values
     *
     * The easiest way to describe the value an object represents is by implementing
     * `valueOf`. For example, `Date` represents a value by returning a unix
     * timestamp for `valueOf`:
     *
     *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...
     *     var date2 = new Date(1234567890000);
     *     date1.valueOf(); // 1234567890000
     *     assert( date1 !== date2 );
     *     assert( Immutable.is( date1, date2 ) );
     *
     * Note: overriding `valueOf` may have other implications if you use this object
     * where JavaScript expects a primitive, such as implicit string coercion.
     *
     * For more complex types, especially collections, implementing `valueOf` may
     * not be performant. An alternative is to implement `equals` and `hashCode`.
     *
     * `equals` takes another object, presumably of similar type, and returns true
     * if the it is equal. Equality is symmetrical, so the same result should be
     * returned if this and the argument are flipped.
     *
     *     assert( a.equals(b) === b.equals(a) );
     *
     * `hashCode` returns a 32bit integer number representing the object which will
     * be used to determine how to store the value object in a Map or Set. You must
     * provide both or neither methods, one must not exist without the other.
     *
     * Also, an important relationship between these methods must be upheld: if two
     * values are equal, they *must* return the same hashCode. If the values are not
     * equal, they might have the same hashCode; this is called a hash collision,
     * and while undesirable for performance reasons, it is acceptable.
     *
     *     if (a.equals(b)) {
     *       assert( a.hashCode() === b.hashCode() );
     *     }
     *
     * All Immutable collections implement `equals` and `hashCode`.
     *
     */
    function is(valueA, valueB) {
      if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
        return true;
      }
      if (!valueA || !valueB) {
        return false;
      }
      if (
        typeof valueA.valueOf === "function" &&
        typeof valueB.valueOf === "function"
      ) {
        valueA = valueA.valueOf();
        valueB = valueB.valueOf();
        if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
          return true;
        }
        if (!valueA || !valueB) {
          return false;
        }
      }
      if (
        typeof valueA.equals === "function" &&
        typeof valueB.equals === "function" &&
        valueA.equals(valueB)
      ) {
        return true;
      }
      return false;
    }

    function deepEqual(a, b) {
      if (a === b) {
        return true;
      }

      if (
        !isIterable(b) ||
        (a.size !== undefined && b.size !== undefined && a.size !== b.size) ||
        (a.__hash !== undefined &&
          b.__hash !== undefined &&
          a.__hash !== b.__hash) ||
        isKeyed(a) !== isKeyed(b) ||
        isIndexed(a) !== isIndexed(b) ||
        isOrdered(a) !== isOrdered(b)
      ) {
        return false;
      }

      if (a.size === 0 && b.size === 0) {
        return true;
      }

      var notAssociative = !isAssociative(a);

      if (isOrdered(a)) {
        var entries = a.entries();
        return (
          b.every(function(v, k) {
            var entry = entries.next().value;
            return (
              entry && is(entry[1], v) && (notAssociative || is(entry[0], k))
            );
          }) && entries.next().done
        );
      }

      var flipped = false;

      if (a.size === undefined) {
        if (b.size === undefined) {
          if (typeof a.cacheResult === "function") {
            a.cacheResult();
          }
        } else {
          flipped = true;
          var _ = a;
          a = b;
          b = _;
        }
      }

      var allEqual = true;
      var bSize = b.__iterate(function(v, k) {
        if (
          notAssociative
            ? !a.has(v)
            : flipped
            ? !is(v, a.get(k, NOT_SET))
            : !is(a.get(k, NOT_SET), v)
        ) {
          allEqual = false;
          return false;
        }
      });

      return allEqual && a.size === bSize;
    }

    createClass(Repeat, IndexedSeq);

    function Repeat(value, times) {
      if (!(this instanceof Repeat)) {
        return new Repeat(value, times);
      }
      this._value = value;
      this.size = times === undefined ? Infinity : Math.max(0, times);
      if (this.size === 0) {
        if (EMPTY_REPEAT) {
          return EMPTY_REPEAT;
        }
        EMPTY_REPEAT = this;
      }
    }

    Repeat.prototype.toString = function() {
      if (this.size === 0) {
        return "Repeat []";
      }
      return "Repeat [ " + this._value + " " + this.size + " times ]";
    };

    Repeat.prototype.get = function(index, notSetValue) {
      return this.has(index) ? this._value : notSetValue;
    };

    Repeat.prototype.includes = function(searchValue) {
      return is(this._value, searchValue);
    };

    Repeat.prototype.slice = function(begin, end) {
      var size = this.size;
      return wholeSlice(begin, end, size)
        ? this
        : new Repeat(
            this._value,
            resolveEnd(end, size) - resolveBegin(begin, size)
          );
    };

    Repeat.prototype.reverse = function() {
      return this;
    };

    Repeat.prototype.indexOf = function(searchValue) {
      if (is(this._value, searchValue)) {
        return 0;
      }
      return -1;
    };

    Repeat.prototype.lastIndexOf = function(searchValue) {
      if (is(this._value, searchValue)) {
        return this.size;
      }
      return -1;
    };

    Repeat.prototype.__iterate = function(fn, reverse) {
      for (var ii = 0; ii < this.size; ii++) {
        if (fn(this._value, ii, this) === false) {
          return ii + 1;
        }
      }
      return ii;
    };

    Repeat.prototype.__iterator = function(type, reverse) {
      var this$0 = this;
      var ii = 0;
      return new Iterator(function() {
        return ii < this$0.size
          ? iteratorValue(type, ii++, this$0._value)
          : iteratorDone();
      });
    };

    Repeat.prototype.equals = function(other) {
      return other instanceof Repeat
        ? is(this._value, other._value)
        : deepEqual(other);
    };

    var EMPTY_REPEAT;

    function invariant(condition, error) {
      if (!condition) throw new Error(error);
    }

    createClass(Range, IndexedSeq);

    function Range(start, end, step) {
      if (!(this instanceof Range)) {
        return new Range(start, end, step);
      }
      invariant(step !== 0, "Cannot step a Range by 0");
      start = start || 0;
      if (end === undefined) {
        end = Infinity;
      }
      step = step === undefined ? 1 : Math.abs(step);
      if (end < start) {
        step = -step;
      }
      this._start = start;
      this._end = end;
      this._step = step;
      this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);
      if (this.size === 0) {
        if (EMPTY_RANGE) {
          return EMPTY_RANGE;
        }
        EMPTY_RANGE = this;
      }
    }

    Range.prototype.toString = function() {
      if (this.size === 0) {
        return "Range []";
      }
      return (
        "Range [ " +
        this._start +
        "..." +
        this._end +
        (this._step > 1 ? " by " + this._step : "") +
        " ]"
      );
    };

    Range.prototype.get = function(index, notSetValue) {
      return this.has(index)
        ? this._start + wrapIndex(this, index) * this._step
        : notSetValue;
    };

    Range.prototype.includes = function(searchValue) {
      var possibleIndex = (searchValue - this._start) / this._step;
      return (
        possibleIndex >= 0 &&
        possibleIndex < this.size &&
        possibleIndex === Math.floor(possibleIndex)
      );
    };

    Range.prototype.slice = function(begin, end) {
      if (wholeSlice(begin, end, this.size)) {
        return this;
      }
      begin = resolveBegin(begin, this.size);
      end = resolveEnd(end, this.size);
      if (end <= begin) {
        return new Range(0, 0);
      }
      return new Range(
        this.get(begin, this._end),
        this.get(end, this._end),
        this._step
      );
    };

    Range.prototype.indexOf = function(searchValue) {
      var offsetValue = searchValue - this._start;
      if (offsetValue % this._step === 0) {
        var index = offsetValue / this._step;
        if (index >= 0 && index < this.size) {
          return index;
        }
      }
      return -1;
    };

    Range.prototype.lastIndexOf = function(searchValue) {
      return this.indexOf(searchValue);
    };

    Range.prototype.__iterate = function(fn, reverse) {
      var maxIndex = this.size - 1;
      var step = this._step;
      var value = reverse ? this._start + maxIndex * step : this._start;
      for (var ii = 0; ii <= maxIndex; ii++) {
        if (fn(value, ii, this) === false) {
          return ii + 1;
        }
        value += reverse ? -step : step;
      }
      return ii;
    };

    Range.prototype.__iterator = function(type, reverse) {
      var maxIndex = this.size - 1;
      var step = this._step;
      var value = reverse ? this._start + maxIndex * step : this._start;
      var ii = 0;
      return new Iterator(function() {
        var v = value;
        value += reverse ? -step : step;
        return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii++, v);
      });
    };

    Range.prototype.equals = function(other) {
      return other instanceof Range
        ? this._start === other._start &&
            this._end === other._end &&
            this._step === other._step
        : deepEqual(this, other);
    };

    var EMPTY_RANGE;

    createClass(Collection, Iterable);
    function Collection() {
      throw TypeError("Abstract");
    }

    createClass(KeyedCollection, Collection);
    function KeyedCollection() {}

    createClass(IndexedCollection, Collection);
    function IndexedCollection() {}

    createClass(SetCollection, Collection);
    function SetCollection() {}

    Collection.Keyed = KeyedCollection;
    Collection.Indexed = IndexedCollection;
    Collection.Set = SetCollection;

    var imul =
      typeof Math.imul === "function" && Math.imul(0xffffffff, 2) === -2
        ? Math.imul
        : function imul(a, b) {
            a = a | 0; // int
            b = b | 0; // int
            var c = a & 0xffff;
            var d = b & 0xffff;
            // Shift by 0 fixes the sign on the high part.
            return (
              (c * d + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0)) | 0
            ); // int
          };

    // v8 has an optimization for storing 31-bit signed numbers.
    // Values which have either 00 or 11 as the high order bits qualify.
    // This function drops the highest order bit in a signed number, maintaining
    // the sign bit.
    function smi(i32) {
      return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff);
    }

    function hash(o) {
      if (o === false || o === null || o === undefined) {
        return 0;
      }
      if (typeof o.valueOf === "function") {
        o = o.valueOf();
        if (o === false || o === null || o === undefined) {
          return 0;
        }
      }
      if (o === true) {
        return 1;
      }
      var type = typeof o;
      if (type === "number") {
        var h = o | 0;
        if (h !== o) {
          h ^= o * 0xffffffff;
        }
        while (o > 0xffffffff) {
          o /= 0xffffffff;
          h ^= o;
        }
        return smi(h);
      }
      if (type === "string") {
        return o.length > STRING_HASH_CACHE_MIN_STRLEN
          ? cachedHashString(o)
          : hashString(o);
      }
      if (typeof o.hashCode === "function") {
        return o.hashCode();
      }
      if (type === "object") {
        return hashJSObj(o);
      }
      if (typeof o.toString === "function") {
        return hashString(o.toString());
      }
      throw new Error("Value type " + type + " cannot be hashed.");
    }

    function cachedHashString(string) {
      var hash = stringHashCache[string];
      if (hash === undefined) {
        hash = hashString(string);
        if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {
          STRING_HASH_CACHE_SIZE = 0;
          stringHashCache = {};
        }
        STRING_HASH_CACHE_SIZE++;
        stringHashCache[string] = hash;
      }
      return hash;
    }

    // http://jsperf.com/hashing-strings
    function hashString(string) {
      // This is the hash from JVM
      // The hash code for a string is computed as
      // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],
      // where s[i] is the ith character of the string and n is the length of
      // the string. We "mod" the result to make it between 0 (inclusive) and 2^31
      // (exclusive) by dropping high bits.
      var hash = 0;
      for (var ii = 0; ii < string.length; ii++) {
        hash = (31 * hash + string.charCodeAt(ii)) | 0;
      }
      return smi(hash);
    }

    function hashJSObj(obj) {
      var hash;
      if (usingWeakMap) {
        hash = weakMap.get(obj);
        if (hash !== undefined) {
          return hash;
        }
      }

      hash = obj[UID_HASH_KEY];
      if (hash !== undefined) {
        return hash;
      }

      if (!canDefineProperty) {
        hash =
          obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];
        if (hash !== undefined) {
          return hash;
        }

        hash = getIENodeHash(obj);
        if (hash !== undefined) {
          return hash;
        }
      }

      hash = ++objHashUID;
      if (objHashUID & 0x40000000) {
        objHashUID = 0;
      }

      if (usingWeakMap) {
        weakMap.set(obj, hash);
      } else if (isExtensible !== undefined && isExtensible(obj) === false) {
        throw new Error("Non-extensible objects are not allowed as keys.");
      } else if (canDefineProperty) {
        Object.defineProperty(obj, UID_HASH_KEY, {
          enumerable: false,
          configurable: false,
          writable: false,
          value: hash
        });
      } else if (
        obj.propertyIsEnumerable !== undefined &&
        obj.propertyIsEnumerable ===
          obj.constructor.prototype.propertyIsEnumerable
      ) {
        // Since we can't define a non-enumerable property on the object
        // we'll hijack one of the less-used non-enumerable properties to
        // save our hash on it. Since this is a function it will not show up in
        // `JSON.stringify` which is what we want.
        obj.propertyIsEnumerable = function() {
          return this.constructor.prototype.propertyIsEnumerable.apply(
            this,
            arguments
          );
        };
        obj.propertyIsEnumerable[UID_HASH_KEY] = hash;
      } else if (obj.nodeType !== undefined) {
        // At this point we couldn't get the IE `uniqueID` to use as a hash
        // and we couldn't use a non-enumerable property to exploit the
        // dontEnum bug so we simply add the `UID_HASH_KEY` on the node
        // itself.
        obj[UID_HASH_KEY] = hash;
      } else {
        throw new Error("Unable to set a non-enumerable property on object.");
      }

      return hash;
    }

    // Get references to ES5 object methods.
    var isExtensible = Object.isExtensible;

    // True if Object.defineProperty works as expected. IE8 fails this test.
    var canDefineProperty = (function() {
      try {
        Object.defineProperty({}, "@", {});
        return true;
      } catch (e) {
        return false;
      }
    })();

    // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it
    // and avoid memory leaks from the IE cloneNode bug.
    function getIENodeHash(node) {
      if (node && node.nodeType > 0) {
        switch (node.nodeType) {
          case 1: // Element
            return node.uniqueID;
          case 9: // Document
            return node.documentElement && node.documentElement.uniqueID;
        }
      }
    }

    // If possible, use a WeakMap.
    var usingWeakMap = typeof WeakMap === "function";
    var weakMap;
    if (usingWeakMap) {
      weakMap = new WeakMap();
    }

    var objHashUID = 0;

    var UID_HASH_KEY = "__immutablehash__";
    if (typeof Symbol === "function") {
      UID_HASH_KEY = Symbol(UID_HASH_KEY);
    }

    var STRING_HASH_CACHE_MIN_STRLEN = 16;
    var STRING_HASH_CACHE_MAX_SIZE = 255;
    var STRING_HASH_CACHE_SIZE = 0;
    var stringHashCache = {};

    function assertNotInfinite(size) {
      invariant(
        size !== Infinity,
        "Cannot perform this action with an infinite size."
      );
    }

    createClass(Map, KeyedCollection);

    // @pragma Construction

    function Map(value) {
      return value === null || value === undefined
        ? emptyMap()
        : isMap(value) && !isOrdered(value)
        ? value
        : emptyMap().withMutations(function(map) {
            var iter = KeyedIterable(value);
            assertNotInfinite(iter.size);
            iter.forEach(function(v, k) {
              return map.set(k, v);
            });
          });
    }

    Map.prototype.toString = function() {
      return this.__toString("Map {", "}");
    };

    // @pragma Access

    Map.prototype.get = function(k, notSetValue) {
      return this._root
        ? this._root.get(0, undefined, k, notSetValue)
        : notSetValue;
    };

    // @pragma Modification

    Map.prototype.set = function(k, v) {
      return updateMap(this, k, v);
    };

    Map.prototype.setIn = function(keyPath, v) {
      return this.updateIn(keyPath, NOT_SET, function() {
        return v;
      });
    };

    Map.prototype.remove = function(k) {
      return updateMap(this, k, NOT_SET);
    };

    Map.prototype.deleteIn = function(keyPath) {
      return this.updateIn(keyPath, function() {
        return NOT_SET;
      });
    };

    Map.prototype.update = function(k, notSetValue, updater) {
      return arguments.length === 1
        ? k(this)
        : this.updateIn([k], notSetValue, updater);
    };

    Map.prototype.updateIn = function(keyPath, notSetValue, updater) {
      if (!updater) {
        updater = notSetValue;
        notSetValue = undefined;
      }
      var updatedValue = updateInDeepMap(
        this,
        forceIterator(keyPath),
        notSetValue,
        updater
      );
      return updatedValue === NOT_SET ? undefined : updatedValue;
    };

    Map.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = 0;
        this._root = null;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return emptyMap();
    };

    // @pragma Composition

    Map.prototype.merge = function(/*...iters*/) {
      return mergeIntoMapWith(this, undefined, arguments);
    };

    Map.prototype.mergeWith = function(merger) {
      var iters = SLICE$0.call(arguments, 1);
      return mergeIntoMapWith(this, merger, iters);
    };

    Map.prototype.mergeIn = function(keyPath) {
      var iters = SLICE$0.call(arguments, 1);
      return this.updateIn(keyPath, emptyMap(), function(m) {
        return typeof m.merge === "function"
          ? m.merge.apply(m, iters)
          : iters[iters.length - 1];
      });
    };

    Map.prototype.mergeDeep = function(/*...iters*/) {
      return mergeIntoMapWith(this, deepMerger, arguments);
    };

    Map.prototype.mergeDeepWith = function(merger) {
      var iters = SLICE$0.call(arguments, 1);
      return mergeIntoMapWith(this, deepMergerWith(merger), iters);
    };

    Map.prototype.mergeDeepIn = function(keyPath) {
      var iters = SLICE$0.call(arguments, 1);
      return this.updateIn(keyPath, emptyMap(), function(m) {
        return typeof m.mergeDeep === "function"
          ? m.mergeDeep.apply(m, iters)
          : iters[iters.length - 1];
      });
    };

    Map.prototype.sort = function(comparator) {
      // Late binding
      return OrderedMap(sortFactory(this, comparator));
    };

    Map.prototype.sortBy = function(mapper, comparator) {
      // Late binding
      return OrderedMap(sortFactory(this, comparator, mapper));
    };

    // @pragma Mutability

    Map.prototype.withMutations = function(fn) {
      var mutable = this.asMutable();
      fn(mutable);
      return mutable.wasAltered()
        ? mutable.__ensureOwner(this.__ownerID)
        : this;
    };

    Map.prototype.asMutable = function() {
      return this.__ownerID ? this : this.__ensureOwner(new OwnerID());
    };

    Map.prototype.asImmutable = function() {
      return this.__ensureOwner();
    };

    Map.prototype.wasAltered = function() {
      return this.__altered;
    };

    Map.prototype.__iterator = function(type, reverse) {
      return new MapIterator(this, type, reverse);
    };

    Map.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      var iterations = 0;
      this._root &&
        this._root.iterate(function(entry) {
          iterations++;
          return fn(entry[1], entry[0], this$0);
        }, reverse);
      return iterations;
    };

    Map.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {
        this.__ownerID = ownerID;
        this.__altered = false;
        return this;
      }
      return makeMap(this.size, this._root, ownerID, this.__hash);
    };

    function isMap(maybeMap) {
      return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]);
    }

    Map.isMap = isMap;

    var IS_MAP_SENTINEL = "@@__IMMUTABLE_MAP__@@";

    var MapPrototype = Map.prototype;
    MapPrototype[IS_MAP_SENTINEL] = true;
    MapPrototype[DELETE] = MapPrototype.remove;
    MapPrototype.removeIn = MapPrototype.deleteIn;

    // #pragma Trie Nodes

    function ArrayMapNode(ownerID, entries) {
      this.ownerID = ownerID;
      this.entries = entries;
    }

    ArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {
      var entries = this.entries;
      for (var ii = 0, len = entries.length; ii < len; ii++) {
        if (is(key, entries[ii][0])) {
          return entries[ii][1];
        }
      }
      return notSetValue;
    };

    ArrayMapNode.prototype.update = function(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      var removed = value === NOT_SET;

      var entries = this.entries;
      var idx = 0;
      for (var len = entries.length; idx < len; idx++) {
        if (is(key, entries[idx][0])) {
          break;
        }
      }
      var exists = idx < len;

      if (exists ? entries[idx][1] === value : removed) {
        return this;
      }

      SetRef(didAlter);
      (removed || !exists) && SetRef(didChangeSize);

      if (removed && entries.length === 1) {
        return; // undefined
      }

      if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {
        return createNodes(ownerID, entries, key, value);
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newEntries = isEditable ? entries : arrCopy(entries);

      if (exists) {
        if (removed) {
          idx === len - 1
            ? newEntries.pop()
            : (newEntries[idx] = newEntries.pop());
        } else {
          newEntries[idx] = [key, value];
        }
      } else {
        newEntries.push([key, value]);
      }

      if (isEditable) {
        this.entries = newEntries;
        return this;
      }

      return new ArrayMapNode(ownerID, newEntries);
    };

    function BitmapIndexedNode(ownerID, bitmap, nodes) {
      this.ownerID = ownerID;
      this.bitmap = bitmap;
      this.nodes = nodes;
    }

    BitmapIndexedNode.prototype.get = function(
      shift,
      keyHash,
      key,
      notSetValue
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var bit = 1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK);
      var bitmap = this.bitmap;
      return (bitmap & bit) === 0
        ? notSetValue
        : this.nodes[popCount(bitmap & (bit - 1))].get(
            shift + SHIFT,
            keyHash,
            key,
            notSetValue
          );
    };

    BitmapIndexedNode.prototype.update = function(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
      var bit = 1 << keyHashFrag;
      var bitmap = this.bitmap;
      var exists = (bitmap & bit) !== 0;

      if (!exists && value === NOT_SET) {
        return this;
      }

      var idx = popCount(bitmap & (bit - 1));
      var nodes = this.nodes;
      var node = exists ? nodes[idx] : undefined;
      var newNode = updateNode(
        node,
        ownerID,
        shift + SHIFT,
        keyHash,
        key,
        value,
        didChangeSize,
        didAlter
      );

      if (newNode === node) {
        return this;
      }

      if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {
        return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);
      }

      if (
        exists &&
        !newNode &&
        nodes.length === 2 &&
        isLeafNode(nodes[idx ^ 1])
      ) {
        return nodes[idx ^ 1];
      }

      if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {
        return newNode;
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newBitmap = exists ? (newNode ? bitmap : bitmap ^ bit) : bitmap | bit;
      var newNodes = exists
        ? newNode
          ? setIn(nodes, idx, newNode, isEditable)
          : spliceOut(nodes, idx, isEditable)
        : spliceIn(nodes, idx, newNode, isEditable);

      if (isEditable) {
        this.bitmap = newBitmap;
        this.nodes = newNodes;
        return this;
      }

      return new BitmapIndexedNode(ownerID, newBitmap, newNodes);
    };

    function HashArrayMapNode(ownerID, count, nodes) {
      this.ownerID = ownerID;
      this.count = count;
      this.nodes = nodes;
    }

    HashArrayMapNode.prototype.get = function(
      shift,
      keyHash,
      key,
      notSetValue
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
      var node = this.nodes[idx];
      return node
        ? node.get(shift + SHIFT, keyHash, key, notSetValue)
        : notSetValue;
    };

    HashArrayMapNode.prototype.update = function(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
      var removed = value === NOT_SET;
      var nodes = this.nodes;
      var node = nodes[idx];

      if (removed && !node) {
        return this;
      }

      var newNode = updateNode(
        node,
        ownerID,
        shift + SHIFT,
        keyHash,
        key,
        value,
        didChangeSize,
        didAlter
      );
      if (newNode === node) {
        return this;
      }

      var newCount = this.count;
      if (!node) {
        newCount++;
      } else if (!newNode) {
        newCount--;
        if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {
          return packNodes(ownerID, nodes, newCount, idx);
        }
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newNodes = setIn(nodes, idx, newNode, isEditable);

      if (isEditable) {
        this.count = newCount;
        this.nodes = newNodes;
        return this;
      }

      return new HashArrayMapNode(ownerID, newCount, newNodes);
    };

    function HashCollisionNode(ownerID, keyHash, entries) {
      this.ownerID = ownerID;
      this.keyHash = keyHash;
      this.entries = entries;
    }

    HashCollisionNode.prototype.get = function(
      shift,
      keyHash,
      key,
      notSetValue
    ) {
      var entries = this.entries;
      for (var ii = 0, len = entries.length; ii < len; ii++) {
        if (is(key, entries[ii][0])) {
          return entries[ii][1];
        }
      }
      return notSetValue;
    };

    HashCollisionNode.prototype.update = function(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }

      var removed = value === NOT_SET;

      if (keyHash !== this.keyHash) {
        if (removed) {
          return this;
        }
        SetRef(didAlter);
        SetRef(didChangeSize);
        return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);
      }

      var entries = this.entries;
      var idx = 0;
      for (var len = entries.length; idx < len; idx++) {
        if (is(key, entries[idx][0])) {
          break;
        }
      }
      var exists = idx < len;

      if (exists ? entries[idx][1] === value : removed) {
        return this;
      }

      SetRef(didAlter);
      (removed || !exists) && SetRef(didChangeSize);

      if (removed && len === 2) {
        return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newEntries = isEditable ? entries : arrCopy(entries);

      if (exists) {
        if (removed) {
          idx === len - 1
            ? newEntries.pop()
            : (newEntries[idx] = newEntries.pop());
        } else {
          newEntries[idx] = [key, value];
        }
      } else {
        newEntries.push([key, value]);
      }

      if (isEditable) {
        this.entries = newEntries;
        return this;
      }

      return new HashCollisionNode(ownerID, this.keyHash, newEntries);
    };

    function ValueNode(ownerID, keyHash, entry) {
      this.ownerID = ownerID;
      this.keyHash = keyHash;
      this.entry = entry;
    }

    ValueNode.prototype.get = function(shift, keyHash, key, notSetValue) {
      return is(key, this.entry[0]) ? this.entry[1] : notSetValue;
    };

    ValueNode.prototype.update = function(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      var removed = value === NOT_SET;
      var keyMatch = is(key, this.entry[0]);
      if (keyMatch ? value === this.entry[1] : removed) {
        return this;
      }

      SetRef(didAlter);

      if (removed) {
        SetRef(didChangeSize);
        return; // undefined
      }

      if (keyMatch) {
        if (ownerID && ownerID === this.ownerID) {
          this.entry[1] = value;
          return this;
        }
        return new ValueNode(ownerID, this.keyHash, [key, value]);
      }

      SetRef(didChangeSize);
      return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);
    };

    // #pragma Iterators

    ArrayMapNode.prototype.iterate = HashCollisionNode.prototype.iterate = function(
      fn,
      reverse
    ) {
      var entries = this.entries;
      for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {
        if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {
          return false;
        }
      }
    };

    BitmapIndexedNode.prototype.iterate = HashArrayMapNode.prototype.iterate = function(
      fn,
      reverse
    ) {
      var nodes = this.nodes;
      for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {
        var node = nodes[reverse ? maxIndex - ii : ii];
        if (node && node.iterate(fn, reverse) === false) {
          return false;
        }
      }
    };

    ValueNode.prototype.iterate = function(fn, reverse) {
      return fn(this.entry);
    };

    createClass(MapIterator, Iterator);

    function MapIterator(map, type, reverse) {
      this._type = type;
      this._reverse = reverse;
      this._stack = map._root && mapIteratorFrame(map._root);
    }

    MapIterator.prototype.next = function() {
      var type = this._type;
      var stack = this._stack;
      while (stack) {
        var node = stack.node;
        var index = stack.index++;
        var maxIndex;
        if (node.entry) {
          if (index === 0) {
            return mapIteratorValue(type, node.entry);
          }
        } else if (node.entries) {
          maxIndex = node.entries.length - 1;
          if (index <= maxIndex) {
            return mapIteratorValue(
              type,
              node.entries[this._reverse ? maxIndex - index : index]
            );
          }
        } else {
          maxIndex = node.nodes.length - 1;
          if (index <= maxIndex) {
            var subNode = node.nodes[this._reverse ? maxIndex - index : index];
            if (subNode) {
              if (subNode.entry) {
                return mapIteratorValue(type, subNode.entry);
              }
              stack = this._stack = mapIteratorFrame(subNode, stack);
            }
            continue;
          }
        }
        stack = this._stack = this._stack.__prev;
      }
      return iteratorDone();
    };

    function mapIteratorValue(type, entry) {
      return iteratorValue(type, entry[0], entry[1]);
    }

    function mapIteratorFrame(node, prev) {
      return {
        node: node,
        index: 0,
        __prev: prev
      };
    }

    function makeMap(size, root, ownerID, hash) {
      var map = Object.create(MapPrototype);
      map.size = size;
      map._root = root;
      map.__ownerID = ownerID;
      map.__hash = hash;
      map.__altered = false;
      return map;
    }

    var EMPTY_MAP;
    function emptyMap() {
      return EMPTY_MAP || (EMPTY_MAP = makeMap(0));
    }

    function updateMap(map, k, v) {
      var newRoot;
      var newSize;
      if (!map._root) {
        if (v === NOT_SET) {
          return map;
        }
        newSize = 1;
        newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);
      } else {
        var didChangeSize = MakeRef(CHANGE_LENGTH);
        var didAlter = MakeRef(DID_ALTER);
        newRoot = updateNode(
          map._root,
          map.__ownerID,
          0,
          undefined,
          k,
          v,
          didChangeSize,
          didAlter
        );
        if (!didAlter.value) {
          return map;
        }
        newSize =
          map.size + (didChangeSize.value ? (v === NOT_SET ? -1 : 1) : 0);
      }
      if (map.__ownerID) {
        map.size = newSize;
        map._root = newRoot;
        map.__hash = undefined;
        map.__altered = true;
        return map;
      }
      return newRoot ? makeMap(newSize, newRoot) : emptyMap();
    }

    function updateNode(
      node,
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (!node) {
        if (value === NOT_SET) {
          return node;
        }
        SetRef(didAlter);
        SetRef(didChangeSize);
        return new ValueNode(ownerID, keyHash, [key, value]);
      }
      return node.update(
        ownerID,
        shift,
        keyHash,
        key,
        value,
        didChangeSize,
        didAlter
      );
    }

    function isLeafNode(node) {
      return (
        node.constructor === ValueNode || node.constructor === HashCollisionNode
      );
    }

    function mergeIntoNode(node, ownerID, shift, keyHash, entry) {
      if (node.keyHash === keyHash) {
        return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);
      }

      var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;
      var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;

      var newNode;
      var nodes =
        idx1 === idx2
          ? [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)]
          : ((newNode = new ValueNode(ownerID, keyHash, entry)),
            idx1 < idx2 ? [node, newNode] : [newNode, node]);

      return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);
    }

    function createNodes(ownerID, entries, key, value) {
      if (!ownerID) {
        ownerID = new OwnerID();
      }
      var node = new ValueNode(ownerID, hash(key), [key, value]);
      for (var ii = 0; ii < entries.length; ii++) {
        var entry = entries[ii];
        node = node.update(ownerID, 0, undefined, entry[0], entry[1]);
      }
      return node;
    }

    function packNodes(ownerID, nodes, count, excluding) {
      var bitmap = 0;
      var packedII = 0;
      var packedNodes = new Array(count);
      for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {
        var node = nodes[ii];
        if (node !== undefined && ii !== excluding) {
          bitmap |= bit;
          packedNodes[packedII++] = node;
        }
      }
      return new BitmapIndexedNode(ownerID, bitmap, packedNodes);
    }

    function expandNodes(ownerID, nodes, bitmap, including, node) {
      var count = 0;
      var expandedNodes = new Array(SIZE);
      for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {
        expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;
      }
      expandedNodes[including] = node;
      return new HashArrayMapNode(ownerID, count + 1, expandedNodes);
    }

    function mergeIntoMapWith(map, merger, iterables) {
      var iters = [];
      for (var ii = 0; ii < iterables.length; ii++) {
        var value = iterables[ii];
        var iter = KeyedIterable(value);
        if (!isIterable(value)) {
          iter = iter.map(function(v) {
            return fromJS(v);
          });
        }
        iters.push(iter);
      }
      return mergeIntoCollectionWith(map, merger, iters);
    }

    function deepMerger(existing, value, key) {
      return existing && existing.mergeDeep && isIterable(value)
        ? existing.mergeDeep(value)
        : is(existing, value)
        ? existing
        : value;
    }

    function deepMergerWith(merger) {
      return function(existing, value, key) {
        if (existing && existing.mergeDeepWith && isIterable(value)) {
          return existing.mergeDeepWith(merger, value);
        }
        var nextValue = merger(existing, value, key);
        return is(existing, nextValue) ? existing : nextValue;
      };
    }

    function mergeIntoCollectionWith(collection, merger, iters) {
      iters = iters.filter(function(x) {
        return x.size !== 0;
      });
      if (iters.length === 0) {
        return collection;
      }
      if (
        collection.size === 0 &&
        !collection.__ownerID &&
        iters.length === 1
      ) {
        return collection.constructor(iters[0]);
      }
      return collection.withMutations(function(collection) {
        var mergeIntoMap = merger
          ? function(value, key) {
              collection.update(key, NOT_SET, function(existing) {
                return existing === NOT_SET
                  ? value
                  : merger(existing, value, key);
              });
            }
          : function(value, key) {
              collection.set(key, value);
            };
        for (var ii = 0; ii < iters.length; ii++) {
          iters[ii].forEach(mergeIntoMap);
        }
      });
    }

    function updateInDeepMap(existing, keyPathIter, notSetValue, updater) {
      var isNotSet = existing === NOT_SET;
      var step = keyPathIter.next();
      if (step.done) {
        var existingValue = isNotSet ? notSetValue : existing;
        var newValue = updater(existingValue);
        return newValue === existingValue ? existing : newValue;
      }
      invariant(isNotSet || (existing && existing.set), "invalid keyPath");
      var key = step.value;
      var nextExisting = isNotSet ? NOT_SET : existing.get(key, NOT_SET);
      var nextUpdated = updateInDeepMap(
        nextExisting,
        keyPathIter,
        notSetValue,
        updater
      );
      return nextUpdated === nextExisting
        ? existing
        : nextUpdated === NOT_SET
        ? existing.remove(key)
        : (isNotSet ? emptyMap() : existing).set(key, nextUpdated);
    }

    function popCount(x) {
      x = x - ((x >> 1) & 0x55555555);
      x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
      x = (x + (x >> 4)) & 0x0f0f0f0f;
      x = x + (x >> 8);
      x = x + (x >> 16);
      return x & 0x7f;
    }

    function setIn(array, idx, val, canEdit) {
      var newArray = canEdit ? array : arrCopy(array);
      newArray[idx] = val;
      return newArray;
    }

    function spliceIn(array, idx, val, canEdit) {
      var newLen = array.length + 1;
      if (canEdit && idx + 1 === newLen) {
        array[idx] = val;
        return array;
      }
      var newArray = new Array(newLen);
      var after = 0;
      for (var ii = 0; ii < newLen; ii++) {
        if (ii === idx) {
          newArray[ii] = val;
          after = -1;
        } else {
          newArray[ii] = array[ii + after];
        }
      }
      return newArray;
    }

    function spliceOut(array, idx, canEdit) {
      var newLen = array.length - 1;
      if (canEdit && idx === newLen) {
        array.pop();
        return array;
      }
      var newArray = new Array(newLen);
      var after = 0;
      for (var ii = 0; ii < newLen; ii++) {
        if (ii === idx) {
          after = 1;
        }
        newArray[ii] = array[ii + after];
      }
      return newArray;
    }

    var MAX_ARRAY_MAP_SIZE = SIZE / 4;
    var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;
    var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;

    createClass(List, IndexedCollection);

    // @pragma Construction

    function List(value) {
      var empty = emptyList();
      if (value === null || value === undefined) {
        return empty;
      }
      if (isList(value)) {
        return value;
      }
      var iter = IndexedIterable(value);
      var size = iter.size;
      if (size === 0) {
        return empty;
      }
      assertNotInfinite(size);
      if (size > 0 && size < SIZE) {
        return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));
      }
      return empty.withMutations(function(list) {
        list.setSize(size);
        iter.forEach(function(v, i) {
          return list.set(i, v);
        });
      });
    }

    List.of = function(/*...values*/) {
      return this(arguments);
    };

    List.prototype.toString = function() {
      return this.__toString("List [", "]");
    };

    // @pragma Access

    List.prototype.get = function(index, notSetValue) {
      index = wrapIndex(this, index);
      if (index >= 0 && index < this.size) {
        index += this._origin;
        var node = listNodeFor(this, index);
        return node && node.array[index & MASK];
      }
      return notSetValue;
    };

    // @pragma Modification

    List.prototype.set = function(index, value) {
      return updateList(this, index, value);
    };

    List.prototype.remove = function(index) {
      return !this.has(index)
        ? this
        : index === 0
        ? this.shift()
        : index === this.size - 1
        ? this.pop()
        : this.splice(index, 1);
    };

    List.prototype.insert = function(index, value) {
      return this.splice(index, 0, value);
    };

    List.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = this._origin = this._capacity = 0;
        this._level = SHIFT;
        this._root = this._tail = null;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return emptyList();
    };

    List.prototype.push = function(/*...values*/) {
      var values = arguments;
      var oldSize = this.size;
      return this.withMutations(function(list) {
        setListBounds(list, 0, oldSize + values.length);
        for (var ii = 0; ii < values.length; ii++) {
          list.set(oldSize + ii, values[ii]);
        }
      });
    };

    List.prototype.pop = function() {
      return setListBounds(this, 0, -1);
    };

    List.prototype.unshift = function(/*...values*/) {
      var values = arguments;
      return this.withMutations(function(list) {
        setListBounds(list, -values.length);
        for (var ii = 0; ii < values.length; ii++) {
          list.set(ii, values[ii]);
        }
      });
    };

    List.prototype.shift = function() {
      return setListBounds(this, 1);
    };

    // @pragma Composition

    List.prototype.merge = function(/*...iters*/) {
      return mergeIntoListWith(this, undefined, arguments);
    };

    List.prototype.mergeWith = function(merger) {
      var iters = SLICE$0.call(arguments, 1);
      return mergeIntoListWith(this, merger, iters);
    };

    List.prototype.mergeDeep = function(/*...iters*/) {
      return mergeIntoListWith(this, deepMerger, arguments);
    };

    List.prototype.mergeDeepWith = function(merger) {
      var iters = SLICE$0.call(arguments, 1);
      return mergeIntoListWith(this, deepMergerWith(merger), iters);
    };

    List.prototype.setSize = function(size) {
      return setListBounds(this, 0, size);
    };

    // @pragma Iteration

    List.prototype.slice = function(begin, end) {
      var size = this.size;
      if (wholeSlice(begin, end, size)) {
        return this;
      }
      return setListBounds(
        this,
        resolveBegin(begin, size),
        resolveEnd(end, size)
      );
    };

    List.prototype.__iterator = function(type, reverse) {
      var index = 0;
      var values = iterateList(this, reverse);
      return new Iterator(function() {
        var value = values();
        return value === DONE
          ? iteratorDone()
          : iteratorValue(type, index++, value);
      });
    };

    List.prototype.__iterate = function(fn, reverse) {
      var index = 0;
      var values = iterateList(this, reverse);
      var value;
      while ((value = values()) !== DONE) {
        if (fn(value, index++, this) === false) {
          break;
        }
      }
      return index;
    };

    List.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {
        this.__ownerID = ownerID;
        return this;
      }
      return makeList(
        this._origin,
        this._capacity,
        this._level,
        this._root,
        this._tail,
        ownerID,
        this.__hash
      );
    };

    function isList(maybeList) {
      return !!(maybeList && maybeList[IS_LIST_SENTINEL]);
    }

    List.isList = isList;

    var IS_LIST_SENTINEL = "@@__IMMUTABLE_LIST__@@";

    var ListPrototype = List.prototype;
    ListPrototype[IS_LIST_SENTINEL] = true;
    ListPrototype[DELETE] = ListPrototype.remove;
    ListPrototype.setIn = MapPrototype.setIn;
    ListPrototype.deleteIn = ListPrototype.removeIn = MapPrototype.removeIn;
    ListPrototype.update = MapPrototype.update;
    ListPrototype.updateIn = MapPrototype.updateIn;
    ListPrototype.mergeIn = MapPrototype.mergeIn;
    ListPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;
    ListPrototype.withMutations = MapPrototype.withMutations;
    ListPrototype.asMutable = MapPrototype.asMutable;
    ListPrototype.asImmutable = MapPrototype.asImmutable;
    ListPrototype.wasAltered = MapPrototype.wasAltered;

    function VNode(array, ownerID) {
      this.array = array;
      this.ownerID = ownerID;
    }

    // TODO: seems like these methods are very similar

    VNode.prototype.removeBefore = function(ownerID, level, index) {
      if (index === level ? 1 << level : this.array.length === 0) {
        return this;
      }
      var originIndex = (index >>> level) & MASK;
      if (originIndex >= this.array.length) {
        return new VNode([], ownerID);
      }
      var removingFirst = originIndex === 0;
      var newChild;
      if (level > 0) {
        var oldChild = this.array[originIndex];
        newChild =
          oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);
        if (newChild === oldChild && removingFirst) {
          return this;
        }
      }
      if (removingFirst && !newChild) {
        return this;
      }
      var editable = editableVNode(this, ownerID);
      if (!removingFirst) {
        for (var ii = 0; ii < originIndex; ii++) {
          editable.array[ii] = undefined;
        }
      }
      if (newChild) {
        editable.array[originIndex] = newChild;
      }
      return editable;
    };

    VNode.prototype.removeAfter = function(ownerID, level, index) {
      if (index === (level ? 1 << level : 0) || this.array.length === 0) {
        return this;
      }
      var sizeIndex = ((index - 1) >>> level) & MASK;
      if (sizeIndex >= this.array.length) {
        return this;
      }

      var newChild;
      if (level > 0) {
        var oldChild = this.array[sizeIndex];
        newChild =
          oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);
        if (newChild === oldChild && sizeIndex === this.array.length - 1) {
          return this;
        }
      }

      var editable = editableVNode(this, ownerID);
      editable.array.splice(sizeIndex + 1);
      if (newChild) {
        editable.array[sizeIndex] = newChild;
      }
      return editable;
    };

    var DONE = {};

    function iterateList(list, reverse) {
      var left = list._origin;
      var right = list._capacity;
      var tailPos = getTailOffset(right);
      var tail = list._tail;

      return iterateNodeOrLeaf(list._root, list._level, 0);

      function iterateNodeOrLeaf(node, level, offset) {
        return level === 0
          ? iterateLeaf(node, offset)
          : iterateNode(node, level, offset);
      }

      function iterateLeaf(node, offset) {
        var array =
          offset === tailPos ? tail && tail.array : node && node.array;
        var from = offset > left ? 0 : left - offset;
        var to = right - offset;
        if (to > SIZE) {
          to = SIZE;
        }
        return function() {
          if (from === to) {
            return DONE;
          }
          var idx = reverse ? --to : from++;
          return array && array[idx];
        };
      }

      function iterateNode(node, level, offset) {
        var values;
        var array = node && node.array;
        var from = offset > left ? 0 : (left - offset) >> level;
        var to = ((right - offset) >> level) + 1;
        if (to > SIZE) {
          to = SIZE;
        }
        return function() {
          do {
            if (values) {
              var value = values();
              if (value !== DONE) {
                return value;
              }
              values = null;
            }
            if (from === to) {
              return DONE;
            }
            var idx = reverse ? --to : from++;
            values = iterateNodeOrLeaf(
              array && array[idx],
              level - SHIFT,
              offset + (idx << level)
            );
          } while (true);
        };
      }
    }

    function makeList(origin, capacity, level, root, tail, ownerID, hash) {
      var list = Object.create(ListPrototype);
      list.size = capacity - origin;
      list._origin = origin;
      list._capacity = capacity;
      list._level = level;
      list._root = root;
      list._tail = tail;
      list.__ownerID = ownerID;
      list.__hash = hash;
      list.__altered = false;
      return list;
    }

    var EMPTY_LIST;
    function emptyList() {
      return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));
    }

    function updateList(list, index, value) {
      index = wrapIndex(list, index);

      if (index !== index) {
        return list;
      }

      if (index >= list.size || index < 0) {
        return list.withMutations(function(list) {
          index < 0
            ? setListBounds(list, index).set(0, value)
            : setListBounds(list, 0, index + 1).set(index, value);
        });
      }

      index += list._origin;

      var newTail = list._tail;
      var newRoot = list._root;
      var didAlter = MakeRef(DID_ALTER);
      if (index >= getTailOffset(list._capacity)) {
        newTail = updateVNode(
          newTail,
          list.__ownerID,
          0,
          index,
          value,
          didAlter
        );
      } else {
        newRoot = updateVNode(
          newRoot,
          list.__ownerID,
          list._level,
          index,
          value,
          didAlter
        );
      }

      if (!didAlter.value) {
        return list;
      }

      if (list.__ownerID) {
        list._root = newRoot;
        list._tail = newTail;
        list.__hash = undefined;
        list.__altered = true;
        return list;
      }
      return makeList(
        list._origin,
        list._capacity,
        list._level,
        newRoot,
        newTail
      );
    }

    function updateVNode(node, ownerID, level, index, value, didAlter) {
      var idx = (index >>> level) & MASK;
      var nodeHas = node && idx < node.array.length;
      if (!nodeHas && value === undefined) {
        return node;
      }

      var newNode;

      if (level > 0) {
        var lowerNode = node && node.array[idx];
        var newLowerNode = updateVNode(
          lowerNode,
          ownerID,
          level - SHIFT,
          index,
          value,
          didAlter
        );
        if (newLowerNode === lowerNode) {
          return node;
        }
        newNode = editableVNode(node, ownerID);
        newNode.array[idx] = newLowerNode;
        return newNode;
      }

      if (nodeHas && node.array[idx] === value) {
        return node;
      }

      SetRef(didAlter);

      newNode = editableVNode(node, ownerID);
      if (value === undefined && idx === newNode.array.length - 1) {
        newNode.array.pop();
      } else {
        newNode.array[idx] = value;
      }
      return newNode;
    }

    function editableVNode(node, ownerID) {
      if (ownerID && node && ownerID === node.ownerID) {
        return node;
      }
      return new VNode(node ? node.array.slice() : [], ownerID);
    }

    function listNodeFor(list, rawIndex) {
      if (rawIndex >= getTailOffset(list._capacity)) {
        return list._tail;
      }
      if (rawIndex < 1 << (list._level + SHIFT)) {
        var node = list._root;
        var level = list._level;
        while (node && level > 0) {
          node = node.array[(rawIndex >>> level) & MASK];
          level -= SHIFT;
        }
        return node;
      }
    }

    function setListBounds(list, begin, end) {
      // Sanitize begin & end using this shorthand for ToInt32(argument)
      // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
      if (begin !== undefined) {
        begin = begin | 0;
      }
      if (end !== undefined) {
        end = end | 0;
      }
      var owner = list.__ownerID || new OwnerID();
      var oldOrigin = list._origin;
      var oldCapacity = list._capacity;
      var newOrigin = oldOrigin + begin;
      var newCapacity =
        end === undefined
          ? oldCapacity
          : end < 0
          ? oldCapacity + end
          : oldOrigin + end;
      if (newOrigin === oldOrigin && newCapacity === oldCapacity) {
        return list;
      }

      // If it's going to end after it starts, it's empty.
      if (newOrigin >= newCapacity) {
        return list.clear();
      }

      var newLevel = list._level;
      var newRoot = list._root;

      // New origin might need creating a higher root.
      var offsetShift = 0;
      while (newOrigin + offsetShift < 0) {
        newRoot = new VNode(
          newRoot && newRoot.array.length ? [undefined, newRoot] : [],
          owner
        );
        newLevel += SHIFT;
        offsetShift += 1 << newLevel;
      }
      if (offsetShift) {
        newOrigin += offsetShift;
        oldOrigin += offsetShift;
        newCapacity += offsetShift;
        oldCapacity += offsetShift;
      }

      var oldTailOffset = getTailOffset(oldCapacity);
      var newTailOffset = getTailOffset(newCapacity);

      // New size might need creating a higher root.
      while (newTailOffset >= 1 << (newLevel + SHIFT)) {
        newRoot = new VNode(
          newRoot && newRoot.array.length ? [newRoot] : [],
          owner
        );
        newLevel += SHIFT;
      }

      // Locate or create the new tail.
      var oldTail = list._tail;
      var newTail =
        newTailOffset < oldTailOffset
          ? listNodeFor(list, newCapacity - 1)
          : newTailOffset > oldTailOffset
          ? new VNode([], owner)
          : oldTail;

      // Merge Tail into tree.
      if (
        oldTail &&
        newTailOffset > oldTailOffset &&
        newOrigin < oldCapacity &&
        oldTail.array.length
      ) {
        newRoot = editableVNode(newRoot, owner);
        var node = newRoot;
        for (var level = newLevel; level > SHIFT; level -= SHIFT) {
          var idx = (oldTailOffset >>> level) & MASK;
          node = node.array[idx] = editableVNode(node.array[idx], owner);
        }
        node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;
      }

      // If the size has been reduced, there's a chance the tail needs to be trimmed.
      if (newCapacity < oldCapacity) {
        newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);
      }

      // If the new origin is within the tail, then we do not need a root.
      if (newOrigin >= newTailOffset) {
        newOrigin -= newTailOffset;
        newCapacity -= newTailOffset;
        newLevel = SHIFT;
        newRoot = null;
        newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);

        // Otherwise, if the root has been trimmed, garbage collect.
      } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {
        offsetShift = 0;

        // Identify the new top root node of the subtree of the old root.
        while (newRoot) {
          var beginIndex = (newOrigin >>> newLevel) & MASK;
          if ((beginIndex !== newTailOffset >>> newLevel) & MASK) {
            break;
          }
          if (beginIndex) {
            offsetShift += (1 << newLevel) * beginIndex;
          }
          newLevel -= SHIFT;
          newRoot = newRoot.array[beginIndex];
        }

        // Trim the new sides of the new root.
        if (newRoot && newOrigin > oldOrigin) {
          newRoot = newRoot.removeBefore(
            owner,
            newLevel,
            newOrigin - offsetShift
          );
        }
        if (newRoot && newTailOffset < oldTailOffset) {
          newRoot = newRoot.removeAfter(
            owner,
            newLevel,
            newTailOffset - offsetShift
          );
        }
        if (offsetShift) {
          newOrigin -= offsetShift;
          newCapacity -= offsetShift;
        }
      }

      if (list.__ownerID) {
        list.size = newCapacity - newOrigin;
        list._origin = newOrigin;
        list._capacity = newCapacity;
        list._level = newLevel;
        list._root = newRoot;
        list._tail = newTail;
        list.__hash = undefined;
        list.__altered = true;
        return list;
      }
      return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);
    }

    function mergeIntoListWith(list, merger, iterables) {
      var iters = [];
      var maxSize = 0;
      for (var ii = 0; ii < iterables.length; ii++) {
        var value = iterables[ii];
        var iter = IndexedIterable(value);
        if (iter.size > maxSize) {
          maxSize = iter.size;
        }
        if (!isIterable(value)) {
          iter = iter.map(function(v) {
            return fromJS(v);
          });
        }
        iters.push(iter);
      }
      if (maxSize > list.size) {
        list = list.setSize(maxSize);
      }
      return mergeIntoCollectionWith(list, merger, iters);
    }

    function getTailOffset(size) {
      return size < SIZE ? 0 : ((size - 1) >>> SHIFT) << SHIFT;
    }

    createClass(OrderedMap, Map);

    // @pragma Construction

    function OrderedMap(value) {
      return value === null || value === undefined
        ? emptyOrderedMap()
        : isOrderedMap(value)
        ? value
        : emptyOrderedMap().withMutations(function(map) {
            var iter = KeyedIterable(value);
            assertNotInfinite(iter.size);
            iter.forEach(function(v, k) {
              return map.set(k, v);
            });
          });
    }

    OrderedMap.of = function(/*...values*/) {
      return this(arguments);
    };

    OrderedMap.prototype.toString = function() {
      return this.__toString("OrderedMap {", "}");
    };

    // @pragma Access

    OrderedMap.prototype.get = function(k, notSetValue) {
      var index = this._map.get(k);
      return index !== undefined ? this._list.get(index)[1] : notSetValue;
    };

    // @pragma Modification

    OrderedMap.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = 0;
        this._map.clear();
        this._list.clear();
        return this;
      }
      return emptyOrderedMap();
    };

    OrderedMap.prototype.set = function(k, v) {
      return updateOrderedMap(this, k, v);
    };

    OrderedMap.prototype.remove = function(k) {
      return updateOrderedMap(this, k, NOT_SET);
    };

    OrderedMap.prototype.wasAltered = function() {
      return this._map.wasAltered() || this._list.wasAltered();
    };

    OrderedMap.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      return this._list.__iterate(function(entry) {
        return entry && fn(entry[1], entry[0], this$0);
      }, reverse);
    };

    OrderedMap.prototype.__iterator = function(type, reverse) {
      return this._list.fromEntrySeq().__iterator(type, reverse);
    };

    OrderedMap.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      var newMap = this._map.__ensureOwner(ownerID);
      var newList = this._list.__ensureOwner(ownerID);
      if (!ownerID) {
        this.__ownerID = ownerID;
        this._map = newMap;
        this._list = newList;
        return this;
      }
      return makeOrderedMap(newMap, newList, ownerID, this.__hash);
    };

    function isOrderedMap(maybeOrderedMap) {
      return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);
    }

    OrderedMap.isOrderedMap = isOrderedMap;

    OrderedMap.prototype[IS_ORDERED_SENTINEL] = true;
    OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;

    function makeOrderedMap(map, list, ownerID, hash) {
      var omap = Object.create(OrderedMap.prototype);
      omap.size = map ? map.size : 0;
      omap._map = map;
      omap._list = list;
      omap.__ownerID = ownerID;
      omap.__hash = hash;
      return omap;
    }

    var EMPTY_ORDERED_MAP;
    function emptyOrderedMap() {
      return (
        EMPTY_ORDERED_MAP ||
        (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()))
      );
    }

    function updateOrderedMap(omap, k, v) {
      var map = omap._map;
      var list = omap._list;
      var i = map.get(k);
      var has = i !== undefined;
      var newMap;
      var newList;
      if (v === NOT_SET) {
        // removed
        if (!has) {
          return omap;
        }
        if (list.size >= SIZE && list.size >= map.size * 2) {
          newList = list.filter(function(entry, idx) {
            return entry !== undefined && i !== idx;
          });
          newMap = newList
            .toKeyedSeq()
            .map(function(entry) {
              return entry[0];
            })
            .flip()
            .toMap();
          if (omap.__ownerID) {
            newMap.__ownerID = newList.__ownerID = omap.__ownerID;
          }
        } else {
          newMap = map.remove(k);
          newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);
        }
      } else {
        if (has) {
          if (v === list.get(i)[1]) {
            return omap;
          }
          newMap = map;
          newList = list.set(i, [k, v]);
        } else {
          newMap = map.set(k, list.size);
          newList = list.set(list.size, [k, v]);
        }
      }
      if (omap.__ownerID) {
        omap.size = newMap.size;
        omap._map = newMap;
        omap._list = newList;
        omap.__hash = undefined;
        return omap;
      }
      return makeOrderedMap(newMap, newList);
    }

    createClass(ToKeyedSequence, KeyedSeq);
    function ToKeyedSequence(indexed, useKeys) {
      this._iter = indexed;
      this._useKeys = useKeys;
      this.size = indexed.size;
    }

    ToKeyedSequence.prototype.get = function(key, notSetValue) {
      return this._iter.get(key, notSetValue);
    };

    ToKeyedSequence.prototype.has = function(key) {
      return this._iter.has(key);
    };

    ToKeyedSequence.prototype.valueSeq = function() {
      return this._iter.valueSeq();
    };

    ToKeyedSequence.prototype.reverse = function() {
      var this$0 = this;
      var reversedSequence = reverseFactory(this, true);
      if (!this._useKeys) {
        reversedSequence.valueSeq = function() {
          return this$0._iter.toSeq().reverse();
        };
      }
      return reversedSequence;
    };

    ToKeyedSequence.prototype.map = function(mapper, context) {
      var this$0 = this;
      var mappedSequence = mapFactory(this, mapper, context);
      if (!this._useKeys) {
        mappedSequence.valueSeq = function() {
          return this$0._iter.toSeq().map(mapper, context);
        };
      }
      return mappedSequence;
    };

    ToKeyedSequence.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      var ii;
      return this._iter.__iterate(
        this._useKeys
          ? function(v, k) {
              return fn(v, k, this$0);
            }
          : ((ii = reverse ? resolveSize(this) : 0),
            function(v) {
              return fn(v, reverse ? --ii : ii++, this$0);
            }),
        reverse
      );
    };

    ToKeyedSequence.prototype.__iterator = function(type, reverse) {
      if (this._useKeys) {
        return this._iter.__iterator(type, reverse);
      }
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      var ii = reverse ? resolveSize(this) : 0;
      return new Iterator(function() {
        var step = iterator.next();
        return step.done
          ? step
          : iteratorValue(type, reverse ? --ii : ii++, step.value, step);
      });
    };

    ToKeyedSequence.prototype[IS_ORDERED_SENTINEL] = true;

    createClass(ToIndexedSequence, IndexedSeq);
    function ToIndexedSequence(iter) {
      this._iter = iter;
      this.size = iter.size;
    }

    ToIndexedSequence.prototype.includes = function(value) {
      return this._iter.includes(value);
    };

    ToIndexedSequence.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      var iterations = 0;
      return this._iter.__iterate(function(v) {
        return fn(v, iterations++, this$0);
      }, reverse);
    };

    ToIndexedSequence.prototype.__iterator = function(type, reverse) {
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      var iterations = 0;
      return new Iterator(function() {
        var step = iterator.next();
        return step.done
          ? step
          : iteratorValue(type, iterations++, step.value, step);
      });
    };

    createClass(ToSetSequence, SetSeq);
    function ToSetSequence(iter) {
      this._iter = iter;
      this.size = iter.size;
    }

    ToSetSequence.prototype.has = function(key) {
      return this._iter.includes(key);
    };

    ToSetSequence.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      return this._iter.__iterate(function(v) {
        return fn(v, v, this$0);
      }, reverse);
    };

    ToSetSequence.prototype.__iterator = function(type, reverse) {
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      return new Iterator(function() {
        var step = iterator.next();
        return step.done
          ? step
          : iteratorValue(type, step.value, step.value, step);
      });
    };

    createClass(FromEntriesSequence, KeyedSeq);
    function FromEntriesSequence(entries) {
      this._iter = entries;
      this.size = entries.size;
    }

    FromEntriesSequence.prototype.entrySeq = function() {
      return this._iter.toSeq();
    };

    FromEntriesSequence.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      return this._iter.__iterate(function(entry) {
        // Check if entry exists first so array access doesn't throw for holes
        // in the parent iteration.
        if (entry) {
          validateEntry(entry);
          var indexedIterable = isIterable(entry);
          return fn(
            indexedIterable ? entry.get(1) : entry[1],
            indexedIterable ? entry.get(0) : entry[0],
            this$0
          );
        }
      }, reverse);
    };

    FromEntriesSequence.prototype.__iterator = function(type, reverse) {
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      return new Iterator(function() {
        while (true) {
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          var entry = step.value;
          // Check if entry exists first so array access doesn't throw for holes
          // in the parent iteration.
          if (entry) {
            validateEntry(entry);
            var indexedIterable = isIterable(entry);
            return iteratorValue(
              type,
              indexedIterable ? entry.get(0) : entry[0],
              indexedIterable ? entry.get(1) : entry[1],
              step
            );
          }
        }
      });
    };

    ToIndexedSequence.prototype.cacheResult = ToKeyedSequence.prototype.cacheResult = ToSetSequence.prototype.cacheResult = FromEntriesSequence.prototype.cacheResult = cacheResultThrough;

    function flipFactory(iterable) {
      var flipSequence = makeSequence(iterable);
      flipSequence._iter = iterable;
      flipSequence.size = iterable.size;
      flipSequence.flip = function() {
        return iterable;
      };
      flipSequence.reverse = function() {
        var reversedSequence = iterable.reverse.apply(this); // super.reverse()
        reversedSequence.flip = function() {
          return iterable.reverse();
        };
        return reversedSequence;
      };
      flipSequence.has = function(key) {
        return iterable.includes(key);
      };
      flipSequence.includes = function(key) {
        return iterable.has(key);
      };
      flipSequence.cacheResult = cacheResultThrough;
      flipSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        return iterable.__iterate(function(v, k) {
          return fn(k, v, this$0) !== false;
        }, reverse);
      };
      flipSequence.__iteratorUncached = function(type, reverse) {
        if (type === ITERATE_ENTRIES) {
          var iterator = iterable.__iterator(type, reverse);
          return new Iterator(function() {
            var step = iterator.next();
            if (!step.done) {
              var k = step.value[0];
              step.value[0] = step.value[1];
              step.value[1] = k;
            }
            return step;
          });
        }
        return iterable.__iterator(
          type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,
          reverse
        );
      };
      return flipSequence;
    }

    function mapFactory(iterable, mapper, context) {
      var mappedSequence = makeSequence(iterable);
      mappedSequence.size = iterable.size;
      mappedSequence.has = function(key) {
        return iterable.has(key);
      };
      mappedSequence.get = function(key, notSetValue) {
        var v = iterable.get(key, NOT_SET);
        return v === NOT_SET
          ? notSetValue
          : mapper.call(context, v, key, iterable);
      };
      mappedSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        return iterable.__iterate(function(v, k, c) {
          return fn(mapper.call(context, v, k, c), k, this$0) !== false;
        }, reverse);
      };
      mappedSequence.__iteratorUncached = function(type, reverse) {
        var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
        return new Iterator(function() {
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          var entry = step.value;
          var key = entry[0];
          return iteratorValue(
            type,
            key,
            mapper.call(context, entry[1], key, iterable),
            step
          );
        });
      };
      return mappedSequence;
    }

    function reverseFactory(iterable, useKeys) {
      var reversedSequence = makeSequence(iterable);
      reversedSequence._iter = iterable;
      reversedSequence.size = iterable.size;
      reversedSequence.reverse = function() {
        return iterable;
      };
      if (iterable.flip) {
        reversedSequence.flip = function() {
          var flipSequence = flipFactory(iterable);
          flipSequence.reverse = function() {
            return iterable.flip();
          };
          return flipSequence;
        };
      }
      reversedSequence.get = function(key, notSetValue) {
        return iterable.get(useKeys ? key : -1 - key, notSetValue);
      };
      reversedSequence.has = function(key) {
        return iterable.has(useKeys ? key : -1 - key);
      };
      reversedSequence.includes = function(value) {
        return iterable.includes(value);
      };
      reversedSequence.cacheResult = cacheResultThrough;
      reversedSequence.__iterate = function(fn, reverse) {
        var this$0 = this;
        return iterable.__iterate(function(v, k) {
          return fn(v, k, this$0);
        }, !reverse);
      };
      reversedSequence.__iterator = function(type, reverse) {
        return iterable.__iterator(type, !reverse);
      };
      return reversedSequence;
    }

    function filterFactory(iterable, predicate, context, useKeys) {
      var filterSequence = makeSequence(iterable);
      if (useKeys) {
        filterSequence.has = function(key) {
          var v = iterable.get(key, NOT_SET);
          return v !== NOT_SET && !!predicate.call(context, v, key, iterable);
        };
        filterSequence.get = function(key, notSetValue) {
          var v = iterable.get(key, NOT_SET);
          return v !== NOT_SET && predicate.call(context, v, key, iterable)
            ? v
            : notSetValue;
        };
      }
      filterSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        var iterations = 0;
        iterable.__iterate(function(v, k, c) {
          if (predicate.call(context, v, k, c)) {
            iterations++;
            return fn(v, useKeys ? k : iterations - 1, this$0);
          }
        }, reverse);
        return iterations;
      };
      filterSequence.__iteratorUncached = function(type, reverse) {
        var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
        var iterations = 0;
        return new Iterator(function() {
          while (true) {
            var step = iterator.next();
            if (step.done) {
              return step;
            }
            var entry = step.value;
            var key = entry[0];
            var value = entry[1];
            if (predicate.call(context, value, key, iterable)) {
              return iteratorValue(
                type,
                useKeys ? key : iterations++,
                value,
                step
              );
            }
          }
        });
      };
      return filterSequence;
    }

    function countByFactory(iterable, grouper, context) {
      var groups = Map().asMutable();
      iterable.__iterate(function(v, k) {
        groups.update(grouper.call(context, v, k, iterable), 0, function(a) {
          return a + 1;
        });
      });
      return groups.asImmutable();
    }

    function groupByFactory(iterable, grouper, context) {
      var isKeyedIter = isKeyed(iterable);
      var groups = (isOrdered(iterable) ? OrderedMap() : Map()).asMutable();
      iterable.__iterate(function(v, k) {
        groups.update(grouper.call(context, v, k, iterable), function(a) {
          return (a = a || []), a.push(isKeyedIter ? [k, v] : v), a;
        });
      });
      var coerce = iterableClass(iterable);
      return groups.map(function(arr) {
        return reify(iterable, coerce(arr));
      });
    }

    function sliceFactory(iterable, begin, end, useKeys) {
      var originalSize = iterable.size;

      // Sanitize begin & end using this shorthand for ToInt32(argument)
      // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
      if (begin !== undefined) {
        begin = begin | 0;
      }
      if (end !== undefined) {
        end = end | 0;
      }

      if (wholeSlice(begin, end, originalSize)) {
        return iterable;
      }

      var resolvedBegin = resolveBegin(begin, originalSize);
      var resolvedEnd = resolveEnd(end, originalSize);

      // begin or end will be NaN if they were provided as negative numbers and
      // this iterable's size is unknown. In that case, cache first so there is
      // a known size and these do not resolve to NaN.
      if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {
        return sliceFactory(
          iterable.toSeq().cacheResult(),
          begin,
          end,
          useKeys
        );
      }

      // Note: resolvedEnd is undefined when the original sequence's length is
      // unknown and this slice did not supply an end and should contain all
      // elements after resolvedBegin.
      // In that case, resolvedSize will be NaN and sliceSize will remain undefined.
      var resolvedSize = resolvedEnd - resolvedBegin;
      var sliceSize;
      if (resolvedSize === resolvedSize) {
        sliceSize = resolvedSize < 0 ? 0 : resolvedSize;
      }

      var sliceSeq = makeSequence(iterable);

      // If iterable.size is undefined, the size of the realized sliceSeq is
      // unknown at this point unless the number of items to slice is 0
      sliceSeq.size =
        sliceSize === 0 ? sliceSize : (iterable.size && sliceSize) || undefined;

      if (!useKeys && isSeq(iterable) && sliceSize >= 0) {
        sliceSeq.get = function(index, notSetValue) {
          index = wrapIndex(this, index);
          return index >= 0 && index < sliceSize
            ? iterable.get(index + resolvedBegin, notSetValue)
            : notSetValue;
        };
      }

      sliceSeq.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        if (sliceSize === 0) {
          return 0;
        }
        if (reverse) {
          return this.cacheResult().__iterate(fn, reverse);
        }
        var skipped = 0;
        var isSkipping = true;
        var iterations = 0;
        iterable.__iterate(function(v, k) {
          if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {
            iterations++;
            return (
              fn(v, useKeys ? k : iterations - 1, this$0) !== false &&
              iterations !== sliceSize
            );
          }
        });
        return iterations;
      };

      sliceSeq.__iteratorUncached = function(type, reverse) {
        if (sliceSize !== 0 && reverse) {
          return this.cacheResult().__iterator(type, reverse);
        }
        // Don't bother instantiating parent iterator if taking 0.
        var iterator = sliceSize !== 0 && iterable.__iterator(type, reverse);
        var skipped = 0;
        var iterations = 0;
        return new Iterator(function() {
          while (skipped++ < resolvedBegin) {
            iterator.next();
          }
          if (++iterations > sliceSize) {
            return iteratorDone();
          }
          var step = iterator.next();
          if (useKeys || type === ITERATE_VALUES) {
            return step;
          } else if (type === ITERATE_KEYS) {
            return iteratorValue(type, iterations - 1, undefined, step);
          } else {
            return iteratorValue(type, iterations - 1, step.value[1], step);
          }
        });
      };

      return sliceSeq;
    }

    function takeWhileFactory(iterable, predicate, context) {
      var takeSequence = makeSequence(iterable);
      takeSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        if (reverse) {
          return this.cacheResult().__iterate(fn, reverse);
        }
        var iterations = 0;
        iterable.__iterate(function(v, k, c) {
          return (
            predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$0)
          );
        });
        return iterations;
      };
      takeSequence.__iteratorUncached = function(type, reverse) {
        var this$0 = this;
        if (reverse) {
          return this.cacheResult().__iterator(type, reverse);
        }
        var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
        var iterating = true;
        return new Iterator(function() {
          if (!iterating) {
            return iteratorDone();
          }
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          var entry = step.value;
          var k = entry[0];
          var v = entry[1];
          if (!predicate.call(context, v, k, this$0)) {
            iterating = false;
            return iteratorDone();
          }
          return type === ITERATE_ENTRIES
            ? step
            : iteratorValue(type, k, v, step);
        });
      };
      return takeSequence;
    }

    function skipWhileFactory(iterable, predicate, context, useKeys) {
      var skipSequence = makeSequence(iterable);
      skipSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        if (reverse) {
          return this.cacheResult().__iterate(fn, reverse);
        }
        var isSkipping = true;
        var iterations = 0;
        iterable.__iterate(function(v, k, c) {
          if (
            !(isSkipping && (isSkipping = predicate.call(context, v, k, c)))
          ) {
            iterations++;
            return fn(v, useKeys ? k : iterations - 1, this$0);
          }
        });
        return iterations;
      };
      skipSequence.__iteratorUncached = function(type, reverse) {
        var this$0 = this;
        if (reverse) {
          return this.cacheResult().__iterator(type, reverse);
        }
        var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
        var skipping = true;
        var iterations = 0;
        return new Iterator(function() {
          var step, k, v;
          do {
            step = iterator.next();
            if (step.done) {
              if (useKeys || type === ITERATE_VALUES) {
                return step;
              } else if (type === ITERATE_KEYS) {
                return iteratorValue(type, iterations++, undefined, step);
              } else {
                return iteratorValue(type, iterations++, step.value[1], step);
              }
            }
            var entry = step.value;
            k = entry[0];
            v = entry[1];
            skipping && (skipping = predicate.call(context, v, k, this$0));
          } while (skipping);
          return type === ITERATE_ENTRIES
            ? step
            : iteratorValue(type, k, v, step);
        });
      };
      return skipSequence;
    }

    function concatFactory(iterable, values) {
      var isKeyedIterable = isKeyed(iterable);
      var iters = [iterable]
        .concat(values)
        .map(function(v) {
          if (!isIterable(v)) {
            v = isKeyedIterable
              ? keyedSeqFromValue(v)
              : indexedSeqFromValue(Array.isArray(v) ? v : [v]);
          } else if (isKeyedIterable) {
            v = KeyedIterable(v);
          }
          return v;
        })
        .filter(function(v) {
          return v.size !== 0;
        });

      if (iters.length === 0) {
        return iterable;
      }

      if (iters.length === 1) {
        var singleton = iters[0];
        if (
          singleton === iterable ||
          (isKeyedIterable && isKeyed(singleton)) ||
          (isIndexed(iterable) && isIndexed(singleton))
        ) {
          return singleton;
        }
      }

      var concatSeq = new ArraySeq(iters);
      if (isKeyedIterable) {
        concatSeq = concatSeq.toKeyedSeq();
      } else if (!isIndexed(iterable)) {
        concatSeq = concatSeq.toSetSeq();
      }
      concatSeq = concatSeq.flatten(true);
      concatSeq.size = iters.reduce(function(sum, seq) {
        if (sum !== undefined) {
          var size = seq.size;
          if (size !== undefined) {
            return sum + size;
          }
        }
      }, 0);
      return concatSeq;
    }

    function flattenFactory(iterable, depth, useKeys) {
      var flatSequence = makeSequence(iterable);
      flatSequence.__iterateUncached = function(fn, reverse) {
        var iterations = 0;
        var stopped = false;
        function flatDeep(iter, currentDepth) {
          var this$0 = this;
          iter.__iterate(function(v, k) {
            if ((!depth || currentDepth < depth) && isIterable(v)) {
              flatDeep(v, currentDepth + 1);
            } else if (fn(v, useKeys ? k : iterations++, this$0) === false) {
              stopped = true;
            }
            return !stopped;
          }, reverse);
        }
        flatDeep(iterable, 0);
        return iterations;
      };
      flatSequence.__iteratorUncached = function(type, reverse) {
        var iterator = iterable.__iterator(type, reverse);
        var stack = [];
        var iterations = 0;
        return new Iterator(function() {
          while (iterator) {
            var step = iterator.next();
            if (step.done !== false) {
              iterator = stack.pop();
              continue;
            }
            var v = step.value;
            if (type === ITERATE_ENTRIES) {
              v = v[1];
            }
            if ((!depth || stack.length < depth) && isIterable(v)) {
              stack.push(iterator);
              iterator = v.__iterator(type, reverse);
            } else {
              return useKeys
                ? step
                : iteratorValue(type, iterations++, v, step);
            }
          }
          return iteratorDone();
        });
      };
      return flatSequence;
    }

    function flatMapFactory(iterable, mapper, context) {
      var coerce = iterableClass(iterable);
      return iterable
        .toSeq()
        .map(function(v, k) {
          return coerce(mapper.call(context, v, k, iterable));
        })
        .flatten(true);
    }

    function interposeFactory(iterable, separator) {
      var interposedSequence = makeSequence(iterable);
      interposedSequence.size = iterable.size && iterable.size * 2 - 1;
      interposedSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        var iterations = 0;
        iterable.__iterate(function(v, k) {
          return (
            (!iterations || fn(separator, iterations++, this$0) !== false) &&
            fn(v, iterations++, this$0) !== false
          );
        }, reverse);
        return iterations;
      };
      interposedSequence.__iteratorUncached = function(type, reverse) {
        var iterator = iterable.__iterator(ITERATE_VALUES, reverse);
        var iterations = 0;
        var step;
        return new Iterator(function() {
          if (!step || iterations % 2) {
            step = iterator.next();
            if (step.done) {
              return step;
            }
          }
          return iterations % 2
            ? iteratorValue(type, iterations++, separator)
            : iteratorValue(type, iterations++, step.value, step);
        });
      };
      return interposedSequence;
    }

    function sortFactory(iterable, comparator, mapper) {
      if (!comparator) {
        comparator = defaultComparator;
      }
      var isKeyedIterable = isKeyed(iterable);
      var index = 0;
      var entries = iterable
        .toSeq()
        .map(function(v, k) {
          return [k, v, index++, mapper ? mapper(v, k, iterable) : v];
        })
        .toArray();
      entries
        .sort(function(a, b) {
          return comparator(a[3], b[3]) || a[2] - b[2];
        })
        .forEach(
          isKeyedIterable
            ? function(v, i) {
                entries[i].length = 2;
              }
            : function(v, i) {
                entries[i] = v[1];
              }
        );
      return isKeyedIterable
        ? KeyedSeq(entries)
        : isIndexed(iterable)
        ? IndexedSeq(entries)
        : SetSeq(entries);
    }

    function maxFactory(iterable, comparator, mapper) {
      if (!comparator) {
        comparator = defaultComparator;
      }
      if (mapper) {
        var entry = iterable
          .toSeq()
          .map(function(v, k) {
            return [v, mapper(v, k, iterable)];
          })
          .reduce(function(a, b) {
            return maxCompare(comparator, a[1], b[1]) ? b : a;
          });
        return entry && entry[0];
      } else {
        return iterable.reduce(function(a, b) {
          return maxCompare(comparator, a, b) ? b : a;
        });
      }
    }

    function maxCompare(comparator, a, b) {
      var comp = comparator(b, a);
      // b is considered the new max if the comparator declares them equal, but
      // they are not equal and b is in fact a nullish value.
      return (
        (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) ||
        comp > 0
      );
    }

    function zipWithFactory(keyIter, zipper, iters) {
      var zipSequence = makeSequence(keyIter);
      zipSequence.size = new ArraySeq(iters)
        .map(function(i) {
          return i.size;
        })
        .min();
      // Note: this a generic base implementation of __iterate in terms of
      // __iterator which may be more generically useful in the future.
      zipSequence.__iterate = function(fn, reverse) {
        /* generic:
      var iterator = this.__iterator(ITERATE_ENTRIES, reverse);
      var step;
      var iterations = 0;
      while (!(step = iterator.next()).done) {
        iterations++;
        if (fn(step.value[1], step.value[0], this) === false) {
          break;
        }
      }
      return iterations;
      */
        // indexed:
        var iterator = this.__iterator(ITERATE_VALUES, reverse);
        var step;
        var iterations = 0;
        while (!(step = iterator.next()).done) {
          if (fn(step.value, iterations++, this) === false) {
            break;
          }
        }
        return iterations;
      };
      zipSequence.__iteratorUncached = function(type, reverse) {
        var iterators = iters.map(function(i) {
          return (i = Iterable(i)), getIterator(reverse ? i.reverse() : i);
        });
        var iterations = 0;
        var isDone = false;
        return new Iterator(function() {
          var steps;
          if (!isDone) {
            steps = iterators.map(function(i) {
              return i.next();
            });
            isDone = steps.some(function(s) {
              return s.done;
            });
          }
          if (isDone) {
            return iteratorDone();
          }
          return iteratorValue(
            type,
            iterations++,
            zipper.apply(
              null,
              steps.map(function(s) {
                return s.value;
              })
            )
          );
        });
      };
      return zipSequence;
    }

    // #pragma Helper Functions

    function reify(iter, seq) {
      return isSeq(iter) ? seq : iter.constructor(seq);
    }

    function validateEntry(entry) {
      if (entry !== Object(entry)) {
        throw new TypeError("Expected [K, V] tuple: " + entry);
      }
    }

    function resolveSize(iter) {
      assertNotInfinite(iter.size);
      return ensureSize(iter);
    }

    function iterableClass(iterable) {
      return isKeyed(iterable)
        ? KeyedIterable
        : isIndexed(iterable)
        ? IndexedIterable
        : SetIterable;
    }

    function makeSequence(iterable) {
      return Object.create(
        (isKeyed(iterable)
          ? KeyedSeq
          : isIndexed(iterable)
          ? IndexedSeq
          : SetSeq
        ).prototype
      );
    }

    function cacheResultThrough() {
      if (this._iter.cacheResult) {
        this._iter.cacheResult();
        this.size = this._iter.size;
        return this;
      } else {
        return Seq.prototype.cacheResult.call(this);
      }
    }

    function defaultComparator(a, b) {
      return a > b ? 1 : a < b ? -1 : 0;
    }

    function forceIterator(keyPath) {
      var iter = getIterator(keyPath);
      if (!iter) {
        // Array might not be iterable in this environment, so we need a fallback
        // to our wrapped type.
        if (!isArrayLike(keyPath)) {
          throw new TypeError("Expected iterable or array-like: " + keyPath);
        }
        iter = getIterator(Iterable(keyPath));
      }
      return iter;
    }

    createClass(Record, KeyedCollection);

    function Record(defaultValues, name) {
      var hasInitialized;

      var RecordType = function Record(values) {
        if (values instanceof RecordType) {
          return values;
        }
        if (!(this instanceof RecordType)) {
          return new RecordType(values);
        }
        if (!hasInitialized) {
          hasInitialized = true;
          var keys = Object.keys(defaultValues);
          setProps(RecordTypePrototype, keys);
          RecordTypePrototype.size = keys.length;
          RecordTypePrototype._name = name;
          RecordTypePrototype._keys = keys;
          RecordTypePrototype._defaultValues = defaultValues;
        }
        this._map = Map(values);
      };

      var RecordTypePrototype = (RecordType.prototype = Object.create(
        RecordPrototype
      ));
      RecordTypePrototype.constructor = RecordType;

      return RecordType;
    }

    Record.prototype.toString = function() {
      return this.__toString(recordName(this) + " {", "}");
    };

    // @pragma Access

    Record.prototype.has = function(k) {
      return this._defaultValues.hasOwnProperty(k);
    };

    Record.prototype.get = function(k, notSetValue) {
      if (!this.has(k)) {
        return notSetValue;
      }
      var defaultVal = this._defaultValues[k];
      return this._map ? this._map.get(k, defaultVal) : defaultVal;
    };

    // @pragma Modification

    Record.prototype.clear = function() {
      if (this.__ownerID) {
        this._map && this._map.clear();
        return this;
      }
      var RecordType = this.constructor;
      return (
        RecordType._empty || (RecordType._empty = makeRecord(this, emptyMap()))
      );
    };

    Record.prototype.set = function(k, v) {
      if (!this.has(k)) {
        throw new Error(
          'Cannot set unknown key "' + k + '" on ' + recordName(this)
        );
      }
      var newMap = this._map && this._map.set(k, v);
      if (this.__ownerID || newMap === this._map) {
        return this;
      }
      return makeRecord(this, newMap);
    };

    Record.prototype.remove = function(k) {
      if (!this.has(k)) {
        return this;
      }
      var newMap = this._map && this._map.remove(k);
      if (this.__ownerID || newMap === this._map) {
        return this;
      }
      return makeRecord(this, newMap);
    };

    Record.prototype.wasAltered = function() {
      return this._map.wasAltered();
    };

    Record.prototype.__iterator = function(type, reverse) {
      var this$0 = this;
      return KeyedIterable(this._defaultValues)
        .map(function(_, k) {
          return this$0.get(k);
        })
        .__iterator(type, reverse);
    };

    Record.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      return KeyedIterable(this._defaultValues)
        .map(function(_, k) {
          return this$0.get(k);
        })
        .__iterate(fn, reverse);
    };

    Record.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      var newMap = this._map && this._map.__ensureOwner(ownerID);
      if (!ownerID) {
        this.__ownerID = ownerID;
        this._map = newMap;
        return this;
      }
      return makeRecord(this, newMap, ownerID);
    };

    var RecordPrototype = Record.prototype;
    RecordPrototype[DELETE] = RecordPrototype.remove;
    RecordPrototype.deleteIn = RecordPrototype.removeIn = MapPrototype.removeIn;
    RecordPrototype.merge = MapPrototype.merge;
    RecordPrototype.mergeWith = MapPrototype.mergeWith;
    RecordPrototype.mergeIn = MapPrototype.mergeIn;
    RecordPrototype.mergeDeep = MapPrototype.mergeDeep;
    RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith;
    RecordPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;
    RecordPrototype.setIn = MapPrototype.setIn;
    RecordPrototype.update = MapPrototype.update;
    RecordPrototype.updateIn = MapPrototype.updateIn;
    RecordPrototype.withMutations = MapPrototype.withMutations;
    RecordPrototype.asMutable = MapPrototype.asMutable;
    RecordPrototype.asImmutable = MapPrototype.asImmutable;

    function makeRecord(likeRecord, map, ownerID) {
      var record = Object.create(Object.getPrototypeOf(likeRecord));
      record._map = map;
      record.__ownerID = ownerID;
      return record;
    }

    function recordName(record) {
      return record._name || record.constructor.name || "Record";
    }

    function setProps(prototype, names) {
      try {
        names.forEach(setProp.bind(undefined, prototype));
      } catch (error) {
        // Object.defineProperty failed. Probably IE8.
      }
    }

    function setProp(prototype, name) {
      Object.defineProperty(prototype, name, {
        get: function() {
          return this.get(name);
        },
        set: function(value) {
          invariant(this.__ownerID, "Cannot set on an immutable record.");
          this.set(name, value);
        }
      });
    }

    createClass(Set, SetCollection);

    // @pragma Construction

    function Set(value) {
      return value === null || value === undefined
        ? emptySet()
        : isSet(value) && !isOrdered(value)
        ? value
        : emptySet().withMutations(function(set) {
            var iter = SetIterable(value);
            assertNotInfinite(iter.size);
            iter.forEach(function(v) {
              return set.add(v);
            });
          });
    }

    Set.of = function(/*...values*/) {
      return this(arguments);
    };

    Set.fromKeys = function(value) {
      return this(KeyedIterable(value).keySeq());
    };

    Set.prototype.toString = function() {
      return this.__toString("Set {", "}");
    };

    // @pragma Access

    Set.prototype.has = function(value) {
      return this._map.has(value);
    };

    // @pragma Modification

    Set.prototype.add = function(value) {
      return updateSet(this, this._map.set(value, true));
    };

    Set.prototype.remove = function(value) {
      return updateSet(this, this._map.remove(value));
    };

    Set.prototype.clear = function() {
      return updateSet(this, this._map.clear());
    };

    // @pragma Composition

    Set.prototype.union = function() {
      var iters = SLICE$0.call(arguments, 0);
      iters = iters.filter(function(x) {
        return x.size !== 0;
      });
      if (iters.length === 0) {
        return this;
      }
      if (this.size === 0 && !this.__ownerID && iters.length === 1) {
        return this.constructor(iters[0]);
      }
      return this.withMutations(function(set) {
        for (var ii = 0; ii < iters.length; ii++) {
          SetIterable(iters[ii]).forEach(function(value) {
            return set.add(value);
          });
        }
      });
    };

    Set.prototype.intersect = function() {
      var iters = SLICE$0.call(arguments, 0);
      if (iters.length === 0) {
        return this;
      }
      iters = iters.map(function(iter) {
        return SetIterable(iter);
      });
      var originalSet = this;
      return this.withMutations(function(set) {
        originalSet.forEach(function(value) {
          if (
            !iters.every(function(iter) {
              return iter.includes(value);
            })
          ) {
            set.remove(value);
          }
        });
      });
    };

    Set.prototype.subtract = function() {
      var iters = SLICE$0.call(arguments, 0);
      if (iters.length === 0) {
        return this;
      }
      iters = iters.map(function(iter) {
        return SetIterable(iter);
      });
      var originalSet = this;
      return this.withMutations(function(set) {
        originalSet.forEach(function(value) {
          if (
            iters.some(function(iter) {
              return iter.includes(value);
            })
          ) {
            set.remove(value);
          }
        });
      });
    };

    Set.prototype.merge = function() {
      return this.union.apply(this, arguments);
    };

    Set.prototype.mergeWith = function(merger) {
      var iters = SLICE$0.call(arguments, 1);
      return this.union.apply(this, iters);
    };

    Set.prototype.sort = function(comparator) {
      // Late binding
      return OrderedSet(sortFactory(this, comparator));
    };

    Set.prototype.sortBy = function(mapper, comparator) {
      // Late binding
      return OrderedSet(sortFactory(this, comparator, mapper));
    };

    Set.prototype.wasAltered = function() {
      return this._map.wasAltered();
    };

    Set.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      return this._map.__iterate(function(_, k) {
        return fn(k, k, this$0);
      }, reverse);
    };

    Set.prototype.__iterator = function(type, reverse) {
      return this._map
        .map(function(_, k) {
          return k;
        })
        .__iterator(type, reverse);
    };

    Set.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      var newMap = this._map.__ensureOwner(ownerID);
      if (!ownerID) {
        this.__ownerID = ownerID;
        this._map = newMap;
        return this;
      }
      return this.__make(newMap, ownerID);
    };

    function isSet(maybeSet) {
      return !!(maybeSet && maybeSet[IS_SET_SENTINEL]);
    }

    Set.isSet = isSet;

    var IS_SET_SENTINEL = "@@__IMMUTABLE_SET__@@";

    var SetPrototype = Set.prototype;
    SetPrototype[IS_SET_SENTINEL] = true;
    SetPrototype[DELETE] = SetPrototype.remove;
    SetPrototype.mergeDeep = SetPrototype.merge;
    SetPrototype.mergeDeepWith = SetPrototype.mergeWith;
    SetPrototype.withMutations = MapPrototype.withMutations;
    SetPrototype.asMutable = MapPrototype.asMutable;
    SetPrototype.asImmutable = MapPrototype.asImmutable;

    SetPrototype.__empty = emptySet;
    SetPrototype.__make = makeSet;

    function updateSet(set, newMap) {
      if (set.__ownerID) {
        set.size = newMap.size;
        set._map = newMap;
        return set;
      }
      return newMap === set._map
        ? set
        : newMap.size === 0
        ? set.__empty()
        : set.__make(newMap);
    }

    function makeSet(map, ownerID) {
      var set = Object.create(SetPrototype);
      set.size = map ? map.size : 0;
      set._map = map;
      set.__ownerID = ownerID;
      return set;
    }

    var EMPTY_SET;
    function emptySet() {
      return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));
    }

    createClass(OrderedSet, Set);

    // @pragma Construction

    function OrderedSet(value) {
      return value === null || value === undefined
        ? emptyOrderedSet()
        : isOrderedSet(value)
        ? value
        : emptyOrderedSet().withMutations(function(set) {
            var iter = SetIterable(value);
            assertNotInfinite(iter.size);
            iter.forEach(function(v) {
              return set.add(v);
            });
          });
    }

    OrderedSet.of = function(/*...values*/) {
      return this(arguments);
    };

    OrderedSet.fromKeys = function(value) {
      return this(KeyedIterable(value).keySeq());
    };

    OrderedSet.prototype.toString = function() {
      return this.__toString("OrderedSet {", "}");
    };

    function isOrderedSet(maybeOrderedSet) {
      return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);
    }

    OrderedSet.isOrderedSet = isOrderedSet;

    var OrderedSetPrototype = OrderedSet.prototype;
    OrderedSetPrototype[IS_ORDERED_SENTINEL] = true;

    OrderedSetPrototype.__empty = emptyOrderedSet;
    OrderedSetPrototype.__make = makeOrderedSet;

    function makeOrderedSet(map, ownerID) {
      var set = Object.create(OrderedSetPrototype);
      set.size = map ? map.size : 0;
      set._map = map;
      set.__ownerID = ownerID;
      return set;
    }

    var EMPTY_ORDERED_SET;
    function emptyOrderedSet() {
      return (
        EMPTY_ORDERED_SET ||
        (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()))
      );
    }

    createClass(Stack, IndexedCollection);

    // @pragma Construction

    function Stack(value) {
      return value === null || value === undefined
        ? emptyStack()
        : isStack(value)
        ? value
        : emptyStack().unshiftAll(value);
    }

    Stack.of = function(/*...values*/) {
      return this(arguments);
    };

    Stack.prototype.toString = function() {
      return this.__toString("Stack [", "]");
    };

    // @pragma Access

    Stack.prototype.get = function(index, notSetValue) {
      var head = this._head;
      index = wrapIndex(this, index);
      while (head && index--) {
        head = head.next;
      }
      return head ? head.value : notSetValue;
    };

    Stack.prototype.peek = function() {
      return this._head && this._head.value;
    };

    // @pragma Modification

    Stack.prototype.push = function(/*...values*/) {
      if (arguments.length === 0) {
        return this;
      }
      var newSize = this.size + arguments.length;
      var head = this._head;
      for (var ii = arguments.length - 1; ii >= 0; ii--) {
        head = {
          value: arguments[ii],
          next: head
        };
      }
      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return makeStack(newSize, head);
    };

    Stack.prototype.pushAll = function(iter) {
      iter = IndexedIterable(iter);
      if (iter.size === 0) {
        return this;
      }
      assertNotInfinite(iter.size);
      var newSize = this.size;
      var head = this._head;
      iter.reverse().forEach(function(value) {
        newSize++;
        head = {
          value: value,
          next: head
        };
      });
      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return makeStack(newSize, head);
    };

    Stack.prototype.pop = function() {
      return this.slice(1);
    };

    Stack.prototype.unshift = function(/*...values*/) {
      return this.push.apply(this, arguments);
    };

    Stack.prototype.unshiftAll = function(iter) {
      return this.pushAll(iter);
    };

    Stack.prototype.shift = function() {
      return this.pop.apply(this, arguments);
    };

    Stack.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = 0;
        this._head = undefined;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return emptyStack();
    };

    Stack.prototype.slice = function(begin, end) {
      if (wholeSlice(begin, end, this.size)) {
        return this;
      }
      var resolvedBegin = resolveBegin(begin, this.size);
      var resolvedEnd = resolveEnd(end, this.size);
      if (resolvedEnd !== this.size) {
        // super.slice(begin, end);
        return IndexedCollection.prototype.slice.call(this, begin, end);
      }
      var newSize = this.size - resolvedBegin;
      var head = this._head;
      while (resolvedBegin--) {
        head = head.next;
      }
      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return makeStack(newSize, head);
    };

    // @pragma Mutability

    Stack.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {
        this.__ownerID = ownerID;
        this.__altered = false;
        return this;
      }
      return makeStack(this.size, this._head, ownerID, this.__hash);
    };

    // @pragma Iteration

    Stack.prototype.__iterate = function(fn, reverse) {
      if (reverse) {
        return this.reverse().__iterate(fn);
      }
      var iterations = 0;
      var node = this._head;
      while (node) {
        if (fn(node.value, iterations++, this) === false) {
          break;
        }
        node = node.next;
      }
      return iterations;
    };

    Stack.prototype.__iterator = function(type, reverse) {
      if (reverse) {
        return this.reverse().__iterator(type);
      }
      var iterations = 0;
      var node = this._head;
      return new Iterator(function() {
        if (node) {
          var value = node.value;
          node = node.next;
          return iteratorValue(type, iterations++, value);
        }
        return iteratorDone();
      });
    };

    function isStack(maybeStack) {
      return !!(maybeStack && maybeStack[IS_STACK_SENTINEL]);
    }

    Stack.isStack = isStack;

    var IS_STACK_SENTINEL = "@@__IMMUTABLE_STACK__@@";

    var StackPrototype = Stack.prototype;
    StackPrototype[IS_STACK_SENTINEL] = true;
    StackPrototype.withMutations = MapPrototype.withMutations;
    StackPrototype.asMutable = MapPrototype.asMutable;
    StackPrototype.asImmutable = MapPrototype.asImmutable;
    StackPrototype.wasAltered = MapPrototype.wasAltered;

    function makeStack(size, head, ownerID, hash) {
      var map = Object.create(StackPrototype);
      map.size = size;
      map._head = head;
      map.__ownerID = ownerID;
      map.__hash = hash;
      map.__altered = false;
      return map;
    }

    var EMPTY_STACK;
    function emptyStack() {
      return EMPTY_STACK || (EMPTY_STACK = makeStack(0));
    }

    /**
     * Contributes additional methods to a constructor
     */
    function mixin(ctor, methods) {
      var keyCopier = function(key) {
        ctor.prototype[key] = methods[key];
      };
      Object.keys(methods).forEach(keyCopier);
      Object.getOwnPropertySymbols &&
        Object.getOwnPropertySymbols(methods).forEach(keyCopier);
      return ctor;
    }

    Iterable.Iterator = Iterator;

    mixin(Iterable, {
      // ### Conversion to other types

      toArray: function() {
        assertNotInfinite(this.size);
        var array = new Array(this.size || 0);
        this.valueSeq().__iterate(function(v, i) {
          array[i] = v;
        });
        return array;
      },

      toIndexedSeq: function() {
        return new ToIndexedSequence(this);
      },

      toJS: function() {
        return this.toSeq()
          .map(function(value) {
            return value && typeof value.toJS === "function"
              ? value.toJS()
              : value;
          })
          .__toJS();
      },

      toJSON: function() {
        return this.toSeq()
          .map(function(value) {
            return value && typeof value.toJSON === "function"
              ? value.toJSON()
              : value;
          })
          .__toJS();
      },

      toKeyedSeq: function() {
        return new ToKeyedSequence(this, true);
      },

      toMap: function() {
        // Use Late Binding here to solve the circular dependency.
        return Map(this.toKeyedSeq());
      },

      toObject: function() {
        assertNotInfinite(this.size);
        var object = {};
        this.__iterate(function(v, k) {
          object[k] = v;
        });
        return object;
      },

      toOrderedMap: function() {
        // Use Late Binding here to solve the circular dependency.
        return OrderedMap(this.toKeyedSeq());
      },

      toOrderedSet: function() {
        // Use Late Binding here to solve the circular dependency.
        return OrderedSet(isKeyed(this) ? this.valueSeq() : this);
      },

      toSet: function() {
        // Use Late Binding here to solve the circular dependency.
        return Set(isKeyed(this) ? this.valueSeq() : this);
      },

      toSetSeq: function() {
        return new ToSetSequence(this);
      },

      toSeq: function() {
        return isIndexed(this)
          ? this.toIndexedSeq()
          : isKeyed(this)
          ? this.toKeyedSeq()
          : this.toSetSeq();
      },

      toStack: function() {
        // Use Late Binding here to solve the circular dependency.
        return Stack(isKeyed(this) ? this.valueSeq() : this);
      },

      toList: function() {
        // Use Late Binding here to solve the circular dependency.
        return List(isKeyed(this) ? this.valueSeq() : this);
      },

      // ### Common JavaScript methods and properties

      toString: function() {
        return "[Iterable]";
      },

      __toString: function(head, tail) {
        if (this.size === 0) {
          return head + tail;
        }
        return (
          head +
          " " +
          this.toSeq()
            .map(this.__toStringMapper)
            .join(", ") +
          " " +
          tail
        );
      },

      // ### ES6 Collection methods (ES6 Array and Map)

      concat: function() {
        var values = SLICE$0.call(arguments, 0);
        return reify(this, concatFactory(this, values));
      },

      includes: function(searchValue) {
        return this.some(function(value) {
          return is(value, searchValue);
        });
      },

      entries: function() {
        return this.__iterator(ITERATE_ENTRIES);
      },

      every: function(predicate, context) {
        assertNotInfinite(this.size);
        var returnValue = true;
        this.__iterate(function(v, k, c) {
          if (!predicate.call(context, v, k, c)) {
            returnValue = false;
            return false;
          }
        });
        return returnValue;
      },

      filter: function(predicate, context) {
        return reify(this, filterFactory(this, predicate, context, true));
      },

      find: function(predicate, context, notSetValue) {
        var entry = this.findEntry(predicate, context);
        return entry ? entry[1] : notSetValue;
      },

      findEntry: function(predicate, context) {
        var found;
        this.__iterate(function(v, k, c) {
          if (predicate.call(context, v, k, c)) {
            found = [k, v];
            return false;
          }
        });
        return found;
      },

      findLastEntry: function(predicate, context) {
        return this.toSeq()
          .reverse()
          .findEntry(predicate, context);
      },

      forEach: function(sideEffect, context) {
        assertNotInfinite(this.size);
        return this.__iterate(context ? sideEffect.bind(context) : sideEffect);
      },

      join: function(separator) {
        assertNotInfinite(this.size);
        separator = separator !== undefined ? "" + separator : ",";
        var joined = "";
        var isFirst = true;
        this.__iterate(function(v) {
          isFirst ? (isFirst = false) : (joined += separator);
          joined += v !== null && v !== undefined ? v.toString() : "";
        });
        return joined;
      },

      keys: function() {
        return this.__iterator(ITERATE_KEYS);
      },

      map: function(mapper, context) {
        return reify(this, mapFactory(this, mapper, context));
      },

      reduce: function(reducer, initialReduction, context) {
        assertNotInfinite(this.size);
        var reduction;
        var useFirst;
        if (arguments.length < 2) {
          useFirst = true;
        } else {
          reduction = initialReduction;
        }
        this.__iterate(function(v, k, c) {
          if (useFirst) {
            useFirst = false;
            reduction = v;
          } else {
            reduction = reducer.call(context, reduction, v, k, c);
          }
        });
        return reduction;
      },

      reduceRight: function(reducer, initialReduction, context) {
        var reversed = this.toKeyedSeq().reverse();
        return reversed.reduce.apply(reversed, arguments);
      },

      reverse: function() {
        return reify(this, reverseFactory(this, true));
      },

      slice: function(begin, end) {
        return reify(this, sliceFactory(this, begin, end, true));
      },

      some: function(predicate, context) {
        return !this.every(not(predicate), context);
      },

      sort: function(comparator) {
        return reify(this, sortFactory(this, comparator));
      },

      values: function() {
        return this.__iterator(ITERATE_VALUES);
      },

      // ### More sequential methods

      butLast: function() {
        return this.slice(0, -1);
      },

      isEmpty: function() {
        return this.size !== undefined
          ? this.size === 0
          : !this.some(function() {
              return true;
            });
      },

      count: function(predicate, context) {
        return ensureSize(
          predicate ? this.toSeq().filter(predicate, context) : this
        );
      },

      countBy: function(grouper, context) {
        return countByFactory(this, grouper, context);
      },

      equals: function(other) {
        return deepEqual(this, other);
      },

      entrySeq: function() {
        var iterable = this;
        if (iterable._cache) {
          // We cache as an entries array, so we can just return the cache!
          return new ArraySeq(iterable._cache);
        }
        var entriesSequence = iterable
          .toSeq()
          .map(entryMapper)
          .toIndexedSeq();
        entriesSequence.fromEntrySeq = function() {
          return iterable.toSeq();
        };
        return entriesSequence;
      },

      filterNot: function(predicate, context) {
        return this.filter(not(predicate), context);
      },

      findLast: function(predicate, context, notSetValue) {
        return this.toKeyedSeq()
          .reverse()
          .find(predicate, context, notSetValue);
      },

      first: function() {
        return this.find(returnTrue);
      },

      flatMap: function(mapper, context) {
        return reify(this, flatMapFactory(this, mapper, context));
      },

      flatten: function(depth) {
        return reify(this, flattenFactory(this, depth, true));
      },

      fromEntrySeq: function() {
        return new FromEntriesSequence(this);
      },

      get: function(searchKey, notSetValue) {
        return this.find(
          function(_, key) {
            return is(key, searchKey);
          },
          undefined,
          notSetValue
        );
      },

      getIn: function(searchKeyPath, notSetValue) {
        var nested = this;
        // Note: in an ES6 environment, we would prefer:
        // for (var key of searchKeyPath) {
        var iter = forceIterator(searchKeyPath);
        var step;
        while (!(step = iter.next()).done) {
          var key = step.value;
          nested = nested && nested.get ? nested.get(key, NOT_SET) : NOT_SET;
          if (nested === NOT_SET) {
            return notSetValue;
          }
        }
        return nested;
      },

      groupBy: function(grouper, context) {
        return groupByFactory(this, grouper, context);
      },

      has: function(searchKey) {
        return this.get(searchKey, NOT_SET) !== NOT_SET;
      },

      hasIn: function(searchKeyPath) {
        return this.getIn(searchKeyPath, NOT_SET) !== NOT_SET;
      },

      isSubset: function(iter) {
        iter = typeof iter.includes === "function" ? iter : Iterable(iter);
        return this.every(function(value) {
          return iter.includes(value);
        });
      },

      isSuperset: function(iter) {
        iter = typeof iter.isSubset === "function" ? iter : Iterable(iter);
        return iter.isSubset(this);
      },

      keySeq: function() {
        return this.toSeq()
          .map(keyMapper)
          .toIndexedSeq();
      },

      last: function() {
        return this.toSeq()
          .reverse()
          .first();
      },

      max: function(comparator) {
        return maxFactory(this, comparator);
      },

      maxBy: function(mapper, comparator) {
        return maxFactory(this, comparator, mapper);
      },

      min: function(comparator) {
        return maxFactory(
          this,
          comparator ? neg(comparator) : defaultNegComparator
        );
      },

      minBy: function(mapper, comparator) {
        return maxFactory(
          this,
          comparator ? neg(comparator) : defaultNegComparator,
          mapper
        );
      },

      rest: function() {
        return this.slice(1);
      },

      skip: function(amount) {
        return this.slice(Math.max(0, amount));
      },

      skipLast: function(amount) {
        return reify(
          this,
          this.toSeq()
            .reverse()
            .skip(amount)
            .reverse()
        );
      },

      skipWhile: function(predicate, context) {
        return reify(this, skipWhileFactory(this, predicate, context, true));
      },

      skipUntil: function(predicate, context) {
        return this.skipWhile(not(predicate), context);
      },

      sortBy: function(mapper, comparator) {
        return reify(this, sortFactory(this, comparator, mapper));
      },

      take: function(amount) {
        return this.slice(0, Math.max(0, amount));
      },

      takeLast: function(amount) {
        return reify(
          this,
          this.toSeq()
            .reverse()
            .take(amount)
            .reverse()
        );
      },

      takeWhile: function(predicate, context) {
        return reify(this, takeWhileFactory(this, predicate, context));
      },

      takeUntil: function(predicate, context) {
        return this.takeWhile(not(predicate), context);
      },

      valueSeq: function() {
        return this.toIndexedSeq();
      },

      // ### Hashable Object

      hashCode: function() {
        return this.__hash || (this.__hash = hashIterable(this));
      }

      // ### Internal

      // abstract __iterate(fn, reverse)

      // abstract __iterator(type, reverse)
    });

    // var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
    // var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
    // var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';
    // var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';

    var IterablePrototype = Iterable.prototype;
    IterablePrototype[IS_ITERABLE_SENTINEL] = true;
    IterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.values;
    IterablePrototype.__toJS = IterablePrototype.toArray;
    IterablePrototype.__toStringMapper = quoteString;
    IterablePrototype.inspect = IterablePrototype.toSource = function() {
      return this.toString();
    };
    IterablePrototype.chain = IterablePrototype.flatMap;
    IterablePrototype.contains = IterablePrototype.includes;

    // Temporary warning about using length
    (function() {
      try {
        Object.defineProperty(IterablePrototype, "length", {
          get: function() {
            if (!Iterable.noLengthWarning) {
              var stack;
              try {
                throw new Error();
              } catch (error) {
                stack = error.stack;
              }
              if (stack.indexOf("_wrapObject") === -1) {
                console &&
                  console.warn &&
                  console.warn(
                    "iterable.length has been deprecated, " +
                      "use iterable.size or iterable.count(). " +
                      "This warning will become a silent error in a future version. " +
                      stack
                  );
                return this.size;
              }
            }
          }
        });
      } catch (e) {}
    })();

    mixin(KeyedIterable, {
      // ### More sequential methods

      flip: function() {
        return reify(this, flipFactory(this));
      },

      findKey: function(predicate, context) {
        var entry = this.findEntry(predicate, context);
        return entry && entry[0];
      },

      findLastKey: function(predicate, context) {
        return this.toSeq()
          .reverse()
          .findKey(predicate, context);
      },

      keyOf: function(searchValue) {
        return this.findKey(function(value) {
          return is(value, searchValue);
        });
      },

      lastKeyOf: function(searchValue) {
        return this.findLastKey(function(value) {
          return is(value, searchValue);
        });
      },

      mapEntries: function(mapper, context) {
        var this$0 = this;
        var iterations = 0;
        return reify(
          this,
          this.toSeq()
            .map(function(v, k) {
              return mapper.call(context, [k, v], iterations++, this$0);
            })
            .fromEntrySeq()
        );
      },

      mapKeys: function(mapper, context) {
        var this$0 = this;
        return reify(
          this,
          this.toSeq()
            .flip()
            .map(function(k, v) {
              return mapper.call(context, k, v, this$0);
            })
            .flip()
        );
      }
    });

    var KeyedIterablePrototype = KeyedIterable.prototype;
    KeyedIterablePrototype[IS_KEYED_SENTINEL] = true;
    KeyedIterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.entries;
    KeyedIterablePrototype.__toJS = IterablePrototype.toObject;
    KeyedIterablePrototype.__toStringMapper = function(v, k) {
      return JSON.stringify(k) + ": " + quoteString(v);
    };

    mixin(IndexedIterable, {
      // ### Conversion to other types

      toKeyedSeq: function() {
        return new ToKeyedSequence(this, false);
      },

      // ### ES6 Collection methods (ES6 Array and Map)

      filter: function(predicate, context) {
        return reify(this, filterFactory(this, predicate, context, false));
      },

      findIndex: function(predicate, context) {
        var entry = this.findEntry(predicate, context);
        return entry ? entry[0] : -1;
      },

      indexOf: function(searchValue) {
        var key = this.toKeyedSeq().keyOf(searchValue);
        return key === undefined ? -1 : key;
      },

      lastIndexOf: function(searchValue) {
        var key = this.toKeyedSeq()
          .reverse()
          .keyOf(searchValue);
        return key === undefined ? -1 : key;

        // var index =
        // return this.toSeq().reverse().indexOf(searchValue);
      },

      reverse: function() {
        return reify(this, reverseFactory(this, false));
      },

      slice: function(begin, end) {
        return reify(this, sliceFactory(this, begin, end, false));
      },

      splice: function(index, removeNum /*, ...values*/) {
        var numArgs = arguments.length;
        removeNum = Math.max(removeNum | 0, 0);
        if (numArgs === 0 || (numArgs === 2 && !removeNum)) {
          return this;
        }
        // If index is negative, it should resolve relative to the size of the
        // collection. However size may be expensive to compute if not cached, so
        // only call count() if the number is in fact negative.
        index = resolveBegin(index, index < 0 ? this.count() : this.size);
        var spliced = this.slice(0, index);
        return reify(
          this,
          numArgs === 1
            ? spliced
            : spliced.concat(
                arrCopy(arguments, 2),
                this.slice(index + removeNum)
              )
        );
      },

      // ### More collection methods

      findLastIndex: function(predicate, context) {
        var key = this.toKeyedSeq().findLastKey(predicate, context);
        return key === undefined ? -1 : key;
      },

      first: function() {
        return this.get(0);
      },

      flatten: function(depth) {
        return reify(this, flattenFactory(this, depth, false));
      },

      get: function(index, notSetValue) {
        index = wrapIndex(this, index);
        return index < 0 ||
          this.size === Infinity ||
            (this.size !== undefined && index > this.size)
          ? notSetValue
          : this.find(
              function(_, key) {
                return key === index;
              },
              undefined,
              notSetValue
            );
      },

      has: function(index) {
        index = wrapIndex(this, index);
        return (
          index >= 0 &&
          (this.size !== undefined
            ? this.size === Infinity || index < this.size
            : this.indexOf(index) !== -1)
        );
      },

      interpose: function(separator) {
        return reify(this, interposeFactory(this, separator));
      },

      interleave: function(/*...iterables*/) {
        var iterables = [this].concat(arrCopy(arguments));
        var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, iterables);
        var interleaved = zipped.flatten(true);
        if (zipped.size) {
          interleaved.size = zipped.size * iterables.length;
        }
        return reify(this, interleaved);
      },

      last: function() {
        return this.get(-1);
      },

      skipWhile: function(predicate, context) {
        return reify(this, skipWhileFactory(this, predicate, context, false));
      },

      zip: function(/*, ...iterables */) {
        var iterables = [this].concat(arrCopy(arguments));
        return reify(this, zipWithFactory(this, defaultZipper, iterables));
      },

      zipWith: function(zipper /*, ...iterables */) {
        var iterables = arrCopy(arguments);
        iterables[0] = this;
        return reify(this, zipWithFactory(this, zipper, iterables));
      }
    });

    IndexedIterable.prototype[IS_INDEXED_SENTINEL] = true;
    IndexedIterable.prototype[IS_ORDERED_SENTINEL] = true;

    mixin(SetIterable, {
      // ### ES6 Collection methods (ES6 Array and Map)

      get: function(value, notSetValue) {
        return this.has(value) ? value : notSetValue;
      },

      includes: function(value) {
        return this.has(value);
      },

      // ### More sequential methods

      keySeq: function() {
        return this.valueSeq();
      }
    });

    SetIterable.prototype.has = IterablePrototype.includes;

    // Mixin subclasses

    mixin(KeyedSeq, KeyedIterable.prototype);
    mixin(IndexedSeq, IndexedIterable.prototype);
    mixin(SetSeq, SetIterable.prototype);

    mixin(KeyedCollection, KeyedIterable.prototype);
    mixin(IndexedCollection, IndexedIterable.prototype);
    mixin(SetCollection, SetIterable.prototype);

    // #pragma Helper functions

    function keyMapper(v, k) {
      return k;
    }

    function entryMapper(v, k) {
      return [k, v];
    }

    function not(predicate) {
      return function() {
        return !predicate.apply(this, arguments);
      };
    }

    function neg(predicate) {
      return function() {
        return -predicate.apply(this, arguments);
      };
    }

    function quoteString(value) {
      return typeof value === "string" ? JSON.stringify(value) : value;
    }

    function defaultZipper() {
      return arrCopy(arguments);
    }

    function defaultNegComparator(a, b) {
      return a < b ? 1 : a > b ? -1 : 0;
    }

    function hashIterable(iterable) {
      if (iterable.size === Infinity) {
        return 0;
      }
      var ordered = isOrdered(iterable);
      var keyed = isKeyed(iterable);
      var h = ordered ? 1 : 0;
      var size = iterable.__iterate(
        keyed
          ? ordered
            ? function(v, k) {
                h = (31 * h + hashMerge(hash(v), hash(k))) | 0;
              }
            : function(v, k) {
                h = (h + hashMerge(hash(v), hash(k))) | 0;
              }
          : ordered
          ? function(v) {
              h = (31 * h + hash(v)) | 0;
            }
          : function(v) {
              h = (h + hash(v)) | 0;
            }
      );
      return murmurHashOfSize(size, h);
    }

    function murmurHashOfSize(size, h) {
      h = imul(h, 0xcc9e2d51);
      h = imul((h << 15) | (h >>> -15), 0x1b873593);
      h = imul((h << 13) | (h >>> -13), 5);
      h = ((h + 0xe6546b64) | 0) ^ size;
      h = imul(h ^ (h >>> 16), 0x85ebca6b);
      h = imul(h ^ (h >>> 13), 0xc2b2ae35);
      h = smi(h ^ (h >>> 16));
      return h;
    }

    function hashMerge(a, b) {
      return (a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2))) | 0; // int
    }

    var Immutable = {
      Iterable: Iterable,

      Seq: Seq,
      Collection: Collection,
      Map: Map,
      OrderedMap: OrderedMap,
      List: List,
      Stack: Stack,
      Set: Set,
      OrderedSet: OrderedSet,

      Record: Record,
      Range: Range,
      Repeat: Repeat,

      is: is,
      fromJS: fromJS
    };

    return Immutable;
  });
});

var OrderedMap = immutable.OrderedMap;

var BlockMapBuilder = {
  createFromArray: function createFromArray(blocks) {
    return OrderedMap(
      blocks.map(function(block) {
        return [block.getKey(), block];
      })
    );
  }
};

var BlockMapBuilder_1 = BlockMapBuilder;

function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _possibleConstructorReturn(self, call) {
  if (!self) {
    throw new ReferenceError(
      "this hasn't been initialised - super() hasn't been called"
    );
  }
  return call && (typeof call === "object" || typeof call === "function")
    ? call
    : self;
}

function _inherits(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError(
      "Super expression must either be null or a function, not " +
        typeof superClass
    );
  }
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass)
    Object.setPrototypeOf
      ? Object.setPrototypeOf(subClass, superClass)
      : (subClass.__proto__ = superClass);
}

var Map = immutable.Map,
  OrderedSet = immutable.OrderedSet,
  Record = immutable.Record;

// Immutable.map is typed such that the value for every key in the map
// must be the same type

var EMPTY_SET = OrderedSet();

var defaultRecord = {
  style: EMPTY_SET,
  entity: null
};

var CharacterMetadataRecord = Record(defaultRecord);

var CharacterMetadata = (function(_CharacterMetadataRec) {
  _inherits(CharacterMetadata, _CharacterMetadataRec);

  function CharacterMetadata() {
    _classCallCheck(this, CharacterMetadata);

    return _possibleConstructorReturn(
      this,
      _CharacterMetadataRec.apply(this, arguments)
    );
  }

  CharacterMetadata.prototype.getStyle = function getStyle() {
    return this.get("style");
  };

  CharacterMetadata.prototype.getEntity = function getEntity() {
    return this.get("entity");
  };

  CharacterMetadata.prototype.hasStyle = function hasStyle(style) {
    return this.getStyle().includes(style);
  };

  CharacterMetadata.applyStyle = function applyStyle(record, style) {
    var withStyle = record.set("style", record.getStyle().add(style));
    return CharacterMetadata.create(withStyle);
  };

  CharacterMetadata.removeStyle = function removeStyle(record, style) {
    var withoutStyle = record.set("style", record.getStyle().remove(style));
    return CharacterMetadata.create(withoutStyle);
  };

  CharacterMetadata.applyEntity = function applyEntity(record, entityKey) {
    var withEntity =
      record.getEntity() === entityKey
        ? record
        : record.set("entity", entityKey);
    return CharacterMetadata.create(withEntity);
  };

  /**
   * Use this function instead of the `CharacterMetadata` constructor.
   * Since most content generally uses only a very small number of
   * style/entity permutations, we can reuse these objects as often as
   * possible.
   */

  CharacterMetadata.create = function create(config) {
    if (!config) {
      return EMPTY;
    }

    var defaultConfig = {
      style: EMPTY_SET,
      entity: null
    };

    // Fill in unspecified properties, if necessary.
    var configMap = Map(defaultConfig).merge(config);

    var existing = pool.get(configMap);
    if (existing) {
      return existing;
    }

    var newCharacter = new CharacterMetadata(configMap);
    pool = pool.set(configMap, newCharacter);
    return newCharacter;
  };

  return CharacterMetadata;
})(CharacterMetadataRecord);

var EMPTY = new CharacterMetadata();
var pool = Map([[Map(defaultRecord), EMPTY]]);

CharacterMetadata.EMPTY = EMPTY;

var CharacterMetadata_1 = CharacterMetadata;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule findRangesImmutable
 * @format
 *
 */

/**
 * Search through an array to find contiguous stretches of elements that
 * match a specified filter function.
 *
 * When ranges are found, execute a specified `found` function to supply
 * the values to the caller.
 */
function findRangesImmutable(haystack, areEqualFn, filterFn, foundFn) {
  if (!haystack.size) {
    return;
  }

  var cursor = 0;

  haystack.reduce(function(value, nextValue, nextIndex) {
    if (!areEqualFn(value, nextValue)) {
      if (filterFn(value)) {
        foundFn(cursor, nextIndex);
      }
      cursor = nextIndex;
    }
    return nextValue;
  });

  filterFn(haystack.last()) && foundFn(cursor, haystack.count());
}

var findRangesImmutable_1 = findRangesImmutable;

function _classCallCheck$1(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _possibleConstructorReturn$1(self, call) {
  if (!self) {
    throw new ReferenceError(
      "this hasn't been initialised - super() hasn't been called"
    );
  }
  return call && (typeof call === "object" || typeof call === "function")
    ? call
    : self;
}

function _inherits$1(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError(
      "Super expression must either be null or a function, not " +
        typeof superClass
    );
  }
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass)
    Object.setPrototypeOf
      ? Object.setPrototypeOf(subClass, superClass)
      : (subClass.__proto__ = superClass);
}

var List = immutable.List,
  Map$1 = immutable.Map,
  OrderedSet$1 = immutable.OrderedSet,
  Record$1 = immutable.Record,
  Repeat = immutable.Repeat;

var EMPTY_SET$1 = OrderedSet$1();

var defaultRecord$1 = {
  key: "",
  type: "unstyled",
  text: "",
  characterList: List(),
  depth: 0,
  data: Map$1()
};

var ContentBlockRecord = Record$1(defaultRecord$1);

var decorateCharacterList = function decorateCharacterList(config) {
  if (!config) {
    return config;
  }

  var characterList = config.characterList,
    text = config.text;

  if (text && !characterList) {
    config.characterList = List(Repeat(CharacterMetadata_1.EMPTY, text.length));
  }

  return config;
};

var ContentBlock = (function(_ContentBlockRecord) {
  _inherits$1(ContentBlock, _ContentBlockRecord);

  function ContentBlock(config) {
    _classCallCheck$1(this, ContentBlock);

    return _possibleConstructorReturn$1(
      this,
      _ContentBlockRecord.call(this, decorateCharacterList(config))
    );
  }

  ContentBlock.prototype.getKey = function getKey() {
    return this.get("key");
  };

  ContentBlock.prototype.getType = function getType() {
    return this.get("type");
  };

  ContentBlock.prototype.getText = function getText() {
    return this.get("text");
  };

  ContentBlock.prototype.getCharacterList = function getCharacterList() {
    return this.get("characterList");
  };

  ContentBlock.prototype.getLength = function getLength() {
    return this.getText().length;
  };

  ContentBlock.prototype.getDepth = function getDepth() {
    return this.get("depth");
  };

  ContentBlock.prototype.getData = function getData() {
    return this.get("data");
  };

  ContentBlock.prototype.getInlineStyleAt = function getInlineStyleAt(offset) {
    var character = this.getCharacterList().get(offset);
    return character ? character.getStyle() : EMPTY_SET$1;
  };

  ContentBlock.prototype.getEntityAt = function getEntityAt(offset) {
    var character = this.getCharacterList().get(offset);
    return character ? character.getEntity() : null;
  };

  /**
   * Execute a callback for every contiguous range of styles within the block.
   */

  ContentBlock.prototype.findStyleRanges = function findStyleRanges(
    filterFn,
    callback
  ) {
    findRangesImmutable_1(
      this.getCharacterList(),
      haveEqualStyle,
      filterFn,
      callback
    );
  };

  /**
   * Execute a callback for every contiguous range of entities within the block.
   */

  ContentBlock.prototype.findEntityRanges = function findEntityRanges(
    filterFn,
    callback
  ) {
    findRangesImmutable_1(
      this.getCharacterList(),
      haveEqualEntity,
      filterFn,
      callback
    );
  };

  return ContentBlock;
})(ContentBlockRecord);

function haveEqualStyle(charA, charB) {
  return charA.getStyle() === charB.getStyle();
}

function haveEqualEntity(charA, charB) {
  return charA.getEntity() === charB.getEntity();
}

var ContentBlock_1 = ContentBlock;

function _classCallCheck$2(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _possibleConstructorReturn$2(self, call) {
  if (!self) {
    throw new ReferenceError(
      "this hasn't been initialised - super() hasn't been called"
    );
  }
  return call && (typeof call === "object" || typeof call === "function")
    ? call
    : self;
}

function _inherits$2(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError(
      "Super expression must either be null or a function, not " +
        typeof superClass
    );
  }
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass)
    Object.setPrototypeOf
      ? Object.setPrototypeOf(subClass, superClass)
      : (subClass.__proto__ = superClass);
}

var List$1 = immutable.List,
  Map$2 = immutable.Map,
  OrderedSet$2 = immutable.OrderedSet,
  Record$2 = immutable.Record,
  Repeat$1 = immutable.Repeat;

var EMPTY_SET$2 = OrderedSet$2();

var defaultRecord$2 = {
  parent: null,
  characterList: List$1(),
  data: Map$2(),
  depth: 0,
  key: "",
  text: "",
  type: "unstyled",
  children: List$1(),
  prevSibling: null,
  nextSibling: null
};

var haveEqualStyle$1 = function haveEqualStyle(charA, charB) {
  return charA.getStyle() === charB.getStyle();
};

var haveEqualEntity$1 = function haveEqualEntity(charA, charB) {
  return charA.getEntity() === charB.getEntity();
};

var decorateCharacterList$1 = function decorateCharacterList(config) {
  if (!config) {
    return config;
  }

  var characterList = config.characterList,
    text = config.text;

  if (text && !characterList) {
    config.characterList = List$1(
      Repeat$1(CharacterMetadata_1.EMPTY, text.length)
    );
  }

  return config;
};

var ContentBlockNode = (function(_Record) {
  _inherits$2(ContentBlockNode, _Record);

  function ContentBlockNode() {
    var props =
      arguments.length > 0 && arguments[0] !== undefined
        ? arguments[0]
        : defaultRecord$2;

    _classCallCheck$2(this, ContentBlockNode);

    return _possibleConstructorReturn$2(
      this,
      _Record.call(this, decorateCharacterList$1(props))
    );
  }

  ContentBlockNode.prototype.getKey = function getKey() {
    return this.get("key");
  };

  ContentBlockNode.prototype.getType = function getType() {
    return this.get("type");
  };

  ContentBlockNode.prototype.getText = function getText() {
    return this.get("text");
  };

  ContentBlockNode.prototype.getCharacterList = function getCharacterList() {
    return this.get("characterList");
  };

  ContentBlockNode.prototype.getLength = function getLength() {
    return this.getText().length;
  };

  ContentBlockNode.prototype.getDepth = function getDepth() {
    return this.get("depth");
  };

  ContentBlockNode.prototype.getData = function getData() {
    return this.get("data");
  };

  ContentBlockNode.prototype.getInlineStyleAt = function getInlineStyleAt(
    offset
  ) {
    var character = this.getCharacterList().get(offset);
    return character ? character.getStyle() : EMPTY_SET$2;
  };

  ContentBlockNode.prototype.getEntityAt = function getEntityAt(offset) {
    var character = this.getCharacterList().get(offset);
    return character ? character.getEntity() : null;
  };

  ContentBlockNode.prototype.getChildKeys = function getChildKeys() {
    return this.get("children");
  };

  ContentBlockNode.prototype.getParentKey = function getParentKey() {
    return this.get("parent");
  };

  ContentBlockNode.prototype.getPrevSiblingKey = function getPrevSiblingKey() {
    return this.get("prevSibling");
  };

  ContentBlockNode.prototype.getNextSiblingKey = function getNextSiblingKey() {
    return this.get("nextSibling");
  };

  ContentBlockNode.prototype.findStyleRanges = function findStyleRanges(
    filterFn,
    callback
  ) {
    findRangesImmutable_1(
      this.getCharacterList(),
      haveEqualStyle$1,
      filterFn,
      callback
    );
  };

  ContentBlockNode.prototype.findEntityRanges = function findEntityRanges(
    filterFn,
    callback
  ) {
    findRangesImmutable_1(
      this.getCharacterList(),
      haveEqualEntity$1,
      filterFn,
      callback
    );
  };

  return ContentBlockNode;
})(Record$2(defaultRecord$2));

var ContentBlockNode_1 = ContentBlockNode;

/**
 * Copyright 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule DraftFeatureFlags-core
 * @format
 *
 */

var DraftFeatureFlags = {
  draft_killswitch_allow_nontextnodes: false,
  draft_segmented_entities_behavior: false,
  draft_handlebeforeinput_composed_text: false,
  draft_tree_data_support: false
};

var DraftFeatureFlagsCore = DraftFeatureFlags;

var DraftFeatureFlags_1 = DraftFeatureFlagsCore;

var Map$3 = immutable.Map;

var ContentStateInlineStyle = {
  add: function add(contentState, selectionState, inlineStyle) {
    return modifyInlineStyle(contentState, selectionState, inlineStyle, true);
  },

  remove: function remove(contentState, selectionState, inlineStyle) {
    return modifyInlineStyle(contentState, selectionState, inlineStyle, false);
  }
};

function modifyInlineStyle(
  contentState,
  selectionState,
  inlineStyle,
  addOrRemove
) {
  var blockMap = contentState.getBlockMap();
  var startKey = selectionState.getStartKey();
  var startOffset = selectionState.getStartOffset();
  var endKey = selectionState.getEndKey();
  var endOffset = selectionState.getEndOffset();

  var newBlocks = blockMap
    .skipUntil(function(_, k) {
      return k === startKey;
    })
    .takeUntil(function(_, k) {
      return k === endKey;
    })
    .concat(Map$3([[endKey, blockMap.get(endKey)]]))
    .map(function(block, blockKey) {
      var sliceStart;
      var sliceEnd;

      if (startKey === endKey) {
        sliceStart = startOffset;
        sliceEnd = endOffset;
      } else {
        sliceStart = blockKey === startKey ? startOffset : 0;
        sliceEnd = blockKey === endKey ? endOffset : block.getLength();
      }

      var chars = block.getCharacterList();
      var current;
      while (sliceStart < sliceEnd) {
        current = chars.get(sliceStart);
        chars = chars.set(
          sliceStart,
          addOrRemove
            ? CharacterMetadata_1.applyStyle(current, inlineStyle)
            : CharacterMetadata_1.removeStyle(current, inlineStyle)
        );
        sliceStart++;
      }

      return block.set("characterList", chars);
    });

  return contentState.merge({
    blockMap: blockMap.merge(newBlocks),
    selectionBefore: selectionState,
    selectionAfter: selectionState
  });
}

var ContentStateInlineStyle_1 = ContentStateInlineStyle;

function applyEntityToContentBlock(contentBlock, start, end, entityKey) {
  var characterList = contentBlock.getCharacterList();
  while (start < end) {
    characterList = characterList.set(
      start,
      CharacterMetadata_1.applyEntity(characterList.get(start), entityKey)
    );
    start++;
  }
  return contentBlock.set("characterList", characterList);
}

var applyEntityToContentBlock_1 = applyEntityToContentBlock;

function applyEntityToContentState(contentState, selectionState, entityKey) {
  var blockMap = contentState.getBlockMap();
  var startKey = selectionState.getStartKey();
  var startOffset = selectionState.getStartOffset();
  var endKey = selectionState.getEndKey();
  var endOffset = selectionState.getEndOffset();

  var newBlocks = blockMap
    .skipUntil(function(_, k) {
      return k === startKey;
    })
    .takeUntil(function(_, k) {
      return k === endKey;
    })
    .toOrderedMap()
    .merge(immutable.OrderedMap([[endKey, blockMap.get(endKey)]]))
    .map(function(block, blockKey) {
      var sliceStart = blockKey === startKey ? startOffset : 0;
      var sliceEnd = blockKey === endKey ? endOffset : block.getLength();
      return applyEntityToContentBlock_1(
        block,
        sliceStart,
        sliceEnd,
        entityKey
      );
    });

  return contentState.merge({
    blockMap: blockMap.merge(newBlocks),
    selectionBefore: selectionState,
    selectionAfter: selectionState
  });
}

var applyEntityToContentState_1 = applyEntityToContentState;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule DraftEntitySegments
 * @format
 *
 */

/**
 * Identify the range to delete from a segmented entity.
 *
 * Rules:
 *
 *  Example: 'John F. Kennedy'
 *
 *   - Deletion from within any non-whitespace (i.e. ['John', 'F.', 'Kennedy'])
 *     will return the range of that text.
 *
 *       'John F. Kennedy' -> 'John F.'
 *                  ^
 *
 *   - Forward deletion of whitespace will remove the following section:
 *
 *       'John F. Kennedy' -> 'John Kennedy'
 *            ^
 *
 *   - Backward deletion of whitespace will remove the previous section:
 *
 *       'John F. Kennedy' -> 'F. Kennedy'
 *            ^
 */
var DraftEntitySegments = {
  getRemovalRange: function getRemovalRange(
    selectionStart,
    selectionEnd,
    text,
    entityStart,
    direction
  ) {
    var segments = text.split(" ");
    segments = segments.map(function(/*string*/ segment, /*number*/ ii) {
      if (direction === "forward") {
        if (ii > 0) {
          return " " + segment;
        }
      } else if (ii < segments.length - 1) {
        return segment + " ";
      }
      return segment;
    });

    var segmentStart = entityStart;
    var segmentEnd;
    var segment;
    var removalStart = null;
    var removalEnd = null;

    for (var jj = 0; jj < segments.length; jj++) {
      segment = segments[jj];
      segmentEnd = segmentStart + segment.length;

      // Our selection overlaps this segment.
      if (selectionStart < segmentEnd && segmentStart < selectionEnd) {
        if (removalStart !== null) {
          removalEnd = segmentEnd;
        } else {
          removalStart = segmentStart;
          removalEnd = segmentEnd;
        }
      } else if (removalStart !== null) {
        break;
      }

      segmentStart = segmentEnd;
    }

    var entityEnd = entityStart + text.length;
    var atStart = removalStart === entityStart;
    var atEnd = removalEnd === entityEnd;

    if ((!atStart && atEnd) || (atStart && !atEnd)) {
      if (direction === "forward") {
        if (removalEnd !== entityEnd) {
          removalEnd++;
        }
      } else if (removalStart !== entityStart) {
        removalStart--;
      }
    }

    return {
      start: removalStart,
      end: removalEnd
    };
  }
};

var DraftEntitySegments_1 = DraftEntitySegments;

/**
 * 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.
 *
 */

/**
 * 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.
 */

var validateFormat = function validateFormat(format) {};

if (process.env.NODE_ENV !== "production") {
  validateFormat = function validateFormat(format) {
    if (format === undefined) {
      throw new Error("invariant requires an error message argument");
    }
  };
}

function invariant(condition, format, a, b, c, d, e, f) {
  validateFormat(format);

  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 args = [a, b, c, d, e, f];
      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;
  }
}

var invariant_1 = invariant;

/**
 * Obtain the start and end positions of the range that has the
 * specified entity applied to it.
 *
 * Entity keys are applied only to contiguous stretches of text, so this
 * method searches for the first instance of the entity key and returns
 * the subsequent range.
 */
function getRangesForDraftEntity(block, key) {
  var ranges = [];
  block.findEntityRanges(
    function(c) {
      return c.getEntity() === key;
    },
    function(start, end) {
      ranges.push({ start: start, end: end });
    }
  );

  !!!ranges.length
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "Entity key not found in this range.")
      : invariant_1(false)
    : void 0;

  return ranges;
}

var getRangesForDraftEntity_1 = getRangesForDraftEntity;

/**
 * Given a SelectionState and a removal direction, determine the entire range
 * that should be removed from a ContentState. This is based on any entities
 * within the target, with their `mutability` values taken into account.
 *
 * For instance, if we are attempting to remove part of an "immutable" entity
 * range, the entire entity must be removed. The returned `SelectionState`
 * will be adjusted accordingly.
 */
function getCharacterRemovalRange(
  entityMap,
  startBlock,
  endBlock,
  selectionState,
  direction
) {
  var start = selectionState.getStartOffset();
  var end = selectionState.getEndOffset();
  var startEntityKey = startBlock.getEntityAt(start);
  var endEntityKey = endBlock.getEntityAt(end - 1);
  if (!startEntityKey && !endEntityKey) {
    return selectionState;
  }
  var newSelectionState = selectionState;
  if (startEntityKey && startEntityKey === endEntityKey) {
    newSelectionState = getEntityRemovalRange(
      entityMap,
      startBlock,
      newSelectionState,
      direction,
      startEntityKey,
      true,
      true
    );
  } else if (startEntityKey && endEntityKey) {
    var startSelectionState = getEntityRemovalRange(
      entityMap,
      startBlock,
      newSelectionState,
      direction,
      startEntityKey,
      false,
      true
    );
    var endSelectionState = getEntityRemovalRange(
      entityMap,
      endBlock,
      newSelectionState,
      direction,
      endEntityKey,
      false,
      false
    );
    newSelectionState = newSelectionState.merge({
      anchorOffset: startSelectionState.getAnchorOffset(),
      focusOffset: endSelectionState.getFocusOffset(),
      isBackward: false
    });
  } else if (startEntityKey) {
    var _startSelectionState = getEntityRemovalRange(
      entityMap,
      startBlock,
      newSelectionState,
      direction,
      startEntityKey,
      false,
      true
    );
    newSelectionState = newSelectionState.merge({
      anchorOffset: _startSelectionState.getStartOffset(),
      isBackward: false
    });
  } else if (endEntityKey) {
    var _endSelectionState = getEntityRemovalRange(
      entityMap,
      endBlock,
      newSelectionState,
      direction,
      endEntityKey,
      false,
      false
    );
    newSelectionState = newSelectionState.merge({
      focusOffset: _endSelectionState.getEndOffset(),
      isBackward: false
    });
  }
  return newSelectionState;
}

function getEntityRemovalRange(
  entityMap,
  block,
  selectionState,
  direction,
  entityKey,
  isEntireSelectionWithinEntity,
  isEntityAtStart
) {
  var start = selectionState.getStartOffset();
  var end = selectionState.getEndOffset();
  var entity = entityMap.__get(entityKey);
  var mutability = entity.getMutability();
  var sideToConsider = isEntityAtStart ? start : end;

  // `MUTABLE` entities can just have the specified range of text removed
  // directly. No adjustments are needed.
  if (mutability === "MUTABLE") {
    return selectionState;
  }

  // Find the entity range that overlaps with our removal range.
  var entityRanges = getRangesForDraftEntity_1(block, entityKey).filter(
    function(range) {
      return sideToConsider <= range.end && sideToConsider >= range.start;
    }
  );

  !(entityRanges.length == 1)
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(
          false,
          "There should only be one entity range within this removal range."
        )
      : invariant_1(false)
    : void 0;

  var entityRange = entityRanges[0];

  // For `IMMUTABLE` entity types, we will remove the entire entity range.
  if (mutability === "IMMUTABLE") {
    return selectionState.merge({
      anchorOffset: entityRange.start,
      focusOffset: entityRange.end,
      isBackward: false
    });
  }

  // For `SEGMENTED` entity types, determine the appropriate segment to
  // remove.
  if (!isEntireSelectionWithinEntity) {
    if (isEntityAtStart) {
      end = entityRange.end;
    } else {
      start = entityRange.start;
    }
  }

  var removalRange = DraftEntitySegments_1.getRemovalRange(
    start,
    end,
    block.getText().slice(entityRange.start, entityRange.end),
    entityRange.start,
    direction
  );

  return selectionState.merge({
    anchorOffset: removalRange.start,
    focusOffset: removalRange.end,
    isBackward: false
  });
}

var getCharacterRemovalRange_1 = getCharacterRemovalRange;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule generateRandomKey
 * @format
 *
 */

var seenKeys = {};
var MULTIPLIER = Math.pow(2, 24);

function generateRandomKey() {
  var key = void 0;
  while (key === undefined || seenKeys.hasOwnProperty(key) || !isNaN(+key)) {
    key = Math.floor(Math.random() * MULTIPLIER).toString(32);
  }
  seenKeys[key] = true;
  return key;
}

var generateRandomKey_1 = generateRandomKey;

var OrderedMap$1 = immutable.OrderedMap;

var randomizeContentBlockNodeKeys = function randomizeContentBlockNodeKeys(
  blockMap
) {
  var newKeysRef = {};

  // we keep track of root blocks in order to update subsequent sibling links
  var lastRootBlock = void 0;

  return OrderedMap$1(
    blockMap
      .withMutations(function(blockMapState) {
        blockMapState.forEach(function(block, index) {
          var oldKey = block.getKey();
          var nextKey = block.getNextSiblingKey();
          var prevKey = block.getPrevSiblingKey();
          var childrenKeys = block.getChildKeys();
          var parentKey = block.getParentKey();

          // new key that we will use to build linking
          var key = generateRandomKey_1();

          // we will add it here to re-use it later
          newKeysRef[oldKey] = key;

          if (nextKey) {
            var nextBlock = blockMapState.get(nextKey);
            if (nextBlock) {
              blockMapState.setIn([nextKey, "prevSibling"], key);
            } else {
              // this can happen when generating random keys for fragments
              blockMapState.setIn([oldKey, "nextSibling"], null);
            }
          }

          if (prevKey) {
            var prevBlock = blockMapState.get(prevKey);
            if (prevBlock) {
              blockMapState.setIn([prevKey, "nextSibling"], key);
            } else {
              // this can happen when generating random keys for fragments
              blockMapState.setIn([oldKey, "prevSibling"], null);
            }
          }

          if (parentKey && blockMapState.get(parentKey)) {
            var parentBlock = blockMapState.get(parentKey);
            var parentChildrenList = parentBlock.getChildKeys();
            blockMapState.setIn(
              [parentKey, "children"],
              parentChildrenList.set(
                parentChildrenList.indexOf(block.getKey()),
                key
              )
            );
          } else {
            // blocks will then be treated as root block nodes
            blockMapState.setIn([oldKey, "parent"], null);

            if (lastRootBlock) {
              blockMapState.setIn([lastRootBlock.getKey(), "nextSibling"], key);
              blockMapState.setIn(
                [oldKey, "prevSibling"],
                newKeysRef[lastRootBlock.getKey()]
              );
            }

            lastRootBlock = blockMapState.get(oldKey);
          }

          childrenKeys.forEach(function(childKey) {
            var childBlock = blockMapState.get(childKey);
            if (childBlock) {
              blockMapState.setIn([childKey, "parent"], key);
            } else {
              blockMapState.setIn(
                [oldKey, "children"],
                block.getChildKeys().filter(function(child) {
                  return child !== childKey;
                })
              );
            }
          });
        });
      })
      .toArray()
      .map(function(block) {
        return [
          newKeysRef[block.getKey()],
          block.set("key", newKeysRef[block.getKey()])
        ];
      })
  );
};

var randomizeContentBlockKeys = function randomizeContentBlockKeys(blockMap) {
  return OrderedMap$1(
    blockMap.toArray().map(function(block) {
      var key = generateRandomKey_1();
      return [key, block.set("key", key)];
    })
  );
};

var randomizeBlockMapKeys = function randomizeBlockMapKeys(blockMap) {
  var isTreeBasedBlockMap = blockMap.first() instanceof ContentBlockNode_1;

  if (!isTreeBasedBlockMap) {
    return randomizeContentBlockKeys(blockMap);
  }

  return randomizeContentBlockNodeKeys(blockMap);
};

var randomizeBlockMapKeys_1 = randomizeBlockMapKeys;

function removeEntitiesAtEdges(contentState, selectionState) {
  var blockMap = contentState.getBlockMap();
  var entityMap = contentState.getEntityMap();

  var updatedBlocks = {};

  var startKey = selectionState.getStartKey();
  var startOffset = selectionState.getStartOffset();
  var startBlock = blockMap.get(startKey);
  var updatedStart = removeForBlock(entityMap, startBlock, startOffset);

  if (updatedStart !== startBlock) {
    updatedBlocks[startKey] = updatedStart;
  }

  var endKey = selectionState.getEndKey();
  var endOffset = selectionState.getEndOffset();
  var endBlock = blockMap.get(endKey);
  if (startKey === endKey) {
    endBlock = updatedStart;
  }

  var updatedEnd = removeForBlock(entityMap, endBlock, endOffset);

  if (updatedEnd !== endBlock) {
    updatedBlocks[endKey] = updatedEnd;
  }

  if (!Object.keys(updatedBlocks).length) {
    return contentState.set("selectionAfter", selectionState);
  }

  return contentState.merge({
    blockMap: blockMap.merge(updatedBlocks),
    selectionAfter: selectionState
  });
}

function getRemovalRange(characters, key, offset) {
  var removalRange;
  findRangesImmutable_1(
    characters,
    function(a, b) {
      return a.getEntity() === b.getEntity();
    },
    function(element) {
      return element.getEntity() === key;
    },
    function(start, end) {
      if (start <= offset && end >= offset) {
        removalRange = { start: start, end: end };
      }
    }
  );
  !(typeof removalRange === "object")
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "Removal range must exist within character list.")
      : invariant_1(false)
    : void 0;
  return removalRange;
}

function removeForBlock(entityMap, block, offset) {
  var chars = block.getCharacterList();
  var charBefore = offset > 0 ? chars.get(offset - 1) : undefined;
  var charAfter = offset < chars.count() ? chars.get(offset) : undefined;
  var entityBeforeCursor = charBefore ? charBefore.getEntity() : undefined;
  var entityAfterCursor = charAfter ? charAfter.getEntity() : undefined;

  if (entityAfterCursor && entityAfterCursor === entityBeforeCursor) {
    var entity = entityMap.__get(entityAfterCursor);
    if (entity.getMutability() !== "MUTABLE") {
      var _getRemovalRange = getRemovalRange(chars, entityAfterCursor, offset),
        start = _getRemovalRange.start,
        end = _getRemovalRange.end;

      var current;
      while (start < end) {
        current = chars.get(start);
        chars = chars.set(
          start,
          CharacterMetadata_1.applyEntity(current, null)
        );
        start++;
      }
      return block.set("characterList", chars);
    }
  }

  return block;
}

var removeEntitiesAtEdges_1 = removeEntitiesAtEdges;

var getContentStateFragment = function getContentStateFragment(
  contentState,
  selectionState
) {
  var startKey = selectionState.getStartKey();
  var startOffset = selectionState.getStartOffset();
  var endKey = selectionState.getEndKey();
  var endOffset = selectionState.getEndOffset();

  // Edge entities should be stripped to ensure that we don't preserve
  // invalid partial entities when the fragment is reused. We do, however,
  // preserve entities that are entirely within the selection range.
  var contentWithoutEdgeEntities = removeEntitiesAtEdges_1(
    contentState,
    selectionState
  );

  var blockMap = contentWithoutEdgeEntities.getBlockMap();
  var blockKeys = blockMap.keySeq();
  var startIndex = blockKeys.indexOf(startKey);
  var endIndex = blockKeys.indexOf(endKey) + 1;

  return randomizeBlockMapKeys_1(
    blockMap.slice(startIndex, endIndex).map(function(block, blockKey) {
      var text = block.getText();
      var chars = block.getCharacterList();

      if (startKey === endKey) {
        return block.merge({
          text: text.slice(startOffset, endOffset),
          characterList: chars.slice(startOffset, endOffset)
        });
      }

      if (blockKey === startKey) {
        return block.merge({
          text: text.slice(startOffset),
          characterList: chars.slice(startOffset)
        });
      }

      if (blockKey === endKey) {
        return block.merge({
          text: text.slice(0, endOffset),
          characterList: chars.slice(0, endOffset)
        });
      }

      return block;
    })
  );
};

var getContentStateFragment_1 = getContentStateFragment;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule insertIntoList
 * @format
 *
 */

/**
 * Maintain persistence for target list when appending and prepending.
 */
function insertIntoList(targetList, toInsert, offset) {
  if (offset === targetList.count()) {
    toInsert.forEach(function(c) {
      targetList = targetList.push(c);
    });
  } else if (offset === 0) {
    toInsert.reverse().forEach(function(c) {
      targetList = targetList.unshift(c);
    });
  } else {
    var head = targetList.slice(0, offset);
    var tail = targetList.slice(offset);
    targetList = head.concat(toInsert, tail).toList();
  }
  return targetList;
}

var insertIntoList_1 = insertIntoList;

var List$2 = immutable.List;

var updateExistingBlock = function updateExistingBlock(
  contentState,
  selectionState,
  blockMap,
  fragmentBlock,
  targetKey,
  targetOffset
) {
  var targetBlock = blockMap.get(targetKey);
  var text = targetBlock.getText();
  var chars = targetBlock.getCharacterList();
  var finalKey = targetKey;
  var finalOffset = targetOffset + fragmentBlock.getText().length;

  var newBlock = targetBlock.merge({
    text:
      text.slice(0, targetOffset) +
      fragmentBlock.getText() +
      text.slice(targetOffset),
    characterList: insertIntoList_1(
      chars,
      fragmentBlock.getCharacterList(),
      targetOffset
    ),
    data: fragmentBlock.getData()
  });

  return contentState.merge({
    blockMap: blockMap.set(targetKey, newBlock),
    selectionBefore: selectionState,
    selectionAfter: selectionState.merge({
      anchorKey: finalKey,
      anchorOffset: finalOffset,
      focusKey: finalKey,
      focusOffset: finalOffset,
      isBackward: false
    })
  });
};

/**
 * Appends text/characterList from the fragment first block to
 * target block.
 */
var updateHead = function updateHead(block, targetOffset, fragment) {
  var text = block.getText();
  var chars = block.getCharacterList();

  // Modify head portion of block.
  var headText = text.slice(0, targetOffset);
  var headCharacters = chars.slice(0, targetOffset);
  var appendToHead = fragment.first();

  return block.merge({
    text: headText + appendToHead.getText(),
    characterList: headCharacters.concat(appendToHead.getCharacterList()),
    type: headText ? block.getType() : appendToHead.getType(),
    data: appendToHead.getData()
  });
};

/**
 * Appends offset text/characterList from the target block to the last
 * fragment block.
 */
var updateTail = function updateTail(block, targetOffset, fragment) {
  // Modify tail portion of block.
  var text = block.getText();
  var chars = block.getCharacterList();

  // Modify head portion of block.
  var blockSize = text.length;
  var tailText = text.slice(targetOffset, blockSize);
  var tailCharacters = chars.slice(targetOffset, blockSize);
  var prependToTail = fragment.last();

  return prependToTail.merge({
    text: prependToTail.getText() + tailText,
    characterList: prependToTail.getCharacterList().concat(tailCharacters),
    data: prependToTail.getData()
  });
};

var getRootBlocks = function getRootBlocks(block, blockMap) {
  var headKey = block.getKey();
  var rootBlock = block;
  var rootBlocks = [];

  // sometimes the fragment head block will not be part of the blockMap itself this can happen when
  // the fragment head is used to update the target block, however when this does not happen we need
  // to make sure that we include it on the rootBlocks since the first block of a fragment is always a
  // fragment root block
  if (blockMap.get(headKey)) {
    rootBlocks.push(headKey);
  }

  while (rootBlock && rootBlock.getNextSiblingKey()) {
    var lastSiblingKey = rootBlock.getNextSiblingKey();

    if (!lastSiblingKey) {
      break;
    }

    rootBlocks.push(lastSiblingKey);
    rootBlock = blockMap.get(lastSiblingKey);
  }

  return rootBlocks;
};

var updateBlockMapLinks = function updateBlockMapLinks(
  blockMap,
  originalBlockMap,
  targetBlock,
  fragmentHeadBlock
) {
  return blockMap.withMutations(function(blockMapState) {
    var targetKey = targetBlock.getKey();
    var headKey = fragmentHeadBlock.getKey();
    var targetNextKey = targetBlock.getNextSiblingKey();
    var targetParentKey = targetBlock.getParentKey();
    var fragmentRootBlocks = getRootBlocks(fragmentHeadBlock, blockMap);
    var lastRootFragmentBlockKey =
      fragmentRootBlocks[fragmentRootBlocks.length - 1];

    if (blockMapState.get(headKey)) {
      // update the fragment head when it is part of the blockMap otherwise
      blockMapState.setIn([targetKey, "nextSibling"], headKey);
      blockMapState.setIn([headKey, "prevSibling"], targetKey);
    } else {
      // update the target block that had the fragment head contents merged into it
      blockMapState.setIn(
        [targetKey, "nextSibling"],
        fragmentHeadBlock.getNextSiblingKey()
      );
      blockMapState.setIn(
        [fragmentHeadBlock.getNextSiblingKey(), "prevSibling"],
        targetKey
      );
    }

    // update the last root block fragment
    blockMapState.setIn(
      [lastRootFragmentBlockKey, "nextSibling"],
      targetNextKey
    );

    // update the original target next block
    if (targetNextKey) {
      blockMapState.setIn(
        [targetNextKey, "prevSibling"],
        lastRootFragmentBlockKey
      );
    }

    // update fragment parent links
    fragmentRootBlocks.forEach(function(blockKey) {
      return blockMapState.setIn([blockKey, "parent"], targetParentKey);
    });

    // update targetBlock parent child links
    if (targetParentKey) {
      var targetParent = blockMap.get(targetParentKey);
      var originalTargetParentChildKeys = targetParent.getChildKeys();

      var targetBlockIndex = originalTargetParentChildKeys.indexOf(targetKey);
      var insertionIndex = targetBlockIndex + 1;

      var newChildrenKeysArray = originalTargetParentChildKeys.toArray();

      // insert fragment children
      newChildrenKeysArray.splice.apply(
        newChildrenKeysArray,
        [insertionIndex, 0].concat(fragmentRootBlocks)
      );

      blockMapState.setIn(
        [targetParentKey, "children"],
        List$2(newChildrenKeysArray)
      );
    }
  });
};

var insertFragment = function insertFragment(
  contentState,
  selectionState,
  blockMap,
  fragment,
  targetKey,
  targetOffset
) {
  var isTreeBasedBlockMap = blockMap.first() instanceof ContentBlockNode_1;
  var newBlockArr = [];
  var fragmentSize = fragment.size;
  var target = blockMap.get(targetKey);
  var head = fragment.first();
  var tail = fragment.last();
  var finalOffset = tail.getLength();
  var finalKey = tail.getKey();
  var shouldNotUpdateFromFragmentBlock =
    isTreeBasedBlockMap &&
    (!target.getChildKeys().isEmpty() || !head.getChildKeys().isEmpty());

  blockMap.forEach(function(block, blockKey) {
    if (blockKey !== targetKey) {
      newBlockArr.push(block);
      return;
    }

    if (shouldNotUpdateFromFragmentBlock) {
      newBlockArr.push(block);
    } else {
      newBlockArr.push(updateHead(block, targetOffset, fragment));
    }

    // Insert fragment blocks after the head and before the tail.
    fragment
      // when we are updating the target block with the head fragment block we skip the first fragment
      // head since its contents have already been merged with the target block otherwise we include
      // the whole fragment
      .slice(shouldNotUpdateFromFragmentBlock ? 0 : 1, fragmentSize - 1)
      .forEach(function(fragmentBlock) {
        return newBlockArr.push(fragmentBlock);
      });

    // update tail
    newBlockArr.push(updateTail(block, targetOffset, fragment));
  });

  var updatedBlockMap = BlockMapBuilder_1.createFromArray(newBlockArr);

  if (isTreeBasedBlockMap) {
    updatedBlockMap = updateBlockMapLinks(
      updatedBlockMap,
      blockMap,
      target,
      head
    );
  }

  return contentState.merge({
    blockMap: updatedBlockMap,
    selectionBefore: selectionState,
    selectionAfter: selectionState.merge({
      anchorKey: finalKey,
      anchorOffset: finalOffset,
      focusKey: finalKey,
      focusOffset: finalOffset,
      isBackward: false
    })
  });
};

var insertFragmentIntoContentState = function insertFragmentIntoContentState(
  contentState,
  selectionState,
  fragmentBlockMap
) {
  !selectionState.isCollapsed()
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(
          false,
          "`insertFragment` should only be called with a collapsed selection state."
        )
      : invariant_1(false)
    : void 0;

  var blockMap = contentState.getBlockMap();
  var fragment = randomizeBlockMapKeys_1(fragmentBlockMap);
  var targetKey = selectionState.getStartKey();
  var targetOffset = selectionState.getStartOffset();

  var targetBlock = blockMap.get(targetKey);

  if (targetBlock instanceof ContentBlockNode_1) {
    !targetBlock.getChildKeys().isEmpty()
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(
            false,
            "`insertFragment` should not be called when a container node is selected."
          )
        : invariant_1(false)
      : void 0;
  }

  // When we insert a fragment with a single block we simply update the target block
  // with the contents of the inserted fragment block
  if (fragment.size === 1) {
    return updateExistingBlock(
      contentState,
      selectionState,
      blockMap,
      fragment.first(),
      targetKey,
      targetOffset
    );
  }

  return insertFragment(
    contentState,
    selectionState,
    blockMap,
    fragment,
    targetKey,
    targetOffset
  );
};

var insertFragmentIntoContentState_1 = insertFragmentIntoContentState;

var Repeat$2 = immutable.Repeat;

function insertTextIntoContentState(
  contentState,
  selectionState,
  text,
  characterMetadata
) {
  !selectionState.isCollapsed()
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(
          false,
          "`insertText` should only be called with a collapsed range."
        )
      : invariant_1(false)
    : void 0;

  var len = text.length;
  if (!len) {
    return contentState;
  }

  var blockMap = contentState.getBlockMap();
  var key = selectionState.getStartKey();
  var offset = selectionState.getStartOffset();
  var block = blockMap.get(key);
  var blockText = block.getText();

  var newBlock = block.merge({
    text:
      blockText.slice(0, offset) +
      text +
      blockText.slice(offset, block.getLength()),
    characterList: insertIntoList_1(
      block.getCharacterList(),
      Repeat$2(characterMetadata, len).toList(),
      offset
    )
  });

  var newOffset = offset + len;

  return contentState.merge({
    blockMap: blockMap.set(key, newBlock),
    selectionAfter: selectionState.merge({
      anchorOffset: newOffset,
      focusOffset: newOffset
    })
  });
}

var insertTextIntoContentState_1 = insertTextIntoContentState;

var Map$4 = immutable.Map;

function modifyBlockForContentState(contentState, selectionState, operation) {
  var startKey = selectionState.getStartKey();
  var endKey = selectionState.getEndKey();
  var blockMap = contentState.getBlockMap();
  var newBlocks = blockMap
    .toSeq()
    .skipUntil(function(_, k) {
      return k === startKey;
    })
    .takeUntil(function(_, k) {
      return k === endKey;
    })
    .concat(Map$4([[endKey, blockMap.get(endKey)]]))
    .map(operation);

  return contentState.merge({
    blockMap: blockMap.merge(newBlocks),
    selectionBefore: selectionState,
    selectionAfter: selectionState
  });
}

var modifyBlockForContentState_1 = modifyBlockForContentState;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule getNextDelimiterBlockKey
 * @format
 *
 *
 * This is unstable and not part of the public API and should not be used by
 * production systems. This file may be update/removed without notice.
 */

var getNextDelimiterBlockKey = function getNextDelimiterBlockKey(
  block,
  blockMap
) {
  var isExperimentalTreeBlock = block instanceof ContentBlockNode_1;

  if (!isExperimentalTreeBlock) {
    return null;
  }

  var nextSiblingKey = block.getNextSiblingKey();

  if (nextSiblingKey) {
    return nextSiblingKey;
  }

  var parent = block.getParentKey();

  if (!parent) {
    return null;
  }

  var nextNonDescendantBlock = blockMap.get(parent);
  while (
    nextNonDescendantBlock &&
    !nextNonDescendantBlock.getNextSiblingKey()
  ) {
    var parentKey = nextNonDescendantBlock.getParentKey();
    nextNonDescendantBlock = parentKey ? blockMap.get(parentKey) : null;
  }

  if (!nextNonDescendantBlock) {
    return null;
  }

  return nextNonDescendantBlock.getNextSiblingKey();
};

var getNextDelimiterBlockKey_1 = getNextDelimiterBlockKey;

var List$3 = immutable.List,
  Map$5 = immutable.Map;

var transformBlock = function transformBlock(key, blockMap, func) {
  if (!key) {
    return;
  }

  var block = blockMap.get(key);

  if (!block) {
    return;
  }

  blockMap.set(key, func(block));
};

/**
 * Ancestors needs to be preserved when there are non selected
 * children to make sure we do not leave any orphans behind
 */
var getAncestorsKeys = function getAncestorsKeys(blockKey, blockMap) {
  var parents = [];

  if (!blockKey) {
    return parents;
  }

  var blockNode = blockMap.get(blockKey);
  while (blockNode && blockNode.getParentKey()) {
    var parentKey = blockNode.getParentKey();
    if (parentKey) {
      parents.push(parentKey);
    }
    blockNode = parentKey ? blockMap.get(parentKey) : null;
  }

  return parents;
};

/**
 * Get all next delimiter keys until we hit a root delimiter and return
 * an array of key references
 */
var getNextDelimitersBlockKeys = function getNextDelimitersBlockKeys(
  block,
  blockMap
) {
  var nextDelimiters = [];

  if (!block) {
    return nextDelimiters;
  }

  var nextDelimiter = getNextDelimiterBlockKey_1(block, blockMap);
  while (nextDelimiter && blockMap.get(nextDelimiter)) {
    var _block = blockMap.get(nextDelimiter);
    nextDelimiters.push(nextDelimiter);

    // we do not need to keep checking all root node siblings, just the first occurance
    nextDelimiter = _block.getParentKey()
      ? getNextDelimiterBlockKey_1(_block, blockMap)
      : null;
  }

  return nextDelimiters;
};

var getNextValidSibling = function getNextValidSibling(
  block,
  blockMap,
  originalBlockMap
) {
  if (!block) {
    return null;
  }

  // note that we need to make sure we refer to the original block since this
  // function is called within a withMutations
  var nextValidSiblingKey = originalBlockMap
    .get(block.getKey())
    .getNextSiblingKey();

  while (nextValidSiblingKey && !blockMap.get(nextValidSiblingKey)) {
    nextValidSiblingKey =
      originalBlockMap.get(nextValidSiblingKey).getNextSiblingKey() || null;
  }

  return nextValidSiblingKey;
};

var getPrevValidSibling = function getPrevValidSibling(
  block,
  blockMap,
  originalBlockMap
) {
  if (!block) {
    return null;
  }

  // note that we need to make sure we refer to the original block since this
  // function is called within a withMutations
  var prevValidSiblingKey = originalBlockMap
    .get(block.getKey())
    .getPrevSiblingKey();

  while (prevValidSiblingKey && !blockMap.get(prevValidSiblingKey)) {
    prevValidSiblingKey =
      originalBlockMap.get(prevValidSiblingKey).getPrevSiblingKey() || null;
  }

  return prevValidSiblingKey;
};

var updateBlockMapLinks$1 = function updateBlockMapLinks(
  blockMap,
  startBlock,
  endBlock,
  originalBlockMap
) {
  return blockMap.withMutations(function(blocks) {
    // update start block if its retained
    transformBlock(startBlock.getKey(), blocks, function(block) {
      return block.merge({
        nextSibling: getNextValidSibling(startBlock, blocks, originalBlockMap),
        prevSibling: getPrevValidSibling(startBlock, blocks, originalBlockMap)
      });
    });

    // update endblock if its retained
    transformBlock(endBlock.getKey(), blocks, function(block) {
      return block.merge({
        nextSibling: getNextValidSibling(endBlock, blocks, originalBlockMap),
        prevSibling: getPrevValidSibling(endBlock, blocks, originalBlockMap)
      });
    });

    // update start block parent ancestors
    getAncestorsKeys(startBlock.getKey(), originalBlockMap).forEach(function(
      parentKey
    ) {
      return transformBlock(parentKey, blocks, function(block) {
        return block.merge({
          children: block.getChildKeys().filter(function(key) {
            return blocks.get(key);
          }),
          nextSibling: getNextValidSibling(block, blocks, originalBlockMap),
          prevSibling: getPrevValidSibling(block, blocks, originalBlockMap)
        });
      });
    });

    // update start block next - can only happen if startBlock == endBlock
    transformBlock(startBlock.getNextSiblingKey(), blocks, function(block) {
      return block.merge({
        prevSibling: startBlock.getPrevSiblingKey()
      });
    });

    // update start block prev
    transformBlock(startBlock.getPrevSiblingKey(), blocks, function(block) {
      return block.merge({
        nextSibling: getNextValidSibling(startBlock, blocks, originalBlockMap)
      });
    });

    // update end block next
    transformBlock(endBlock.getNextSiblingKey(), blocks, function(block) {
      return block.merge({
        prevSibling: getPrevValidSibling(endBlock, blocks, originalBlockMap)
      });
    });

    // update end block prev
    transformBlock(endBlock.getPrevSiblingKey(), blocks, function(block) {
      return block.merge({
        nextSibling: endBlock.getNextSiblingKey()
      });
    });

    // update end block parent ancestors
    getAncestorsKeys(endBlock.getKey(), originalBlockMap).forEach(function(
      parentKey
    ) {
      transformBlock(parentKey, blocks, function(block) {
        return block.merge({
          children: block.getChildKeys().filter(function(key) {
            return blocks.get(key);
          }),
          nextSibling: getNextValidSibling(block, blocks, originalBlockMap),
          prevSibling: getPrevValidSibling(block, blocks, originalBlockMap)
        });
      });
    });

    // update next delimiters all the way to a root delimiter
    getNextDelimitersBlockKeys(endBlock, originalBlockMap).forEach(function(
      delimiterKey
    ) {
      return transformBlock(delimiterKey, blocks, function(block) {
        return block.merge({
          nextSibling: getNextValidSibling(block, blocks, originalBlockMap),
          prevSibling: getPrevValidSibling(block, blocks, originalBlockMap)
        });
      });
    });
  });
};

var removeRangeFromContentState = function removeRangeFromContentState(
  contentState,
  selectionState
) {
  if (selectionState.isCollapsed()) {
    return contentState;
  }

  var blockMap = contentState.getBlockMap();
  var startKey = selectionState.getStartKey();
  var startOffset = selectionState.getStartOffset();
  var endKey = selectionState.getEndKey();
  var endOffset = selectionState.getEndOffset();

  var startBlock = blockMap.get(startKey);
  var endBlock = blockMap.get(endKey);

  // we assume that ContentBlockNode and ContentBlocks are not mixed together
  var isExperimentalTreeBlock = startBlock instanceof ContentBlockNode_1;

  // used to retain blocks that should not be deleted to avoid orphan children
  var parentAncestors = [];

  if (isExperimentalTreeBlock) {
    var endBlockchildrenKeys = endBlock.getChildKeys();
    var endBlockAncestors = getAncestorsKeys(endKey, blockMap);

    // endBlock has unselected sibblings so we can not remove its ancestors parents
    if (endBlock.getNextSiblingKey()) {
      parentAncestors = parentAncestors.concat(endBlockAncestors);
    }

    // endBlock has children so can not remove this block or any of its ancestors
    if (!endBlockchildrenKeys.isEmpty()) {
      parentAncestors = parentAncestors.concat(
        endBlockAncestors.concat([endKey])
      );
    }

    // we need to retain all ancestors of the next delimiter block
    parentAncestors = parentAncestors.concat(
      getAncestorsKeys(getNextDelimiterBlockKey_1(endBlock, blockMap), blockMap)
    );
  }

  var characterList = void 0;

  if (startBlock === endBlock) {
    characterList = removeFromList(
      startBlock.getCharacterList(),
      startOffset,
      endOffset
    );
  } else {
    characterList = startBlock
      .getCharacterList()
      .slice(0, startOffset)
      .concat(endBlock.getCharacterList().slice(endOffset));
  }

  var modifiedStart = startBlock.merge({
    text:
      startBlock.getText().slice(0, startOffset) +
      endBlock.getText().slice(endOffset),
    characterList: characterList
  });

  var newBlocks = blockMap
    .toSeq()
    .skipUntil(function(_, k) {
      return k === startKey;
    })
    .takeUntil(function(_, k) {
      return k === endKey;
    })
    .filter(function(_, k) {
      return parentAncestors.indexOf(k) === -1;
    })
    .concat(Map$5([[endKey, null]]))
    .map(function(_, k) {
      return k === startKey ? modifiedStart : null;
    });

  var updatedBlockMap = blockMap.merge(newBlocks).filter(function(block) {
    return !!block;
  });

  if (isExperimentalTreeBlock) {
    updatedBlockMap = updateBlockMapLinks$1(
      updatedBlockMap,
      startBlock,
      endBlock,
      blockMap
    );
  }

  return contentState.merge({
    blockMap: updatedBlockMap,
    selectionBefore: selectionState,
    selectionAfter: selectionState.merge({
      anchorKey: startKey,
      anchorOffset: startOffset,
      focusKey: startKey,
      focusOffset: startOffset,
      isBackward: false
    })
  });
};

/**
 * Maintain persistence for target list when removing characters on the
 * head and tail of the character list.
 */
var removeFromList = function removeFromList(
  targetList,
  startOffset,
  endOffset
) {
  if (startOffset === 0) {
    while (startOffset < endOffset) {
      targetList = targetList.shift();
      startOffset++;
    }
  } else if (endOffset === targetList.count()) {
    while (endOffset > startOffset) {
      targetList = targetList.pop();
      endOffset--;
    }
  } else {
    var head = targetList.slice(0, startOffset);
    var tail = targetList.slice(endOffset);
    targetList = head.concat(tail).toList();
  }
  return targetList;
};

var removeRangeFromContentState_1 = removeRangeFromContentState;

var List$4 = immutable.List,
  Map$6 = immutable.Map;

var transformBlock$1 = function transformBlock(key, blockMap, func) {
  if (!key) {
    return;
  }

  var block = blockMap.get(key);

  if (!block) {
    return;
  }

  blockMap.set(key, func(block));
};

var updateBlockMapLinks$2 = function updateBlockMapLinks(
  blockMap,
  originalBlock,
  belowBlock
) {
  return blockMap.withMutations(function(blocks) {
    var originalBlockKey = originalBlock.getKey();
    var belowBlockKey = belowBlock.getKey();

    // update block parent
    transformBlock$1(originalBlock.getParentKey(), blocks, function(block) {
      var parentChildrenList = block.getChildKeys();
      var insertionIndex = parentChildrenList.indexOf(originalBlockKey) + 1;
      var newChildrenArray = parentChildrenList.toArray();

      newChildrenArray.splice(insertionIndex, 0, belowBlockKey);

      return block.merge({
        children: List$4(newChildrenArray)
      });
    });

    // update original next block
    transformBlock$1(originalBlock.getNextSiblingKey(), blocks, function(
      block
    ) {
      return block.merge({
        prevSibling: belowBlockKey
      });
    });

    // update original block
    transformBlock$1(originalBlockKey, blocks, function(block) {
      return block.merge({
        nextSibling: belowBlockKey
      });
    });

    // update below block
    transformBlock$1(belowBlockKey, blocks, function(block) {
      return block.merge({
        prevSibling: originalBlockKey
      });
    });
  });
};

var splitBlockInContentState = function splitBlockInContentState(
  contentState,
  selectionState
) {
  !selectionState.isCollapsed()
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "Selection range must be collapsed.")
      : invariant_1(false)
    : void 0;

  var key = selectionState.getAnchorKey();
  var offset = selectionState.getAnchorOffset();
  var blockMap = contentState.getBlockMap();
  var blockToSplit = blockMap.get(key);
  var text = blockToSplit.getText();
  var chars = blockToSplit.getCharacterList();
  var keyBelow = generateRandomKey_1();
  var isExperimentalTreeBlock = blockToSplit instanceof ContentBlockNode_1;

  var blockAbove = blockToSplit.merge({
    text: text.slice(0, offset),
    characterList: chars.slice(0, offset)
  });
  var blockBelow = blockAbove.merge({
    key: keyBelow,
    text: text.slice(offset),
    characterList: chars.slice(offset),
    data: Map$6()
  });

  var blocksBefore = blockMap.toSeq().takeUntil(function(v) {
    return v === blockToSplit;
  });
  var blocksAfter = blockMap
    .toSeq()
    .skipUntil(function(v) {
      return v === blockToSplit;
    })
    .rest();
  var newBlocks = blocksBefore
    .concat(
      [
        [key, blockAbove],
        [keyBelow, blockBelow]
      ],
      blocksAfter
    )
    .toOrderedMap();

  if (isExperimentalTreeBlock) {
    !blockToSplit.getChildKeys().isEmpty()
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(false, "ContentBlockNode must not have children")
        : invariant_1(false)
      : void 0;

    newBlocks = updateBlockMapLinks$2(newBlocks, blockAbove, blockBelow);
  }

  return contentState.merge({
    blockMap: newBlocks,
    selectionBefore: selectionState,
    selectionAfter: selectionState.merge({
      anchorKey: keyBelow,
      anchorOffset: 0,
      focusKey: keyBelow,
      focusOffset: 0,
      isBackward: false
    })
  });
};

var splitBlockInContentState_1 = splitBlockInContentState;

var OrderedSet$3 = immutable.OrderedSet;

/**
 * `DraftModifier` provides a set of convenience methods that apply
 * modifications to a `ContentState` object based on a target `SelectionState`.
 *
 * Any change to a `ContentState` should be decomposable into a series of
 * transaction functions that apply the required changes and return output
 * `ContentState` objects.
 *
 * These functions encapsulate some of the most common transaction sequences.
 */

var DraftModifier = {
  replaceText: function replaceText(
    contentState,
    rangeToReplace,
    text,
    inlineStyle,
    entityKey
  ) {
    var withoutEntities = removeEntitiesAtEdges_1(contentState, rangeToReplace);
    var withoutText = removeRangeFromContentState_1(
      withoutEntities,
      rangeToReplace
    );

    var character = CharacterMetadata_1.create({
      style: inlineStyle || OrderedSet$3(),
      entity: entityKey || null
    });

    return insertTextIntoContentState_1(
      withoutText,
      withoutText.getSelectionAfter(),
      text,
      character
    );
  },

  insertText: function insertText(
    contentState,
    targetRange,
    text,
    inlineStyle,
    entityKey
  ) {
    !targetRange.isCollapsed()
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(false, "Target range must be collapsed for `insertText`.")
        : invariant_1(false)
      : void 0;
    return DraftModifier.replaceText(
      contentState,
      targetRange,
      text,
      inlineStyle,
      entityKey
    );
  },

  moveText: function moveText(contentState, removalRange, targetRange) {
    var movedFragment = getContentStateFragment_1(contentState, removalRange);

    var afterRemoval = DraftModifier.removeRange(
      contentState,
      removalRange,
      "backward"
    );

    return DraftModifier.replaceWithFragment(
      afterRemoval,
      targetRange,
      movedFragment
    );
  },

  replaceWithFragment: function replaceWithFragment(
    contentState,
    targetRange,
    fragment
  ) {
    var withoutEntities = removeEntitiesAtEdges_1(contentState, targetRange);
    var withoutText = removeRangeFromContentState_1(
      withoutEntities,
      targetRange
    );

    return insertFragmentIntoContentState_1(
      withoutText,
      withoutText.getSelectionAfter(),
      fragment
    );
  },

  removeRange: function removeRange(
    contentState,
    rangeToRemove,
    removalDirection
  ) {
    var startKey = void 0,
      endKey = void 0,
      startBlock = void 0,
      endBlock = void 0;
    if (rangeToRemove.getIsBackward()) {
      rangeToRemove = rangeToRemove.merge({
        anchorKey: rangeToRemove.getFocusKey(),
        anchorOffset: rangeToRemove.getFocusOffset(),
        focusKey: rangeToRemove.getAnchorKey(),
        focusOffset: rangeToRemove.getAnchorOffset(),
        isBackward: false
      });
    }
    startKey = rangeToRemove.getAnchorKey();
    endKey = rangeToRemove.getFocusKey();
    startBlock = contentState.getBlockForKey(startKey);
    endBlock = contentState.getBlockForKey(endKey);
    var startOffset = rangeToRemove.getStartOffset();
    var endOffset = rangeToRemove.getEndOffset();

    var startEntityKey = startBlock.getEntityAt(startOffset);
    var endEntityKey = endBlock.getEntityAt(endOffset - 1);

    // Check whether the selection state overlaps with a single entity.
    // If so, try to remove the appropriate substring of the entity text.
    if (startKey === endKey) {
      if (startEntityKey && startEntityKey === endEntityKey) {
        var _adjustedRemovalRange = getCharacterRemovalRange_1(
          contentState.getEntityMap(),
          startBlock,
          endBlock,
          rangeToRemove,
          removalDirection
        );
        return removeRangeFromContentState_1(
          contentState,
          _adjustedRemovalRange
        );
      }
    }
    var adjustedRemovalRange = rangeToRemove;

    var withoutEntities = removeEntitiesAtEdges_1(
      contentState,
      adjustedRemovalRange
    );
    return removeRangeFromContentState_1(withoutEntities, adjustedRemovalRange);
  },

  splitBlock: function splitBlock(contentState, selectionState) {
    var withoutEntities = removeEntitiesAtEdges_1(contentState, selectionState);
    var withoutText = removeRangeFromContentState_1(
      withoutEntities,
      selectionState
    );

    return splitBlockInContentState_1(
      withoutText,
      withoutText.getSelectionAfter()
    );
  },

  applyInlineStyle: function applyInlineStyle(
    contentState,
    selectionState,
    inlineStyle
  ) {
    return ContentStateInlineStyle_1.add(
      contentState,
      selectionState,
      inlineStyle
    );
  },

  removeInlineStyle: function removeInlineStyle(
    contentState,
    selectionState,
    inlineStyle
  ) {
    return ContentStateInlineStyle_1.remove(
      contentState,
      selectionState,
      inlineStyle
    );
  },

  setBlockType: function setBlockType(contentState, selectionState, blockType) {
    return modifyBlockForContentState_1(contentState, selectionState, function(
      block
    ) {
      return block.merge({ type: blockType, depth: 0 });
    });
  },

  setBlockData: function setBlockData(contentState, selectionState, blockData) {
    return modifyBlockForContentState_1(contentState, selectionState, function(
      block
    ) {
      return block.merge({ data: blockData });
    });
  },

  mergeBlockData: function mergeBlockData(
    contentState,
    selectionState,
    blockData
  ) {
    return modifyBlockForContentState_1(contentState, selectionState, function(
      block
    ) {
      return block.merge({ data: block.getData().merge(blockData) });
    });
  },

  applyEntity: function applyEntity(contentState, selectionState, entityKey) {
    var withoutEntities = removeEntitiesAtEdges_1(contentState, selectionState);
    return applyEntityToContentState_1(
      withoutEntities,
      selectionState,
      entityKey
    );
  }
};

var DraftModifier_1 = DraftModifier;

/**
 * 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.
 *
 *
 */

function makeEmptyFunction(arg) {
  return function() {
    return arg;
  };
}

/**
 * This function accepts and discards inputs; it has no side effects. This is
 * primarily useful idiomatically for overridable function endpoints which
 * always need to be callable, since JS lacks a null-call idiom ala Cocoa.
 */
var emptyFunction = function emptyFunction() {};

emptyFunction.thatReturns = makeEmptyFunction;
emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
emptyFunction.thatReturnsNull = makeEmptyFunction(null);
emptyFunction.thatReturnsThis = function() {
  return this;
};
emptyFunction.thatReturnsArgument = function(arg) {
  return arg;
};

var emptyFunction_1 = emptyFunction;

var List$5 = immutable.List,
  Repeat$3 = immutable.Repeat,
  Record$3 = immutable.Record;

var returnTrue = emptyFunction_1.thatReturnsTrue;

var FINGERPRINT_DELIMITER = "-";

var defaultLeafRange = {
  start: null,
  end: null
};

var LeafRange = Record$3(defaultLeafRange);

var defaultDecoratorRange = {
  start: null,
  end: null,
  decoratorKey: null,
  leaves: null
};

var DecoratorRange = Record$3(defaultDecoratorRange);

var BlockTree = {
  /**
   * Generate a block tree for a given ContentBlock/decorator pair.
   */
  generate: function generate(contentState, block, decorator) {
    var textLength = block.getLength();
    if (!textLength) {
      return List$5.of(
        new DecoratorRange({
          start: 0,
          end: 0,
          decoratorKey: null,
          leaves: List$5.of(new LeafRange({ start: 0, end: 0 }))
        })
      );
    }

    var leafSets = [];
    var decorations = decorator
      ? decorator.getDecorations(block, contentState)
      : List$5(Repeat$3(null, textLength));

    var chars = block.getCharacterList();

    findRangesImmutable_1(decorations, areEqual, returnTrue, function(
      start,
      end
    ) {
      leafSets.push(
        new DecoratorRange({
          start: start,
          end: end,
          decoratorKey: decorations.get(start),
          leaves: generateLeaves(chars.slice(start, end).toList(), start)
        })
      );
    });

    return List$5(leafSets);
  },

  /**
   * Create a string representation of the given tree map. This allows us
   * to rapidly determine whether a tree has undergone a significant
   * structural change.
   */
  getFingerprint: function getFingerprint(tree) {
    return tree
      .map(function(leafSet) {
        var decoratorKey = leafSet.get("decoratorKey");
        var fingerprintString =
          decoratorKey !== null
            ? decoratorKey + "." + (leafSet.get("end") - leafSet.get("start"))
            : "";
        return "" + fingerprintString + "." + leafSet.get("leaves").size;
      })
      .join(FINGERPRINT_DELIMITER);
  }
};

/**
 * Generate LeafRange records for a given character list.
 */
function generateLeaves(characters, offset) {
  var leaves = [];
  var inlineStyles = characters
    .map(function(c) {
      return c.getStyle();
    })
    .toList();
  findRangesImmutable_1(inlineStyles, areEqual, returnTrue, function(
    start,
    end
  ) {
    leaves.push(
      new LeafRange({
        start: start + offset,
        end: end + offset
      })
    );
  });
  return List$5(leaves);
}

function areEqual(a, b) {
  return a === b;
}

var BlockTree_1 = BlockTree;

function _classCallCheck$3(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _possibleConstructorReturn$3(self, call) {
  if (!self) {
    throw new ReferenceError(
      "this hasn't been initialised - super() hasn't been called"
    );
  }
  return call && (typeof call === "object" || typeof call === "function")
    ? call
    : self;
}

function _inherits$3(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError(
      "Super expression must either be null or a function, not " +
        typeof superClass
    );
  }
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass)
    Object.setPrototypeOf
      ? Object.setPrototypeOf(subClass, superClass)
      : (subClass.__proto__ = superClass);
}

var Record$4 = immutable.Record;

var DraftEntityInstanceRecord = Record$4({
  type: "TOKEN",
  mutability: "IMMUTABLE",
  data: Object
});

/**
 * An instance of a document entity, consisting of a `type` and relevant
 * `data`, metadata about the entity.
 *
 * For instance, a "link" entity might provide a URI, and a "mention"
 * entity might provide the mentioned user's ID. These pieces of data
 * may be used when rendering the entity as part of a ContentBlock DOM
 * representation. For a link, the data would be used as an href for
 * the rendered anchor. For a mention, the ID could be used to retrieve
 * a hovercard.
 */

var DraftEntityInstance = (function(_DraftEntityInstanceR) {
  _inherits$3(DraftEntityInstance, _DraftEntityInstanceR);

  function DraftEntityInstance() {
    _classCallCheck$3(this, DraftEntityInstance);

    return _possibleConstructorReturn$3(
      this,
      _DraftEntityInstanceR.apply(this, arguments)
    );
  }

  DraftEntityInstance.prototype.getType = function getType() {
    return this.get("type");
  };

  DraftEntityInstance.prototype.getMutability = function getMutability() {
    return this.get("mutability");
  };

  DraftEntityInstance.prototype.getData = function getData() {
    return this.get("data");
  };

  return DraftEntityInstance;
})(DraftEntityInstanceRecord);

var DraftEntityInstance_1 = DraftEntityInstance;

var _extends =
  objectAssign ||
  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;
  };

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule DraftEntity
 * @format
 *
 */

var Map$7 = immutable.Map;

var instances = Map$7();
var instanceKey = 0;

/**
 * Temporary utility for generating the warnings
 */
function logWarning(oldMethodCall, newMethodCall) {
  console.warn(
    "WARNING: " +
      oldMethodCall +
      ' will be deprecated soon!\nPlease use "' +
      newMethodCall +
      '" instead.'
  );
}

/**
 * A "document entity" is an object containing metadata associated with a
 * piece of text in a ContentBlock.
 *
 * For example, a `link` entity might include a `uri` property. When a
 * ContentBlock is rendered in the browser, text that refers to that link
 * entity may be rendered as an anchor, with the `uri` as the href value.
 *
 * In a ContentBlock, every position in the text may correspond to zero
 * or one entities. This correspondence is tracked using a key string,
 * generated via DraftEntity.create() and used to obtain entity metadata
 * via DraftEntity.get().
 */
var DraftEntity = {
  /**
   * WARNING: This method will be deprecated soon!
   * Please use 'contentState.getLastCreatedEntityKey' instead.
   * ---
   * Get the random key string from whatever entity was last created.
   * We need this to support the new API, as part of transitioning to put Entity
   * storage in contentState.
   */
  getLastCreatedEntityKey: function getLastCreatedEntityKey() {
    logWarning(
      "DraftEntity.getLastCreatedEntityKey",
      "contentState.getLastCreatedEntityKey"
    );
    return DraftEntity.__getLastCreatedEntityKey();
  },

  /**
   * WARNING: This method will be deprecated soon!
   * Please use 'contentState.createEntity' instead.
   * ---
   * Create a DraftEntityInstance and store it for later retrieval.
   *
   * A random key string will be generated and returned. This key may
   * be used to track the entity's usage in a ContentBlock, and for
   * retrieving data about the entity at render time.
   */
  create: function create(type, mutability, data) {
    logWarning("DraftEntity.create", "contentState.createEntity");
    return DraftEntity.__create(type, mutability, data);
  },

  /**
   * WARNING: This method will be deprecated soon!
   * Please use 'contentState.addEntity' instead.
   * ---
   * Add an existing DraftEntityInstance to the DraftEntity map. This is
   * useful when restoring instances from the server.
   */
  add: function add(instance) {
    logWarning("DraftEntity.add", "contentState.addEntity");
    return DraftEntity.__add(instance);
  },

  /**
   * WARNING: This method will be deprecated soon!
   * Please use 'contentState.getEntity' instead.
   * ---
   * Retrieve the entity corresponding to the supplied key string.
   */
  get: function get(key) {
    logWarning("DraftEntity.get", "contentState.getEntity");
    return DraftEntity.__get(key);
  },

  /**
   * WARNING: This method will be deprecated soon!
   * Please use 'contentState.mergeEntityData' instead.
   * ---
   * Entity instances are immutable. If you need to update the data for an
   * instance, this method will merge your data updates and return a new
   * instance.
   */
  mergeData: function mergeData(key, toMerge) {
    logWarning("DraftEntity.mergeData", "contentState.mergeEntityData");
    return DraftEntity.__mergeData(key, toMerge);
  },

  /**
   * WARNING: This method will be deprecated soon!
   * Please use 'contentState.replaceEntityData' instead.
   * ---
   * Completely replace the data for a given instance.
   */
  replaceData: function replaceData(key, newData) {
    logWarning("DraftEntity.replaceData", "contentState.replaceEntityData");
    return DraftEntity.__replaceData(key, newData);
  },

  // ***********************************WARNING******************************
  // --- the above public API will be deprecated in the next version of Draft!
  // The methods below this line are private - don't call them directly.

  /**
   * Get the random key string from whatever entity was last created.
   * We need this to support the new API, as part of transitioning to put Entity
   * storage in contentState.
   */
  __getLastCreatedEntityKey: function __getLastCreatedEntityKey() {
    return "" + instanceKey;
  },

  /**
   * Create a DraftEntityInstance and store it for later retrieval.
   *
   * A random key string will be generated and returned. This key may
   * be used to track the entity's usage in a ContentBlock, and for
   * retrieving data about the entity at render time.
   */
  __create: function __create(type, mutability, data) {
    return DraftEntity.__add(
      new DraftEntityInstance_1({
        type: type,
        mutability: mutability,
        data: data || {}
      })
    );
  },

  /**
   * Add an existing DraftEntityInstance to the DraftEntity map. This is
   * useful when restoring instances from the server.
   */
  __add: function __add(instance) {
    var key = "" + ++instanceKey;
    instances = instances.set(key, instance);
    return key;
  },

  /**
   * Retrieve the entity corresponding to the supplied key string.
   */
  __get: function __get(key) {
    var instance = instances.get(key);
    !!!instance
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(false, "Unknown DraftEntity key: %s.", key)
        : invariant_1(false)
      : void 0;
    return instance;
  },

  /**
   * Entity instances are immutable. If you need to update the data for an
   * instance, this method will merge your data updates and return a new
   * instance.
   */
  __mergeData: function __mergeData(key, toMerge) {
    var instance = DraftEntity.__get(key);
    var newData = _extends({}, instance.getData(), toMerge);
    var newInstance = instance.set("data", newData);
    instances = instances.set(key, newInstance);
    return newInstance;
  },

  /**
   * Completely replace the data for a given instance.
   */
  __replaceData: function __replaceData(key, newData) {
    var instance = DraftEntity.__get(key);
    var newInstance = instance.set("data", newData);
    instances = instances.set(key, newInstance);
    return newInstance;
  }
};

var DraftEntity_1 = DraftEntity;

function _classCallCheck$4(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _possibleConstructorReturn$4(self, call) {
  if (!self) {
    throw new ReferenceError(
      "this hasn't been initialised - super() hasn't been called"
    );
  }
  return call && (typeof call === "object" || typeof call === "function")
    ? call
    : self;
}

function _inherits$4(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError(
      "Super expression must either be null or a function, not " +
        typeof superClass
    );
  }
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass)
    Object.setPrototypeOf
      ? Object.setPrototypeOf(subClass, superClass)
      : (subClass.__proto__ = superClass);
}

var Record$5 = immutable.Record;

var defaultRecord$3 = {
  anchorKey: "",
  anchorOffset: 0,
  focusKey: "",
  focusOffset: 0,
  isBackward: false,
  hasFocus: false
};

var SelectionStateRecord = Record$5(defaultRecord$3);

var SelectionState = (function(_SelectionStateRecord) {
  _inherits$4(SelectionState, _SelectionStateRecord);

  function SelectionState() {
    _classCallCheck$4(this, SelectionState);

    return _possibleConstructorReturn$4(
      this,
      _SelectionStateRecord.apply(this, arguments)
    );
  }

  SelectionState.prototype.serialize = function serialize() {
    return (
      "Anchor: " +
      this.getAnchorKey() +
      ":" +
      this.getAnchorOffset() +
      ", " +
      "Focus: " +
      this.getFocusKey() +
      ":" +
      this.getFocusOffset() +
      ", " +
      "Is Backward: " +
      String(this.getIsBackward()) +
      ", " +
      "Has Focus: " +
      String(this.getHasFocus())
    );
  };

  SelectionState.prototype.getAnchorKey = function getAnchorKey() {
    return this.get("anchorKey");
  };

  SelectionState.prototype.getAnchorOffset = function getAnchorOffset() {
    return this.get("anchorOffset");
  };

  SelectionState.prototype.getFocusKey = function getFocusKey() {
    return this.get("focusKey");
  };

  SelectionState.prototype.getFocusOffset = function getFocusOffset() {
    return this.get("focusOffset");
  };

  SelectionState.prototype.getIsBackward = function getIsBackward() {
    return this.get("isBackward");
  };

  SelectionState.prototype.getHasFocus = function getHasFocus() {
    return this.get("hasFocus");
  };

  /**
   * Return whether the specified range overlaps with an edge of the
   * SelectionState.
   */

  SelectionState.prototype.hasEdgeWithin = function hasEdgeWithin(
    blockKey,
    start,
    end
  ) {
    var anchorKey = this.getAnchorKey();
    var focusKey = this.getFocusKey();

    if (anchorKey === focusKey && anchorKey === blockKey) {
      var selectionStart = this.getStartOffset();
      var selectionEnd = this.getEndOffset();
      return start <= selectionEnd && selectionStart <= end;
    }

    if (blockKey !== anchorKey && blockKey !== focusKey) {
      return false;
    }

    var offsetToCheck =
      blockKey === anchorKey ? this.getAnchorOffset() : this.getFocusOffset();

    return start <= offsetToCheck && end >= offsetToCheck;
  };

  SelectionState.prototype.isCollapsed = function isCollapsed() {
    return (
      this.getAnchorKey() === this.getFocusKey() &&
      this.getAnchorOffset() === this.getFocusOffset()
    );
  };

  SelectionState.prototype.getStartKey = function getStartKey() {
    return this.getIsBackward() ? this.getFocusKey() : this.getAnchorKey();
  };

  SelectionState.prototype.getStartOffset = function getStartOffset() {
    return this.getIsBackward()
      ? this.getFocusOffset()
      : this.getAnchorOffset();
  };

  SelectionState.prototype.getEndKey = function getEndKey() {
    return this.getIsBackward() ? this.getAnchorKey() : this.getFocusKey();
  };

  SelectionState.prototype.getEndOffset = function getEndOffset() {
    return this.getIsBackward()
      ? this.getAnchorOffset()
      : this.getFocusOffset();
  };

  SelectionState.createEmpty = function createEmpty(key) {
    return new SelectionState({
      anchorKey: key,
      anchorOffset: 0,
      focusKey: key,
      focusOffset: 0,
      isBackward: false,
      hasFocus: false
    });
  };

  return SelectionState;
})(SelectionStateRecord);

var SelectionState_1 = SelectionState;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule sanitizeDraftText
 * @format
 *
 */

var REGEX_BLOCK_DELIMITER = new RegExp("\r", "g");

function sanitizeDraftText(input) {
  return input.replace(REGEX_BLOCK_DELIMITER, "");
}

var sanitizeDraftText_1 = sanitizeDraftText;

function _classCallCheck$5(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _possibleConstructorReturn$5(self, call) {
  if (!self) {
    throw new ReferenceError(
      "this hasn't been initialised - super() hasn't been called"
    );
  }
  return call && (typeof call === "object" || typeof call === "function")
    ? call
    : self;
}

function _inherits$5(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError(
      "Super expression must either be null or a function, not " +
        typeof superClass
    );
  }
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass)
    Object.setPrototypeOf
      ? Object.setPrototypeOf(subClass, superClass)
      : (subClass.__proto__ = superClass);
}

var List$6 = immutable.List,
  Record$6 = immutable.Record,
  Repeat$4 = immutable.Repeat;

var defaultRecord$4 = {
  entityMap: null,
  blockMap: null,
  selectionBefore: null,
  selectionAfter: null
};

var ContentBlockNodeRecord = ContentBlock_1;

var ContentStateRecord = Record$6(defaultRecord$4);

var ContentState = (function(_ContentStateRecord) {
  _inherits$5(ContentState, _ContentStateRecord);

  function ContentState() {
    _classCallCheck$5(this, ContentState);

    return _possibleConstructorReturn$5(
      this,
      _ContentStateRecord.apply(this, arguments)
    );
  }

  ContentState.prototype.getEntityMap = function getEntityMap() {
    // TODO: update this when we fully remove DraftEntity
    return DraftEntity_1;
  };

  ContentState.prototype.getBlockMap = function getBlockMap() {
    return this.get("blockMap");
  };

  ContentState.prototype.getSelectionBefore = function getSelectionBefore() {
    return this.get("selectionBefore");
  };

  ContentState.prototype.getSelectionAfter = function getSelectionAfter() {
    return this.get("selectionAfter");
  };

  ContentState.prototype.getBlockForKey = function getBlockForKey(key) {
    var block = this.getBlockMap().get(key);
    return block;
  };

  ContentState.prototype.getKeyBefore = function getKeyBefore(key) {
    return this.getBlockMap()
      .reverse()
      .keySeq()
      .skipUntil(function(v) {
        return v === key;
      })
      .skip(1)
      .first();
  };

  ContentState.prototype.getKeyAfter = function getKeyAfter(key) {
    return this.getBlockMap()
      .keySeq()
      .skipUntil(function(v) {
        return v === key;
      })
      .skip(1)
      .first();
  };

  ContentState.prototype.getBlockAfter = function getBlockAfter(key) {
    return this.getBlockMap()
      .skipUntil(function(_, k) {
        return k === key;
      })
      .skip(1)
      .first();
  };

  ContentState.prototype.getBlockBefore = function getBlockBefore(key) {
    return this.getBlockMap()
      .reverse()
      .skipUntil(function(_, k) {
        return k === key;
      })
      .skip(1)
      .first();
  };

  ContentState.prototype.getBlocksAsArray = function getBlocksAsArray() {
    return this.getBlockMap().toArray();
  };

  ContentState.prototype.getFirstBlock = function getFirstBlock() {
    return this.getBlockMap().first();
  };

  ContentState.prototype.getLastBlock = function getLastBlock() {
    return this.getBlockMap().last();
  };

  ContentState.prototype.getPlainText = function getPlainText(delimiter) {
    return this.getBlockMap()
      .map(function(block) {
        return block ? block.getText() : "";
      })
      .join(delimiter || "\n");
  };

  ContentState.prototype.getLastCreatedEntityKey = function getLastCreatedEntityKey() {
    // TODO: update this when we fully remove DraftEntity
    return DraftEntity_1.__getLastCreatedEntityKey();
  };

  ContentState.prototype.hasText = function hasText() {
    var blockMap = this.getBlockMap();
    return blockMap.size > 1 || blockMap.first().getLength() > 0;
  };

  ContentState.prototype.createEntity = function createEntity(
    type,
    mutability,
    data
  ) {
    // TODO: update this when we fully remove DraftEntity
    DraftEntity_1.__create(type, mutability, data);
    return this;
  };

  ContentState.prototype.mergeEntityData = function mergeEntityData(
    key,
    toMerge
  ) {
    // TODO: update this when we fully remove DraftEntity
    DraftEntity_1.__mergeData(key, toMerge);
    return this;
  };

  ContentState.prototype.replaceEntityData = function replaceEntityData(
    key,
    newData
  ) {
    // TODO: update this when we fully remove DraftEntity
    DraftEntity_1.__replaceData(key, newData);
    return this;
  };

  ContentState.prototype.addEntity = function addEntity(instance) {
    // TODO: update this when we fully remove DraftEntity
    DraftEntity_1.__add(instance);
    return this;
  };

  ContentState.prototype.getEntity = function getEntity(key) {
    // TODO: update this when we fully remove DraftEntity
    return DraftEntity_1.__get(key);
  };

  ContentState.createFromBlockArray = function createFromBlockArray(
    // TODO: update flow type when we completely deprecate the old entity API
    blocks,
    entityMap
  ) {
    // TODO: remove this when we completely deprecate the old entity API
    var theBlocks = Array.isArray(blocks) ? blocks : blocks.contentBlocks;
    var blockMap = BlockMapBuilder_1.createFromArray(theBlocks);
    var selectionState = blockMap.isEmpty()
      ? new SelectionState_1()
      : SelectionState_1.createEmpty(blockMap.first().getKey());
    return new ContentState({
      blockMap: blockMap,
      entityMap: entityMap || DraftEntity_1,
      selectionBefore: selectionState,
      selectionAfter: selectionState
    });
  };

  ContentState.createFromText = function createFromText(text) {
    var delimiter =
      arguments.length > 1 && arguments[1] !== undefined
        ? arguments[1]
        : /\r\n?|\n/g;

    var strings = text.split(delimiter);
    var blocks = strings.map(function(block) {
      block = sanitizeDraftText_1(block);
      return new ContentBlockNodeRecord({
        key: generateRandomKey_1(),
        text: block,
        type: "unstyled",
        characterList: List$6(Repeat$4(CharacterMetadata_1.EMPTY, block.length))
      });
    });
    return ContentState.createFromBlockArray(blocks);
  };

  return ContentState;
})(ContentStateRecord);

var ContentState_1 = ContentState;

var NEUTRAL = "NEUTRAL"; // No strong direction
var LTR = "LTR"; // Left-to-Right direction
var RTL = "RTL"; // Right-to-Left direction

var globalDir = null;

// == Helpers ==

/**
 * Check if a directionality value is a Strong one
 */
function isStrong(dir) {
  return dir === LTR || dir === RTL;
}

/**
 * Get string value to be used for `dir` HTML attribute or `direction` CSS
 * property.
 */
function getHTMLDir(dir) {
  !isStrong(dir)
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(
          false,
          "`dir` must be a strong direction to be converted to HTML Direction"
        )
      : invariant_1(false)
    : void 0;
  return dir === LTR ? "ltr" : "rtl";
}

/**
 * Get string value to be used for `dir` HTML attribute or `direction` CSS
 * property, but returns null if `dir` has same value as `otherDir`.
 * `null`.
 */
function getHTMLDirIfDifferent(dir, otherDir) {
  !isStrong(dir)
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(
          false,
          "`dir` must be a strong direction to be converted to HTML Direction"
        )
      : invariant_1(false)
    : void 0;
  !isStrong(otherDir)
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(
          false,
          "`otherDir` must be a strong direction to be converted to HTML Direction"
        )
      : invariant_1(false)
    : void 0;
  return dir === otherDir ? null : getHTMLDir(dir);
}

// == Global Direction ==

/**
 * Set the global direction.
 */
function setGlobalDir(dir) {
  globalDir = dir;
}

/**
 * Initialize the global direction
 */
function initGlobalDir() {
  setGlobalDir(LTR);
}

/**
 * Get the global direction
 */
function getGlobalDir() {
  if (!globalDir) {
    this.initGlobalDir();
  }
  !globalDir
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "Global direction not set.")
      : invariant_1(false)
    : void 0;
  return globalDir;
}

var UnicodeBidiDirection = {
  // Values
  NEUTRAL: NEUTRAL,
  LTR: LTR,
  RTL: RTL,
  // Helpers
  isStrong: isStrong,
  getHTMLDir: getHTMLDir,
  getHTMLDirIfDifferent: getHTMLDirIfDifferent,
  // Global Direction
  setGlobalDir: setGlobalDir,
  initGlobalDir: initGlobalDir,
  getGlobalDir: getGlobalDir
};

var UnicodeBidiDirection_1 = UnicodeBidiDirection;

/**
 * RegExp ranges of characters with a *Strong* Bidi_Class value.
 *
 * Data is based on DerivedBidiClass.txt in UCD version 7.0.0.
 *
 * NOTE: For performance reasons, we only support Unicode's
 *       Basic Multilingual Plane (BMP) for now.
 */
var RANGE_BY_BIDI_TYPE = {
  L:
    "A-Za-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u01BA\u01BB" +
    "\u01BC-\u01BF\u01C0-\u01C3\u01C4-\u0293\u0294\u0295-\u02AF\u02B0-\u02B8" +
    "\u02BB-\u02C1\u02D0-\u02D1\u02E0-\u02E4\u02EE\u0370-\u0373\u0376-\u0377" +
    "\u037A\u037B-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1" +
    "\u03A3-\u03F5\u03F7-\u0481\u0482\u048A-\u052F\u0531-\u0556\u0559" +
    "\u055A-\u055F\u0561-\u0587\u0589\u0903\u0904-\u0939\u093B\u093D" +
    "\u093E-\u0940\u0949-\u094C\u094E-\u094F\u0950\u0958-\u0961\u0964-\u0965" +
    "\u0966-\u096F\u0970\u0971\u0972-\u0980\u0982-\u0983\u0985-\u098C" +
    "\u098F-\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD" +
    "\u09BE-\u09C0\u09C7-\u09C8\u09CB-\u09CC\u09CE\u09D7\u09DC-\u09DD" +
    "\u09DF-\u09E1\u09E6-\u09EF\u09F0-\u09F1\u09F4-\u09F9\u09FA\u0A03" +
    "\u0A05-\u0A0A\u0A0F-\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32-\u0A33" +
    "\u0A35-\u0A36\u0A38-\u0A39\u0A3E-\u0A40\u0A59-\u0A5C\u0A5E\u0A66-\u0A6F" +
    "\u0A72-\u0A74\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0" +
    "\u0AB2-\u0AB3\u0AB5-\u0AB9\u0ABD\u0ABE-\u0AC0\u0AC9\u0ACB-\u0ACC\u0AD0" +
    "\u0AE0-\u0AE1\u0AE6-\u0AEF\u0AF0\u0B02-\u0B03\u0B05-\u0B0C\u0B0F-\u0B10" +
    "\u0B13-\u0B28\u0B2A-\u0B30\u0B32-\u0B33\u0B35-\u0B39\u0B3D\u0B3E\u0B40" +
    "\u0B47-\u0B48\u0B4B-\u0B4C\u0B57\u0B5C-\u0B5D\u0B5F-\u0B61\u0B66-\u0B6F" +
    "\u0B70\u0B71\u0B72-\u0B77\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95" +
    "\u0B99-\u0B9A\u0B9C\u0B9E-\u0B9F\u0BA3-\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9" +
    "\u0BBE-\u0BBF\u0BC1-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCC\u0BD0\u0BD7" +
    "\u0BE6-\u0BEF\u0BF0-\u0BF2\u0C01-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10" +
    "\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C41-\u0C44\u0C58-\u0C59\u0C60-\u0C61" +
    "\u0C66-\u0C6F\u0C7F\u0C82-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8" +
    "\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CBE\u0CBF\u0CC0-\u0CC4\u0CC6" +
    "\u0CC7-\u0CC8\u0CCA-\u0CCB\u0CD5-\u0CD6\u0CDE\u0CE0-\u0CE1\u0CE6-\u0CEF" +
    "\u0CF1-\u0CF2\u0D02-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D" +
    "\u0D3E-\u0D40\u0D46-\u0D48\u0D4A-\u0D4C\u0D4E\u0D57\u0D60-\u0D61" +
    "\u0D66-\u0D6F\u0D70-\u0D75\u0D79\u0D7A-\u0D7F\u0D82-\u0D83\u0D85-\u0D96" +
    "\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCF-\u0DD1\u0DD8-\u0DDF" +
    "\u0DE6-\u0DEF\u0DF2-\u0DF3\u0DF4\u0E01-\u0E30\u0E32-\u0E33\u0E40-\u0E45" +
    "\u0E46\u0E4F\u0E50-\u0E59\u0E5A-\u0E5B\u0E81-\u0E82\u0E84\u0E87-\u0E88" +
    "\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7" +
    "\u0EAA-\u0EAB\u0EAD-\u0EB0\u0EB2-\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6" +
    "\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F01-\u0F03\u0F04-\u0F12\u0F13\u0F14" +
    "\u0F15-\u0F17\u0F1A-\u0F1F\u0F20-\u0F29\u0F2A-\u0F33\u0F34\u0F36\u0F38" +
    "\u0F3E-\u0F3F\u0F40-\u0F47\u0F49-\u0F6C\u0F7F\u0F85\u0F88-\u0F8C" +
    "\u0FBE-\u0FC5\u0FC7-\u0FCC\u0FCE-\u0FCF\u0FD0-\u0FD4\u0FD5-\u0FD8" +
    "\u0FD9-\u0FDA\u1000-\u102A\u102B-\u102C\u1031\u1038\u103B-\u103C\u103F" +
    "\u1040-\u1049\u104A-\u104F\u1050-\u1055\u1056-\u1057\u105A-\u105D\u1061" +
    "\u1062-\u1064\u1065-\u1066\u1067-\u106D\u106E-\u1070\u1075-\u1081" +
    "\u1083-\u1084\u1087-\u108C\u108E\u108F\u1090-\u1099\u109A-\u109C" +
    "\u109E-\u109F\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FB\u10FC" +
    "\u10FD-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288" +
    "\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5" +
    "\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1360-\u1368" +
    "\u1369-\u137C\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166D-\u166E" +
    "\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EB-\u16ED\u16EE-\u16F0" +
    "\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1735-\u1736" +
    "\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17B6\u17BE-\u17C5" +
    "\u17C7-\u17C8\u17D4-\u17D6\u17D7\u17D8-\u17DA\u17DC\u17E0-\u17E9" +
    "\u1810-\u1819\u1820-\u1842\u1843\u1844-\u1877\u1880-\u18A8\u18AA" +
    "\u18B0-\u18F5\u1900-\u191E\u1923-\u1926\u1929-\u192B\u1930-\u1931" +
    "\u1933-\u1938\u1946-\u194F\u1950-\u196D\u1970-\u1974\u1980-\u19AB" +
    "\u19B0-\u19C0\u19C1-\u19C7\u19C8-\u19C9\u19D0-\u19D9\u19DA\u1A00-\u1A16" +
    "\u1A19-\u1A1A\u1A1E-\u1A1F\u1A20-\u1A54\u1A55\u1A57\u1A61\u1A63-\u1A64" +
    "\u1A6D-\u1A72\u1A80-\u1A89\u1A90-\u1A99\u1AA0-\u1AA6\u1AA7\u1AA8-\u1AAD" +
    "\u1B04\u1B05-\u1B33\u1B35\u1B3B\u1B3D-\u1B41\u1B43-\u1B44\u1B45-\u1B4B" +
    "\u1B50-\u1B59\u1B5A-\u1B60\u1B61-\u1B6A\u1B74-\u1B7C\u1B82\u1B83-\u1BA0" +
    "\u1BA1\u1BA6-\u1BA7\u1BAA\u1BAE-\u1BAF\u1BB0-\u1BB9\u1BBA-\u1BE5\u1BE7" +
    "\u1BEA-\u1BEC\u1BEE\u1BF2-\u1BF3\u1BFC-\u1BFF\u1C00-\u1C23\u1C24-\u1C2B" +
    "\u1C34-\u1C35\u1C3B-\u1C3F\u1C40-\u1C49\u1C4D-\u1C4F\u1C50-\u1C59" +
    "\u1C5A-\u1C77\u1C78-\u1C7D\u1C7E-\u1C7F\u1CC0-\u1CC7\u1CD3\u1CE1" +
    "\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF2-\u1CF3\u1CF5-\u1CF6\u1D00-\u1D2B" +
    "\u1D2C-\u1D6A\u1D6B-\u1D77\u1D78\u1D79-\u1D9A\u1D9B-\u1DBF\u1E00-\u1F15" +
    "\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D" +
    "\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC" +
    "\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200E" +
    "\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D" +
    "\u2124\u2126\u2128\u212A-\u212D\u212F-\u2134\u2135-\u2138\u2139" +
    "\u213C-\u213F\u2145-\u2149\u214E\u214F\u2160-\u2182\u2183-\u2184" +
    "\u2185-\u2188\u2336-\u237A\u2395\u249C-\u24E9\u26AC\u2800-\u28FF" +
    "\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2C7B\u2C7C-\u2C7D\u2C7E-\u2CE4" +
    "\u2CEB-\u2CEE\u2CF2-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F" +
    "\u2D70\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE" +
    "\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005\u3006\u3007" +
    "\u3021-\u3029\u302E-\u302F\u3031-\u3035\u3038-\u303A\u303B\u303C" +
    "\u3041-\u3096\u309D-\u309E\u309F\u30A1-\u30FA\u30FC-\u30FE\u30FF" +
    "\u3105-\u312D\u3131-\u318E\u3190-\u3191\u3192-\u3195\u3196-\u319F" +
    "\u31A0-\u31BA\u31F0-\u31FF\u3200-\u321C\u3220-\u3229\u322A-\u3247" +
    "\u3248-\u324F\u3260-\u327B\u327F\u3280-\u3289\u328A-\u32B0\u32C0-\u32CB" +
    "\u32D0-\u32FE\u3300-\u3376\u337B-\u33DD\u33E0-\u33FE\u3400-\u4DB5" +
    "\u4E00-\u9FCC\uA000-\uA014\uA015\uA016-\uA48C\uA4D0-\uA4F7\uA4F8-\uA4FD" +
    "\uA4FE-\uA4FF\uA500-\uA60B\uA60C\uA610-\uA61F\uA620-\uA629\uA62A-\uA62B" +
    "\uA640-\uA66D\uA66E\uA680-\uA69B\uA69C-\uA69D\uA6A0-\uA6E5\uA6E6-\uA6EF" +
    "\uA6F2-\uA6F7\uA722-\uA76F\uA770\uA771-\uA787\uA789-\uA78A\uA78B-\uA78E" +
    "\uA790-\uA7AD\uA7B0-\uA7B1\uA7F7\uA7F8-\uA7F9\uA7FA\uA7FB-\uA801" +
    "\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA823-\uA824\uA827\uA830-\uA835" +
    "\uA836-\uA837\uA840-\uA873\uA880-\uA881\uA882-\uA8B3\uA8B4-\uA8C3" +
    "\uA8CE-\uA8CF\uA8D0-\uA8D9\uA8F2-\uA8F7\uA8F8-\uA8FA\uA8FB\uA900-\uA909" +
    "\uA90A-\uA925\uA92E-\uA92F\uA930-\uA946\uA952-\uA953\uA95F\uA960-\uA97C" +
    "\uA983\uA984-\uA9B2\uA9B4-\uA9B5\uA9BA-\uA9BB\uA9BD-\uA9C0\uA9C1-\uA9CD" +
    "\uA9CF\uA9D0-\uA9D9\uA9DE-\uA9DF\uA9E0-\uA9E4\uA9E6\uA9E7-\uA9EF" +
    "\uA9F0-\uA9F9\uA9FA-\uA9FE\uAA00-\uAA28\uAA2F-\uAA30\uAA33-\uAA34" +
    "\uAA40-\uAA42\uAA44-\uAA4B\uAA4D\uAA50-\uAA59\uAA5C-\uAA5F\uAA60-\uAA6F" +
    "\uAA70\uAA71-\uAA76\uAA77-\uAA79\uAA7A\uAA7B\uAA7D\uAA7E-\uAAAF\uAAB1" +
    "\uAAB5-\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADC\uAADD\uAADE-\uAADF" +
    "\uAAE0-\uAAEA\uAAEB\uAAEE-\uAAEF\uAAF0-\uAAF1\uAAF2\uAAF3-\uAAF4\uAAF5" +
    "\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E" +
    "\uAB30-\uAB5A\uAB5B\uAB5C-\uAB5F\uAB64-\uAB65\uABC0-\uABE2\uABE3-\uABE4" +
    "\uABE6-\uABE7\uABE9-\uABEA\uABEB\uABEC\uABF0-\uABF9\uAC00-\uD7A3" +
    "\uD7B0-\uD7C6\uD7CB-\uD7FB\uE000-\uF8FF\uF900-\uFA6D\uFA70-\uFAD9" +
    "\uFB00-\uFB06\uFB13-\uFB17\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFF6F\uFF70" +
    "\uFF71-\uFF9D\uFF9E-\uFF9F\uFFA0-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF" +
    "\uFFD2-\uFFD7\uFFDA-\uFFDC",

  R:
    "\u0590\u05BE\u05C0\u05C3\u05C6\u05C8-\u05CF\u05D0-\u05EA\u05EB-\u05EF" +
    "\u05F0-\u05F2\u05F3-\u05F4\u05F5-\u05FF\u07C0-\u07C9\u07CA-\u07EA" +
    "\u07F4-\u07F5\u07FA\u07FB-\u07FF\u0800-\u0815\u081A\u0824\u0828" +
    "\u082E-\u082F\u0830-\u083E\u083F\u0840-\u0858\u085C-\u085D\u085E" +
    "\u085F-\u089F\u200F\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB37\uFB38-\uFB3C" +
    "\uFB3D\uFB3E\uFB3F\uFB40-\uFB41\uFB42\uFB43-\uFB44\uFB45\uFB46-\uFB4F",

  AL:
    "\u0608\u060B\u060D\u061B\u061C\u061D\u061E-\u061F\u0620-\u063F\u0640" +
    "\u0641-\u064A\u066D\u066E-\u066F\u0671-\u06D3\u06D4\u06D5\u06E5-\u06E6" +
    "\u06EE-\u06EF\u06FA-\u06FC\u06FD-\u06FE\u06FF\u0700-\u070D\u070E\u070F" +
    "\u0710\u0712-\u072F\u074B-\u074C\u074D-\u07A5\u07B1\u07B2-\u07BF" +
    "\u08A0-\u08B2\u08B3-\u08E3\uFB50-\uFBB1\uFBB2-\uFBC1\uFBC2-\uFBD2" +
    "\uFBD3-\uFD3D\uFD40-\uFD4F\uFD50-\uFD8F\uFD90-\uFD91\uFD92-\uFDC7" +
    "\uFDC8-\uFDCF\uFDF0-\uFDFB\uFDFC\uFDFE-\uFDFF\uFE70-\uFE74\uFE75" +
    "\uFE76-\uFEFC\uFEFD-\uFEFE"
};

var REGEX_STRONG = new RegExp(
  "[" +
    RANGE_BY_BIDI_TYPE.L +
    RANGE_BY_BIDI_TYPE.R +
    RANGE_BY_BIDI_TYPE.AL +
    "]"
);

var REGEX_RTL = new RegExp(
  "[" + RANGE_BY_BIDI_TYPE.R + RANGE_BY_BIDI_TYPE.AL + "]"
);

/**
 * Returns the first strong character (has Bidi_Class value of L, R, or AL).
 *
 * @param str  A text block; e.g. paragraph, table cell, tag
 * @return     A character with strong bidi direction, or null if not found
 */
function firstStrongChar(str) {
  var match = REGEX_STRONG.exec(str);
  return match == null ? null : match[0];
}

/**
 * Returns the direction of a block of text, based on the direction of its
 * first strong character (has Bidi_Class value of L, R, or AL).
 *
 * @param str  A text block; e.g. paragraph, table cell, tag
 * @return     The resolved direction
 */
function firstStrongCharDir(str) {
  var strongChar = firstStrongChar(str);
  if (strongChar == null) {
    return UnicodeBidiDirection_1.NEUTRAL;
  }
  return REGEX_RTL.exec(strongChar)
    ? UnicodeBidiDirection_1.RTL
    : UnicodeBidiDirection_1.LTR;
}

/**
 * Returns the direction of a block of text, based on the direction of its
 * first strong character (has Bidi_Class value of L, R, or AL), or a fallback
 * direction, if no strong character is found.
 *
 * This function is supposed to be used in respect to Higher-Level Protocol
 * rule HL1. (http://www.unicode.org/reports/tr9/#HL1)
 *
 * @param str       A text block; e.g. paragraph, table cell, tag
 * @param fallback  Fallback direction, used if no strong direction detected
 *                  for the block (default = NEUTRAL)
 * @return          The resolved direction
 */
function resolveBlockDir(str, fallback) {
  fallback = fallback || UnicodeBidiDirection_1.NEUTRAL;
  if (!str.length) {
    return fallback;
  }
  var blockDir = firstStrongCharDir(str);
  return blockDir === UnicodeBidiDirection_1.NEUTRAL ? fallback : blockDir;
}

/**
 * Returns the direction of a block of text, based on the direction of its
 * first strong character (has Bidi_Class value of L, R, or AL), or a fallback
 * direction, if no strong character is found.
 *
 * NOTE: This function is similar to resolveBlockDir(), but uses the global
 * direction as the fallback, so it *always* returns a Strong direction,
 * making it useful for integration in places that you need to make the final
 * decision, like setting some CSS class.
 *
 * This function is supposed to be used in respect to Higher-Level Protocol
 * rule HL1. (http://www.unicode.org/reports/tr9/#HL1)
 *
 * @param str             A text block; e.g. paragraph, table cell
 * @param strongFallback  Fallback direction, used if no strong direction
 *                        detected for the block (default = global direction)
 * @return                The resolved Strong direction
 */
function getDirection(str, strongFallback) {
  if (!strongFallback) {
    strongFallback = UnicodeBidiDirection_1.getGlobalDir();
  }
  !UnicodeBidiDirection_1.isStrong(strongFallback)
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "Fallback direction must be a strong direction")
      : invariant_1(false)
    : void 0;
  return resolveBlockDir(str, strongFallback);
}

/**
 * Returns true if getDirection(arguments...) returns LTR.
 *
 * @param str             A text block; e.g. paragraph, table cell
 * @param strongFallback  Fallback direction, used if no strong direction
 *                        detected for the block (default = global direction)
 * @return                True if the resolved direction is LTR
 */
function isDirectionLTR(str, strongFallback) {
  return getDirection(str, strongFallback) === UnicodeBidiDirection_1.LTR;
}

/**
 * Returns true if getDirection(arguments...) returns RTL.
 *
 * @param str             A text block; e.g. paragraph, table cell
 * @param strongFallback  Fallback direction, used if no strong direction
 *                        detected for the block (default = global direction)
 * @return                True if the resolved direction is RTL
 */
function isDirectionRTL(str, strongFallback) {
  return getDirection(str, strongFallback) === UnicodeBidiDirection_1.RTL;
}

var UnicodeBidi = {
  firstStrongChar: firstStrongChar,
  firstStrongCharDir: firstStrongCharDir,
  resolveBlockDir: resolveBlockDir,
  getDirection: getDirection,
  isDirectionLTR: isDirectionLTR,
  isDirectionRTL: isDirectionRTL
};

var UnicodeBidi_1 = UnicodeBidi;

function _classCallCheck$6(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

var UnicodeBidiService = (function() {
  /**
   * Stateful class for paragraph direction detection
   *
   * @param defaultDir  Default direction of the service
   */
  function UnicodeBidiService(defaultDir) {
    _classCallCheck$6(this, UnicodeBidiService);

    if (!defaultDir) {
      defaultDir = UnicodeBidiDirection_1.getGlobalDir();
    } else {
      !UnicodeBidiDirection_1.isStrong(defaultDir)
        ? process.env.NODE_ENV !== "production"
          ? invariant_1(
              false,
              "Default direction must be a strong direction (LTR or RTL)"
            )
          : invariant_1(false)
        : void 0;
    }
    this._defaultDir = defaultDir;
    this.reset();
  }

  /**
   * Reset the internal state
   *
   * Instead of creating a new instance, you can just reset() your instance
   * everytime you start a new loop.
   */

  UnicodeBidiService.prototype.reset = function reset() {
    this._lastDir = this._defaultDir;
  };

  /**
   * Returns the direction of a block of text, and remembers it as the
   * fall-back direction for the next paragraph.
   *
   * @param str  A text block, e.g. paragraph, table cell, tag
   * @return     The resolved direction
   */

  UnicodeBidiService.prototype.getDirection = function getDirection(str) {
    this._lastDir = UnicodeBidi_1.getDirection(str, this._lastDir);
    return this._lastDir;
  };

  return UnicodeBidiService;
})();

var UnicodeBidiService_1 = UnicodeBidiService;

/**
 * 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.
 *
 *
 */

var nullthrows = function nullthrows(x) {
  if (x != null) {
    return x;
  }
  throw new Error("Got unexpected null or undefined");
};

var nullthrows_1 = nullthrows;

var OrderedMap$2 = immutable.OrderedMap;

var bidiService;

var EditorBidiService = {
  getDirectionMap: function getDirectionMap(content, prevBidiMap) {
    if (!bidiService) {
      bidiService = new UnicodeBidiService_1();
    } else {
      bidiService.reset();
    }

    var blockMap = content.getBlockMap();
    var nextBidi = blockMap.valueSeq().map(function(block) {
      return nullthrows_1(bidiService).getDirection(block.getText());
    });
    var bidiMap = OrderedMap$2(blockMap.keySeq().zip(nextBidi));

    if (prevBidiMap != null && immutable.is(prevBidiMap, bidiMap)) {
      return prevBidiMap;
    }

    return bidiMap;
  }
};

var EditorBidiService_1 = EditorBidiService;

var _extends$1 =
  objectAssign ||
  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;
  };

function _classCallCheck$7(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

var OrderedSet$4 = immutable.OrderedSet,
  Record$7 = immutable.Record,
  Stack = immutable.Stack;

var defaultRecord$5 = {
  allowUndo: true,
  currentContent: null,
  decorator: null,
  directionMap: null,
  forceSelection: false,
  inCompositionMode: false,
  inlineStyleOverride: null,
  lastChangeType: null,
  nativelyRenderedContent: null,
  redoStack: Stack(),
  selection: null,
  treeMap: null,
  undoStack: Stack()
};

var EditorStateRecord = Record$7(defaultRecord$5);

var EditorState = (function() {
  EditorState.createEmpty = function createEmpty(decorator) {
    return EditorState.createWithContent(
      ContentState_1.createFromText(""),
      decorator
    );
  };

  EditorState.createWithContent = function createWithContent(
    contentState,
    decorator
  ) {
    var firstKey = contentState
      .getBlockMap()
      .first()
      .getKey();
    return EditorState.create({
      currentContent: contentState,
      undoStack: Stack(),
      redoStack: Stack(),
      decorator: decorator || null,
      selection: SelectionState_1.createEmpty(firstKey)
    });
  };

  EditorState.create = function create(config) {
    var currentContent = config.currentContent,
      decorator = config.decorator;

    var recordConfig = _extends$1({}, config, {
      treeMap: generateNewTreeMap(currentContent, decorator),
      directionMap: EditorBidiService_1.getDirectionMap(currentContent)
    });
    return new EditorState(new EditorStateRecord(recordConfig));
  };

  EditorState.set = function set(editorState, put) {
    var map = editorState.getImmutable().withMutations(function(state) {
      var existingDecorator = state.get("decorator");
      var decorator = existingDecorator;
      if (put.decorator === null) {
        decorator = null;
      } else if (put.decorator) {
        decorator = put.decorator;
      }

      var newContent = put.currentContent || editorState.getCurrentContent();

      if (decorator !== existingDecorator) {
        var treeMap = state.get("treeMap");
        var newTreeMap;
        if (decorator && existingDecorator) {
          newTreeMap = regenerateTreeForNewDecorator(
            newContent,
            newContent.getBlockMap(),
            treeMap,
            decorator,
            existingDecorator
          );
        } else {
          newTreeMap = generateNewTreeMap(newContent, decorator);
        }

        state.merge({
          decorator: decorator,
          treeMap: newTreeMap,
          nativelyRenderedContent: null
        });
        return;
      }

      var existingContent = editorState.getCurrentContent();
      if (newContent !== existingContent) {
        state.set(
          "treeMap",
          regenerateTreeForNewBlocks(
            editorState,
            newContent.getBlockMap(),
            newContent.getEntityMap(),
            decorator
          )
        );
      }

      state.merge(put);
    });

    return new EditorState(map);
  };

  EditorState.prototype.toJS = function toJS() {
    return this.getImmutable().toJS();
  };

  EditorState.prototype.getAllowUndo = function getAllowUndo() {
    return this.getImmutable().get("allowUndo");
  };

  EditorState.prototype.getCurrentContent = function getCurrentContent() {
    return this.getImmutable().get("currentContent");
  };

  EditorState.prototype.getUndoStack = function getUndoStack() {
    return this.getImmutable().get("undoStack");
  };

  EditorState.prototype.getRedoStack = function getRedoStack() {
    return this.getImmutable().get("redoStack");
  };

  EditorState.prototype.getSelection = function getSelection() {
    return this.getImmutable().get("selection");
  };

  EditorState.prototype.getDecorator = function getDecorator() {
    return this.getImmutable().get("decorator");
  };

  EditorState.prototype.isInCompositionMode = function isInCompositionMode() {
    return this.getImmutable().get("inCompositionMode");
  };

  EditorState.prototype.mustForceSelection = function mustForceSelection() {
    return this.getImmutable().get("forceSelection");
  };

  EditorState.prototype.getNativelyRenderedContent = function getNativelyRenderedContent() {
    return this.getImmutable().get("nativelyRenderedContent");
  };

  EditorState.prototype.getLastChangeType = function getLastChangeType() {
    return this.getImmutable().get("lastChangeType");
  };

  /**
   * While editing, the user may apply inline style commands with a collapsed
   * cursor, intending to type text that adopts the specified style. In this
   * case, we track the specified style as an "override" that takes precedence
   * over the inline style of the text adjacent to the cursor.
   *
   * If null, there is no override in place.
   */

  EditorState.prototype.getInlineStyleOverride = function getInlineStyleOverride() {
    return this.getImmutable().get("inlineStyleOverride");
  };

  EditorState.setInlineStyleOverride = function setInlineStyleOverride(
    editorState,
    inlineStyleOverride
  ) {
    return EditorState.set(editorState, {
      inlineStyleOverride: inlineStyleOverride
    });
  };

  /**
   * Get the appropriate inline style for the editor state. If an
   * override is in place, use it. Otherwise, the current style is
   * based on the location of the selection state.
   */

  EditorState.prototype.getCurrentInlineStyle = function getCurrentInlineStyle() {
    var override = this.getInlineStyleOverride();
    if (override != null) {
      return override;
    }

    var content = this.getCurrentContent();
    var selection = this.getSelection();

    if (selection.isCollapsed()) {
      return getInlineStyleForCollapsedSelection(content, selection);
    }

    return getInlineStyleForNonCollapsedSelection(content, selection);
  };

  EditorState.prototype.getBlockTree = function getBlockTree(blockKey) {
    return this.getImmutable().getIn(["treeMap", blockKey]);
  };

  EditorState.prototype.isSelectionAtStartOfContent = function isSelectionAtStartOfContent() {
    var firstKey = this.getCurrentContent()
      .getBlockMap()
      .first()
      .getKey();
    return this.getSelection().hasEdgeWithin(firstKey, 0, 0);
  };

  EditorState.prototype.isSelectionAtEndOfContent = function isSelectionAtEndOfContent() {
    var content = this.getCurrentContent();
    var blockMap = content.getBlockMap();
    var last = blockMap.last();
    var end = last.getLength();
    return this.getSelection().hasEdgeWithin(last.getKey(), end, end);
  };

  EditorState.prototype.getDirectionMap = function getDirectionMap() {
    return this.getImmutable().get("directionMap");
  };

  /**
   * Incorporate native DOM selection changes into the EditorState. This
   * method can be used when we simply want to accept whatever the DOM
   * has given us to represent selection, and we do not need to re-render
   * the editor.
   *
   * To forcibly move the DOM selection, see `EditorState.forceSelection`.
   */

  EditorState.acceptSelection = function acceptSelection(
    editorState,
    selection
  ) {
    return updateSelection(editorState, selection, false);
  };

  /**
   * At times, we need to force the DOM selection to be where we
   * need it to be. This can occur when the anchor or focus nodes
   * are non-text nodes, for instance. In this case, we want to trigger
   * a re-render of the editor, which in turn forces selection into
   * the correct place in the DOM. The `forceSelection` method
   * accomplishes this.
   *
   * This method should be used in cases where you need to explicitly
   * move the DOM selection from one place to another without a change
   * in ContentState.
   */

  EditorState.forceSelection = function forceSelection(editorState, selection) {
    if (!selection.getHasFocus()) {
      selection = selection.set("hasFocus", true);
    }
    return updateSelection(editorState, selection, true);
  };

  /**
   * Move selection to the end of the editor without forcing focus.
   */

  EditorState.moveSelectionToEnd = function moveSelectionToEnd(editorState) {
    var content = editorState.getCurrentContent();
    var lastBlock = content.getLastBlock();
    var lastKey = lastBlock.getKey();
    var length = lastBlock.getLength();

    return EditorState.acceptSelection(
      editorState,
      new SelectionState_1({
        anchorKey: lastKey,
        anchorOffset: length,
        focusKey: lastKey,
        focusOffset: length,
        isBackward: false
      })
    );
  };

  /**
   * Force focus to the end of the editor. This is useful in scenarios
   * where we want to programmatically focus the input and it makes sense
   * to allow the user to continue working seamlessly.
   */

  EditorState.moveFocusToEnd = function moveFocusToEnd(editorState) {
    var afterSelectionMove = EditorState.moveSelectionToEnd(editorState);
    return EditorState.forceSelection(
      afterSelectionMove,
      afterSelectionMove.getSelection()
    );
  };

  /**
   * Push the current ContentState onto the undo stack if it should be
   * considered a boundary state, and set the provided ContentState as the
   * new current content.
   */

  EditorState.push = function push(editorState, contentState, changeType) {
    if (editorState.getCurrentContent() === contentState) {
      return editorState;
    }

    var forceSelection = changeType !== "insert-characters";
    var directionMap = EditorBidiService_1.getDirectionMap(
      contentState,
      editorState.getDirectionMap()
    );

    if (!editorState.getAllowUndo()) {
      return EditorState.set(editorState, {
        currentContent: contentState,
        directionMap: directionMap,
        lastChangeType: changeType,
        selection: contentState.getSelectionAfter(),
        forceSelection: forceSelection,
        inlineStyleOverride: null
      });
    }

    var selection = editorState.getSelection();
    var currentContent = editorState.getCurrentContent();
    var undoStack = editorState.getUndoStack();
    var newContent = contentState;

    if (
      selection !== currentContent.getSelectionAfter() ||
      mustBecomeBoundary(editorState, changeType)
    ) {
      undoStack = undoStack.push(currentContent);
      newContent = newContent.set("selectionBefore", selection);
    } else if (
      changeType === "insert-characters" ||
      changeType === "backspace-character" ||
      changeType === "delete-character"
    ) {
      // Preserve the previous selection.
      newContent = newContent.set(
        "selectionBefore",
        currentContent.getSelectionBefore()
      );
    }

    var inlineStyleOverride = editorState.getInlineStyleOverride();

    // Don't discard inline style overrides for the following change types:
    var overrideChangeTypes = [
      "adjust-depth",
      "change-block-type",
      "split-block"
    ];

    if (overrideChangeTypes.indexOf(changeType) === -1) {
      inlineStyleOverride = null;
    }

    var editorStateChanges = {
      currentContent: newContent,
      directionMap: directionMap,
      undoStack: undoStack,
      redoStack: Stack(),
      lastChangeType: changeType,
      selection: contentState.getSelectionAfter(),
      forceSelection: forceSelection,
      inlineStyleOverride: inlineStyleOverride
    };

    return EditorState.set(editorState, editorStateChanges);
  };

  /**
   * Make the top ContentState in the undo stack the new current content and
   * push the current content onto the redo stack.
   */

  EditorState.undo = function undo(editorState) {
    if (!editorState.getAllowUndo()) {
      return editorState;
    }

    var undoStack = editorState.getUndoStack();
    var newCurrentContent = undoStack.peek();
    if (!newCurrentContent) {
      return editorState;
    }

    var currentContent = editorState.getCurrentContent();
    var directionMap = EditorBidiService_1.getDirectionMap(
      newCurrentContent,
      editorState.getDirectionMap()
    );

    return EditorState.set(editorState, {
      currentContent: newCurrentContent,
      directionMap: directionMap,
      undoStack: undoStack.shift(),
      redoStack: editorState.getRedoStack().push(currentContent),
      forceSelection: true,
      inlineStyleOverride: null,
      lastChangeType: "undo",
      nativelyRenderedContent: null,
      selection: currentContent.getSelectionBefore()
    });
  };

  /**
   * Make the top ContentState in the redo stack the new current content and
   * push the current content onto the undo stack.
   */

  EditorState.redo = function redo(editorState) {
    if (!editorState.getAllowUndo()) {
      return editorState;
    }

    var redoStack = editorState.getRedoStack();
    var newCurrentContent = redoStack.peek();
    if (!newCurrentContent) {
      return editorState;
    }

    var currentContent = editorState.getCurrentContent();
    var directionMap = EditorBidiService_1.getDirectionMap(
      newCurrentContent,
      editorState.getDirectionMap()
    );

    return EditorState.set(editorState, {
      currentContent: newCurrentContent,
      directionMap: directionMap,
      undoStack: editorState.getUndoStack().push(currentContent),
      redoStack: redoStack.shift(),
      forceSelection: true,
      inlineStyleOverride: null,
      lastChangeType: "redo",
      nativelyRenderedContent: null,
      selection: newCurrentContent.getSelectionAfter()
    });
  };

  /**
   * Not for public consumption.
   */

  function EditorState(immutable) {
    _classCallCheck$7(this, EditorState);

    this._immutable = immutable;
  }

  /**
   * Not for public consumption.
   */

  EditorState.prototype.getImmutable = function getImmutable() {
    return this._immutable;
  };

  return EditorState;
})();

/**
 * Set the supplied SelectionState as the new current selection, and set
 * the `force` flag to trigger manual selection placement by the view.
 */

function updateSelection(editorState, selection, forceSelection) {
  return EditorState.set(editorState, {
    selection: selection,
    forceSelection: forceSelection,
    nativelyRenderedContent: null,
    inlineStyleOverride: null
  });
}

/**
 * Regenerate the entire tree map for a given ContentState and decorator.
 * Returns an OrderedMap that maps all available ContentBlock objects.
 */
function generateNewTreeMap(contentState, decorator) {
  return contentState
    .getBlockMap()
    .map(function(block) {
      return BlockTree_1.generate(contentState, block, decorator);
    })
    .toOrderedMap();
}

/**
 * Regenerate tree map objects for all ContentBlocks that have changed
 * between the current editorState and newContent. Returns an OrderedMap
 * with only changed regenerated tree map objects.
 */
function regenerateTreeForNewBlocks(
  editorState,
  newBlockMap,
  newEntityMap,
  decorator
) {
  var contentState = editorState
    .getCurrentContent()
    .set("entityMap", newEntityMap);
  var prevBlockMap = contentState.getBlockMap();
  var prevTreeMap = editorState.getImmutable().get("treeMap");
  return prevTreeMap.merge(
    newBlockMap
      .toSeq()
      .filter(function(block, key) {
        return block !== prevBlockMap.get(key);
      })
      .map(function(block) {
        return BlockTree_1.generate(contentState, block, decorator);
      })
  );
}

/**
 * Generate tree map objects for a new decorator object, preserving any
 * decorations that are unchanged from the previous decorator.
 *
 * Note that in order for this to perform optimally, decoration Lists for
 * decorators should be preserved when possible to allow for direct immutable
 * List comparison.
 */
function regenerateTreeForNewDecorator(
  content,
  blockMap,
  previousTreeMap,
  decorator,
  existingDecorator
) {
  return previousTreeMap.merge(
    blockMap
      .toSeq()
      .filter(function(block) {
        return (
          decorator.getDecorations(block, content) !==
          existingDecorator.getDecorations(block, content)
        );
      })
      .map(function(block) {
        return BlockTree_1.generate(content, block, decorator);
      })
  );
}

/**
 * Return whether a change should be considered a boundary state, given
 * the previous change type. Allows us to discard potential boundary states
 * during standard typing or deletion behavior.
 */
function mustBecomeBoundary(editorState, changeType) {
  var lastChangeType = editorState.getLastChangeType();
  return (
    changeType !== lastChangeType ||
    (changeType !== "insert-characters" &&
      changeType !== "backspace-character" &&
      changeType !== "delete-character")
  );
}

function getInlineStyleForCollapsedSelection(content, selection) {
  var startKey = selection.getStartKey();
  var startOffset = selection.getStartOffset();
  var startBlock = content.getBlockForKey(startKey);

  // If the cursor is not at the start of the block, look backward to
  // preserve the style of the preceding character.
  if (startOffset > 0) {
    return startBlock.getInlineStyleAt(startOffset - 1);
  }

  // The caret is at position zero in this block. If the block has any
  // text at all, use the style of the first character.
  if (startBlock.getLength()) {
    return startBlock.getInlineStyleAt(0);
  }

  // Otherwise, look upward in the document to find the closest character.
  return lookUpwardForInlineStyle(content, startKey);
}

function getInlineStyleForNonCollapsedSelection(content, selection) {
  var startKey = selection.getStartKey();
  var startOffset = selection.getStartOffset();
  var startBlock = content.getBlockForKey(startKey);

  // If there is a character just inside the selection, use its style.
  if (startOffset < startBlock.getLength()) {
    return startBlock.getInlineStyleAt(startOffset);
  }

  // Check if the selection at the end of a non-empty block. Use the last
  // style in the block.
  if (startOffset > 0) {
    return startBlock.getInlineStyleAt(startOffset - 1);
  }

  // Otherwise, look upward in the document to find the closest character.
  return lookUpwardForInlineStyle(content, startKey);
}

function lookUpwardForInlineStyle(content, fromKey) {
  var lastNonEmpty = content
    .getBlockMap()
    .reverse()
    .skipUntil(function(_, k) {
      return k === fromKey;
    })
    .skip(1)
    .skipUntil(function(block, _) {
      return block.getLength();
    })
    .first();

  if (lastNonEmpty)
    return lastNonEmpty.getInlineStyleAt(lastNonEmpty.getLength() - 1);
  return OrderedSet$4();
}

var EditorState_1 = EditorState;

var OrderedMap$3 = immutable.OrderedMap,
  List$7 = immutable.List;

var transformBlock$2 = function transformBlock(key, blockMap, func) {
  if (!key) {
    return;
  }

  var block = blockMap.get(key);

  if (!block) {
    return;
  }

  blockMap.set(key, func(block));
};

var updateBlockMapLinks$3 = function updateBlockMapLinks(
  blockMap,
  originalBlockToBeMoved,
  originalTargetBlock,
  insertionMode,
  isExperimentalTreeBlock
) {
  if (!isExperimentalTreeBlock) {
    return blockMap;
  }
  // possible values of 'insertionMode' are: 'after', 'before'
  var isInsertedAfterTarget = insertionMode === "after";

  var originalBlockKey = originalBlockToBeMoved.getKey();
  var originalTargetKey = originalTargetBlock.getKey();
  var originalParentKey = originalBlockToBeMoved.getParentKey();
  var originalNextSiblingKey = originalBlockToBeMoved.getNextSiblingKey();
  var originalPrevSiblingKey = originalBlockToBeMoved.getPrevSiblingKey();
  var newParentKey = originalTargetBlock.getParentKey();
  var newNextSiblingKey = isInsertedAfterTarget
    ? originalTargetBlock.getNextSiblingKey()
    : originalTargetKey;
  var newPrevSiblingKey = isInsertedAfterTarget
    ? originalTargetKey
    : originalTargetBlock.getPrevSiblingKey();

  return blockMap.withMutations(function(blocks) {
    // update old parent
    transformBlock$2(originalParentKey, blocks, function(block) {
      var parentChildrenList = block.getChildKeys();
      return block.merge({
        children: parentChildrenList["delete"](
          parentChildrenList.indexOf(originalBlockKey)
        )
      });
    });

    // update old prev
    transformBlock$2(originalPrevSiblingKey, blocks, function(block) {
      return block.merge({
        nextSibling: originalNextSiblingKey
      });
    });

    // update old next
    transformBlock$2(originalNextSiblingKey, blocks, function(block) {
      return block.merge({
        prevSibling: originalPrevSiblingKey
      });
    });

    // update new next
    transformBlock$2(newNextSiblingKey, blocks, function(block) {
      return block.merge({
        prevSibling: originalBlockKey
      });
    });

    // update new prev
    transformBlock$2(newPrevSiblingKey, blocks, function(block) {
      return block.merge({
        nextSibling: originalBlockKey
      });
    });

    // update new parent
    transformBlock$2(newParentKey, blocks, function(block) {
      var newParentChildrenList = block.getChildKeys();
      var targetBlockIndex = newParentChildrenList.indexOf(originalTargetKey);

      var insertionIndex = isInsertedAfterTarget
        ? targetBlockIndex + 1
        : targetBlockIndex !== 0
        ? targetBlockIndex - 1
        : 0;

      var newChildrenArray = newParentChildrenList.toArray();
      newChildrenArray.splice(insertionIndex, 0, originalBlockKey);

      return block.merge({
        children: List$7(newChildrenArray)
      });
    });

    // update block
    transformBlock$2(originalBlockKey, blocks, function(block) {
      return block.merge({
        nextSibling: newNextSiblingKey,
        prevSibling: newPrevSiblingKey,
        parent: newParentKey
      });
    });
  });
};

var moveBlockInContentState = function moveBlockInContentState(
  contentState,
  blockToBeMoved,
  targetBlock,
  insertionMode
) {
  !(insertionMode !== "replace")
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "Replacing blocks is not supported.")
      : invariant_1(false)
    : void 0;

  var targetKey = targetBlock.getKey();
  var blockKey = blockToBeMoved.getKey();

  !(blockKey !== targetKey)
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "Block cannot be moved next to itself.")
      : invariant_1(false)
    : void 0;

  var blockMap = contentState.getBlockMap();
  var isExperimentalTreeBlock = blockToBeMoved instanceof ContentBlockNode_1;

  var blocksToBeMoved = [blockToBeMoved];
  var blockMapWithoutBlocksToBeMoved = blockMap["delete"](blockKey);

  if (isExperimentalTreeBlock) {
    blocksToBeMoved = [];
    blockMapWithoutBlocksToBeMoved = blockMap.withMutations(function(blocks) {
      var nextSiblingKey = blockToBeMoved.getNextSiblingKey();
      var nextDelimiterBlockKey = getNextDelimiterBlockKey_1(
        blockToBeMoved,
        blocks
      );

      blocks
        .toSeq()
        .skipUntil(function(block) {
          return block.getKey() === blockKey;
        })
        .takeWhile(function(block) {
          var key = block.getKey();
          var isBlockToBeMoved = key === blockKey;
          var hasNextSiblingAndIsNotNextSibling =
            nextSiblingKey && key !== nextSiblingKey;
          var doesNotHaveNextSiblingAndIsNotDelimiter =
            !nextSiblingKey &&
            block.getParentKey() &&
            (!nextDelimiterBlockKey || key !== nextDelimiterBlockKey);

          return !!(
            isBlockToBeMoved ||
            hasNextSiblingAndIsNotNextSibling ||
            doesNotHaveNextSiblingAndIsNotDelimiter
          );
        })
        .forEach(function(block) {
          blocksToBeMoved.push(block);
          blocks["delete"](block.getKey());
        });
    });
  }

  var blocksBefore = blockMapWithoutBlocksToBeMoved
    .toSeq()
    .takeUntil(function(v) {
      return v === targetBlock;
    });

  var blocksAfter = blockMapWithoutBlocksToBeMoved
    .toSeq()
    .skipUntil(function(v) {
      return v === targetBlock;
    })
    .skip(1);

  var slicedBlocks = blocksToBeMoved.map(function(block) {
    return [block.getKey(), block];
  });

  var newBlocks = OrderedMap$3();

  if (insertionMode === "before") {
    var blockBefore = contentState.getBlockBefore(targetKey);

    !(!blockBefore || blockBefore.getKey() !== blockToBeMoved.getKey())
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(false, "Block cannot be moved next to itself.")
        : invariant_1(false)
      : void 0;

    newBlocks = blocksBefore
      .concat([].concat(slicedBlocks, [[targetKey, targetBlock]]), blocksAfter)
      .toOrderedMap();
  } else if (insertionMode === "after") {
    var blockAfter = contentState.getBlockAfter(targetKey);

    !(!blockAfter || blockAfter.getKey() !== blockKey)
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(false, "Block cannot be moved next to itself.")
        : invariant_1(false)
      : void 0;

    newBlocks = blocksBefore
      .concat([[targetKey, targetBlock]].concat(slicedBlocks), blocksAfter)
      .toOrderedMap();
  }

  return contentState.merge({
    blockMap: updateBlockMapLinks$3(
      newBlocks,
      blockToBeMoved,
      targetBlock,
      insertionMode,
      isExperimentalTreeBlock
    ),
    selectionBefore: contentState.getSelectionAfter(),
    selectionAfter: contentState.getSelectionAfter().merge({
      anchorKey: blockKey,
      focusKey: blockKey
    })
  });
};

var moveBlockInContentState_1 = moveBlockInContentState;

var ContentBlockRecord$1 = ContentBlock_1;

var List$8 = immutable.List,
  Repeat$5 = immutable.Repeat;

var AtomicBlockUtils = {
  insertAtomicBlock: function insertAtomicBlock(
    editorState,
    entityKey,
    character
  ) {
    var contentState = editorState.getCurrentContent();
    var selectionState = editorState.getSelection();

    var afterRemoval = DraftModifier_1.removeRange(
      contentState,
      selectionState,
      "backward"
    );

    var targetSelection = afterRemoval.getSelectionAfter();
    var afterSplit = DraftModifier_1.splitBlock(afterRemoval, targetSelection);
    var insertionTarget = afterSplit.getSelectionAfter();

    var asAtomicBlock = DraftModifier_1.setBlockType(
      afterSplit,
      insertionTarget,
      "atomic"
    );

    var charData = CharacterMetadata_1.create({ entity: entityKey });

    var atomicBlockConfig = {
      key: generateRandomKey_1(),
      type: "atomic",
      text: character,
      characterList: List$8(Repeat$5(charData, character.length))
    };

    var atomicDividerBlockConfig = {
      key: generateRandomKey_1(),
      type: "unstyled"
    };

    var fragmentArray = [
      new ContentBlockRecord$1(atomicBlockConfig),
      new ContentBlockRecord$1(atomicDividerBlockConfig)
    ];

    var fragment = BlockMapBuilder_1.createFromArray(fragmentArray);

    var withAtomicBlock = DraftModifier_1.replaceWithFragment(
      asAtomicBlock,
      insertionTarget,
      fragment
    );

    var newContent = withAtomicBlock.merge({
      selectionBefore: selectionState,
      selectionAfter: withAtomicBlock.getSelectionAfter().set("hasFocus", true)
    });

    return EditorState_1.push(editorState, newContent, "insert-fragment");
  },

  moveAtomicBlock: function moveAtomicBlock(
    editorState,
    atomicBlock,
    targetRange,
    insertionMode
  ) {
    var contentState = editorState.getCurrentContent();
    var selectionState = editorState.getSelection();

    var withMovedAtomicBlock = void 0;

    if (insertionMode === "before" || insertionMode === "after") {
      var targetBlock = contentState.getBlockForKey(
        insertionMode === "before"
          ? targetRange.getStartKey()
          : targetRange.getEndKey()
      );

      withMovedAtomicBlock = moveBlockInContentState_1(
        contentState,
        atomicBlock,
        targetBlock,
        insertionMode
      );
    } else {
      var afterRemoval = DraftModifier_1.removeRange(
        contentState,
        targetRange,
        "backward"
      );

      var selectionAfterRemoval = afterRemoval.getSelectionAfter();
      var _targetBlock = afterRemoval.getBlockForKey(
        selectionAfterRemoval.getFocusKey()
      );

      if (selectionAfterRemoval.getStartOffset() === 0) {
        withMovedAtomicBlock = moveBlockInContentState_1(
          afterRemoval,
          atomicBlock,
          _targetBlock,
          "before"
        );
      } else if (
        selectionAfterRemoval.getEndOffset() === _targetBlock.getLength()
      ) {
        withMovedAtomicBlock = moveBlockInContentState_1(
          afterRemoval,
          atomicBlock,
          _targetBlock,
          "after"
        );
      } else {
        var afterSplit = DraftModifier_1.splitBlock(
          afterRemoval,
          selectionAfterRemoval
        );

        var selectionAfterSplit = afterSplit.getSelectionAfter();
        var _targetBlock2 = afterSplit.getBlockForKey(
          selectionAfterSplit.getFocusKey()
        );

        withMovedAtomicBlock = moveBlockInContentState_1(
          afterSplit,
          atomicBlock,
          _targetBlock2,
          "before"
        );
      }
    }

    var newContent = withMovedAtomicBlock.merge({
      selectionBefore: selectionState,
      selectionAfter: withMovedAtomicBlock
        .getSelectionAfter()
        .set("hasFocus", true)
    });

    return EditorState_1.push(editorState, newContent, "move-block");
  }
};

var AtomicBlockUtils_1 = AtomicBlockUtils;

function _classCallCheck$8(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

var List$9 = immutable.List;

var DELIMITER = ".";

/**
 * A CompositeDraftDecorator traverses through a list of DraftDecorator
 * instances to identify sections of a ContentBlock that should be rendered
 * in a "decorated" manner. For example, hashtags, mentions, and links may
 * be intended to stand out visually, be rendered as anchors, etc.
 *
 * The list of decorators supplied to the constructor will be used in the
 * order they are provided. This allows the caller to specify a priority for
 * string matching, in case of match collisions among decorators.
 *
 * For instance, I may have a link with a `#` in its text. Though this section
 * of text may match our hashtag decorator, it should not be treated as a
 * hashtag. I should therefore list my link DraftDecorator
 * before my hashtag DraftDecorator when constructing this composite
 * decorator instance.
 *
 * Thus, when a collision like this is encountered, the earlier match is
 * preserved and the new match is discarded.
 */

var CompositeDraftDecorator = (function() {
  function CompositeDraftDecorator(decorators) {
    _classCallCheck$8(this, CompositeDraftDecorator);

    // Copy the decorator array, since we use this array order to determine
    // precedence of decoration matching. If the array is mutated externally,
    // we don't want to be affected here.
    this._decorators = decorators.slice();
  }

  CompositeDraftDecorator.prototype.getDecorations = function getDecorations(
    block,
    contentState
  ) {
    var decorations = Array(block.getText().length).fill(null);

    this._decorators.forEach(function(/*object*/ decorator, /*number*/ ii) {
      var counter = 0;
      var strategy = decorator.strategy;
      var callback = function callback(/*number*/ start, /*number*/ end) {
        // Find out if any of our matching range is already occupied
        // by another decorator. If so, discard the match. Otherwise, store
        // the component key for rendering.
        if (canOccupySlice(decorations, start, end)) {
          occupySlice(decorations, start, end, ii + DELIMITER + counter);
          counter++;
        }
      };
      strategy(block, callback, contentState);
    });

    return List$9(decorations);
  };

  CompositeDraftDecorator.prototype.getComponentForKey = function getComponentForKey(
    key
  ) {
    var componentKey = parseInt(key.split(DELIMITER)[0], 10);
    return this._decorators[componentKey].component;
  };

  CompositeDraftDecorator.prototype.getPropsForKey = function getPropsForKey(
    key
  ) {
    var componentKey = parseInt(key.split(DELIMITER)[0], 10);
    return this._decorators[componentKey].props;
  };

  return CompositeDraftDecorator;
})();

/**
 * Determine whether we can occupy the specified slice of the decorations
 * array.
 */

function canOccupySlice(decorations, start, end) {
  for (var ii = start; ii < end; ii++) {
    if (decorations[ii] != null) {
      return false;
    }
  }
  return true;
}

/**
 * Splice the specified component into our decoration array at the desired
 * range.
 */
function occupySlice(targetArr, start, end, componentKey) {
  for (var ii = start; ii < end; ii++) {
    targetArr[ii] = componentKey;
  }
}

var CompositeDraftDecorator_1 = CompositeDraftDecorator;

/**
 * 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.
 *
 */

/**
 * This function is used to mark string literals representing CSS class names
 * so that they can be transformed statically. This allows for modularization
 * and minification of CSS class names.
 *
 * In static_upstream, this function is actually implemented, but it should
 * eventually be replaced with something more descriptive, and the transform
 * that is used in the main stack should be ported for use elsewhere.
 *
 * @param string|object className to modularize, or an object of key/values.
 *                      In the object case, the values are conditions that
 *                      determine if the className keys should be included.
 * @param [string ...]  Variable list of classNames in the string case.
 * @return string       Renderable space-separated CSS className.
 */
function cx(classNames) {
  if (typeof classNames == "object") {
    return Object.keys(classNames)
      .filter(function(className) {
        return classNames[className];
      })
      .map(replace)
      .join(" ");
  }
  return Array.prototype.map.call(arguments, replace).join(" ");
}

function replace(str) {
  return str.replace(/\//g, "-");
}

var cx_1 = cx;

var Map$8 = immutable.Map;

var UL_WRAP = React__default.createElement("ul", {
  className: cx_1("public/DraftStyleDefault/ul")
});
var OL_WRAP = React__default.createElement("ol", {
  className: cx_1("public/DraftStyleDefault/ol")
});
var PRE_WRAP = React__default.createElement("pre", {
  className: cx_1("public/DraftStyleDefault/pre")
});

var DefaultDraftBlockRenderMap = Map$8({
  "header-one": {
    element: "h1"
  },
  "header-two": {
    element: "h2"
  },
  "header-three": {
    element: "h3"
  },
  "header-four": {
    element: "h4"
  },
  "header-five": {
    element: "h5"
  },
  "header-six": {
    element: "h6"
  },
  "unordered-list-item": {
    element: "li",
    wrapper: UL_WRAP
  },
  "ordered-list-item": {
    element: "li",
    wrapper: OL_WRAP
  },
  blockquote: {
    element: "blockquote"
  },
  atomic: {
    element: "figure"
  },
  "code-block": {
    element: "pre",
    wrapper: PRE_WRAP
  },
  unstyled: {
    element: "div",
    aliasedElements: ["p"]
  }
});

var DefaultDraftBlockRenderMap_1 = DefaultDraftBlockRenderMap;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule DefaultDraftInlineStyle
 * @format
 *
 */

var DefaultDraftInlineStyle = {
  BOLD: {
    fontWeight: "bold"
  },

  CODE: {
    fontFamily: "monospace",
    wordWrap: "break-word"
  },

  ITALIC: {
    fontStyle: "italic"
  },

  STRIKETHROUGH: {
    textDecoration: "line-through"
  },

  UNDERLINE: {
    textDecoration: "underline"
  }
};

/**
 * 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.
 *
 */

var Keys = {
  BACKSPACE: 8,
  TAB: 9,
  RETURN: 13,
  ALT: 18,
  ESC: 27,
  SPACE: 32,
  PAGE_UP: 33,
  PAGE_DOWN: 34,
  END: 35,
  HOME: 36,
  LEFT: 37,
  UP: 38,
  RIGHT: 39,
  DOWN: 40,
  DELETE: 46,
  COMMA: 188,
  PERIOD: 190,
  A: 65,
  Z: 90,
  ZERO: 48,
  NUMPAD_0: 96,
  NUMPAD_9: 105
};

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule getEntityKeyForSelection
 * @format
 *
 */

/**
 * Return the entity key that should be used when inserting text for the
 * specified target selection, only if the entity is `MUTABLE`. `IMMUTABLE`
 * and `SEGMENTED` entities should not be used for insertion behavior.
 */
function getEntityKeyForSelection(contentState, targetSelection) {
  var entityKey;

  if (targetSelection.isCollapsed()) {
    var key = targetSelection.getAnchorKey();
    var offset = targetSelection.getAnchorOffset();
    if (offset > 0) {
      entityKey = contentState.getBlockForKey(key).getEntityAt(offset - 1);
      if (entityKey !== contentState.getBlockForKey(key).getEntityAt(offset)) {
        return null;
      }
      return filterKey(contentState.getEntityMap(), entityKey);
    }
    return null;
  }

  var startKey = targetSelection.getStartKey();
  var startOffset = targetSelection.getStartOffset();
  var startBlock = contentState.getBlockForKey(startKey);

  entityKey =
    startOffset === startBlock.getLength()
      ? null
      : startBlock.getEntityAt(startOffset);

  return filterKey(contentState.getEntityMap(), entityKey);
}

/**
 * Determine whether an entity key corresponds to a `MUTABLE` entity. If so,
 * return it. If not, return null.
 */
function filterKey(entityMap, entityKey) {
  if (entityKey) {
    var entity = entityMap.__get(entityKey);
    return entity.getMutability() === "MUTABLE" ? entityKey : null;
  }
  return null;
}

var getEntityKeyForSelection_1 = getEntityKeyForSelection;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule isEventHandled
 * @format
 *
 */

/**
 * Utility method for determining whether or not the value returned
 * from a handler indicates that it was handled.
 */
function isEventHandled(value) {
  return value === "handled" || value === true;
}

var isEventHandled_1 = isEventHandled;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule isSelectionAtLeafStart
 * @format
 *
 */

function isSelectionAtLeafStart(editorState) {
  var selection = editorState.getSelection();
  var anchorKey = selection.getAnchorKey();
  var blockTree = editorState.getBlockTree(anchorKey);
  var offset = selection.getStartOffset();

  var isAtStart = false;

  blockTree.some(function(leafSet) {
    if (offset === leafSet.get("start")) {
      isAtStart = true;
      return true;
    }

    if (offset < leafSet.get("end")) {
      return leafSet.get("leaves").some(function(leaf) {
        var leafStart = leaf.get("start");
        if (offset === leafStart) {
          isAtStart = true;
          return true;
        }

        return false;
      });
    }

    return false;
  });

  return isAtStart;
}

var isSelectionAtLeafStart_1 = isSelectionAtLeafStart;

/**
 * Millisecond delay to allow `compositionstart` to fire again upon
 * `compositionend`.
 *
 * This is used for Korean input to ensure that typing can continue without
 * the editor trying to render too quickly. More specifically, Safari 7.1+
 * triggers `compositionstart` a little slower than Chrome/FF, which
 * leads to composed characters being resolved and re-render occurring
 * sooner than we want.
 */
var RESOLVE_DELAY = 20;

/**
 * A handful of variables used to track the current composition and its
 * resolution status. These exist at the module level because it is not
 * possible to have compositions occurring in multiple editors simultaneously,
 * and it simplifies state management with respect to the DraftEditor component.
 */
var resolved = false;
var stillComposing = false;
var textInputData = "";

var DraftEditorCompositionHandler = {
  onBeforeInput: function onBeforeInput(editor, e) {
    textInputData = (textInputData || "") + e.data;
  },

  /**
   * A `compositionstart` event has fired while we're still in composition
   * mode. Continue the current composition session to prevent a re-render.
   */
  onCompositionStart: function onCompositionStart(editor) {
    stillComposing = true;
  },

  /**
   * Attempt to end the current composition session.
   *
   * Defer handling because browser will still insert the chars into active
   * element after `compositionend`. If a `compositionstart` event fires
   * before `resolveComposition` executes, our composition session will
   * continue.
   *
   * The `resolved` flag is useful because certain IME interfaces fire the
   * `compositionend` event multiple times, thus queueing up multiple attempts
   * at handling the composition. Since handling the same composition event
   * twice could break the DOM, we only use the first event. Example: Arabic
   * Google Input Tools on Windows 8.1 fires `compositionend` three times.
   */
  onCompositionEnd: function onCompositionEnd(editor) {
    resolved = false;
    stillComposing = false;
    setTimeout(function() {
      if (!resolved) {
        DraftEditorCompositionHandler.resolveComposition(editor);
      }
    }, RESOLVE_DELAY);
  },

  /**
   * In Safari, keydown events may fire when committing compositions. If
   * the arrow keys are used to commit, prevent default so that the cursor
   * doesn't move, otherwise it will jump back noticeably on re-render.
   */
  onKeyDown: function onKeyDown(editor, e) {
    if (!stillComposing) {
      // If a keydown event is received after compositionend but before the
      // 20ms timer expires (ex: type option-E then backspace, or type A then
      // backspace in 2-Set Korean), we should immediately resolve the
      // composition and reinterpret the key press in edit mode.
      DraftEditorCompositionHandler.resolveComposition(editor);
      editor._onKeyDown(e);
      return;
    }
    if (e.which === Keys.RIGHT || e.which === Keys.LEFT) {
      e.preventDefault();
    }
  },

  /**
   * Keypress events may fire when committing compositions. In Firefox,
   * pressing RETURN commits the composition and inserts extra newline
   * characters that we do not want. `preventDefault` allows the composition
   * to be committed while preventing the extra characters.
   */
  onKeyPress: function onKeyPress(editor, e) {
    if (e.which === Keys.RETURN) {
      e.preventDefault();
    }
  },

  /**
   * Attempt to insert composed characters into the document.
   *
   * If we are still in a composition session, do nothing. Otherwise, insert
   * the characters into the document and terminate the composition session.
   *
   * If no characters were composed -- for instance, the user
   * deleted all composed characters and committed nothing new --
   * force a re-render. We also re-render when the composition occurs
   * at the beginning of a leaf, to ensure that if the browser has
   * created a new text node for the composition, we will discard it.
   *
   * Resetting innerHTML will move focus to the beginning of the editor,
   * so we update to force it back to the correct place.
   */
  resolveComposition: function resolveComposition(editor) {
    if (stillComposing) {
      return;
    }

    resolved = true;
    var composedChars = textInputData;
    textInputData = "";

    var editorState = EditorState_1.set(editor._latestEditorState, {
      inCompositionMode: false
    });

    var currentStyle = editorState.getCurrentInlineStyle();
    var entityKey = getEntityKeyForSelection_1(
      editorState.getCurrentContent(),
      editorState.getSelection()
    );

    var mustReset =
      !composedChars ||
      isSelectionAtLeafStart_1(editorState) ||
      currentStyle.size > 0 ||
      entityKey !== null;

    if (mustReset) {
      editor.restoreEditorDOM();
    }

    editor.exitCurrentMode();

    if (composedChars) {
      // If characters have been composed, re-rendering with the update
      // is sufficient to reset the editor.
      var contentState = DraftModifier_1.replaceText(
        editorState.getCurrentContent(),
        editorState.getSelection(),
        composedChars,
        currentStyle,
        entityKey
      );
      editor.update(
        EditorState_1.push(editorState, contentState, "insert-characters")
      );
      return;
    }

    if (mustReset) {
      editor.update(
        EditorState_1.set(editorState, {
          nativelyRenderedContent: null,
          forceSelection: true
        })
      );
    }
  }
};

var DraftEditorCompositionHandler_1 = DraftEditorCompositionHandler;

var uaParser = _commonjsHelpers.createCommonjsModule(function(module, exports) {
  /*!
   * UAParser.js v0.7.21
   * Lightweight JavaScript-based User-Agent string parser
   * https://github.com/faisalman/ua-parser-js
   *
   * Copyright © 2012-2019 Faisal Salman <f@faisalman.com>
   * Licensed under MIT License
   */

  (function(window, undefined$1) {
    //////////////
    // Constants
    /////////////

    var LIBVERSION = "0.7.21",
      EMPTY = "",
      UNKNOWN = "?",
      FUNC_TYPE = "function",
      OBJ_TYPE = "object",
      STR_TYPE = "string",
      MAJOR = "major", // deprecated
      MODEL = "model",
      NAME = "name",
      TYPE = "type",
      VENDOR = "vendor",
      VERSION = "version",
      ARCHITECTURE = "architecture",
      CONSOLE = "console",
      MOBILE = "mobile",
      TABLET = "tablet",
      SMARTTV = "smarttv",
      WEARABLE = "wearable",
      EMBEDDED = "embedded";

    ///////////
    // Helper
    //////////

    var util = {
      extend: function(regexes, extensions) {
        var mergedRegexes = {};
        for (var i in regexes) {
          if (extensions[i] && extensions[i].length % 2 === 0) {
            mergedRegexes[i] = extensions[i].concat(regexes[i]);
          } else {
            mergedRegexes[i] = regexes[i];
          }
        }
        return mergedRegexes;
      },
      has: function(str1, str2) {
        if (typeof str1 === "string") {
          return str2.toLowerCase().indexOf(str1.toLowerCase()) !== -1;
        } else {
          return false;
        }
      },
      lowerize: function(str) {
        return str.toLowerCase();
      },
      major: function(version) {
        return typeof version === STR_TYPE
          ? version.replace(/[^\d\.]/g, "").split(".")[0]
          : undefined$1;
      },
      trim: function(str) {
        return str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
      }
    };

    ///////////////
    // Map helper
    //////////////

    var mapper = {
      rgx: function(ua, arrays) {
        var i = 0,
          j,
          k,
          p,
          q,
          matches,
          match;

        // loop through all regexes maps
        while (i < arrays.length && !matches) {
          var regex = arrays[i], // even sequence (0,2,4,..)
            props = arrays[i + 1]; // odd sequence (1,3,5,..)
          j = k = 0;

          // try matching uastring with regexes
          while (j < regex.length && !matches) {
            matches = regex[j++].exec(ua);

            if (!!matches) {
              for (p = 0; p < props.length; p++) {
                match = matches[++k];
                q = props[p];
                // check if given property is actually array
                if (typeof q === OBJ_TYPE && q.length > 0) {
                  if (q.length == 2) {
                    if (typeof q[1] == FUNC_TYPE) {
                      // assign modified match
                      this[q[0]] = q[1].call(this, match);
                    } else {
                      // assign given value, ignore regex match
                      this[q[0]] = q[1];
                    }
                  } else if (q.length == 3) {
                    // check whether function or regex
                    if (
                      typeof q[1] === FUNC_TYPE &&
                      !(q[1].exec && q[1].test)
                    ) {
                      // call function (usually string mapper)
                      this[q[0]] = match
                        ? q[1].call(this, match, q[2])
                        : undefined$1;
                    } else {
                      // sanitize match using given regex
                      this[q[0]] = match
                        ? match.replace(q[1], q[2])
                        : undefined$1;
                    }
                  } else if (q.length == 4) {
                    this[q[0]] = match
                      ? q[3].call(this, match.replace(q[1], q[2]))
                      : undefined$1;
                  }
                } else {
                  this[q] = match ? match : undefined$1;
                }
              }
            }
          }
          i += 2;
        }
      },

      str: function(str, map) {
        for (var i in map) {
          // check if array
          if (typeof map[i] === OBJ_TYPE && map[i].length > 0) {
            for (var j = 0; j < map[i].length; j++) {
              if (util.has(map[i][j], str)) {
                return i === UNKNOWN ? undefined$1 : i;
              }
            }
          } else if (util.has(map[i], str)) {
            return i === UNKNOWN ? undefined$1 : i;
          }
        }
        return str;
      }
    };

    ///////////////
    // String map
    //////////////

    var maps = {
      browser: {
        oldsafari: {
          version: {
            "1.0": "/8",
            "1.2": "/1",
            "1.3": "/3",
            "2.0": "/412",
            "2.0.2": "/416",
            "2.0.3": "/417",
            "2.0.4": "/419",
            "?": "/"
          }
        }
      },

      device: {
        amazon: {
          model: {
            "Fire Phone": ["SD", "KF"]
          }
        },
        sprint: {
          model: {
            "Evo Shift 4G": "7373KT"
          },
          vendor: {
            HTC: "APA",
            Sprint: "Sprint"
          }
        }
      },

      os: {
        windows: {
          version: {
            ME: "4.90",
            "NT 3.11": "NT3.51",
            "NT 4.0": "NT4.0",
            "2000": "NT 5.0",
            XP: ["NT 5.1", "NT 5.2"],
            Vista: "NT 6.0",
            "7": "NT 6.1",
            "8": "NT 6.2",
            "8.1": "NT 6.3",
            "10": ["NT 6.4", "NT 10.0"],
            RT: "ARM"
          }
        }
      }
    };

    //////////////
    // Regex map
    /////////////

    var regexes = {
      browser: [
        [
          // Presto based
          /(opera\smini)\/([\w\.-]+)/i, // Opera Mini
          /(opera\s[mobiletab]+).+version\/([\w\.-]+)/i, // Opera Mobi/Tablet
          /(opera).+version\/([\w\.]+)/i, // Opera > 9.80
          /(opera)[\/\s]+([\w\.]+)/i // Opera < 9.80
        ],
        [NAME, VERSION],
        [
          /(opios)[\/\s]+([\w\.]+)/i // Opera mini on iphone >= 8.0
        ],
        [[NAME, "Opera Mini"], VERSION],
        [
          /\s(opr)\/([\w\.]+)/i // Opera Webkit
        ],
        [[NAME, "Opera"], VERSION],
        [
          // Mixed
          /(kindle)\/([\w\.]+)/i, // Kindle
          /(lunascape|maxthon|netfront|jasmine|blazer)[\/\s]?([\w\.]*)/i,
          // Lunascape/Maxthon/Netfront/Jasmine/Blazer
          // Trident based
          /(avant\s|iemobile|slim)(?:browser)?[\/\s]?([\w\.]*)/i,
          // Avant/IEMobile/SlimBrowser
          /(bidubrowser|baidubrowser)[\/\s]?([\w\.]+)/i, // Baidu Browser
          /(?:ms|\()(ie)\s([\w\.]+)/i, // Internet Explorer

          // Webkit/KHTML based
          /(rekonq)\/([\w\.]*)/i, // Rekonq
          /(chromium|flock|rockmelt|midori|epiphany|silk|skyfire|ovibrowser|bolt|iron|vivaldi|iridium|phantomjs|bowser|quark|qupzilla|falkon)\/([\w\.-]+)/i
          // Chromium/Flock/RockMelt/Midori/Epiphany/Silk/Skyfire/Bolt/Iron/Iridium/PhantomJS/Bowser/QupZilla/Falkon
        ],
        [NAME, VERSION],
        [
          /(konqueror)\/([\w\.]+)/i // Konqueror
        ],
        [[NAME, "Konqueror"], VERSION],
        [
          /(trident).+rv[:\s]([\w\.]+).+like\sgecko/i // IE11
        ],
        [[NAME, "IE"], VERSION],
        [
          /(edge|edgios|edga|edg)\/((\d+)?[\w\.]+)/i // Microsoft Edge
        ],
        [[NAME, "Edge"], VERSION],
        [
          /(yabrowser)\/([\w\.]+)/i // Yandex
        ],
        [[NAME, "Yandex"], VERSION],
        [
          /(Avast)\/([\w\.]+)/i // Avast Secure Browser
        ],
        [[NAME, "Avast Secure Browser"], VERSION],
        [
          /(AVG)\/([\w\.]+)/i // AVG Secure Browser
        ],
        [[NAME, "AVG Secure Browser"], VERSION],
        [
          /(puffin)\/([\w\.]+)/i // Puffin
        ],
        [[NAME, "Puffin"], VERSION],
        [
          /(focus)\/([\w\.]+)/i // Firefox Focus
        ],
        [[NAME, "Firefox Focus"], VERSION],
        [
          /(opt)\/([\w\.]+)/i // Opera Touch
        ],
        [[NAME, "Opera Touch"], VERSION],
        [
          /((?:[\s\/])uc?\s?browser|(?:juc.+)ucweb)[\/\s]?([\w\.]+)/i // UCBrowser
        ],
        [[NAME, "UCBrowser"], VERSION],
        [
          /(comodo_dragon)\/([\w\.]+)/i // Comodo Dragon
        ],
        [[NAME, /_/g, " "], VERSION],
        [
          /(windowswechat qbcore)\/([\w\.]+)/i // WeChat Desktop for Windows Built-in Browser
        ],
        [[NAME, "WeChat(Win) Desktop"], VERSION],
        [
          /(micromessenger)\/([\w\.]+)/i // WeChat
        ],
        [[NAME, "WeChat"], VERSION],
        [
          /(brave)\/([\w\.]+)/i // Brave browser
        ],
        [[NAME, "Brave"], VERSION],
        [
          /(qqbrowserlite)\/([\w\.]+)/i // QQBrowserLite
        ],
        [NAME, VERSION],
        [
          /(QQ)\/([\d\.]+)/i // QQ, aka ShouQ
        ],
        [NAME, VERSION],
        [
          /m?(qqbrowser)[\/\s]?([\w\.]+)/i // QQBrowser
        ],
        [NAME, VERSION],
        [
          /(baiduboxapp)[\/\s]?([\w\.]+)/i // Baidu App
        ],
        [NAME, VERSION],
        [
          /(2345Explorer)[\/\s]?([\w\.]+)/i // 2345 Browser
        ],
        [NAME, VERSION],
        [
          /(MetaSr)[\/\s]?([\w\.]+)/i // SouGouBrowser
        ],
        [NAME],
        [
          /(LBBROWSER)/i // LieBao Browser
        ],
        [NAME],
        [
          /xiaomi\/miuibrowser\/([\w\.]+)/i // MIUI Browser
        ],
        [VERSION, [NAME, "MIUI Browser"]],
        [
          /;fbav\/([\w\.]+);/i // Facebook App for iOS & Android
        ],
        [VERSION, [NAME, "Facebook"]],
        [
          /safari\s(line)\/([\w\.]+)/i, // Line App for iOS
          /android.+(line)\/([\w\.]+)\/iab/i // Line App for Android
        ],
        [NAME, VERSION],
        [
          /headlesschrome(?:\/([\w\.]+)|\s)/i // Chrome Headless
        ],
        [VERSION, [NAME, "Chrome Headless"]],
        [
          /\swv\).+(chrome)\/([\w\.]+)/i // Chrome WebView
        ],
        [[NAME, /(.+)/, "$1 WebView"], VERSION],
        [/((?:oculus|samsung)browser)\/([\w\.]+)/i],
        [[NAME, /(.+(?:g|us))(.+)/, "$1 $2"], VERSION],
        [
          // Oculus / Samsung Browser

          /android.+version\/([\w\.]+)\s+(?:mobile\s?safari|safari)*/i // Android Browser
        ],
        [VERSION, [NAME, "Android Browser"]],
        [
          /(sailfishbrowser)\/([\w\.]+)/i // Sailfish Browser
        ],
        [[NAME, "Sailfish Browser"], VERSION],
        [
          /(chrome|omniweb|arora|[tizenoka]{5}\s?browser)\/v?([\w\.]+)/i
          // Chrome/OmniWeb/Arora/Tizen/Nokia
        ],
        [NAME, VERSION],
        [
          /(dolfin)\/([\w\.]+)/i // Dolphin
        ],
        [[NAME, "Dolphin"], VERSION],
        [
          /(qihu|qhbrowser|qihoobrowser|360browser)/i // 360
        ],
        [[NAME, "360 Browser"]],
        [
          /((?:android.+)crmo|crios)\/([\w\.]+)/i // Chrome for Android/iOS
        ],
        [[NAME, "Chrome"], VERSION],
        [
          /(coast)\/([\w\.]+)/i // Opera Coast
        ],
        [[NAME, "Opera Coast"], VERSION],
        [
          /fxios\/([\w\.-]+)/i // Firefox for iOS
        ],
        [VERSION, [NAME, "Firefox"]],
        [
          /version\/([\w\.]+).+?mobile\/\w+\s(safari)/i // Mobile Safari
        ],
        [VERSION, [NAME, "Mobile Safari"]],
        [
          /version\/([\w\.]+).+?(mobile\s?safari|safari)/i // Safari & Safari Mobile
        ],
        [VERSION, NAME],
        [
          /webkit.+?(gsa)\/([\w\.]+).+?(mobile\s?safari|safari)(\/[\w\.]+)/i // Google Search Appliance on iOS
        ],
        [[NAME, "GSA"], VERSION],
        [
          /webkit.+?(mobile\s?safari|safari)(\/[\w\.]+)/i // Safari < 3.0
        ],
        [NAME, [VERSION, mapper.str, maps.browser.oldsafari.version]],
        [/(webkit|khtml)\/([\w\.]+)/i],
        [NAME, VERSION],
        [
          // Gecko based
          /(navigator|netscape)\/([\w\.-]+)/i // Netscape
        ],
        [[NAME, "Netscape"], VERSION],
        [
          /(swiftfox)/i, // Swiftfox
          /(icedragon|iceweasel|camino|chimera|fennec|maemo\sbrowser|minimo|conkeror)[\/\s]?([\w\.\+]+)/i,
          // IceDragon/Iceweasel/Camino/Chimera/Fennec/Maemo/Minimo/Conkeror
          /(firefox|seamonkey|k-meleon|icecat|iceape|firebird|phoenix|palemoon|basilisk|waterfox)\/([\w\.-]+)$/i,

          // Firefox/SeaMonkey/K-Meleon/IceCat/IceApe/Firebird/Phoenix
          /(mozilla)\/([\w\.]+).+rv\:.+gecko\/\d+/i, // Mozilla

          // Other
          /(polaris|lynx|dillo|icab|doris|amaya|w3m|netsurf|sleipnir)[\/\s]?([\w\.]+)/i,
          // Polaris/Lynx/Dillo/iCab/Doris/Amaya/w3m/NetSurf/Sleipnir
          /(links)\s\(([\w\.]+)/i, // Links
          /(gobrowser)\/?([\w\.]*)/i, // GoBrowser
          /(ice\s?browser)\/v?([\w\._]+)/i, // ICE Browser
          /(mosaic)[\/\s]([\w\.]+)/i // Mosaic
        ],
        [NAME, VERSION]
      ],

      cpu: [
        [
          /(?:(amd|x(?:(?:86|64)[_-])?|wow|win)64)[;\)]/i // AMD64
        ],
        [[ARCHITECTURE, "amd64"]],
        [
          /(ia32(?=;))/i // IA32 (quicktime)
        ],
        [[ARCHITECTURE, util.lowerize]],
        [
          /((?:i[346]|x)86)[;\)]/i // IA32
        ],
        [[ARCHITECTURE, "ia32"]],
        [
          // PocketPC mistakenly identified as PowerPC
          /windows\s(ce|mobile);\sppc;/i
        ],
        [[ARCHITECTURE, "arm"]],
        [
          /((?:ppc|powerpc)(?:64)?)(?:\smac|;|\))/i // PowerPC
        ],
        [[ARCHITECTURE, /ower/, "", util.lowerize]],
        [
          /(sun4\w)[;\)]/i // SPARC
        ],
        [[ARCHITECTURE, "sparc"]],
        [
          /((?:avr32|ia64(?=;))|68k(?=\))|arm(?:64|(?=v\d+[;l]))|(?=atmel\s)avr|(?:irix|mips|sparc)(?:64)?(?=;)|pa-risc)/i
          // IA64, 68K, ARM/64, AVR/32, IRIX/64, MIPS/64, SPARC/64, PA-RISC
        ],
        [[ARCHITECTURE, util.lowerize]]
      ],

      device: [
        [
          /\((ipad|playbook);[\w\s\),;-]+(rim|apple)/i // iPad/PlayBook
        ],
        [MODEL, VENDOR, [TYPE, TABLET]],
        [
          /applecoremedia\/[\w\.]+ \((ipad)/ // iPad
        ],
        [MODEL, [VENDOR, "Apple"], [TYPE, TABLET]],
        [
          /(apple\s{0,1}tv)/i // Apple TV
        ],
        [
          [MODEL, "Apple TV"],
          [VENDOR, "Apple"],
          [TYPE, SMARTTV]
        ],
        [
          /(archos)\s(gamepad2?)/i, // Archos
          /(hp).+(touchpad)/i, // HP TouchPad
          /(hp).+(tablet)/i, // HP Tablet
          /(kindle)\/([\w\.]+)/i, // Kindle
          /\s(nook)[\w\s]+build\/(\w+)/i, // Nook
          /(dell)\s(strea[kpr\s\d]*[\dko])/i // Dell Streak
        ],
        [VENDOR, MODEL, [TYPE, TABLET]],
        [
          /(kf[A-z]+)\sbuild\/.+silk\//i // Kindle Fire HD
        ],
        [MODEL, [VENDOR, "Amazon"], [TYPE, TABLET]],
        [
          /(sd|kf)[0349hijorstuw]+\sbuild\/.+silk\//i // Fire Phone
        ],
        [
          [MODEL, mapper.str, maps.device.amazon.model],
          [VENDOR, "Amazon"],
          [TYPE, MOBILE]
        ],
        [
          /android.+aft([bms])\sbuild/i // Fire TV
        ],
        [MODEL, [VENDOR, "Amazon"], [TYPE, SMARTTV]],
        [
          /\((ip[honed|\s\w*]+);.+(apple)/i // iPod/iPhone
        ],
        [MODEL, VENDOR, [TYPE, MOBILE]],
        [
          /\((ip[honed|\s\w*]+);/i // iPod/iPhone
        ],
        [MODEL, [VENDOR, "Apple"], [TYPE, MOBILE]],
        [
          /(blackberry)[\s-]?(\w+)/i, // BlackBerry
          /(blackberry|benq|palm(?=\-)|sonyericsson|acer|asus|dell|meizu|motorola|polytron)[\s_-]?([\w-]*)/i,
          // BenQ/Palm/Sony-Ericsson/Acer/Asus/Dell/Meizu/Motorola/Polytron
          /(hp)\s([\w\s]+\w)/i, // HP iPAQ
          /(asus)-?(\w+)/i // Asus
        ],
        [VENDOR, MODEL, [TYPE, MOBILE]],
        [
          /\(bb10;\s(\w+)/i // BlackBerry 10
        ],
        [MODEL, [VENDOR, "BlackBerry"], [TYPE, MOBILE]],
        [
          // Asus Tablets
          /android.+(transfo[prime\s]{4,10}\s\w+|eeepc|slider\s\w+|nexus 7|padfone|p00c)/i
        ],
        [MODEL, [VENDOR, "Asus"], [TYPE, TABLET]],
        [
          /(sony)\s(tablet\s[ps])\sbuild\//i, // Sony
          /(sony)?(?:sgp.+)\sbuild\//i
        ],
        [
          [VENDOR, "Sony"],
          [MODEL, "Xperia Tablet"],
          [TYPE, TABLET]
        ],
        [
          /android.+\s([c-g]\d{4}|so[-l]\w+)(?=\sbuild\/|\).+chrome\/(?![1-6]{0,1}\d\.))/i
        ],
        [MODEL, [VENDOR, "Sony"], [TYPE, MOBILE]],
        [
          /\s(ouya)\s/i, // Ouya
          /(nintendo)\s([wids3u]+)/i // Nintendo
        ],
        [VENDOR, MODEL, [TYPE, CONSOLE]],
        [
          /android.+;\s(shield)\sbuild/i // Nvidia
        ],
        [MODEL, [VENDOR, "Nvidia"], [TYPE, CONSOLE]],
        [
          /(playstation\s[34portablevi]+)/i // Playstation
        ],
        [MODEL, [VENDOR, "Sony"], [TYPE, CONSOLE]],
        [
          /(sprint\s(\w+))/i // Sprint Phones
        ],
        [
          [VENDOR, mapper.str, maps.device.sprint.vendor],
          [MODEL, mapper.str, maps.device.sprint.model],
          [TYPE, MOBILE]
        ],
        [
          /(htc)[;_\s-]+([\w\s]+(?=\)|\sbuild)|\w+)/i, // HTC
          /(zte)-(\w*)/i, // ZTE
          /(alcatel|geeksphone|nexian|panasonic|(?=;\s)sony)[_\s-]?([\w-]*)/i
          // Alcatel/GeeksPhone/Nexian/Panasonic/Sony
        ],
        [VENDOR, [MODEL, /_/g, " "], [TYPE, MOBILE]],
        [
          /(nexus\s9)/i // HTC Nexus 9
        ],
        [MODEL, [VENDOR, "HTC"], [TYPE, TABLET]],
        [
          /d\/huawei([\w\s-]+)[;\)]/i,
          /(nexus\s6p|vog-l29|ane-lx1|eml-l29)/i // Huawei
        ],
        [MODEL, [VENDOR, "Huawei"], [TYPE, MOBILE]],
        [
          /android.+(bah2?-a?[lw]\d{2})/i // Huawei MediaPad
        ],
        [MODEL, [VENDOR, "Huawei"], [TYPE, TABLET]],
        [
          /(microsoft);\s(lumia[\s\w]+)/i // Microsoft Lumia
        ],
        [VENDOR, MODEL, [TYPE, MOBILE]],
        [
          /[\s\(;](xbox(?:\sone)?)[\s\);]/i // Microsoft Xbox
        ],
        [MODEL, [VENDOR, "Microsoft"], [TYPE, CONSOLE]],
        [
          /(kin\.[onetw]{3})/i // Microsoft Kin
        ],
        [
          [MODEL, /\./g, " "],
          [VENDOR, "Microsoft"],
          [TYPE, MOBILE]
        ],
        [
          // Motorola
          /\s(milestone|droid(?:[2-4x]|\s(?:bionic|x2|pro|razr))?:?(\s4g)?)[\w\s]+build\//i,
          /mot[\s-]?(\w*)/i,
          /(XT\d{3,4}) build\//i,
          /(nexus\s6)/i
        ],
        [MODEL, [VENDOR, "Motorola"], [TYPE, MOBILE]],
        [/android.+\s(mz60\d|xoom[\s2]{0,2})\sbuild\//i],
        [MODEL, [VENDOR, "Motorola"], [TYPE, TABLET]],
        [
          /hbbtv\/\d+\.\d+\.\d+\s+\([\w\s]*;\s*(\w[^;]*);([^;]*)/i // HbbTV devices
        ],
        [
          [VENDOR, util.trim],
          [MODEL, util.trim],
          [TYPE, SMARTTV]
        ],
        [/hbbtv.+maple;(\d+)/i],
        [
          [MODEL, /^/, "SmartTV"],
          [VENDOR, "Samsung"],
          [TYPE, SMARTTV]
        ],
        [
          /\(dtv[\);].+(aquos)/i // Sharp
        ],
        [MODEL, [VENDOR, "Sharp"], [TYPE, SMARTTV]],
        [
          /android.+((sch-i[89]0\d|shw-m380s|gt-p\d{4}|gt-n\d+|sgh-t8[56]9|nexus 10))/i,
          /((SM-T\w+))/i
        ],
        [[VENDOR, "Samsung"], MODEL, [TYPE, TABLET]],
        [
          // Samsung
          /smart-tv.+(samsung)/i
        ],
        [VENDOR, [TYPE, SMARTTV], MODEL],
        [
          /((s[cgp]h-\w+|gt-\w+|galaxy\snexus|sm-\w[\w\d]+))/i,
          /(sam[sung]*)[\s-]*(\w+-?[\w-]*)/i,
          /sec-((sgh\w+))/i
        ],
        [[VENDOR, "Samsung"], MODEL, [TYPE, MOBILE]],
        [
          /sie-(\w*)/i // Siemens
        ],
        [MODEL, [VENDOR, "Siemens"], [TYPE, MOBILE]],
        [
          /(maemo|nokia).*(n900|lumia\s\d+)/i, // Nokia
          /(nokia)[\s_-]?([\w-]*)/i
        ],
        [[VENDOR, "Nokia"], MODEL, [TYPE, MOBILE]],
        [
          /android[x\d\.\s;]+\s([ab][1-7]\-?[0178a]\d\d?)/i // Acer
        ],
        [MODEL, [VENDOR, "Acer"], [TYPE, TABLET]],
        [
          /android.+([vl]k\-?\d{3})\s+build/i // LG Tablet
        ],
        [MODEL, [VENDOR, "LG"], [TYPE, TABLET]],
        [
          /android\s3\.[\s\w;-]{10}(lg?)-([06cv9]{3,4})/i // LG Tablet
        ],
        [[VENDOR, "LG"], MODEL, [TYPE, TABLET]],
        [
          /(lg) netcast\.tv/i // LG SmartTV
        ],
        [VENDOR, MODEL, [TYPE, SMARTTV]],
        [
          /(nexus\s[45])/i, // LG
          /lg[e;\s\/-]+(\w*)/i,
          /android.+lg(\-?[\d\w]+)\s+build/i
        ],
        [MODEL, [VENDOR, "LG"], [TYPE, MOBILE]],
        [
          /(lenovo)\s?(s(?:5000|6000)(?:[\w-]+)|tab(?:[\s\w]+))/i // Lenovo tablets
        ],
        [VENDOR, MODEL, [TYPE, TABLET]],
        [
          /android.+(ideatab[a-z0-9\-\s]+)/i // Lenovo
        ],
        [MODEL, [VENDOR, "Lenovo"], [TYPE, TABLET]],
        [/(lenovo)[_\s-]?([\w-]+)/i],
        [VENDOR, MODEL, [TYPE, MOBILE]],
        [
          /linux;.+((jolla));/i // Jolla
        ],
        [VENDOR, MODEL, [TYPE, MOBILE]],
        [
          /((pebble))app\/[\d\.]+\s/i // Pebble
        ],
        [VENDOR, MODEL, [TYPE, WEARABLE]],
        [
          /android.+;\s(oppo)\s?([\w\s]+)\sbuild/i // OPPO
        ],
        [VENDOR, MODEL, [TYPE, MOBILE]],
        [
          /crkey/i // Google Chromecast
        ],
        [
          [MODEL, "Chromecast"],
          [VENDOR, "Google"],
          [TYPE, SMARTTV]
        ],
        [
          /android.+;\s(glass)\s\d/i // Google Glass
        ],
        [MODEL, [VENDOR, "Google"], [TYPE, WEARABLE]],
        [
          /android.+;\s(pixel c)[\s)]/i // Google Pixel C
        ],
        [MODEL, [VENDOR, "Google"], [TYPE, TABLET]],
        [
          /android.+;\s(pixel( [23])?( xl)?)[\s)]/i // Google Pixel
        ],
        [MODEL, [VENDOR, "Google"], [TYPE, MOBILE]],
        [
          /android.+;\s(\w+)\s+build\/hm\1/i, // Xiaomi Hongmi 'numeric' models
          /android.+(hm[\s\-_]*note?[\s_]*(?:\d\w)?)\s+build/i, // Xiaomi Hongmi
          /android.+(mi[\s\-_]*(?:a\d|one|one[\s_]plus|note lte)?[\s_]*(?:\d?\w?)[\s_]*(?:plus)?)\s+build/i,
          // Xiaomi Mi
          /android.+(redmi[\s\-_]*(?:note)?(?:[\s_]*[\w\s]+))\s+build/i // Redmi Phones
        ],
        [
          [MODEL, /_/g, " "],
          [VENDOR, "Xiaomi"],
          [TYPE, MOBILE]
        ],
        [
          /android.+(mi[\s\-_]*(?:pad)(?:[\s_]*[\w\s]+))\s+build/i // Mi Pad tablets
        ],
        [
          [MODEL, /_/g, " "],
          [VENDOR, "Xiaomi"],
          [TYPE, TABLET]
        ],
        [
          /android.+;\s(m[1-5]\snote)\sbuild/i // Meizu
        ],
        [MODEL, [VENDOR, "Meizu"], [TYPE, MOBILE]],
        [/(mz)-([\w-]{2,})/i],
        [[VENDOR, "Meizu"], MODEL, [TYPE, MOBILE]],
        [
          /android.+a000(1)\s+build/i, // OnePlus
          /android.+oneplus\s(a\d{4})[\s)]/i
        ],
        [MODEL, [VENDOR, "OnePlus"], [TYPE, MOBILE]],
        [
          /android.+[;\/]\s*(RCT[\d\w]+)\s+build/i // RCA Tablets
        ],
        [MODEL, [VENDOR, "RCA"], [TYPE, TABLET]],
        [
          /android.+[;\/\s]+(Venue[\d\s]{2,7})\s+build/i // Dell Venue Tablets
        ],
        [MODEL, [VENDOR, "Dell"], [TYPE, TABLET]],
        [
          /android.+[;\/]\s*(Q[T|M][\d\w]+)\s+build/i // Verizon Tablet
        ],
        [MODEL, [VENDOR, "Verizon"], [TYPE, TABLET]],
        [
          /android.+[;\/]\s+(Barnes[&\s]+Noble\s+|BN[RT])(V?.*)\s+build/i // Barnes & Noble Tablet
        ],
        [[VENDOR, "Barnes & Noble"], MODEL, [TYPE, TABLET]],
        [
          /android.+[;\/]\s+(TM\d{3}.*\b)\s+build/i // Barnes & Noble Tablet
        ],
        [MODEL, [VENDOR, "NuVision"], [TYPE, TABLET]],
        [
          /android.+;\s(k88)\sbuild/i // ZTE K Series Tablet
        ],
        [MODEL, [VENDOR, "ZTE"], [TYPE, TABLET]],
        [
          /android.+[;\/]\s*(gen\d{3})\s+build.*49h/i // Swiss GEN Mobile
        ],
        [MODEL, [VENDOR, "Swiss"], [TYPE, MOBILE]],
        [
          /android.+[;\/]\s*(zur\d{3})\s+build/i // Swiss ZUR Tablet
        ],
        [MODEL, [VENDOR, "Swiss"], [TYPE, TABLET]],
        [
          /android.+[;\/]\s*((Zeki)?TB.*\b)\s+build/i // Zeki Tablets
        ],
        [MODEL, [VENDOR, "Zeki"], [TYPE, TABLET]],
        [
          /(android).+[;\/]\s+([YR]\d{2})\s+build/i,
          /android.+[;\/]\s+(Dragon[\-\s]+Touch\s+|DT)(\w{5})\sbuild/i // Dragon Touch Tablet
        ],
        [[VENDOR, "Dragon Touch"], MODEL, [TYPE, TABLET]],
        [
          /android.+[;\/]\s*(NS-?\w{0,9})\sbuild/i // Insignia Tablets
        ],
        [MODEL, [VENDOR, "Insignia"], [TYPE, TABLET]],
        [
          /android.+[;\/]\s*((NX|Next)-?\w{0,9})\s+build/i // NextBook Tablets
        ],
        [MODEL, [VENDOR, "NextBook"], [TYPE, TABLET]],
        [
          /android.+[;\/]\s*(Xtreme\_)?(V(1[045]|2[015]|30|40|60|7[05]|90))\s+build/i
        ],
        [[VENDOR, "Voice"], MODEL, [TYPE, MOBILE]],
        [
          // Voice Xtreme Phones

          /android.+[;\/]\s*(LVTEL\-)?(V1[12])\s+build/i // LvTel Phones
        ],
        [[VENDOR, "LvTel"], MODEL, [TYPE, MOBILE]],
        [/android.+;\s(PH-1)\s/i],
        [MODEL, [VENDOR, "Essential"], [TYPE, MOBILE]],
        [
          // Essential PH-1

          /android.+[;\/]\s*(V(100MD|700NA|7011|917G).*\b)\s+build/i // Envizen Tablets
        ],
        [MODEL, [VENDOR, "Envizen"], [TYPE, TABLET]],
        [
          /android.+[;\/]\s*(Le[\s\-]+Pan)[\s\-]+(\w{1,9})\s+build/i // Le Pan Tablets
        ],
        [VENDOR, MODEL, [TYPE, TABLET]],
        [
          /android.+[;\/]\s*(Trio[\s\-]*.*)\s+build/i // MachSpeed Tablets
        ],
        [MODEL, [VENDOR, "MachSpeed"], [TYPE, TABLET]],
        [
          /android.+[;\/]\s*(Trinity)[\-\s]*(T\d{3})\s+build/i // Trinity Tablets
        ],
        [VENDOR, MODEL, [TYPE, TABLET]],
        [
          /android.+[;\/]\s*TU_(1491)\s+build/i // Rotor Tablets
        ],
        [MODEL, [VENDOR, "Rotor"], [TYPE, TABLET]],
        [
          /android.+(KS(.+))\s+build/i // Amazon Kindle Tablets
        ],
        [MODEL, [VENDOR, "Amazon"], [TYPE, TABLET]],
        [
          /android.+(Gigaset)[\s\-]+(Q\w{1,9})\s+build/i // Gigaset Tablets
        ],
        [VENDOR, MODEL, [TYPE, TABLET]],
        [
          /\s(tablet|tab)[;\/]/i, // Unidentifiable Tablet
          /\s(mobile)(?:[;\/]|\ssafari)/i // Unidentifiable Mobile
        ],
        [[TYPE, util.lowerize], VENDOR, MODEL],
        [
          /[\s\/\(](smart-?tv)[;\)]/i // SmartTV
        ],
        [[TYPE, SMARTTV]],
        [
          /(android[\w\.\s\-]{0,9});.+build/i // Generic Android Device
        ],
        [MODEL, [VENDOR, "Generic"]]
      ],

      engine: [
        [
          /windows.+\sedge\/([\w\.]+)/i // EdgeHTML
        ],
        [VERSION, [NAME, "EdgeHTML"]],
        [
          /webkit\/537\.36.+chrome\/(?!27)([\w\.]+)/i // Blink
        ],
        [VERSION, [NAME, "Blink"]],
        [
          /(presto)\/([\w\.]+)/i, // Presto
          /(webkit|trident|netfront|netsurf|amaya|lynx|w3m|goanna)\/([\w\.]+)/i,
          // WebKit/Trident/NetFront/NetSurf/Amaya/Lynx/w3m/Goanna
          /(khtml|tasman|links)[\/\s]\(?([\w\.]+)/i, // KHTML/Tasman/Links
          /(icab)[\/\s]([23]\.[\d\.]+)/i // iCab
        ],
        [NAME, VERSION],
        [
          /rv\:([\w\.]{1,9}).+(gecko)/i // Gecko
        ],
        [VERSION, NAME]
      ],

      os: [
        [
          // Windows based
          /microsoft\s(windows)\s(vista|xp)/i // Windows (iTunes)
        ],
        [NAME, VERSION],
        [
          /(windows)\snt\s6\.2;\s(arm)/i, // Windows RT
          /(windows\sphone(?:\sos)*)[\s\/]?([\d\.\s\w]*)/i, // Windows Phone
          /(windows\smobile|windows)[\s\/]?([ntce\d\.\s]+\w)/i
        ],
        [NAME, [VERSION, mapper.str, maps.os.windows.version]],
        [/(win(?=3|9|n)|win\s9x\s)([nt\d\.]+)/i],
        [
          [NAME, "Windows"],
          [VERSION, mapper.str, maps.os.windows.version]
        ],
        [
          // Mobile/Embedded OS
          /\((bb)(10);/i // BlackBerry 10
        ],
        [[NAME, "BlackBerry"], VERSION],
        [
          /(blackberry)\w*\/?([\w\.]*)/i, // Blackberry
          /(tizen|kaios)[\/\s]([\w\.]+)/i, // Tizen/KaiOS
          /(android|webos|palm\sos|qnx|bada|rim\stablet\sos|meego|sailfish|contiki)[\/\s-]?([\w\.]*)/i
          // Android/WebOS/Palm/QNX/Bada/RIM/MeeGo/Contiki/Sailfish OS
        ],
        [NAME, VERSION],
        [
          /(symbian\s?os|symbos|s60(?=;))[\/\s-]?([\w\.]*)/i // Symbian
        ],
        [[NAME, "Symbian"], VERSION],
        [
          /\((series40);/i // Series 40
        ],
        [NAME],
        [
          /mozilla.+\(mobile;.+gecko.+firefox/i // Firefox OS
        ],
        [[NAME, "Firefox OS"], VERSION],
        [
          // Console
          /(nintendo|playstation)\s([wids34portablevu]+)/i, // Nintendo/Playstation

          // GNU/Linux based
          /(mint)[\/\s\(]?(\w*)/i, // Mint
          /(mageia|vectorlinux)[;\s]/i, // Mageia/VectorLinux
          /(joli|[kxln]?ubuntu|debian|suse|opensuse|gentoo|(?=\s)arch|slackware|fedora|mandriva|centos|pclinuxos|redhat|zenwalk|linpus)[\/\s-]?(?!chrom)([\w\.-]*)/i,
          // Joli/Ubuntu/Debian/SUSE/Gentoo/Arch/Slackware
          // Fedora/Mandriva/CentOS/PCLinuxOS/RedHat/Zenwalk/Linpus
          /(hurd|linux)\s?([\w\.]*)/i, // Hurd/Linux
          /(gnu)\s?([\w\.]*)/i // GNU
        ],
        [NAME, VERSION],
        [
          /(cros)\s[\w]+\s([\w\.]+\w)/i // Chromium OS
        ],
        [[NAME, "Chromium OS"], VERSION],
        [
          // Solaris
          /(sunos)\s?([\w\.\d]*)/i // Solaris
        ],
        [[NAME, "Solaris"], VERSION],
        [
          // BSD based
          /\s([frentopc-]{0,4}bsd|dragonfly)\s?([\w\.]*)/i // FreeBSD/NetBSD/OpenBSD/PC-BSD/DragonFly
        ],
        [NAME, VERSION],
        [
          /(haiku)\s(\w+)/i // Haiku
        ],
        [NAME, VERSION],
        [
          /cfnetwork\/.+darwin/i,
          /ip[honead]{2,4}(?:.*os\s([\w]+)\slike\smac|;\sopera)/i // iOS
        ],
        [
          [VERSION, /_/g, "."],
          [NAME, "iOS"]
        ],
        [
          /(mac\sos\sx)\s?([\w\s\.]*)/i,
          /(macintosh|mac(?=_powerpc)\s)/i // Mac OS
        ],
        [
          [NAME, "Mac OS"],
          [VERSION, /_/g, "."]
        ],
        [
          // Other
          /((?:open)?solaris)[\/\s-]?([\w\.]*)/i, // Solaris
          /(aix)\s((\d)(?=\.|\)|\s)[\w\.])*/i, // AIX
          /(plan\s9|minix|beos|os\/2|amigaos|morphos|risc\sos|openvms|fuchsia)/i,
          // Plan9/Minix/BeOS/OS2/AmigaOS/MorphOS/RISCOS/OpenVMS/Fuchsia
          /(unix)\s?([\w\.]*)/i // UNIX
        ],
        [NAME, VERSION]
      ]
    };

    /////////////////
    // Constructor
    ////////////////
    var UAParser = function(uastring, extensions) {
      if (typeof uastring === "object") {
        extensions = uastring;
        uastring = undefined$1;
      }

      if (!(this instanceof UAParser)) {
        return new UAParser(uastring, extensions).getResult();
      }

      var ua =
        uastring ||
        (window && window.navigator && window.navigator.userAgent
          ? window.navigator.userAgent
          : EMPTY);
      var rgxmap = extensions ? util.extend(regexes, extensions) : regexes;

      this.getBrowser = function() {
        var browser = { name: undefined$1, version: undefined$1 };
        mapper.rgx.call(browser, ua, rgxmap.browser);
        browser.major = util.major(browser.version); // deprecated
        return browser;
      };
      this.getCPU = function() {
        var cpu = { architecture: undefined$1 };
        mapper.rgx.call(cpu, ua, rgxmap.cpu);
        return cpu;
      };
      this.getDevice = function() {
        var device = {
          vendor: undefined$1,
          model: undefined$1,
          type: undefined$1
        };
        mapper.rgx.call(device, ua, rgxmap.device);
        return device;
      };
      this.getEngine = function() {
        var engine = { name: undefined$1, version: undefined$1 };
        mapper.rgx.call(engine, ua, rgxmap.engine);
        return engine;
      };
      this.getOS = function() {
        var os = { name: undefined$1, version: undefined$1 };
        mapper.rgx.call(os, ua, rgxmap.os);
        return os;
      };
      this.getResult = function() {
        return {
          ua: this.getUA(),
          browser: this.getBrowser(),
          engine: this.getEngine(),
          os: this.getOS(),
          device: this.getDevice(),
          cpu: this.getCPU()
        };
      };
      this.getUA = function() {
        return ua;
      };
      this.setUA = function(uastring) {
        ua = uastring;
        return this;
      };
      return this;
    };

    UAParser.VERSION = LIBVERSION;
    UAParser.BROWSER = {
      NAME: NAME,
      MAJOR: MAJOR, // deprecated
      VERSION: VERSION
    };
    UAParser.CPU = {
      ARCHITECTURE: ARCHITECTURE
    };
    UAParser.DEVICE = {
      MODEL: MODEL,
      VENDOR: VENDOR,
      TYPE: TYPE,
      CONSOLE: CONSOLE,
      MOBILE: MOBILE,
      SMARTTV: SMARTTV,
      TABLET: TABLET,
      WEARABLE: WEARABLE,
      EMBEDDED: EMBEDDED
    };
    UAParser.ENGINE = {
      NAME: NAME,
      VERSION: VERSION
    };
    UAParser.OS = {
      NAME: NAME,
      VERSION: VERSION
    };

    ///////////
    // Export
    //////////

    // check js environment
    {
      // nodejs env
      if (module.exports) {
        exports = module.exports = UAParser;
      }
      exports.UAParser = UAParser;
    }

    // jQuery/Zepto specific (optional)
    // Note:
    //   In AMD env the global scope should be kept clean, but jQuery is an exception.
    //   jQuery always exports to global scope, unless jQuery.noConflict(true) is used,
    //   and we should catch that.
    var $ = window && (window.jQuery || window.Zepto);
    if ($ && !$.ua) {
      var parser = new UAParser();
      $.ua = parser.getResult();
      $.ua.get = function() {
        return parser.getUA();
      };
      $.ua.set = function(uastring) {
        parser.setUA(uastring);
        var result = parser.getResult();
        for (var prop in result) {
          $.ua[prop] = result[prop];
        }
      };
    }
  })(typeof window === "object" ? window : _commonjsHelpers.commonjsGlobal);
});
var uaParser_1 = uaParser.UAParser;

var UNKNOWN = "Unknown";

var PLATFORM_MAP = {
  "Mac OS": "Mac OS X"
};

/**
 * Convert from UAParser platform name to what we expect.
 */
function convertPlatformName(name) {
  return PLATFORM_MAP[name] || name;
}

/**
 * Get the version number in parts. This is very naive. We actually get major
 * version as a part of UAParser already, which is generally good enough, but
 * let's get the minor just in case.
 */
function getBrowserVersion(version) {
  if (!version) {
    return {
      major: "",
      minor: ""
    };
  }
  var parts = version.split(".");
  return {
    major: parts[0],
    minor: parts[1]
  };
}

/**
 * Get the UA data fom UAParser and then convert it to the format we're
 * expecting for our APIS.
 */
var parser = new uaParser();
var results = parser.getResult();

// Do some conversion first.
var browserVersionData = getBrowserVersion(results.browser.version);
var uaData = {
  browserArchitecture: results.cpu.architecture || UNKNOWN,
  browserFullVersion: results.browser.version || UNKNOWN,
  browserMinorVersion: browserVersionData.minor || UNKNOWN,
  browserName: results.browser.name || UNKNOWN,
  browserVersion: results.browser.major || UNKNOWN,
  deviceName: results.device.model || UNKNOWN,
  engineName: results.engine.name || UNKNOWN,
  engineVersion: results.engine.version || UNKNOWN,
  platformArchitecture: results.cpu.architecture || UNKNOWN,
  platformName: convertPlatformName(results.os.name) || UNKNOWN,
  platformVersion: results.os.version || UNKNOWN,
  platformFullVersion: results.os.version || UNKNOWN
};

var UserAgentData = uaData;

var componentRegex = /\./;
var orRegex = /\|\|/;
var rangeRegex = /\s+\-\s+/;
var modifierRegex = /^(<=|<|=|>=|~>|~|>|)?\s*(.+)/;
var numericRegex = /^(\d*)(.*)/;

/**
 * Splits input `range` on "||" and returns true if any subrange matches
 * `version`.
 *
 * @param {string} range
 * @param {string} version
 * @returns {boolean}
 */
function checkOrExpression(range, version) {
  var expressions = range.split(orRegex);

  if (expressions.length > 1) {
    return expressions.some(function(range) {
      return VersionRange.contains(range, version);
    });
  } else {
    range = expressions[0].trim();
    return checkRangeExpression(range, version);
  }
}

/**
 * Splits input `range` on " - " (the surrounding whitespace is required) and
 * returns true if version falls between the two operands.
 *
 * @param {string} range
 * @param {string} version
 * @returns {boolean}
 */
function checkRangeExpression(range, version) {
  var expressions = range.split(rangeRegex);

  !(expressions.length > 0 && expressions.length <= 2)
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, 'the "-" operator expects exactly 2 operands')
      : invariant_1(false)
    : void 0;

  if (expressions.length === 1) {
    return checkSimpleExpression(expressions[0], version);
  } else {
    var startVersion = expressions[0],
      endVersion = expressions[1];

    !(isSimpleVersion(startVersion) && isSimpleVersion(endVersion))
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(
            false,
            'operands to the "-" operator must be simple (no modifiers)'
          )
        : invariant_1(false)
      : void 0;

    return (
      checkSimpleExpression(">=" + startVersion, version) &&
      checkSimpleExpression("<=" + endVersion, version)
    );
  }
}

/**
 * Checks if `range` matches `version`. `range` should be a "simple" range (ie.
 * not a compound range using the " - " or "||" operators).
 *
 * @param {string} range
 * @param {string} version
 * @returns {boolean}
 */
function checkSimpleExpression(range, version) {
  range = range.trim();
  if (range === "") {
    return true;
  }

  var versionComponents = version.split(componentRegex);

  var _getModifierAndCompon = getModifierAndComponents(range),
    modifier = _getModifierAndCompon.modifier,
    rangeComponents = _getModifierAndCompon.rangeComponents;

  switch (modifier) {
    case "<":
      return checkLessThan(versionComponents, rangeComponents);
    case "<=":
      return checkLessThanOrEqual(versionComponents, rangeComponents);
    case ">=":
      return checkGreaterThanOrEqual(versionComponents, rangeComponents);
    case ">":
      return checkGreaterThan(versionComponents, rangeComponents);
    case "~":
    case "~>":
      return checkApproximateVersion(versionComponents, rangeComponents);
    default:
      return checkEqual(versionComponents, rangeComponents);
  }
}

/**
 * Checks whether `a` is less than `b`.
 *
 * @param {array<string>} a
 * @param {array<string>} b
 * @returns {boolean}
 */
function checkLessThan(a, b) {
  return compareComponents(a, b) === -1;
}

/**
 * Checks whether `a` is less than or equal to `b`.
 *
 * @param {array<string>} a
 * @param {array<string>} b
 * @returns {boolean}
 */
function checkLessThanOrEqual(a, b) {
  var result = compareComponents(a, b);
  return result === -1 || result === 0;
}

/**
 * Checks whether `a` is equal to `b`.
 *
 * @param {array<string>} a
 * @param {array<string>} b
 * @returns {boolean}
 */
function checkEqual(a, b) {
  return compareComponents(a, b) === 0;
}

/**
 * Checks whether `a` is greater than or equal to `b`.
 *
 * @param {array<string>} a
 * @param {array<string>} b
 * @returns {boolean}
 */
function checkGreaterThanOrEqual(a, b) {
  var result = compareComponents(a, b);
  return result === 1 || result === 0;
}

/**
 * Checks whether `a` is greater than `b`.
 *
 * @param {array<string>} a
 * @param {array<string>} b
 * @returns {boolean}
 */
function checkGreaterThan(a, b) {
  return compareComponents(a, b) === 1;
}

/**
 * Checks whether `a` is "reasonably close" to `b` (as described in
 * https://www.npmjs.org/doc/misc/semver.html). For example, if `b` is "1.3.1"
 * then "reasonably close" is defined as ">= 1.3.1 and < 1.4".
 *
 * @param {array<string>} a
 * @param {array<string>} b
 * @returns {boolean}
 */
function checkApproximateVersion(a, b) {
  var lowerBound = b.slice();
  var upperBound = b.slice();

  if (upperBound.length > 1) {
    upperBound.pop();
  }
  var lastIndex = upperBound.length - 1;
  var numeric = parseInt(upperBound[lastIndex], 10);
  if (isNumber(numeric)) {
    upperBound[lastIndex] = numeric + 1 + "";
  }

  return checkGreaterThanOrEqual(a, lowerBound) && checkLessThan(a, upperBound);
}

/**
 * Extracts the optional modifier (<, <=, =, >=, >, ~, ~>) and version
 * components from `range`.
 *
 * For example, given `range` ">= 1.2.3" returns an object with a `modifier` of
 * `">="` and `components` of `[1, 2, 3]`.
 *
 * @param {string} range
 * @returns {object}
 */
function getModifierAndComponents(range) {
  var rangeComponents = range.split(componentRegex);
  var matches = rangeComponents[0].match(modifierRegex);
  !matches
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "expected regex to match but it did not")
      : invariant_1(false)
    : void 0;

  return {
    modifier: matches[1],
    rangeComponents: [matches[2]].concat(rangeComponents.slice(1))
  };
}

/**
 * Determines if `number` is a number.
 *
 * @param {mixed} number
 * @returns {boolean}
 */
function isNumber(number) {
  return !isNaN(number) && isFinite(number);
}

/**
 * Tests whether `range` is a "simple" version number without any modifiers
 * (">", "~" etc).
 *
 * @param {string} range
 * @returns {boolean}
 */
function isSimpleVersion(range) {
  return !getModifierAndComponents(range).modifier;
}

/**
 * Zero-pads array `array` until it is at least `length` long.
 *
 * @param {array} array
 * @param {number} length
 */
function zeroPad(array, length) {
  for (var i = array.length; i < length; i++) {
    array[i] = "0";
  }
}

/**
 * Normalizes `a` and `b` in preparation for comparison by doing the following:
 *
 * - zero-pads `a` and `b`
 * - marks any "x", "X" or "*" component in `b` as equivalent by zero-ing it out
 *   in both `a` and `b`
 * - marks any final "*" component in `b` as a greedy wildcard by zero-ing it
 *   and all of its successors in `a`
 *
 * @param {array<string>} a
 * @param {array<string>} b
 * @returns {array<array<string>>}
 */
function normalizeVersions(a, b) {
  a = a.slice();
  b = b.slice();

  zeroPad(a, b.length);

  // mark "x" and "*" components as equal
  for (var i = 0; i < b.length; i++) {
    var matches = b[i].match(/^[x*]$/i);
    if (matches) {
      b[i] = a[i] = "0";

      // final "*" greedily zeros all remaining components
      if (matches[0] === "*" && i === b.length - 1) {
        for (var j = i; j < a.length; j++) {
          a[j] = "0";
        }
      }
    }
  }

  zeroPad(b, a.length);

  return [a, b];
}

/**
 * Returns the numerical -- not the lexicographical -- ordering of `a` and `b`.
 *
 * For example, `10-alpha` is greater than `2-beta`.
 *
 * @param {string} a
 * @param {string} b
 * @returns {number} -1, 0 or 1 to indicate whether `a` is less than, equal to,
 * or greater than `b`, respectively
 */
function compareNumeric(a, b) {
  var aPrefix = a.match(numericRegex)[1];
  var bPrefix = b.match(numericRegex)[1];
  var aNumeric = parseInt(aPrefix, 10);
  var bNumeric = parseInt(bPrefix, 10);

  if (isNumber(aNumeric) && isNumber(bNumeric) && aNumeric !== bNumeric) {
    return compare(aNumeric, bNumeric);
  } else {
    return compare(a, b);
  }
}

/**
 * Returns the ordering of `a` and `b`.
 *
 * @param {string|number} a
 * @param {string|number} b
 * @returns {number} -1, 0 or 1 to indicate whether `a` is less than, equal to,
 * or greater than `b`, respectively
 */
function compare(a, b) {
  !(typeof a === typeof b)
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, '"a" and "b" must be of the same type')
      : invariant_1(false)
    : void 0;

  if (a > b) {
    return 1;
  } else if (a < b) {
    return -1;
  } else {
    return 0;
  }
}

/**
 * Compares arrays of version components.
 *
 * @param {array<string>} a
 * @param {array<string>} b
 * @returns {number} -1, 0 or 1 to indicate whether `a` is less than, equal to,
 * or greater than `b`, respectively
 */
function compareComponents(a, b) {
  var _normalizeVersions = normalizeVersions(a, b),
    aNormalized = _normalizeVersions[0],
    bNormalized = _normalizeVersions[1];

  for (var i = 0; i < bNormalized.length; i++) {
    var result = compareNumeric(aNormalized[i], bNormalized[i]);
    if (result) {
      return result;
    }
  }

  return 0;
}

var VersionRange = {
  /**
   * Checks whether `version` satisfies the `range` specification.
   *
   * We support a subset of the expressions defined in
   * https://www.npmjs.org/doc/misc/semver.html:
   *
   *    version   Must match version exactly
   *    =version  Same as just version
   *    >version  Must be greater than version
   *    >=version Must be greater than or equal to version
   *    <version  Must be less than version
   *    <=version Must be less than or equal to version
   *    ~version  Must be at least version, but less than the next significant
   *              revision above version:
   *              "~1.2.3" is equivalent to ">= 1.2.3 and < 1.3"
   *    ~>version Equivalent to ~version
   *    1.2.x     Must match "1.2.x", where "x" is a wildcard that matches
   *              anything
   *    1.2.*     Similar to "1.2.x", but "*" in the trailing position is a
   *              "greedy" wildcard, so will match any number of additional
   *              components:
   *              "1.2.*" will match "1.2.1", "1.2.1.1", "1.2.1.1.1" etc
   *    *         Any version
   *    ""        (Empty string) Same as *
   *    v1 - v2   Equivalent to ">= v1 and <= v2"
   *    r1 || r2  Passes if either r1 or r2 are satisfied
   *
   * @param {string} range
   * @param {string} version
   * @returns {boolean}
   */
  contains: function contains(range, version) {
    return checkOrExpression(range.trim(), version.trim());
  }
};

var VersionRange_1 = VersionRange;

/**
 * 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.
 *
 */

var hasOwnProperty$1 = Object.prototype.hasOwnProperty;

/**
 * Executes the provided `callback` once for each enumerable own property in the
 * object and constructs a new object from the results. The `callback` is
 * invoked with three arguments:
 *
 *  - the property value
 *  - the property name
 *  - the object being traversed
 *
 * Properties that are added after the call to `mapObject` will not be visited
 * by `callback`. If the values of existing properties are changed, the value
 * passed to `callback` will be the value at the time `mapObject` visits them.
 * Properties that are deleted before being visited are not visited.
 *
 * @grep function objectMap()
 * @grep function objMap()
 *
 * @param {?object} object
 * @param {function} callback
 * @param {*} context
 * @return {?object}
 */
function mapObject(object, callback, context) {
  if (!object) {
    return null;
  }
  var result = {};
  for (var name in object) {
    if (hasOwnProperty$1.call(object, name)) {
      result[name] = callback.call(context, object[name], name, object);
    }
  }
  return result;
}

var mapObject_1 = mapObject;

/**
 * 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 static-only
 */

/**
 * Memoizes the return value of a function that accepts one string argument.
 */

function memoizeStringOnly(callback) {
  var cache = {};
  return function(string) {
    if (!cache.hasOwnProperty(string)) {
      cache[string] = callback.call(this, string);
    }
    return cache[string];
  };
}

var memoizeStringOnly_1 = memoizeStringOnly;

/**
 * Checks to see whether `name` and `version` satisfy `query`.
 *
 * @param {string} name Name of the browser, device, engine or platform
 * @param {?string} version Version of the browser, engine or platform
 * @param {string} query Query of form "Name [range expression]"
 * @param {?function} normalizer Optional pre-processor for range expression
 * @return {boolean}
 */
function compare$1(name, version, query, normalizer) {
  // check for exact match with no version
  if (name === query) {
    return true;
  }

  // check for non-matching names
  if (!query.startsWith(name)) {
    return false;
  }

  // full comparison with version
  var range = query.slice(name.length);
  if (version) {
    range = normalizer ? normalizer(range) : range;
    return VersionRange_1.contains(range, version);
  }

  return false;
}

/**
 * Normalizes `version` by stripping any "NT" prefix, but only on the Windows
 * platform.
 *
 * Mimics the stripping performed by the `UserAgentWindowsPlatform` PHP class.
 *
 * @param {string} version
 * @return {string}
 */
function normalizePlatformVersion(version) {
  if (UserAgentData.platformName === "Windows") {
    return version.replace(/^\s*NT/, "");
  }

  return version;
}

/**
 * Provides client-side access to the authoritative PHP-generated User Agent
 * information supplied by the server.
 */
var UserAgent = {
  /**
   * Check if the User Agent browser matches `query`.
   *
   * `query` should be a string like "Chrome" or "Chrome > 33".
   *
   * Valid browser names include:
   *
   * - ACCESS NetFront
   * - AOL
   * - Amazon Silk
   * - Android
   * - BlackBerry
   * - BlackBerry PlayBook
   * - Chrome
   * - Chrome for iOS
   * - Chrome frame
   * - Facebook PHP SDK
   * - Facebook for iOS
   * - Firefox
   * - IE
   * - IE Mobile
   * - Mobile Safari
   * - Motorola Internet Browser
   * - Nokia
   * - Openwave Mobile Browser
   * - Opera
   * - Opera Mini
   * - Opera Mobile
   * - Safari
   * - UIWebView
   * - Unknown
   * - webOS
   * - etc...
   *
   * An authoritative list can be found in the PHP `BrowserDetector` class and
   * related classes in the same file (see calls to `new UserAgentBrowser` here:
   * https://fburl.com/50728104).
   *
   * @note Function results are memoized
   *
   * @param {string} query Query of the form "Name [range expression]"
   * @return {boolean}
   */
  isBrowser: function isBrowser(query) {
    return compare$1(
      UserAgentData.browserName,
      UserAgentData.browserFullVersion,
      query
    );
  },

  /**
   * Check if the User Agent browser uses a 32 or 64 bit architecture.
   *
   * @note Function results are memoized
   *
   * @param {string} query Query of the form "32" or "64".
   * @return {boolean}
   */
  isBrowserArchitecture: function isBrowserArchitecture(query) {
    return compare$1(UserAgentData.browserArchitecture, null, query);
  },

  /**
   * Check if the User Agent device matches `query`.
   *
   * `query` should be a string like "iPhone" or "iPad".
   *
   * Valid device names include:
   *
   * - Kindle
   * - Kindle Fire
   * - Unknown
   * - iPad
   * - iPhone
   * - iPod
   * - etc...
   *
   * An authoritative list can be found in the PHP `DeviceDetector` class and
   * related classes in the same file (see calls to `new UserAgentDevice` here:
   * https://fburl.com/50728332).
   *
   * @note Function results are memoized
   *
   * @param {string} query Query of the form "Name"
   * @return {boolean}
   */
  isDevice: function isDevice(query) {
    return compare$1(UserAgentData.deviceName, null, query);
  },

  /**
   * Check if the User Agent rendering engine matches `query`.
   *
   * `query` should be a string like "WebKit" or "WebKit >= 537".
   *
   * Valid engine names include:
   *
   * - Gecko
   * - Presto
   * - Trident
   * - WebKit
   * - etc...
   *
   * An authoritative list can be found in the PHP `RenderingEngineDetector`
   * class related classes in the same file (see calls to `new
   * UserAgentRenderingEngine` here: https://fburl.com/50728617).
   *
   * @note Function results are memoized
   *
   * @param {string} query Query of the form "Name [range expression]"
   * @return {boolean}
   */
  isEngine: function isEngine(query) {
    return compare$1(
      UserAgentData.engineName,
      UserAgentData.engineVersion,
      query
    );
  },

  /**
   * Check if the User Agent platform matches `query`.
   *
   * `query` should be a string like "Windows" or "iOS 5 - 6".
   *
   * Valid platform names include:
   *
   * - Android
   * - BlackBerry OS
   * - Java ME
   * - Linux
   * - Mac OS X
   * - Mac OS X Calendar
   * - Mac OS X Internet Account
   * - Symbian
   * - SymbianOS
   * - Windows
   * - Windows Mobile
   * - Windows Phone
   * - iOS
   * - iOS Facebook Integration Account
   * - iOS Facebook Social Sharing UI
   * - webOS
   * - Chrome OS
   * - etc...
   *
   * An authoritative list can be found in the PHP `PlatformDetector` class and
   * related classes in the same file (see calls to `new UserAgentPlatform`
   * here: https://fburl.com/50729226).
   *
   * @note Function results are memoized
   *
   * @param {string} query Query of the form "Name [range expression]"
   * @return {boolean}
   */
  isPlatform: function isPlatform(query) {
    return compare$1(
      UserAgentData.platformName,
      UserAgentData.platformFullVersion,
      query,
      normalizePlatformVersion
    );
  },

  /**
   * Check if the User Agent platform is a 32 or 64 bit architecture.
   *
   * @note Function results are memoized
   *
   * @param {string} query Query of the form "32" or "64".
   * @return {boolean}
   */
  isPlatformArchitecture: function isPlatformArchitecture(query) {
    return compare$1(UserAgentData.platformArchitecture, null, query);
  }
};

var UserAgent_1 = mapObject_1(UserAgent, memoizeStringOnly_1);

function _classCallCheck$9(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _possibleConstructorReturn$6(self, call) {
  if (!self) {
    throw new ReferenceError(
      "this hasn't been initialised - super() hasn't been called"
    );
  }
  return call && (typeof call === "object" || typeof call === "function")
    ? call
    : self;
}

function _inherits$6(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError(
      "Super expression must either be null or a function, not " +
        typeof superClass
    );
  }
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass)
    Object.setPrototypeOf
      ? Object.setPrototypeOf(subClass, superClass)
      : (subClass.__proto__ = superClass);
}

// In IE, spans with <br> tags render as two newlines. By rendering a span
// with only a newline character, we can be sure to render a single line.
var useNewlineChar = UserAgent_1.isBrowser("IE <= 11");

/**
 * Check whether the node should be considered a newline.
 */
function isNewline(node) {
  return useNewlineChar ? node.textContent === "\n" : node.tagName === "BR";
}

/**
 * Placeholder elements for empty text content.
 *
 * What is this `data-text` attribute, anyway? It turns out that we need to
 * put an attribute on the lowest-level text node in order to preserve correct
 * spellcheck handling. If the <span> is naked, Chrome and Safari may do
 * bizarre things to do the DOM -- split text nodes, create extra spans, etc.
 * If the <span> has an attribute, this appears not to happen.
 * See http://jsfiddle.net/9khdavod/ for the failure case, and
 * http://jsfiddle.net/7pg143f7/ for the fixed case.
 */
var NEWLINE_A = useNewlineChar
  ? React__default.createElement(
      "span",
      { key: "A", "data-text": "true" },
      "\n"
    )
  : React__default.createElement("br", { key: "A", "data-text": "true" });

var NEWLINE_B = useNewlineChar
  ? React__default.createElement(
      "span",
      { key: "B", "data-text": "true" },
      "\n"
    )
  : React__default.createElement("br", { key: "B", "data-text": "true" });

/**
 * The lowest-level component in a `DraftEditor`, the text node component
 * replaces the default React text node implementation. This allows us to
 * perform custom handling of newline behavior and avoid re-rendering text
 * nodes with DOM state that already matches the expectations of our immutable
 * editor state.
 */
var DraftEditorTextNode = (function(_React$Component) {
  _inherits$6(DraftEditorTextNode, _React$Component);

  function DraftEditorTextNode(props) {
    _classCallCheck$9(this, DraftEditorTextNode);

    // By flipping this flag, we also keep flipping keys which forces
    // React to remount this node every time it rerenders.
    var _this = _possibleConstructorReturn$6(
      this,
      _React$Component.call(this, props)
    );

    _this._forceFlag = false;
    return _this;
  }

  DraftEditorTextNode.prototype.shouldComponentUpdate = function shouldComponentUpdate(
    nextProps
  ) {
    var node = reactDom__default.findDOMNode(this);
    var shouldBeNewline = nextProps.children === "";
    !(node instanceof Element)
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(false, "node is not an Element")
        : invariant_1(false)
      : void 0;
    if (shouldBeNewline) {
      return !isNewline(node);
    }
    return node.textContent !== nextProps.children;
  };

  DraftEditorTextNode.prototype.componentDidMount = function componentDidMount() {
    this._forceFlag = !this._forceFlag;
  };

  DraftEditorTextNode.prototype.componentDidUpdate = function componentDidUpdate() {
    this._forceFlag = !this._forceFlag;
  };

  DraftEditorTextNode.prototype.render = function render() {
    if (this.props.children === "") {
      return this._forceFlag ? NEWLINE_A : NEWLINE_B;
    }
    return React__default.createElement(
      "span",
      { key: this._forceFlag ? "A" : "B", "data-text": "true" },
      this.props.children
    );
  };

  return DraftEditorTextNode;
})(React__default.Component);

var DraftEditorTextNode_react = DraftEditorTextNode;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule DraftJsDebugLogging
 */

var DraftJsDebugLogging = {
  logSelectionStateFailure: function logSelectionStateFailure() {
    return null;
  }
};

/**
 * 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
 */

/**
 * @param {*} object The object to check.
 * @return {boolean} Whether or not the object is a DOM node.
 */
function isNode(object) {
  var doc = object ? object.ownerDocument || object : document;
  var defaultView = doc.defaultView || window;
  return !!(
    object &&
    (typeof defaultView.Node === "function"
      ? object instanceof defaultView.Node
      : typeof object === "object" &&
        typeof object.nodeType === "number" &&
        typeof object.nodeName === "string")
  );
}

var isNode_1 = isNode;

/**
 * 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
 */

/**
 * @param {*} object The object to check.
 * @return {boolean} Whether or not the object is a DOM text node.
 */
function isTextNode(object) {
  return isNode_1(object) && object.nodeType == 3;
}

var isTextNode_1 = isTextNode;

/**
 * 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.
 *
 *
 */

/*eslint-disable no-bitwise */

/**
 * Checks if a given DOM node contains or is another DOM node.
 */
function containsNode(outerNode, innerNode) {
  if (!outerNode || !innerNode) {
    return false;
  } else if (outerNode === innerNode) {
    return true;
  } else if (isTextNode_1(outerNode)) {
    return false;
  } else if (isTextNode_1(innerNode)) {
    return containsNode(outerNode, innerNode.parentNode);
  } else if ("contains" in outerNode) {
    return outerNode.contains(innerNode);
  } else if (outerNode.compareDocumentPosition) {
    return !!(outerNode.compareDocumentPosition(innerNode) & 16);
  } else {
    return false;
  }
}

var containsNode_1 = containsNode;

/**
 * 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
 */

/* eslint-disable fb-www/typeof-undefined */

/**
 * Same as document.activeElement but wraps in a try-catch block. In IE it is
 * not safe to call document.activeElement if there is nothing focused.
 *
 * The activeElement will be null only if the document or document body is not
 * yet defined.
 *
 * @param {?DOMDocument} doc Defaults to current document.
 * @return {?DOMElement}
 */
function getActiveElement(doc) /*?DOMElement*/ {
  doc = doc || (typeof document !== "undefined" ? document : undefined);
  if (typeof doc === "undefined") {
    return null;
  }
  try {
    return doc.activeElement || doc.body;
  } catch (e) {
    return doc.body;
  }
}

var getActiveElement_1 = getActiveElement;

function getAnonymizedDOM(node, getNodeLabels) {
  if (!node) {
    return "[empty]";
  }

  var anonymized = anonymizeTextWithin(node, getNodeLabels);
  if (anonymized.nodeType === Node.TEXT_NODE) {
    return anonymized.textContent;
  }

  !(anonymized instanceof Element)
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "Node must be an Element if it is not a text node.")
      : invariant_1(false)
    : void 0;
  return anonymized.outerHTML;
}

function anonymizeTextWithin(node, getNodeLabels) {
  var labels = getNodeLabels !== undefined ? getNodeLabels(node) : [];

  if (node.nodeType === Node.TEXT_NODE) {
    var length = node.textContent.length;
    return document.createTextNode(
      "[text " + length + (labels.length ? " | " + labels.join(", ") : "") + "]"
    );
  }

  var clone = node.cloneNode();
  if (clone.nodeType === 1 && labels.length) {
    clone.setAttribute("data-labels", labels.join(", "));
  }
  var childNodes = node.childNodes;
  for (var ii = 0; ii < childNodes.length; ii++) {
    clone.appendChild(anonymizeTextWithin(childNodes[ii], getNodeLabels));
  }

  return clone;
}

function getAnonymizedEditorDOM(node, getNodeLabels) {
  // grabbing the DOM content of the Draft editor
  var currentNode = node;
  while (currentNode) {
    if (
      currentNode instanceof Element &&
      currentNode.hasAttribute("contenteditable")
    ) {
      // found the Draft editor container
      return getAnonymizedDOM(currentNode, getNodeLabels);
    } else {
      currentNode = currentNode.parentNode;
    }
  }
  return "Could not find contentEditable parent of node";
}

function getNodeLength(node) {
  return node.nodeValue === null
    ? node.childNodes.length
    : node.nodeValue.length;
}

/**
 * In modern non-IE browsers, we can support both forward and backward
 * selections.
 *
 * Note: IE10+ supports the Selection object, but it does not support
 * the `extend` method, which means that even in modern IE, it's not possible
 * to programatically create a backward selection. Thus, for all IE
 * versions, we use the old IE API to create our selections.
 */
function setDraftEditorSelection(
  selectionState,
  node,
  blockKey,
  nodeStart,
  nodeEnd
) {
  // It's possible that the editor has been removed from the DOM but
  // our selection code doesn't know it yet. Forcing selection in
  // this case may lead to errors, so just bail now.
  if (!containsNode_1(document.documentElement, node)) {
    return;
  }

  var selection = _commonjsHelpers.commonjsGlobal.getSelection();
  var anchorKey = selectionState.getAnchorKey();
  var anchorOffset = selectionState.getAnchorOffset();
  var focusKey = selectionState.getFocusKey();
  var focusOffset = selectionState.getFocusOffset();
  var isBackward = selectionState.getIsBackward();

  // IE doesn't support backward selection. Swap key/offset pairs.
  if (!selection.extend && isBackward) {
    var tempKey = anchorKey;
    var tempOffset = anchorOffset;
    anchorKey = focusKey;
    anchorOffset = focusOffset;
    focusKey = tempKey;
    focusOffset = tempOffset;
    isBackward = false;
  }

  var hasAnchor =
    anchorKey === blockKey &&
    nodeStart <= anchorOffset &&
    nodeEnd >= anchorOffset;

  var hasFocus =
    focusKey === blockKey && nodeStart <= focusOffset && nodeEnd >= focusOffset;

  // If the selection is entirely bound within this node, set the selection
  // and be done.
  if (hasAnchor && hasFocus) {
    selection.removeAllRanges();
    addPointToSelection(
      selection,
      node,
      anchorOffset - nodeStart,
      selectionState
    );
    addFocusToSelection(
      selection,
      node,
      focusOffset - nodeStart,
      selectionState
    );
    return;
  }

  if (!isBackward) {
    // If the anchor is within this node, set the range start.
    if (hasAnchor) {
      selection.removeAllRanges();
      addPointToSelection(
        selection,
        node,
        anchorOffset - nodeStart,
        selectionState
      );
    }

    // If the focus is within this node, we can assume that we have
    // already set the appropriate start range on the selection, and
    // can simply extend the selection.
    if (hasFocus) {
      addFocusToSelection(
        selection,
        node,
        focusOffset - nodeStart,
        selectionState
      );
    }
  } else {
    // If this node has the focus, set the selection range to be a
    // collapsed range beginning here. Later, when we encounter the anchor,
    // we'll use this information to extend the selection.
    if (hasFocus) {
      selection.removeAllRanges();
      addPointToSelection(
        selection,
        node,
        focusOffset - nodeStart,
        selectionState
      );
    }

    // If this node has the anchor, we may assume that the correct
    // focus information is already stored on the selection object.
    // We keep track of it, reset the selection range, and extend it
    // back to the focus point.
    if (hasAnchor) {
      var storedFocusNode = selection.focusNode;
      var storedFocusOffset = selection.focusOffset;

      selection.removeAllRanges();
      addPointToSelection(
        selection,
        node,
        anchorOffset - nodeStart,
        selectionState
      );
      addFocusToSelection(
        selection,
        storedFocusNode,
        storedFocusOffset,
        selectionState
      );
    }
  }
}

/**
 * Extend selection towards focus point.
 */
function addFocusToSelection(selection, node, offset, selectionState) {
  var activeElement = getActiveElement_1();
  if (selection.extend && containsNode_1(activeElement, node)) {
    // If `extend` is called while another element has focus, an error is
    // thrown. We therefore disable `extend` if the active element is somewhere
    // other than the node we are selecting. This should only occur in Firefox,
    // since it is the only browser to support multiple selections.
    // See https://bugzilla.mozilla.org/show_bug.cgi?id=921444.

    // logging to catch bug that is being reported in t16250795
    if (offset > getNodeLength(node)) {
      // the call to 'selection.extend' is about to throw
      DraftJsDebugLogging.logSelectionStateFailure({
        anonymizedDom: getAnonymizedEditorDOM(node),
        extraParams: JSON.stringify({ offset: offset }),
        selectionState: JSON.stringify(selectionState.toJS())
      });
    }

    // logging to catch bug that is being reported in t18110632
    var nodeWasFocus = node === selection.focusNode;
    try {
      selection.extend(node, offset);
    } catch (e) {
      DraftJsDebugLogging.logSelectionStateFailure({
        anonymizedDom: getAnonymizedEditorDOM(node, function(n) {
          var labels = [];
          if (n === activeElement) {
            labels.push("active element");
          }
          if (n === selection.anchorNode) {
            labels.push("selection anchor node");
          }
          if (n === selection.focusNode) {
            labels.push("selection focus node");
          }
          return labels;
        }),
        extraParams: JSON.stringify(
          {
            activeElementName: activeElement ? activeElement.nodeName : null,
            nodeIsFocus: node === selection.focusNode,
            nodeWasFocus: nodeWasFocus,
            selectionRangeCount: selection.rangeCount,
            selectionAnchorNodeName: selection.anchorNode
              ? selection.anchorNode.nodeName
              : null,
            selectionAnchorOffset: selection.anchorOffset,
            selectionFocusNodeName: selection.focusNode
              ? selection.focusNode.nodeName
              : null,
            selectionFocusOffset: selection.focusOffset,
            message: e ? "" + e : null,
            offset: offset
          },
          null,
          2
        ),
        selectionState: JSON.stringify(selectionState.toJS(), null, 2)
      });
      // allow the error to be thrown -
      // better than continuing in a broken state
      throw e;
    }
  } else {
    // IE doesn't support extend. This will mean no backward selection.
    // Extract the existing selection range and add focus to it.
    // Additionally, clone the selection range. IE11 throws an
    // InvalidStateError when attempting to access selection properties
    // after the range is detached.
    var range = selection.getRangeAt(0);
    range.setEnd(node, offset);
    selection.addRange(range.cloneRange());
  }
}

function addPointToSelection(selection, node, offset, selectionState) {
  var range = document.createRange();
  // logging to catch bug that is being reported in t16250795
  if (offset > getNodeLength(node)) {
    // in this case we know that the call to 'range.setStart' is about to throw
    DraftJsDebugLogging.logSelectionStateFailure({
      anonymizedDom: getAnonymizedEditorDOM(node),
      extraParams: JSON.stringify({ offset: offset }),
      selectionState: JSON.stringify(selectionState.toJS())
    });
  }
  range.setStart(node, offset);
  selection.addRange(range);
}

var setDraftEditorSelection_1 = setDraftEditorSelection;

function _classCallCheck$a(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _possibleConstructorReturn$7(self, call) {
  if (!self) {
    throw new ReferenceError(
      "this hasn't been initialised - super() hasn't been called"
    );
  }
  return call && (typeof call === "object" || typeof call === "function")
    ? call
    : self;
}

function _inherits$7(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError(
      "Super expression must either be null or a function, not " +
        typeof superClass
    );
  }
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass)
    Object.setPrototypeOf
      ? Object.setPrototypeOf(subClass, superClass)
      : (subClass.__proto__ = superClass);
}

/**
 * All leaf nodes in the editor are spans with single text nodes. Leaf
 * elements are styled based on the merging of an optional custom style map
 * and a default style map.
 *
 * `DraftEditorLeaf` also provides a wrapper for calling into the imperative
 * DOM Selection API. In this way, top-level components can declaratively
 * maintain the selection state.
 */
var DraftEditorLeaf = (function(_React$Component) {
  _inherits$7(DraftEditorLeaf, _React$Component);

  function DraftEditorLeaf() {
    _classCallCheck$a(this, DraftEditorLeaf);

    return _possibleConstructorReturn$7(
      this,
      _React$Component.apply(this, arguments)
    );
  }

  DraftEditorLeaf.prototype._setSelection = function _setSelection() {
    var selection = this.props.selection;

    // If selection state is irrelevant to the parent block, no-op.

    if (selection == null || !selection.getHasFocus()) {
      return;
    }

    var _props = this.props,
      block = _props.block,
      start = _props.start,
      text = _props.text;

    var blockKey = block.getKey();
    var end = start + text.length;
    if (!selection.hasEdgeWithin(blockKey, start, end)) {
      return;
    }

    // Determine the appropriate target node for selection. If the child
    // is not a text node, it is a <br /> spacer. In this case, use the
    // <span> itself as the selection target.
    var node = reactDom__default.findDOMNode(this);
    !node
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(false, "Missing node")
        : invariant_1(false)
      : void 0;
    var child = node.firstChild;
    !child
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(false, "Missing child")
        : invariant_1(false)
      : void 0;
    var targetNode = void 0;

    if (child.nodeType === Node.TEXT_NODE) {
      targetNode = child;
    } else if (child.tagName === "BR") {
      targetNode = node;
    } else {
      targetNode = child.firstChild;
      !targetNode
        ? process.env.NODE_ENV !== "production"
          ? invariant_1(false, "Missing targetNode")
          : invariant_1(false)
        : void 0;
    }

    setDraftEditorSelection_1(selection, targetNode, blockKey, start, end);
  };
  /**
   * By making individual leaf instances aware of their context within
   * the text of the editor, we can set our selection range more
   * easily than we could in the non-React world.
   *
   * Note that this depends on our maintaining tight control over the
   * DOM structure of the DraftEditor component. If leaves had multiple
   * text nodes, this would be harder.
   */

  DraftEditorLeaf.prototype.shouldComponentUpdate = function shouldComponentUpdate(
    nextProps
  ) {
    var leafNode = reactDom__default.findDOMNode(this.leaf);
    !leafNode
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(false, "Missing leafNode")
        : invariant_1(false)
      : void 0;
    return (
      leafNode.textContent !== nextProps.text ||
      nextProps.styleSet !== this.props.styleSet ||
      nextProps.forceSelection
    );
  };

  DraftEditorLeaf.prototype.componentDidUpdate = function componentDidUpdate() {
    this._setSelection();
  };

  DraftEditorLeaf.prototype.componentDidMount = function componentDidMount() {
    this._setSelection();
  };

  DraftEditorLeaf.prototype.render = function render() {
    var _this2 = this;

    var block = this.props.block;
    var text = this.props.text;

    // If the leaf is at the end of its block and ends in a soft newline, append
    // an extra line feed character. Browsers collapse trailing newline
    // characters, which leaves the cursor in the wrong place after a
    // shift+enter. The extra character repairs this.

    if (text.endsWith("\n") && this.props.isLast) {
      text += "\n";
    }

    var _props2 = this.props,
      customStyleMap = _props2.customStyleMap,
      customStyleFn = _props2.customStyleFn,
      offsetKey = _props2.offsetKey,
      styleSet = _props2.styleSet;

    var styleObj = styleSet.reduce(function(map, styleName) {
      var mergedStyles = {};
      var style = customStyleMap[styleName];

      if (style !== undefined && map.textDecoration !== style.textDecoration) {
        // .trim() is necessary for IE9/10/11 and Edge
        mergedStyles.textDecoration = [map.textDecoration, style.textDecoration]
          .join(" ")
          .trim();
      }

      return objectAssign(map, style, mergedStyles);
    }, {});

    if (customStyleFn) {
      var newStyles = customStyleFn(styleSet, block);
      styleObj = objectAssign(styleObj, newStyles);
    }

    return React__default.createElement(
      "span",
      {
        "data-offset-key": offsetKey,
        ref: function ref(_ref) {
          return (_this2.leaf = _ref);
        },
        style: styleObj
      },
      React__default.createElement(DraftEditorTextNode_react, null, text)
    );
  };

  return DraftEditorLeaf;
})(React__default.Component);

var DraftEditorLeaf_react = DraftEditorLeaf;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule DraftOffsetKey
 * @format
 *
 */

var KEY_DELIMITER = "-";

var DraftOffsetKey = {
  encode: function encode(blockKey, decoratorKey, leafKey) {
    return blockKey + KEY_DELIMITER + decoratorKey + KEY_DELIMITER + leafKey;
  },

  decode: function decode(offsetKey) {
    var _offsetKey$split = offsetKey.split(KEY_DELIMITER),
      blockKey = _offsetKey$split[0],
      decoratorKey = _offsetKey$split[1],
      leafKey = _offsetKey$split[2];

    return {
      blockKey: blockKey,
      decoratorKey: parseInt(decoratorKey, 10),
      leafKey: parseInt(leafKey, 10)
    };
  }
};

var DraftOffsetKey_1 = DraftOffsetKey;

/**
 * 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.
 *
 */

/**
 * @param {DOMElement} element
 * @param {DOMDocument} doc
 * @return {boolean}
 */
function _isViewportScrollElement(element, doc) {
  return !!doc && (element === doc.documentElement || element === doc.body);
}

/**
 * Scroll Module. This class contains 4 simple static functions
 * to be used to access Element.scrollTop/scrollLeft properties.
 * To solve the inconsistencies between browsers when either
 * document.body or document.documentElement is supplied,
 * below logic will be used to alleviate the issue:
 *
 * 1. If 'element' is either 'document.body' or 'document.documentElement,
 *    get whichever element's 'scroll{Top,Left}' is larger.
 * 2. If 'element' is either 'document.body' or 'document.documentElement',
 *    set the 'scroll{Top,Left}' on both elements.
 */

var Scroll = {
  /**
   * @param {DOMElement} element
   * @return {number}
   */
  getTop: function getTop(element) {
    var doc = element.ownerDocument;
    return _isViewportScrollElement(element, doc)
      ? // In practice, they will either both have the same value,
        // or one will be zero and the other will be the scroll position
        // of the viewport. So we can use `X || Y` instead of `Math.max(X, Y)`
        doc.body.scrollTop || doc.documentElement.scrollTop
      : element.scrollTop;
  },

  /**
   * @param {DOMElement} element
   * @param {number} newTop
   */
  setTop: function setTop(element, newTop) {
    var doc = element.ownerDocument;
    if (_isViewportScrollElement(element, doc)) {
      doc.body.scrollTop = doc.documentElement.scrollTop = newTop;
    } else {
      element.scrollTop = newTop;
    }
  },

  /**
   * @param {DOMElement} element
   * @return {number}
   */
  getLeft: function getLeft(element) {
    var doc = element.ownerDocument;
    return _isViewportScrollElement(element, doc)
      ? doc.body.scrollLeft || doc.documentElement.scrollLeft
      : element.scrollLeft;
  },

  /**
   * @param {DOMElement} element
   * @param {number} newLeft
   */
  setLeft: function setLeft(element, newLeft) {
    var doc = element.ownerDocument;
    if (_isViewportScrollElement(element, doc)) {
      doc.body.scrollLeft = doc.documentElement.scrollLeft = newLeft;
    } else {
      element.scrollLeft = newLeft;
    }
  }
};

var Scroll_1 = Scroll;

/**
 * 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 _hyphenPattern = /-(.)/g;

/**
 * Camelcases a hyphenated string, for example:
 *
 *   > camelize('background-color')
 *   < "backgroundColor"
 *
 * @param {string} string
 * @return {string}
 */
function camelize(string) {
  return string.replace(_hyphenPattern, function(_, character) {
    return character.toUpperCase();
  });
}

var camelize_1 = camelize;

/**
 * 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 _uppercasePattern = /([A-Z])/g;

/**
 * Hyphenates a camelcased string, for example:
 *
 *   > hyphenate('backgroundColor')
 *   < "background-color"
 *
 * For CSS style names, use `hyphenateStyleName` instead which works properly
 * with all vendor prefixes, including `ms`.
 *
 * @param {string} string
 * @return {string}
 */
function hyphenate(string) {
  return string.replace(_uppercasePattern, "-$1").toLowerCase();
}

var hyphenate_1 = hyphenate;

/**
 * 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
 */

function asString(value) /*?string*/ {
  return value == null ? value : String(value);
}

function getStyleProperty(/*DOMNode*/ node, /*string*/ name) /*?string*/ {
  var computedStyle = void 0;

  // W3C Standard
  if (window.getComputedStyle) {
    // In certain cases such as within an iframe in FF3, this returns null.
    computedStyle = window.getComputedStyle(node, null);
    if (computedStyle) {
      return asString(computedStyle.getPropertyValue(hyphenate_1(name)));
    }
  }
  // Safari
  if (document.defaultView && document.defaultView.getComputedStyle) {
    computedStyle = document.defaultView.getComputedStyle(node, null);
    // A Safari bug causes this to return null for `display: none` elements.
    if (computedStyle) {
      return asString(computedStyle.getPropertyValue(hyphenate_1(name)));
    }
    if (name === "display") {
      return "none";
    }
  }
  // Internet Explorer
  if (node.currentStyle) {
    if (name === "float") {
      return asString(
        node.currentStyle.cssFloat || node.currentStyle.styleFloat
      );
    }
    return asString(node.currentStyle[camelize_1(name)]);
  }
  return asString(node.style && node.style[camelize_1(name)]);
}

var getStyleProperty_1 = getStyleProperty;

/**
 * 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
 */

/**
 * @param {DOMNode} element [description]
 * @param {string} name Overflow style property name.
 * @return {boolean} True if the supplied ndoe is scrollable.
 */
function _isNodeScrollable(element, name) {
  var overflow = Style.get(element, name);
  return overflow === "auto" || overflow === "scroll";
}

/**
 * Utilities for querying and mutating style properties.
 */
var Style = {
  /**
   * Gets the style property for the supplied node. This will return either the
   * computed style, if available, or the declared style.
   *
   * @param {DOMNode} node
   * @param {string} name Style property name.
   * @return {?string} Style property value.
   */
  get: getStyleProperty_1,

  /**
   * Determines the nearest ancestor of a node that is scrollable.
   *
   * NOTE: This can be expensive if used repeatedly or on a node nested deeply.
   *
   * @param {?DOMNode} node Node from which to start searching.
   * @return {?DOMWindow|DOMElement} Scroll parent of the supplied node.
   */
  getScrollParent: function getScrollParent(node) {
    if (!node) {
      return null;
    }
    var ownerDocument = node.ownerDocument;
    while (node && node !== ownerDocument.body) {
      if (
        _isNodeScrollable(node, "overflow") ||
        _isNodeScrollable(node, "overflowY") ||
        _isNodeScrollable(node, "overflowX")
      ) {
        return node;
      }
      node = node.parentNode;
    }
    return ownerDocument.defaultView || ownerDocument.parentWindow;
  }
};

var Style_1 = Style;

/**
 * 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
 */

/**
 * Gets an element's bounding rect in pixels relative to the viewport.
 *
 * @param {DOMElement} elem
 * @return {object}
 */
function getElementRect(elem) {
  var docElem = elem.ownerDocument.documentElement;

  // FF 2, Safari 3 and Opera 9.5- do not support getBoundingClientRect().
  // IE9- will throw if the element is not in the document.
  if (!("getBoundingClientRect" in elem) || !containsNode_1(docElem, elem)) {
    return {
      left: 0,
      right: 0,
      top: 0,
      bottom: 0
    };
  }

  // Subtracts clientTop/Left because IE8- added a 2px border to the
  // <html> element (see http://fburl.com/1493213). IE 7 in
  // Quicksmode does not report clientLeft/clientTop so there
  // will be an unaccounted offset of 2px when in quirksmode
  var rect = elem.getBoundingClientRect();

  return {
    left: Math.round(rect.left) - docElem.clientLeft,
    right: Math.round(rect.right) - docElem.clientLeft,
    top: Math.round(rect.top) - docElem.clientTop,
    bottom: Math.round(rect.bottom) - docElem.clientTop
  };
}

var getElementRect_1 = getElementRect;

/**
 * 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
 */

/**
 * Gets an element's position in pixels relative to the viewport. The returned
 * object represents the position of the element's top left corner.
 *
 * @param {DOMElement} element
 * @return {object}
 */
function getElementPosition(element) {
  var rect = getElementRect_1(element);
  return {
    x: rect.left,
    y: rect.top,
    width: rect.right - rect.left,
    height: rect.bottom - rect.top
  };
}

var getElementPosition_1 = getElementPosition;

/**
 * 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 isWebkit =
  typeof navigator !== "undefined" &&
  navigator.userAgent.indexOf("AppleWebKit") > -1;

/**
 * Gets the element with the document scroll properties such as `scrollLeft` and
 * `scrollHeight`. This may differ across different browsers.
 *
 * NOTE: The return value can be null if the DOM is not yet ready.
 *
 * @param {?DOMDocument} doc Defaults to current document.
 * @return {?DOMElement}
 */
function getDocumentScrollElement(doc) {
  doc = doc || document;
  if (doc.scrollingElement) {
    return doc.scrollingElement;
  }
  return !isWebkit && doc.compatMode === "CSS1Compat"
    ? doc.documentElement
    : doc.body;
}

var getDocumentScrollElement_1 = getDocumentScrollElement;

/**
 * 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
 */

/**
 * Gets the scroll position of the supplied element or window.
 *
 * The return values are unbounded, unlike `getScrollPosition`. This means they
 * may be negative or exceed the element boundaries (which is possible using
 * inertial scrolling).
 *
 * @param {DOMWindow|DOMElement} scrollable
 * @return {object} Map with `x` and `y` keys.
 */

function getUnboundedScrollPosition(scrollable) {
  if (scrollable.Window && scrollable instanceof scrollable.Window) {
    return {
      x:
        scrollable.pageXOffset ||
        scrollable.document.documentElement.scrollLeft,
      y: scrollable.pageYOffset || scrollable.document.documentElement.scrollTop
    };
  }
  return {
    x: scrollable.scrollLeft,
    y: scrollable.scrollTop
  };
}

var getUnboundedScrollPosition_1 = getUnboundedScrollPosition;

/**
 * Gets the scroll position of the supplied element or window.
 *
 * The return values are bounded. This means that if the scroll position is
 * negative or exceeds the element boundaries (which is possible using inertial
 * scrolling), you will get zero or the maximum scroll position, respectively.
 *
 * If you need the unbound scroll position, use `getUnboundedScrollPosition`.
 *
 * @param {DOMWindow|DOMElement} scrollable
 * @return {object} Map with `x` and `y` keys.
 */
function getScrollPosition(scrollable) {
  var documentScrollElement = getDocumentScrollElement_1(
    scrollable.ownerDocument || scrollable.document
  );
  if (scrollable.Window && scrollable instanceof scrollable.Window) {
    scrollable = documentScrollElement;
  }
  var scrollPosition = getUnboundedScrollPosition_1(scrollable);

  var viewport =
    scrollable === documentScrollElement
      ? scrollable.ownerDocument.documentElement
      : scrollable;

  var xMax = scrollable.scrollWidth - viewport.clientWidth;
  var yMax = scrollable.scrollHeight - viewport.clientHeight;

  scrollPosition.x = Math.max(0, Math.min(scrollPosition.x, xMax));
  scrollPosition.y = Math.max(0, Math.min(scrollPosition.y, yMax));

  return scrollPosition;
}

var getScrollPosition_1 = getScrollPosition;

function getViewportWidth() {
  var width = void 0;
  if (document.documentElement) {
    width = document.documentElement.clientWidth;
  }

  if (!width && document.body) {
    width = document.body.clientWidth;
  }

  return width || 0;
}
/**
 * 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
 */

function getViewportHeight() {
  var height = void 0;
  if (document.documentElement) {
    height = document.documentElement.clientHeight;
  }

  if (!height && document.body) {
    height = document.body.clientHeight;
  }

  return height || 0;
}

/**
 * Gets the viewport dimensions including any scrollbars.
 */
function getViewportDimensions() {
  return {
    width: window.innerWidth || getViewportWidth(),
    height: window.innerHeight || getViewportHeight()
  };
}

/**
 * Gets the viewport dimensions excluding any scrollbars.
 */
getViewportDimensions.withoutScrollbars = function() {
  return {
    width: getViewportWidth(),
    height: getViewportHeight()
  };
};

var getViewportDimensions_1 = getViewportDimensions;

var _extends$2 =
  objectAssign ||
  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;
  };

function _classCallCheck$b(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _possibleConstructorReturn$8(self, call) {
  if (!self) {
    throw new ReferenceError(
      "this hasn't been initialised - super() hasn't been called"
    );
  }
  return call && (typeof call === "object" || typeof call === "function")
    ? call
    : self;
}

function _inherits$8(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError(
      "Super expression must either be null or a function, not " +
        typeof superClass
    );
  }
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass)
    Object.setPrototypeOf
      ? Object.setPrototypeOf(subClass, superClass)
      : (subClass.__proto__ = superClass);
}

var SCROLL_BUFFER = 10;

/**
 * Return whether a block overlaps with either edge of the `SelectionState`.
 */
var isBlockOnSelectionEdge = function isBlockOnSelectionEdge(selection, key) {
  return selection.getAnchorKey() === key || selection.getFocusKey() === key;
};

/**
 * The default block renderer for a `DraftEditor` component.
 *
 * A `DraftEditorBlock` is able to render a given `ContentBlock` to its
 * appropriate decorator and inline style components.
 */

var DraftEditorBlock = (function(_React$Component) {
  _inherits$8(DraftEditorBlock, _React$Component);

  function DraftEditorBlock() {
    _classCallCheck$b(this, DraftEditorBlock);

    return _possibleConstructorReturn$8(
      this,
      _React$Component.apply(this, arguments)
    );
  }

  DraftEditorBlock.prototype.shouldComponentUpdate = function shouldComponentUpdate(
    nextProps
  ) {
    return (
      this.props.block !== nextProps.block ||
      this.props.tree !== nextProps.tree ||
      this.props.direction !== nextProps.direction ||
      (isBlockOnSelectionEdge(nextProps.selection, nextProps.block.getKey()) &&
        nextProps.forceSelection)
    );
  };

  /**
   * When a block is mounted and overlaps the selection state, we need to make
   * sure that the cursor is visible to match native behavior. This may not
   * be the case if the user has pressed `RETURN` or pasted some content, since
   * programatically creating these new blocks and setting the DOM selection
   * will miss out on the browser natively scrolling to that position.
   *
   * To replicate native behavior, if the block overlaps the selection state
   * on mount, force the scroll position. Check the scroll state of the scroll
   * parent, and adjust it to align the entire block to the bottom of the
   * scroll parent.
   */

  DraftEditorBlock.prototype.componentDidMount = function componentDidMount() {
    var selection = this.props.selection;
    var endKey = selection.getEndKey();
    if (!selection.getHasFocus() || endKey !== this.props.block.getKey()) {
      return;
    }

    var blockNode = reactDom__default.findDOMNode(this);
    var scrollParent = Style_1.getScrollParent(blockNode);
    var scrollPosition = getScrollPosition_1(scrollParent);
    var scrollDelta = void 0;

    if (scrollParent === window) {
      var nodePosition = getElementPosition_1(blockNode);
      var nodeBottom = nodePosition.y + nodePosition.height;
      var viewportHeight = getViewportDimensions_1().height;
      scrollDelta = nodeBottom - viewportHeight;
      if (scrollDelta > 0) {
        window.scrollTo(
          scrollPosition.x,
          scrollPosition.y + scrollDelta + SCROLL_BUFFER
        );
      }
    } else {
      !(blockNode instanceof HTMLElement)
        ? process.env.NODE_ENV !== "production"
          ? invariant_1(false, "blockNode is not an HTMLElement")
          : invariant_1(false)
        : void 0;
      var blockBottom = blockNode.offsetHeight + blockNode.offsetTop;
      var scrollBottom = scrollParent.offsetHeight + scrollPosition.y;
      scrollDelta = blockBottom - scrollBottom;
      if (scrollDelta > 0) {
        Scroll_1.setTop(
          scrollParent,
          Scroll_1.getTop(scrollParent) + scrollDelta + SCROLL_BUFFER
        );
      }
    }
  };

  DraftEditorBlock.prototype._renderChildren = function _renderChildren() {
    var _this2 = this;

    var block = this.props.block;
    var blockKey = block.getKey();
    var text = block.getText();
    var lastLeafSet = this.props.tree.size - 1;
    var hasSelection = isBlockOnSelectionEdge(this.props.selection, blockKey);

    return this.props.tree
      .map(function(leafSet, ii) {
        var leavesForLeafSet = leafSet.get("leaves");
        var lastLeaf = leavesForLeafSet.size - 1;
        var leaves = leavesForLeafSet
          .map(function(leaf, jj) {
            var offsetKey = DraftOffsetKey_1.encode(blockKey, ii, jj);
            var start = leaf.get("start");
            var end = leaf.get("end");
            return React__default.createElement(DraftEditorLeaf_react, {
              key: offsetKey,
              offsetKey: offsetKey,
              block: block,
              start: start,
              selection: hasSelection ? _this2.props.selection : null,
              forceSelection: _this2.props.forceSelection,
              text: text.slice(start, end),
              styleSet: block.getInlineStyleAt(start),
              customStyleMap: _this2.props.customStyleMap,
              customStyleFn: _this2.props.customStyleFn,
              isLast: ii === lastLeafSet && jj === lastLeaf
            });
          })
          .toArray();

        var decoratorKey = leafSet.get("decoratorKey");
        if (decoratorKey == null) {
          return leaves;
        }

        if (!_this2.props.decorator) {
          return leaves;
        }

        var decorator = nullthrows_1(_this2.props.decorator);

        var DecoratorComponent = decorator.getComponentForKey(decoratorKey);
        if (!DecoratorComponent) {
          return leaves;
        }

        var decoratorProps = decorator.getPropsForKey(decoratorKey);
        var decoratorOffsetKey = DraftOffsetKey_1.encode(blockKey, ii, 0);
        var decoratedText = text.slice(
          leavesForLeafSet.first().get("start"),
          leavesForLeafSet.last().get("end")
        );

        // Resetting dir to the same value on a child node makes Chrome/Firefox
        // confused on cursor movement. See http://jsfiddle.net/d157kLck/3/
        var dir = UnicodeBidiDirection_1.getHTMLDirIfDifferent(
          UnicodeBidi_1.getDirection(decoratedText),
          _this2.props.direction
        );

        return React__default.createElement(
          DecoratorComponent,
          _extends$2({}, decoratorProps, {
            contentState: _this2.props.contentState,
            decoratedText: decoratedText,
            dir: dir,
            key: decoratorOffsetKey,
            entityKey: block.getEntityAt(leafSet.get("start")),
            offsetKey: decoratorOffsetKey
          }),
          leaves
        );
      })
      .toArray();
  };

  DraftEditorBlock.prototype.render = function render() {
    var _props = this.props,
      direction = _props.direction,
      offsetKey = _props.offsetKey;

    var className = cx_1({
      "public/DraftStyleDefault/block": true,
      "public/DraftStyleDefault/ltr": direction === "LTR",
      "public/DraftStyleDefault/rtl": direction === "RTL"
    });

    return React__default.createElement(
      "div",
      { "data-offset-key": offsetKey, className: className },
      this._renderChildren()
    );
  };

  return DraftEditorBlock;
})(React__default.Component);

var DraftEditorBlock_react = DraftEditorBlock;

/**
 * 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 static-only
 */

/**
 * Combines multiple className strings into one.
 * http://jsperf.com/joinclasses-args-vs-array
 *
 * @param {...?string} className
 * @return {string}
 */

function joinClasses(className /*, ... */) {
  if (!className) {
    className = "";
  }
  var nextClass = void 0;
  var argLength = arguments.length;
  if (argLength > 1) {
    for (var ii = 1; ii < argLength; ii++) {
      nextClass = arguments[ii];
      if (nextClass) {
        className = (className ? className + " " : "") + nextClass;
      }
    }
  }
  return className;
}

var joinClasses_1 = joinClasses;

var _extends$3 =
  objectAssign ||
  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;
  };

function _classCallCheck$c(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _possibleConstructorReturn$9(self, call) {
  if (!self) {
    throw new ReferenceError(
      "this hasn't been initialised - super() hasn't been called"
    );
  }
  return call && (typeof call === "object" || typeof call === "function")
    ? call
    : self;
}

function _inherits$9(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError(
      "Super expression must either be null or a function, not " +
        typeof superClass
    );
  }
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass)
    Object.setPrototypeOf
      ? Object.setPrototypeOf(subClass, superClass)
      : (subClass.__proto__ = superClass);
}

/**
 * Provide default styling for list items. This way, lists will be styled with
 * proper counters and indentation even if the caller does not specify
 * their own styling at all. If more than five levels of nesting are needed,
 * the necessary CSS classes can be provided via `blockStyleFn` configuration.
 */
var getListItemClasses = function getListItemClasses(
  type,
  depth,
  shouldResetCount,
  direction
) {
  return cx_1({
    "public/DraftStyleDefault/unorderedListItem":
      type === "unordered-list-item",
    "public/DraftStyleDefault/orderedListItem": type === "ordered-list-item",
    "public/DraftStyleDefault/reset": shouldResetCount,
    "public/DraftStyleDefault/depth0": depth === 0,
    "public/DraftStyleDefault/depth1": depth === 1,
    "public/DraftStyleDefault/depth2": depth === 2,
    "public/DraftStyleDefault/depth3": depth === 3,
    "public/DraftStyleDefault/depth4": depth === 4,
    "public/DraftStyleDefault/listLTR": direction === "LTR",
    "public/DraftStyleDefault/listRTL": direction === "RTL"
  });
};

/**
 * `DraftEditorContents` is the container component for all block components
 * rendered for a `DraftEditor`. It is optimized to aggressively avoid
 * re-rendering blocks whenever possible.
 *
 * This component is separate from `DraftEditor` because certain props
 * (for instance, ARIA props) must be allowed to update without affecting
 * the contents of the editor.
 */

var DraftEditorContents = (function(_React$Component) {
  _inherits$9(DraftEditorContents, _React$Component);

  function DraftEditorContents() {
    _classCallCheck$c(this, DraftEditorContents);

    return _possibleConstructorReturn$9(
      this,
      _React$Component.apply(this, arguments)
    );
  }

  DraftEditorContents.prototype.shouldComponentUpdate = function shouldComponentUpdate(
    nextProps
  ) {
    var prevEditorState = this.props.editorState;
    var nextEditorState = nextProps.editorState;

    var prevDirectionMap = prevEditorState.getDirectionMap();
    var nextDirectionMap = nextEditorState.getDirectionMap();

    // Text direction has changed for one or more blocks. We must re-render.
    if (prevDirectionMap !== nextDirectionMap) {
      return true;
    }

    var didHaveFocus = prevEditorState.getSelection().getHasFocus();
    var nowHasFocus = nextEditorState.getSelection().getHasFocus();

    if (didHaveFocus !== nowHasFocus) {
      return true;
    }

    var nextNativeContent = nextEditorState.getNativelyRenderedContent();

    var wasComposing = prevEditorState.isInCompositionMode();
    var nowComposing = nextEditorState.isInCompositionMode();

    // If the state is unchanged or we're currently rendering a natively
    // rendered state, there's nothing new to be done.
    if (
      prevEditorState === nextEditorState ||
      (nextNativeContent !== null &&
        nextEditorState.getCurrentContent() === nextNativeContent) ||
      (wasComposing && nowComposing)
    ) {
      return false;
    }

    var prevContent = prevEditorState.getCurrentContent();
    var nextContent = nextEditorState.getCurrentContent();
    var prevDecorator = prevEditorState.getDecorator();
    var nextDecorator = nextEditorState.getDecorator();
    return (
      wasComposing !== nowComposing ||
      prevContent !== nextContent ||
      prevDecorator !== nextDecorator ||
      nextEditorState.mustForceSelection()
    );
  };

  DraftEditorContents.prototype.render = function render() {
    var _props = this.props,
      blockRenderMap = _props.blockRenderMap,
      blockRendererFn = _props.blockRendererFn,
      blockStyleFn = _props.blockStyleFn,
      customStyleMap = _props.customStyleMap,
      customStyleFn = _props.customStyleFn,
      editorState = _props.editorState,
      editorKey = _props.editorKey,
      textDirectionality = _props.textDirectionality;

    var content = editorState.getCurrentContent();
    var selection = editorState.getSelection();
    var forceSelection = editorState.mustForceSelection();
    var decorator = editorState.getDecorator();
    var directionMap = nullthrows_1(editorState.getDirectionMap());

    var blocksAsArray = content.getBlocksAsArray();
    var processedBlocks = [];

    var currentDepth = null;
    var lastWrapperTemplate = null;

    for (var ii = 0; ii < blocksAsArray.length; ii++) {
      var _block = blocksAsArray[ii];
      var key = _block.getKey();
      var blockType = _block.getType();

      var customRenderer = blockRendererFn(_block);
      var CustomComponent = void 0,
        customProps = void 0,
        customEditable = void 0;
      if (customRenderer) {
        CustomComponent = customRenderer.component;
        customProps = customRenderer.props;
        customEditable = customRenderer.editable;
      }

      var direction = textDirectionality
        ? textDirectionality
        : directionMap.get(key);
      var offsetKey = DraftOffsetKey_1.encode(key, 0, 0);
      var componentProps = {
        contentState: content,
        block: _block,
        blockProps: customProps,
        blockStyleFn: blockStyleFn,
        customStyleMap: customStyleMap,
        customStyleFn: customStyleFn,
        decorator: decorator,
        direction: direction,
        forceSelection: forceSelection,
        key: key,
        offsetKey: offsetKey,
        selection: selection,
        tree: editorState.getBlockTree(key)
      };

      var configForType =
        blockRenderMap.get(blockType) || blockRenderMap.get("unstyled");
      var wrapperTemplate = configForType.wrapper;

      var Element =
        configForType.element || blockRenderMap.get("unstyled").element;

      var depth = _block.getDepth();
      var className = "";
      if (blockStyleFn) {
        className = blockStyleFn(_block);
      }

      // List items are special snowflakes, since we handle nesting and
      // counters manually.
      if (Element === "li") {
        var shouldResetCount =
          lastWrapperTemplate !== wrapperTemplate ||
          currentDepth === null ||
          depth > currentDepth;
        className = joinClasses_1(
          className,
          getListItemClasses(blockType, depth, shouldResetCount, direction)
        );
      }

      var Component = CustomComponent || DraftEditorBlock_react;
      var childProps = {
        className: className,
        "data-block": true,
        "data-editor": editorKey,
        "data-offset-key": offsetKey,
        key: key
      };
      if (customEditable !== undefined) {
        childProps = _extends$3({}, childProps, {
          contentEditable: customEditable,
          suppressContentEditableWarning: true
        });
      }

      var child = React__default.createElement(
        Element,
        childProps,
        React__default.createElement(Component, componentProps)
      );

      processedBlocks.push({
        block: child,
        wrapperTemplate: wrapperTemplate,
        key: key,
        offsetKey: offsetKey
      });

      if (wrapperTemplate) {
        currentDepth = _block.getDepth();
      } else {
        currentDepth = null;
      }
      lastWrapperTemplate = wrapperTemplate;
    }

    // Group contiguous runs of blocks that have the same wrapperTemplate
    var outputBlocks = [];
    for (var _ii = 0; _ii < processedBlocks.length; ) {
      var info = processedBlocks[_ii];
      if (info.wrapperTemplate) {
        var blocks = [];
        do {
          blocks.push(processedBlocks[_ii].block);
          _ii++;
        } while (
          _ii < processedBlocks.length &&
          processedBlocks[_ii].wrapperTemplate === info.wrapperTemplate
        );
        var wrapperElement = React__default.cloneElement(
          info.wrapperTemplate,
          {
            key: info.key + "-wrap",
            "data-offset-key": info.offsetKey
          },
          blocks
        );
        outputBlocks.push(wrapperElement);
      } else {
        outputBlocks.push(info.block);
        _ii++;
      }
    }

    return React__default.createElement(
      "div",
      { "data-contents": "true" },
      outputBlocks
    );
  };

  return DraftEditorContents;
})(React__default.Component);

var DraftEditorContentsCore_react = DraftEditorContents;

var DraftEditorContents_react = DraftEditorContentsCore_react;

/**
 * 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.
 *
 */
var PhotosMimeType = {
  isImage: function isImage(mimeString) {
    return getParts(mimeString)[0] === "image";
  },
  isJpeg: function isJpeg(mimeString) {
    var parts = getParts(mimeString);
    return (
      PhotosMimeType.isImage(mimeString) &&
      // see http://fburl.com/10972194
      (parts[1] === "jpeg" || parts[1] === "pjpeg")
    );
  }
};

function getParts(mimeString) {
  return mimeString.split("/");
}

var PhotosMimeType_1 = PhotosMimeType;

/**
 * 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
 */

/**
 * Convert array-like objects to arrays.
 *
 * This API assumes the caller knows the contents of the data type. For less
 * well defined inputs use createArrayFromMixed.
 *
 * @param {object|function|filelist} obj
 * @return {array}
 */
function toArray(obj) {
  var length = obj.length;

  // Some browsers builtin objects can report typeof 'function' (e.g. NodeList
  // in old versions of Safari).
  !(
    !Array.isArray(obj) &&
    (typeof obj === "object" || typeof obj === "function")
  )
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "toArray: Array-like object expected")
      : invariant_1(false)
    : void 0;

  !(typeof length === "number")
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "toArray: Object needs a length property")
      : invariant_1(false)
    : void 0;

  !(length === 0 || length - 1 in obj)
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "toArray: Object should have keys for indices")
      : invariant_1(false)
    : void 0;

  !(typeof obj.callee !== "function")
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(
          false,
          "toArray: Object can't be `arguments`. Use rest params " +
            "(function(...args) {}) or Array.from() instead."
        )
      : invariant_1(false)
    : void 0;

  // Old IE doesn't give collections access to hasOwnProperty. Assume inputs
  // without method will throw during the slice call and skip straight to the
  // fallback.
  if (obj.hasOwnProperty) {
    try {
      return Array.prototype.slice.call(obj);
    } catch (e) {
      // IE < 9 does not support Array#slice on collections objects
    }
  }

  // Fall back to copying key by key. This assumes all keys have a value,
  // so will not preserve sparsely populated inputs.
  var ret = Array(length);
  for (var ii = 0; ii < length; ii++) {
    ret[ii] = obj[ii];
  }
  return ret;
}

/**
 * Perform a heuristic test to determine if an object is "array-like".
 *
 *   A monk asked Joshu, a Zen master, "Has a dog Buddha nature?"
 *   Joshu replied: "Mu."
 *
 * This function determines if its argument has "array nature": it returns
 * true if the argument is an actual array, an `arguments' object, or an
 * HTMLCollection (e.g. node.childNodes or node.getElementsByTagName()).
 *
 * It will return false for other array-like objects like Filelist.
 *
 * @param {*} obj
 * @return {boolean}
 */
function hasArrayNature(obj) {
  return (
    // not null/false
    !!obj &&
    // arrays are objects, NodeLists are functions in Safari
    (typeof obj == "object" || typeof obj == "function") &&
    // quacks like an array
    "length" in obj &&
    // not window
    !("setInterval" in obj) &&
    // no DOM node should be considered an array-like
    // a 'select' element has 'length' and 'item' properties on IE8
    typeof obj.nodeType != "number" &&
    // a real array
    (Array.isArray(obj) ||
      // arguments
      "callee" in obj ||
      // HTMLCollection/NodeList
      "item" in obj)
  );
}

/**
 * Ensure that the argument is an array by wrapping it in an array if it is not.
 * Creates a copy of the argument if it is already an array.
 *
 * This is mostly useful idiomatically:
 *
 *   var createArrayFromMixed = require('createArrayFromMixed');
 *
 *   function takesOneOrMoreThings(things) {
 *     things = createArrayFromMixed(things);
 *     ...
 *   }
 *
 * This allows you to treat `things' as an array, but accept scalars in the API.
 *
 * If you need to convert an array-like object, like `arguments`, into an array
 * use toArray instead.
 *
 * @param {*} obj
 * @return {array}
 */
function createArrayFromMixed(obj) {
  if (!hasArrayNature(obj)) {
    return [obj];
  } else if (Array.isArray(obj)) {
    return obj.slice();
  } else {
    return toArray(obj);
  }
}

var createArrayFromMixed_1 = createArrayFromMixed;

function _classCallCheck$d(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

/**
 * 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 CR_LF_REGEX = new RegExp("\r\n", "g");
var LF_ONLY = "\n";

var RICH_TEXT_TYPES = {
  "text/rtf": 1,
  "text/html": 1
};

/**
 * If DataTransferItem is a file then return the Blob of data.
 *
 * @param {object} item
 * @return {?blob}
 */
function getFileFromDataTransfer(item) {
  if (item.kind == "file") {
    return item.getAsFile();
  }
}

var DataTransfer = (function() {
  /**
   * @param {object} data
   */
  function DataTransfer(data) {
    _classCallCheck$d(this, DataTransfer);

    this.data = data;

    // Types could be DOMStringList or array
    this.types = data.types ? createArrayFromMixed_1(data.types) : [];
  }

  /**
   * Is this likely to be a rich text data transfer?
   *
   * @return {boolean}
   */

  DataTransfer.prototype.isRichText = function isRichText() {
    // If HTML is available, treat this data as rich text. This way, we avoid
    // using a pasted image if it is packaged with HTML -- this may occur with
    // pastes from MS Word, for example.  However this is only rich text if
    // there's accompanying text.
    if (this.getHTML() && this.getText()) {
      return true;
    }

    // When an image is copied from a preview window, you end up with two
    // DataTransferItems one of which is a file's metadata as text.  Skip those.
    if (this.isImage()) {
      return false;
    }

    return this.types.some(function(type) {
      return RICH_TEXT_TYPES[type];
    });
  };

  /**
   * Get raw text.
   *
   * @return {?string}
   */

  DataTransfer.prototype.getText = function getText() {
    var text;
    if (this.data.getData) {
      if (!this.types.length) {
        text = this.data.getData("Text");
      } else if (this.types.indexOf("text/plain") != -1) {
        text = this.data.getData("text/plain");
      }
    }
    return text ? text.replace(CR_LF_REGEX, LF_ONLY) : null;
  };

  /**
   * Get HTML paste data
   *
   * @return {?string}
   */

  DataTransfer.prototype.getHTML = function getHTML() {
    if (this.data.getData) {
      if (!this.types.length) {
        return this.data.getData("Text");
      } else if (this.types.indexOf("text/html") != -1) {
        return this.data.getData("text/html");
      }
    }
  };

  /**
   * Is this a link data transfer?
   *
   * @return {boolean}
   */

  DataTransfer.prototype.isLink = function isLink() {
    return this.types.some(function(type) {
      return (
        type.indexOf("Url") != -1 ||
        type.indexOf("text/uri-list") != -1 ||
        type.indexOf("text/x-moz-url")
      );
    });
  };

  /**
   * Get a link url.
   *
   * @return {?string}
   */

  DataTransfer.prototype.getLink = function getLink() {
    if (this.data.getData) {
      if (this.types.indexOf("text/x-moz-url") != -1) {
        var url = this.data.getData("text/x-moz-url").split("\n");
        return url[0];
      }
      return this.types.indexOf("text/uri-list") != -1
        ? this.data.getData("text/uri-list")
        : this.data.getData("url");
    }

    return null;
  };

  /**
   * Is this an image data transfer?
   *
   * @return {boolean}
   */

  DataTransfer.prototype.isImage = function isImage() {
    var isImage = this.types.some(function(type) {
      // Firefox will have a type of application/x-moz-file for images during
      // dragging
      return type.indexOf("application/x-moz-file") != -1;
    });

    if (isImage) {
      return true;
    }

    var items = this.getFiles();
    for (var i = 0; i < items.length; i++) {
      var type = items[i].type;
      if (!PhotosMimeType_1.isImage(type)) {
        return false;
      }
    }

    return true;
  };

  DataTransfer.prototype.getCount = function getCount() {
    if (this.data.hasOwnProperty("items")) {
      return this.data.items.length;
    } else if (this.data.hasOwnProperty("mozItemCount")) {
      return this.data.mozItemCount;
    } else if (this.data.files) {
      return this.data.files.length;
    }
    return null;
  };

  /**
   * Get files.
   *
   * @return {array}
   */

  DataTransfer.prototype.getFiles = function getFiles() {
    if (this.data.items) {
      // createArrayFromMixed doesn't properly handle DataTransferItemLists.
      return Array.prototype.slice
        .call(this.data.items)
        .map(getFileFromDataTransfer)
        .filter(emptyFunction_1.thatReturnsArgument);
    } else if (this.data.files) {
      return Array.prototype.slice.call(this.data.files);
    } else {
      return [];
    }
  };

  /**
   * Are there any files to fetch?
   *
   * @return {boolean}
   */

  DataTransfer.prototype.hasFiles = function hasFiles() {
    return this.getFiles().length > 0;
  };

  return DataTransfer;
})();

var DataTransfer_1 = DataTransfer;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule getSelectionOffsetKeyForNode
 * @format
 *
 */

/**
 * Get offset key from a node or it's child nodes. Return the first offset key
 * found on the DOM tree of given node.
 */

function getSelectionOffsetKeyForNode(node) {
  if (node instanceof Element) {
    var offsetKey = node.getAttribute("data-offset-key");
    if (offsetKey) {
      return offsetKey;
    }
    for (var ii = 0; ii < node.childNodes.length; ii++) {
      var childOffsetKey = getSelectionOffsetKeyForNode(node.childNodes[ii]);
      if (childOffsetKey) {
        return childOffsetKey;
      }
    }
  }
  return null;
}

var getSelectionOffsetKeyForNode_1 = getSelectionOffsetKeyForNode;

/**
 * Get the key from the node's nearest offset-aware ancestor.
 */
function findAncestorOffsetKey(node) {
  var searchNode = node;
  while (searchNode && searchNode !== document.documentElement) {
    var key = getSelectionOffsetKeyForNode_1(searchNode);
    if (key != null) {
      return key;
    }
    searchNode = searchNode.parentNode;
  }
  return null;
}

var findAncestorOffsetKey_1 = findAncestorOffsetKey;

var TEXT_CLIPPING_REGEX = /\.textClipping$/;

var TEXT_TYPES = {
  "text/plain": true,
  "text/html": true,
  "text/rtf": true
};

// Somewhat arbitrary upper bound on text size. Let's not lock up the browser.
var TEXT_SIZE_UPPER_BOUND = 5000;

/**
 * Extract the text content from a file list.
 */
function getTextContentFromFiles(files, callback) {
  var readCount = 0;
  var results = [];
  files.forEach(function(/*blob*/ file) {
    readFile(file, function(/*string*/ text) {
      readCount++;
      text && results.push(text.slice(0, TEXT_SIZE_UPPER_BOUND));
      if (readCount == files.length) {
        callback(results.join("\r"));
      }
    });
  });
}

/**
 * todo isaac: Do work to turn html/rtf into a content fragment.
 */
function readFile(file, callback) {
  if (
    !_commonjsHelpers.commonjsGlobal.FileReader ||
    (file.type && !(file.type in TEXT_TYPES))
  ) {
    callback("");
    return;
  }

  if (file.type === "") {
    var contents = "";
    // Special-case text clippings, which have an empty type but include
    // `.textClipping` in the file name. `readAsText` results in an empty
    // string for text clippings, so we force the file name to serve
    // as the text value for the file.
    if (TEXT_CLIPPING_REGEX.test(file.name)) {
      contents = file.name.replace(TEXT_CLIPPING_REGEX, "");
    }
    callback(contents);
    return;
  }

  var reader = new FileReader();
  reader.onload = function() {
    var result = reader.result;
    !(typeof result === "string")
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(
            false,
            'We should be calling "FileReader.readAsText" which returns a string'
          )
        : invariant_1(false)
      : void 0;
    callback(result);
  };
  reader.onerror = function() {
    callback("");
  };
  reader.readAsText(file);
}

var getTextContentFromFiles_1 = getTextContentFromFiles;

function getUpdatedSelectionState(
  editorState,
  anchorKey,
  anchorOffset,
  focusKey,
  focusOffset
) {
  var selection = nullthrows_1(editorState.getSelection());
  if (process.env.NODE_ENV !== "production") {
    if (!anchorKey || !focusKey) {
      /*eslint-disable no-console */
      console.warn("Invalid selection state.", arguments, editorState.toJS());
      /*eslint-enable no-console */
      return selection;
    }
  }

  var anchorPath = DraftOffsetKey_1.decode(anchorKey);
  var anchorBlockKey = anchorPath.blockKey;
  var anchorLeaf = editorState
    .getBlockTree(anchorBlockKey)
    .getIn([anchorPath.decoratorKey, "leaves", anchorPath.leafKey]);

  var focusPath = DraftOffsetKey_1.decode(focusKey);
  var focusBlockKey = focusPath.blockKey;
  var focusLeaf = editorState
    .getBlockTree(focusBlockKey)
    .getIn([focusPath.decoratorKey, "leaves", focusPath.leafKey]);

  var anchorLeafStart = anchorLeaf.get("start");
  var focusLeafStart = focusLeaf.get("start");

  var anchorBlockOffset = anchorLeaf ? anchorLeafStart + anchorOffset : null;
  var focusBlockOffset = focusLeaf ? focusLeafStart + focusOffset : null;

  var areEqual =
    selection.getAnchorKey() === anchorBlockKey &&
    selection.getAnchorOffset() === anchorBlockOffset &&
    selection.getFocusKey() === focusBlockKey &&
    selection.getFocusOffset() === focusBlockOffset;

  if (areEqual) {
    return selection;
  }

  var isBackward = false;
  if (anchorBlockKey === focusBlockKey) {
    var anchorLeafEnd = anchorLeaf.get("end");
    var focusLeafEnd = focusLeaf.get("end");
    if (focusLeafStart === anchorLeafStart && focusLeafEnd === anchorLeafEnd) {
      isBackward = focusOffset < anchorOffset;
    } else {
      isBackward = focusLeafStart < anchorLeafStart;
    }
  } else {
    var startKey = editorState
      .getCurrentContent()
      .getBlockMap()
      .keySeq()
      .skipUntil(function(v) {
        return v === anchorBlockKey || v === focusBlockKey;
      })
      .first();
    isBackward = startKey === focusBlockKey;
  }

  return selection.merge({
    anchorKey: anchorBlockKey,
    anchorOffset: anchorBlockOffset,
    focusKey: focusBlockKey,
    focusOffset: focusBlockOffset,
    isBackward: isBackward
  });
}

var getUpdatedSelectionState_1 = getUpdatedSelectionState;

/**
 * Get a SelectionState for the supplied mouse event.
 */
function getSelectionForEvent(event, editorState) {
  var node = null;
  var offset = null;

  if (typeof document.caretRangeFromPoint === "function") {
    var dropRange = document.caretRangeFromPoint(event.x, event.y);
    node = dropRange.startContainer;
    offset = dropRange.startOffset;
  } else if (event.rangeParent) {
    node = event.rangeParent;
    offset = event.rangeOffset;
  } else {
    return null;
  }

  node = nullthrows_1(node);
  offset = nullthrows_1(offset);
  var offsetKey = nullthrows_1(findAncestorOffsetKey_1(node));

  return getUpdatedSelectionState_1(
    editorState,
    offsetKey,
    offset,
    offsetKey,
    offset
  );
}

var DraftEditorDragHandler = {
  /**
   * Drag originating from input terminated.
   */
  onDragEnd: function onDragEnd(editor) {
    editor.exitCurrentMode();
  },

  /**
   * Handle data being dropped.
   */
  onDrop: function onDrop(editor, e) {
    var data = new DataTransfer_1(e.nativeEvent.dataTransfer);

    var editorState = editor._latestEditorState;
    var dropSelection = getSelectionForEvent(e.nativeEvent, editorState);

    e.preventDefault();
    editor.exitCurrentMode();

    if (dropSelection == null) {
      return;
    }

    var files = data.getFiles();
    if (files.length > 0) {
      if (
        editor.props.handleDroppedFiles &&
        isEventHandled_1(editor.props.handleDroppedFiles(dropSelection, files))
      ) {
        return;
      }

      getTextContentFromFiles_1(files, function(fileText) {
        fileText &&
          editor.update(
            insertTextAtSelection(editorState, dropSelection, fileText)
          );
      });
      return;
    }

    var dragType = editor._internalDrag ? "internal" : "external";
    if (
      editor.props.handleDrop &&
      isEventHandled_1(editor.props.handleDrop(dropSelection, data, dragType))
    ) {
      return;
    }

    if (editor._internalDrag) {
      editor.update(moveText(editorState, dropSelection));
      return;
    }

    editor.update(
      insertTextAtSelection(editorState, dropSelection, data.getText())
    );
  }
};

function moveText(editorState, targetSelection) {
  var newContentState = DraftModifier_1.moveText(
    editorState.getCurrentContent(),
    editorState.getSelection(),
    targetSelection
  );
  return EditorState_1.push(editorState, newContentState, "insert-fragment");
}

/**
 * Insert text at a specified selection.
 */
function insertTextAtSelection(editorState, selection, text) {
  var newContentState = DraftModifier_1.insertText(
    editorState.getCurrentContent(),
    selection,
    text,
    editorState.getCurrentInlineStyle()
  );
  return EditorState_1.push(editorState, newContentState, "insert-fragment");
}

var DraftEditorDragHandler_1 = DraftEditorDragHandler;

(function(global, undefined$1) {
  if (global.setImmediate) {
    return;
  }

  var nextHandle = 1; // Spec says greater than zero
  var tasksByHandle = {};
  var currentlyRunningATask = false;
  var doc = global.document;
  var registerImmediate;

  function setImmediate(callback) {
    // Callback can either be a function or a string
    if (typeof callback !== "function") {
      callback = new Function("" + callback);
    }
    // Copy function arguments
    var args = new Array(arguments.length - 1);
    for (var i = 0; i < args.length; i++) {
      args[i] = arguments[i + 1];
    }
    // Store and register the task
    var task = { callback: callback, args: args };
    tasksByHandle[nextHandle] = task;
    registerImmediate(nextHandle);
    return nextHandle++;
  }

  function clearImmediate(handle) {
    delete tasksByHandle[handle];
  }

  function run(task) {
    var callback = task.callback;
    var args = task.args;
    switch (args.length) {
      case 0:
        callback();
        break;
      case 1:
        callback(args[0]);
        break;
      case 2:
        callback(args[0], args[1]);
        break;
      case 3:
        callback(args[0], args[1], args[2]);
        break;
      default:
        callback.apply(undefined$1, args);
        break;
    }
  }

  function runIfPresent(handle) {
    // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
    // So if we're currently running a task, we'll need to delay this invocation.
    if (currentlyRunningATask) {
      // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
      // "too much recursion" error.
      setTimeout(runIfPresent, 0, handle);
    } else {
      var task = tasksByHandle[handle];
      if (task) {
        currentlyRunningATask = true;
        try {
          run(task);
        } finally {
          clearImmediate(handle);
          currentlyRunningATask = false;
        }
      }
    }
  }

  function installNextTickImplementation() {
    registerImmediate = function(handle) {
      process.nextTick(function() {
        runIfPresent(handle);
      });
    };
  }

  function canUsePostMessage() {
    // The test against `importScripts` prevents this implementation from being installed inside a web worker,
    // where `global.postMessage` means something completely different and can't be used for this purpose.
    if (global.postMessage && !global.importScripts) {
      var postMessageIsAsynchronous = true;
      var oldOnMessage = global.onmessage;
      global.onmessage = function() {
        postMessageIsAsynchronous = false;
      };
      global.postMessage("", "*");
      global.onmessage = oldOnMessage;
      return postMessageIsAsynchronous;
    }
  }

  function installPostMessageImplementation() {
    // Installs an event handler on `global` for the `message` event: see
    // * https://developer.mozilla.org/en/DOM/window.postMessage
    // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages

    var messagePrefix = "setImmediate$" + Math.random() + "$";
    var onGlobalMessage = function(event) {
      if (
        event.source === global &&
        typeof event.data === "string" &&
        event.data.indexOf(messagePrefix) === 0
      ) {
        runIfPresent(+event.data.slice(messagePrefix.length));
      }
    };

    if (global.addEventListener) {
      global.addEventListener("message", onGlobalMessage, false);
    } else {
      global.attachEvent("onmessage", onGlobalMessage);
    }

    registerImmediate = function(handle) {
      global.postMessage(messagePrefix + handle, "*");
    };
  }

  function installMessageChannelImplementation() {
    var channel = new MessageChannel();
    channel.port1.onmessage = function(event) {
      var handle = event.data;
      runIfPresent(handle);
    };

    registerImmediate = function(handle) {
      channel.port2.postMessage(handle);
    };
  }

  function installReadyStateChangeImplementation() {
    var html = doc.documentElement;
    registerImmediate = function(handle) {
      // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
      // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
      var script = doc.createElement("script");
      script.onreadystatechange = function() {
        runIfPresent(handle);
        script.onreadystatechange = null;
        html.removeChild(script);
        script = null;
      };
      html.appendChild(script);
    };
  }

  function installSetTimeoutImplementation() {
    registerImmediate = function(handle) {
      setTimeout(runIfPresent, 0, handle);
    };
  }

  // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
  var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
  attachTo = attachTo && attachTo.setTimeout ? attachTo : global;

  // Don't get fooled by e.g. browserify environments.
  if ({}.toString.call(global.process) === "[object process]") {
    // For Node.js before 0.9
    installNextTickImplementation();
  } else if (canUsePostMessage()) {
    // For non-IE10 modern browsers
    installPostMessageImplementation();
  } else if (global.MessageChannel) {
    // For web workers, where supported
    installMessageChannelImplementation();
  } else if (doc && "onreadystatechange" in doc.createElement("script")) {
    // For IE 6–8
    installReadyStateChangeImplementation();
  } else {
    // For older browsers
    installSetTimeoutImplementation();
  }

  attachTo.setImmediate = setImmediate;
  attachTo.clearImmediate = clearImmediate;
})(
  typeof self === "undefined"
    ? typeof _commonjsHelpers.commonjsGlobal === "undefined"
      ? _commonjsHelpers.commonjsGlobal
      : _commonjsHelpers.commonjsGlobal
    : self
);

// setimmediate adds setImmediate to the global. We want to make sure we export
// the actual function.

var setImmediate = _commonjsHelpers.commonjsGlobal.setImmediate;

// When nothing is focused, Firefox regards two characters, `'` and `/`, as
// commands that should open and focus the "quickfind" search bar. This should
// *never* happen while a contenteditable is focused, but as of v28, it
// sometimes does, even when the keypress event target is the contenteditable.
// This breaks the input. Special case these characters to ensure that when
// they are typed, we prevent default on the event to make sure not to
// trigger quickfind.
var FF_QUICKFIND_CHAR = "'";
var FF_QUICKFIND_LINK_CHAR = "/";
var isFirefox = UserAgent_1.isBrowser("Firefox");

function mustPreventDefaultForCharacter(character) {
  return (
    isFirefox &&
    (character == FF_QUICKFIND_CHAR || character == FF_QUICKFIND_LINK_CHAR)
  );
}

/**
 * Replace the current selection with the specified text string, with the
 * inline style and entity key applied to the newly inserted text.
 */
function replaceText(editorState, text, inlineStyle, entityKey) {
  var contentState = DraftModifier_1.replaceText(
    editorState.getCurrentContent(),
    editorState.getSelection(),
    text,
    inlineStyle,
    entityKey
  );
  return EditorState_1.push(editorState, contentState, "insert-characters");
}

/**
 * When `onBeforeInput` executes, the browser is attempting to insert a
 * character into the editor. Apply this character data to the document,
 * allowing native insertion if possible.
 *
 * Native insertion is encouraged in order to limit re-rendering and to
 * preserve spellcheck highlighting, which disappears or flashes if re-render
 * occurs on the relevant text nodes.
 */
function editOnBeforeInput(editor, e) {
  if (editor._pendingStateFromBeforeInput !== undefined) {
    editor.update(editor._pendingStateFromBeforeInput);
    editor._pendingStateFromBeforeInput = undefined;
  }

  var editorState = editor._latestEditorState;

  var chars = e.data;

  // In some cases (ex: IE ideographic space insertion) no character data
  // is provided. There's nothing to do when this happens.
  if (!chars) {
    return;
  }

  // Allow the top-level component to handle the insertion manually. This is
  // useful when triggering interesting behaviors for a character insertion,
  // Simple examples: replacing a raw text ':)' with a smile emoji or image
  // decorator, or setting a block to be a list item after typing '- ' at the
  // start of the block.
  if (
    editor.props.handleBeforeInput &&
    isEventHandled_1(editor.props.handleBeforeInput(chars, editorState))
  ) {
    e.preventDefault();
    return;
  }

  // If selection is collapsed, conditionally allow native behavior. This
  // reduces re-renders and preserves spellcheck highlighting. If the selection
  // is not collapsed, we will re-render.
  var selection = editorState.getSelection();
  var selectionStart = selection.getStartOffset();
  var selectionEnd = selection.getEndOffset();
  var anchorKey = selection.getAnchorKey();

  if (!selection.isCollapsed()) {
    e.preventDefault();

    // If the currently selected text matches what the user is trying to
    // replace it with, let's just update the `SelectionState`. If not, update
    // the `ContentState` with the new text.
    var currentlySelectedChars = editorState
      .getCurrentContent()
      .getPlainText()
      .slice(selectionStart, selectionEnd);
    if (chars === currentlySelectedChars) {
      editor.update(
        EditorState_1.forceSelection(
          editorState,
          selection.merge({
            focusOffset: selectionEnd
          })
        )
      );
    } else {
      editor.update(
        replaceText(
          editorState,
          chars,
          editorState.getCurrentInlineStyle(),
          getEntityKeyForSelection_1(
            editorState.getCurrentContent(),
            editorState.getSelection()
          )
        )
      );
    }
    return;
  }

  var newEditorState = replaceText(
    editorState,
    chars,
    editorState.getCurrentInlineStyle(),
    getEntityKeyForSelection_1(
      editorState.getCurrentContent(),
      editorState.getSelection()
    )
  );

  // Bunch of different cases follow where we need to prevent native insertion.
  var mustPreventNative = false;
  if (!mustPreventNative) {
    // Browsers tend to insert text in weird places in the DOM when typing at
    // the start of a leaf, so we'll handle it ourselves.
    mustPreventNative = isSelectionAtLeafStart_1(
      editor._latestCommittedEditorState
    );
  }
  if (!mustPreventNative) {
    // Chrome will also split up a node into two pieces if it contains a Tab
    // char, for no explicable reason. Seemingly caused by this commit:
    // https://chromium.googlesource.com/chromium/src/+/013ac5eaf3%5E%21/
    var nativeSelection = _commonjsHelpers.commonjsGlobal.getSelection();
    // Selection is necessarily collapsed at this point due to earlier check.
    if (
      nativeSelection.anchorNode &&
      nativeSelection.anchorNode.nodeType === Node.TEXT_NODE
    ) {
      // See isTabHTMLSpanElement in chromium EditingUtilities.cpp.
      var parentNode = nativeSelection.anchorNode.parentNode;
      mustPreventNative =
        parentNode.nodeName === "SPAN" &&
        parentNode.firstChild.nodeType === Node.TEXT_NODE &&
        parentNode.firstChild.nodeValue.indexOf("\t") !== -1;
    }
  }
  if (!mustPreventNative) {
    // Check the old and new "fingerprints" of the current block to determine
    // whether this insertion requires any addition or removal of text nodes,
    // in which case we would prevent the native character insertion.
    var originalFingerprint = BlockTree_1.getFingerprint(
      editorState.getBlockTree(anchorKey)
    );
    var newFingerprint = BlockTree_1.getFingerprint(
      newEditorState.getBlockTree(anchorKey)
    );
    mustPreventNative = originalFingerprint !== newFingerprint;
  }
  if (!mustPreventNative) {
    mustPreventNative = mustPreventDefaultForCharacter(chars);
  }
  if (!mustPreventNative) {
    mustPreventNative =
      nullthrows_1(newEditorState.getDirectionMap()).get(anchorKey) !==
      nullthrows_1(editorState.getDirectionMap()).get(anchorKey);
  }

  if (mustPreventNative) {
    e.preventDefault();
    editor.update(newEditorState);
    return;
  }

  // We made it all the way! Let the browser do its thing and insert the char.
  newEditorState = EditorState_1.set(newEditorState, {
    nativelyRenderedContent: newEditorState.getCurrentContent()
  });
  // The native event is allowed to occur. To allow user onChange handlers to
  // change the inserted text, we wait until the text is actually inserted
  // before we actually update our state. That way when we rerender, the text
  // we see in the DOM will already have been inserted properly.
  editor._pendingStateFromBeforeInput = newEditorState;
  setImmediate(function() {
    if (editor._pendingStateFromBeforeInput !== undefined) {
      editor.update(editor._pendingStateFromBeforeInput);
      editor._pendingStateFromBeforeInput = undefined;
    }
  });
}

var editOnBeforeInput_1 = editOnBeforeInput;

function editOnBlur(editor, e) {
  // In a contentEditable element, when you select a range and then click
  // another active element, this does trigger a `blur` event but will not
  // remove the DOM selection from the contenteditable.
  // This is consistent across all browsers, but we prefer that the editor
  // behave like a textarea, where a `blur` event clears the DOM selection.
  // We therefore force the issue to be certain, checking whether the active
  // element is `body` to force it when blurring occurs within the window (as
  // opposed to clicking to another tab or window).
  if (getActiveElement_1() === document.body) {
    var _selection = _commonjsHelpers.commonjsGlobal.getSelection();
    var editorNode = editor.editor;
    if (
      _selection.rangeCount === 1 &&
      containsNode_1(editorNode, _selection.anchorNode) &&
      containsNode_1(editorNode, _selection.focusNode)
    ) {
      _selection.removeAllRanges();
    }
  }

  var editorState = editor._latestEditorState;
  var currentSelection = editorState.getSelection();
  if (!currentSelection.getHasFocus()) {
    return;
  }

  var selection = currentSelection.set("hasFocus", false);
  editor.props.onBlur && editor.props.onBlur(e);
  editor.update(EditorState_1.acceptSelection(editorState, selection));
}

var editOnBlur_1 = editOnBlur;

/**
 * The user has begun using an IME input system. Switching to `composite` mode
 * allows handling composition input and disables other edit behavior.
 */
function editOnCompositionStart(editor, e) {
  editor.setMode("composite");
  editor.update(
    EditorState_1.set(editor._latestEditorState, { inCompositionMode: true })
  );
  // Allow composition handler to interpret the compositionstart event
  editor._onCompositionStart(e);
}

var editOnCompositionStart_1 = editOnCompositionStart;

function getFragmentFromSelection(editorState) {
  var selectionState = editorState.getSelection();

  if (selectionState.isCollapsed()) {
    return null;
  }

  return getContentStateFragment_1(
    editorState.getCurrentContent(),
    selectionState
  );
}

var getFragmentFromSelection_1 = getFragmentFromSelection;

/**
 * If we have a selection, create a ContentState fragment and store
 * it in our internal clipboard. Subsequent paste events will use this
 * fragment if no external clipboard data is supplied.
 */
function editOnCopy(editor, e) {
  var editorState = editor._latestEditorState;
  var selection = editorState.getSelection();

  // No selection, so there's nothing to copy.
  if (selection.isCollapsed()) {
    e.preventDefault();
    return;
  }

  editor.setClipboard(getFragmentFromSelection_1(editor._latestEditorState));
}

var editOnCopy_1 = editOnCopy;

/**
 * On `cut` events, native behavior is allowed to occur so that the system
 * clipboard is set properly. This means that we need to take steps to recover
 * the editor DOM state after the `cut` has occurred in order to maintain
 * control of the component.
 *
 * In addition, we can keep a copy of the removed fragment, including all
 * styles and entities, for use as an internal paste.
 */
function editOnCut(editor, e) {
  var editorState = editor._latestEditorState;
  var selection = editorState.getSelection();
  var element = e.target;
  var scrollPosition = void 0;

  // No selection, so there's nothing to cut.
  if (selection.isCollapsed()) {
    e.preventDefault();
    return;
  }

  // Track the current scroll position so that it can be forced back in place
  // after the editor regains control of the DOM.
  if (element instanceof Node) {
    scrollPosition = getScrollPosition_1(Style_1.getScrollParent(element));
  }

  var fragment = getFragmentFromSelection_1(editorState);
  editor.setClipboard(fragment);

  // Set `cut` mode to disable all event handling temporarily.
  editor.setMode("cut");

  // Let native `cut` behavior occur, then recover control.
  setTimeout(function() {
    editor.restoreEditorDOM(scrollPosition);
    editor.exitCurrentMode();
    editor.update(removeFragment(editorState));
  }, 0);
}

function removeFragment(editorState) {
  var newContent = DraftModifier_1.removeRange(
    editorState.getCurrentContent(),
    editorState.getSelection(),
    "forward"
  );
  return EditorState_1.push(editorState, newContent, "remove-range");
}

var editOnCut_1 = editOnCut;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule editOnDragOver
 * @format
 *
 */

/**
 * Drag behavior has begun from outside the editor element.
 */
function editOnDragOver(editor, e) {
  editor._internalDrag = false;
  editor.setMode("drag");
  e.preventDefault();
}

var editOnDragOver_1 = editOnDragOver;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule editOnDragStart
 * @format
 *
 */

/**
 * A `dragstart` event has begun within the text editor component.
 */
function editOnDragStart(editor) {
  editor._internalDrag = true;
  editor.setMode("drag");
}

var editOnDragStart_1 = editOnDragStart;

function editOnFocus(editor, e) {
  var editorState = editor._latestEditorState;
  var currentSelection = editorState.getSelection();
  if (currentSelection.getHasFocus()) {
    return;
  }

  var selection = currentSelection.set("hasFocus", true);
  editor.props.onFocus && editor.props.onFocus(e);

  // When the tab containing this text editor is hidden and the user does a
  // find-in-page in a _different_ tab, Chrome on Mac likes to forget what the
  // selection was right after sending this focus event and (if you let it)
  // moves the cursor back to the beginning of the editor, so we force the
  // selection here instead of simply accepting it in order to preserve the
  // old cursor position. See https://crbug.com/540004.
  // But it looks like this is fixed in Chrome 60.0.3081.0.
  // Other browsers also don't have this bug, so we prefer to acceptSelection
  // when possible, to ensure that unfocusing and refocusing a Draft editor
  // doesn't preserve the selection, matching how textareas work.
  if (UserAgent_1.isBrowser("Chrome < 60.0.3081.0")) {
    editor.update(EditorState_1.forceSelection(editorState, selection));
  } else {
    editor.update(EditorState_1.acceptSelection(editorState, selection));
  }
}

var editOnFocus_1 = editOnFocus;

var isGecko = UserAgent_1.isEngine("Gecko");

var DOUBLE_NEWLINE = "\n\n";

/**
 * This function is intended to handle spellcheck and autocorrect changes,
 * which occur in the DOM natively without any opportunity to observe or
 * interpret the changes before they occur.
 *
 * The `input` event fires in contentEditable elements reliably for non-IE
 * browsers, immediately after changes occur to the editor DOM. Since our other
 * handlers override or otherwise handle cover other varieties of text input,
 * the DOM state should match the model in all controlled input cases. Thus,
 * when an `input` change leads to a DOM/model mismatch, the change should be
 * due to a spellcheck change, and we can incorporate it into our model.
 */
function editOnInput(editor) {
  if (editor._pendingStateFromBeforeInput !== undefined) {
    editor.update(editor._pendingStateFromBeforeInput);
    editor._pendingStateFromBeforeInput = undefined;
  }

  var domSelection = _commonjsHelpers.commonjsGlobal.getSelection();

  var anchorNode = domSelection.anchorNode,
    isCollapsed = domSelection.isCollapsed;

  var isNotTextNode = anchorNode.nodeType !== Node.TEXT_NODE;
  var isNotTextOrElementNode =
    anchorNode.nodeType !== Node.TEXT_NODE &&
    anchorNode.nodeType !== Node.ELEMENT_NODE;

  {
    if (isNotTextOrElementNode) {
      // TODO: (t16149272) figure out context for this change
      return;
    }
  }

  if (
    anchorNode.nodeType === Node.TEXT_NODE &&
    (anchorNode.previousSibling !== null || anchorNode.nextSibling !== null)
  ) {
    // When typing at the beginning of a visual line, Chrome splits the text
    // nodes into two. Why? No one knows. This commit is suspicious:
    // https://chromium.googlesource.com/chromium/src/+/a3b600981286b135632371477f902214c55a1724
    // To work around, we'll merge the sibling text nodes back into this one.
    var span = anchorNode.parentNode;
    anchorNode.nodeValue = span.textContent;
    for (
      var child = span.firstChild;
      child !== null;
      child = child.nextSibling
    ) {
      if (child !== anchorNode) {
        span.removeChild(child);
      }
    }
  }

  var domText = anchorNode.textContent;
  var editorState = editor._latestEditorState;
  var offsetKey = nullthrows_1(findAncestorOffsetKey_1(anchorNode));

  var _DraftOffsetKey$decod = DraftOffsetKey_1.decode(offsetKey),
    blockKey = _DraftOffsetKey$decod.blockKey,
    decoratorKey = _DraftOffsetKey$decod.decoratorKey,
    leafKey = _DraftOffsetKey$decod.leafKey;

  var _editorState$getBlock = editorState
      .getBlockTree(blockKey)
      .getIn([decoratorKey, "leaves", leafKey]),
    start = _editorState$getBlock.start,
    end = _editorState$getBlock.end;

  var content = editorState.getCurrentContent();
  var block = content.getBlockForKey(blockKey);
  var modelText = block.getText().slice(start, end);

  // Special-case soft newlines here. If the DOM text ends in a soft newline,
  // we will have manually inserted an extra soft newline in DraftEditorLeaf.
  // We want to remove this extra newline for the purpose of our comparison
  // of DOM and model text.
  if (domText.endsWith(DOUBLE_NEWLINE)) {
    domText = domText.slice(0, -1);
  }

  // No change -- the DOM is up to date. Nothing to do here.
  if (domText === modelText) {
    // This can be buggy for some Android keyboards because they don't fire
    // standard onkeydown/pressed events and only fired editOnInput
    // so domText is already changed by the browser and ends up being equal
    // to modelText unexpectedly
    return;
  }

  var selection = editorState.getSelection();

  // We'll replace the entire leaf with the text content of the target.
  var targetRange = selection.merge({
    anchorOffset: start,
    focusOffset: end,
    isBackward: false
  });

  var entityKey = block.getEntityAt(start);
  var entity = entityKey && content.getEntity(entityKey);
  var entityType = entity && entity.getMutability();
  var preserveEntity = entityType === "MUTABLE";

  // Immutable or segmented entities cannot properly be handled by the
  // default browser undo, so we have to use a different change type to
  // force using our internal undo method instead of falling through to the
  // native browser undo.
  var changeType = preserveEntity ? "spellcheck-change" : "apply-entity";

  var newContent = DraftModifier_1.replaceText(
    content,
    targetRange,
    domText,
    block.getInlineStyleAt(start),
    preserveEntity ? block.getEntityAt(start) : null
  );

  var anchorOffset, focusOffset, startOffset, endOffset;

  if (isGecko) {
    // Firefox selection does not change while the context menu is open, so
    // we preserve the anchor and focus values of the DOM selection.
    anchorOffset = domSelection.anchorOffset;
    focusOffset = domSelection.focusOffset;
    startOffset = start + Math.min(anchorOffset, focusOffset);
    endOffset = startOffset + Math.abs(anchorOffset - focusOffset);
    anchorOffset = startOffset;
    focusOffset = endOffset;
  } else {
    // Browsers other than Firefox may adjust DOM selection while the context
    // menu is open, and Safari autocorrect is prone to providing an inaccurate
    // DOM selection. Don't trust it. Instead, use our existing SelectionState
    // and adjust it based on the number of characters changed during the
    // mutation.
    var charDelta = domText.length - modelText.length;
    startOffset = selection.getStartOffset();
    endOffset = selection.getEndOffset();

    anchorOffset = isCollapsed ? endOffset + charDelta : startOffset;
    focusOffset = endOffset + charDelta;
  }

  // Segmented entities are completely or partially removed when their
  // text content changes. For this case we do not want any text to be selected
  // after the change, so we are not merging the selection.
  var contentWithAdjustedDOMSelection = newContent.merge({
    selectionBefore: content.getSelectionAfter(),
    selectionAfter: selection.merge({
      anchorOffset: anchorOffset,
      focusOffset: focusOffset
    })
  });

  editor.update(
    EditorState_1.push(editorState, contentWithAdjustedDOMSelection, changeType)
  );
}

var editOnInput_1 = editOnInput;

var isOSX = UserAgent_1.isPlatform("Mac OS X");

var KeyBindingUtil = {
  /**
   * Check whether the ctrlKey modifier is *not* being used in conjunction with
   * the altKey modifier. If they are combined, the result is an `altGraph`
   * key modifier, which should not be handled by this set of key bindings.
   */
  isCtrlKeyCommand: function isCtrlKeyCommand(e) {
    return !!e.ctrlKey && !e.altKey;
  },

  isOptionKeyCommand: function isOptionKeyCommand(e) {
    return isOSX && e.altKey;
  },

  hasCommandModifier: function hasCommandModifier(e) {
    return isOSX
      ? !!e.metaKey && !e.altKey
      : KeyBindingUtil.isCtrlKeyCommand(e);
  }
};

var KeyBindingUtil_1 = KeyBindingUtil;

var clipboard = null;

/**
 * Some systems offer a "secondary" clipboard to allow quick internal cut
 * and paste behavior. For instance, Ctrl+K (cut) and Ctrl+Y (paste).
 */
var SecondaryClipboard = {
  cut: function cut(editorState) {
    var content = editorState.getCurrentContent();
    var selection = editorState.getSelection();
    var targetRange = null;

    if (selection.isCollapsed()) {
      var anchorKey = selection.getAnchorKey();
      var blockEnd = content.getBlockForKey(anchorKey).getLength();

      if (blockEnd === selection.getAnchorOffset()) {
        return editorState;
      }

      targetRange = selection.set("focusOffset", blockEnd);
    } else {
      targetRange = selection;
    }

    targetRange = nullthrows_1(targetRange);
    clipboard = getContentStateFragment_1(content, targetRange);

    var afterRemoval = DraftModifier_1.removeRange(
      content,
      targetRange,
      "forward"
    );

    if (afterRemoval === content) {
      return editorState;
    }

    return EditorState_1.push(editorState, afterRemoval, "remove-range");
  },

  paste: function paste(editorState) {
    if (!clipboard) {
      return editorState;
    }

    var newContent = DraftModifier_1.replaceWithFragment(
      editorState.getCurrentContent(),
      editorState.getSelection(),
      clipboard
    );

    return EditorState_1.push(editorState, newContent, "insert-fragment");
  }
};

var SecondaryClipboard_1 = SecondaryClipboard;

// These two ranges are consecutive so anything in [HIGH_START, LOW_END] is a
// surrogate code unit.
var SURROGATE_HIGH_START = 0xd800;
var SURROGATE_HIGH_END = 0xdbff;
var SURROGATE_LOW_START = 0xdc00;
var SURROGATE_LOW_END = 0xdfff;
var SURROGATE_UNITS_REGEX = /[\uD800-\uDFFF]/;

/**
 * @param {number} codeUnit   A Unicode code-unit, in range [0, 0x10FFFF]
 * @return {boolean}          Whether code-unit is in a surrogate (hi/low) range
 */
function isCodeUnitInSurrogateRange(codeUnit) {
  return SURROGATE_HIGH_START <= codeUnit && codeUnit <= SURROGATE_LOW_END;
}

/**
 * Returns whether the two characters starting at `index` form a surrogate pair.
 * For example, given the string s = "\uD83D\uDE0A", (s, 0) returns true and
 * (s, 1) returns false.
 *
 * @param {string} str
 * @param {number} index
 * @return {boolean}
 */
function isSurrogatePair(str, index) {
  !(0 <= index && index < str.length)
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(
          false,
          "isSurrogatePair: Invalid index %s for string length %s.",
          index,
          str.length
        )
      : invariant_1(false)
    : void 0;
  if (index + 1 === str.length) {
    return false;
  }
  var first = str.charCodeAt(index);
  var second = str.charCodeAt(index + 1);
  return (
    SURROGATE_HIGH_START <= first &&
    first <= SURROGATE_HIGH_END &&
    SURROGATE_LOW_START <= second &&
    second <= SURROGATE_LOW_END
  );
}

/**
 * @param {string} str  Non-empty string
 * @return {boolean}    True if the input includes any surrogate code units
 */
function hasSurrogateUnit(str) {
  return SURROGATE_UNITS_REGEX.test(str);
}

/**
 * Return the length of the original Unicode character at given position in the
 * String by looking into the UTF-16 code unit; that is equal to 1 for any
 * non-surrogate characters in BMP ([U+0000..U+D7FF] and [U+E000, U+FFFF]); and
 * returns 2 for the hi/low surrogates ([U+D800..U+DFFF]), which are in fact
 * representing non-BMP characters ([U+10000..U+10FFFF]).
 *
 * Examples:
 * - '\u0020' => 1
 * - '\u3020' => 1
 * - '\uD835' => 2
 * - '\uD835\uDDEF' => 2
 * - '\uDDEF' => 2
 *
 * @param {string} str  Non-empty string
 * @param {number} pos  Position in the string to look for one code unit
 * @return {number}      Number 1 or 2
 */
function getUTF16Length(str, pos) {
  return 1 + isCodeUnitInSurrogateRange(str.charCodeAt(pos));
}

/**
 * Fully Unicode-enabled replacement for String#length
 *
 * @param {string} str  Valid Unicode string
 * @return {number}     The number of Unicode characters in the string
 */
function strlen(str) {
  // Call the native functions if there's no surrogate char
  if (!hasSurrogateUnit(str)) {
    return str.length;
  }

  var len = 0;
  for (var pos = 0; pos < str.length; pos += getUTF16Length(str, pos)) {
    len++;
  }
  return len;
}

/**
 * Fully Unicode-enabled replacement for String#substr()
 *
 * @param {string} str      Valid Unicode string
 * @param {number} start    Location in Unicode sequence to begin extracting
 * @param {?number} length  The number of Unicode characters to extract
 *                          (default: to the end of the string)
 * @return {string}         Extracted sub-string
 */
function substr(str, start, length) {
  start = start || 0;
  length = length === undefined ? Infinity : length || 0;

  // Call the native functions if there's no surrogate char
  if (!hasSurrogateUnit(str)) {
    return str.substr(start, length);
  }

  // Obvious cases
  var size = str.length;
  if (size <= 0 || start > size || length <= 0) {
    return "";
  }

  // Find the actual starting position
  var posA = 0;
  if (start > 0) {
    for (; start > 0 && posA < size; start--) {
      posA += getUTF16Length(str, posA);
    }
    if (posA >= size) {
      return "";
    }
  } else if (start < 0) {
    for (posA = size; start < 0 && 0 < posA; start++) {
      posA -= getUTF16Length(str, posA - 1);
    }
    if (posA < 0) {
      posA = 0;
    }
  }

  // Find the actual ending position
  var posB = size;
  if (length < size) {
    for (posB = posA; length > 0 && posB < size; length--) {
      posB += getUTF16Length(str, posB);
    }
  }

  return str.substring(posA, posB);
}

/**
 * Fully Unicode-enabled replacement for String#substring()
 *
 * @param {string} str    Valid Unicode string
 * @param {number} start  Location in Unicode sequence to begin extracting
 * @param {?number} end   Location in Unicode sequence to end extracting
 *                        (default: end of the string)
 * @return {string}       Extracted sub-string
 */
function substring(str, start, end) {
  start = start || 0;
  end = end === undefined ? Infinity : end || 0;

  if (start < 0) {
    start = 0;
  }
  if (end < 0) {
    end = 0;
  }

  var length = Math.abs(end - start);
  start = start < end ? start : end;
  return substr(str, start, length);
}

/**
 * Get a list of Unicode code-points from a String
 *
 * @param {string} str        Valid Unicode string
 * @return {array<number>}    A list of code-points in [0..0x10FFFF]
 */
function getCodePoints(str) {
  var codePoints = [];
  for (var pos = 0; pos < str.length; pos += getUTF16Length(str, pos)) {
    codePoints.push(str.codePointAt(pos));
  }
  return codePoints;
}

var UnicodeUtils = {
  getCodePoints: getCodePoints,
  getUTF16Length: getUTF16Length,
  hasSurrogateUnit: hasSurrogateUnit,
  isCodeUnitInSurrogateRange: isCodeUnitInSurrogateRange,
  isSurrogatePair: isSurrogatePair,
  strlen: strlen,
  substring: substring,
  substr: substr
};

var UnicodeUtils_1 = UnicodeUtils;

var isChrome = UserAgent_1.isBrowser("Chrome");

// In Chrome, the client rects will include the entire bounds of all nodes that
// begin (have a start tag) within the selection, even if the selection does
// not overlap the entire node. To resolve this, we split the range at each
// start tag and join the client rects together.
// https://code.google.com/p/chromium/issues/detail?id=324437
/* eslint-disable consistent-return */
function getRangeClientRectsChrome(range) {
  var tempRange = range.cloneRange();
  var clientRects = [];

  for (
    var ancestor = range.endContainer;
    ancestor != null;
    ancestor = ancestor.parentNode
  ) {
    // If we've climbed up to the common ancestor, we can now use the
    // original start point and stop climbing the tree.
    var atCommonAncestor = ancestor === range.commonAncestorContainer;
    if (atCommonAncestor) {
      tempRange.setStart(range.startContainer, range.startOffset);
    } else {
      tempRange.setStart(tempRange.endContainer, 0);
    }
    var rects = Array.from(tempRange.getClientRects());
    clientRects.push(rects);
    if (atCommonAncestor) {
      var _ref;

      clientRects.reverse();
      return (_ref = []).concat.apply(_ref, clientRects);
    }
    tempRange.setEndBefore(ancestor);
  }

  process.env.NODE_ENV !== "production"
    ? invariant_1(
        false,
        "Found an unexpected detached subtree when getting range client rects."
      )
    : invariant_1(false);
}
/* eslint-enable consistent-return */

/**
 * Like range.getClientRects() but normalizes for browser bugs.
 */
var getRangeClientRects = isChrome
  ? getRangeClientRectsChrome
  : function(range) {
      return Array.from(range.getClientRects());
    };

var getRangeClientRects_1 = getRangeClientRects;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule expandRangeToStartOfLine
 * @format
 *
 */

/**
 * Return the computed line height, in pixels, for the provided element.
 */
function getLineHeightPx(element) {
  var computed = getComputedStyle(element);
  var div = document.createElement("div");
  div.style.fontFamily = computed.fontFamily;
  div.style.fontSize = computed.fontSize;
  div.style.fontStyle = computed.fontStyle;
  div.style.fontWeight = computed.fontWeight;
  div.style.lineHeight = computed.lineHeight;
  div.style.position = "absolute";
  div.textContent = "M";

  var documentBody = document.body;
  !documentBody
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "Missing document.body")
      : invariant_1(false)
    : void 0;

  // forced layout here
  documentBody.appendChild(div);
  var rect = div.getBoundingClientRect();
  documentBody.removeChild(div);

  return rect.height;
}

/**
 * Return whether every ClientRect in the provided list lies on the same line.
 *
 * We assume that the rects on the same line all contain the baseline, so the
 * lowest top line needs to be above the highest bottom line (i.e., if you were
 * to project the rects onto the y-axis, their intersection would be nonempty).
 *
 * In addition, we require that no two boxes are lineHeight (or more) apart at
 * either top or bottom, which helps protect against false positives for fonts
 * with extremely large glyph heights (e.g., with a font size of 17px, Zapfino
 * produces rects of height 58px!).
 */
function areRectsOnOneLine(rects, lineHeight) {
  var minTop = Infinity;
  var minBottom = Infinity;
  var maxTop = -Infinity;
  var maxBottom = -Infinity;

  for (var ii = 0; ii < rects.length; ii++) {
    var rect = rects[ii];
    if (rect.width === 0 || rect.width === 1) {
      // When a range starts or ends a soft wrap, many browsers (Chrome, IE,
      // Safari) include an empty rect on the previous or next line. When the
      // text lies in a container whose position is not integral (e.g., from
      // margin: auto), Safari makes these empty rects have width 1 (instead of
      // 0). Having one-pixel-wide characters seems unlikely (and most browsers
      // report widths in subpixel precision anyway) so it's relatively safe to
      // skip over them.
      continue;
    }
    minTop = Math.min(minTop, rect.top);
    minBottom = Math.min(minBottom, rect.bottom);
    maxTop = Math.max(maxTop, rect.top);
    maxBottom = Math.max(maxBottom, rect.bottom);
  }

  return (
    maxTop <= minBottom &&
    maxTop - minTop < lineHeight &&
    maxBottom - minBottom < lineHeight
  );
}

/**
 * Return the length of a node, as used by Range offsets.
 */
function getNodeLength$1(node) {
  // http://www.w3.org/TR/dom/#concept-node-length
  switch (node.nodeType) {
    case Node.DOCUMENT_TYPE_NODE:
      return 0;
    case Node.TEXT_NODE:
    case Node.PROCESSING_INSTRUCTION_NODE:
    case Node.COMMENT_NODE:
      return node.length;
    default:
      return node.childNodes.length;
  }
}

/**
 * Given a collapsed range, move the start position backwards as far as
 * possible while the range still spans only a single line.
 */
function expandRangeToStartOfLine(range) {
  !range.collapsed
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(
          false,
          "expandRangeToStartOfLine: Provided range is not collapsed."
        )
      : invariant_1(false)
    : void 0;
  range = range.cloneRange();

  var containingElement = range.startContainer;
  if (containingElement.nodeType !== 1) {
    containingElement = containingElement.parentNode;
  }
  var lineHeight = getLineHeightPx(containingElement);

  // Imagine our text looks like:
  //   <div><span>once upon a time, there was a <em>boy
  //   who lived</em> </span><q><strong>under^ the
  //   stairs</strong> in a small closet.</q></div>
  // where the caret represents the cursor. First, we crawl up the tree until
  // the range spans multiple lines (setting the start point to before
  // "<strong>", then before "<div>"), then at each level we do a search to
  // find the latest point which is still on a previous line. We'll find that
  // the break point is inside the span, then inside the <em>, then in its text
  // node child, the actual break point before "who".

  var bestContainer = range.endContainer;
  var bestOffset = range.endOffset;
  range.setStart(range.startContainer, 0);

  while (areRectsOnOneLine(getRangeClientRects_1(range), lineHeight)) {
    bestContainer = range.startContainer;
    bestOffset = range.startOffset;
    !bestContainer.parentNode
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(
            false,
            "Found unexpected detached subtree when traversing."
          )
        : invariant_1(false)
      : void 0;
    range.setStartBefore(bestContainer);
    if (
      bestContainer.nodeType === 1 &&
      getComputedStyle(bestContainer).display !== "inline"
    ) {
      // The start of the line is never in a different block-level container.
      break;
    }
  }

  // In the above example, range now spans from "<div>" to "under",
  // bestContainer is <div>, and bestOffset is 1 (index of <q> inside <div>)].
  // Picking out which child to recurse into here is a special case since we
  // don't want to check past <q> -- once we find that the final range starts
  // in <span>, we can look at all of its children (and all of their children)
  // to find the break point.

  // At all times, (bestContainer, bestOffset) is the latest single-line start
  // point that we know of.
  var currentContainer = bestContainer;
  var maxIndexToConsider = bestOffset - 1;

  do {
    var nodeValue = currentContainer.nodeValue;

    for (var ii = maxIndexToConsider; ii >= 0; ii--) {
      if (
        nodeValue != null &&
        ii > 0 &&
        UnicodeUtils_1.isSurrogatePair(nodeValue, ii - 1)
      ) {
        // We're in the middle of a surrogate pair -- skip over so we never
        // return a range with an endpoint in the middle of a code point.
        continue;
      }

      range.setStart(currentContainer, ii);
      if (areRectsOnOneLine(getRangeClientRects_1(range), lineHeight)) {
        bestContainer = currentContainer;
        bestOffset = ii;
      } else {
        break;
      }
    }

    if (ii === -1 || currentContainer.childNodes.length === 0) {
      // If ii === -1, then (bestContainer, bestOffset), which is equal to
      // (currentContainer, 0), was a single-line start point but a start
      // point before currentContainer wasn't, so the line break seems to
      // have occurred immediately after currentContainer's start tag
      //
      // If currentContainer.childNodes.length === 0, we're already at a
      // terminal node (e.g., text node) and should return our current best.
      break;
    }

    currentContainer = currentContainer.childNodes[ii];
    maxIndexToConsider = getNodeLength$1(currentContainer);
  } while (true);

  range.setStart(bestContainer, bestOffset);
  return range;
}

var expandRangeToStartOfLine_1 = expandRangeToStartOfLine;

/**
 * Convert the current selection range to an anchor/focus pair of offset keys
 * and values that can be interpreted by components.
 */
function getDraftEditorSelectionWithNodes(
  editorState,
  root,
  anchorNode,
  anchorOffset,
  focusNode,
  focusOffset
) {
  var anchorIsTextNode = anchorNode.nodeType === Node.TEXT_NODE;
  var focusIsTextNode = focusNode.nodeType === Node.TEXT_NODE;

  // If the selection range lies only on text nodes, the task is simple.
  // Find the nearest offset-aware elements and use the
  // offset values supplied by the selection range.
  if (anchorIsTextNode && focusIsTextNode) {
    return {
      selectionState: getUpdatedSelectionState_1(
        editorState,
        nullthrows_1(findAncestorOffsetKey_1(anchorNode)),
        anchorOffset,
        nullthrows_1(findAncestorOffsetKey_1(focusNode)),
        focusOffset
      ),
      needsRecovery: false
    };
  }

  var anchorPoint = null;
  var focusPoint = null;
  var needsRecovery = true;

  // An element is selected. Convert this selection range into leaf offset
  // keys and offset values for consumption at the component level. This
  // is common in Firefox, where select-all and triple click behavior leads
  // to entire elements being selected.
  //
  // Note that we use the `needsRecovery` parameter in the callback here. This
  // is because when certain elements are selected, the behavior for subsequent
  // cursor movement (e.g. via arrow keys) is uncertain and may not match
  // expectations at the component level. For example, if an entire <div> is
  // selected and the user presses the right arrow, Firefox keeps the selection
  // on the <div>. If we allow subsequent keypresses to insert characters
  // natively, they will be inserted into a browser-created text node to the
  // right of that <div>. This is obviously undesirable.
  //
  // With the `needsRecovery` flag, we inform the caller that it is responsible
  // for manually setting the selection state on the rendered document to
  // ensure proper selection state maintenance.

  if (anchorIsTextNode) {
    anchorPoint = {
      key: nullthrows_1(findAncestorOffsetKey_1(anchorNode)),
      offset: anchorOffset
    };
    focusPoint = getPointForNonTextNode(root, focusNode, focusOffset);
  } else if (focusIsTextNode) {
    focusPoint = {
      key: nullthrows_1(findAncestorOffsetKey_1(focusNode)),
      offset: focusOffset
    };
    anchorPoint = getPointForNonTextNode(root, anchorNode, anchorOffset);
  } else {
    anchorPoint = getPointForNonTextNode(root, anchorNode, anchorOffset);
    focusPoint = getPointForNonTextNode(root, focusNode, focusOffset);

    // If the selection is collapsed on an empty block, don't force recovery.
    // This way, on arrow key selection changes, the browser can move the
    // cursor from a non-zero offset on one block, through empty blocks,
    // to a matching non-zero offset on other text blocks.
    if (anchorNode === focusNode && anchorOffset === focusOffset) {
      needsRecovery =
        !!anchorNode.firstChild && anchorNode.firstChild.nodeName !== "BR";
    }
  }

  return {
    selectionState: getUpdatedSelectionState_1(
      editorState,
      anchorPoint.key,
      anchorPoint.offset,
      focusPoint.key,
      focusPoint.offset
    ),
    needsRecovery: needsRecovery
  };
}

/**
 * Identify the first leaf descendant for the given node.
 */
function getFirstLeaf(node) {
  while (
    node.firstChild &&
    // data-blocks has no offset
    ((node.firstChild instanceof Element &&
      node.firstChild.getAttribute("data-blocks") === "true") ||
      getSelectionOffsetKeyForNode_1(node.firstChild))
  ) {
    node = node.firstChild;
  }
  return node;
}

/**
 * Identify the last leaf descendant for the given node.
 */
function getLastLeaf(node) {
  while (
    node.lastChild &&
    // data-blocks has no offset
    ((node.lastChild instanceof Element &&
      node.lastChild.getAttribute("data-blocks") === "true") ||
      getSelectionOffsetKeyForNode_1(node.lastChild))
  ) {
    node = node.lastChild;
  }
  return node;
}

function getPointForNonTextNode(editorRoot, startNode, childOffset) {
  var node = startNode;
  var offsetKey = findAncestorOffsetKey_1(node);

  !(
    offsetKey != null ||
    (editorRoot && (editorRoot === node || editorRoot.firstChild === node))
  )
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "Unknown node in selection range.")
      : invariant_1(false)
    : void 0;

  // If the editorRoot is the selection, step downward into the content
  // wrapper.
  if (editorRoot === node) {
    node = node.firstChild;
    !(node instanceof Element && node.getAttribute("data-contents") === "true")
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(false, "Invalid DraftEditorContents structure.")
        : invariant_1(false)
      : void 0;
    if (childOffset > 0) {
      childOffset = node.childNodes.length;
    }
  }

  // If the child offset is zero and we have an offset key, we're done.
  // If there's no offset key because the entire editor is selected,
  // find the leftmost ("first") leaf in the tree and use that as the offset
  // key.
  if (childOffset === 0) {
    var key = null;
    if (offsetKey != null) {
      key = offsetKey;
    } else {
      var firstLeaf = getFirstLeaf(node);
      key = nullthrows_1(getSelectionOffsetKeyForNode_1(firstLeaf));
    }
    return { key: key, offset: 0 };
  }

  var nodeBeforeCursor = node.childNodes[childOffset - 1];
  var leafKey = null;
  var textLength = null;

  if (!getSelectionOffsetKeyForNode_1(nodeBeforeCursor)) {
    // Our target node may be a leaf or a text node, in which case we're
    // already where we want to be and can just use the child's length as
    // our offset.
    leafKey = nullthrows_1(offsetKey);
    textLength = getTextContentLength(nodeBeforeCursor);
  } else {
    // Otherwise, we'll look at the child to the left of the cursor and find
    // the last leaf node in its subtree.
    var lastLeaf = getLastLeaf(nodeBeforeCursor);
    leafKey = nullthrows_1(getSelectionOffsetKeyForNode_1(lastLeaf));
    textLength = getTextContentLength(lastLeaf);
  }

  return {
    key: leafKey,
    offset: textLength
  };
}

/**
 * Return the length of a node's textContent, regarding single newline
 * characters as zero-length. This allows us to avoid problems with identifying
 * the correct selection offset for empty blocks in IE, in which we
 * render newlines instead of break tags.
 */
function getTextContentLength(node) {
  var textContent = node.textContent;
  return textContent === "\n" ? 0 : textContent.length;
}

var getDraftEditorSelectionWithNodes_1 = getDraftEditorSelectionWithNodes;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule moveSelectionBackward
 * @format
 *
 */

/**
 * Given a collapsed selection, move the focus `maxDistance` backward within
 * the selected block. If the selection will go beyond the start of the block,
 * move focus to the end of the previous block, but no further.
 *
 * This function is not Unicode-aware, so surrogate pairs will be treated
 * as having length 2.
 */
function moveSelectionBackward(editorState, maxDistance) {
  var selection = editorState.getSelection();
  var content = editorState.getCurrentContent();
  var key = selection.getStartKey();
  var offset = selection.getStartOffset();

  var focusKey = key;
  var focusOffset = 0;

  if (maxDistance > offset) {
    var keyBefore = content.getKeyBefore(key);
    if (keyBefore == null) {
      focusKey = key;
    } else {
      focusKey = keyBefore;
      var blockBefore = content.getBlockForKey(keyBefore);
      focusOffset = blockBefore.getText().length;
    }
  } else {
    focusOffset = offset - maxDistance;
  }

  return selection.merge({
    focusKey: focusKey,
    focusOffset: focusOffset,
    isBackward: true
  });
}

var moveSelectionBackward_1 = moveSelectionBackward;

/**
 * For a collapsed selection state, remove text based on the specified strategy.
 * If the selection state is not collapsed, remove the entire selected range.
 */
function removeTextWithStrategy(editorState, strategy, direction) {
  var selection = editorState.getSelection();
  var content = editorState.getCurrentContent();
  var target = selection;
  if (selection.isCollapsed()) {
    if (direction === "forward") {
      if (editorState.isSelectionAtEndOfContent()) {
        return content;
      }
    } else if (editorState.isSelectionAtStartOfContent()) {
      return content;
    }

    target = strategy(editorState);
    if (target === selection) {
      return content;
    }
  }
  return DraftModifier_1.removeRange(content, target, direction);
}

var removeTextWithStrategy_1 = removeTextWithStrategy;

function keyCommandBackspaceToStartOfLine(editorState) {
  var afterRemoval = removeTextWithStrategy_1(
    editorState,
    function(strategyState) {
      var selection = strategyState.getSelection();
      if (selection.isCollapsed() && selection.getAnchorOffset() === 0) {
        return moveSelectionBackward_1(strategyState, 1);
      }

      var domSelection = _commonjsHelpers.commonjsGlobal.getSelection();
      var range = domSelection.getRangeAt(0);
      range = expandRangeToStartOfLine_1(range);

      return getDraftEditorSelectionWithNodes_1(
        strategyState,
        null,
        range.endContainer,
        range.endOffset,
        range.startContainer,
        range.startOffset
      ).selectionState;
    },
    "backward"
  );

  if (afterRemoval === editorState.getCurrentContent()) {
    return editorState;
  }

  return EditorState_1.push(editorState, afterRemoval, "remove-range");
}

var keyCommandBackspaceToStartOfLine_1 = keyCommandBackspaceToStartOfLine;

/**
 * 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
 * @stub
 *
 */

// \u00a1-\u00b1\u00b4-\u00b8\u00ba\u00bb\u00bf
//             is latin supplement punctuation except fractions and superscript
//             numbers
// \u2010-\u2027\u2030-\u205e
//             is punctuation from the general punctuation block:
//             weird quotes, commas, bullets, dashes, etc.
// \u30fb\u3001\u3002\u3008-\u3011\u3014-\u301f
//             is CJK punctuation
// \uff1a-\uff1f\uff01-\uff0f\uff3b-\uff40\uff5b-\uff65
//             is some full-width/half-width punctuation
// \u2E2E\u061f\u066a-\u066c\u061b\u060c\u060d\uFD3e\uFD3F
//             is some Arabic punctuation marks
// \u1801\u0964\u104a\u104b
//             is misc. other language punctuation marks

var PUNCTUATION =
  "[.,+*?$|#{}()'\\^\\-\\[\\]\\\\\\/!@%\"~=<>_:;" +
  "\u30FB\u3001\u3002\u3008-\u3011\u3014-\u301F\uFF1A-\uFF1F\uFF01-\uFF0F" +
  "\uFF3B-\uFF40\uFF5B-\uFF65\u2E2E\u061F\u066A-\u066C\u061B\u060C\u060D" +
  "\uFD3E\uFD3F\u1801\u0964\u104A\u104B\u2010-\u2027\u2030-\u205E" +
  "\xA1-\xB1\xB4-\xB8\xBA\xBB\xBF]";

var TokenizeUtil = {
  getPunctuation: function getPunctuation() {
    return PUNCTUATION;
  }
};

var punctuation = TokenizeUtil.getPunctuation();

// The apostrophe and curly single quotes behave in a curious way: when
// surrounded on both sides by word characters, they behave as word chars; when
// either neighbor is punctuation or an end of the string, they behave as
// punctuation.
var CHAMELEON_CHARS = "['\u2018\u2019]";

// Remove the underscore, which should count as part of the removable word. The
// "chameleon chars" also count as punctuation in this regex.
var WHITESPACE_AND_PUNCTUATION = "\\s|(?![_])" + punctuation;

var DELETE_STRING =
  "^" +
  "(?:" +
  WHITESPACE_AND_PUNCTUATION +
  ")*" +
  "(?:" +
  CHAMELEON_CHARS +
  "|(?!" +
  WHITESPACE_AND_PUNCTUATION +
  ").)*" +
  "(?:(?!" +
  WHITESPACE_AND_PUNCTUATION +
  ").)";
var DELETE_REGEX = new RegExp(DELETE_STRING);

var BACKSPACE_STRING =
  "(?:(?!" +
  WHITESPACE_AND_PUNCTUATION +
  ").)" +
  "(?:" +
  CHAMELEON_CHARS +
  "|(?!" +
  WHITESPACE_AND_PUNCTUATION +
  ").)*" +
  "(?:" +
  WHITESPACE_AND_PUNCTUATION +
  ")*" +
  "$";
var BACKSPACE_REGEX = new RegExp(BACKSPACE_STRING);

function getRemovableWord(text, isBackward) {
  var matches = isBackward
    ? BACKSPACE_REGEX.exec(text)
    : DELETE_REGEX.exec(text);
  return matches ? matches[0] : text;
}

var DraftRemovableWord = {
  getBackward: function getBackward(text) {
    return getRemovableWord(text, true);
  },

  getForward: function getForward(text) {
    return getRemovableWord(text, false);
  }
};

var DraftRemovableWord_1 = DraftRemovableWord;

/**
 * Delete the word that is left of the cursor, as well as any spaces or
 * punctuation after the word.
 */
function keyCommandBackspaceWord(editorState) {
  var afterRemoval = removeTextWithStrategy_1(
    editorState,
    function(strategyState) {
      var selection = strategyState.getSelection();
      var offset = selection.getStartOffset();
      // If there are no words before the cursor, remove the preceding newline.
      if (offset === 0) {
        return moveSelectionBackward_1(strategyState, 1);
      }
      var key = selection.getStartKey();
      var content = strategyState.getCurrentContent();
      var text = content
        .getBlockForKey(key)
        .getText()
        .slice(0, offset);
      var toRemove = DraftRemovableWord_1.getBackward(text);
      return moveSelectionBackward_1(strategyState, toRemove.length || 1);
    },
    "backward"
  );

  if (afterRemoval === editorState.getCurrentContent()) {
    return editorState;
  }

  return EditorState_1.push(editorState, afterRemoval, "remove-range");
}

var keyCommandBackspaceWord_1 = keyCommandBackspaceWord;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule moveSelectionForward
 * @format
 *
 */

/**
 * Given a collapsed selection, move the focus `maxDistance` forward within
 * the selected block. If the selection will go beyond the end of the block,
 * move focus to the start of the next block, but no further.
 *
 * This function is not Unicode-aware, so surrogate pairs will be treated
 * as having length 2.
 */
function moveSelectionForward(editorState, maxDistance) {
  var selection = editorState.getSelection();
  var key = selection.getStartKey();
  var offset = selection.getStartOffset();
  var content = editorState.getCurrentContent();

  var focusKey = key;
  var focusOffset;

  var block = content.getBlockForKey(key);

  if (maxDistance > block.getText().length - offset) {
    focusKey = content.getKeyAfter(key);
    focusOffset = 0;
  } else {
    focusOffset = offset + maxDistance;
  }

  return selection.merge({ focusKey: focusKey, focusOffset: focusOffset });
}

var moveSelectionForward_1 = moveSelectionForward;

/**
 * Delete the word that is right of the cursor, as well as any spaces or
 * punctuation before the word.
 */
function keyCommandDeleteWord(editorState) {
  var afterRemoval = removeTextWithStrategy_1(
    editorState,
    function(strategyState) {
      var selection = strategyState.getSelection();
      var offset = selection.getStartOffset();
      var key = selection.getStartKey();
      var content = strategyState.getCurrentContent();
      var text = content
        .getBlockForKey(key)
        .getText()
        .slice(offset);
      var toRemove = DraftRemovableWord_1.getForward(text);

      // If there are no words in front of the cursor, remove the newline.
      return moveSelectionForward_1(strategyState, toRemove.length || 1);
    },
    "forward"
  );

  if (afterRemoval === editorState.getCurrentContent()) {
    return editorState;
  }

  return EditorState_1.push(editorState, afterRemoval, "remove-range");
}

var keyCommandDeleteWord_1 = keyCommandDeleteWord;

function keyCommandInsertNewline(editorState) {
  var contentState = DraftModifier_1.splitBlock(
    editorState.getCurrentContent(),
    editorState.getSelection()
  );
  return EditorState_1.push(editorState, contentState, "split-block");
}

var keyCommandInsertNewline_1 = keyCommandInsertNewline;

/**
 * See comment for `moveSelectionToStartOfBlock`.
 */
function keyCommandMoveSelectionToEndOfBlock(editorState) {
  var selection = editorState.getSelection();
  var endKey = selection.getEndKey();
  var content = editorState.getCurrentContent();
  var textLength = content.getBlockForKey(endKey).getLength();
  return EditorState_1.set(editorState, {
    selection: selection.merge({
      anchorKey: endKey,
      anchorOffset: textLength,
      focusKey: endKey,
      focusOffset: textLength,
      isBackward: false
    }),
    forceSelection: true
  });
}

var keyCommandMoveSelectionToEndOfBlock_1 = keyCommandMoveSelectionToEndOfBlock;

/**
 * Collapse selection at the start of the first selected block. This is used
 * for Firefox versions that attempt to navigate forward/backward instead of
 * moving the cursor. Other browsers are able to move the cursor natively.
 */
function keyCommandMoveSelectionToStartOfBlock(editorState) {
  var selection = editorState.getSelection();
  var startKey = selection.getStartKey();
  return EditorState_1.set(editorState, {
    selection: selection.merge({
      anchorKey: startKey,
      anchorOffset: 0,
      focusKey: startKey,
      focusOffset: 0,
      isBackward: false
    }),
    forceSelection: true
  });
}

var keyCommandMoveSelectionToStartOfBlock_1 = keyCommandMoveSelectionToStartOfBlock;

/**
 * Remove the selected range. If the cursor is collapsed, remove the preceding
 * character. This operation is Unicode-aware, so removing a single character
 * will remove a surrogate pair properly as well.
 */
function keyCommandPlainBackspace(editorState) {
  var afterRemoval = removeTextWithStrategy_1(
    editorState,
    function(strategyState) {
      var selection = strategyState.getSelection();
      var content = strategyState.getCurrentContent();
      var key = selection.getAnchorKey();
      var offset = selection.getAnchorOffset();
      var charBehind = content.getBlockForKey(key).getText()[offset - 1];
      return moveSelectionBackward_1(
        strategyState,
        charBehind ? UnicodeUtils_1.getUTF16Length(charBehind, 0) : 1
      );
    },
    "backward"
  );

  if (afterRemoval === editorState.getCurrentContent()) {
    return editorState;
  }

  var selection = editorState.getSelection();
  return EditorState_1.push(
    editorState,
    afterRemoval.set("selectionBefore", selection),
    selection.isCollapsed() ? "backspace-character" : "remove-range"
  );
}

var keyCommandPlainBackspace_1 = keyCommandPlainBackspace;

/**
 * Remove the selected range. If the cursor is collapsed, remove the following
 * character. This operation is Unicode-aware, so removing a single character
 * will remove a surrogate pair properly as well.
 */
function keyCommandPlainDelete(editorState) {
  var afterRemoval = removeTextWithStrategy_1(
    editorState,
    function(strategyState) {
      var selection = strategyState.getSelection();
      var content = strategyState.getCurrentContent();
      var key = selection.getAnchorKey();
      var offset = selection.getAnchorOffset();
      var charAhead = content.getBlockForKey(key).getText()[offset];
      return moveSelectionForward_1(
        strategyState,
        charAhead ? UnicodeUtils_1.getUTF16Length(charAhead, 0) : 1
      );
    },
    "forward"
  );

  if (afterRemoval === editorState.getCurrentContent()) {
    return editorState;
  }

  var selection = editorState.getSelection();

  return EditorState_1.push(
    editorState,
    afterRemoval.set("selectionBefore", selection),
    selection.isCollapsed() ? "delete-character" : "remove-range"
  );
}

var keyCommandPlainDelete_1 = keyCommandPlainDelete;

/**
 * Transpose the characters on either side of a collapsed cursor, or
 * if the cursor is at the end of the block, transpose the last two
 * characters.
 */
function keyCommandTransposeCharacters(editorState) {
  var selection = editorState.getSelection();
  if (!selection.isCollapsed()) {
    return editorState;
  }

  var offset = selection.getAnchorOffset();
  if (offset === 0) {
    return editorState;
  }

  var blockKey = selection.getAnchorKey();
  var content = editorState.getCurrentContent();
  var block = content.getBlockForKey(blockKey);
  var length = block.getLength();

  // Nothing to transpose if there aren't two characters.
  if (length <= 1) {
    return editorState;
  }

  var removalRange;
  var finalSelection;

  if (offset === length) {
    // The cursor is at the end of the block. Swap the last two characters.
    removalRange = selection.set("anchorOffset", offset - 1);
    finalSelection = selection;
  } else {
    removalRange = selection.set("focusOffset", offset + 1);
    finalSelection = removalRange.set("anchorOffset", offset + 1);
  }

  // Extract the character to move as a fragment. This preserves its
  // styling and entity, if any.
  var movedFragment = getContentStateFragment_1(content, removalRange);
  var afterRemoval = DraftModifier_1.removeRange(
    content,
    removalRange,
    "backward"
  );

  // After the removal, the insertion target is one character back.
  var selectionAfter = afterRemoval.getSelectionAfter();
  var targetOffset = selectionAfter.getAnchorOffset() - 1;
  var targetRange = selectionAfter.merge({
    anchorOffset: targetOffset,
    focusOffset: targetOffset
  });

  var afterInsert = DraftModifier_1.replaceWithFragment(
    afterRemoval,
    targetRange,
    movedFragment
  );

  var newEditorState = EditorState_1.push(
    editorState,
    afterInsert,
    "insert-fragment"
  );

  return EditorState_1.acceptSelection(newEditorState, finalSelection);
}

var keyCommandTransposeCharacters_1 = keyCommandTransposeCharacters;

function keyCommandUndo(e, editorState, updateFn) {
  var undoneState = EditorState_1.undo(editorState);

  // If the last change to occur was a spellcheck change, allow the undo
  // event to fall through to the browser. This allows the browser to record
  // the unwanted change, which should soon lead it to learn not to suggest
  // the correction again.
  if (editorState.getLastChangeType() === "spellcheck-change") {
    var nativelyRenderedContent = undoneState.getCurrentContent();
    updateFn(
      EditorState_1.set(undoneState, {
        nativelyRenderedContent: nativelyRenderedContent
      })
    );
    return;
  }

  // Otheriwse, manage the undo behavior manually.
  e.preventDefault();
  if (!editorState.getNativelyRenderedContent()) {
    updateFn(undoneState);
    return;
  }

  // Trigger a re-render with the current content state to ensure that the
  // component tree has up-to-date props for comparison.
  updateFn(EditorState_1.set(editorState, { nativelyRenderedContent: null }));

  // Wait to ensure that the re-render has occurred before performing
  // the undo action.
  setTimeout(function() {
    updateFn(undoneState);
  }, 0);
}

var keyCommandUndo_1 = keyCommandUndo;

var isOptionKeyCommand = KeyBindingUtil_1.isOptionKeyCommand;

var isChrome$1 = UserAgent_1.isBrowser("Chrome");

/**
 * Map a `DraftEditorCommand` command value to a corresponding function.
 */
function onKeyCommand(command, editorState) {
  switch (command) {
    case "redo":
      return EditorState_1.redo(editorState);
    case "delete":
      return keyCommandPlainDelete_1(editorState);
    case "delete-word":
      return keyCommandDeleteWord_1(editorState);
    case "backspace":
      return keyCommandPlainBackspace_1(editorState);
    case "backspace-word":
      return keyCommandBackspaceWord_1(editorState);
    case "backspace-to-start-of-line":
      return keyCommandBackspaceToStartOfLine_1(editorState);
    case "split-block":
      return keyCommandInsertNewline_1(editorState);
    case "transpose-characters":
      return keyCommandTransposeCharacters_1(editorState);
    case "move-selection-to-start-of-block":
      return keyCommandMoveSelectionToStartOfBlock_1(editorState);
    case "move-selection-to-end-of-block":
      return keyCommandMoveSelectionToEndOfBlock_1(editorState);
    case "secondary-cut":
      return SecondaryClipboard_1.cut(editorState);
    case "secondary-paste":
      return SecondaryClipboard_1.paste(editorState);
    default:
      return editorState;
  }
}

/**
 * Intercept keydown behavior to handle keys and commands manually, if desired.
 *
 * Keydown combinations may be mapped to `DraftCommand` values, which may
 * correspond to command functions that modify the editor or its contents.
 *
 * See `getDefaultKeyBinding` for defaults. Alternatively, the top-level
 * component may provide a custom mapping via the `keyBindingFn` prop.
 */
function editOnKeyDown(editor, e) {
  var keyCode = e.which;
  var editorState = editor._latestEditorState;

  switch (keyCode) {
    case Keys.RETURN:
      e.preventDefault();
      // The top-level component may manually handle newline insertion. If
      // no special handling is performed, fall through to command handling.
      if (
        editor.props.handleReturn &&
        isEventHandled_1(editor.props.handleReturn(e, editorState))
      ) {
        return;
      }
      break;
    case Keys.ESC:
      e.preventDefault();
      editor.props.onEscape && editor.props.onEscape(e);
      return;
    case Keys.TAB:
      editor.props.onTab && editor.props.onTab(e);
      return;
    case Keys.UP:
      editor.props.onUpArrow && editor.props.onUpArrow(e);
      return;
    case Keys.RIGHT:
      editor.props.onRightArrow && editor.props.onRightArrow(e);
      return;
    case Keys.DOWN:
      editor.props.onDownArrow && editor.props.onDownArrow(e);
      return;
    case Keys.LEFT:
      editor.props.onLeftArrow && editor.props.onLeftArrow(e);
      return;
    case Keys.SPACE:
      // Handling for OSX where option + space scrolls.
      if (isChrome$1 && isOptionKeyCommand(e)) {
        e.preventDefault();
        // Insert a nbsp into the editor.
        var contentState = DraftModifier_1.replaceText(
          editorState.getCurrentContent(),
          editorState.getSelection(),
          "\xA0"
        );
        editor.update(
          EditorState_1.push(editorState, contentState, "insert-characters")
        );
        return;
      }
  }

  var command = editor.props.keyBindingFn(e);

  // If no command is specified, allow keydown event to continue.
  if (!command) {
    return;
  }

  if (command === "undo") {
    // Since undo requires some special updating behavior to keep the editor
    // in sync, handle it separately.
    keyCommandUndo_1(e, editorState, editor.update);
    return;
  }

  // At this point, we know that we're handling a command of some kind, so
  // we don't want to insert a character following the keydown.
  e.preventDefault();

  // Allow components higher up the tree to handle the command first.
  if (
    editor.props.handleKeyCommand &&
    isEventHandled_1(editor.props.handleKeyCommand(command, editorState))
  ) {
    return;
  }

  var newState = onKeyCommand(command, editorState);
  if (newState !== editorState) {
    editor.update(newState);
  }
}

var editOnKeyDown_1 = editOnKeyDown;

/**
 * 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.
 *
 *
 */

function _classCallCheck$e(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

var URI = (function() {
  function URI(uri) {
    _classCallCheck$e(this, URI);

    this._uri = uri;
  }

  URI.prototype.toString = function toString() {
    return this._uri;
  };

  return URI;
})();

var URI_1 = URI;

var isOldIE = UserAgent_1.isBrowser("IE <= 9");

// Provides a dom node that will not execute scripts
// https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation.createHTMLDocument
// https://developer.mozilla.org/en-US/Add-ons/Code_snippets/HTML_to_DOM

function getSafeBodyFromHTML(html) {
  var doc;
  var root = null;
  // Provides a safe context
  if (
    !isOldIE &&
    document.implementation &&
    document.implementation.createHTMLDocument
  ) {
    doc = document.implementation.createHTMLDocument("foo");
    !doc.documentElement
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(false, "Missing doc.documentElement")
        : invariant_1(false)
      : void 0;
    doc.documentElement.innerHTML = html;
    root = doc.getElementsByTagName("body")[0];
  }
  return root;
}

var getSafeBodyFromHTML_1 = getSafeBodyFromHTML;

var _extends$4 =
  objectAssign ||
  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;
  };

var _knownListItemDepthCl;

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 _require = immutable,
  Set = _require.Set;

var experimentalTreeDataSupport = DraftFeatureFlags_1.draft_tree_data_support;

var List$a = immutable.List,
  OrderedSet$5 = immutable.OrderedSet;

var NBSP = "&nbsp;";
var SPACE = " ";

// Arbitrary max indent
var MAX_DEPTH = 4;

// used for replacing characters in HTML
var REGEX_CR = new RegExp("\r", "g");
var REGEX_LF = new RegExp("\n", "g");
var REGEX_NBSP = new RegExp(NBSP, "g");
var REGEX_CARRIAGE = new RegExp("&#13;?", "g");
var REGEX_ZWS = new RegExp("&#8203;?", "g");

// https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight
var boldValues = ["bold", "bolder", "500", "600", "700", "800", "900"];
var notBoldValues = ["light", "lighter", "100", "200", "300", "400"];

// Block tag flow is different because LIs do not have
// a deterministic style ;_;
var inlineTags = {
  b: "BOLD",
  code: "CODE",
  del: "STRIKETHROUGH",
  em: "ITALIC",
  i: "ITALIC",
  s: "STRIKETHROUGH",
  strike: "STRIKETHROUGH",
  strong: "BOLD",
  u: "UNDERLINE"
};

var knownListItemDepthClasses =
  ((_knownListItemDepthCl = {}),
  _defineProperty(
    _knownListItemDepthCl,
    cx_1("public/DraftStyleDefault/depth0"),
    0
  ),
  _defineProperty(
    _knownListItemDepthCl,
    cx_1("public/DraftStyleDefault/depth1"),
    1
  ),
  _defineProperty(
    _knownListItemDepthCl,
    cx_1("public/DraftStyleDefault/depth2"),
    2
  ),
  _defineProperty(
    _knownListItemDepthCl,
    cx_1("public/DraftStyleDefault/depth3"),
    3
  ),
  _defineProperty(
    _knownListItemDepthCl,
    cx_1("public/DraftStyleDefault/depth4"),
    4
  ),
  _knownListItemDepthCl);

var anchorAttr = ["className", "href", "rel", "target", "title"];

var imgAttr = ["alt", "className", "height", "src", "width"];

var lastBlock = void 0;

var EMPTY_CHUNK = {
  text: "",
  inlines: [],
  entities: [],
  blocks: []
};

var EMPTY_BLOCK = {
  children: List$a(),
  depth: 0,
  key: "",
  type: ""
};

var getListBlockType = function getListBlockType(tag, lastList) {
  if (tag === "li") {
    return lastList === "ol" ? "ordered-list-item" : "unordered-list-item";
  }
  return null;
};

var getBlockMapSupportedTags = function getBlockMapSupportedTags(
  blockRenderMap
) {
  var unstyledElement = blockRenderMap.get("unstyled").element;
  var tags = Set([]);

  blockRenderMap.forEach(function(draftBlock) {
    if (draftBlock.aliasedElements) {
      draftBlock.aliasedElements.forEach(function(tag) {
        tags = tags.add(tag);
      });
    }

    tags = tags.add(draftBlock.element);
  });

  return tags
    .filter(function(tag) {
      return tag && tag !== unstyledElement;
    })
    .toArray()
    .sort();
};

// custom element conversions
var getMultiMatchedType = function getMultiMatchedType(
  tag,
  lastList,
  multiMatchExtractor
) {
  for (var ii = 0; ii < multiMatchExtractor.length; ii++) {
    var matchType = multiMatchExtractor[ii](tag, lastList);
    if (matchType) {
      return matchType;
    }
  }
  return null;
};

var getBlockTypeForTag = function getBlockTypeForTag(
  tag,
  lastList,
  blockRenderMap
) {
  var matchedTypes = blockRenderMap
    .filter(function(draftBlock) {
      return (
        draftBlock.element === tag ||
        draftBlock.wrapper === tag ||
        (draftBlock.aliasedElements &&
          draftBlock.aliasedElements.some(function(alias) {
            return alias === tag;
          }))
      );
    })
    .keySeq()
    .toSet()
    .toArray()
    .sort();

  // if we dont have any matched type, return unstyled
  // if we have one matched type return it
  // if we have multi matched types use the multi-match function to gather type
  switch (matchedTypes.length) {
    case 0:
      return "unstyled";
    case 1:
      return matchedTypes[0];
    default:
      return (
        getMultiMatchedType(tag, lastList, [getListBlockType]) || "unstyled"
      );
  }
};

var processInlineTag = function processInlineTag(tag, node, currentStyle) {
  var styleToCheck = inlineTags[tag];
  if (styleToCheck) {
    currentStyle = currentStyle.add(styleToCheck).toOrderedSet();
  } else if (node instanceof HTMLElement) {
    var htmlElement = node;
    currentStyle = currentStyle
      .withMutations(function(style) {
        var fontWeight = htmlElement.style.fontWeight;
        var fontStyle = htmlElement.style.fontStyle;
        var textDecoration = htmlElement.style.textDecoration;

        if (boldValues.indexOf(fontWeight) >= 0) {
          style.add("BOLD");
        } else if (notBoldValues.indexOf(fontWeight) >= 0) {
          style.remove("BOLD");
        }

        if (fontStyle === "italic") {
          style.add("ITALIC");
        } else if (fontStyle === "normal") {
          style.remove("ITALIC");
        }

        if (textDecoration === "underline") {
          style.add("UNDERLINE");
        }
        if (textDecoration === "line-through") {
          style.add("STRIKETHROUGH");
        }
        if (textDecoration === "none") {
          style.remove("UNDERLINE");
          style.remove("STRIKETHROUGH");
        }
      })
      .toOrderedSet();
  }
  return currentStyle;
};

var joinChunks = function joinChunks(A, B, experimentalHasNestedBlocks) {
  // Sometimes two blocks will touch in the DOM and we need to strip the
  // extra delimiter to preserve niceness.
  var lastInA = A.text.slice(-1);
  var firstInB = B.text.slice(0, 1);

  if (lastInA === "\r" && firstInB === "\r" && !experimentalHasNestedBlocks) {
    A.text = A.text.slice(0, -1);
    A.inlines.pop();
    A.entities.pop();
    A.blocks.pop();
  }

  // Kill whitespace after blocks
  if (lastInA === "\r") {
    if (B.text === SPACE || B.text === "\n") {
      return A;
    } else if (firstInB === SPACE || firstInB === "\n") {
      B.text = B.text.slice(1);
      B.inlines.shift();
      B.entities.shift();
    }
  }

  return {
    text: A.text + B.text,
    inlines: A.inlines.concat(B.inlines),
    entities: A.entities.concat(B.entities),
    blocks: A.blocks.concat(B.blocks)
  };
};

/**
 * Check to see if we have anything like <p> <blockquote> <h1>... to create
 * block tags from. If we do, we can use those and ignore <div> tags. If we
 * don't, we can treat <div> tags as meaningful (unstyled) blocks.
 */
var containsSemanticBlockMarkup = function containsSemanticBlockMarkup(
  html,
  blockTags
) {
  return blockTags.some(function(tag) {
    return html.indexOf("<" + tag) !== -1;
  });
};

var hasValidLinkText = function hasValidLinkText(link) {
  !(link instanceof HTMLAnchorElement)
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "Link must be an HTMLAnchorElement.")
      : invariant_1(false)
    : void 0;
  var protocol = link.protocol;
  return (
    protocol === "http:" || protocol === "https:" || protocol === "mailto:"
  );
};

var getWhitespaceChunk = function getWhitespaceChunk(inEntity) {
  var entities = new Array(1);
  if (inEntity) {
    entities[0] = inEntity;
  }
  return _extends$4({}, EMPTY_CHUNK, {
    text: SPACE,
    inlines: [OrderedSet$5()],
    entities: entities
  });
};

var getSoftNewlineChunk = function getSoftNewlineChunk() {
  return _extends$4({}, EMPTY_CHUNK, {
    text: "\n",
    inlines: [OrderedSet$5()],
    entities: new Array(1)
  });
};

var getChunkedBlock = function getChunkedBlock() {
  var props =
    arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

  return _extends$4({}, EMPTY_BLOCK, props);
};

var getBlockDividerChunk = function getBlockDividerChunk(block, depth) {
  var parentKey =
    arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;

  return {
    text: "\r",
    inlines: [OrderedSet$5()],
    entities: new Array(1),
    blocks: [
      getChunkedBlock({
        parent: parentKey,
        key: generateRandomKey_1(),
        type: block,
        depth: Math.max(0, Math.min(MAX_DEPTH, depth))
      })
    ]
  };
};

/**
 *  If we're pasting from one DraftEditor to another we can check to see if
 *  existing list item depth classes are being used and preserve this style
 */
var getListItemDepth = function getListItemDepth(node) {
  var depth =
    arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;

  Object.keys(knownListItemDepthClasses).some(function(depthClass) {
    if (node.classList.contains(depthClass)) {
      depth = knownListItemDepthClasses[depthClass];
    }
  });
  return depth;
};

var genFragment = function genFragment(
  entityMap,
  node,
  inlineStyle,
  lastList,
  inBlock,
  blockTags,
  depth,
  blockRenderMap,
  inEntity,
  parentKey
) {
  var lastLastBlock = lastBlock;
  var nodeName = node.nodeName.toLowerCase();
  var newEntityMap = entityMap;
  var nextBlockType = "unstyled";
  var newBlock = false;
  var inBlockType =
    inBlock && getBlockTypeForTag(inBlock, lastList, blockRenderMap);
  var chunk = _extends$4({}, EMPTY_CHUNK);
  var newChunk = null;
  var blockKey = void 0;

  // Base Case
  if (nodeName === "#text") {
    var _text = node.textContent;
    var nodeTextContent = _text.trim();

    // We should not create blocks for leading spaces that are
    // existing around ol/ul and their children list items
    if (lastList && nodeTextContent === "" && node.parentElement) {
      var parentNodeName = node.parentElement.nodeName.toLowerCase();
      if (parentNodeName === "ol" || parentNodeName === "ul") {
        return { chunk: _extends$4({}, EMPTY_CHUNK), entityMap: entityMap };
      }
    }

    if (nodeTextContent === "" && inBlock !== "pre") {
      return { chunk: getWhitespaceChunk(inEntity), entityMap: entityMap };
    }
    if (inBlock !== "pre") {
      // Can't use empty string because MSWord
      _text = _text.replace(REGEX_LF, SPACE);
    }

    // save the last block so we can use it later
    lastBlock = nodeName;

    return {
      chunk: {
        text: _text,
        inlines: Array(_text.length).fill(inlineStyle),
        entities: Array(_text.length).fill(inEntity),
        blocks: []
      },
      entityMap: entityMap
    };
  }

  // save the last block so we can use it later
  lastBlock = nodeName;

  // BR tags
  if (nodeName === "br") {
    if (lastLastBlock === "br" && (!inBlock || inBlockType === "unstyled")) {
      return {
        chunk: getBlockDividerChunk("unstyled", depth, parentKey),
        entityMap: entityMap
      };
    }
    return { chunk: getSoftNewlineChunk(), entityMap: entityMap };
  }

  // IMG tags
  if (
    nodeName === "img" &&
    node instanceof HTMLImageElement &&
    node.attributes.getNamedItem("src") &&
    node.attributes.getNamedItem("src").value
  ) {
    var image = node;
    var entityConfig = {};

    imgAttr.forEach(function(attr) {
      var imageAttribute = image.getAttribute(attr);
      if (imageAttribute) {
        entityConfig[attr] = imageAttribute;
      }
    });
    // Forcing this node to have children because otherwise no entity will be
    // created for this node.
    // The child text node cannot just have a space or return as content -
    // we strip those out.
    // See https://github.com/facebook/draft-js/issues/231 for some context.
    node.textContent = "\uD83D\uDCF7";

    // TODO: update this when we remove DraftEntity entirely
    inEntity = DraftEntity_1.__create("IMAGE", "MUTABLE", entityConfig || {});
  }

  // Inline tags
  inlineStyle = processInlineTag(nodeName, node, inlineStyle);

  // Handle lists
  if (nodeName === "ul" || nodeName === "ol") {
    if (lastList) {
      depth += 1;
    }
    lastList = nodeName;
  }

  if (nodeName === "li" && node instanceof HTMLElement) {
    depth = getListItemDepth(node, depth);
  }

  var blockType = getBlockTypeForTag(nodeName, lastList, blockRenderMap);
  var inListBlock = lastList && inBlock === "li" && nodeName === "li";
  var inBlockOrHasNestedBlocks =
    (!inBlock || experimentalTreeDataSupport) &&
    blockTags.indexOf(nodeName) !== -1;

  // Block Tags
  if (inListBlock || inBlockOrHasNestedBlocks) {
    chunk = getBlockDividerChunk(blockType, depth, parentKey);
    blockKey = chunk.blocks[0].key;
    inBlock = nodeName;
    newBlock = !experimentalTreeDataSupport;
  }

  // this is required so that we can handle 'ul' and 'ol'
  if (inListBlock) {
    nextBlockType =
      lastList === "ul" ? "unordered-list-item" : "ordered-list-item";
  }

  // Recurse through children
  var child = node.firstChild;
  if (child != null) {
    nodeName = child.nodeName.toLowerCase();
  }

  var entityId = null;

  while (child) {
    if (
      child instanceof HTMLAnchorElement &&
      child.href &&
      hasValidLinkText(child)
    ) {
      (function() {
        var anchor = child;
        var entityConfig = {};

        anchorAttr.forEach(function(attr) {
          var anchorAttribute = anchor.getAttribute(attr);
          if (anchorAttribute) {
            entityConfig[attr] = anchorAttribute;
          }
        });

        entityConfig.url = new URI_1(anchor.href).toString();
        // TODO: update this when we remove DraftEntity completely
        entityId = DraftEntity_1.__create(
          "LINK",
          "MUTABLE",
          entityConfig || {}
        );
      })();
    } else {
      entityId = undefined;
    }

    var _genFragment = genFragment(
        newEntityMap,
        child,
        inlineStyle,
        lastList,
        inBlock,
        blockTags,
        depth,
        blockRenderMap,
        entityId || inEntity,
        null
      ),
      generatedChunk = _genFragment.chunk,
      maybeUpdatedEntityMap = _genFragment.entityMap;

    newChunk = generatedChunk;
    newEntityMap = maybeUpdatedEntityMap;

    chunk = joinChunks(chunk, newChunk, experimentalTreeDataSupport);
    var sibling = child.nextSibling;

    // Put in a newline to break up blocks inside blocks
    if (!parentKey && sibling && blockTags.indexOf(nodeName) >= 0 && inBlock) {
      chunk = joinChunks(chunk, getSoftNewlineChunk());
    }
    if (sibling) {
      nodeName = sibling.nodeName.toLowerCase();
    }
    child = sibling;
  }

  if (newBlock) {
    chunk = joinChunks(
      chunk,
      getBlockDividerChunk(nextBlockType, depth, parentKey)
    );
  }

  return { chunk: chunk, entityMap: newEntityMap };
};

var getChunkForHTML = function getChunkForHTML(
  html,
  DOMBuilder,
  blockRenderMap,
  entityMap
) {
  html = html
    .trim()
    .replace(REGEX_CR, "")
    .replace(REGEX_NBSP, SPACE)
    .replace(REGEX_CARRIAGE, "")
    .replace(REGEX_ZWS, "");

  var supportedBlockTags = getBlockMapSupportedTags(blockRenderMap);

  var safeBody = DOMBuilder(html);
  if (!safeBody) {
    return null;
  }
  lastBlock = null;

  // Sometimes we aren't dealing with content that contains nice semantic
  // tags. In this case, use divs to separate everything out into paragraphs
  // and hope for the best.
  var workingBlocks = containsSemanticBlockMarkup(html, supportedBlockTags)
    ? supportedBlockTags
    : ["div"];

  // Start with -1 block depth to offset the fact that we are passing in a fake
  // UL block to start with.
  var fragment = genFragment(
    entityMap,
    safeBody,
    OrderedSet$5(),
    "ul",
    null,
    workingBlocks,
    -1,
    blockRenderMap
  );

  var chunk = fragment.chunk;
  var newEntityMap = fragment.entityMap;

  // join with previous block to prevent weirdness on paste
  if (chunk.text.indexOf("\r") === 0) {
    chunk = {
      text: chunk.text.slice(1),
      inlines: chunk.inlines.slice(1),
      entities: chunk.entities.slice(1),
      blocks: chunk.blocks
    };
  }

  // Kill block delimiter at the end
  if (chunk.text.slice(-1) === "\r") {
    chunk.text = chunk.text.slice(0, -1);
    chunk.inlines = chunk.inlines.slice(0, -1);
    chunk.entities = chunk.entities.slice(0, -1);
    chunk.blocks.pop();
  }

  // If we saw no block tags, put an unstyled one in
  if (chunk.blocks.length === 0) {
    chunk.blocks.push(
      _extends$4({}, EMPTY_CHUNK, {
        type: "unstyled",
        depth: 0
      })
    );
  }

  // Sometimes we start with text that isn't in a block, which is then
  // followed by blocks. Need to fix up the blocks to add in
  // an unstyled block for this content
  if (chunk.text.split("\r").length === chunk.blocks.length + 1) {
    chunk.blocks.unshift({ type: "unstyled", depth: 0 });
  }

  return { chunk: chunk, entityMap: newEntityMap };
};

var convertChunkToContentBlocks = function convertChunkToContentBlocks(chunk) {
  if (!chunk || !chunk.text || !Array.isArray(chunk.blocks)) {
    return null;
  }

  var initialState = {
    cacheRef: {},
    contentBlocks: []
  };

  var start = 0;

  var rawBlocks = chunk.blocks,
    rawInlines = chunk.inlines,
    rawEntities = chunk.entities;

  var BlockNodeRecord = ContentBlock_1;

  return chunk.text.split("\r").reduce(function(acc, textBlock, index) {
    // Make absolutely certain that our text is acceptable.
    textBlock = sanitizeDraftText_1(textBlock);

    var block = rawBlocks[index];
    var end = start + textBlock.length;
    var inlines = rawInlines.slice(start, end);
    var entities = rawEntities.slice(start, end);
    var characterList = List$a(
      inlines.map(function(style, index) {
        var data = { style: style, entity: null };
        if (entities[index]) {
          data.entity = entities[index];
        }
        return CharacterMetadata_1.create(data);
      })
    );
    start = end + 1;

    var depth = block.depth,
      type = block.type,
      parent = block.parent;

    var key = block.key || generateRandomKey_1();
    var parentTextNodeKey = null; // will be used to store container text nodes

    // childrens add themselves to their parents since we are iterating in order
    if (parent) {
      var parentIndex = acc.cacheRef[parent];
      var parentRecord = acc.contentBlocks[parentIndex];

      // if parent has text we need to split it into a separate unstyled element
      if (parentRecord.getChildKeys().isEmpty() && parentRecord.getText()) {
        var parentCharacterList = parentRecord.getCharacterList();
        var parentText = parentRecord.getText();
        parentTextNodeKey = generateRandomKey_1();

        var textNode = new ContentBlockNode_1({
          key: parentTextNodeKey,
          text: parentText,
          characterList: parentCharacterList,
          parent: parent,
          nextSibling: key
        });

        acc.contentBlocks.push(textNode);

        parentRecord = parentRecord.withMutations(function(block) {
          block
            .set("characterList", List$a())
            .set("text", "")
            .set("children", parentRecord.children.push(textNode.getKey()));
        });
      }

      acc.contentBlocks[parentIndex] = parentRecord.set(
        "children",
        parentRecord.children.push(key)
      );
    }

    var blockNode = new BlockNodeRecord({
      key: key,
      parent: parent,
      type: type,
      depth: depth,
      text: textBlock,
      characterList: characterList,
      prevSibling:
        parentTextNodeKey ||
        (index === 0 || rawBlocks[index - 1].parent !== parent
          ? null
          : rawBlocks[index - 1].key),
      nextSibling:
        index === rawBlocks.length - 1 || rawBlocks[index + 1].parent !== parent
          ? null
          : rawBlocks[index + 1].key
    });

    // insert node
    acc.contentBlocks.push(blockNode);

    // cache ref for building links
    acc.cacheRef[blockNode.key] = index;

    return acc;
  }, initialState).contentBlocks;
};

var convertFromHTMLtoContentBlocks = function convertFromHTMLtoContentBlocks(
  html
) {
  var DOMBuilder =
    arguments.length > 1 && arguments[1] !== undefined
      ? arguments[1]
      : getSafeBodyFromHTML_1;
  var blockRenderMap =
    arguments.length > 2 && arguments[2] !== undefined
      ? arguments[2]
      : DefaultDraftBlockRenderMap_1;

  // Be ABSOLUTELY SURE that the dom builder you pass here won't execute
  // arbitrary code in whatever environment you're running this in. For an
  // example of how we try to do this in-browser, see getSafeBodyFromHTML.

  // TODO: replace DraftEntity with an OrderedMap here
  var chunkData = getChunkForHTML(
    html,
    DOMBuilder,
    blockRenderMap,
    DraftEntity_1
  );

  if (chunkData == null) {
    return null;
  }

  var chunk = chunkData.chunk,
    entityMap = chunkData.entityMap;

  var contentBlocks = convertChunkToContentBlocks(chunk);

  return {
    contentBlocks: contentBlocks,
    entityMap: entityMap
  };
};

var convertFromHTMLToContentBlocks = convertFromHTMLtoContentBlocks;

var List$b = immutable.List,
  Repeat$6 = immutable.Repeat;
var ContentBlockRecord$2 = ContentBlock_1;

var DraftPasteProcessor = {
  processHTML: function processHTML(html, blockRenderMap) {
    return convertFromHTMLToContentBlocks(
      html,
      getSafeBodyFromHTML_1,
      blockRenderMap
    );
  },
  processText: function processText(textBlocks, character, type) {
    return textBlocks.reduce(function(acc, textLine, index) {
      textLine = sanitizeDraftText_1(textLine);
      var key = generateRandomKey_1();

      var blockNodeConfig = {
        key: key,
        type: type,
        text: textLine,
        characterList: List$b(Repeat$6(character, textLine.length))
      };

      acc.push(new ContentBlockRecord$2(blockNodeConfig));

      return acc;
    }, []);
  }
};

var DraftPasteProcessor_1 = DraftPasteProcessor;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule adjustBlockDepthForContentState
 * @format
 *
 */

function adjustBlockDepthForContentState(
  contentState,
  selectionState,
  adjustment,
  maxDepth
) {
  var startKey = selectionState.getStartKey();
  var endKey = selectionState.getEndKey();
  var blockMap = contentState.getBlockMap();
  var blocks = blockMap
    .toSeq()
    .skipUntil(function(_, k) {
      return k === startKey;
    })
    .takeUntil(function(_, k) {
      return k === endKey;
    })
    .concat([[endKey, blockMap.get(endKey)]])
    .map(function(block) {
      var depth = block.getDepth() + adjustment;
      depth = Math.max(0, Math.min(depth, maxDepth));
      return block.set("depth", depth);
    });

  blockMap = blockMap.merge(blocks);

  return contentState.merge({
    blockMap: blockMap,
    selectionBefore: selectionState,
    selectionAfter: selectionState
  });
}

var adjustBlockDepthForContentState_1 = adjustBlockDepthForContentState;

var RichTextEditorUtil = {
  currentBlockContainsLink: function currentBlockContainsLink(editorState) {
    var selection = editorState.getSelection();
    var contentState = editorState.getCurrentContent();
    var entityMap = contentState.getEntityMap();
    return contentState
      .getBlockForKey(selection.getAnchorKey())
      .getCharacterList()
      .slice(selection.getStartOffset(), selection.getEndOffset())
      .some(function(v) {
        var entity = v.getEntity();
        return !!entity && entityMap.__get(entity).getType() === "LINK";
      });
  },

  getCurrentBlockType: function getCurrentBlockType(editorState) {
    var selection = editorState.getSelection();
    return editorState
      .getCurrentContent()
      .getBlockForKey(selection.getStartKey())
      .getType();
  },

  getDataObjectForLinkURL: function getDataObjectForLinkURL(uri) {
    return { url: uri.toString() };
  },

  handleKeyCommand: function handleKeyCommand(editorState, command) {
    switch (command) {
      case "bold":
        return RichTextEditorUtil.toggleInlineStyle(editorState, "BOLD");
      case "italic":
        return RichTextEditorUtil.toggleInlineStyle(editorState, "ITALIC");
      case "underline":
        return RichTextEditorUtil.toggleInlineStyle(editorState, "UNDERLINE");
      case "code":
        return RichTextEditorUtil.toggleCode(editorState);
      case "backspace":
      case "backspace-word":
      case "backspace-to-start-of-line":
        return RichTextEditorUtil.onBackspace(editorState);
      case "delete":
      case "delete-word":
      case "delete-to-end-of-block":
        return RichTextEditorUtil.onDelete(editorState);
      default:
        // they may have custom editor commands; ignore those
        return null;
    }
  },

  insertSoftNewline: function insertSoftNewline(editorState) {
    var contentState = DraftModifier_1.insertText(
      editorState.getCurrentContent(),
      editorState.getSelection(),
      "\n",
      editorState.getCurrentInlineStyle(),
      null
    );

    var newEditorState = EditorState_1.push(
      editorState,
      contentState,
      "insert-characters"
    );

    return EditorState_1.forceSelection(
      newEditorState,
      contentState.getSelectionAfter()
    );
  },

  /**
   * For collapsed selections at the start of styled blocks, backspace should
   * just remove the existing style.
   */
  onBackspace: function onBackspace(editorState) {
    var selection = editorState.getSelection();
    if (
      !selection.isCollapsed() ||
      selection.getAnchorOffset() ||
      selection.getFocusOffset()
    ) {
      return null;
    }

    // First, try to remove a preceding atomic block.
    var content = editorState.getCurrentContent();
    var startKey = selection.getStartKey();
    var blockBefore = content.getBlockBefore(startKey);

    if (blockBefore && blockBefore.getType() === "atomic") {
      var blockMap = content.getBlockMap()["delete"](blockBefore.getKey());
      var withoutAtomicBlock = content.merge({
        blockMap: blockMap,
        selectionAfter: selection
      });
      if (withoutAtomicBlock !== content) {
        return EditorState_1.push(
          editorState,
          withoutAtomicBlock,
          "remove-range"
        );
      }
    }

    // If that doesn't succeed, try to remove the current block style.
    var withoutBlockStyle = RichTextEditorUtil.tryToRemoveBlockStyle(
      editorState
    );

    if (withoutBlockStyle) {
      return EditorState_1.push(
        editorState,
        withoutBlockStyle,
        "change-block-type"
      );
    }

    return null;
  },

  onDelete: function onDelete(editorState) {
    var selection = editorState.getSelection();
    if (!selection.isCollapsed()) {
      return null;
    }

    var content = editorState.getCurrentContent();
    var startKey = selection.getStartKey();
    var block = content.getBlockForKey(startKey);
    var length = block.getLength();

    // The cursor is somewhere within the text. Behave normally.
    if (selection.getStartOffset() < length) {
      return null;
    }

    var blockAfter = content.getBlockAfter(startKey);

    if (!blockAfter || blockAfter.getType() !== "atomic") {
      return null;
    }

    var atomicBlockTarget = selection.merge({
      focusKey: blockAfter.getKey(),
      focusOffset: blockAfter.getLength()
    });

    var withoutAtomicBlock = DraftModifier_1.removeRange(
      content,
      atomicBlockTarget,
      "forward"
    );

    if (withoutAtomicBlock !== content) {
      return EditorState_1.push(
        editorState,
        withoutAtomicBlock,
        "remove-range"
      );
    }

    return null;
  },

  onTab: function onTab(event, editorState, maxDepth) {
    var selection = editorState.getSelection();
    var key = selection.getAnchorKey();
    if (key !== selection.getFocusKey()) {
      return editorState;
    }

    var content = editorState.getCurrentContent();
    var block = content.getBlockForKey(key);
    var type = block.getType();
    if (type !== "unordered-list-item" && type !== "ordered-list-item") {
      return editorState;
    }

    event.preventDefault();

    // Only allow indenting one level beyond the block above, and only if
    // the block above is a list item as well.
    var blockAbove = content.getBlockBefore(key);
    if (!blockAbove) {
      return editorState;
    }

    var typeAbove = blockAbove.getType();
    if (
      typeAbove !== "unordered-list-item" &&
      typeAbove !== "ordered-list-item"
    ) {
      return editorState;
    }

    var depth = block.getDepth();
    if (!event.shiftKey && depth === maxDepth) {
      return editorState;
    }

    maxDepth = Math.min(blockAbove.getDepth() + 1, maxDepth);

    var withAdjustment = adjustBlockDepthForContentState_1(
      content,
      selection,
      event.shiftKey ? -1 : 1,
      maxDepth
    );

    return EditorState_1.push(editorState, withAdjustment, "adjust-depth");
  },

  toggleBlockType: function toggleBlockType(editorState, blockType) {
    var selection = editorState.getSelection();
    var startKey = selection.getStartKey();
    var endKey = selection.getEndKey();
    var content = editorState.getCurrentContent();
    var target = selection;

    // Triple-click can lead to a selection that includes offset 0 of the
    // following block. The `SelectionState` for this case is accurate, but
    // we should avoid toggling block type for the trailing block because it
    // is a confusing interaction.
    if (startKey !== endKey && selection.getEndOffset() === 0) {
      var blockBefore = nullthrows_1(content.getBlockBefore(endKey));
      endKey = blockBefore.getKey();
      target = target.merge({
        anchorKey: startKey,
        anchorOffset: selection.getStartOffset(),
        focusKey: endKey,
        focusOffset: blockBefore.getLength(),
        isBackward: false
      });
    }

    var hasAtomicBlock = content
      .getBlockMap()
      .skipWhile(function(_, k) {
        return k !== startKey;
      })
      .reverse()
      .skipWhile(function(_, k) {
        return k !== endKey;
      })
      .some(function(v) {
        return v.getType() === "atomic";
      });

    if (hasAtomicBlock) {
      return editorState;
    }

    var typeToSet =
      content.getBlockForKey(startKey).getType() === blockType
        ? "unstyled"
        : blockType;

    return EditorState_1.push(
      editorState,
      DraftModifier_1.setBlockType(content, target, typeToSet),
      "change-block-type"
    );
  },

  toggleCode: function toggleCode(editorState) {
    var selection = editorState.getSelection();
    var anchorKey = selection.getAnchorKey();
    var focusKey = selection.getFocusKey();

    if (selection.isCollapsed() || anchorKey !== focusKey) {
      return RichTextEditorUtil.toggleBlockType(editorState, "code-block");
    }

    return RichTextEditorUtil.toggleInlineStyle(editorState, "CODE");
  },

  /**
   * Toggle the specified inline style for the selection. If the
   * user's selection is collapsed, apply or remove the style for the
   * internal state. If it is not collapsed, apply the change directly
   * to the document state.
   */
  toggleInlineStyle: function toggleInlineStyle(editorState, inlineStyle) {
    var selection = editorState.getSelection();
    var currentStyle = editorState.getCurrentInlineStyle();

    // If the selection is collapsed, toggle the specified style on or off and
    // set the result as the new inline style override. This will then be
    // used as the inline style for the next character to be inserted.
    if (selection.isCollapsed()) {
      return EditorState_1.setInlineStyleOverride(
        editorState,
        currentStyle.has(inlineStyle)
          ? currentStyle.remove(inlineStyle)
          : currentStyle.add(inlineStyle)
      );
    }

    // If characters are selected, immediately apply or remove the
    // inline style on the document state itself.
    var content = editorState.getCurrentContent();
    var newContent;

    // If the style is already present for the selection range, remove it.
    // Otherwise, apply it.
    if (currentStyle.has(inlineStyle)) {
      newContent = DraftModifier_1.removeInlineStyle(
        content,
        selection,
        inlineStyle
      );
    } else {
      newContent = DraftModifier_1.applyInlineStyle(
        content,
        selection,
        inlineStyle
      );
    }

    return EditorState_1.push(editorState, newContent, "change-inline-style");
  },

  toggleLink: function toggleLink(editorState, targetSelection, entityKey) {
    var withoutLink = DraftModifier_1.applyEntity(
      editorState.getCurrentContent(),
      targetSelection,
      entityKey
    );

    return EditorState_1.push(editorState, withoutLink, "apply-entity");
  },

  /**
   * When a collapsed cursor is at the start of the first styled block, or
   * an empty styled block, changes block to 'unstyled'. Returns null if
   * block or selection does not meet that criteria.
   */
  tryToRemoveBlockStyle: function tryToRemoveBlockStyle(editorState) {
    var selection = editorState.getSelection();
    var offset = selection.getAnchorOffset();
    if (selection.isCollapsed() && offset === 0) {
      var key = selection.getAnchorKey();
      var content = editorState.getCurrentContent();
      var block = content.getBlockForKey(key);

      var firstBlock = content.getFirstBlock();
      if (block.getLength() > 0 && block !== firstBlock) {
        return null;
      }

      var type = block.getType();
      var blockBefore = content.getBlockBefore(key);
      if (
        type === "code-block" &&
        blockBefore &&
        blockBefore.getType() === "code-block" &&
        blockBefore.getLength() !== 0
      ) {
        return null;
      }

      if (type !== "unstyled") {
        return DraftModifier_1.setBlockType(content, selection, "unstyled");
      }
    }
    return null;
  }
};

var RichTextEditorUtil_1 = RichTextEditorUtil;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule splitTextIntoTextBlocks
 * @format
 *
 */

var NEWLINE_REGEX = /\r\n?|\n/g;

function splitTextIntoTextBlocks(text) {
  return text.split(NEWLINE_REGEX);
}

var splitTextIntoTextBlocks_1 = splitTextIntoTextBlocks;

/**
 * Paste content.
 */
function editOnPaste(editor, e) {
  e.preventDefault();
  var data = new DataTransfer_1(e.clipboardData);

  // Get files, unless this is likely to be a string the user wants inline.
  if (!data.isRichText()) {
    var files = data.getFiles();
    var defaultFileText = data.getText();
    if (files.length > 0) {
      // Allow customized paste handling for images, etc. Otherwise, fall
      // through to insert text contents into the editor.
      if (
        editor.props.handlePastedFiles &&
        isEventHandled_1(editor.props.handlePastedFiles(files))
      ) {
        return;
      }

      getTextContentFromFiles_1(files, function(/*string*/ fileText) {
        fileText = fileText || defaultFileText;
        if (!fileText) {
          return;
        }

        var editorState = editor._latestEditorState;
        var blocks = splitTextIntoTextBlocks_1(fileText);
        var character = CharacterMetadata_1.create({
          style: editorState.getCurrentInlineStyle(),
          entity: getEntityKeyForSelection_1(
            editorState.getCurrentContent(),
            editorState.getSelection()
          )
        });
        var currentBlockType = RichTextEditorUtil_1.getCurrentBlockType(
          editorState
        );

        var text = DraftPasteProcessor_1.processText(
          blocks,
          character,
          currentBlockType
        );
        var fragment = BlockMapBuilder_1.createFromArray(text);

        var withInsertedText = DraftModifier_1.replaceWithFragment(
          editorState.getCurrentContent(),
          editorState.getSelection(),
          fragment
        );

        editor.update(
          EditorState_1.push(editorState, withInsertedText, "insert-fragment")
        );
      });

      return;
    }
  }

  var textBlocks = [];
  var text = data.getText();
  var html = data.getHTML();
  var editorState = editor._latestEditorState;

  if (
    editor.props.handlePastedText &&
    isEventHandled_1(editor.props.handlePastedText(text, html, editorState))
  ) {
    return;
  }

  if (text) {
    textBlocks = splitTextIntoTextBlocks_1(text);
  }

  if (!editor.props.stripPastedStyles) {
    // If the text from the paste event is rich content that matches what we
    // already have on the internal clipboard, assume that we should just use
    // the clipboard fragment for the paste. This will allow us to preserve
    // styling and entities, if any are present. Note that newlines are
    // stripped during comparison -- this is because copy/paste within the
    // editor in Firefox and IE will not include empty lines. The resulting
    // paste will preserve the newlines correctly.
    var internalClipboard = editor.getClipboard();
    if (data.isRichText() && internalClipboard) {
      if (
        // If the editorKey is present in the pasted HTML, it should be safe to
        // assume this is an internal paste.
        html.indexOf(editor.getEditorKey()) !== -1 ||
        // The copy may have been made within a single block, in which case the
        // editor key won't be part of the paste. In this case, just check
        // whether the pasted text matches the internal clipboard.
        (textBlocks.length === 1 &&
          internalClipboard.size === 1 &&
          internalClipboard.first().getText() === text)
      ) {
        editor.update(
          insertFragment$1(editor._latestEditorState, internalClipboard)
        );
        return;
      }
    } else if (
      internalClipboard &&
      data.types.includes("com.apple.webarchive") &&
      !data.types.includes("text/html") &&
      areTextBlocksAndClipboardEqual(textBlocks, internalClipboard)
    ) {
      // Safari does not properly store text/html in some cases.
      // Use the internalClipboard if present and equal to what is on
      // the clipboard. See https://bugs.webkit.org/show_bug.cgi?id=19893.
      editor.update(
        insertFragment$1(editor._latestEditorState, internalClipboard)
      );
      return;
    }

    // If there is html paste data, try to parse that.
    if (html) {
      var htmlFragment = DraftPasteProcessor_1.processHTML(
        html,
        editor.props.blockRenderMap
      );
      if (htmlFragment) {
        var contentBlocks = htmlFragment.contentBlocks,
          entityMap = htmlFragment.entityMap;

        if (contentBlocks) {
          var htmlMap = BlockMapBuilder_1.createFromArray(contentBlocks);
          editor.update(
            insertFragment$1(editor._latestEditorState, htmlMap, entityMap)
          );
          return;
        }
      }
    }

    // Otherwise, create a new fragment from our pasted text. Also
    // empty the internal clipboard, since it's no longer valid.
    editor.setClipboard(null);
  }

  if (textBlocks.length) {
    var character = CharacterMetadata_1.create({
      style: editorState.getCurrentInlineStyle(),
      entity: getEntityKeyForSelection_1(
        editorState.getCurrentContent(),
        editorState.getSelection()
      )
    });

    var currentBlockType = RichTextEditorUtil_1.getCurrentBlockType(
      editorState
    );

    var textFragment = DraftPasteProcessor_1.processText(
      textBlocks,
      character,
      currentBlockType
    );

    var textMap = BlockMapBuilder_1.createFromArray(textFragment);
    editor.update(insertFragment$1(editor._latestEditorState, textMap));
  }
}

function insertFragment$1(editorState, fragment, entityMap) {
  var newContent = DraftModifier_1.replaceWithFragment(
    editorState.getCurrentContent(),
    editorState.getSelection(),
    fragment
  );
  // TODO: merge the entity map once we stop using DraftEntity
  // like this:
  // const mergedEntityMap = newContent.getEntityMap().merge(entityMap);

  return EditorState_1.push(
    editorState,
    newContent.set("entityMap", entityMap),
    "insert-fragment"
  );
}

function areTextBlocksAndClipboardEqual(textBlocks, blockMap) {
  return (
    textBlocks.length === blockMap.size &&
    blockMap.valueSeq().every(function(block, ii) {
      return block.getText() === textBlocks[ii];
    })
  );
}

var editOnPaste_1 = editOnPaste;

/**
 * Convert the current selection range to an anchor/focus pair of offset keys
 * and values that can be interpreted by components.
 */
function getDraftEditorSelection(editorState, root) {
  var selection = _commonjsHelpers.commonjsGlobal.getSelection();

  // No active selection.
  if (selection.rangeCount === 0) {
    return {
      selectionState: editorState.getSelection().set("hasFocus", false),
      needsRecovery: false
    };
  }

  return getDraftEditorSelectionWithNodes_1(
    editorState,
    root,
    selection.anchorNode,
    selection.anchorOffset,
    selection.focusNode,
    selection.focusOffset
  );
}

var getDraftEditorSelection_1 = getDraftEditorSelection;

function editOnSelect(editor) {
  if (
    editor._blockSelectEvents ||
    editor._latestEditorState !== editor.props.editorState
  ) {
    return;
  }

  var editorState = editor.props.editorState;
  var editorNode = reactDom__default.findDOMNode(editor.editorContainer);
  !editorNode
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "Missing editorNode")
      : invariant_1(false)
    : void 0;
  !(editorNode.firstChild instanceof HTMLElement)
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "editorNode.firstChild is not an HTMLElement")
      : invariant_1(false)
    : void 0;
  var documentSelection = getDraftEditorSelection_1(
    editorState,
    editorNode.firstChild
  );
  var updatedSelectionState = documentSelection.selectionState;

  if (updatedSelectionState !== editorState.getSelection()) {
    if (documentSelection.needsRecovery) {
      editorState = EditorState_1.forceSelection(
        editorState,
        updatedSelectionState
      );
    } else {
      editorState = EditorState_1.acceptSelection(
        editorState,
        updatedSelectionState
      );
    }
    editor.update(editorState);
  }
}

var editOnSelect_1 = editOnSelect;

var DraftEditorEditHandler = {
  onBeforeInput: editOnBeforeInput_1,
  onBlur: editOnBlur_1,
  onCompositionStart: editOnCompositionStart_1,
  onCopy: editOnCopy_1,
  onCut: editOnCut_1,
  onDragOver: editOnDragOver_1,
  onDragStart: editOnDragStart_1,
  onFocus: editOnFocus_1,
  onInput: editOnInput_1,
  onKeyDown: editOnKeyDown_1,
  onPaste: editOnPaste_1,
  onSelect: editOnSelect_1
};

var DraftEditorEditHandler_1 = DraftEditorEditHandler;

function _classCallCheck$f(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _possibleConstructorReturn$a(self, call) {
  if (!self) {
    throw new ReferenceError(
      "this hasn't been initialised - super() hasn't been called"
    );
  }
  return call && (typeof call === "object" || typeof call === "function")
    ? call
    : self;
}

function _inherits$a(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError(
      "Super expression must either be null or a function, not " +
        typeof superClass
    );
  }
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass)
    Object.setPrototypeOf
      ? Object.setPrototypeOf(subClass, superClass)
      : (subClass.__proto__ = superClass);
}

/**
 * This component is responsible for rendering placeholder text for the
 * `DraftEditor` component.
 *
 * Override placeholder style via CSS.
 */
var DraftEditorPlaceholder = (function(_React$Component) {
  _inherits$a(DraftEditorPlaceholder, _React$Component);

  function DraftEditorPlaceholder() {
    _classCallCheck$f(this, DraftEditorPlaceholder);

    return _possibleConstructorReturn$a(
      this,
      _React$Component.apply(this, arguments)
    );
  }

  DraftEditorPlaceholder.prototype.shouldComponentUpdate = function shouldComponentUpdate(
    nextProps
  ) {
    return (
      this.props.text !== nextProps.text ||
      this.props.editorState.getSelection().getHasFocus() !==
        nextProps.editorState.getSelection().getHasFocus()
    );
  };

  DraftEditorPlaceholder.prototype.render = function render() {
    var hasFocus = this.props.editorState.getSelection().getHasFocus();

    var className = cx_1({
      "public/DraftEditorPlaceholder/root": true,
      "public/DraftEditorPlaceholder/hasFocus": hasFocus
    });

    var contentStyle = {
      whiteSpace: "pre-wrap"
    };

    return React__default.createElement(
      "div",
      { className: className },
      React__default.createElement(
        "div",
        {
          className: cx_1("public/DraftEditorPlaceholder/inner"),
          id: this.props.accessibilityID,
          style: contentStyle
        },
        this.props.text
      )
    );
  };

  return DraftEditorPlaceholder;
})(React__default.Component);

var DraftEditorPlaceholder_react = DraftEditorPlaceholder;

var isOSX$1 = UserAgent_1.isPlatform("Mac OS X");
var isWindows = UserAgent_1.isPlatform("Windows");

// Firefox on OSX had a bug resulting in navigation instead of cursor movement.
// This bug was fixed in Firefox 29. Feature detection is virtually impossible
// so we just check the version number. See #342765.
var shouldFixFirefoxMovement = isOSX$1 && UserAgent_1.isBrowser("Firefox < 29");

var hasCommandModifier = KeyBindingUtil_1.hasCommandModifier,
  isCtrlKeyCommand = KeyBindingUtil_1.isCtrlKeyCommand;

function shouldRemoveWord(e) {
  return (isOSX$1 && e.altKey) || isCtrlKeyCommand(e);
}

/**
 * Get the appropriate undo/redo command for a Z key command.
 */
function getZCommand(e) {
  if (!hasCommandModifier(e)) {
    return null;
  }
  return e.shiftKey ? "redo" : "undo";
}

function getDeleteCommand(e) {
  // Allow default "cut" behavior for Windows on Shift + Delete.
  if (isWindows && e.shiftKey) {
    return null;
  }
  return shouldRemoveWord(e) ? "delete-word" : "delete";
}

function getBackspaceCommand(e) {
  if (hasCommandModifier(e) && isOSX$1) {
    return "backspace-to-start-of-line";
  }
  return shouldRemoveWord(e) ? "backspace-word" : "backspace";
}

/**
 * Retrieve a bound key command for the given event.
 */
function getDefaultKeyBinding(e) {
  switch (e.keyCode) {
    case 66:
      // B
      return hasCommandModifier(e) ? "bold" : null;
    case 68:
      // D
      return isCtrlKeyCommand(e) ? "delete" : null;
    case 72:
      // H
      return isCtrlKeyCommand(e) ? "backspace" : null;
    case 73:
      // I
      return hasCommandModifier(e) ? "italic" : null;
    case 74:
      // J
      return hasCommandModifier(e) ? "code" : null;
    case 75:
      // K
      return !isWindows && isCtrlKeyCommand(e) ? "secondary-cut" : null;
    case 77:
      // M
      return isCtrlKeyCommand(e) ? "split-block" : null;
    case 79:
      // O
      return isCtrlKeyCommand(e) ? "split-block" : null;
    case 84:
      // T
      return isOSX$1 && isCtrlKeyCommand(e) ? "transpose-characters" : null;
    case 85:
      // U
      return hasCommandModifier(e) ? "underline" : null;
    case 87:
      // W
      return isOSX$1 && isCtrlKeyCommand(e) ? "backspace-word" : null;
    case 89:
      // Y
      if (isCtrlKeyCommand(e)) {
        return isWindows ? "redo" : "secondary-paste";
      }
      return null;
    case 90:
      // Z
      return getZCommand(e) || null;
    case Keys.RETURN:
      return "split-block";
    case Keys.DELETE:
      return getDeleteCommand(e);
    case Keys.BACKSPACE:
      return getBackspaceCommand(e);
    // LEFT/RIGHT handlers serve as a workaround for a Firefox bug.
    case Keys.LEFT:
      return shouldFixFirefoxMovement && hasCommandModifier(e)
        ? "move-selection-to-start-of-block"
        : null;
    case Keys.RIGHT:
      return shouldFixFirefoxMovement && hasCommandModifier(e)
        ? "move-selection-to-end-of-block"
        : null;
    default:
      return null;
  }
}

var getDefaultKeyBinding_1 = getDefaultKeyBinding;

var _extends$5 =
  objectAssign ||
  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;
  };

function _classCallCheck$g(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _possibleConstructorReturn$b(self, call) {
  if (!self) {
    throw new ReferenceError(
      "this hasn't been initialised - super() hasn't been called"
    );
  }
  return call && (typeof call === "object" || typeof call === "function")
    ? call
    : self;
}

function _inherits$b(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError(
      "Super expression must either be null or a function, not " +
        typeof superClass
    );
  }
  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass)
    Object.setPrototypeOf
      ? Object.setPrototypeOf(subClass, superClass)
      : (subClass.__proto__ = superClass);
}

var isIE = UserAgent_1.isBrowser("IE");

// IE does not support the `input` event on contentEditable, so we can't
// observe spellcheck behavior.
var allowSpellCheck = !isIE;

// Define a set of handler objects to correspond to each possible `mode`
// of editor behavior.
var handlerMap = {
  edit: DraftEditorEditHandler_1,
  composite: DraftEditorCompositionHandler_1,
  drag: DraftEditorDragHandler_1,
  cut: null,
  render: null
};

/**
 * `DraftEditor` is the root editor component. It composes a `contentEditable`
 * div, and provides a wide variety of useful function props for managing the
 * state of the editor. See `DraftEditorProps` for details.
 */
var DraftEditor = (function(_React$Component) {
  _inherits$b(DraftEditor, _React$Component);

  function DraftEditor(props) {
    _classCallCheck$g(this, DraftEditor);

    var _this = _possibleConstructorReturn$b(
      this,
      _React$Component.call(this, props)
    );

    _this.focus = function(scrollPosition) {
      var editorState = _this.props.editorState;

      var alreadyHasFocus = editorState.getSelection().getHasFocus();
      var editorNode = reactDom__default.findDOMNode(_this.editor);

      if (!editorNode) {
        // once in a while people call 'focus' in a setTimeout, and the node has
        // been deleted, so it can be null in that case.
        return;
      }

      var scrollParent = Style_1.getScrollParent(editorNode);

      var _ref = scrollPosition || getScrollPosition_1(scrollParent),
        x = _ref.x,
        y = _ref.y;

      !(editorNode instanceof HTMLElement)
        ? process.env.NODE_ENV !== "production"
          ? invariant_1(false, "editorNode is not an HTMLElement")
          : invariant_1(false)
        : void 0;
      editorNode.focus();

      // Restore scroll position
      if (scrollParent === window) {
        window.scrollTo(x, y);
      } else {
        Scroll_1.setTop(scrollParent, y);
      }

      // On Chrome and Safari, calling focus on contenteditable focuses the
      // cursor at the first character. This is something you don't expect when
      // you're clicking on an input element but not directly on a character.
      // Put the cursor back where it was before the blur.
      if (!alreadyHasFocus) {
        _this.update(
          EditorState_1.forceSelection(editorState, editorState.getSelection())
        );
      }
    };

    _this.blur = function() {
      var editorNode = reactDom__default.findDOMNode(_this.editor);
      !(editorNode instanceof HTMLElement)
        ? process.env.NODE_ENV !== "production"
          ? invariant_1(false, "editorNode is not an HTMLElement")
          : invariant_1(false)
        : void 0;
      editorNode.blur();
    };

    _this.setMode = function(mode) {
      _this._handler = handlerMap[mode];
    };

    _this.exitCurrentMode = function() {
      _this.setMode("edit");
    };

    _this.restoreEditorDOM = function(scrollPosition) {
      _this.setState({ contentsKey: _this.state.contentsKey + 1 }, function() {
        _this.focus(scrollPosition);
      });
    };

    _this.setClipboard = function(clipboard) {
      _this._clipboard = clipboard;
    };

    _this.getClipboard = function() {
      return _this._clipboard;
    };

    _this.update = function(editorState) {
      _this._latestEditorState = editorState;
      _this.props.onChange(editorState);
    };

    _this.onDragEnter = function() {
      _this._dragCount++;
    };

    _this.onDragLeave = function() {
      _this._dragCount--;
      if (_this._dragCount === 0) {
        _this.exitCurrentMode();
      }
    };

    _this._blockSelectEvents = false;
    _this._clipboard = null;
    _this._handler = null;
    _this._dragCount = 0;
    _this._editorKey = props.editorKey || generateRandomKey_1();
    _this._placeholderAccessibilityID = "placeholder-" + _this._editorKey;
    _this._latestEditorState = props.editorState;
    _this._latestCommittedEditorState = props.editorState;

    _this._onBeforeInput = _this._buildHandler("onBeforeInput");
    _this._onBlur = _this._buildHandler("onBlur");
    _this._onCharacterData = _this._buildHandler("onCharacterData");
    _this._onCompositionEnd = _this._buildHandler("onCompositionEnd");
    _this._onCompositionStart = _this._buildHandler("onCompositionStart");
    _this._onCopy = _this._buildHandler("onCopy");
    _this._onCut = _this._buildHandler("onCut");
    _this._onDragEnd = _this._buildHandler("onDragEnd");
    _this._onDragOver = _this._buildHandler("onDragOver");
    _this._onDragStart = _this._buildHandler("onDragStart");
    _this._onDrop = _this._buildHandler("onDrop");
    _this._onInput = _this._buildHandler("onInput");
    _this._onFocus = _this._buildHandler("onFocus");
    _this._onKeyDown = _this._buildHandler("onKeyDown");
    _this._onKeyPress = _this._buildHandler("onKeyPress");
    _this._onKeyUp = _this._buildHandler("onKeyUp");
    _this._onMouseDown = _this._buildHandler("onMouseDown");
    _this._onMouseUp = _this._buildHandler("onMouseUp");
    _this._onPaste = _this._buildHandler("onPaste");
    _this._onSelect = _this._buildHandler("onSelect");

    _this.getEditorKey = function() {
      return _this._editorKey;
    };

    // See `restoreEditorDOM()`.
    _this.state = { contentsKey: 0 };
    return _this;
  }

  /**
   * Build a method that will pass the event to the specified handler method.
   * This allows us to look up the correct handler function for the current
   * editor mode, if any has been specified.
   */

  /**
   * Define proxies that can route events to the current handler.
   */

  DraftEditor.prototype._buildHandler = function _buildHandler(eventName) {
    var _this2 = this;

    return function(e) {
      if (!_this2.props.readOnly) {
        var method = _this2._handler && _this2._handler[eventName];
        method && method(_this2, e);
      }
    };
  };

  DraftEditor.prototype._showPlaceholder = function _showPlaceholder() {
    return (
      !!this.props.placeholder &&
      !this.props.editorState.isInCompositionMode() &&
      !this.props.editorState.getCurrentContent().hasText()
    );
  };

  DraftEditor.prototype._renderPlaceholder = function _renderPlaceholder() {
    if (this._showPlaceholder()) {
      var placeHolderProps = {
        text: nullthrows_1(this.props.placeholder),
        editorState: this.props.editorState,
        textAlignment: this.props.textAlignment,
        accessibilityID: this._placeholderAccessibilityID
      };

      return React__default.createElement(
        DraftEditorPlaceholder_react,
        placeHolderProps
      );
    }
    return null;
  };

  DraftEditor.prototype.render = function render() {
    var _this3 = this;

    var _props = this.props,
      blockRenderMap = _props.blockRenderMap,
      blockRendererFn = _props.blockRendererFn,
      blockStyleFn = _props.blockStyleFn,
      customStyleFn = _props.customStyleFn,
      customStyleMap = _props.customStyleMap,
      editorState = _props.editorState,
      readOnly = _props.readOnly,
      textAlignment = _props.textAlignment,
      textDirectionality = _props.textDirectionality;

    var rootClass = cx_1({
      "DraftEditor/root": true,
      "DraftEditor/alignLeft": textAlignment === "left",
      "DraftEditor/alignRight": textAlignment === "right",
      "DraftEditor/alignCenter": textAlignment === "center"
    });

    var contentStyle = {
      outline: "none",
      // fix parent-draggable Safari bug. #1326
      userSelect: "text",
      WebkitUserSelect: "text",
      whiteSpace: "pre-wrap",
      wordWrap: "break-word"
    };

    // The aria-expanded and aria-haspopup properties should only be rendered
    // for a combobox.
    var ariaRole = this.props.role || "textbox";
    var ariaExpanded =
      ariaRole === "combobox" ? !!this.props.ariaExpanded : null;

    var editorContentsProps = {
      blockRenderMap: blockRenderMap,
      blockRendererFn: blockRendererFn,
      blockStyleFn: blockStyleFn,
      customStyleMap: _extends$5({}, DefaultDraftInlineStyle, customStyleMap),
      customStyleFn: customStyleFn,
      editorKey: this._editorKey,
      editorState: editorState,
      key: "contents" + this.state.contentsKey,
      textDirectionality: textDirectionality
    };

    return React__default.createElement(
      "div",
      { className: rootClass },
      this._renderPlaceholder(),
      React__default.createElement(
        "div",
        {
          className: cx_1("DraftEditor/editorContainer"),
          ref: function ref(_ref3) {
            return (_this3.editorContainer = _ref3);
          }
        },
        React__default.createElement(
          "div",
          {
            "aria-activedescendant": readOnly
              ? null
              : this.props.ariaActiveDescendantID,
            "aria-autocomplete": readOnly ? null : this.props.ariaAutoComplete,
            "aria-controls": readOnly ? null : this.props.ariaControls,
            "aria-describedby":
              this.props.ariaDescribedBy || this._placeholderAccessibilityID,
            "aria-expanded": readOnly ? null : ariaExpanded,
            "aria-label": this.props.ariaLabel,
            "aria-labelledby": this.props.ariaLabelledBy,
            "aria-multiline": this.props.ariaMultiline,
            autoCapitalize: this.props.autoCapitalize,
            autoComplete: this.props.autoComplete,
            autoCorrect: this.props.autoCorrect,
            className: cx_1({
              // Chrome's built-in translation feature mutates the DOM in ways
              // that Draft doesn't expect (ex: adding <font> tags inside
              // DraftEditorLeaf spans) and causes problems. We add notranslate
              // here which makes its autotranslation skip over this subtree.
              notranslate: !readOnly,
              "public/DraftEditor/content": true
            }),
            contentEditable: !readOnly,
            "data-testid": this.props.webDriverTestID,
            onBeforeInput: this._onBeforeInput,
            onBlur: this._onBlur,
            onCompositionEnd: this._onCompositionEnd,
            onCompositionStart: this._onCompositionStart,
            onCopy: this._onCopy,
            onCut: this._onCut,
            onDragEnd: this._onDragEnd,
            onDragEnter: this.onDragEnter,
            onDragLeave: this.onDragLeave,
            onDragOver: this._onDragOver,
            onDragStart: this._onDragStart,
            onDrop: this._onDrop,
            onFocus: this._onFocus,
            onInput: this._onInput,
            onKeyDown: this._onKeyDown,
            onKeyPress: this._onKeyPress,
            onKeyUp: this._onKeyUp,
            onMouseUp: this._onMouseUp,
            onPaste: this._onPaste,
            onSelect: this._onSelect,
            ref: function ref(_ref2) {
              return (_this3.editor = _ref2);
            },
            role: readOnly ? null : ariaRole,
            spellCheck: allowSpellCheck && this.props.spellCheck,
            style: contentStyle,
            suppressContentEditableWarning: true,
            tabIndex: this.props.tabIndex
          },
          React__default.createElement(
            DraftEditorContents_react,
            editorContentsProps
          )
        )
      )
    );
  };

  DraftEditor.prototype.componentDidMount = function componentDidMount() {
    this.setMode("edit");

    /**
     * IE has a hardcoded "feature" that attempts to convert link text into
     * anchors in contentEditable DOM. This breaks the editor's expectations of
     * the DOM, and control is lost. Disable it to make IE behave.
     * See: http://blogs.msdn.com/b/ieinternals/archive/2010/09/15/
     * ie9-beta-minor-change-list.aspx
     */
    if (isIE) {
      document.execCommand("AutoUrlDetect", false, false);
    }
  };

  /**
   * Prevent selection events from affecting the current editor state. This
   * is mostly intended to defend against IE, which fires off `selectionchange`
   * events regardless of whether the selection is set via the browser or
   * programmatically. We only care about selection events that occur because
   * of browser interaction, not re-renders and forced selections.
   */

  DraftEditor.prototype.componentWillUpdate = function componentWillUpdate(
    nextProps
  ) {
    this._blockSelectEvents = true;
    this._latestEditorState = nextProps.editorState;
  };

  DraftEditor.prototype.componentDidUpdate = function componentDidUpdate() {
    this._blockSelectEvents = false;
    this._latestCommittedEditorState = this.props.editorState;
  };

  /**
   * Used via `this.focus()`.
   *
   * Force focus back onto the editor node.
   *
   * We attempt to preserve scroll position when focusing. You can also pass
   * a specified scroll position (for cases like `cut` behavior where it should
   * be restored to a known position).
   */

  /**
   * Used via `this.setMode(...)`.
   *
   * Set the behavior mode for the editor component. This switches the current
   * handler module to ensure that DOM events are managed appropriately for
   * the active mode.
   */

  /**
   * Used via `this.restoreEditorDOM()`.
   *
   * Force a complete re-render of the DraftEditorContents based on the current
   * EditorState. This is useful when we know we are going to lose control of
   * the DOM state (cut command, IME) and we want to make sure that
   * reconciliation occurs on a version of the DOM that is synchronized with
   * our EditorState.
   */

  /**
   * Used via `this.setClipboard(...)`.
   *
   * Set the clipboard state for a cut/copy event.
   */

  /**
   * Used via `this.getClipboard()`.
   *
   * Retrieve the clipboard state for a cut/copy event.
   */

  /**
   * Used via `this.update(...)`.
   *
   * Propagate a new `EditorState` object to higher-level components. This is
   * the method by which event handlers inform the `DraftEditor` component of
   * state changes. A component that composes a `DraftEditor` **must** provide
   * an `onChange` prop to receive state updates passed along from this
   * function.
   */

  /**
   * Used in conjunction with `onDragLeave()`, by counting the number of times
   * a dragged element enters and leaves the editor (or any of its children),
   * to determine when the dragged element absolutely leaves the editor.
   */

  /**
   * See `onDragEnter()`.
   */

  return DraftEditor;
})(React__default.Component);

DraftEditor.defaultProps = {
  blockRenderMap: DefaultDraftBlockRenderMap_1,
  blockRendererFn: emptyFunction_1.thatReturnsNull,
  blockStyleFn: emptyFunction_1.thatReturns(""),
  keyBindingFn: getDefaultKeyBinding_1,
  readOnly: false,
  spellCheck: false,
  stripPastedStyles: false
};

var DraftEditor_react = DraftEditor;

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule DraftStringKey
 * @format
 *
 */

var DraftStringKey = {
  stringify: function stringify(key) {
    return "_" + String(key);
  },

  unstringify: function unstringify(key) {
    return key.slice(1);
  }
};

var DraftStringKey_1 = DraftStringKey;

var strlen$1 = UnicodeUtils_1.strlen;

/**
 * Convert to UTF-8 character counts for storage.
 */

function encodeEntityRanges(block, storageMap) {
  var encoded = [];
  block.findEntityRanges(
    function(character) {
      return !!character.getEntity();
    },
    function(/*number*/ start, /*number*/ end) {
      var text = block.getText();
      var key = block.getEntityAt(start);
      encoded.push({
        offset: strlen$1(text.slice(0, start)),
        length: strlen$1(text.slice(start, end)),
        // Encode the key as a number for range storage.
        key: Number(storageMap[DraftStringKey_1.stringify(key)])
      });
    }
  );
  return encoded;
}

var encodeEntityRanges_1 = encodeEntityRanges;

var areEqual$1 = function areEqual(a, b) {
  return a === b;
};
var isTruthy = function isTruthy(a) {
  return !!a;
};
var EMPTY_ARRAY = [];

/**
 * Helper function for getting encoded styles for each inline style. Convert
 * to UTF-8 character counts for storage.
 */
function getEncodedInlinesForType(block, styleList, styleToEncode) {
  var ranges = [];

  // Obtain an array with ranges for only the specified style.
  var filteredInlines = styleList
    .map(function(style) {
      return style.has(styleToEncode);
    })
    .toList();

  findRangesImmutable_1(
    filteredInlines,
    areEqual$1,
    // We only want to keep ranges with nonzero style values.
    isTruthy,
    function(start, end) {
      var text = block.getText();
      ranges.push({
        offset: UnicodeUtils_1.strlen(text.slice(0, start)),
        length: UnicodeUtils_1.strlen(text.slice(start, end)),
        style: styleToEncode
      });
    }
  );

  return ranges;
}

/*
 * Retrieve the encoded arrays of inline styles, with each individual style
 * treated separately.
 */
function encodeInlineStyleRanges(block) {
  var styleList = block
    .getCharacterList()
    .map(function(c) {
      return c.getStyle();
    })
    .toList();
  var ranges = styleList
    .flatten()
    .toSet()
    .map(function(style) {
      return getEncodedInlinesForType(block, styleList, style);
    });

  return Array.prototype.concat.apply(EMPTY_ARRAY, ranges.toJS());
}

var encodeInlineStyleRanges_1 = encodeInlineStyleRanges;

var _extends$6 =
  objectAssign ||
  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;
  };

var createRawBlock = function createRawBlock(block, entityStorageMap) {
  return {
    key: block.getKey(),
    text: block.getText(),
    type: block.getType(),
    depth: block.getDepth(),
    inlineStyleRanges: encodeInlineStyleRanges_1(block),
    entityRanges: encodeEntityRanges_1(block, entityStorageMap),
    data: block.getData().toObject()
  };
};

var insertRawBlock = function insertRawBlock(
  block,
  entityMap,
  rawBlocks,
  blockCacheRef
) {
  if (block instanceof ContentBlock_1) {
    rawBlocks.push(createRawBlock(block, entityMap));
    return;
  }

  !(block instanceof ContentBlockNode_1)
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "block is not a BlockNode")
      : invariant_1(false)
    : void 0;

  var parentKey = block.getParentKey();
  var rawBlock = (blockCacheRef[block.getKey()] = _extends$6(
    {},
    createRawBlock(block, entityMap),
    {
      children: []
    }
  ));

  if (parentKey) {
    blockCacheRef[parentKey].children.push(rawBlock);
    return;
  }

  rawBlocks.push(rawBlock);
};

var encodeRawBlocks = function encodeRawBlocks(contentState, rawState) {
  var entityMap = rawState.entityMap;

  var rawBlocks = [];

  var blockCacheRef = {};
  var entityCacheRef = {};
  var entityStorageKey = 0;

  contentState.getBlockMap().forEach(function(block) {
    block.findEntityRanges(
      function(character) {
        return character.getEntity() !== null;
      },
      function(start) {
        var entityKey = block.getEntityAt(start);
        // Stringify to maintain order of otherwise numeric keys.
        var stringifiedEntityKey = DraftStringKey_1.stringify(entityKey);
        // This makes this function resilient to two entities
        // erroneously having the same key
        if (entityCacheRef[stringifiedEntityKey]) {
          return;
        }
        entityCacheRef[stringifiedEntityKey] = entityKey;
        // we need the `any` casting here since this is a temporary state
        // where we will later on flip the entity map and populate it with
        // real entity, at this stage we just need to map back the entity
        // key used by the BlockNode
        entityMap[stringifiedEntityKey] = "" + entityStorageKey;
        entityStorageKey++;
      }
    );

    insertRawBlock(block, entityMap, rawBlocks, blockCacheRef);
  });

  return {
    blocks: rawBlocks,
    entityMap: entityMap
  };
};

// Flip storage map so that our storage keys map to global
// DraftEntity keys.
var encodeRawEntityMap = function encodeRawEntityMap(contentState, rawState) {
  var blocks = rawState.blocks,
    entityMap = rawState.entityMap;

  var rawEntityMap = {};

  Object.keys(entityMap).forEach(function(key, index) {
    var entity = contentState.getEntity(DraftStringKey_1.unstringify(key));
    rawEntityMap[index] = {
      type: entity.getType(),
      mutability: entity.getMutability(),
      data: entity.getData()
    };
  });

  return {
    blocks: blocks,
    entityMap: rawEntityMap
  };
};

var convertFromDraftStateToRaw = function convertFromDraftStateToRaw(
  contentState
) {
  var rawDraftContentState = {
    entityMap: {},
    blocks: []
  };

  // add blocks
  rawDraftContentState = encodeRawBlocks(contentState, rawDraftContentState);

  // add entities
  rawDraftContentState = encodeRawEntityMap(contentState, rawDraftContentState);

  return rawDraftContentState;
};

var convertFromDraftStateToRaw_1 = convertFromDraftStateToRaw;

var _extends$7 =
  objectAssign ||
  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;
  };

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule DraftTreeAdapter
 * @format
 *
 *
 * This is unstable and not part of the public API and should not be used by
 * production systems. This file may be update/removed without notice.
 */

var traverseInDepthOrder = function traverseInDepthOrder(blocks, fn) {
  var stack = [].concat(blocks).reverse();
  while (stack.length) {
    var _block = stack.pop();

    fn(_block);

    var children = _block.children;

    !Array.isArray(children)
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(false, "Invalid tree raw block")
        : invariant_1(false)
      : void 0;

    stack = stack.concat([].concat(children.reverse()));
  }
};

var isListBlock = function isListBlock(block) {
  if (!(block && block.type)) {
    return false;
  }
  var type = block.type;

  return type === "unordered-list-item" || type === "ordered-list-item";
};

var addDepthToChildren = function addDepthToChildren(block) {
  if (Array.isArray(block.children)) {
    block.children = block.children.map(function(child) {
      return child.type === block.type
        ? _extends$7({}, child, { depth: (block.depth || 0) + 1 })
        : child;
    });
  }
};

/**
 * This adapter is intended to be be used as an adapter to draft tree data
 *
 * draft state <=====> draft tree state
 */
var DraftTreeAdapter = {
  /**
   * Converts from a tree raw state back to  draft raw state
   */
  fromRawTreeStateToRawState: function fromRawTreeStateToRawState(
    draftTreeState
  ) {
    var blocks = draftTreeState.blocks;

    var transformedBlocks = [];

    !Array.isArray(blocks)
      ? process.env.NODE_ENV !== "production"
        ? invariant_1(false, "Invalid raw state")
        : invariant_1(false)
      : void 0;

    if (!Array.isArray(blocks) || !blocks.length) {
      return draftTreeState;
    }

    traverseInDepthOrder(blocks, function(block) {
      var newBlock = _extends$7({}, block);

      if (isListBlock(block)) {
        newBlock.depth = newBlock.depth || 0;
        addDepthToChildren(block);
      }

      delete newBlock.children;

      transformedBlocks.push(newBlock);
    });

    draftTreeState.blocks = transformedBlocks;

    return _extends$7({}, draftTreeState, {
      blocks: transformedBlocks
    });
  },

  /**
   * Converts from draft raw state to tree draft state
   */
  fromRawStateToRawTreeState: function fromRawStateToRawTreeState(draftState) {
    var lastListDepthCacheRef = {};
    var transformedBlocks = [];

    draftState.blocks.forEach(function(block) {
      var isList = isListBlock(block);
      var depth = block.depth || 0;
      var treeBlock = _extends$7({}, block, {
        children: []
      });

      if (!isList) {
        // reset the cache path
        lastListDepthCacheRef = {};
        transformedBlocks.push(treeBlock);
        return;
      }

      // update our depth cache reference path
      lastListDepthCacheRef[depth] = treeBlock;

      // if we are greater than zero we must have seen a parent already
      if (depth > 0) {
        var parent = lastListDepthCacheRef[depth - 1];

        !parent
          ? process.env.NODE_ENV !== "production"
            ? invariant_1(false, "Invalid depth for RawDraftContentBlock")
            : invariant_1(false)
          : void 0;

        // push nested list blocks
        parent.children.push(treeBlock);
        return;
      }

      // push root list blocks
      transformedBlocks.push(treeBlock);
    });

    return _extends$7({}, draftState, {
      blocks: transformedBlocks
    });
  }
};

var DraftTreeAdapter_1 = DraftTreeAdapter;

var List$c = immutable.List;

function createCharacterList(inlineStyles, entities) {
  var characterArray = inlineStyles.map(function(style, ii) {
    var entity = entities[ii];
    return CharacterMetadata_1.create({ style: style, entity: entity });
  });
  return List$c(characterArray);
}

var createCharacterList_1 = createCharacterList;

var substr$1 = UnicodeUtils_1.substr;

/**
 * Convert to native JavaScript string lengths to determine ranges.
 */

function decodeEntityRanges(text, ranges) {
  var entities = Array(text.length).fill(null);
  if (ranges) {
    ranges.forEach(function(range) {
      // Using Unicode-enabled substrings converted to JavaScript lengths,
      // fill the output array with entity keys.
      var start = substr$1(text, 0, range.offset).length;
      var end = start + substr$1(text, range.offset, range.length).length;
      for (var ii = start; ii < end; ii++) {
        entities[ii] = range.key;
      }
    });
  }
  return entities;
}

var decodeEntityRanges_1 = decodeEntityRanges;

var OrderedSet$6 = immutable.OrderedSet;

var substr$2 = UnicodeUtils_1.substr;

var EMPTY_SET$3 = OrderedSet$6();

/**
 * Convert to native JavaScript string lengths to determine ranges.
 */
function decodeInlineStyleRanges(text, ranges) {
  var styles = Array(text.length).fill(EMPTY_SET$3);
  if (ranges) {
    ranges.forEach(function(/*object*/ range) {
      var cursor = substr$2(text, 0, range.offset).length;
      var end = cursor + substr$2(text, range.offset, range.length).length;
      while (cursor < end) {
        styles[cursor] = styles[cursor].add(range.style);
        cursor++;
      }
    });
  }
  return styles;
}

var decodeInlineStyleRanges_1 = decodeInlineStyleRanges;

var _extends$8 =
  objectAssign ||
  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;
  };

var List$d = immutable.List,
  Map$9 = immutable.Map,
  OrderedMap$4 = immutable.OrderedMap;

var decodeBlockNodeConfig = function decodeBlockNodeConfig(block, entityMap) {
  var key = block.key,
    type = block.type,
    data = block.data,
    text = block.text,
    depth = block.depth;

  var blockNodeConfig = {
    text: text,
    depth: depth || 0,
    type: type || "unstyled",
    key: key || generateRandomKey_1(),
    data: Map$9(data),
    characterList: decodeCharacterList(block, entityMap)
  };

  return blockNodeConfig;
};

var decodeCharacterList = function decodeCharacterList(block, entityMap) {
  var text = block.text,
    rawEntityRanges = block.entityRanges,
    rawInlineStyleRanges = block.inlineStyleRanges;

  var entityRanges = rawEntityRanges || [];
  var inlineStyleRanges = rawInlineStyleRanges || [];

  // Translate entity range keys to the DraftEntity map.
  return createCharacterList_1(
    decodeInlineStyleRanges_1(text, inlineStyleRanges),
    decodeEntityRanges_1(
      text,
      entityRanges
        .filter(function(range) {
          return entityMap.hasOwnProperty(range.key);
        })
        .map(function(range) {
          return _extends$8({}, range, { key: entityMap[range.key] });
        })
    )
  );
};

var decodeContentBlocks = function decodeContentBlocks(blocks, entityMap) {
  return OrderedMap$4(
    blocks.map(function(block) {
      var contentBlock = new ContentBlock_1(
        decodeBlockNodeConfig(block, entityMap)
      );
      return [contentBlock.getKey(), contentBlock];
    })
  );
};

var decodeRawBlocks = function decodeRawBlocks(rawState, entityMap) {
  var isTreeRawBlock = Array.isArray(rawState.blocks[0].children);
  var rawBlocks = rawState.blocks;

  {
    return decodeContentBlocks(
      isTreeRawBlock
        ? DraftTreeAdapter_1.fromRawTreeStateToRawState(rawState).blocks
        : rawBlocks,
      entityMap
    );
  }
};

var decodeRawEntityMap = function decodeRawEntityMap(rawState) {
  var rawEntityMap = rawState.entityMap;

  var entityMap = {};

  // TODO: Update this once we completely remove DraftEntity
  Object.keys(rawEntityMap).forEach(function(rawEntityKey) {
    var _rawEntityMap$rawEnti = rawEntityMap[rawEntityKey],
      type = _rawEntityMap$rawEnti.type,
      mutability = _rawEntityMap$rawEnti.mutability,
      data = _rawEntityMap$rawEnti.data;

    // get the key reference to created entity

    entityMap[rawEntityKey] = DraftEntity_1.__create(
      type,
      mutability,
      data || {}
    );
  });

  return entityMap;
};

var convertFromRawToDraftState = function convertFromRawToDraftState(rawState) {
  !Array.isArray(rawState.blocks)
    ? process.env.NODE_ENV !== "production"
      ? invariant_1(false, "invalid RawDraftContentState")
      : invariant_1(false)
    : void 0;

  // decode entities
  var entityMap = decodeRawEntityMap(rawState);

  // decode blockMap
  var blockMap = decodeRawBlocks(rawState, entityMap);

  // create initial selection
  var selectionState = blockMap.isEmpty()
    ? new SelectionState_1()
    : SelectionState_1.createEmpty(blockMap.first().getKey());

  return new ContentState_1({
    blockMap: blockMap,
    entityMap: entityMap,
    selectionBefore: selectionState,
    selectionAfter: selectionState
  });
};

var convertFromRawToDraftState_1 = convertFromRawToDraftState;

/**
 * Like range.getBoundingClientRect() but normalizes for browser bugs.
 */
function getRangeBoundingClientRect(range) {
  // "Return a DOMRect object describing the smallest rectangle that includes
  // the first rectangle in list and all of the remaining rectangles of which
  // the height or width is not zero."
  // http://www.w3.org/TR/cssom-view/#dom-range-getboundingclientrect
  var rects = getRangeClientRects_1(range);
  var top = 0;
  var right = 0;
  var bottom = 0;
  var left = 0;

  if (rects.length) {
    // If the first rectangle has 0 width, we use the second, this is needed
    // because Chrome renders a 0 width rectangle when the selection contains
    // a line break.
    if (rects.length > 1 && rects[0].width === 0) {
      var _rects$ = rects[1];
      top = _rects$.top;
      right = _rects$.right;
      bottom = _rects$.bottom;
      left = _rects$.left;
    } else {
      var _rects$2 = rects[0];
      top = _rects$2.top;
      right = _rects$2.right;
      bottom = _rects$2.bottom;
      left = _rects$2.left;
    }

    for (var ii = 1; ii < rects.length; ii++) {
      var rect = rects[ii];
      if (rect.height !== 0 && rect.width !== 0) {
        top = Math.min(top, rect.top);
        right = Math.max(right, rect.right);
        bottom = Math.max(bottom, rect.bottom);
        left = Math.min(left, rect.left);
      }
    }
  }

  return {
    top: top,
    right: right,
    bottom: bottom,
    left: left,
    width: right - left,
    height: bottom - top
  };
}

var getRangeBoundingClientRect_1 = getRangeBoundingClientRect;

/**
 * Return the bounding ClientRect for the visible DOM selection, if any.
 * In cases where there are no selected ranges or the bounding rect is
 * temporarily invalid, return null.
 */
function getVisibleSelectionRect(global) {
  var selection = global.getSelection();
  if (!selection.rangeCount) {
    return null;
  }

  var range = selection.getRangeAt(0);
  var boundingRect = getRangeBoundingClientRect_1(range);
  var top = boundingRect.top,
    right = boundingRect.right,
    bottom = boundingRect.bottom,
    left = boundingRect.left;

  // When a re-render leads to a node being removed, the DOM selection will
  // temporarily be placed on an ancestor node, which leads to an invalid
  // bounding rect. Discard this state.

  if (top === 0 && right === 0 && bottom === 0 && left === 0) {
    return null;
  }

  return boundingRect;
}

var getVisibleSelectionRect_1 = getVisibleSelectionRect;

var DraftPublic = {
  Editor: DraftEditor_react,
  EditorBlock: DraftEditorBlock_react,
  EditorState: EditorState_1,

  CompositeDecorator: CompositeDraftDecorator_1,
  Entity: DraftEntity_1,
  EntityInstance: DraftEntityInstance_1,

  BlockMapBuilder: BlockMapBuilder_1,
  CharacterMetadata: CharacterMetadata_1,
  ContentBlock: ContentBlock_1,
  ContentState: ContentState_1,
  SelectionState: SelectionState_1,

  AtomicBlockUtils: AtomicBlockUtils_1,
  KeyBindingUtil: KeyBindingUtil_1,
  Modifier: DraftModifier_1,
  RichUtils: RichTextEditorUtil_1,

  DefaultDraftBlockRenderMap: DefaultDraftBlockRenderMap_1,
  DefaultDraftInlineStyle: DefaultDraftInlineStyle,

  convertFromHTML: convertFromHTMLToContentBlocks,
  convertFromRaw: convertFromRawToDraftState_1,
  convertToRaw: convertFromDraftStateToRaw_1,
  genKey: generateRandomKey_1,
  getDefaultKeyBinding: getDefaultKeyBinding_1,
  getVisibleSelectionRect: getVisibleSelectionRect_1
};

var Draft = DraftPublic;

var immutable$1 = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  /**
   *  Copyright (c) 2014-2015, Facebook, Inc.
   *  All rights reserved.
   *
   *  This source code is licensed under the BSD-style license found in the
   *  LICENSE file in the root directory of this source tree. An additional grant
   *  of patent rights can be found in the PATENTS file in the same directory.
   */

  (function(global, factory) {
    module.exports = factory();
  })(_commonjsHelpers.commonjsGlobal, function() {
    var SLICE$0 = Array.prototype.slice;

    function createClass(ctor, superClass) {
      if (superClass) {
        ctor.prototype = Object.create(superClass.prototype);
      }
      ctor.prototype.constructor = ctor;
    }

    function Iterable(value) {
      return isIterable(value) ? value : Seq(value);
    }

    createClass(KeyedIterable, Iterable);
    function KeyedIterable(value) {
      return isKeyed(value) ? value : KeyedSeq(value);
    }

    createClass(IndexedIterable, Iterable);
    function IndexedIterable(value) {
      return isIndexed(value) ? value : IndexedSeq(value);
    }

    createClass(SetIterable, Iterable);
    function SetIterable(value) {
      return isIterable(value) && !isAssociative(value) ? value : SetSeq(value);
    }

    function isIterable(maybeIterable) {
      return !!(maybeIterable && maybeIterable[IS_ITERABLE_SENTINEL]);
    }

    function isKeyed(maybeKeyed) {
      return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL]);
    }

    function isIndexed(maybeIndexed) {
      return !!(maybeIndexed && maybeIndexed[IS_INDEXED_SENTINEL]);
    }

    function isAssociative(maybeAssociative) {
      return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);
    }

    function isOrdered(maybeOrdered) {
      return !!(maybeOrdered && maybeOrdered[IS_ORDERED_SENTINEL]);
    }

    Iterable.isIterable = isIterable;
    Iterable.isKeyed = isKeyed;
    Iterable.isIndexed = isIndexed;
    Iterable.isAssociative = isAssociative;
    Iterable.isOrdered = isOrdered;

    Iterable.Keyed = KeyedIterable;
    Iterable.Indexed = IndexedIterable;
    Iterable.Set = SetIterable;

    var IS_ITERABLE_SENTINEL = "@@__IMMUTABLE_ITERABLE__@@";
    var IS_KEYED_SENTINEL = "@@__IMMUTABLE_KEYED__@@";
    var IS_INDEXED_SENTINEL = "@@__IMMUTABLE_INDEXED__@@";
    var IS_ORDERED_SENTINEL = "@@__IMMUTABLE_ORDERED__@@";

    // Used for setting prototype methods that IE8 chokes on.
    var DELETE = "delete";

    // Constants describing the size of trie nodes.
    var SHIFT = 5; // Resulted in best performance after ______?
    var SIZE = 1 << SHIFT;
    var MASK = SIZE - 1;

    // A consistent shared value representing "not set" which equals nothing other
    // than itself, and nothing that could be provided externally.
    var NOT_SET = {};

    // Boolean references, Rough equivalent of `bool &`.
    var CHANGE_LENGTH = { value: false };
    var DID_ALTER = { value: false };

    function MakeRef(ref) {
      ref.value = false;
      return ref;
    }

    function SetRef(ref) {
      ref && (ref.value = true);
    }

    // A function which returns a value representing an "owner" for transient writes
    // to tries. The return value will only ever equal itself, and will not equal
    // the return of any subsequent call of this function.
    function OwnerID() {}

    // http://jsperf.com/copy-array-inline
    function arrCopy(arr, offset) {
      offset = offset || 0;
      var len = Math.max(0, arr.length - offset);
      var newArr = new Array(len);
      for (var ii = 0; ii < len; ii++) {
        newArr[ii] = arr[ii + offset];
      }
      return newArr;
    }

    function ensureSize(iter) {
      if (iter.size === undefined) {
        iter.size = iter.__iterate(returnTrue);
      }
      return iter.size;
    }

    function wrapIndex(iter, index) {
      // This implements "is array index" which the ECMAString spec defines as:
      //
      //     A String property name P is an array index if and only if
      //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal
      //     to 2^32−1.
      //
      // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects
      if (typeof index !== "number") {
        var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32
        if ("" + uint32Index !== index || uint32Index === 4294967295) {
          return NaN;
        }
        index = uint32Index;
      }
      return index < 0 ? ensureSize(iter) + index : index;
    }

    function returnTrue() {
      return true;
    }

    function wholeSlice(begin, end, size) {
      return (
        (begin === 0 || (size !== undefined && begin <= -size)) &&
        (end === undefined || (size !== undefined && end >= size))
      );
    }

    function resolveBegin(begin, size) {
      return resolveIndex(begin, size, 0);
    }

    function resolveEnd(end, size) {
      return resolveIndex(end, size, size);
    }

    function resolveIndex(index, size, defaultIndex) {
      return index === undefined
        ? defaultIndex
        : index < 0
        ? Math.max(0, size + index)
        : size === undefined
        ? index
        : Math.min(size, index);
    }

    /* global Symbol */

    var ITERATE_KEYS = 0;
    var ITERATE_VALUES = 1;
    var ITERATE_ENTRIES = 2;

    var REAL_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
    var FAUX_ITERATOR_SYMBOL = "@@iterator";

    var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;

    function Iterator(next) {
      this.next = next;
    }

    Iterator.prototype.toString = function() {
      return "[Iterator]";
    };

    Iterator.KEYS = ITERATE_KEYS;
    Iterator.VALUES = ITERATE_VALUES;
    Iterator.ENTRIES = ITERATE_ENTRIES;

    Iterator.prototype.inspect = Iterator.prototype.toSource = function() {
      return this.toString();
    };
    Iterator.prototype[ITERATOR_SYMBOL] = function() {
      return this;
    };

    function iteratorValue(type, k, v, iteratorResult) {
      var value = type === 0 ? k : type === 1 ? v : [k, v];
      iteratorResult
        ? (iteratorResult.value = value)
        : (iteratorResult = {
            value: value,
            done: false
          });
      return iteratorResult;
    }

    function iteratorDone() {
      return { value: undefined, done: true };
    }

    function hasIterator(maybeIterable) {
      return !!getIteratorFn(maybeIterable);
    }

    function isIterator(maybeIterator) {
      return maybeIterator && typeof maybeIterator.next === "function";
    }

    function getIterator(iterable) {
      var iteratorFn = getIteratorFn(iterable);
      return iteratorFn && iteratorFn.call(iterable);
    }

    function getIteratorFn(iterable) {
      var iteratorFn =
        iterable &&
        ((REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||
          iterable[FAUX_ITERATOR_SYMBOL]);
      if (typeof iteratorFn === "function") {
        return iteratorFn;
      }
    }

    function isArrayLike(value) {
      return value && typeof value.length === "number";
    }

    createClass(Seq, Iterable);
    function Seq(value) {
      return value === null || value === undefined
        ? emptySequence()
        : isIterable(value)
        ? value.toSeq()
        : seqFromValue(value);
    }

    Seq.of = function(/*...values*/) {
      return Seq(arguments);
    };

    Seq.prototype.toSeq = function() {
      return this;
    };

    Seq.prototype.toString = function() {
      return this.__toString("Seq {", "}");
    };

    Seq.prototype.cacheResult = function() {
      if (!this._cache && this.__iterateUncached) {
        this._cache = this.entrySeq().toArray();
        this.size = this._cache.length;
      }
      return this;
    };

    // abstract __iterateUncached(fn, reverse)

    Seq.prototype.__iterate = function(fn, reverse) {
      return seqIterate(this, fn, reverse, true);
    };

    // abstract __iteratorUncached(type, reverse)

    Seq.prototype.__iterator = function(type, reverse) {
      return seqIterator(this, type, reverse, true);
    };

    createClass(KeyedSeq, Seq);
    function KeyedSeq(value) {
      return value === null || value === undefined
        ? emptySequence().toKeyedSeq()
        : isIterable(value)
        ? isKeyed(value)
          ? value.toSeq()
          : value.fromEntrySeq()
        : keyedSeqFromValue(value);
    }

    KeyedSeq.prototype.toKeyedSeq = function() {
      return this;
    };

    createClass(IndexedSeq, Seq);
    function IndexedSeq(value) {
      return value === null || value === undefined
        ? emptySequence()
        : !isIterable(value)
        ? indexedSeqFromValue(value)
        : isKeyed(value)
        ? value.entrySeq()
        : value.toIndexedSeq();
    }

    IndexedSeq.of = function(/*...values*/) {
      return IndexedSeq(arguments);
    };

    IndexedSeq.prototype.toIndexedSeq = function() {
      return this;
    };

    IndexedSeq.prototype.toString = function() {
      return this.__toString("Seq [", "]");
    };

    IndexedSeq.prototype.__iterate = function(fn, reverse) {
      return seqIterate(this, fn, reverse, false);
    };

    IndexedSeq.prototype.__iterator = function(type, reverse) {
      return seqIterator(this, type, reverse, false);
    };

    createClass(SetSeq, Seq);
    function SetSeq(value) {
      return (value === null || value === undefined
        ? emptySequence()
        : !isIterable(value)
        ? indexedSeqFromValue(value)
        : isKeyed(value)
        ? value.entrySeq()
        : value
      ).toSetSeq();
    }

    SetSeq.of = function(/*...values*/) {
      return SetSeq(arguments);
    };

    SetSeq.prototype.toSetSeq = function() {
      return this;
    };

    Seq.isSeq = isSeq;
    Seq.Keyed = KeyedSeq;
    Seq.Set = SetSeq;
    Seq.Indexed = IndexedSeq;

    var IS_SEQ_SENTINEL = "@@__IMMUTABLE_SEQ__@@";

    Seq.prototype[IS_SEQ_SENTINEL] = true;

    createClass(ArraySeq, IndexedSeq);
    function ArraySeq(array) {
      this._array = array;
      this.size = array.length;
    }

    ArraySeq.prototype.get = function(index, notSetValue) {
      return this.has(index)
        ? this._array[wrapIndex(this, index)]
        : notSetValue;
    };

    ArraySeq.prototype.__iterate = function(fn, reverse) {
      var array = this._array;
      var maxIndex = array.length - 1;
      for (var ii = 0; ii <= maxIndex; ii++) {
        if (fn(array[reverse ? maxIndex - ii : ii], ii, this) === false) {
          return ii + 1;
        }
      }
      return ii;
    };

    ArraySeq.prototype.__iterator = function(type, reverse) {
      var array = this._array;
      var maxIndex = array.length - 1;
      var ii = 0;
      return new Iterator(function() {
        return ii > maxIndex
          ? iteratorDone()
          : iteratorValue(type, ii, array[reverse ? maxIndex - ii++ : ii++]);
      });
    };

    createClass(ObjectSeq, KeyedSeq);
    function ObjectSeq(object) {
      var keys = Object.keys(object);
      this._object = object;
      this._keys = keys;
      this.size = keys.length;
    }

    ObjectSeq.prototype.get = function(key, notSetValue) {
      if (notSetValue !== undefined && !this.has(key)) {
        return notSetValue;
      }
      return this._object[key];
    };

    ObjectSeq.prototype.has = function(key) {
      return this._object.hasOwnProperty(key);
    };

    ObjectSeq.prototype.__iterate = function(fn, reverse) {
      var object = this._object;
      var keys = this._keys;
      var maxIndex = keys.length - 1;
      for (var ii = 0; ii <= maxIndex; ii++) {
        var key = keys[reverse ? maxIndex - ii : ii];
        if (fn(object[key], key, this) === false) {
          return ii + 1;
        }
      }
      return ii;
    };

    ObjectSeq.prototype.__iterator = function(type, reverse) {
      var object = this._object;
      var keys = this._keys;
      var maxIndex = keys.length - 1;
      var ii = 0;
      return new Iterator(function() {
        var key = keys[reverse ? maxIndex - ii : ii];
        return ii++ > maxIndex
          ? iteratorDone()
          : iteratorValue(type, key, object[key]);
      });
    };

    ObjectSeq.prototype[IS_ORDERED_SENTINEL] = true;

    createClass(IterableSeq, IndexedSeq);
    function IterableSeq(iterable) {
      this._iterable = iterable;
      this.size = iterable.length || iterable.size;
    }

    IterableSeq.prototype.__iterateUncached = function(fn, reverse) {
      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);
      }
      var iterable = this._iterable;
      var iterator = getIterator(iterable);
      var iterations = 0;
      if (isIterator(iterator)) {
        var step;
        while (!(step = iterator.next()).done) {
          if (fn(step.value, iterations++, this) === false) {
            break;
          }
        }
      }
      return iterations;
    };

    IterableSeq.prototype.__iteratorUncached = function(type, reverse) {
      if (reverse) {
        return this.cacheResult().__iterator(type, reverse);
      }
      var iterable = this._iterable;
      var iterator = getIterator(iterable);
      if (!isIterator(iterator)) {
        return new Iterator(iteratorDone);
      }
      var iterations = 0;
      return new Iterator(function() {
        var step = iterator.next();
        return step.done ? step : iteratorValue(type, iterations++, step.value);
      });
    };

    createClass(IteratorSeq, IndexedSeq);
    function IteratorSeq(iterator) {
      this._iterator = iterator;
      this._iteratorCache = [];
    }

    IteratorSeq.prototype.__iterateUncached = function(fn, reverse) {
      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);
      }
      var iterator = this._iterator;
      var cache = this._iteratorCache;
      var iterations = 0;
      while (iterations < cache.length) {
        if (fn(cache[iterations], iterations++, this) === false) {
          return iterations;
        }
      }
      var step;
      while (!(step = iterator.next()).done) {
        var val = step.value;
        cache[iterations] = val;
        if (fn(val, iterations++, this) === false) {
          break;
        }
      }
      return iterations;
    };

    IteratorSeq.prototype.__iteratorUncached = function(type, reverse) {
      if (reverse) {
        return this.cacheResult().__iterator(type, reverse);
      }
      var iterator = this._iterator;
      var cache = this._iteratorCache;
      var iterations = 0;
      return new Iterator(function() {
        if (iterations >= cache.length) {
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          cache[iterations] = step.value;
        }
        return iteratorValue(type, iterations, cache[iterations++]);
      });
    };

    // # pragma Helper functions

    function isSeq(maybeSeq) {
      return !!(maybeSeq && maybeSeq[IS_SEQ_SENTINEL]);
    }

    var EMPTY_SEQ;

    function emptySequence() {
      return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));
    }

    function keyedSeqFromValue(value) {
      var seq = Array.isArray(value)
        ? new ArraySeq(value).fromEntrySeq()
        : isIterator(value)
        ? new IteratorSeq(value).fromEntrySeq()
        : hasIterator(value)
        ? new IterableSeq(value).fromEntrySeq()
        : typeof value === "object"
        ? new ObjectSeq(value)
        : undefined;
      if (!seq) {
        throw new TypeError(
          "Expected Array or iterable object of [k, v] entries, " +
            "or keyed object: " +
            value
        );
      }
      return seq;
    }

    function indexedSeqFromValue(value) {
      var seq = maybeIndexedSeqFromValue(value);
      if (!seq) {
        throw new TypeError(
          "Expected Array or iterable object of values: " + value
        );
      }
      return seq;
    }

    function seqFromValue(value) {
      var seq =
        maybeIndexedSeqFromValue(value) ||
        (typeof value === "object" && new ObjectSeq(value));
      if (!seq) {
        throw new TypeError(
          "Expected Array or iterable object of values, or keyed object: " +
            value
        );
      }
      return seq;
    }

    function maybeIndexedSeqFromValue(value) {
      return isArrayLike(value)
        ? new ArraySeq(value)
        : isIterator(value)
        ? new IteratorSeq(value)
        : hasIterator(value)
        ? new IterableSeq(value)
        : undefined;
    }

    function seqIterate(seq, fn, reverse, useKeys) {
      var cache = seq._cache;
      if (cache) {
        var maxIndex = cache.length - 1;
        for (var ii = 0; ii <= maxIndex; ii++) {
          var entry = cache[reverse ? maxIndex - ii : ii];
          if (fn(entry[1], useKeys ? entry[0] : ii, seq) === false) {
            return ii + 1;
          }
        }
        return ii;
      }
      return seq.__iterateUncached(fn, reverse);
    }

    function seqIterator(seq, type, reverse, useKeys) {
      var cache = seq._cache;
      if (cache) {
        var maxIndex = cache.length - 1;
        var ii = 0;
        return new Iterator(function() {
          var entry = cache[reverse ? maxIndex - ii : ii];
          return ii++ > maxIndex
            ? iteratorDone()
            : iteratorValue(type, useKeys ? entry[0] : ii - 1, entry[1]);
        });
      }
      return seq.__iteratorUncached(type, reverse);
    }

    function fromJS(json, converter) {
      return converter
        ? fromJSWith(converter, json, "", { "": json })
        : fromJSDefault(json);
    }

    function fromJSWith(converter, json, key, parentJSON) {
      if (Array.isArray(json)) {
        return converter.call(
          parentJSON,
          key,
          IndexedSeq(json).map(function(v, k) {
            return fromJSWith(converter, v, k, json);
          })
        );
      }
      if (isPlainObj(json)) {
        return converter.call(
          parentJSON,
          key,
          KeyedSeq(json).map(function(v, k) {
            return fromJSWith(converter, v, k, json);
          })
        );
      }
      return json;
    }

    function fromJSDefault(json) {
      if (Array.isArray(json)) {
        return IndexedSeq(json)
          .map(fromJSDefault)
          .toList();
      }
      if (isPlainObj(json)) {
        return KeyedSeq(json)
          .map(fromJSDefault)
          .toMap();
      }
      return json;
    }

    function isPlainObj(value) {
      return (
        value &&
        (value.constructor === Object || value.constructor === undefined)
      );
    }

    /**
     * An extension of the "same-value" algorithm as [described for use by ES6 Map
     * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)
     *
     * NaN is considered the same as NaN, however -0 and 0 are considered the same
     * value, which is different from the algorithm described by
     * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
     *
     * This is extended further to allow Objects to describe the values they
     * represent, by way of `valueOf` or `equals` (and `hashCode`).
     *
     * Note: because of this extension, the key equality of Immutable.Map and the
     * value equality of Immutable.Set will differ from ES6 Map and Set.
     *
     * ### Defining custom values
     *
     * The easiest way to describe the value an object represents is by implementing
     * `valueOf`. For example, `Date` represents a value by returning a unix
     * timestamp for `valueOf`:
     *
     *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...
     *     var date2 = new Date(1234567890000);
     *     date1.valueOf(); // 1234567890000
     *     assert( date1 !== date2 );
     *     assert( Immutable.is( date1, date2 ) );
     *
     * Note: overriding `valueOf` may have other implications if you use this object
     * where JavaScript expects a primitive, such as implicit string coercion.
     *
     * For more complex types, especially collections, implementing `valueOf` may
     * not be performant. An alternative is to implement `equals` and `hashCode`.
     *
     * `equals` takes another object, presumably of similar type, and returns true
     * if the it is equal. Equality is symmetrical, so the same result should be
     * returned if this and the argument are flipped.
     *
     *     assert( a.equals(b) === b.equals(a) );
     *
     * `hashCode` returns a 32bit integer number representing the object which will
     * be used to determine how to store the value object in a Map or Set. You must
     * provide both or neither methods, one must not exist without the other.
     *
     * Also, an important relationship between these methods must be upheld: if two
     * values are equal, they *must* return the same hashCode. If the values are not
     * equal, they might have the same hashCode; this is called a hash collision,
     * and while undesirable for performance reasons, it is acceptable.
     *
     *     if (a.equals(b)) {
     *       assert( a.hashCode() === b.hashCode() );
     *     }
     *
     * All Immutable collections implement `equals` and `hashCode`.
     *
     */
    function is(valueA, valueB) {
      if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
        return true;
      }
      if (!valueA || !valueB) {
        return false;
      }
      if (
        typeof valueA.valueOf === "function" &&
        typeof valueB.valueOf === "function"
      ) {
        valueA = valueA.valueOf();
        valueB = valueB.valueOf();
        if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
          return true;
        }
        if (!valueA || !valueB) {
          return false;
        }
      }
      if (
        typeof valueA.equals === "function" &&
        typeof valueB.equals === "function" &&
        valueA.equals(valueB)
      ) {
        return true;
      }
      return false;
    }

    function deepEqual(a, b) {
      if (a === b) {
        return true;
      }

      if (
        !isIterable(b) ||
        (a.size !== undefined && b.size !== undefined && a.size !== b.size) ||
        (a.__hash !== undefined &&
          b.__hash !== undefined &&
          a.__hash !== b.__hash) ||
        isKeyed(a) !== isKeyed(b) ||
        isIndexed(a) !== isIndexed(b) ||
        isOrdered(a) !== isOrdered(b)
      ) {
        return false;
      }

      if (a.size === 0 && b.size === 0) {
        return true;
      }

      var notAssociative = !isAssociative(a);

      if (isOrdered(a)) {
        var entries = a.entries();
        return (
          b.every(function(v, k) {
            var entry = entries.next().value;
            return (
              entry && is(entry[1], v) && (notAssociative || is(entry[0], k))
            );
          }) && entries.next().done
        );
      }

      var flipped = false;

      if (a.size === undefined) {
        if (b.size === undefined) {
          if (typeof a.cacheResult === "function") {
            a.cacheResult();
          }
        } else {
          flipped = true;
          var _ = a;
          a = b;
          b = _;
        }
      }

      var allEqual = true;
      var bSize = b.__iterate(function(v, k) {
        if (
          notAssociative
            ? !a.has(v)
            : flipped
            ? !is(v, a.get(k, NOT_SET))
            : !is(a.get(k, NOT_SET), v)
        ) {
          allEqual = false;
          return false;
        }
      });

      return allEqual && a.size === bSize;
    }

    createClass(Repeat, IndexedSeq);

    function Repeat(value, times) {
      if (!(this instanceof Repeat)) {
        return new Repeat(value, times);
      }
      this._value = value;
      this.size = times === undefined ? Infinity : Math.max(0, times);
      if (this.size === 0) {
        if (EMPTY_REPEAT) {
          return EMPTY_REPEAT;
        }
        EMPTY_REPEAT = this;
      }
    }

    Repeat.prototype.toString = function() {
      if (this.size === 0) {
        return "Repeat []";
      }
      return "Repeat [ " + this._value + " " + this.size + " times ]";
    };

    Repeat.prototype.get = function(index, notSetValue) {
      return this.has(index) ? this._value : notSetValue;
    };

    Repeat.prototype.includes = function(searchValue) {
      return is(this._value, searchValue);
    };

    Repeat.prototype.slice = function(begin, end) {
      var size = this.size;
      return wholeSlice(begin, end, size)
        ? this
        : new Repeat(
            this._value,
            resolveEnd(end, size) - resolveBegin(begin, size)
          );
    };

    Repeat.prototype.reverse = function() {
      return this;
    };

    Repeat.prototype.indexOf = function(searchValue) {
      if (is(this._value, searchValue)) {
        return 0;
      }
      return -1;
    };

    Repeat.prototype.lastIndexOf = function(searchValue) {
      if (is(this._value, searchValue)) {
        return this.size;
      }
      return -1;
    };

    Repeat.prototype.__iterate = function(fn, reverse) {
      for (var ii = 0; ii < this.size; ii++) {
        if (fn(this._value, ii, this) === false) {
          return ii + 1;
        }
      }
      return ii;
    };

    Repeat.prototype.__iterator = function(type, reverse) {
      var this$0 = this;
      var ii = 0;
      return new Iterator(function() {
        return ii < this$0.size
          ? iteratorValue(type, ii++, this$0._value)
          : iteratorDone();
      });
    };

    Repeat.prototype.equals = function(other) {
      return other instanceof Repeat
        ? is(this._value, other._value)
        : deepEqual(other);
    };

    var EMPTY_REPEAT;

    function invariant(condition, error) {
      if (!condition) throw new Error(error);
    }

    createClass(Range, IndexedSeq);

    function Range(start, end, step) {
      if (!(this instanceof Range)) {
        return new Range(start, end, step);
      }
      invariant(step !== 0, "Cannot step a Range by 0");
      start = start || 0;
      if (end === undefined) {
        end = Infinity;
      }
      step = step === undefined ? 1 : Math.abs(step);
      if (end < start) {
        step = -step;
      }
      this._start = start;
      this._end = end;
      this._step = step;
      this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);
      if (this.size === 0) {
        if (EMPTY_RANGE) {
          return EMPTY_RANGE;
        }
        EMPTY_RANGE = this;
      }
    }

    Range.prototype.toString = function() {
      if (this.size === 0) {
        return "Range []";
      }
      return (
        "Range [ " +
        this._start +
        "..." +
        this._end +
        (this._step > 1 ? " by " + this._step : "") +
        " ]"
      );
    };

    Range.prototype.get = function(index, notSetValue) {
      return this.has(index)
        ? this._start + wrapIndex(this, index) * this._step
        : notSetValue;
    };

    Range.prototype.includes = function(searchValue) {
      var possibleIndex = (searchValue - this._start) / this._step;
      return (
        possibleIndex >= 0 &&
        possibleIndex < this.size &&
        possibleIndex === Math.floor(possibleIndex)
      );
    };

    Range.prototype.slice = function(begin, end) {
      if (wholeSlice(begin, end, this.size)) {
        return this;
      }
      begin = resolveBegin(begin, this.size);
      end = resolveEnd(end, this.size);
      if (end <= begin) {
        return new Range(0, 0);
      }
      return new Range(
        this.get(begin, this._end),
        this.get(end, this._end),
        this._step
      );
    };

    Range.prototype.indexOf = function(searchValue) {
      var offsetValue = searchValue - this._start;
      if (offsetValue % this._step === 0) {
        var index = offsetValue / this._step;
        if (index >= 0 && index < this.size) {
          return index;
        }
      }
      return -1;
    };

    Range.prototype.lastIndexOf = function(searchValue) {
      return this.indexOf(searchValue);
    };

    Range.prototype.__iterate = function(fn, reverse) {
      var maxIndex = this.size - 1;
      var step = this._step;
      var value = reverse ? this._start + maxIndex * step : this._start;
      for (var ii = 0; ii <= maxIndex; ii++) {
        if (fn(value, ii, this) === false) {
          return ii + 1;
        }
        value += reverse ? -step : step;
      }
      return ii;
    };

    Range.prototype.__iterator = function(type, reverse) {
      var maxIndex = this.size - 1;
      var step = this._step;
      var value = reverse ? this._start + maxIndex * step : this._start;
      var ii = 0;
      return new Iterator(function() {
        var v = value;
        value += reverse ? -step : step;
        return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii++, v);
      });
    };

    Range.prototype.equals = function(other) {
      return other instanceof Range
        ? this._start === other._start &&
            this._end === other._end &&
            this._step === other._step
        : deepEqual(this, other);
    };

    var EMPTY_RANGE;

    createClass(Collection, Iterable);
    function Collection() {
      throw TypeError("Abstract");
    }

    createClass(KeyedCollection, Collection);
    function KeyedCollection() {}

    createClass(IndexedCollection, Collection);
    function IndexedCollection() {}

    createClass(SetCollection, Collection);
    function SetCollection() {}

    Collection.Keyed = KeyedCollection;
    Collection.Indexed = IndexedCollection;
    Collection.Set = SetCollection;

    var imul =
      typeof Math.imul === "function" && Math.imul(0xffffffff, 2) === -2
        ? Math.imul
        : function imul(a, b) {
            a = a | 0; // int
            b = b | 0; // int
            var c = a & 0xffff;
            var d = b & 0xffff;
            // Shift by 0 fixes the sign on the high part.
            return (
              (c * d + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0)) | 0
            ); // int
          };

    // v8 has an optimization for storing 31-bit signed numbers.
    // Values which have either 00 or 11 as the high order bits qualify.
    // This function drops the highest order bit in a signed number, maintaining
    // the sign bit.
    function smi(i32) {
      return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff);
    }

    function hash(o) {
      if (o === false || o === null || o === undefined) {
        return 0;
      }
      if (typeof o.valueOf === "function") {
        o = o.valueOf();
        if (o === false || o === null || o === undefined) {
          return 0;
        }
      }
      if (o === true) {
        return 1;
      }
      var type = typeof o;
      if (type === "number") {
        var h = o | 0;
        if (h !== o) {
          h ^= o * 0xffffffff;
        }
        while (o > 0xffffffff) {
          o /= 0xffffffff;
          h ^= o;
        }
        return smi(h);
      }
      if (type === "string") {
        return o.length > STRING_HASH_CACHE_MIN_STRLEN
          ? cachedHashString(o)
          : hashString(o);
      }
      if (typeof o.hashCode === "function") {
        return o.hashCode();
      }
      if (type === "object") {
        return hashJSObj(o);
      }
      if (typeof o.toString === "function") {
        return hashString(o.toString());
      }
      throw new Error("Value type " + type + " cannot be hashed.");
    }

    function cachedHashString(string) {
      var hash = stringHashCache[string];
      if (hash === undefined) {
        hash = hashString(string);
        if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {
          STRING_HASH_CACHE_SIZE = 0;
          stringHashCache = {};
        }
        STRING_HASH_CACHE_SIZE++;
        stringHashCache[string] = hash;
      }
      return hash;
    }

    // http://jsperf.com/hashing-strings
    function hashString(string) {
      // This is the hash from JVM
      // The hash code for a string is computed as
      // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],
      // where s[i] is the ith character of the string and n is the length of
      // the string. We "mod" the result to make it between 0 (inclusive) and 2^31
      // (exclusive) by dropping high bits.
      var hash = 0;
      for (var ii = 0; ii < string.length; ii++) {
        hash = (31 * hash + string.charCodeAt(ii)) | 0;
      }
      return smi(hash);
    }

    function hashJSObj(obj) {
      var hash;
      if (usingWeakMap) {
        hash = weakMap.get(obj);
        if (hash !== undefined) {
          return hash;
        }
      }

      hash = obj[UID_HASH_KEY];
      if (hash !== undefined) {
        return hash;
      }

      if (!canDefineProperty) {
        hash =
          obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];
        if (hash !== undefined) {
          return hash;
        }

        hash = getIENodeHash(obj);
        if (hash !== undefined) {
          return hash;
        }
      }

      hash = ++objHashUID;
      if (objHashUID & 0x40000000) {
        objHashUID = 0;
      }

      if (usingWeakMap) {
        weakMap.set(obj, hash);
      } else if (isExtensible !== undefined && isExtensible(obj) === false) {
        throw new Error("Non-extensible objects are not allowed as keys.");
      } else if (canDefineProperty) {
        Object.defineProperty(obj, UID_HASH_KEY, {
          enumerable: false,
          configurable: false,
          writable: false,
          value: hash
        });
      } else if (
        obj.propertyIsEnumerable !== undefined &&
        obj.propertyIsEnumerable ===
          obj.constructor.prototype.propertyIsEnumerable
      ) {
        // Since we can't define a non-enumerable property on the object
        // we'll hijack one of the less-used non-enumerable properties to
        // save our hash on it. Since this is a function it will not show up in
        // `JSON.stringify` which is what we want.
        obj.propertyIsEnumerable = function() {
          return this.constructor.prototype.propertyIsEnumerable.apply(
            this,
            arguments
          );
        };
        obj.propertyIsEnumerable[UID_HASH_KEY] = hash;
      } else if (obj.nodeType !== undefined) {
        // At this point we couldn't get the IE `uniqueID` to use as a hash
        // and we couldn't use a non-enumerable property to exploit the
        // dontEnum bug so we simply add the `UID_HASH_KEY` on the node
        // itself.
        obj[UID_HASH_KEY] = hash;
      } else {
        throw new Error("Unable to set a non-enumerable property on object.");
      }

      return hash;
    }

    // Get references to ES5 object methods.
    var isExtensible = Object.isExtensible;

    // True if Object.defineProperty works as expected. IE8 fails this test.
    var canDefineProperty = (function() {
      try {
        Object.defineProperty({}, "@", {});
        return true;
      } catch (e) {
        return false;
      }
    })();

    // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it
    // and avoid memory leaks from the IE cloneNode bug.
    function getIENodeHash(node) {
      if (node && node.nodeType > 0) {
        switch (node.nodeType) {
          case 1: // Element
            return node.uniqueID;
          case 9: // Document
            return node.documentElement && node.documentElement.uniqueID;
        }
      }
    }

    // If possible, use a WeakMap.
    var usingWeakMap = typeof WeakMap === "function";
    var weakMap;
    if (usingWeakMap) {
      weakMap = new WeakMap();
    }

    var objHashUID = 0;

    var UID_HASH_KEY = "__immutablehash__";
    if (typeof Symbol === "function") {
      UID_HASH_KEY = Symbol(UID_HASH_KEY);
    }

    var STRING_HASH_CACHE_MIN_STRLEN = 16;
    var STRING_HASH_CACHE_MAX_SIZE = 255;
    var STRING_HASH_CACHE_SIZE = 0;
    var stringHashCache = {};

    function assertNotInfinite(size) {
      invariant(
        size !== Infinity,
        "Cannot perform this action with an infinite size."
      );
    }

    createClass(Map, KeyedCollection);

    // @pragma Construction

    function Map(value) {
      return value === null || value === undefined
        ? emptyMap()
        : isMap(value) && !isOrdered(value)
        ? value
        : emptyMap().withMutations(function(map) {
            var iter = KeyedIterable(value);
            assertNotInfinite(iter.size);
            iter.forEach(function(v, k) {
              return map.set(k, v);
            });
          });
    }

    Map.prototype.toString = function() {
      return this.__toString("Map {", "}");
    };

    // @pragma Access

    Map.prototype.get = function(k, notSetValue) {
      return this._root
        ? this._root.get(0, undefined, k, notSetValue)
        : notSetValue;
    };

    // @pragma Modification

    Map.prototype.set = function(k, v) {
      return updateMap(this, k, v);
    };

    Map.prototype.setIn = function(keyPath, v) {
      return this.updateIn(keyPath, NOT_SET, function() {
        return v;
      });
    };

    Map.prototype.remove = function(k) {
      return updateMap(this, k, NOT_SET);
    };

    Map.prototype.deleteIn = function(keyPath) {
      return this.updateIn(keyPath, function() {
        return NOT_SET;
      });
    };

    Map.prototype.update = function(k, notSetValue, updater) {
      return arguments.length === 1
        ? k(this)
        : this.updateIn([k], notSetValue, updater);
    };

    Map.prototype.updateIn = function(keyPath, notSetValue, updater) {
      if (!updater) {
        updater = notSetValue;
        notSetValue = undefined;
      }
      var updatedValue = updateInDeepMap(
        this,
        forceIterator(keyPath),
        notSetValue,
        updater
      );
      return updatedValue === NOT_SET ? undefined : updatedValue;
    };

    Map.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = 0;
        this._root = null;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return emptyMap();
    };

    // @pragma Composition

    Map.prototype.merge = function(/*...iters*/) {
      return mergeIntoMapWith(this, undefined, arguments);
    };

    Map.prototype.mergeWith = function(merger) {
      var iters = SLICE$0.call(arguments, 1);
      return mergeIntoMapWith(this, merger, iters);
    };

    Map.prototype.mergeIn = function(keyPath) {
      var iters = SLICE$0.call(arguments, 1);
      return this.updateIn(keyPath, emptyMap(), function(m) {
        return typeof m.merge === "function"
          ? m.merge.apply(m, iters)
          : iters[iters.length - 1];
      });
    };

    Map.prototype.mergeDeep = function(/*...iters*/) {
      return mergeIntoMapWith(this, deepMerger, arguments);
    };

    Map.prototype.mergeDeepWith = function(merger) {
      var iters = SLICE$0.call(arguments, 1);
      return mergeIntoMapWith(this, deepMergerWith(merger), iters);
    };

    Map.prototype.mergeDeepIn = function(keyPath) {
      var iters = SLICE$0.call(arguments, 1);
      return this.updateIn(keyPath, emptyMap(), function(m) {
        return typeof m.mergeDeep === "function"
          ? m.mergeDeep.apply(m, iters)
          : iters[iters.length - 1];
      });
    };

    Map.prototype.sort = function(comparator) {
      // Late binding
      return OrderedMap(sortFactory(this, comparator));
    };

    Map.prototype.sortBy = function(mapper, comparator) {
      // Late binding
      return OrderedMap(sortFactory(this, comparator, mapper));
    };

    // @pragma Mutability

    Map.prototype.withMutations = function(fn) {
      var mutable = this.asMutable();
      fn(mutable);
      return mutable.wasAltered()
        ? mutable.__ensureOwner(this.__ownerID)
        : this;
    };

    Map.prototype.asMutable = function() {
      return this.__ownerID ? this : this.__ensureOwner(new OwnerID());
    };

    Map.prototype.asImmutable = function() {
      return this.__ensureOwner();
    };

    Map.prototype.wasAltered = function() {
      return this.__altered;
    };

    Map.prototype.__iterator = function(type, reverse) {
      return new MapIterator(this, type, reverse);
    };

    Map.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      var iterations = 0;
      this._root &&
        this._root.iterate(function(entry) {
          iterations++;
          return fn(entry[1], entry[0], this$0);
        }, reverse);
      return iterations;
    };

    Map.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {
        this.__ownerID = ownerID;
        this.__altered = false;
        return this;
      }
      return makeMap(this.size, this._root, ownerID, this.__hash);
    };

    function isMap(maybeMap) {
      return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]);
    }

    Map.isMap = isMap;

    var IS_MAP_SENTINEL = "@@__IMMUTABLE_MAP__@@";

    var MapPrototype = Map.prototype;
    MapPrototype[IS_MAP_SENTINEL] = true;
    MapPrototype[DELETE] = MapPrototype.remove;
    MapPrototype.removeIn = MapPrototype.deleteIn;

    // #pragma Trie Nodes

    function ArrayMapNode(ownerID, entries) {
      this.ownerID = ownerID;
      this.entries = entries;
    }

    ArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {
      var entries = this.entries;
      for (var ii = 0, len = entries.length; ii < len; ii++) {
        if (is(key, entries[ii][0])) {
          return entries[ii][1];
        }
      }
      return notSetValue;
    };

    ArrayMapNode.prototype.update = function(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      var removed = value === NOT_SET;

      var entries = this.entries;
      var idx = 0;
      for (var len = entries.length; idx < len; idx++) {
        if (is(key, entries[idx][0])) {
          break;
        }
      }
      var exists = idx < len;

      if (exists ? entries[idx][1] === value : removed) {
        return this;
      }

      SetRef(didAlter);
      (removed || !exists) && SetRef(didChangeSize);

      if (removed && entries.length === 1) {
        return; // undefined
      }

      if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {
        return createNodes(ownerID, entries, key, value);
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newEntries = isEditable ? entries : arrCopy(entries);

      if (exists) {
        if (removed) {
          idx === len - 1
            ? newEntries.pop()
            : (newEntries[idx] = newEntries.pop());
        } else {
          newEntries[idx] = [key, value];
        }
      } else {
        newEntries.push([key, value]);
      }

      if (isEditable) {
        this.entries = newEntries;
        return this;
      }

      return new ArrayMapNode(ownerID, newEntries);
    };

    function BitmapIndexedNode(ownerID, bitmap, nodes) {
      this.ownerID = ownerID;
      this.bitmap = bitmap;
      this.nodes = nodes;
    }

    BitmapIndexedNode.prototype.get = function(
      shift,
      keyHash,
      key,
      notSetValue
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var bit = 1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK);
      var bitmap = this.bitmap;
      return (bitmap & bit) === 0
        ? notSetValue
        : this.nodes[popCount(bitmap & (bit - 1))].get(
            shift + SHIFT,
            keyHash,
            key,
            notSetValue
          );
    };

    BitmapIndexedNode.prototype.update = function(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
      var bit = 1 << keyHashFrag;
      var bitmap = this.bitmap;
      var exists = (bitmap & bit) !== 0;

      if (!exists && value === NOT_SET) {
        return this;
      }

      var idx = popCount(bitmap & (bit - 1));
      var nodes = this.nodes;
      var node = exists ? nodes[idx] : undefined;
      var newNode = updateNode(
        node,
        ownerID,
        shift + SHIFT,
        keyHash,
        key,
        value,
        didChangeSize,
        didAlter
      );

      if (newNode === node) {
        return this;
      }

      if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {
        return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);
      }

      if (
        exists &&
        !newNode &&
        nodes.length === 2 &&
        isLeafNode(nodes[idx ^ 1])
      ) {
        return nodes[idx ^ 1];
      }

      if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {
        return newNode;
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newBitmap = exists ? (newNode ? bitmap : bitmap ^ bit) : bitmap | bit;
      var newNodes = exists
        ? newNode
          ? setIn(nodes, idx, newNode, isEditable)
          : spliceOut(nodes, idx, isEditable)
        : spliceIn(nodes, idx, newNode, isEditable);

      if (isEditable) {
        this.bitmap = newBitmap;
        this.nodes = newNodes;
        return this;
      }

      return new BitmapIndexedNode(ownerID, newBitmap, newNodes);
    };

    function HashArrayMapNode(ownerID, count, nodes) {
      this.ownerID = ownerID;
      this.count = count;
      this.nodes = nodes;
    }

    HashArrayMapNode.prototype.get = function(
      shift,
      keyHash,
      key,
      notSetValue
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
      var node = this.nodes[idx];
      return node
        ? node.get(shift + SHIFT, keyHash, key, notSetValue)
        : notSetValue;
    };

    HashArrayMapNode.prototype.update = function(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
      var removed = value === NOT_SET;
      var nodes = this.nodes;
      var node = nodes[idx];

      if (removed && !node) {
        return this;
      }

      var newNode = updateNode(
        node,
        ownerID,
        shift + SHIFT,
        keyHash,
        key,
        value,
        didChangeSize,
        didAlter
      );
      if (newNode === node) {
        return this;
      }

      var newCount = this.count;
      if (!node) {
        newCount++;
      } else if (!newNode) {
        newCount--;
        if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {
          return packNodes(ownerID, nodes, newCount, idx);
        }
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newNodes = setIn(nodes, idx, newNode, isEditable);

      if (isEditable) {
        this.count = newCount;
        this.nodes = newNodes;
        return this;
      }

      return new HashArrayMapNode(ownerID, newCount, newNodes);
    };

    function HashCollisionNode(ownerID, keyHash, entries) {
      this.ownerID = ownerID;
      this.keyHash = keyHash;
      this.entries = entries;
    }

    HashCollisionNode.prototype.get = function(
      shift,
      keyHash,
      key,
      notSetValue
    ) {
      var entries = this.entries;
      for (var ii = 0, len = entries.length; ii < len; ii++) {
        if (is(key, entries[ii][0])) {
          return entries[ii][1];
        }
      }
      return notSetValue;
    };

    HashCollisionNode.prototype.update = function(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }

      var removed = value === NOT_SET;

      if (keyHash !== this.keyHash) {
        if (removed) {
          return this;
        }
        SetRef(didAlter);
        SetRef(didChangeSize);
        return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);
      }

      var entries = this.entries;
      var idx = 0;
      for (var len = entries.length; idx < len; idx++) {
        if (is(key, entries[idx][0])) {
          break;
        }
      }
      var exists = idx < len;

      if (exists ? entries[idx][1] === value : removed) {
        return this;
      }

      SetRef(didAlter);
      (removed || !exists) && SetRef(didChangeSize);

      if (removed && len === 2) {
        return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newEntries = isEditable ? entries : arrCopy(entries);

      if (exists) {
        if (removed) {
          idx === len - 1
            ? newEntries.pop()
            : (newEntries[idx] = newEntries.pop());
        } else {
          newEntries[idx] = [key, value];
        }
      } else {
        newEntries.push([key, value]);
      }

      if (isEditable) {
        this.entries = newEntries;
        return this;
      }

      return new HashCollisionNode(ownerID, this.keyHash, newEntries);
    };

    function ValueNode(ownerID, keyHash, entry) {
      this.ownerID = ownerID;
      this.keyHash = keyHash;
      this.entry = entry;
    }

    ValueNode.prototype.get = function(shift, keyHash, key, notSetValue) {
      return is(key, this.entry[0]) ? this.entry[1] : notSetValue;
    };

    ValueNode.prototype.update = function(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      var removed = value === NOT_SET;
      var keyMatch = is(key, this.entry[0]);
      if (keyMatch ? value === this.entry[1] : removed) {
        return this;
      }

      SetRef(didAlter);

      if (removed) {
        SetRef(didChangeSize);
        return; // undefined
      }

      if (keyMatch) {
        if (ownerID && ownerID === this.ownerID) {
          this.entry[1] = value;
          return this;
        }
        return new ValueNode(ownerID, this.keyHash, [key, value]);
      }

      SetRef(didChangeSize);
      return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);
    };

    // #pragma Iterators

    ArrayMapNode.prototype.iterate = HashCollisionNode.prototype.iterate = function(
      fn,
      reverse
    ) {
      var entries = this.entries;
      for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {
        if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {
          return false;
        }
      }
    };

    BitmapIndexedNode.prototype.iterate = HashArrayMapNode.prototype.iterate = function(
      fn,
      reverse
    ) {
      var nodes = this.nodes;
      for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {
        var node = nodes[reverse ? maxIndex - ii : ii];
        if (node && node.iterate(fn, reverse) === false) {
          return false;
        }
      }
    };

    ValueNode.prototype.iterate = function(fn, reverse) {
      return fn(this.entry);
    };

    createClass(MapIterator, Iterator);

    function MapIterator(map, type, reverse) {
      this._type = type;
      this._reverse = reverse;
      this._stack = map._root && mapIteratorFrame(map._root);
    }

    MapIterator.prototype.next = function() {
      var type = this._type;
      var stack = this._stack;
      while (stack) {
        var node = stack.node;
        var index = stack.index++;
        var maxIndex;
        if (node.entry) {
          if (index === 0) {
            return mapIteratorValue(type, node.entry);
          }
        } else if (node.entries) {
          maxIndex = node.entries.length - 1;
          if (index <= maxIndex) {
            return mapIteratorValue(
              type,
              node.entries[this._reverse ? maxIndex - index : index]
            );
          }
        } else {
          maxIndex = node.nodes.length - 1;
          if (index <= maxIndex) {
            var subNode = node.nodes[this._reverse ? maxIndex - index : index];
            if (subNode) {
              if (subNode.entry) {
                return mapIteratorValue(type, subNode.entry);
              }
              stack = this._stack = mapIteratorFrame(subNode, stack);
            }
            continue;
          }
        }
        stack = this._stack = this._stack.__prev;
      }
      return iteratorDone();
    };

    function mapIteratorValue(type, entry) {
      return iteratorValue(type, entry[0], entry[1]);
    }

    function mapIteratorFrame(node, prev) {
      return {
        node: node,
        index: 0,
        __prev: prev
      };
    }

    function makeMap(size, root, ownerID, hash) {
      var map = Object.create(MapPrototype);
      map.size = size;
      map._root = root;
      map.__ownerID = ownerID;
      map.__hash = hash;
      map.__altered = false;
      return map;
    }

    var EMPTY_MAP;
    function emptyMap() {
      return EMPTY_MAP || (EMPTY_MAP = makeMap(0));
    }

    function updateMap(map, k, v) {
      var newRoot;
      var newSize;
      if (!map._root) {
        if (v === NOT_SET) {
          return map;
        }
        newSize = 1;
        newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);
      } else {
        var didChangeSize = MakeRef(CHANGE_LENGTH);
        var didAlter = MakeRef(DID_ALTER);
        newRoot = updateNode(
          map._root,
          map.__ownerID,
          0,
          undefined,
          k,
          v,
          didChangeSize,
          didAlter
        );
        if (!didAlter.value) {
          return map;
        }
        newSize =
          map.size + (didChangeSize.value ? (v === NOT_SET ? -1 : 1) : 0);
      }
      if (map.__ownerID) {
        map.size = newSize;
        map._root = newRoot;
        map.__hash = undefined;
        map.__altered = true;
        return map;
      }
      return newRoot ? makeMap(newSize, newRoot) : emptyMap();
    }

    function updateNode(
      node,
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (!node) {
        if (value === NOT_SET) {
          return node;
        }
        SetRef(didAlter);
        SetRef(didChangeSize);
        return new ValueNode(ownerID, keyHash, [key, value]);
      }
      return node.update(
        ownerID,
        shift,
        keyHash,
        key,
        value,
        didChangeSize,
        didAlter
      );
    }

    function isLeafNode(node) {
      return (
        node.constructor === ValueNode || node.constructor === HashCollisionNode
      );
    }

    function mergeIntoNode(node, ownerID, shift, keyHash, entry) {
      if (node.keyHash === keyHash) {
        return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);
      }

      var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;
      var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;

      var newNode;
      var nodes =
        idx1 === idx2
          ? [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)]
          : ((newNode = new ValueNode(ownerID, keyHash, entry)),
            idx1 < idx2 ? [node, newNode] : [newNode, node]);

      return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);
    }

    function createNodes(ownerID, entries, key, value) {
      if (!ownerID) {
        ownerID = new OwnerID();
      }
      var node = new ValueNode(ownerID, hash(key), [key, value]);
      for (var ii = 0; ii < entries.length; ii++) {
        var entry = entries[ii];
        node = node.update(ownerID, 0, undefined, entry[0], entry[1]);
      }
      return node;
    }

    function packNodes(ownerID, nodes, count, excluding) {
      var bitmap = 0;
      var packedII = 0;
      var packedNodes = new Array(count);
      for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {
        var node = nodes[ii];
        if (node !== undefined && ii !== excluding) {
          bitmap |= bit;
          packedNodes[packedII++] = node;
        }
      }
      return new BitmapIndexedNode(ownerID, bitmap, packedNodes);
    }

    function expandNodes(ownerID, nodes, bitmap, including, node) {
      var count = 0;
      var expandedNodes = new Array(SIZE);
      for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {
        expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;
      }
      expandedNodes[including] = node;
      return new HashArrayMapNode(ownerID, count + 1, expandedNodes);
    }

    function mergeIntoMapWith(map, merger, iterables) {
      var iters = [];
      for (var ii = 0; ii < iterables.length; ii++) {
        var value = iterables[ii];
        var iter = KeyedIterable(value);
        if (!isIterable(value)) {
          iter = iter.map(function(v) {
            return fromJS(v);
          });
        }
        iters.push(iter);
      }
      return mergeIntoCollectionWith(map, merger, iters);
    }

    function deepMerger(existing, value, key) {
      return existing && existing.mergeDeep && isIterable(value)
        ? existing.mergeDeep(value)
        : is(existing, value)
        ? existing
        : value;
    }

    function deepMergerWith(merger) {
      return function(existing, value, key) {
        if (existing && existing.mergeDeepWith && isIterable(value)) {
          return existing.mergeDeepWith(merger, value);
        }
        var nextValue = merger(existing, value, key);
        return is(existing, nextValue) ? existing : nextValue;
      };
    }

    function mergeIntoCollectionWith(collection, merger, iters) {
      iters = iters.filter(function(x) {
        return x.size !== 0;
      });
      if (iters.length === 0) {
        return collection;
      }
      if (
        collection.size === 0 &&
        !collection.__ownerID &&
        iters.length === 1
      ) {
        return collection.constructor(iters[0]);
      }
      return collection.withMutations(function(collection) {
        var mergeIntoMap = merger
          ? function(value, key) {
              collection.update(key, NOT_SET, function(existing) {
                return existing === NOT_SET
                  ? value
                  : merger(existing, value, key);
              });
            }
          : function(value, key) {
              collection.set(key, value);
            };
        for (var ii = 0; ii < iters.length; ii++) {
          iters[ii].forEach(mergeIntoMap);
        }
      });
    }

    function updateInDeepMap(existing, keyPathIter, notSetValue, updater) {
      var isNotSet = existing === NOT_SET;
      var step = keyPathIter.next();
      if (step.done) {
        var existingValue = isNotSet ? notSetValue : existing;
        var newValue = updater(existingValue);
        return newValue === existingValue ? existing : newValue;
      }
      invariant(isNotSet || (existing && existing.set), "invalid keyPath");
      var key = step.value;
      var nextExisting = isNotSet ? NOT_SET : existing.get(key, NOT_SET);
      var nextUpdated = updateInDeepMap(
        nextExisting,
        keyPathIter,
        notSetValue,
        updater
      );
      return nextUpdated === nextExisting
        ? existing
        : nextUpdated === NOT_SET
        ? existing.remove(key)
        : (isNotSet ? emptyMap() : existing).set(key, nextUpdated);
    }

    function popCount(x) {
      x = x - ((x >> 1) & 0x55555555);
      x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
      x = (x + (x >> 4)) & 0x0f0f0f0f;
      x = x + (x >> 8);
      x = x + (x >> 16);
      return x & 0x7f;
    }

    function setIn(array, idx, val, canEdit) {
      var newArray = canEdit ? array : arrCopy(array);
      newArray[idx] = val;
      return newArray;
    }

    function spliceIn(array, idx, val, canEdit) {
      var newLen = array.length + 1;
      if (canEdit && idx + 1 === newLen) {
        array[idx] = val;
        return array;
      }
      var newArray = new Array(newLen);
      var after = 0;
      for (var ii = 0; ii < newLen; ii++) {
        if (ii === idx) {
          newArray[ii] = val;
          after = -1;
        } else {
          newArray[ii] = array[ii + after];
        }
      }
      return newArray;
    }

    function spliceOut(array, idx, canEdit) {
      var newLen = array.length - 1;
      if (canEdit && idx === newLen) {
        array.pop();
        return array;
      }
      var newArray = new Array(newLen);
      var after = 0;
      for (var ii = 0; ii < newLen; ii++) {
        if (ii === idx) {
          after = 1;
        }
        newArray[ii] = array[ii + after];
      }
      return newArray;
    }

    var MAX_ARRAY_MAP_SIZE = SIZE / 4;
    var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;
    var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;

    createClass(List, IndexedCollection);

    // @pragma Construction

    function List(value) {
      var empty = emptyList();
      if (value === null || value === undefined) {
        return empty;
      }
      if (isList(value)) {
        return value;
      }
      var iter = IndexedIterable(value);
      var size = iter.size;
      if (size === 0) {
        return empty;
      }
      assertNotInfinite(size);
      if (size > 0 && size < SIZE) {
        return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));
      }
      return empty.withMutations(function(list) {
        list.setSize(size);
        iter.forEach(function(v, i) {
          return list.set(i, v);
        });
      });
    }

    List.of = function(/*...values*/) {
      return this(arguments);
    };

    List.prototype.toString = function() {
      return this.__toString("List [", "]");
    };

    // @pragma Access

    List.prototype.get = function(index, notSetValue) {
      index = wrapIndex(this, index);
      if (index >= 0 && index < this.size) {
        index += this._origin;
        var node = listNodeFor(this, index);
        return node && node.array[index & MASK];
      }
      return notSetValue;
    };

    // @pragma Modification

    List.prototype.set = function(index, value) {
      return updateList(this, index, value);
    };

    List.prototype.remove = function(index) {
      return !this.has(index)
        ? this
        : index === 0
        ? this.shift()
        : index === this.size - 1
        ? this.pop()
        : this.splice(index, 1);
    };

    List.prototype.insert = function(index, value) {
      return this.splice(index, 0, value);
    };

    List.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = this._origin = this._capacity = 0;
        this._level = SHIFT;
        this._root = this._tail = null;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return emptyList();
    };

    List.prototype.push = function(/*...values*/) {
      var values = arguments;
      var oldSize = this.size;
      return this.withMutations(function(list) {
        setListBounds(list, 0, oldSize + values.length);
        for (var ii = 0; ii < values.length; ii++) {
          list.set(oldSize + ii, values[ii]);
        }
      });
    };

    List.prototype.pop = function() {
      return setListBounds(this, 0, -1);
    };

    List.prototype.unshift = function(/*...values*/) {
      var values = arguments;
      return this.withMutations(function(list) {
        setListBounds(list, -values.length);
        for (var ii = 0; ii < values.length; ii++) {
          list.set(ii, values[ii]);
        }
      });
    };

    List.prototype.shift = function() {
      return setListBounds(this, 1);
    };

    // @pragma Composition

    List.prototype.merge = function(/*...iters*/) {
      return mergeIntoListWith(this, undefined, arguments);
    };

    List.prototype.mergeWith = function(merger) {
      var iters = SLICE$0.call(arguments, 1);
      return mergeIntoListWith(this, merger, iters);
    };

    List.prototype.mergeDeep = function(/*...iters*/) {
      return mergeIntoListWith(this, deepMerger, arguments);
    };

    List.prototype.mergeDeepWith = function(merger) {
      var iters = SLICE$0.call(arguments, 1);
      return mergeIntoListWith(this, deepMergerWith(merger), iters);
    };

    List.prototype.setSize = function(size) {
      return setListBounds(this, 0, size);
    };

    // @pragma Iteration

    List.prototype.slice = function(begin, end) {
      var size = this.size;
      if (wholeSlice(begin, end, size)) {
        return this;
      }
      return setListBounds(
        this,
        resolveBegin(begin, size),
        resolveEnd(end, size)
      );
    };

    List.prototype.__iterator = function(type, reverse) {
      var index = 0;
      var values = iterateList(this, reverse);
      return new Iterator(function() {
        var value = values();
        return value === DONE
          ? iteratorDone()
          : iteratorValue(type, index++, value);
      });
    };

    List.prototype.__iterate = function(fn, reverse) {
      var index = 0;
      var values = iterateList(this, reverse);
      var value;
      while ((value = values()) !== DONE) {
        if (fn(value, index++, this) === false) {
          break;
        }
      }
      return index;
    };

    List.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {
        this.__ownerID = ownerID;
        return this;
      }
      return makeList(
        this._origin,
        this._capacity,
        this._level,
        this._root,
        this._tail,
        ownerID,
        this.__hash
      );
    };

    function isList(maybeList) {
      return !!(maybeList && maybeList[IS_LIST_SENTINEL]);
    }

    List.isList = isList;

    var IS_LIST_SENTINEL = "@@__IMMUTABLE_LIST__@@";

    var ListPrototype = List.prototype;
    ListPrototype[IS_LIST_SENTINEL] = true;
    ListPrototype[DELETE] = ListPrototype.remove;
    ListPrototype.setIn = MapPrototype.setIn;
    ListPrototype.deleteIn = ListPrototype.removeIn = MapPrototype.removeIn;
    ListPrototype.update = MapPrototype.update;
    ListPrototype.updateIn = MapPrototype.updateIn;
    ListPrototype.mergeIn = MapPrototype.mergeIn;
    ListPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;
    ListPrototype.withMutations = MapPrototype.withMutations;
    ListPrototype.asMutable = MapPrototype.asMutable;
    ListPrototype.asImmutable = MapPrototype.asImmutable;
    ListPrototype.wasAltered = MapPrototype.wasAltered;

    function VNode(array, ownerID) {
      this.array = array;
      this.ownerID = ownerID;
    }

    // TODO: seems like these methods are very similar

    VNode.prototype.removeBefore = function(ownerID, level, index) {
      if (index === level ? 1 << level : this.array.length === 0) {
        return this;
      }
      var originIndex = (index >>> level) & MASK;
      if (originIndex >= this.array.length) {
        return new VNode([], ownerID);
      }
      var removingFirst = originIndex === 0;
      var newChild;
      if (level > 0) {
        var oldChild = this.array[originIndex];
        newChild =
          oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);
        if (newChild === oldChild && removingFirst) {
          return this;
        }
      }
      if (removingFirst && !newChild) {
        return this;
      }
      var editable = editableVNode(this, ownerID);
      if (!removingFirst) {
        for (var ii = 0; ii < originIndex; ii++) {
          editable.array[ii] = undefined;
        }
      }
      if (newChild) {
        editable.array[originIndex] = newChild;
      }
      return editable;
    };

    VNode.prototype.removeAfter = function(ownerID, level, index) {
      if (index === (level ? 1 << level : 0) || this.array.length === 0) {
        return this;
      }
      var sizeIndex = ((index - 1) >>> level) & MASK;
      if (sizeIndex >= this.array.length) {
        return this;
      }

      var newChild;
      if (level > 0) {
        var oldChild = this.array[sizeIndex];
        newChild =
          oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);
        if (newChild === oldChild && sizeIndex === this.array.length - 1) {
          return this;
        }
      }

      var editable = editableVNode(this, ownerID);
      editable.array.splice(sizeIndex + 1);
      if (newChild) {
        editable.array[sizeIndex] = newChild;
      }
      return editable;
    };

    var DONE = {};

    function iterateList(list, reverse) {
      var left = list._origin;
      var right = list._capacity;
      var tailPos = getTailOffset(right);
      var tail = list._tail;

      return iterateNodeOrLeaf(list._root, list._level, 0);

      function iterateNodeOrLeaf(node, level, offset) {
        return level === 0
          ? iterateLeaf(node, offset)
          : iterateNode(node, level, offset);
      }

      function iterateLeaf(node, offset) {
        var array =
          offset === tailPos ? tail && tail.array : node && node.array;
        var from = offset > left ? 0 : left - offset;
        var to = right - offset;
        if (to > SIZE) {
          to = SIZE;
        }
        return function() {
          if (from === to) {
            return DONE;
          }
          var idx = reverse ? --to : from++;
          return array && array[idx];
        };
      }

      function iterateNode(node, level, offset) {
        var values;
        var array = node && node.array;
        var from = offset > left ? 0 : (left - offset) >> level;
        var to = ((right - offset) >> level) + 1;
        if (to > SIZE) {
          to = SIZE;
        }
        return function() {
          do {
            if (values) {
              var value = values();
              if (value !== DONE) {
                return value;
              }
              values = null;
            }
            if (from === to) {
              return DONE;
            }
            var idx = reverse ? --to : from++;
            values = iterateNodeOrLeaf(
              array && array[idx],
              level - SHIFT,
              offset + (idx << level)
            );
          } while (true);
        };
      }
    }

    function makeList(origin, capacity, level, root, tail, ownerID, hash) {
      var list = Object.create(ListPrototype);
      list.size = capacity - origin;
      list._origin = origin;
      list._capacity = capacity;
      list._level = level;
      list._root = root;
      list._tail = tail;
      list.__ownerID = ownerID;
      list.__hash = hash;
      list.__altered = false;
      return list;
    }

    var EMPTY_LIST;
    function emptyList() {
      return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));
    }

    function updateList(list, index, value) {
      index = wrapIndex(list, index);

      if (index !== index) {
        return list;
      }

      if (index >= list.size || index < 0) {
        return list.withMutations(function(list) {
          index < 0
            ? setListBounds(list, index).set(0, value)
            : setListBounds(list, 0, index + 1).set(index, value);
        });
      }

      index += list._origin;

      var newTail = list._tail;
      var newRoot = list._root;
      var didAlter = MakeRef(DID_ALTER);
      if (index >= getTailOffset(list._capacity)) {
        newTail = updateVNode(
          newTail,
          list.__ownerID,
          0,
          index,
          value,
          didAlter
        );
      } else {
        newRoot = updateVNode(
          newRoot,
          list.__ownerID,
          list._level,
          index,
          value,
          didAlter
        );
      }

      if (!didAlter.value) {
        return list;
      }

      if (list.__ownerID) {
        list._root = newRoot;
        list._tail = newTail;
        list.__hash = undefined;
        list.__altered = true;
        return list;
      }
      return makeList(
        list._origin,
        list._capacity,
        list._level,
        newRoot,
        newTail
      );
    }

    function updateVNode(node, ownerID, level, index, value, didAlter) {
      var idx = (index >>> level) & MASK;
      var nodeHas = node && idx < node.array.length;
      if (!nodeHas && value === undefined) {
        return node;
      }

      var newNode;

      if (level > 0) {
        var lowerNode = node && node.array[idx];
        var newLowerNode = updateVNode(
          lowerNode,
          ownerID,
          level - SHIFT,
          index,
          value,
          didAlter
        );
        if (newLowerNode === lowerNode) {
          return node;
        }
        newNode = editableVNode(node, ownerID);
        newNode.array[idx] = newLowerNode;
        return newNode;
      }

      if (nodeHas && node.array[idx] === value) {
        return node;
      }

      SetRef(didAlter);

      newNode = editableVNode(node, ownerID);
      if (value === undefined && idx === newNode.array.length - 1) {
        newNode.array.pop();
      } else {
        newNode.array[idx] = value;
      }
      return newNode;
    }

    function editableVNode(node, ownerID) {
      if (ownerID && node && ownerID === node.ownerID) {
        return node;
      }
      return new VNode(node ? node.array.slice() : [], ownerID);
    }

    function listNodeFor(list, rawIndex) {
      if (rawIndex >= getTailOffset(list._capacity)) {
        return list._tail;
      }
      if (rawIndex < 1 << (list._level + SHIFT)) {
        var node = list._root;
        var level = list._level;
        while (node && level > 0) {
          node = node.array[(rawIndex >>> level) & MASK];
          level -= SHIFT;
        }
        return node;
      }
    }

    function setListBounds(list, begin, end) {
      // Sanitize begin & end using this shorthand for ToInt32(argument)
      // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
      if (begin !== undefined) {
        begin = begin | 0;
      }
      if (end !== undefined) {
        end = end | 0;
      }
      var owner = list.__ownerID || new OwnerID();
      var oldOrigin = list._origin;
      var oldCapacity = list._capacity;
      var newOrigin = oldOrigin + begin;
      var newCapacity =
        end === undefined
          ? oldCapacity
          : end < 0
          ? oldCapacity + end
          : oldOrigin + end;
      if (newOrigin === oldOrigin && newCapacity === oldCapacity) {
        return list;
      }

      // If it's going to end after it starts, it's empty.
      if (newOrigin >= newCapacity) {
        return list.clear();
      }

      var newLevel = list._level;
      var newRoot = list._root;

      // New origin might need creating a higher root.
      var offsetShift = 0;
      while (newOrigin + offsetShift < 0) {
        newRoot = new VNode(
          newRoot && newRoot.array.length ? [undefined, newRoot] : [],
          owner
        );
        newLevel += SHIFT;
        offsetShift += 1 << newLevel;
      }
      if (offsetShift) {
        newOrigin += offsetShift;
        oldOrigin += offsetShift;
        newCapacity += offsetShift;
        oldCapacity += offsetShift;
      }

      var oldTailOffset = getTailOffset(oldCapacity);
      var newTailOffset = getTailOffset(newCapacity);

      // New size might need creating a higher root.
      while (newTailOffset >= 1 << (newLevel + SHIFT)) {
        newRoot = new VNode(
          newRoot && newRoot.array.length ? [newRoot] : [],
          owner
        );
        newLevel += SHIFT;
      }

      // Locate or create the new tail.
      var oldTail = list._tail;
      var newTail =
        newTailOffset < oldTailOffset
          ? listNodeFor(list, newCapacity - 1)
          : newTailOffset > oldTailOffset
          ? new VNode([], owner)
          : oldTail;

      // Merge Tail into tree.
      if (
        oldTail &&
        newTailOffset > oldTailOffset &&
        newOrigin < oldCapacity &&
        oldTail.array.length
      ) {
        newRoot = editableVNode(newRoot, owner);
        var node = newRoot;
        for (var level = newLevel; level > SHIFT; level -= SHIFT) {
          var idx = (oldTailOffset >>> level) & MASK;
          node = node.array[idx] = editableVNode(node.array[idx], owner);
        }
        node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;
      }

      // If the size has been reduced, there's a chance the tail needs to be trimmed.
      if (newCapacity < oldCapacity) {
        newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);
      }

      // If the new origin is within the tail, then we do not need a root.
      if (newOrigin >= newTailOffset) {
        newOrigin -= newTailOffset;
        newCapacity -= newTailOffset;
        newLevel = SHIFT;
        newRoot = null;
        newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);

        // Otherwise, if the root has been trimmed, garbage collect.
      } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {
        offsetShift = 0;

        // Identify the new top root node of the subtree of the old root.
        while (newRoot) {
          var beginIndex = (newOrigin >>> newLevel) & MASK;
          if ((beginIndex !== newTailOffset >>> newLevel) & MASK) {
            break;
          }
          if (beginIndex) {
            offsetShift += (1 << newLevel) * beginIndex;
          }
          newLevel -= SHIFT;
          newRoot = newRoot.array[beginIndex];
        }

        // Trim the new sides of the new root.
        if (newRoot && newOrigin > oldOrigin) {
          newRoot = newRoot.removeBefore(
            owner,
            newLevel,
            newOrigin - offsetShift
          );
        }
        if (newRoot && newTailOffset < oldTailOffset) {
          newRoot = newRoot.removeAfter(
            owner,
            newLevel,
            newTailOffset - offsetShift
          );
        }
        if (offsetShift) {
          newOrigin -= offsetShift;
          newCapacity -= offsetShift;
        }
      }

      if (list.__ownerID) {
        list.size = newCapacity - newOrigin;
        list._origin = newOrigin;
        list._capacity = newCapacity;
        list._level = newLevel;
        list._root = newRoot;
        list._tail = newTail;
        list.__hash = undefined;
        list.__altered = true;
        return list;
      }
      return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);
    }

    function mergeIntoListWith(list, merger, iterables) {
      var iters = [];
      var maxSize = 0;
      for (var ii = 0; ii < iterables.length; ii++) {
        var value = iterables[ii];
        var iter = IndexedIterable(value);
        if (iter.size > maxSize) {
          maxSize = iter.size;
        }
        if (!isIterable(value)) {
          iter = iter.map(function(v) {
            return fromJS(v);
          });
        }
        iters.push(iter);
      }
      if (maxSize > list.size) {
        list = list.setSize(maxSize);
      }
      return mergeIntoCollectionWith(list, merger, iters);
    }

    function getTailOffset(size) {
      return size < SIZE ? 0 : ((size - 1) >>> SHIFT) << SHIFT;
    }

    createClass(OrderedMap, Map);

    // @pragma Construction

    function OrderedMap(value) {
      return value === null || value === undefined
        ? emptyOrderedMap()
        : isOrderedMap(value)
        ? value
        : emptyOrderedMap().withMutations(function(map) {
            var iter = KeyedIterable(value);
            assertNotInfinite(iter.size);
            iter.forEach(function(v, k) {
              return map.set(k, v);
            });
          });
    }

    OrderedMap.of = function(/*...values*/) {
      return this(arguments);
    };

    OrderedMap.prototype.toString = function() {
      return this.__toString("OrderedMap {", "}");
    };

    // @pragma Access

    OrderedMap.prototype.get = function(k, notSetValue) {
      var index = this._map.get(k);
      return index !== undefined ? this._list.get(index)[1] : notSetValue;
    };

    // @pragma Modification

    OrderedMap.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = 0;
        this._map.clear();
        this._list.clear();
        return this;
      }
      return emptyOrderedMap();
    };

    OrderedMap.prototype.set = function(k, v) {
      return updateOrderedMap(this, k, v);
    };

    OrderedMap.prototype.remove = function(k) {
      return updateOrderedMap(this, k, NOT_SET);
    };

    OrderedMap.prototype.wasAltered = function() {
      return this._map.wasAltered() || this._list.wasAltered();
    };

    OrderedMap.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      return this._list.__iterate(function(entry) {
        return entry && fn(entry[1], entry[0], this$0);
      }, reverse);
    };

    OrderedMap.prototype.__iterator = function(type, reverse) {
      return this._list.fromEntrySeq().__iterator(type, reverse);
    };

    OrderedMap.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      var newMap = this._map.__ensureOwner(ownerID);
      var newList = this._list.__ensureOwner(ownerID);
      if (!ownerID) {
        this.__ownerID = ownerID;
        this._map = newMap;
        this._list = newList;
        return this;
      }
      return makeOrderedMap(newMap, newList, ownerID, this.__hash);
    };

    function isOrderedMap(maybeOrderedMap) {
      return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);
    }

    OrderedMap.isOrderedMap = isOrderedMap;

    OrderedMap.prototype[IS_ORDERED_SENTINEL] = true;
    OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;

    function makeOrderedMap(map, list, ownerID, hash) {
      var omap = Object.create(OrderedMap.prototype);
      omap.size = map ? map.size : 0;
      omap._map = map;
      omap._list = list;
      omap.__ownerID = ownerID;
      omap.__hash = hash;
      return omap;
    }

    var EMPTY_ORDERED_MAP;
    function emptyOrderedMap() {
      return (
        EMPTY_ORDERED_MAP ||
        (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()))
      );
    }

    function updateOrderedMap(omap, k, v) {
      var map = omap._map;
      var list = omap._list;
      var i = map.get(k);
      var has = i !== undefined;
      var newMap;
      var newList;
      if (v === NOT_SET) {
        // removed
        if (!has) {
          return omap;
        }
        if (list.size >= SIZE && list.size >= map.size * 2) {
          newList = list.filter(function(entry, idx) {
            return entry !== undefined && i !== idx;
          });
          newMap = newList
            .toKeyedSeq()
            .map(function(entry) {
              return entry[0];
            })
            .flip()
            .toMap();
          if (omap.__ownerID) {
            newMap.__ownerID = newList.__ownerID = omap.__ownerID;
          }
        } else {
          newMap = map.remove(k);
          newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);
        }
      } else {
        if (has) {
          if (v === list.get(i)[1]) {
            return omap;
          }
          newMap = map;
          newList = list.set(i, [k, v]);
        } else {
          newMap = map.set(k, list.size);
          newList = list.set(list.size, [k, v]);
        }
      }
      if (omap.__ownerID) {
        omap.size = newMap.size;
        omap._map = newMap;
        omap._list = newList;
        omap.__hash = undefined;
        return omap;
      }
      return makeOrderedMap(newMap, newList);
    }

    createClass(ToKeyedSequence, KeyedSeq);
    function ToKeyedSequence(indexed, useKeys) {
      this._iter = indexed;
      this._useKeys = useKeys;
      this.size = indexed.size;
    }

    ToKeyedSequence.prototype.get = function(key, notSetValue) {
      return this._iter.get(key, notSetValue);
    };

    ToKeyedSequence.prototype.has = function(key) {
      return this._iter.has(key);
    };

    ToKeyedSequence.prototype.valueSeq = function() {
      return this._iter.valueSeq();
    };

    ToKeyedSequence.prototype.reverse = function() {
      var this$0 = this;
      var reversedSequence = reverseFactory(this, true);
      if (!this._useKeys) {
        reversedSequence.valueSeq = function() {
          return this$0._iter.toSeq().reverse();
        };
      }
      return reversedSequence;
    };

    ToKeyedSequence.prototype.map = function(mapper, context) {
      var this$0 = this;
      var mappedSequence = mapFactory(this, mapper, context);
      if (!this._useKeys) {
        mappedSequence.valueSeq = function() {
          return this$0._iter.toSeq().map(mapper, context);
        };
      }
      return mappedSequence;
    };

    ToKeyedSequence.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      var ii;
      return this._iter.__iterate(
        this._useKeys
          ? function(v, k) {
              return fn(v, k, this$0);
            }
          : ((ii = reverse ? resolveSize(this) : 0),
            function(v) {
              return fn(v, reverse ? --ii : ii++, this$0);
            }),
        reverse
      );
    };

    ToKeyedSequence.prototype.__iterator = function(type, reverse) {
      if (this._useKeys) {
        return this._iter.__iterator(type, reverse);
      }
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      var ii = reverse ? resolveSize(this) : 0;
      return new Iterator(function() {
        var step = iterator.next();
        return step.done
          ? step
          : iteratorValue(type, reverse ? --ii : ii++, step.value, step);
      });
    };

    ToKeyedSequence.prototype[IS_ORDERED_SENTINEL] = true;

    createClass(ToIndexedSequence, IndexedSeq);
    function ToIndexedSequence(iter) {
      this._iter = iter;
      this.size = iter.size;
    }

    ToIndexedSequence.prototype.includes = function(value) {
      return this._iter.includes(value);
    };

    ToIndexedSequence.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      var iterations = 0;
      return this._iter.__iterate(function(v) {
        return fn(v, iterations++, this$0);
      }, reverse);
    };

    ToIndexedSequence.prototype.__iterator = function(type, reverse) {
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      var iterations = 0;
      return new Iterator(function() {
        var step = iterator.next();
        return step.done
          ? step
          : iteratorValue(type, iterations++, step.value, step);
      });
    };

    createClass(ToSetSequence, SetSeq);
    function ToSetSequence(iter) {
      this._iter = iter;
      this.size = iter.size;
    }

    ToSetSequence.prototype.has = function(key) {
      return this._iter.includes(key);
    };

    ToSetSequence.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      return this._iter.__iterate(function(v) {
        return fn(v, v, this$0);
      }, reverse);
    };

    ToSetSequence.prototype.__iterator = function(type, reverse) {
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      return new Iterator(function() {
        var step = iterator.next();
        return step.done
          ? step
          : iteratorValue(type, step.value, step.value, step);
      });
    };

    createClass(FromEntriesSequence, KeyedSeq);
    function FromEntriesSequence(entries) {
      this._iter = entries;
      this.size = entries.size;
    }

    FromEntriesSequence.prototype.entrySeq = function() {
      return this._iter.toSeq();
    };

    FromEntriesSequence.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      return this._iter.__iterate(function(entry) {
        // Check if entry exists first so array access doesn't throw for holes
        // in the parent iteration.
        if (entry) {
          validateEntry(entry);
          var indexedIterable = isIterable(entry);
          return fn(
            indexedIterable ? entry.get(1) : entry[1],
            indexedIterable ? entry.get(0) : entry[0],
            this$0
          );
        }
      }, reverse);
    };

    FromEntriesSequence.prototype.__iterator = function(type, reverse) {
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      return new Iterator(function() {
        while (true) {
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          var entry = step.value;
          // Check if entry exists first so array access doesn't throw for holes
          // in the parent iteration.
          if (entry) {
            validateEntry(entry);
            var indexedIterable = isIterable(entry);
            return iteratorValue(
              type,
              indexedIterable ? entry.get(0) : entry[0],
              indexedIterable ? entry.get(1) : entry[1],
              step
            );
          }
        }
      });
    };

    ToIndexedSequence.prototype.cacheResult = ToKeyedSequence.prototype.cacheResult = ToSetSequence.prototype.cacheResult = FromEntriesSequence.prototype.cacheResult = cacheResultThrough;

    function flipFactory(iterable) {
      var flipSequence = makeSequence(iterable);
      flipSequence._iter = iterable;
      flipSequence.size = iterable.size;
      flipSequence.flip = function() {
        return iterable;
      };
      flipSequence.reverse = function() {
        var reversedSequence = iterable.reverse.apply(this); // super.reverse()
        reversedSequence.flip = function() {
          return iterable.reverse();
        };
        return reversedSequence;
      };
      flipSequence.has = function(key) {
        return iterable.includes(key);
      };
      flipSequence.includes = function(key) {
        return iterable.has(key);
      };
      flipSequence.cacheResult = cacheResultThrough;
      flipSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        return iterable.__iterate(function(v, k) {
          return fn(k, v, this$0) !== false;
        }, reverse);
      };
      flipSequence.__iteratorUncached = function(type, reverse) {
        if (type === ITERATE_ENTRIES) {
          var iterator = iterable.__iterator(type, reverse);
          return new Iterator(function() {
            var step = iterator.next();
            if (!step.done) {
              var k = step.value[0];
              step.value[0] = step.value[1];
              step.value[1] = k;
            }
            return step;
          });
        }
        return iterable.__iterator(
          type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,
          reverse
        );
      };
      return flipSequence;
    }

    function mapFactory(iterable, mapper, context) {
      var mappedSequence = makeSequence(iterable);
      mappedSequence.size = iterable.size;
      mappedSequence.has = function(key) {
        return iterable.has(key);
      };
      mappedSequence.get = function(key, notSetValue) {
        var v = iterable.get(key, NOT_SET);
        return v === NOT_SET
          ? notSetValue
          : mapper.call(context, v, key, iterable);
      };
      mappedSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        return iterable.__iterate(function(v, k, c) {
          return fn(mapper.call(context, v, k, c), k, this$0) !== false;
        }, reverse);
      };
      mappedSequence.__iteratorUncached = function(type, reverse) {
        var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
        return new Iterator(function() {
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          var entry = step.value;
          var key = entry[0];
          return iteratorValue(
            type,
            key,
            mapper.call(context, entry[1], key, iterable),
            step
          );
        });
      };
      return mappedSequence;
    }

    function reverseFactory(iterable, useKeys) {
      var reversedSequence = makeSequence(iterable);
      reversedSequence._iter = iterable;
      reversedSequence.size = iterable.size;
      reversedSequence.reverse = function() {
        return iterable;
      };
      if (iterable.flip) {
        reversedSequence.flip = function() {
          var flipSequence = flipFactory(iterable);
          flipSequence.reverse = function() {
            return iterable.flip();
          };
          return flipSequence;
        };
      }
      reversedSequence.get = function(key, notSetValue) {
        return iterable.get(useKeys ? key : -1 - key, notSetValue);
      };
      reversedSequence.has = function(key) {
        return iterable.has(useKeys ? key : -1 - key);
      };
      reversedSequence.includes = function(value) {
        return iterable.includes(value);
      };
      reversedSequence.cacheResult = cacheResultThrough;
      reversedSequence.__iterate = function(fn, reverse) {
        var this$0 = this;
        return iterable.__iterate(function(v, k) {
          return fn(v, k, this$0);
        }, !reverse);
      };
      reversedSequence.__iterator = function(type, reverse) {
        return iterable.__iterator(type, !reverse);
      };
      return reversedSequence;
    }

    function filterFactory(iterable, predicate, context, useKeys) {
      var filterSequence = makeSequence(iterable);
      if (useKeys) {
        filterSequence.has = function(key) {
          var v = iterable.get(key, NOT_SET);
          return v !== NOT_SET && !!predicate.call(context, v, key, iterable);
        };
        filterSequence.get = function(key, notSetValue) {
          var v = iterable.get(key, NOT_SET);
          return v !== NOT_SET && predicate.call(context, v, key, iterable)
            ? v
            : notSetValue;
        };
      }
      filterSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        var iterations = 0;
        iterable.__iterate(function(v, k, c) {
          if (predicate.call(context, v, k, c)) {
            iterations++;
            return fn(v, useKeys ? k : iterations - 1, this$0);
          }
        }, reverse);
        return iterations;
      };
      filterSequence.__iteratorUncached = function(type, reverse) {
        var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
        var iterations = 0;
        return new Iterator(function() {
          while (true) {
            var step = iterator.next();
            if (step.done) {
              return step;
            }
            var entry = step.value;
            var key = entry[0];
            var value = entry[1];
            if (predicate.call(context, value, key, iterable)) {
              return iteratorValue(
                type,
                useKeys ? key : iterations++,
                value,
                step
              );
            }
          }
        });
      };
      return filterSequence;
    }

    function countByFactory(iterable, grouper, context) {
      var groups = Map().asMutable();
      iterable.__iterate(function(v, k) {
        groups.update(grouper.call(context, v, k, iterable), 0, function(a) {
          return a + 1;
        });
      });
      return groups.asImmutable();
    }

    function groupByFactory(iterable, grouper, context) {
      var isKeyedIter = isKeyed(iterable);
      var groups = (isOrdered(iterable) ? OrderedMap() : Map()).asMutable();
      iterable.__iterate(function(v, k) {
        groups.update(grouper.call(context, v, k, iterable), function(a) {
          return (a = a || []), a.push(isKeyedIter ? [k, v] : v), a;
        });
      });
      var coerce = iterableClass(iterable);
      return groups.map(function(arr) {
        return reify(iterable, coerce(arr));
      });
    }

    function sliceFactory(iterable, begin, end, useKeys) {
      var originalSize = iterable.size;

      // Sanitize begin & end using this shorthand for ToInt32(argument)
      // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
      if (begin !== undefined) {
        begin = begin | 0;
      }
      if (end !== undefined) {
        end = end | 0;
      }

      if (wholeSlice(begin, end, originalSize)) {
        return iterable;
      }

      var resolvedBegin = resolveBegin(begin, originalSize);
      var resolvedEnd = resolveEnd(end, originalSize);

      // begin or end will be NaN if they were provided as negative numbers and
      // this iterable's size is unknown. In that case, cache first so there is
      // a known size and these do not resolve to NaN.
      if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {
        return sliceFactory(
          iterable.toSeq().cacheResult(),
          begin,
          end,
          useKeys
        );
      }

      // Note: resolvedEnd is undefined when the original sequence's length is
      // unknown and this slice did not supply an end and should contain all
      // elements after resolvedBegin.
      // In that case, resolvedSize will be NaN and sliceSize will remain undefined.
      var resolvedSize = resolvedEnd - resolvedBegin;
      var sliceSize;
      if (resolvedSize === resolvedSize) {
        sliceSize = resolvedSize < 0 ? 0 : resolvedSize;
      }

      var sliceSeq = makeSequence(iterable);

      // If iterable.size is undefined, the size of the realized sliceSeq is
      // unknown at this point unless the number of items to slice is 0
      sliceSeq.size =
        sliceSize === 0 ? sliceSize : (iterable.size && sliceSize) || undefined;

      if (!useKeys && isSeq(iterable) && sliceSize >= 0) {
        sliceSeq.get = function(index, notSetValue) {
          index = wrapIndex(this, index);
          return index >= 0 && index < sliceSize
            ? iterable.get(index + resolvedBegin, notSetValue)
            : notSetValue;
        };
      }

      sliceSeq.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        if (sliceSize === 0) {
          return 0;
        }
        if (reverse) {
          return this.cacheResult().__iterate(fn, reverse);
        }
        var skipped = 0;
        var isSkipping = true;
        var iterations = 0;
        iterable.__iterate(function(v, k) {
          if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {
            iterations++;
            return (
              fn(v, useKeys ? k : iterations - 1, this$0) !== false &&
              iterations !== sliceSize
            );
          }
        });
        return iterations;
      };

      sliceSeq.__iteratorUncached = function(type, reverse) {
        if (sliceSize !== 0 && reverse) {
          return this.cacheResult().__iterator(type, reverse);
        }
        // Don't bother instantiating parent iterator if taking 0.
        var iterator = sliceSize !== 0 && iterable.__iterator(type, reverse);
        var skipped = 0;
        var iterations = 0;
        return new Iterator(function() {
          while (skipped++ < resolvedBegin) {
            iterator.next();
          }
          if (++iterations > sliceSize) {
            return iteratorDone();
          }
          var step = iterator.next();
          if (useKeys || type === ITERATE_VALUES) {
            return step;
          } else if (type === ITERATE_KEYS) {
            return iteratorValue(type, iterations - 1, undefined, step);
          } else {
            return iteratorValue(type, iterations - 1, step.value[1], step);
          }
        });
      };

      return sliceSeq;
    }

    function takeWhileFactory(iterable, predicate, context) {
      var takeSequence = makeSequence(iterable);
      takeSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        if (reverse) {
          return this.cacheResult().__iterate(fn, reverse);
        }
        var iterations = 0;
        iterable.__iterate(function(v, k, c) {
          return (
            predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$0)
          );
        });
        return iterations;
      };
      takeSequence.__iteratorUncached = function(type, reverse) {
        var this$0 = this;
        if (reverse) {
          return this.cacheResult().__iterator(type, reverse);
        }
        var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
        var iterating = true;
        return new Iterator(function() {
          if (!iterating) {
            return iteratorDone();
          }
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          var entry = step.value;
          var k = entry[0];
          var v = entry[1];
          if (!predicate.call(context, v, k, this$0)) {
            iterating = false;
            return iteratorDone();
          }
          return type === ITERATE_ENTRIES
            ? step
            : iteratorValue(type, k, v, step);
        });
      };
      return takeSequence;
    }

    function skipWhileFactory(iterable, predicate, context, useKeys) {
      var skipSequence = makeSequence(iterable);
      skipSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        if (reverse) {
          return this.cacheResult().__iterate(fn, reverse);
        }
        var isSkipping = true;
        var iterations = 0;
        iterable.__iterate(function(v, k, c) {
          if (
            !(isSkipping && (isSkipping = predicate.call(context, v, k, c)))
          ) {
            iterations++;
            return fn(v, useKeys ? k : iterations - 1, this$0);
          }
        });
        return iterations;
      };
      skipSequence.__iteratorUncached = function(type, reverse) {
        var this$0 = this;
        if (reverse) {
          return this.cacheResult().__iterator(type, reverse);
        }
        var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
        var skipping = true;
        var iterations = 0;
        return new Iterator(function() {
          var step, k, v;
          do {
            step = iterator.next();
            if (step.done) {
              if (useKeys || type === ITERATE_VALUES) {
                return step;
              } else if (type === ITERATE_KEYS) {
                return iteratorValue(type, iterations++, undefined, step);
              } else {
                return iteratorValue(type, iterations++, step.value[1], step);
              }
            }
            var entry = step.value;
            k = entry[0];
            v = entry[1];
            skipping && (skipping = predicate.call(context, v, k, this$0));
          } while (skipping);
          return type === ITERATE_ENTRIES
            ? step
            : iteratorValue(type, k, v, step);
        });
      };
      return skipSequence;
    }

    function concatFactory(iterable, values) {
      var isKeyedIterable = isKeyed(iterable);
      var iters = [iterable]
        .concat(values)
        .map(function(v) {
          if (!isIterable(v)) {
            v = isKeyedIterable
              ? keyedSeqFromValue(v)
              : indexedSeqFromValue(Array.isArray(v) ? v : [v]);
          } else if (isKeyedIterable) {
            v = KeyedIterable(v);
          }
          return v;
        })
        .filter(function(v) {
          return v.size !== 0;
        });

      if (iters.length === 0) {
        return iterable;
      }

      if (iters.length === 1) {
        var singleton = iters[0];
        if (
          singleton === iterable ||
          (isKeyedIterable && isKeyed(singleton)) ||
          (isIndexed(iterable) && isIndexed(singleton))
        ) {
          return singleton;
        }
      }

      var concatSeq = new ArraySeq(iters);
      if (isKeyedIterable) {
        concatSeq = concatSeq.toKeyedSeq();
      } else if (!isIndexed(iterable)) {
        concatSeq = concatSeq.toSetSeq();
      }
      concatSeq = concatSeq.flatten(true);
      concatSeq.size = iters.reduce(function(sum, seq) {
        if (sum !== undefined) {
          var size = seq.size;
          if (size !== undefined) {
            return sum + size;
          }
        }
      }, 0);
      return concatSeq;
    }

    function flattenFactory(iterable, depth, useKeys) {
      var flatSequence = makeSequence(iterable);
      flatSequence.__iterateUncached = function(fn, reverse) {
        var iterations = 0;
        var stopped = false;
        function flatDeep(iter, currentDepth) {
          var this$0 = this;
          iter.__iterate(function(v, k) {
            if ((!depth || currentDepth < depth) && isIterable(v)) {
              flatDeep(v, currentDepth + 1);
            } else if (fn(v, useKeys ? k : iterations++, this$0) === false) {
              stopped = true;
            }
            return !stopped;
          }, reverse);
        }
        flatDeep(iterable, 0);
        return iterations;
      };
      flatSequence.__iteratorUncached = function(type, reverse) {
        var iterator = iterable.__iterator(type, reverse);
        var stack = [];
        var iterations = 0;
        return new Iterator(function() {
          while (iterator) {
            var step = iterator.next();
            if (step.done !== false) {
              iterator = stack.pop();
              continue;
            }
            var v = step.value;
            if (type === ITERATE_ENTRIES) {
              v = v[1];
            }
            if ((!depth || stack.length < depth) && isIterable(v)) {
              stack.push(iterator);
              iterator = v.__iterator(type, reverse);
            } else {
              return useKeys
                ? step
                : iteratorValue(type, iterations++, v, step);
            }
          }
          return iteratorDone();
        });
      };
      return flatSequence;
    }

    function flatMapFactory(iterable, mapper, context) {
      var coerce = iterableClass(iterable);
      return iterable
        .toSeq()
        .map(function(v, k) {
          return coerce(mapper.call(context, v, k, iterable));
        })
        .flatten(true);
    }

    function interposeFactory(iterable, separator) {
      var interposedSequence = makeSequence(iterable);
      interposedSequence.size = iterable.size && iterable.size * 2 - 1;
      interposedSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        var iterations = 0;
        iterable.__iterate(function(v, k) {
          return (
            (!iterations || fn(separator, iterations++, this$0) !== false) &&
            fn(v, iterations++, this$0) !== false
          );
        }, reverse);
        return iterations;
      };
      interposedSequence.__iteratorUncached = function(type, reverse) {
        var iterator = iterable.__iterator(ITERATE_VALUES, reverse);
        var iterations = 0;
        var step;
        return new Iterator(function() {
          if (!step || iterations % 2) {
            step = iterator.next();
            if (step.done) {
              return step;
            }
          }
          return iterations % 2
            ? iteratorValue(type, iterations++, separator)
            : iteratorValue(type, iterations++, step.value, step);
        });
      };
      return interposedSequence;
    }

    function sortFactory(iterable, comparator, mapper) {
      if (!comparator) {
        comparator = defaultComparator;
      }
      var isKeyedIterable = isKeyed(iterable);
      var index = 0;
      var entries = iterable
        .toSeq()
        .map(function(v, k) {
          return [k, v, index++, mapper ? mapper(v, k, iterable) : v];
        })
        .toArray();
      entries
        .sort(function(a, b) {
          return comparator(a[3], b[3]) || a[2] - b[2];
        })
        .forEach(
          isKeyedIterable
            ? function(v, i) {
                entries[i].length = 2;
              }
            : function(v, i) {
                entries[i] = v[1];
              }
        );
      return isKeyedIterable
        ? KeyedSeq(entries)
        : isIndexed(iterable)
        ? IndexedSeq(entries)
        : SetSeq(entries);
    }

    function maxFactory(iterable, comparator, mapper) {
      if (!comparator) {
        comparator = defaultComparator;
      }
      if (mapper) {
        var entry = iterable
          .toSeq()
          .map(function(v, k) {
            return [v, mapper(v, k, iterable)];
          })
          .reduce(function(a, b) {
            return maxCompare(comparator, a[1], b[1]) ? b : a;
          });
        return entry && entry[0];
      } else {
        return iterable.reduce(function(a, b) {
          return maxCompare(comparator, a, b) ? b : a;
        });
      }
    }

    function maxCompare(comparator, a, b) {
      var comp = comparator(b, a);
      // b is considered the new max if the comparator declares them equal, but
      // they are not equal and b is in fact a nullish value.
      return (
        (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) ||
        comp > 0
      );
    }

    function zipWithFactory(keyIter, zipper, iters) {
      var zipSequence = makeSequence(keyIter);
      zipSequence.size = new ArraySeq(iters)
        .map(function(i) {
          return i.size;
        })
        .min();
      // Note: this a generic base implementation of __iterate in terms of
      // __iterator which may be more generically useful in the future.
      zipSequence.__iterate = function(fn, reverse) {
        /* generic:
      var iterator = this.__iterator(ITERATE_ENTRIES, reverse);
      var step;
      var iterations = 0;
      while (!(step = iterator.next()).done) {
        iterations++;
        if (fn(step.value[1], step.value[0], this) === false) {
          break;
        }
      }
      return iterations;
      */
        // indexed:
        var iterator = this.__iterator(ITERATE_VALUES, reverse);
        var step;
        var iterations = 0;
        while (!(step = iterator.next()).done) {
          if (fn(step.value, iterations++, this) === false) {
            break;
          }
        }
        return iterations;
      };
      zipSequence.__iteratorUncached = function(type, reverse) {
        var iterators = iters.map(function(i) {
          return (i = Iterable(i)), getIterator(reverse ? i.reverse() : i);
        });
        var iterations = 0;
        var isDone = false;
        return new Iterator(function() {
          var steps;
          if (!isDone) {
            steps = iterators.map(function(i) {
              return i.next();
            });
            isDone = steps.some(function(s) {
              return s.done;
            });
          }
          if (isDone) {
            return iteratorDone();
          }
          return iteratorValue(
            type,
            iterations++,
            zipper.apply(
              null,
              steps.map(function(s) {
                return s.value;
              })
            )
          );
        });
      };
      return zipSequence;
    }

    // #pragma Helper Functions

    function reify(iter, seq) {
      return isSeq(iter) ? seq : iter.constructor(seq);
    }

    function validateEntry(entry) {
      if (entry !== Object(entry)) {
        throw new TypeError("Expected [K, V] tuple: " + entry);
      }
    }

    function resolveSize(iter) {
      assertNotInfinite(iter.size);
      return ensureSize(iter);
    }

    function iterableClass(iterable) {
      return isKeyed(iterable)
        ? KeyedIterable
        : isIndexed(iterable)
        ? IndexedIterable
        : SetIterable;
    }

    function makeSequence(iterable) {
      return Object.create(
        (isKeyed(iterable)
          ? KeyedSeq
          : isIndexed(iterable)
          ? IndexedSeq
          : SetSeq
        ).prototype
      );
    }

    function cacheResultThrough() {
      if (this._iter.cacheResult) {
        this._iter.cacheResult();
        this.size = this._iter.size;
        return this;
      } else {
        return Seq.prototype.cacheResult.call(this);
      }
    }

    function defaultComparator(a, b) {
      return a > b ? 1 : a < b ? -1 : 0;
    }

    function forceIterator(keyPath) {
      var iter = getIterator(keyPath);
      if (!iter) {
        // Array might not be iterable in this environment, so we need a fallback
        // to our wrapped type.
        if (!isArrayLike(keyPath)) {
          throw new TypeError("Expected iterable or array-like: " + keyPath);
        }
        iter = getIterator(Iterable(keyPath));
      }
      return iter;
    }

    createClass(Record, KeyedCollection);

    function Record(defaultValues, name) {
      var hasInitialized;

      var RecordType = function Record(values) {
        if (values instanceof RecordType) {
          return values;
        }
        if (!(this instanceof RecordType)) {
          return new RecordType(values);
        }
        if (!hasInitialized) {
          hasInitialized = true;
          var keys = Object.keys(defaultValues);
          setProps(RecordTypePrototype, keys);
          RecordTypePrototype.size = keys.length;
          RecordTypePrototype._name = name;
          RecordTypePrototype._keys = keys;
          RecordTypePrototype._defaultValues = defaultValues;
        }
        this._map = Map(values);
      };

      var RecordTypePrototype = (RecordType.prototype = Object.create(
        RecordPrototype
      ));
      RecordTypePrototype.constructor = RecordType;

      return RecordType;
    }

    Record.prototype.toString = function() {
      return this.__toString(recordName(this) + " {", "}");
    };

    // @pragma Access

    Record.prototype.has = function(k) {
      return this._defaultValues.hasOwnProperty(k);
    };

    Record.prototype.get = function(k, notSetValue) {
      if (!this.has(k)) {
        return notSetValue;
      }
      var defaultVal = this._defaultValues[k];
      return this._map ? this._map.get(k, defaultVal) : defaultVal;
    };

    // @pragma Modification

    Record.prototype.clear = function() {
      if (this.__ownerID) {
        this._map && this._map.clear();
        return this;
      }
      var RecordType = this.constructor;
      return (
        RecordType._empty || (RecordType._empty = makeRecord(this, emptyMap()))
      );
    };

    Record.prototype.set = function(k, v) {
      if (!this.has(k)) {
        throw new Error(
          'Cannot set unknown key "' + k + '" on ' + recordName(this)
        );
      }
      var newMap = this._map && this._map.set(k, v);
      if (this.__ownerID || newMap === this._map) {
        return this;
      }
      return makeRecord(this, newMap);
    };

    Record.prototype.remove = function(k) {
      if (!this.has(k)) {
        return this;
      }
      var newMap = this._map && this._map.remove(k);
      if (this.__ownerID || newMap === this._map) {
        return this;
      }
      return makeRecord(this, newMap);
    };

    Record.prototype.wasAltered = function() {
      return this._map.wasAltered();
    };

    Record.prototype.__iterator = function(type, reverse) {
      var this$0 = this;
      return KeyedIterable(this._defaultValues)
        .map(function(_, k) {
          return this$0.get(k);
        })
        .__iterator(type, reverse);
    };

    Record.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      return KeyedIterable(this._defaultValues)
        .map(function(_, k) {
          return this$0.get(k);
        })
        .__iterate(fn, reverse);
    };

    Record.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      var newMap = this._map && this._map.__ensureOwner(ownerID);
      if (!ownerID) {
        this.__ownerID = ownerID;
        this._map = newMap;
        return this;
      }
      return makeRecord(this, newMap, ownerID);
    };

    var RecordPrototype = Record.prototype;
    RecordPrototype[DELETE] = RecordPrototype.remove;
    RecordPrototype.deleteIn = RecordPrototype.removeIn = MapPrototype.removeIn;
    RecordPrototype.merge = MapPrototype.merge;
    RecordPrototype.mergeWith = MapPrototype.mergeWith;
    RecordPrototype.mergeIn = MapPrototype.mergeIn;
    RecordPrototype.mergeDeep = MapPrototype.mergeDeep;
    RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith;
    RecordPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;
    RecordPrototype.setIn = MapPrototype.setIn;
    RecordPrototype.update = MapPrototype.update;
    RecordPrototype.updateIn = MapPrototype.updateIn;
    RecordPrototype.withMutations = MapPrototype.withMutations;
    RecordPrototype.asMutable = MapPrototype.asMutable;
    RecordPrototype.asImmutable = MapPrototype.asImmutable;

    function makeRecord(likeRecord, map, ownerID) {
      var record = Object.create(Object.getPrototypeOf(likeRecord));
      record._map = map;
      record.__ownerID = ownerID;
      return record;
    }

    function recordName(record) {
      return record._name || record.constructor.name || "Record";
    }

    function setProps(prototype, names) {
      try {
        names.forEach(setProp.bind(undefined, prototype));
      } catch (error) {
        // Object.defineProperty failed. Probably IE8.
      }
    }

    function setProp(prototype, name) {
      Object.defineProperty(prototype, name, {
        get: function() {
          return this.get(name);
        },
        set: function(value) {
          invariant(this.__ownerID, "Cannot set on an immutable record.");
          this.set(name, value);
        }
      });
    }

    createClass(Set, SetCollection);

    // @pragma Construction

    function Set(value) {
      return value === null || value === undefined
        ? emptySet()
        : isSet(value) && !isOrdered(value)
        ? value
        : emptySet().withMutations(function(set) {
            var iter = SetIterable(value);
            assertNotInfinite(iter.size);
            iter.forEach(function(v) {
              return set.add(v);
            });
          });
    }

    Set.of = function(/*...values*/) {
      return this(arguments);
    };

    Set.fromKeys = function(value) {
      return this(KeyedIterable(value).keySeq());
    };

    Set.prototype.toString = function() {
      return this.__toString("Set {", "}");
    };

    // @pragma Access

    Set.prototype.has = function(value) {
      return this._map.has(value);
    };

    // @pragma Modification

    Set.prototype.add = function(value) {
      return updateSet(this, this._map.set(value, true));
    };

    Set.prototype.remove = function(value) {
      return updateSet(this, this._map.remove(value));
    };

    Set.prototype.clear = function() {
      return updateSet(this, this._map.clear());
    };

    // @pragma Composition

    Set.prototype.union = function() {
      var iters = SLICE$0.call(arguments, 0);
      iters = iters.filter(function(x) {
        return x.size !== 0;
      });
      if (iters.length === 0) {
        return this;
      }
      if (this.size === 0 && !this.__ownerID && iters.length === 1) {
        return this.constructor(iters[0]);
      }
      return this.withMutations(function(set) {
        for (var ii = 0; ii < iters.length; ii++) {
          SetIterable(iters[ii]).forEach(function(value) {
            return set.add(value);
          });
        }
      });
    };

    Set.prototype.intersect = function() {
      var iters = SLICE$0.call(arguments, 0);
      if (iters.length === 0) {
        return this;
      }
      iters = iters.map(function(iter) {
        return SetIterable(iter);
      });
      var originalSet = this;
      return this.withMutations(function(set) {
        originalSet.forEach(function(value) {
          if (
            !iters.every(function(iter) {
              return iter.includes(value);
            })
          ) {
            set.remove(value);
          }
        });
      });
    };

    Set.prototype.subtract = function() {
      var iters = SLICE$0.call(arguments, 0);
      if (iters.length === 0) {
        return this;
      }
      iters = iters.map(function(iter) {
        return SetIterable(iter);
      });
      var originalSet = this;
      return this.withMutations(function(set) {
        originalSet.forEach(function(value) {
          if (
            iters.some(function(iter) {
              return iter.includes(value);
            })
          ) {
            set.remove(value);
          }
        });
      });
    };

    Set.prototype.merge = function() {
      return this.union.apply(this, arguments);
    };

    Set.prototype.mergeWith = function(merger) {
      var iters = SLICE$0.call(arguments, 1);
      return this.union.apply(this, iters);
    };

    Set.prototype.sort = function(comparator) {
      // Late binding
      return OrderedSet(sortFactory(this, comparator));
    };

    Set.prototype.sortBy = function(mapper, comparator) {
      // Late binding
      return OrderedSet(sortFactory(this, comparator, mapper));
    };

    Set.prototype.wasAltered = function() {
      return this._map.wasAltered();
    };

    Set.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      return this._map.__iterate(function(_, k) {
        return fn(k, k, this$0);
      }, reverse);
    };

    Set.prototype.__iterator = function(type, reverse) {
      return this._map
        .map(function(_, k) {
          return k;
        })
        .__iterator(type, reverse);
    };

    Set.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      var newMap = this._map.__ensureOwner(ownerID);
      if (!ownerID) {
        this.__ownerID = ownerID;
        this._map = newMap;
        return this;
      }
      return this.__make(newMap, ownerID);
    };

    function isSet(maybeSet) {
      return !!(maybeSet && maybeSet[IS_SET_SENTINEL]);
    }

    Set.isSet = isSet;

    var IS_SET_SENTINEL = "@@__IMMUTABLE_SET__@@";

    var SetPrototype = Set.prototype;
    SetPrototype[IS_SET_SENTINEL] = true;
    SetPrototype[DELETE] = SetPrototype.remove;
    SetPrototype.mergeDeep = SetPrototype.merge;
    SetPrototype.mergeDeepWith = SetPrototype.mergeWith;
    SetPrototype.withMutations = MapPrototype.withMutations;
    SetPrototype.asMutable = MapPrototype.asMutable;
    SetPrototype.asImmutable = MapPrototype.asImmutable;

    SetPrototype.__empty = emptySet;
    SetPrototype.__make = makeSet;

    function updateSet(set, newMap) {
      if (set.__ownerID) {
        set.size = newMap.size;
        set._map = newMap;
        return set;
      }
      return newMap === set._map
        ? set
        : newMap.size === 0
        ? set.__empty()
        : set.__make(newMap);
    }

    function makeSet(map, ownerID) {
      var set = Object.create(SetPrototype);
      set.size = map ? map.size : 0;
      set._map = map;
      set.__ownerID = ownerID;
      return set;
    }

    var EMPTY_SET;
    function emptySet() {
      return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));
    }

    createClass(OrderedSet, Set);

    // @pragma Construction

    function OrderedSet(value) {
      return value === null || value === undefined
        ? emptyOrderedSet()
        : isOrderedSet(value)
        ? value
        : emptyOrderedSet().withMutations(function(set) {
            var iter = SetIterable(value);
            assertNotInfinite(iter.size);
            iter.forEach(function(v) {
              return set.add(v);
            });
          });
    }

    OrderedSet.of = function(/*...values*/) {
      return this(arguments);
    };

    OrderedSet.fromKeys = function(value) {
      return this(KeyedIterable(value).keySeq());
    };

    OrderedSet.prototype.toString = function() {
      return this.__toString("OrderedSet {", "}");
    };

    function isOrderedSet(maybeOrderedSet) {
      return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);
    }

    OrderedSet.isOrderedSet = isOrderedSet;

    var OrderedSetPrototype = OrderedSet.prototype;
    OrderedSetPrototype[IS_ORDERED_SENTINEL] = true;

    OrderedSetPrototype.__empty = emptyOrderedSet;
    OrderedSetPrototype.__make = makeOrderedSet;

    function makeOrderedSet(map, ownerID) {
      var set = Object.create(OrderedSetPrototype);
      set.size = map ? map.size : 0;
      set._map = map;
      set.__ownerID = ownerID;
      return set;
    }

    var EMPTY_ORDERED_SET;
    function emptyOrderedSet() {
      return (
        EMPTY_ORDERED_SET ||
        (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()))
      );
    }

    createClass(Stack, IndexedCollection);

    // @pragma Construction

    function Stack(value) {
      return value === null || value === undefined
        ? emptyStack()
        : isStack(value)
        ? value
        : emptyStack().unshiftAll(value);
    }

    Stack.of = function(/*...values*/) {
      return this(arguments);
    };

    Stack.prototype.toString = function() {
      return this.__toString("Stack [", "]");
    };

    // @pragma Access

    Stack.prototype.get = function(index, notSetValue) {
      var head = this._head;
      index = wrapIndex(this, index);
      while (head && index--) {
        head = head.next;
      }
      return head ? head.value : notSetValue;
    };

    Stack.prototype.peek = function() {
      return this._head && this._head.value;
    };

    // @pragma Modification

    Stack.prototype.push = function(/*...values*/) {
      if (arguments.length === 0) {
        return this;
      }
      var newSize = this.size + arguments.length;
      var head = this._head;
      for (var ii = arguments.length - 1; ii >= 0; ii--) {
        head = {
          value: arguments[ii],
          next: head
        };
      }
      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return makeStack(newSize, head);
    };

    Stack.prototype.pushAll = function(iter) {
      iter = IndexedIterable(iter);
      if (iter.size === 0) {
        return this;
      }
      assertNotInfinite(iter.size);
      var newSize = this.size;
      var head = this._head;
      iter.reverse().forEach(function(value) {
        newSize++;
        head = {
          value: value,
          next: head
        };
      });
      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return makeStack(newSize, head);
    };

    Stack.prototype.pop = function() {
      return this.slice(1);
    };

    Stack.prototype.unshift = function(/*...values*/) {
      return this.push.apply(this, arguments);
    };

    Stack.prototype.unshiftAll = function(iter) {
      return this.pushAll(iter);
    };

    Stack.prototype.shift = function() {
      return this.pop.apply(this, arguments);
    };

    Stack.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = 0;
        this._head = undefined;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return emptyStack();
    };

    Stack.prototype.slice = function(begin, end) {
      if (wholeSlice(begin, end, this.size)) {
        return this;
      }
      var resolvedBegin = resolveBegin(begin, this.size);
      var resolvedEnd = resolveEnd(end, this.size);
      if (resolvedEnd !== this.size) {
        // super.slice(begin, end);
        return IndexedCollection.prototype.slice.call(this, begin, end);
      }
      var newSize = this.size - resolvedBegin;
      var head = this._head;
      while (resolvedBegin--) {
        head = head.next;
      }
      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return makeStack(newSize, head);
    };

    // @pragma Mutability

    Stack.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {
        this.__ownerID = ownerID;
        this.__altered = false;
        return this;
      }
      return makeStack(this.size, this._head, ownerID, this.__hash);
    };

    // @pragma Iteration

    Stack.prototype.__iterate = function(fn, reverse) {
      if (reverse) {
        return this.reverse().__iterate(fn);
      }
      var iterations = 0;
      var node = this._head;
      while (node) {
        if (fn(node.value, iterations++, this) === false) {
          break;
        }
        node = node.next;
      }
      return iterations;
    };

    Stack.prototype.__iterator = function(type, reverse) {
      if (reverse) {
        return this.reverse().__iterator(type);
      }
      var iterations = 0;
      var node = this._head;
      return new Iterator(function() {
        if (node) {
          var value = node.value;
          node = node.next;
          return iteratorValue(type, iterations++, value);
        }
        return iteratorDone();
      });
    };

    function isStack(maybeStack) {
      return !!(maybeStack && maybeStack[IS_STACK_SENTINEL]);
    }

    Stack.isStack = isStack;

    var IS_STACK_SENTINEL = "@@__IMMUTABLE_STACK__@@";

    var StackPrototype = Stack.prototype;
    StackPrototype[IS_STACK_SENTINEL] = true;
    StackPrototype.withMutations = MapPrototype.withMutations;
    StackPrototype.asMutable = MapPrototype.asMutable;
    StackPrototype.asImmutable = MapPrototype.asImmutable;
    StackPrototype.wasAltered = MapPrototype.wasAltered;

    function makeStack(size, head, ownerID, hash) {
      var map = Object.create(StackPrototype);
      map.size = size;
      map._head = head;
      map.__ownerID = ownerID;
      map.__hash = hash;
      map.__altered = false;
      return map;
    }

    var EMPTY_STACK;
    function emptyStack() {
      return EMPTY_STACK || (EMPTY_STACK = makeStack(0));
    }

    /**
     * Contributes additional methods to a constructor
     */
    function mixin(ctor, methods) {
      var keyCopier = function(key) {
        ctor.prototype[key] = methods[key];
      };
      Object.keys(methods).forEach(keyCopier);
      Object.getOwnPropertySymbols &&
        Object.getOwnPropertySymbols(methods).forEach(keyCopier);
      return ctor;
    }

    Iterable.Iterator = Iterator;

    mixin(Iterable, {
      // ### Conversion to other types

      toArray: function() {
        assertNotInfinite(this.size);
        var array = new Array(this.size || 0);
        this.valueSeq().__iterate(function(v, i) {
          array[i] = v;
        });
        return array;
      },

      toIndexedSeq: function() {
        return new ToIndexedSequence(this);
      },

      toJS: function() {
        return this.toSeq()
          .map(function(value) {
            return value && typeof value.toJS === "function"
              ? value.toJS()
              : value;
          })
          .__toJS();
      },

      toJSON: function() {
        return this.toSeq()
          .map(function(value) {
            return value && typeof value.toJSON === "function"
              ? value.toJSON()
              : value;
          })
          .__toJS();
      },

      toKeyedSeq: function() {
        return new ToKeyedSequence(this, true);
      },

      toMap: function() {
        // Use Late Binding here to solve the circular dependency.
        return Map(this.toKeyedSeq());
      },

      toObject: function() {
        assertNotInfinite(this.size);
        var object = {};
        this.__iterate(function(v, k) {
          object[k] = v;
        });
        return object;
      },

      toOrderedMap: function() {
        // Use Late Binding here to solve the circular dependency.
        return OrderedMap(this.toKeyedSeq());
      },

      toOrderedSet: function() {
        // Use Late Binding here to solve the circular dependency.
        return OrderedSet(isKeyed(this) ? this.valueSeq() : this);
      },

      toSet: function() {
        // Use Late Binding here to solve the circular dependency.
        return Set(isKeyed(this) ? this.valueSeq() : this);
      },

      toSetSeq: function() {
        return new ToSetSequence(this);
      },

      toSeq: function() {
        return isIndexed(this)
          ? this.toIndexedSeq()
          : isKeyed(this)
          ? this.toKeyedSeq()
          : this.toSetSeq();
      },

      toStack: function() {
        // Use Late Binding here to solve the circular dependency.
        return Stack(isKeyed(this) ? this.valueSeq() : this);
      },

      toList: function() {
        // Use Late Binding here to solve the circular dependency.
        return List(isKeyed(this) ? this.valueSeq() : this);
      },

      // ### Common JavaScript methods and properties

      toString: function() {
        return "[Iterable]";
      },

      __toString: function(head, tail) {
        if (this.size === 0) {
          return head + tail;
        }
        return (
          head +
          " " +
          this.toSeq()
            .map(this.__toStringMapper)
            .join(", ") +
          " " +
          tail
        );
      },

      // ### ES6 Collection methods (ES6 Array and Map)

      concat: function() {
        var values = SLICE$0.call(arguments, 0);
        return reify(this, concatFactory(this, values));
      },

      includes: function(searchValue) {
        return this.some(function(value) {
          return is(value, searchValue);
        });
      },

      entries: function() {
        return this.__iterator(ITERATE_ENTRIES);
      },

      every: function(predicate, context) {
        assertNotInfinite(this.size);
        var returnValue = true;
        this.__iterate(function(v, k, c) {
          if (!predicate.call(context, v, k, c)) {
            returnValue = false;
            return false;
          }
        });
        return returnValue;
      },

      filter: function(predicate, context) {
        return reify(this, filterFactory(this, predicate, context, true));
      },

      find: function(predicate, context, notSetValue) {
        var entry = this.findEntry(predicate, context);
        return entry ? entry[1] : notSetValue;
      },

      findEntry: function(predicate, context) {
        var found;
        this.__iterate(function(v, k, c) {
          if (predicate.call(context, v, k, c)) {
            found = [k, v];
            return false;
          }
        });
        return found;
      },

      findLastEntry: function(predicate, context) {
        return this.toSeq()
          .reverse()
          .findEntry(predicate, context);
      },

      forEach: function(sideEffect, context) {
        assertNotInfinite(this.size);
        return this.__iterate(context ? sideEffect.bind(context) : sideEffect);
      },

      join: function(separator) {
        assertNotInfinite(this.size);
        separator = separator !== undefined ? "" + separator : ",";
        var joined = "";
        var isFirst = true;
        this.__iterate(function(v) {
          isFirst ? (isFirst = false) : (joined += separator);
          joined += v !== null && v !== undefined ? v.toString() : "";
        });
        return joined;
      },

      keys: function() {
        return this.__iterator(ITERATE_KEYS);
      },

      map: function(mapper, context) {
        return reify(this, mapFactory(this, mapper, context));
      },

      reduce: function(reducer, initialReduction, context) {
        assertNotInfinite(this.size);
        var reduction;
        var useFirst;
        if (arguments.length < 2) {
          useFirst = true;
        } else {
          reduction = initialReduction;
        }
        this.__iterate(function(v, k, c) {
          if (useFirst) {
            useFirst = false;
            reduction = v;
          } else {
            reduction = reducer.call(context, reduction, v, k, c);
          }
        });
        return reduction;
      },

      reduceRight: function(reducer, initialReduction, context) {
        var reversed = this.toKeyedSeq().reverse();
        return reversed.reduce.apply(reversed, arguments);
      },

      reverse: function() {
        return reify(this, reverseFactory(this, true));
      },

      slice: function(begin, end) {
        return reify(this, sliceFactory(this, begin, end, true));
      },

      some: function(predicate, context) {
        return !this.every(not(predicate), context);
      },

      sort: function(comparator) {
        return reify(this, sortFactory(this, comparator));
      },

      values: function() {
        return this.__iterator(ITERATE_VALUES);
      },

      // ### More sequential methods

      butLast: function() {
        return this.slice(0, -1);
      },

      isEmpty: function() {
        return this.size !== undefined
          ? this.size === 0
          : !this.some(function() {
              return true;
            });
      },

      count: function(predicate, context) {
        return ensureSize(
          predicate ? this.toSeq().filter(predicate, context) : this
        );
      },

      countBy: function(grouper, context) {
        return countByFactory(this, grouper, context);
      },

      equals: function(other) {
        return deepEqual(this, other);
      },

      entrySeq: function() {
        var iterable = this;
        if (iterable._cache) {
          // We cache as an entries array, so we can just return the cache!
          return new ArraySeq(iterable._cache);
        }
        var entriesSequence = iterable
          .toSeq()
          .map(entryMapper)
          .toIndexedSeq();
        entriesSequence.fromEntrySeq = function() {
          return iterable.toSeq();
        };
        return entriesSequence;
      },

      filterNot: function(predicate, context) {
        return this.filter(not(predicate), context);
      },

      findLast: function(predicate, context, notSetValue) {
        return this.toKeyedSeq()
          .reverse()
          .find(predicate, context, notSetValue);
      },

      first: function() {
        return this.find(returnTrue);
      },

      flatMap: function(mapper, context) {
        return reify(this, flatMapFactory(this, mapper, context));
      },

      flatten: function(depth) {
        return reify(this, flattenFactory(this, depth, true));
      },

      fromEntrySeq: function() {
        return new FromEntriesSequence(this);
      },

      get: function(searchKey, notSetValue) {
        return this.find(
          function(_, key) {
            return is(key, searchKey);
          },
          undefined,
          notSetValue
        );
      },

      getIn: function(searchKeyPath, notSetValue) {
        var nested = this;
        // Note: in an ES6 environment, we would prefer:
        // for (var key of searchKeyPath) {
        var iter = forceIterator(searchKeyPath);
        var step;
        while (!(step = iter.next()).done) {
          var key = step.value;
          nested = nested && nested.get ? nested.get(key, NOT_SET) : NOT_SET;
          if (nested === NOT_SET) {
            return notSetValue;
          }
        }
        return nested;
      },

      groupBy: function(grouper, context) {
        return groupByFactory(this, grouper, context);
      },

      has: function(searchKey) {
        return this.get(searchKey, NOT_SET) !== NOT_SET;
      },

      hasIn: function(searchKeyPath) {
        return this.getIn(searchKeyPath, NOT_SET) !== NOT_SET;
      },

      isSubset: function(iter) {
        iter = typeof iter.includes === "function" ? iter : Iterable(iter);
        return this.every(function(value) {
          return iter.includes(value);
        });
      },

      isSuperset: function(iter) {
        iter = typeof iter.isSubset === "function" ? iter : Iterable(iter);
        return iter.isSubset(this);
      },

      keySeq: function() {
        return this.toSeq()
          .map(keyMapper)
          .toIndexedSeq();
      },

      last: function() {
        return this.toSeq()
          .reverse()
          .first();
      },

      max: function(comparator) {
        return maxFactory(this, comparator);
      },

      maxBy: function(mapper, comparator) {
        return maxFactory(this, comparator, mapper);
      },

      min: function(comparator) {
        return maxFactory(
          this,
          comparator ? neg(comparator) : defaultNegComparator
        );
      },

      minBy: function(mapper, comparator) {
        return maxFactory(
          this,
          comparator ? neg(comparator) : defaultNegComparator,
          mapper
        );
      },

      rest: function() {
        return this.slice(1);
      },

      skip: function(amount) {
        return this.slice(Math.max(0, amount));
      },

      skipLast: function(amount) {
        return reify(
          this,
          this.toSeq()
            .reverse()
            .skip(amount)
            .reverse()
        );
      },

      skipWhile: function(predicate, context) {
        return reify(this, skipWhileFactory(this, predicate, context, true));
      },

      skipUntil: function(predicate, context) {
        return this.skipWhile(not(predicate), context);
      },

      sortBy: function(mapper, comparator) {
        return reify(this, sortFactory(this, comparator, mapper));
      },

      take: function(amount) {
        return this.slice(0, Math.max(0, amount));
      },

      takeLast: function(amount) {
        return reify(
          this,
          this.toSeq()
            .reverse()
            .take(amount)
            .reverse()
        );
      },

      takeWhile: function(predicate, context) {
        return reify(this, takeWhileFactory(this, predicate, context));
      },

      takeUntil: function(predicate, context) {
        return this.takeWhile(not(predicate), context);
      },

      valueSeq: function() {
        return this.toIndexedSeq();
      },

      // ### Hashable Object

      hashCode: function() {
        return this.__hash || (this.__hash = hashIterable(this));
      }

      // ### Internal

      // abstract __iterate(fn, reverse)

      // abstract __iterator(type, reverse)
    });

    // var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
    // var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
    // var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';
    // var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';

    var IterablePrototype = Iterable.prototype;
    IterablePrototype[IS_ITERABLE_SENTINEL] = true;
    IterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.values;
    IterablePrototype.__toJS = IterablePrototype.toArray;
    IterablePrototype.__toStringMapper = quoteString;
    IterablePrototype.inspect = IterablePrototype.toSource = function() {
      return this.toString();
    };
    IterablePrototype.chain = IterablePrototype.flatMap;
    IterablePrototype.contains = IterablePrototype.includes;

    // Temporary warning about using length
    (function() {
      try {
        Object.defineProperty(IterablePrototype, "length", {
          get: function() {
            if (!Iterable.noLengthWarning) {
              var stack;
              try {
                throw new Error();
              } catch (error) {
                stack = error.stack;
              }
              if (stack.indexOf("_wrapObject") === -1) {
                console &&
                  console.warn &&
                  console.warn(
                    "iterable.length has been deprecated, " +
                      "use iterable.size or iterable.count(). " +
                      "This warning will become a silent error in a future version. " +
                      stack
                  );
                return this.size;
              }
            }
          }
        });
      } catch (e) {}
    })();

    mixin(KeyedIterable, {
      // ### More sequential methods

      flip: function() {
        return reify(this, flipFactory(this));
      },

      findKey: function(predicate, context) {
        var entry = this.findEntry(predicate, context);
        return entry && entry[0];
      },

      findLastKey: function(predicate, context) {
        return this.toSeq()
          .reverse()
          .findKey(predicate, context);
      },

      keyOf: function(searchValue) {
        return this.findKey(function(value) {
          return is(value, searchValue);
        });
      },

      lastKeyOf: function(searchValue) {
        return this.findLastKey(function(value) {
          return is(value, searchValue);
        });
      },

      mapEntries: function(mapper, context) {
        var this$0 = this;
        var iterations = 0;
        return reify(
          this,
          this.toSeq()
            .map(function(v, k) {
              return mapper.call(context, [k, v], iterations++, this$0);
            })
            .fromEntrySeq()
        );
      },

      mapKeys: function(mapper, context) {
        var this$0 = this;
        return reify(
          this,
          this.toSeq()
            .flip()
            .map(function(k, v) {
              return mapper.call(context, k, v, this$0);
            })
            .flip()
        );
      }
    });

    var KeyedIterablePrototype = KeyedIterable.prototype;
    KeyedIterablePrototype[IS_KEYED_SENTINEL] = true;
    KeyedIterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.entries;
    KeyedIterablePrototype.__toJS = IterablePrototype.toObject;
    KeyedIterablePrototype.__toStringMapper = function(v, k) {
      return JSON.stringify(k) + ": " + quoteString(v);
    };

    mixin(IndexedIterable, {
      // ### Conversion to other types

      toKeyedSeq: function() {
        return new ToKeyedSequence(this, false);
      },

      // ### ES6 Collection methods (ES6 Array and Map)

      filter: function(predicate, context) {
        return reify(this, filterFactory(this, predicate, context, false));
      },

      findIndex: function(predicate, context) {
        var entry = this.findEntry(predicate, context);
        return entry ? entry[0] : -1;
      },

      indexOf: function(searchValue) {
        var key = this.toKeyedSeq().keyOf(searchValue);
        return key === undefined ? -1 : key;
      },

      lastIndexOf: function(searchValue) {
        var key = this.toKeyedSeq()
          .reverse()
          .keyOf(searchValue);
        return key === undefined ? -1 : key;

        // var index =
        // return this.toSeq().reverse().indexOf(searchValue);
      },

      reverse: function() {
        return reify(this, reverseFactory(this, false));
      },

      slice: function(begin, end) {
        return reify(this, sliceFactory(this, begin, end, false));
      },

      splice: function(index, removeNum /*, ...values*/) {
        var numArgs = arguments.length;
        removeNum = Math.max(removeNum | 0, 0);
        if (numArgs === 0 || (numArgs === 2 && !removeNum)) {
          return this;
        }
        // If index is negative, it should resolve relative to the size of the
        // collection. However size may be expensive to compute if not cached, so
        // only call count() if the number is in fact negative.
        index = resolveBegin(index, index < 0 ? this.count() : this.size);
        var spliced = this.slice(0, index);
        return reify(
          this,
          numArgs === 1
            ? spliced
            : spliced.concat(
                arrCopy(arguments, 2),
                this.slice(index + removeNum)
              )
        );
      },

      // ### More collection methods

      findLastIndex: function(predicate, context) {
        var key = this.toKeyedSeq().findLastKey(predicate, context);
        return key === undefined ? -1 : key;
      },

      first: function() {
        return this.get(0);
      },

      flatten: function(depth) {
        return reify(this, flattenFactory(this, depth, false));
      },

      get: function(index, notSetValue) {
        index = wrapIndex(this, index);
        return index < 0 ||
          this.size === Infinity ||
            (this.size !== undefined && index > this.size)
          ? notSetValue
          : this.find(
              function(_, key) {
                return key === index;
              },
              undefined,
              notSetValue
            );
      },

      has: function(index) {
        index = wrapIndex(this, index);
        return (
          index >= 0 &&
          (this.size !== undefined
            ? this.size === Infinity || index < this.size
            : this.indexOf(index) !== -1)
        );
      },

      interpose: function(separator) {
        return reify(this, interposeFactory(this, separator));
      },

      interleave: function(/*...iterables*/) {
        var iterables = [this].concat(arrCopy(arguments));
        var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, iterables);
        var interleaved = zipped.flatten(true);
        if (zipped.size) {
          interleaved.size = zipped.size * iterables.length;
        }
        return reify(this, interleaved);
      },

      last: function() {
        return this.get(-1);
      },

      skipWhile: function(predicate, context) {
        return reify(this, skipWhileFactory(this, predicate, context, false));
      },

      zip: function(/*, ...iterables */) {
        var iterables = [this].concat(arrCopy(arguments));
        return reify(this, zipWithFactory(this, defaultZipper, iterables));
      },

      zipWith: function(zipper /*, ...iterables */) {
        var iterables = arrCopy(arguments);
        iterables[0] = this;
        return reify(this, zipWithFactory(this, zipper, iterables));
      }
    });

    IndexedIterable.prototype[IS_INDEXED_SENTINEL] = true;
    IndexedIterable.prototype[IS_ORDERED_SENTINEL] = true;

    mixin(SetIterable, {
      // ### ES6 Collection methods (ES6 Array and Map)

      get: function(value, notSetValue) {
        return this.has(value) ? value : notSetValue;
      },

      includes: function(value) {
        return this.has(value);
      },

      // ### More sequential methods

      keySeq: function() {
        return this.valueSeq();
      }
    });

    SetIterable.prototype.has = IterablePrototype.includes;

    // Mixin subclasses

    mixin(KeyedSeq, KeyedIterable.prototype);
    mixin(IndexedSeq, IndexedIterable.prototype);
    mixin(SetSeq, SetIterable.prototype);

    mixin(KeyedCollection, KeyedIterable.prototype);
    mixin(IndexedCollection, IndexedIterable.prototype);
    mixin(SetCollection, SetIterable.prototype);

    // #pragma Helper functions

    function keyMapper(v, k) {
      return k;
    }

    function entryMapper(v, k) {
      return [k, v];
    }

    function not(predicate) {
      return function() {
        return !predicate.apply(this, arguments);
      };
    }

    function neg(predicate) {
      return function() {
        return -predicate.apply(this, arguments);
      };
    }

    function quoteString(value) {
      return typeof value === "string" ? JSON.stringify(value) : value;
    }

    function defaultZipper() {
      return arrCopy(arguments);
    }

    function defaultNegComparator(a, b) {
      return a < b ? 1 : a > b ? -1 : 0;
    }

    function hashIterable(iterable) {
      if (iterable.size === Infinity) {
        return 0;
      }
      var ordered = isOrdered(iterable);
      var keyed = isKeyed(iterable);
      var h = ordered ? 1 : 0;
      var size = iterable.__iterate(
        keyed
          ? ordered
            ? function(v, k) {
                h = (31 * h + hashMerge(hash(v), hash(k))) | 0;
              }
            : function(v, k) {
                h = (h + hashMerge(hash(v), hash(k))) | 0;
              }
          : ordered
          ? function(v) {
              h = (31 * h + hash(v)) | 0;
            }
          : function(v) {
              h = (h + hash(v)) | 0;
            }
      );
      return murmurHashOfSize(size, h);
    }

    function murmurHashOfSize(size, h) {
      h = imul(h, 0xcc9e2d51);
      h = imul((h << 15) | (h >>> -15), 0x1b873593);
      h = imul((h << 13) | (h >>> -13), 5);
      h = ((h + 0xe6546b64) | 0) ^ size;
      h = imul(h ^ (h >>> 16), 0x85ebca6b);
      h = imul(h ^ (h >>> 13), 0xc2b2ae35);
      h = smi(h ^ (h >>> 16));
      return h;
    }

    function hashMerge(a, b) {
      return (a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2))) | 0; // int
    }

    var Immutable = {
      Iterable: Iterable,

      Seq: Seq,
      Collection: Collection,
      Map: Map,
      OrderedMap: OrderedMap,
      List: List,
      Stack: Stack,
      Set: Set,
      OrderedSet: OrderedSet,

      Record: Record,
      Range: Range,
      Repeat: Repeat,

      is: is,
      fromJS: fromJS
    };

    return Immutable;
  });
});

var draftjsUtils = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  !(function(e, t) {
    module.exports = t(Draft, immutable$1);
  })(
    "undefined" != typeof self ? self : _commonjsHelpers.commonjsGlobal,
    function(e, t) {
      return (function(e) {
        function t(r) {
          if (n[r]) return n[r].exports;
          var o = (n[r] = { i: r, l: !1, exports: {} });
          return e[r].call(o.exports, o, o.exports, t), (o.l = !0), o.exports;
        }
        var n = {};
        return (
          (t.m = e),
          (t.c = n),
          (t.d = function(e, n, r) {
            t.o(e, n) ||
              Object.defineProperty(e, n, {
                configurable: !1,
                enumerable: !0,
                get: r
              });
          }),
          (t.n = function(e) {
            var n =
              e && e.__esModule
                ? function() {
                    return e.default;
                  }
                : function() {
                    return e;
                  };
            return t.d(n, "a", n), n;
          }),
          (t.o = function(e, t) {
            return Object.prototype.hasOwnProperty.call(e, t);
          }),
          (t.p = ""),
          t((t.s = 3))
        );
      })([
        function(t, n) {
          t.exports = e;
        },
        function(e, t, n) {
          function r(e) {
            var t = e.getSelection(),
              n = e.getCurrentContent(),
              r = t.getStartKey(),
              o = t.getEndKey(),
              i = n.getBlockMap();
            return i
              .toSeq()
              .skipUntil(function(e, t) {
                return t === r;
              })
              .takeUntil(function(e, t) {
                return t === o;
              })
              .concat([[o, i.get(o)]]);
          }
          function o(e) {
            return r(e).toList();
          }
          function i(e) {
            if (e) return o(e).get(0);
          }
          function l(e) {
            if (e) {
              var t = i(e),
                n = e.getCurrentContent(),
                r = n
                  .getBlockMap()
                  .toSeq()
                  .toList(),
                o = 0;
              if (
                (r.forEach(function(e, n) {
                  e.get("key") === t.get("key") && (o = n - 1);
                }),
                o > -1)
              )
                return r.get(o);
            }
          }
          function c(e) {
            return e
              ? e
                  .getCurrentContent()
                  .getBlockMap()
                  .toList()
              : new v.List();
          }
          function a(e) {
            var t = o(e);
            if (
              !t.some(function(e) {
                return e.type !== t.get(0).type;
              })
            )
              return t.get(0).type;
          }
          function f(e) {
            var t = p.RichUtils.tryToRemoveBlockStyle(e);
            return t ? p.EditorState.push(e, t, "change-block-type") : e;
          }
          function u(e) {
            var t = "",
              n = e.getSelection(),
              r = n.getAnchorOffset(),
              i = n.getFocusOffset(),
              l = o(e);
            if (l.size > 0) {
              if (n.getIsBackward()) {
                var c = r;
                (r = i), (i = c);
              }
              for (var a = 0; a < l.size; a += 1) {
                var f = 0 === a ? r : 0,
                  u = a === l.size - 1 ? i : l.get(a).getText().length;
                t += l
                  .get(a)
                  .getText()
                  .slice(f, u);
              }
            }
            return t;
          }
          function s(e) {
            var t = e.getCurrentContent(),
              n = e.getSelection(),
              r = p.Modifier.removeRange(t, n, "forward"),
              o = r.getSelectionAfter(),
              i = r.getBlockForKey(o.getStartKey());
            return (
              (r = p.Modifier.insertText(
                r,
                o,
                "\n",
                i.getInlineStyleAt(o.getStartOffset()),
                null
              )),
              p.EditorState.push(e, r, "insert-fragment")
            );
          }
          function g(e) {
            var t = p.Modifier.splitBlock(
              e.getCurrentContent(),
              e.getSelection()
            );
            return f(p.EditorState.push(e, t, "split-block"));
          }
          function d(e) {
            var t = e
                .getCurrentContent()
                .getBlockMap()
                .toList(),
              n = e
                .getSelection()
                .merge({
                  anchorKey: t.first().get("key"),
                  anchorOffset: 0,
                  focusKey: t.last().get("key"),
                  focusOffset: t.last().getLength()
                }),
              r = p.Modifier.removeRange(e.getCurrentContent(), n, "forward");
            return p.EditorState.push(e, r, "remove-range");
          }
          function S(e, t) {
            var n = p.Modifier.setBlockData(
              e.getCurrentContent(),
              e.getSelection(),
              t
            );
            return p.EditorState.push(e, n, "change-block-data");
          }
          function y(e) {
            var t = new v.Map({}),
              n = o(e);
            if (n && n.size > 0)
              for (var r = 0; r < n.size; r += 1) {
                var i = (function(e) {
                  var r = n.get(e).getData();
                  if (!r || 0 === r.size) return (t = t.clear()), "break";
                  if (0 === e) t = r;
                  else if (
                    (t.forEach(function(e, n) {
                      (r.get(n) && r.get(n) === e) || (t = t.delete(n));
                    }),
                    0 === t.size)
                  )
                    return (t = t.clear()), "break";
                })(r);
                if ("break" === i) break;
              }
            return t;
          }
          Object.defineProperty(t, "__esModule", { value: !0 }),
            (t.blockRenderMap = void 0),
            (t.getSelectedBlocksMap = r),
            (t.getSelectedBlocksList = o),
            (t.getSelectedBlock = i),
            (t.getBlockBeforeSelectedBlock = l),
            (t.getAllBlocks = c),
            (t.getSelectedBlocksType = a),
            (t.removeSelectedBlocksStyle = f),
            (t.getSelectionText = u),
            (t.addLineBreakRemovingSelection = s),
            (t.insertNewUnstyledBlock = g),
            (t.clearEditorContent = d),
            (t.setBlockData = S),
            (t.getSelectedBlocksMetadata = y);
          var p = n(0),
            v = n(6),
            k = (0, v.Map)({ code: { element: "pre" } });
          t.blockRenderMap = p.DefaultDraftBlockRenderMap.merge(k);
        },
        function(e, t, n) {
          function r(e) {
            if (e) {
              var t = e.getType();
              return "unordered-list-item" === t || "ordered-list-item" === t;
            }
            return !1;
          }
          function o(e, t, n) {
            var r = e.getSelection(),
              o = e.getCurrentContent(),
              i = o.getBlockMap(),
              l = (0, c.getSelectedBlocksMap)(e).map(function(e) {
                var r = e.getDepth() + t;
                return (r = Math.max(0, Math.min(r, n))), e.set("depth", r);
              });
            return (
              (i = i.merge(l)),
              o.merge({ blockMap: i, selectionBefore: r, selectionAfter: r })
            );
          }
          function i(e, t, n) {
            var r = e.getSelection(),
              i = void 0;
            i = r.getIsBackward() ? r.getFocusKey() : r.getAnchorKey();
            var c = e.getCurrentContent(),
              a = c.getBlockForKey(i),
              f = a.getType();
            if ("unordered-list-item" !== f && "ordered-list-item" !== f)
              return e;
            var u = c.getBlockBefore(i);
            if (!u) return e;
            if (u.getType() !== f) return e;
            var s = a.getDepth();
            if (1 === t && s === n) return e;
            var g = Math.min(u.getDepth() + 1, n),
              d = o(e, t, g);
            return l.EditorState.push(e, d, "adjust-depth");
          }
          Object.defineProperty(t, "__esModule", { value: !0 }),
            (t.isListBlock = r),
            (t.changeDepth = i);
          var l = n(0),
            c = n(1);
        },
        function(e, t, n) {
          e.exports = n(4);
        },
        function(e, t, n) {
          var r = n(5),
            o = n(1),
            i = n(7),
            l = (function(e) {
              return e && e.__esModule ? e : { default: e };
            })(i),
            c = n(2);
          e.exports = {
            getSelectedBlocksMap: o.getSelectedBlocksMap,
            getSelectedBlocksList: o.getSelectedBlocksList,
            getSelectedBlock: o.getSelectedBlock,
            getBlockBeforeSelectedBlock: o.getBlockBeforeSelectedBlock,
            getAllBlocks: o.getAllBlocks,
            getSelectedBlocksType: o.getSelectedBlocksType,
            removeSelectedBlocksStyle: o.removeSelectedBlocksStyle,
            getSelectionText: o.getSelectionText,
            addLineBreakRemovingSelection: o.addLineBreakRemovingSelection,
            insertNewUnstyledBlock: o.insertNewUnstyledBlock,
            clearEditorContent: o.clearEditorContent,
            setBlockData: o.setBlockData,
            getSelectedBlocksMetadata: o.getSelectedBlocksMetadata,
            blockRenderMap: o.blockRenderMap,
            getEntityRange: r.getEntityRange,
            getCustomStyleMap: r.getCustomStyleMap,
            toggleCustomInlineStyle: r.toggleCustomInlineStyle,
            getSelectionEntity: r.getSelectionEntity,
            extractInlineStyle: r.extractInlineStyle,
            removeAllInlineStyles: r.removeAllInlineStyles,
            getSelectionInlineStyle: r.getSelectionInlineStyle,
            getSelectionCustomInlineStyle: r.getSelectionCustomInlineStyle,
            handleNewLine: l.default,
            isListBlock: c.isListBlock,
            changeDepth: c.changeDepth
          };
        },
        function(e, t, n) {
          function r(e, t, n) {
            return (
              t in e
                ? Object.defineProperty(e, t, {
                    value: n,
                    enumerable: !0,
                    configurable: !0,
                    writable: !0
                  })
                : (e[t] = n),
              e
            );
          }
          function o(e) {
            var t = e.getSelection();
            if (t.isCollapsed()) {
              var n = {},
                r = e
                  .getCurrentInlineStyle()
                  .toList()
                  .toJS();
              if (r)
                return (
                  [
                    "BOLD",
                    "ITALIC",
                    "UNDERLINE",
                    "STRIKETHROUGH",
                    "CODE",
                    "SUPERSCRIPT",
                    "SUBSCRIPT"
                  ].forEach(function(e) {
                    n[e] = r.indexOf(e) >= 0;
                  }),
                  n
                );
            }
            var o = t.getStartOffset(),
              i = t.getEndOffset(),
              l = (0, p.getSelectedBlocksList)(e);
            if (l.size > 0) {
              var c = (function() {
                for (
                  var e = {
                      BOLD: !0,
                      ITALIC: !0,
                      UNDERLINE: !0,
                      STRIKETHROUGH: !0,
                      CODE: !0,
                      SUPERSCRIPT: !0,
                      SUBSCRIPT: !0
                    },
                    t = 0;
                  t < l.size;
                  t += 1
                ) {
                  var n = 0 === t ? o : 0,
                    r = t === l.size - 1 ? i : l.get(t).getText().length;
                  n === r && 0 === n ? ((n = 1), (r = 2)) : n === r && (n -= 1);
                  for (var c = n; c < r; c += 1)
                    !(function(n) {
                      var r = l.get(t).getInlineStyleAt(n);
                      [
                        "BOLD",
                        "ITALIC",
                        "UNDERLINE",
                        "STRIKETHROUGH",
                        "CODE",
                        "SUPERSCRIPT",
                        "SUBSCRIPT"
                      ].forEach(function(t) {
                        e[t] = e[t] && r.get(t) === t;
                      });
                    })(c);
                }
                return { v: e };
              })();
              if ("object" === (void 0 === c ? "undefined" : S(c))) return c.v;
            }
            return {};
          }
          function i(e) {
            var t = void 0,
              n = e.getSelection(),
              r = n.getStartOffset(),
              o = n.getEndOffset();
            r === o && 0 === r ? (o = 1) : r === o && (r -= 1);
            for (var i = (0, p.getSelectedBlock)(e), l = r; l < o; l += 1) {
              var c = i.getEntityAt(l);
              if (!c) {
                t = void 0;
                break;
              }
              if (l === r) t = c;
              else if (t !== c) {
                t = void 0;
                break;
              }
            }
            return t;
          }
          function l(e, t) {
            var n = (0, p.getSelectedBlock)(e),
              r = void 0;
            return (
              n.findEntityRanges(
                function(e) {
                  return e.get("entity") === t;
                },
                function(e, t) {
                  r = { start: e, end: t, text: n.get("text").slice(e, t) };
                }
              ),
              r
            );
          }
          function c(e, t, n) {
            var r = e.getSelection(),
              o = Object.keys(v[t]).reduce(function(e, t) {
                return y.Modifier.removeInlineStyle(e, r, t);
              }, e.getCurrentContent()),
              i = y.EditorState.push(e, o, "changeinline-style"),
              l = e.getCurrentInlineStyle();
            if (
              (r.isCollapsed() &&
                (i = l.reduce(function(e, t) {
                  return y.RichUtils.toggleInlineStyle(e, t);
                }, i)),
              "SUPERSCRIPT" === t || "SUBSCRIPT" == t)
            )
              l.has(n) || (i = y.RichUtils.toggleInlineStyle(i, n));
            else {
              var c = "bgcolor" === t ? "backgroundColor" : t;
              l.has(c + "-" + n) ||
                ((i = y.RichUtils.toggleInlineStyle(
                  i,
                  t.toLowerCase() + "-" + n
                )),
                k(t, c, n));
            }
            return i;
          }
          function a(e) {
            if (e) {
              e.getCurrentContent()
                .getBlockMap()
                .map(function(e) {
                  return e.get("characterList");
                })
                .toList()
                .flatten()
                .forEach(function(e) {
                  e && 0 === e.indexOf("color-")
                    ? k("color", "color", e.substr(6))
                    : e && 0 === e.indexOf("bgcolor-")
                    ? k("bgcolor", "backgroundColor", e.substr(8))
                    : e && 0 === e.indexOf("fontsize-")
                    ? k("fontSize", "fontSize", +e.substr(9))
                    : e &&
                      0 === e.indexOf("fontfamily-") &&
                      k("fontFamily", "fontFamily", e.substr(11));
                });
            }
          }
          function f(e, t, n) {
            var r = e.getInlineStyleAt(n).toList(),
              o = r.filter(function(e) {
                return e.startsWith(t.toLowerCase());
              });
            if (o && o.size > 0) return o.get(0);
          }
          function u(e, t) {
            var n = e.getCurrentInlineStyle().toList(),
              r = n.filter(function(e) {
                return e.startsWith(t.toLowerCase());
              });
            if (r && r.size > 0) return r.get(0);
          }
          function s(e, t) {
            if (e && t && t.length > 0) {
              var n = (function() {
                var n = e.getSelection(),
                  r = {};
                if (n.isCollapsed())
                  return (
                    t.forEach(function(t) {
                      r[t] = u(e, t);
                    }),
                    { v: r }
                  );
                var o = n.getStartOffset(),
                  i = n.getEndOffset(),
                  l = (0, p.getSelectedBlocksList)(e);
                if (l.size > 0) {
                  for (var c = 0; c < l.size; c += 1)
                    !(function(e) {
                      var n = 0 === e ? o : 0,
                        c = e === l.size - 1 ? i : l.get(e).getText().length;
                      n === c && 0 === n
                        ? ((n = 1), (c = 2))
                        : n === c && (n -= 1);
                      for (var a = n; a < c; a += 1)
                        !(function(o) {
                          o === n
                            ? t.forEach(function(t) {
                                r[t] = f(l.get(e), t, o);
                              })
                            : t.forEach(function(t) {
                                r[t] &&
                                  r[t] !== f(l.get(e), t, o) &&
                                  (r[t] = void 0);
                              });
                        })(a);
                    })(c);
                  return { v: r };
                }
              })();
              if ("object" === (void 0 === n ? "undefined" : S(n))) return n.v;
            }
            return {};
          }
          function g(e) {
            var t = e.getCurrentInlineStyle(),
              n = e.getCurrentContent();
            return (
              t.forEach(function(t) {
                n = y.Modifier.removeInlineStyle(n, e.getSelection(), t);
              }),
              y.EditorState.push(e, n, "change-inline-style")
            );
          }
          Object.defineProperty(t, "__esModule", { value: !0 }),
            (t.getCustomStyleMap = void 0);
          var d =
              Object.assign ||
              function(e) {
                for (var t = 1; t < arguments.length; t++) {
                  var n = arguments[t];
                  for (var r in n)
                    Object.prototype.hasOwnProperty.call(n, r) && (e[r] = n[r]);
                }
                return e;
              },
            S =
              "function" == typeof Symbol && "symbol" == typeof Symbol.iterator
                ? function(e) {
                    return typeof e;
                  }
                : function(e) {
                    return e &&
                      "function" == typeof Symbol &&
                      e.constructor === Symbol &&
                      e !== Symbol.prototype
                      ? "symbol"
                      : typeof e;
                  };
          (t.getSelectionInlineStyle = o),
            (t.getSelectionEntity = i),
            (t.getEntityRange = l),
            (t.toggleCustomInlineStyle = c),
            (t.extractInlineStyle = a),
            (t.getSelectionCustomInlineStyle = s),
            (t.removeAllInlineStyles = g);
          var y = n(0),
            p = n(1),
            v = {
              color: {},
              bgcolor: {},
              fontSize: {},
              fontFamily: {},
              CODE: {
                fontFamily: "monospace",
                wordWrap: "break-word",
                background: "#f1f1f1",
                borderRadius: 3,
                padding: "1px 3px"
              },
              SUPERSCRIPT: {
                fontSize: 11,
                position: "relative",
                top: -8,
                display: "inline-flex"
              },
              SUBSCRIPT: {
                fontSize: 11,
                position: "relative",
                bottom: -8,
                display: "inline-flex"
              }
            },
            k = function(e, t, n) {
              v[e][e.toLowerCase() + "-" + n] = r({}, "" + t, n);
            };
          t.getCustomStyleMap = function() {
            return d({}, v.color, v.bgcolor, v.fontSize, v.fontFamily, {
              CODE: v.CODE,
              SUPERSCRIPT: v.SUPERSCRIPT,
              SUBSCRIPT: v.SUBSCRIPT
            });
          };
        },
        function(e, n) {
          e.exports = t;
        },
        function(e, t, n) {
          function r(e) {
            var t = e.getSelection();
            if (t.isCollapsed()) {
              var n = e.getCurrentContent(),
                r = t.getStartKey(),
                o = n.getBlockForKey(r);
              if (
                !(0, a.isListBlock)(o) &&
                "unstyled" !== o.getType() &&
                o.getLength() === t.getStartOffset()
              )
                return (0, c.insertNewUnstyledBlock)(e);
              if ((0, a.isListBlock)(o) && 0 === o.getLength()) {
                var i = o.getDepth();
                if (0 === i) return (0, c.removeSelectedBlocksStyle)(e);
                if (i > 0) return (0, a.changeDepth)(e, -1, i);
              }
            }
          }
          function o(e) {
            return (
              13 === e.which &&
              (e.getModifierState("Shift") ||
                e.getModifierState("Alt") ||
                e.getModifierState("Control"))
            );
          }
          function i(e, t) {
            if (o(t)) {
              return e.getSelection().isCollapsed()
                ? l.RichUtils.insertSoftNewline(e)
                : (0, c.addLineBreakRemovingSelection)(e);
            }
            return r(e);
          }
          Object.defineProperty(t, "__esModule", { value: !0 }),
            (t.default = i);
          var l = n(0),
            c = n(1),
            a = n(2);
        }
      ]);
    }
  );
});

_commonjsHelpers.unwrapExports(draftjsUtils);
var draftjsUtils_1 = draftjsUtils.draftjsUtils;

var interopRequireDefault = _commonjsHelpers.createCommonjsModule(function(
  module
) {
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule
      ? obj
      : {
          default: obj
        };
  }

  module.exports = _interopRequireDefault;
});

_commonjsHelpers.unwrapExports(interopRequireDefault);

/**
 * 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.
 */

/**
 * 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.
 */

var invariant$1 = function(condition, format, a, b, c, d, e, f) {
  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 args = [a, b, c, d, e, f];
      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;
  }
};

var browser = invariant$1;

function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr)) {
    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
      arr2[i] = arr[i];
    }

    return arr2;
  }
}

var arrayWithoutHoles = _arrayWithoutHoles;

function _iterableToArray(iter) {
  if (
    Symbol.iterator in Object(iter) ||
    Object.prototype.toString.call(iter) === "[object Arguments]"
  )
    return Array.from(iter);
}

var iterableToArray = _iterableToArray;

function _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance");
}

var nonIterableSpread = _nonIterableSpread;

function _toConsumableArray(arr) {
  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
}

var toConsumableArray = _toConsumableArray;

var updateMutation_1 = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = updateMutation;

  function updateMutation(
    mutation,
    originalOffset,
    originalLength,
    newLength,
    prefixLength,
    suffixLength
  ) {
    // three cases we can reasonably adjust - disjoint mutations that
    // happen later on where the offset will need to be changed,
    // mutations that completely contain the new one where we can adjust
    // the length, and mutations that occur partially within the new one.
    var lengthDiff = newLength - originalLength;
    var mutationAfterChange =
      originalOffset + originalLength <= mutation.offset;

    if (mutationAfterChange) {
      return Object.assign({}, mutation, {
        offset: mutation.offset + lengthDiff
      });
    }

    var mutationContainsChange =
      originalOffset >= mutation.offset &&
      originalOffset + originalLength <= mutation.offset + mutation.length;

    if (mutationContainsChange) {
      return Object.assign({}, mutation, {
        length: mutation.length + lengthDiff
      });
    }

    var mutationWithinPrefixChange =
      mutation.offset >= originalOffset &&
      mutation.offset + mutation.length <= originalOffset + originalLength &&
      prefixLength > 0;

    if (mutationWithinPrefixChange) {
      return Object.assign({}, mutation, {
        offset: mutation.offset + prefixLength
      });
    }

    var mutationContainsPrefix =
      mutation.offset < originalOffset &&
      mutation.offset + mutation.length <= originalOffset + originalLength &&
      mutation.offset + mutation.length > originalOffset &&
      prefixLength > 0;

    if (mutationContainsPrefix) {
      return [
        Object.assign({}, mutation, {
          length: originalOffset - mutation.offset
        }),
        Object.assign({}, mutation, {
          offset: originalOffset + prefixLength,
          length: mutation.offset - originalOffset + mutation.length
        })
      ];
    }

    var mutationContainsSuffix =
      mutation.offset >= originalOffset &&
      mutation.offset + mutation.length > originalOffset + originalLength &&
      originalOffset + originalLength > mutation.offset &&
      suffixLength > 0;

    if (mutationContainsSuffix) {
      return [
        Object.assign({}, mutation, {
          offset: mutation.offset + prefixLength,
          length: originalOffset + originalLength - mutation.offset
        }),
        Object.assign({}, mutation, {
          offset: originalOffset + originalLength + prefixLength + suffixLength,
          length:
            mutation.offset +
            mutation.length -
            (originalOffset + originalLength)
        })
      ];
    }

    return mutation;
  }
});

_commonjsHelpers.unwrapExports(updateMutation_1);

var rangeSort = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = void 0;

  var _default = function _default(r1, r2) {
    if (r1.offset === r2.offset) {
      return r2.length - r1.length;
    }

    return r1.offset - r2.offset;
  };

  exports["default"] = _default;
});

_commonjsHelpers.unwrapExports(rangeSort);

var encodeBlock = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = void 0;

  var _toConsumableArray2 = interopRequireDefault(toConsumableArray);

  var _updateMutation = interopRequireDefault(updateMutation_1);

  var _rangeSort = interopRequireDefault(rangeSort);

  var ENTITY_MAP = {
    "&": "&amp;",
    "<": "&lt;",
    ">": "&gt;",
    '"': "&quot;",
    "'": "&#x27;",
    "`": "&#x60;",
    "\n": "<br/>"
  };

  var _default = function _default(block) {
    var blockText = (0, _toConsumableArray2["default"])(block.text);
    var entities = block.entityRanges.sort(_rangeSort["default"]);
    var styles = block.inlineStyleRanges.sort(_rangeSort["default"]);
    var resultText = "";

    var _loop = function _loop(index) {
      var _char = blockText[index];

      if (ENTITY_MAP[_char] !== undefined) {
        var encoded = ENTITY_MAP[_char];
        var resultIndex = (0, _toConsumableArray2["default"])(resultText)
          .length;
        resultText += encoded;

        var updateForChar = function updateForChar(mutation) {
          return (0, _updateMutation["default"])(
            mutation,
            resultIndex,
            _char.length,
            encoded.length,
            0,
            0
          );
        };

        entities = entities.map(updateForChar);
        styles = styles.map(updateForChar);
      } else {
        resultText += _char;
      }
    };

    for (var index = 0; index < blockText.length; index++) {
      _loop(index);
    }

    return Object.assign({}, block, {
      text: resultText,
      inlineStyleRanges: styles,
      entityRanges: entities
    });
  };

  exports["default"] = _default;
});

_commonjsHelpers.unwrapExports(encodeBlock);

var _typeof_1 = _commonjsHelpers.createCommonjsModule(function(module) {
  function _typeof(obj) {
    "@babel/helpers - typeof";

    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      module.exports = _typeof = function _typeof(obj) {
        return typeof obj;
      };
    } else {
      module.exports = _typeof = function _typeof(obj) {
        return obj &&
          typeof Symbol === "function" &&
          obj.constructor === Symbol &&
          obj !== Symbol.prototype
          ? "symbol"
          : typeof obj;
      };
    }

    return _typeof(obj);
  }

  module.exports = _typeof;
});

var splitReactElement_1 = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = splitReactElement;

  var _invariant = interopRequireDefault(browser);

  var _react = interopRequireDefault(React__default);

  var _server = interopRequireDefault(server);

  // see http://w3c.github.io/html/syntax.html#writing-html-documents-elements
  var VOID_TAGS = [
    "area",
    "base",
    "br",
    "col",
    "embed",
    "hr",
    "img",
    "input",
    "link",
    "meta",
    "param",
    "source",
    "track",
    "wbr"
  ];

  function splitReactElement(element) {
    if (VOID_TAGS.indexOf(element.type) !== -1) {
      return _server["default"].renderToStaticMarkup(element);
    }

    var tags = _server["default"]
      .renderToStaticMarkup(_react["default"].cloneElement(element, {}, "\r"))
      .split("\r");

    (0, _invariant["default"])(
      tags.length > 1,
      "convertToHTML: Element of type ".concat(
        element.type,
        " must render children"
      )
    );
    (0, _invariant["default"])(
      tags.length < 3,
      "convertToHTML: Element of type ".concat(
        element.type,
        " cannot use carriage return character"
      )
    );
    return {
      start: tags[0],
      end: tags[1]
    };
  }
});

_commonjsHelpers.unwrapExports(splitReactElement_1);

var getElementHTML_1 = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = getElementHTML;

  var _typeof2 = interopRequireDefault(_typeof_1);

  var _invariant = interopRequireDefault(browser);

  var _react = interopRequireDefault(React__default);

  var _server = interopRequireDefault(server);

  var _splitReactElement = interopRequireDefault(splitReactElement_1);

  function hasChildren(element) {
    return (
      _react["default"].isValidElement(element) &&
      _react["default"].Children.count(element.props.children) > 0
    );
  }

  function getElementHTML(element) {
    var text =
      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

    if (element === undefined || element === null) {
      return element;
    }

    if (typeof element === "string") {
      return element;
    }

    if (_react["default"].isValidElement(element)) {
      if (hasChildren(element)) {
        return _server["default"].renderToStaticMarkup(element);
      }

      var tags = (0, _splitReactElement["default"])(element);

      if (text !== null && (0, _typeof2["default"])(tags) === "object") {
        var start = tags.start,
          end = tags.end;
        return start + text + end;
      }

      return tags;
    }

    (0, _invariant["default"])(
      Object.prototype.hasOwnProperty.call(element, "start") &&
        Object.prototype.hasOwnProperty.call(element, "end"),
      "convertToHTML: received conversion data without either an HTML string, ReactElement or an object with start/end tags"
    );

    if (text !== null) {
      var _start = element.start,
        _end = element.end;
      return _start + text + _end;
    }

    return element;
  }
});

_commonjsHelpers.unwrapExports(getElementHTML_1);

var getElementTagLength_1 = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = void 0;

  var _typeof2 = interopRequireDefault(_typeof_1);

  var _react = interopRequireDefault(React__default);

  var _splitReactElement = interopRequireDefault(splitReactElement_1);

  var getElementTagLength = function getElementTagLength(element) {
    var type =
      arguments.length > 1 && arguments[1] !== undefined
        ? arguments[1]
        : "start";

    if (_react["default"].isValidElement(element)) {
      var splitElement = (0, _splitReactElement["default"])(element);

      if (typeof splitElement === "string") {
        return 0;
      }

      var length = splitElement[type].length;

      var child = _react["default"].Children.toArray(element.props.children)[0];

      return (
        length +
        (child && _react["default"].isValidElement(child)
          ? getElementTagLength(child, type)
          : 0)
      );
    }

    if ((0, _typeof2["default"])(element) === "object") {
      return element[type] ? element[type].length : 0;
    }

    return 0;
  };

  var _default = getElementTagLength;
  exports["default"] = _default;
});

_commonjsHelpers.unwrapExports(getElementTagLength_1);

var blockEntities = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = void 0;

  var _toConsumableArray2 = interopRequireDefault(toConsumableArray);

  var _updateMutation = interopRequireDefault(updateMutation_1);

  var _rangeSort = interopRequireDefault(rangeSort);

  var _getElementHTML = interopRequireDefault(getElementHTML_1);

  var _getElementTagLength = interopRequireDefault(getElementTagLength_1);

  var converter = function converter() {
    var originalText = arguments.length > 1 ? arguments[1] : undefined;
    return originalText;
  };

  var _default = function _default(block, entityMap) {
    var entityConverter =
      arguments.length > 2 && arguments[2] !== undefined
        ? arguments[2]
        : converter;
    var resultText = (0, _toConsumableArray2["default"])(block.text);
    var getEntityHTML = entityConverter;

    if (entityConverter.__isMiddleware) {
      getEntityHTML = entityConverter(converter);
    }

    if (
      Object.prototype.hasOwnProperty.call(block, "entityRanges") &&
      block.entityRanges.length > 0
    ) {
      var entities = block.entityRanges.sort(_rangeSort["default"]);
      var styles = block.inlineStyleRanges;

      var _loop = function _loop(index) {
        var entityRange = entities[index];
        var entity = entityMap[entityRange.key];
        var originalText = resultText
          .slice(entityRange.offset, entityRange.offset + entityRange.length)
          .join("");
        var entityHTML = getEntityHTML(entity, originalText);
        var converted = (0, _toConsumableArray2["default"])(
          (0, _getElementHTML["default"])(entityHTML, originalText) ||
            originalText
        );
        var prefixLength = (0, _getElementTagLength["default"])(
          entityHTML,
          "start"
        );
        var suffixLength = (0, _getElementTagLength["default"])(
          entityHTML,
          "end"
        );

        var updateLaterMutation = function updateLaterMutation(
          mutation,
          mutationIndex
        ) {
          if (
            mutationIndex > index ||
            Object.prototype.hasOwnProperty.call(mutation, "style")
          ) {
            return (0, _updateMutation["default"])(
              mutation,
              entityRange.offset,
              entityRange.length,
              converted.length,
              prefixLength,
              suffixLength
            );
          }

          return mutation;
        };

        var updateLaterMutations = function updateLaterMutations(mutationList) {
          return mutationList.reduce(function(acc, mutation, mutationIndex) {
            var updatedMutation = updateLaterMutation(mutation, mutationIndex);

            if (Array.isArray(updatedMutation)) {
              return acc.concat(updatedMutation);
            }

            return acc.concat([updatedMutation]);
          }, []);
        };

        entities = updateLaterMutations(entities);
        styles = updateLaterMutations(styles);
        resultText = [].concat(
          (0, _toConsumableArray2["default"])(
            resultText.slice(0, entityRange.offset)
          ),
          (0, _toConsumableArray2["default"])(converted),
          (0, _toConsumableArray2["default"])(
            resultText.slice(entityRange.offset + entityRange.length)
          )
        );
      };

      for (var index = 0; index < entities.length; index++) {
        _loop(index);
      }

      return Object.assign({}, block, {
        text: resultText.join(""),
        inlineStyleRanges: styles,
        entityRanges: entities
      });
    }

    return block;
  };

  exports["default"] = _default;
});

_commonjsHelpers.unwrapExports(blockEntities);

var styleObjectFunction = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = void 0;

  var _default = function _default(object) {
    return function(style) {
      if (typeof object === "function") {
        return object(style);
      }

      return object[style];
    };
  };

  exports["default"] = _default;
});

_commonjsHelpers.unwrapExports(styleObjectFunction);

var accumulateFunction = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = void 0;

  var _default = function _default(newFn, rest) {
    return function() {
      var newResult = newFn.apply(void 0, arguments);

      if (newResult !== undefined && newResult !== null) {
        return newResult;
      }

      return rest.apply(void 0, arguments);
    };
  };

  exports["default"] = _default;
});

_commonjsHelpers.unwrapExports(accumulateFunction);

var defaultInlineHTML_1 = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = defaultInlineHTML;

  var _react = interopRequireDefault(React__default);

  function defaultInlineHTML(style) {
    switch (style) {
      case "BOLD":
        return _react["default"].createElement("strong", null);

      case "ITALIC":
        return _react["default"].createElement("em", null);

      case "UNDERLINE":
        return _react["default"].createElement("u", null);

      case "CODE":
        return _react["default"].createElement("code", null);

      default:
        return {
          start: "",
          end: ""
        };
    }
  }
});

_commonjsHelpers.unwrapExports(defaultInlineHTML_1);

var blockInlineStyles = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = void 0;

  var _toConsumableArray2 = interopRequireDefault(toConsumableArray);

  var _invariant = interopRequireDefault(browser);

  var _styleObjectFunction = interopRequireDefault(styleObjectFunction);

  var _accumulateFunction = interopRequireDefault(accumulateFunction);

  var _getElementHTML = interopRequireDefault(getElementHTML_1);

  var _rangeSort = interopRequireDefault(rangeSort);

  var _defaultInlineHTML = interopRequireDefault(defaultInlineHTML_1);

  var subtractStyles = function subtractStyles(original, toRemove) {
    return original.filter(function(el) {
      return !toRemove.some(function(elToRemove) {
        return elToRemove.style === el.style;
      });
    });
  };

  var popEndingStyles = function popEndingStyles(styleStack, endingStyles) {
    return endingStyles.reduceRight(function(stack, style) {
      var styleToRemove = stack[stack.length - 1];
      (0,
      _invariant[
        "default"
      ])(styleToRemove.style === style.style, "Style ".concat(styleToRemove.style, " to be removed doesn't match expected ").concat(style.style));
      return stack.slice(0, -1);
    }, styleStack);
  };

  var characterStyles = function characterStyles(offset, ranges) {
    return ranges.filter(function(range) {
      return offset >= range.offset && offset < range.offset + range.length;
    });
  };

  var rangeIsSubset = function rangeIsSubset(firstRange, secondRange) {
    // returns true if the second range is a subset of the first
    var secondStartWithinFirst = firstRange.offset <= secondRange.offset;
    var secondEndWithinFirst =
      firstRange.offset + firstRange.length >=
      secondRange.offset + secondRange.length;
    return secondStartWithinFirst && secondEndWithinFirst;
  };

  var latestStyleLast = function latestStyleLast(s1, s2) {
    // make sure longer-lasting styles are added first
    var s2endIndex = s2.offset + s2.length;
    var s1endIndex = s1.offset + s1.length;
    return s2endIndex - s1endIndex;
  };

  var getStylesToReset = function getStylesToReset(remainingStyles, newStyles) {
    var i = 0;

    while (i < remainingStyles.length) {
      if (newStyles.every(rangeIsSubset.bind(null, remainingStyles[i]))) {
        i++;
      } else {
        return remainingStyles.slice(i);
      }
    }

    return [];
  };

  var appendStartMarkup = function appendStartMarkup(
    inlineHTML,
    string,
    styleRange
  ) {
    return (
      string +
      (0, _getElementHTML["default"])(inlineHTML(styleRange.style)).start
    );
  };

  var prependEndMarkup = function prependEndMarkup(
    inlineHTML,
    string,
    styleRange
  ) {
    return (
      (0, _getElementHTML["default"])(inlineHTML(styleRange.style)).end + string
    );
  };

  var defaultCustomInlineHTML = function defaultCustomInlineHTML(next) {
    return function(style) {
      return next(style);
    };
  };

  defaultCustomInlineHTML.__isMiddleware = true;

  var _default = function _default(rawBlock) {
    var customInlineHTML =
      arguments.length > 1 && arguments[1] !== undefined
        ? arguments[1]
        : defaultCustomInlineHTML;
    (0, _invariant["default"])(
      rawBlock !== null && rawBlock !== undefined,
      "Expected raw block to be non-null"
    );
    var inlineHTML;

    if (customInlineHTML.__isMiddleware === true) {
      inlineHTML = customInlineHTML(_defaultInlineHTML["default"]);
    } else {
      inlineHTML = (0, _accumulateFunction["default"])(
        (0, _styleObjectFunction["default"])(customInlineHTML),
        (0, _styleObjectFunction["default"])(_defaultInlineHTML["default"])
      );
    }

    var result = "";
    var styleStack = [];
    var sortedRanges = rawBlock.inlineStyleRanges.sort(_rangeSort["default"]);
    var originalTextArray = (0, _toConsumableArray2["default"])(rawBlock.text);

    for (var i = 0; i < originalTextArray.length; i++) {
      var styles = characterStyles(i, sortedRanges);
      var endingStyles = subtractStyles(styleStack, styles);
      var newStyles = subtractStyles(styles, styleStack);
      var remainingStyles = subtractStyles(styleStack, endingStyles); // reset styles: look for any already existing styles that will need to
      // end before styles that are being added on this character. to solve this
      // close out those current tags and all nested children,
      // then open new ones nested within the new styles.

      var resetStyles = getStylesToReset(remainingStyles, newStyles);
      var openingStyles = resetStyles.concat(newStyles).sort(latestStyleLast);
      var openingStyleTags = openingStyles.reduce(
        appendStartMarkup.bind(null, inlineHTML),
        ""
      );
      var endingStyleTags = endingStyles
        .concat(resetStyles)
        .reduce(prependEndMarkup.bind(null, inlineHTML), "");
      result += endingStyleTags + openingStyleTags + originalTextArray[i];
      styleStack = popEndingStyles(
        styleStack,
        resetStyles.concat(endingStyles)
      );
      styleStack = styleStack.concat(openingStyles);
      (0, _invariant["default"])(
        styleStack.length === styles.length,
        "Character "
          .concat(i, ": ")
          .concat(
            styleStack.length - styles.length,
            " styles left on stack that should no longer be there"
          )
      );
    }

    result = styleStack.reduceRight(function(res, openStyle) {
      return (
        res + (0, _getElementHTML["default"])(inlineHTML(openStyle.style)).end
      );
    }, result);
    return result;
  };

  exports["default"] = _default;
});

_commonjsHelpers.unwrapExports(blockInlineStyles);

var blockTypeObjectFunction = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = void 0;

  var _default = function _default(typeObject) {
    return function(block) {
      if (typeof typeObject === "function") {
        // handle case where typeObject is already a function
        return typeObject(block);
      }

      return typeObject[block.type];
    };
  };

  exports["default"] = _default;
});

_commonjsHelpers.unwrapExports(blockTypeObjectFunction);

var getBlockTags_1 = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = getBlockTags;

  var _invariant = interopRequireDefault(browser);

  var _react = interopRequireDefault(React__default);

  var _server = interopRequireDefault(server);

  var _splitReactElement = interopRequireDefault(splitReactElement_1);

  function hasChildren(element) {
    return (
      _react["default"].isValidElement(element) &&
      _react["default"].Children.count(element.props.children) > 0
    );
  }

  function getBlockTags(blockHTML) {
    (0, _invariant["default"])(
      blockHTML !== null && blockHTML !== undefined,
      "Expected block HTML value to be non-null"
    );

    if (typeof blockHTML === "string") {
      return blockHTML;
    }

    if (_react["default"].isValidElement(blockHTML)) {
      if (hasChildren(blockHTML)) {
        return _server["default"].renderToStaticMarkup(blockHTML);
      }

      return (0, _splitReactElement["default"])(blockHTML);
    }

    if (
      Object.prototype.hasOwnProperty.call(blockHTML, "element") &&
      _react["default"].isValidElement(blockHTML.element)
    ) {
      return Object.assign(
        {},
        blockHTML,
        (0, _splitReactElement["default"])(blockHTML.element)
      );
    }

    (0, _invariant["default"])(
      Object.prototype.hasOwnProperty.call(blockHTML, "start") &&
        Object.prototype.hasOwnProperty.call(blockHTML, "end"),
      "convertToHTML: received block information without either a ReactElement or an object with start/end tags"
    );
    return blockHTML;
  }
});

_commonjsHelpers.unwrapExports(getBlockTags_1);

var getNestedBlockTags_1 = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = getNestedBlockTags;

  var _invariant = interopRequireDefault(browser);

  var _react = interopRequireDefault(React__default);

  var _splitReactElement2 = interopRequireDefault(splitReactElement_1);

  function getNestedBlockTags(blockHTML) {
    (0, _invariant["default"])(
      blockHTML !== null && blockHTML !== undefined,
      "Expected block HTML value to be non-null"
    );

    if (_react["default"].isValidElement(blockHTML.nest)) {
      var _splitReactElement = (0, _splitReactElement2["default"])(
          blockHTML.nest
        ),
        start = _splitReactElement.start,
        end = _splitReactElement.end;

      return Object.assign({}, blockHTML, {
        nestStart: start,
        nestEnd: end
      });
    }

    (0, _invariant["default"])(
      Object.prototype.hasOwnProperty.call(blockHTML, "nestStart") &&
        Object.prototype.hasOwnProperty.call(blockHTML, "nestEnd"),
      "convertToHTML: received block information without either a ReactElement or an object with start/end tags"
    );
    return blockHTML;
  }
});

_commonjsHelpers.unwrapExports(getNestedBlockTags_1);

var defaultBlockHTML = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = void 0;

  var _react = interopRequireDefault(React__default);

  var _default = {
    unstyled: _react["default"].createElement("p", null),
    paragraph: _react["default"].createElement("p", null),
    "header-one": _react["default"].createElement("h1", null),
    "header-two": _react["default"].createElement("h2", null),
    "header-three": _react["default"].createElement("h3", null),
    "header-four": _react["default"].createElement("h4", null),
    "header-five": _react["default"].createElement("h5", null),
    "header-six": _react["default"].createElement("h6", null),
    blockquote: _react["default"].createElement("blockquote", null),
    "unordered-list-item": {
      element: _react["default"].createElement("li", null),
      nest: _react["default"].createElement("ul", null)
    },
    "ordered-list-item": {
      element: _react["default"].createElement("li", null),
      nest: _react["default"].createElement("ol", null)
    },
    media: _react["default"].createElement("figure", null),
    atomic: _react["default"].createElement("figure", null)
  };
  exports["default"] = _default;
});

_commonjsHelpers.unwrapExports(defaultBlockHTML);

var convertToHTML_1 = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = void 0;

  var _invariant = interopRequireDefault(browser);

  var _react = interopRequireDefault(React__default);

  var _server = interopRequireDefault(server);

  var _encodeBlock = interopRequireDefault(encodeBlock);

  var _blockEntities = interopRequireDefault(blockEntities);

  var _blockInlineStyles = interopRequireDefault(blockInlineStyles);

  var _accumulateFunction = interopRequireDefault(accumulateFunction);

  var _blockTypeObjectFunction = interopRequireDefault(blockTypeObjectFunction);

  var _getBlockTags = interopRequireDefault(getBlockTags_1);

  var _getNestedBlockTags = interopRequireDefault(getNestedBlockTags_1);

  var _defaultBlockHTML = interopRequireDefault(defaultBlockHTML);

  // import Immutable from 'immutable'; // eslint-disable-line no-unused-vars
  var defaultEntityToHTML = function defaultEntityToHTML(entity, originalText) {
    return originalText;
  };

  var convertToHTML = function convertToHTML(_ref) {
    var _ref$styleToHTML = _ref.styleToHTML,
      styleToHTML = _ref$styleToHTML === void 0 ? {} : _ref$styleToHTML,
      _ref$blockToHTML = _ref.blockToHTML,
      blockToHTML = _ref$blockToHTML === void 0 ? {} : _ref$blockToHTML,
      _ref$entityToHTML = _ref.entityToHTML,
      entityToHTML =
        _ref$entityToHTML === void 0 ? defaultEntityToHTML : _ref$entityToHTML;
    return function(contentState) {
      (0, _invariant["default"])(
        contentState !== null && contentState !== undefined,
        "Expected contentState to be non-null"
      );
      var getBlockHTML;

      if (blockToHTML.__isMiddleware === true) {
        getBlockHTML = blockToHTML(
          (0, _blockTypeObjectFunction["default"])(_defaultBlockHTML["default"])
        );
      } else {
        getBlockHTML = (0, _accumulateFunction["default"])(
          (0, _blockTypeObjectFunction["default"])(blockToHTML),
          (0, _blockTypeObjectFunction["default"])(_defaultBlockHTML["default"])
        );
      }

      var rawState = (0, Draft.convertToRaw)(contentState);
      var listStack = [];
      var result = rawState.blocks
        .map(function(block) {
          var type = block.type,
            depth = block.depth;
          var closeNestTags = "";
          var openNestTags = "";
          var blockHTMLResult = getBlockHTML(block);

          if (!blockHTMLResult) {
            throw new Error(
              "convertToHTML: missing HTML definition for block with type ".concat(
                block.type
              )
            );
          }

          if (!blockHTMLResult.nest) {
            // this block can't be nested, so reset all nesting if necessary
            closeNestTags = listStack.reduceRight(function(
              string,
              nestedBlock
            ) {
              return (
                string +
                (0, _getNestedBlockTags["default"])(getBlockHTML(nestedBlock))
                  .nestEnd
              );
            },
            "");
            listStack = [];
          } else {
            while (
              depth + 1 !== listStack.length ||
              type !== listStack[depth].type
            ) {
              if (depth + 1 === listStack.length) {
                // depth is right but doesn't match type
                var blockToClose = listStack[depth];
                closeNestTags += (0, _getNestedBlockTags["default"])(
                  getBlockHTML(blockToClose)
                ).nestEnd;
                openNestTags += (0, _getNestedBlockTags["default"])(
                  getBlockHTML(block)
                ).nestStart;
                listStack[depth] = block;
              } else if (depth + 1 < listStack.length) {
                var _blockToClose = listStack[listStack.length - 1];
                closeNestTags += (0, _getNestedBlockTags["default"])(
                  getBlockHTML(_blockToClose)
                ).nestEnd;
                listStack = listStack.slice(0, -1);
              } else {
                openNestTags += (0, _getNestedBlockTags["default"])(
                  getBlockHTML(block)
                ).nestStart;
                listStack.push(block);
              }
            }
          }

          var innerHTML = (0, _blockInlineStyles["default"])(
            (0, _blockEntities["default"])(
              (0, _encodeBlock["default"])(block),
              rawState.entityMap,
              entityToHTML
            ),
            styleToHTML
          );
          var blockHTML = (0, _getBlockTags["default"])(getBlockHTML(block));
          var html;

          if (typeof blockHTML === "string") {
            html = blockHTML;
          } else {
            html = blockHTML.start + innerHTML + blockHTML.end;
          }

          if (
            innerHTML.length === 0 &&
            Object.prototype.hasOwnProperty.call(blockHTML, "empty")
          ) {
            if (_react["default"].isValidElement(blockHTML.empty)) {
              html = _server["default"].renderToStaticMarkup(blockHTML.empty);
            } else {
              html = blockHTML.empty;
            }
          }

          return closeNestTags + openNestTags + html;
        })
        .join("");
      result = listStack.reduce(function(res, nestBlock) {
        return (
          res +
          (0, _getNestedBlockTags["default"])(getBlockHTML(nestBlock)).nestEnd
        );
      }, result);
      return result;
    };
  };

  var _default = function _default() {
    for (
      var _len = arguments.length, args = new Array(_len), _key = 0;
      _key < _len;
      _key++
    ) {
      args[_key] = arguments[_key];
    }

    if (
      args.length === 1 &&
      Object.prototype.hasOwnProperty.call(args[0], "_map") &&
      args[0].getBlockMap != null
    ) {
      // skip higher-order function and use defaults
      return convertToHTML({}).apply(void 0, args);
    }

    return convertToHTML.apply(void 0, args);
  };

  exports["default"] = _default;
});

_commonjsHelpers.unwrapExports(convertToHTML_1);

var immutable$2 = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  /**
   *  Copyright (c) 2014-2015, Facebook, Inc.
   *  All rights reserved.
   *
   *  This source code is licensed under the BSD-style license found in the
   *  LICENSE file in the root directory of this source tree. An additional grant
   *  of patent rights can be found in the PATENTS file in the same directory.
   */

  (function(global, factory) {
    module.exports = factory();
  })(_commonjsHelpers.commonjsGlobal, function() {
    var SLICE$0 = Array.prototype.slice;

    function createClass(ctor, superClass) {
      if (superClass) {
        ctor.prototype = Object.create(superClass.prototype);
      }
      ctor.prototype.constructor = ctor;
    }

    function Iterable(value) {
      return isIterable(value) ? value : Seq(value);
    }

    createClass(KeyedIterable, Iterable);
    function KeyedIterable(value) {
      return isKeyed(value) ? value : KeyedSeq(value);
    }

    createClass(IndexedIterable, Iterable);
    function IndexedIterable(value) {
      return isIndexed(value) ? value : IndexedSeq(value);
    }

    createClass(SetIterable, Iterable);
    function SetIterable(value) {
      return isIterable(value) && !isAssociative(value) ? value : SetSeq(value);
    }

    function isIterable(maybeIterable) {
      return !!(maybeIterable && maybeIterable[IS_ITERABLE_SENTINEL]);
    }

    function isKeyed(maybeKeyed) {
      return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL]);
    }

    function isIndexed(maybeIndexed) {
      return !!(maybeIndexed && maybeIndexed[IS_INDEXED_SENTINEL]);
    }

    function isAssociative(maybeAssociative) {
      return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);
    }

    function isOrdered(maybeOrdered) {
      return !!(maybeOrdered && maybeOrdered[IS_ORDERED_SENTINEL]);
    }

    Iterable.isIterable = isIterable;
    Iterable.isKeyed = isKeyed;
    Iterable.isIndexed = isIndexed;
    Iterable.isAssociative = isAssociative;
    Iterable.isOrdered = isOrdered;

    Iterable.Keyed = KeyedIterable;
    Iterable.Indexed = IndexedIterable;
    Iterable.Set = SetIterable;

    var IS_ITERABLE_SENTINEL = "@@__IMMUTABLE_ITERABLE__@@";
    var IS_KEYED_SENTINEL = "@@__IMMUTABLE_KEYED__@@";
    var IS_INDEXED_SENTINEL = "@@__IMMUTABLE_INDEXED__@@";
    var IS_ORDERED_SENTINEL = "@@__IMMUTABLE_ORDERED__@@";

    // Used for setting prototype methods that IE8 chokes on.
    var DELETE = "delete";

    // Constants describing the size of trie nodes.
    var SHIFT = 5; // Resulted in best performance after ______?
    var SIZE = 1 << SHIFT;
    var MASK = SIZE - 1;

    // A consistent shared value representing "not set" which equals nothing other
    // than itself, and nothing that could be provided externally.
    var NOT_SET = {};

    // Boolean references, Rough equivalent of `bool &`.
    var CHANGE_LENGTH = { value: false };
    var DID_ALTER = { value: false };

    function MakeRef(ref) {
      ref.value = false;
      return ref;
    }

    function SetRef(ref) {
      ref && (ref.value = true);
    }

    // A function which returns a value representing an "owner" for transient writes
    // to tries. The return value will only ever equal itself, and will not equal
    // the return of any subsequent call of this function.
    function OwnerID() {}

    // http://jsperf.com/copy-array-inline
    function arrCopy(arr, offset) {
      offset = offset || 0;
      var len = Math.max(0, arr.length - offset);
      var newArr = new Array(len);
      for (var ii = 0; ii < len; ii++) {
        newArr[ii] = arr[ii + offset];
      }
      return newArr;
    }

    function ensureSize(iter) {
      if (iter.size === undefined) {
        iter.size = iter.__iterate(returnTrue);
      }
      return iter.size;
    }

    function wrapIndex(iter, index) {
      // This implements "is array index" which the ECMAString spec defines as:
      //
      //     A String property name P is an array index if and only if
      //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal
      //     to 2^32−1.
      //
      // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects
      if (typeof index !== "number") {
        var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32
        if ("" + uint32Index !== index || uint32Index === 4294967295) {
          return NaN;
        }
        index = uint32Index;
      }
      return index < 0 ? ensureSize(iter) + index : index;
    }

    function returnTrue() {
      return true;
    }

    function wholeSlice(begin, end, size) {
      return (
        (begin === 0 || (size !== undefined && begin <= -size)) &&
        (end === undefined || (size !== undefined && end >= size))
      );
    }

    function resolveBegin(begin, size) {
      return resolveIndex(begin, size, 0);
    }

    function resolveEnd(end, size) {
      return resolveIndex(end, size, size);
    }

    function resolveIndex(index, size, defaultIndex) {
      return index === undefined
        ? defaultIndex
        : index < 0
        ? Math.max(0, size + index)
        : size === undefined
        ? index
        : Math.min(size, index);
    }

    /* global Symbol */

    var ITERATE_KEYS = 0;
    var ITERATE_VALUES = 1;
    var ITERATE_ENTRIES = 2;

    var REAL_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
    var FAUX_ITERATOR_SYMBOL = "@@iterator";

    var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;

    function Iterator(next) {
      this.next = next;
    }

    Iterator.prototype.toString = function() {
      return "[Iterator]";
    };

    Iterator.KEYS = ITERATE_KEYS;
    Iterator.VALUES = ITERATE_VALUES;
    Iterator.ENTRIES = ITERATE_ENTRIES;

    Iterator.prototype.inspect = Iterator.prototype.toSource = function() {
      return this.toString();
    };
    Iterator.prototype[ITERATOR_SYMBOL] = function() {
      return this;
    };

    function iteratorValue(type, k, v, iteratorResult) {
      var value = type === 0 ? k : type === 1 ? v : [k, v];
      iteratorResult
        ? (iteratorResult.value = value)
        : (iteratorResult = {
            value: value,
            done: false
          });
      return iteratorResult;
    }

    function iteratorDone() {
      return { value: undefined, done: true };
    }

    function hasIterator(maybeIterable) {
      return !!getIteratorFn(maybeIterable);
    }

    function isIterator(maybeIterator) {
      return maybeIterator && typeof maybeIterator.next === "function";
    }

    function getIterator(iterable) {
      var iteratorFn = getIteratorFn(iterable);
      return iteratorFn && iteratorFn.call(iterable);
    }

    function getIteratorFn(iterable) {
      var iteratorFn =
        iterable &&
        ((REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||
          iterable[FAUX_ITERATOR_SYMBOL]);
      if (typeof iteratorFn === "function") {
        return iteratorFn;
      }
    }

    function isArrayLike(value) {
      return value && typeof value.length === "number";
    }

    createClass(Seq, Iterable);
    function Seq(value) {
      return value === null || value === undefined
        ? emptySequence()
        : isIterable(value)
        ? value.toSeq()
        : seqFromValue(value);
    }

    Seq.of = function(/*...values*/) {
      return Seq(arguments);
    };

    Seq.prototype.toSeq = function() {
      return this;
    };

    Seq.prototype.toString = function() {
      return this.__toString("Seq {", "}");
    };

    Seq.prototype.cacheResult = function() {
      if (!this._cache && this.__iterateUncached) {
        this._cache = this.entrySeq().toArray();
        this.size = this._cache.length;
      }
      return this;
    };

    // abstract __iterateUncached(fn, reverse)

    Seq.prototype.__iterate = function(fn, reverse) {
      return seqIterate(this, fn, reverse, true);
    };

    // abstract __iteratorUncached(type, reverse)

    Seq.prototype.__iterator = function(type, reverse) {
      return seqIterator(this, type, reverse, true);
    };

    createClass(KeyedSeq, Seq);
    function KeyedSeq(value) {
      return value === null || value === undefined
        ? emptySequence().toKeyedSeq()
        : isIterable(value)
        ? isKeyed(value)
          ? value.toSeq()
          : value.fromEntrySeq()
        : keyedSeqFromValue(value);
    }

    KeyedSeq.prototype.toKeyedSeq = function() {
      return this;
    };

    createClass(IndexedSeq, Seq);
    function IndexedSeq(value) {
      return value === null || value === undefined
        ? emptySequence()
        : !isIterable(value)
        ? indexedSeqFromValue(value)
        : isKeyed(value)
        ? value.entrySeq()
        : value.toIndexedSeq();
    }

    IndexedSeq.of = function(/*...values*/) {
      return IndexedSeq(arguments);
    };

    IndexedSeq.prototype.toIndexedSeq = function() {
      return this;
    };

    IndexedSeq.prototype.toString = function() {
      return this.__toString("Seq [", "]");
    };

    IndexedSeq.prototype.__iterate = function(fn, reverse) {
      return seqIterate(this, fn, reverse, false);
    };

    IndexedSeq.prototype.__iterator = function(type, reverse) {
      return seqIterator(this, type, reverse, false);
    };

    createClass(SetSeq, Seq);
    function SetSeq(value) {
      return (value === null || value === undefined
        ? emptySequence()
        : !isIterable(value)
        ? indexedSeqFromValue(value)
        : isKeyed(value)
        ? value.entrySeq()
        : value
      ).toSetSeq();
    }

    SetSeq.of = function(/*...values*/) {
      return SetSeq(arguments);
    };

    SetSeq.prototype.toSetSeq = function() {
      return this;
    };

    Seq.isSeq = isSeq;
    Seq.Keyed = KeyedSeq;
    Seq.Set = SetSeq;
    Seq.Indexed = IndexedSeq;

    var IS_SEQ_SENTINEL = "@@__IMMUTABLE_SEQ__@@";

    Seq.prototype[IS_SEQ_SENTINEL] = true;

    createClass(ArraySeq, IndexedSeq);
    function ArraySeq(array) {
      this._array = array;
      this.size = array.length;
    }

    ArraySeq.prototype.get = function(index, notSetValue) {
      return this.has(index)
        ? this._array[wrapIndex(this, index)]
        : notSetValue;
    };

    ArraySeq.prototype.__iterate = function(fn, reverse) {
      var array = this._array;
      var maxIndex = array.length - 1;
      for (var ii = 0; ii <= maxIndex; ii++) {
        if (fn(array[reverse ? maxIndex - ii : ii], ii, this) === false) {
          return ii + 1;
        }
      }
      return ii;
    };

    ArraySeq.prototype.__iterator = function(type, reverse) {
      var array = this._array;
      var maxIndex = array.length - 1;
      var ii = 0;
      return new Iterator(function() {
        return ii > maxIndex
          ? iteratorDone()
          : iteratorValue(type, ii, array[reverse ? maxIndex - ii++ : ii++]);
      });
    };

    createClass(ObjectSeq, KeyedSeq);
    function ObjectSeq(object) {
      var keys = Object.keys(object);
      this._object = object;
      this._keys = keys;
      this.size = keys.length;
    }

    ObjectSeq.prototype.get = function(key, notSetValue) {
      if (notSetValue !== undefined && !this.has(key)) {
        return notSetValue;
      }
      return this._object[key];
    };

    ObjectSeq.prototype.has = function(key) {
      return this._object.hasOwnProperty(key);
    };

    ObjectSeq.prototype.__iterate = function(fn, reverse) {
      var object = this._object;
      var keys = this._keys;
      var maxIndex = keys.length - 1;
      for (var ii = 0; ii <= maxIndex; ii++) {
        var key = keys[reverse ? maxIndex - ii : ii];
        if (fn(object[key], key, this) === false) {
          return ii + 1;
        }
      }
      return ii;
    };

    ObjectSeq.prototype.__iterator = function(type, reverse) {
      var object = this._object;
      var keys = this._keys;
      var maxIndex = keys.length - 1;
      var ii = 0;
      return new Iterator(function() {
        var key = keys[reverse ? maxIndex - ii : ii];
        return ii++ > maxIndex
          ? iteratorDone()
          : iteratorValue(type, key, object[key]);
      });
    };

    ObjectSeq.prototype[IS_ORDERED_SENTINEL] = true;

    createClass(IterableSeq, IndexedSeq);
    function IterableSeq(iterable) {
      this._iterable = iterable;
      this.size = iterable.length || iterable.size;
    }

    IterableSeq.prototype.__iterateUncached = function(fn, reverse) {
      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);
      }
      var iterable = this._iterable;
      var iterator = getIterator(iterable);
      var iterations = 0;
      if (isIterator(iterator)) {
        var step;
        while (!(step = iterator.next()).done) {
          if (fn(step.value, iterations++, this) === false) {
            break;
          }
        }
      }
      return iterations;
    };

    IterableSeq.prototype.__iteratorUncached = function(type, reverse) {
      if (reverse) {
        return this.cacheResult().__iterator(type, reverse);
      }
      var iterable = this._iterable;
      var iterator = getIterator(iterable);
      if (!isIterator(iterator)) {
        return new Iterator(iteratorDone);
      }
      var iterations = 0;
      return new Iterator(function() {
        var step = iterator.next();
        return step.done ? step : iteratorValue(type, iterations++, step.value);
      });
    };

    createClass(IteratorSeq, IndexedSeq);
    function IteratorSeq(iterator) {
      this._iterator = iterator;
      this._iteratorCache = [];
    }

    IteratorSeq.prototype.__iterateUncached = function(fn, reverse) {
      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);
      }
      var iterator = this._iterator;
      var cache = this._iteratorCache;
      var iterations = 0;
      while (iterations < cache.length) {
        if (fn(cache[iterations], iterations++, this) === false) {
          return iterations;
        }
      }
      var step;
      while (!(step = iterator.next()).done) {
        var val = step.value;
        cache[iterations] = val;
        if (fn(val, iterations++, this) === false) {
          break;
        }
      }
      return iterations;
    };

    IteratorSeq.prototype.__iteratorUncached = function(type, reverse) {
      if (reverse) {
        return this.cacheResult().__iterator(type, reverse);
      }
      var iterator = this._iterator;
      var cache = this._iteratorCache;
      var iterations = 0;
      return new Iterator(function() {
        if (iterations >= cache.length) {
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          cache[iterations] = step.value;
        }
        return iteratorValue(type, iterations, cache[iterations++]);
      });
    };

    // # pragma Helper functions

    function isSeq(maybeSeq) {
      return !!(maybeSeq && maybeSeq[IS_SEQ_SENTINEL]);
    }

    var EMPTY_SEQ;

    function emptySequence() {
      return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));
    }

    function keyedSeqFromValue(value) {
      var seq = Array.isArray(value)
        ? new ArraySeq(value).fromEntrySeq()
        : isIterator(value)
        ? new IteratorSeq(value).fromEntrySeq()
        : hasIterator(value)
        ? new IterableSeq(value).fromEntrySeq()
        : typeof value === "object"
        ? new ObjectSeq(value)
        : undefined;
      if (!seq) {
        throw new TypeError(
          "Expected Array or iterable object of [k, v] entries, " +
            "or keyed object: " +
            value
        );
      }
      return seq;
    }

    function indexedSeqFromValue(value) {
      var seq = maybeIndexedSeqFromValue(value);
      if (!seq) {
        throw new TypeError(
          "Expected Array or iterable object of values: " + value
        );
      }
      return seq;
    }

    function seqFromValue(value) {
      var seq =
        maybeIndexedSeqFromValue(value) ||
        (typeof value === "object" && new ObjectSeq(value));
      if (!seq) {
        throw new TypeError(
          "Expected Array or iterable object of values, or keyed object: " +
            value
        );
      }
      return seq;
    }

    function maybeIndexedSeqFromValue(value) {
      return isArrayLike(value)
        ? new ArraySeq(value)
        : isIterator(value)
        ? new IteratorSeq(value)
        : hasIterator(value)
        ? new IterableSeq(value)
        : undefined;
    }

    function seqIterate(seq, fn, reverse, useKeys) {
      var cache = seq._cache;
      if (cache) {
        var maxIndex = cache.length - 1;
        for (var ii = 0; ii <= maxIndex; ii++) {
          var entry = cache[reverse ? maxIndex - ii : ii];
          if (fn(entry[1], useKeys ? entry[0] : ii, seq) === false) {
            return ii + 1;
          }
        }
        return ii;
      }
      return seq.__iterateUncached(fn, reverse);
    }

    function seqIterator(seq, type, reverse, useKeys) {
      var cache = seq._cache;
      if (cache) {
        var maxIndex = cache.length - 1;
        var ii = 0;
        return new Iterator(function() {
          var entry = cache[reverse ? maxIndex - ii : ii];
          return ii++ > maxIndex
            ? iteratorDone()
            : iteratorValue(type, useKeys ? entry[0] : ii - 1, entry[1]);
        });
      }
      return seq.__iteratorUncached(type, reverse);
    }

    function fromJS(json, converter) {
      return converter
        ? fromJSWith(converter, json, "", { "": json })
        : fromJSDefault(json);
    }

    function fromJSWith(converter, json, key, parentJSON) {
      if (Array.isArray(json)) {
        return converter.call(
          parentJSON,
          key,
          IndexedSeq(json).map(function(v, k) {
            return fromJSWith(converter, v, k, json);
          })
        );
      }
      if (isPlainObj(json)) {
        return converter.call(
          parentJSON,
          key,
          KeyedSeq(json).map(function(v, k) {
            return fromJSWith(converter, v, k, json);
          })
        );
      }
      return json;
    }

    function fromJSDefault(json) {
      if (Array.isArray(json)) {
        return IndexedSeq(json)
          .map(fromJSDefault)
          .toList();
      }
      if (isPlainObj(json)) {
        return KeyedSeq(json)
          .map(fromJSDefault)
          .toMap();
      }
      return json;
    }

    function isPlainObj(value) {
      return (
        value &&
        (value.constructor === Object || value.constructor === undefined)
      );
    }

    /**
     * An extension of the "same-value" algorithm as [described for use by ES6 Map
     * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)
     *
     * NaN is considered the same as NaN, however -0 and 0 are considered the same
     * value, which is different from the algorithm described by
     * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
     *
     * This is extended further to allow Objects to describe the values they
     * represent, by way of `valueOf` or `equals` (and `hashCode`).
     *
     * Note: because of this extension, the key equality of Immutable.Map and the
     * value equality of Immutable.Set will differ from ES6 Map and Set.
     *
     * ### Defining custom values
     *
     * The easiest way to describe the value an object represents is by implementing
     * `valueOf`. For example, `Date` represents a value by returning a unix
     * timestamp for `valueOf`:
     *
     *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...
     *     var date2 = new Date(1234567890000);
     *     date1.valueOf(); // 1234567890000
     *     assert( date1 !== date2 );
     *     assert( Immutable.is( date1, date2 ) );
     *
     * Note: overriding `valueOf` may have other implications if you use this object
     * where JavaScript expects a primitive, such as implicit string coercion.
     *
     * For more complex types, especially collections, implementing `valueOf` may
     * not be performant. An alternative is to implement `equals` and `hashCode`.
     *
     * `equals` takes another object, presumably of similar type, and returns true
     * if the it is equal. Equality is symmetrical, so the same result should be
     * returned if this and the argument are flipped.
     *
     *     assert( a.equals(b) === b.equals(a) );
     *
     * `hashCode` returns a 32bit integer number representing the object which will
     * be used to determine how to store the value object in a Map or Set. You must
     * provide both or neither methods, one must not exist without the other.
     *
     * Also, an important relationship between these methods must be upheld: if two
     * values are equal, they *must* return the same hashCode. If the values are not
     * equal, they might have the same hashCode; this is called a hash collision,
     * and while undesirable for performance reasons, it is acceptable.
     *
     *     if (a.equals(b)) {
     *       assert( a.hashCode() === b.hashCode() );
     *     }
     *
     * All Immutable collections implement `equals` and `hashCode`.
     *
     */
    function is(valueA, valueB) {
      if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
        return true;
      }
      if (!valueA || !valueB) {
        return false;
      }
      if (
        typeof valueA.valueOf === "function" &&
        typeof valueB.valueOf === "function"
      ) {
        valueA = valueA.valueOf();
        valueB = valueB.valueOf();
        if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
          return true;
        }
        if (!valueA || !valueB) {
          return false;
        }
      }
      if (
        typeof valueA.equals === "function" &&
        typeof valueB.equals === "function" &&
        valueA.equals(valueB)
      ) {
        return true;
      }
      return false;
    }

    function deepEqual(a, b) {
      if (a === b) {
        return true;
      }

      if (
        !isIterable(b) ||
        (a.size !== undefined && b.size !== undefined && a.size !== b.size) ||
        (a.__hash !== undefined &&
          b.__hash !== undefined &&
          a.__hash !== b.__hash) ||
        isKeyed(a) !== isKeyed(b) ||
        isIndexed(a) !== isIndexed(b) ||
        isOrdered(a) !== isOrdered(b)
      ) {
        return false;
      }

      if (a.size === 0 && b.size === 0) {
        return true;
      }

      var notAssociative = !isAssociative(a);

      if (isOrdered(a)) {
        var entries = a.entries();
        return (
          b.every(function(v, k) {
            var entry = entries.next().value;
            return (
              entry && is(entry[1], v) && (notAssociative || is(entry[0], k))
            );
          }) && entries.next().done
        );
      }

      var flipped = false;

      if (a.size === undefined) {
        if (b.size === undefined) {
          if (typeof a.cacheResult === "function") {
            a.cacheResult();
          }
        } else {
          flipped = true;
          var _ = a;
          a = b;
          b = _;
        }
      }

      var allEqual = true;
      var bSize = b.__iterate(function(v, k) {
        if (
          notAssociative
            ? !a.has(v)
            : flipped
            ? !is(v, a.get(k, NOT_SET))
            : !is(a.get(k, NOT_SET), v)
        ) {
          allEqual = false;
          return false;
        }
      });

      return allEqual && a.size === bSize;
    }

    createClass(Repeat, IndexedSeq);

    function Repeat(value, times) {
      if (!(this instanceof Repeat)) {
        return new Repeat(value, times);
      }
      this._value = value;
      this.size = times === undefined ? Infinity : Math.max(0, times);
      if (this.size === 0) {
        if (EMPTY_REPEAT) {
          return EMPTY_REPEAT;
        }
        EMPTY_REPEAT = this;
      }
    }

    Repeat.prototype.toString = function() {
      if (this.size === 0) {
        return "Repeat []";
      }
      return "Repeat [ " + this._value + " " + this.size + " times ]";
    };

    Repeat.prototype.get = function(index, notSetValue) {
      return this.has(index) ? this._value : notSetValue;
    };

    Repeat.prototype.includes = function(searchValue) {
      return is(this._value, searchValue);
    };

    Repeat.prototype.slice = function(begin, end) {
      var size = this.size;
      return wholeSlice(begin, end, size)
        ? this
        : new Repeat(
            this._value,
            resolveEnd(end, size) - resolveBegin(begin, size)
          );
    };

    Repeat.prototype.reverse = function() {
      return this;
    };

    Repeat.prototype.indexOf = function(searchValue) {
      if (is(this._value, searchValue)) {
        return 0;
      }
      return -1;
    };

    Repeat.prototype.lastIndexOf = function(searchValue) {
      if (is(this._value, searchValue)) {
        return this.size;
      }
      return -1;
    };

    Repeat.prototype.__iterate = function(fn, reverse) {
      for (var ii = 0; ii < this.size; ii++) {
        if (fn(this._value, ii, this) === false) {
          return ii + 1;
        }
      }
      return ii;
    };

    Repeat.prototype.__iterator = function(type, reverse) {
      var this$0 = this;
      var ii = 0;
      return new Iterator(function() {
        return ii < this$0.size
          ? iteratorValue(type, ii++, this$0._value)
          : iteratorDone();
      });
    };

    Repeat.prototype.equals = function(other) {
      return other instanceof Repeat
        ? is(this._value, other._value)
        : deepEqual(other);
    };

    var EMPTY_REPEAT;

    function invariant(condition, error) {
      if (!condition) throw new Error(error);
    }

    createClass(Range, IndexedSeq);

    function Range(start, end, step) {
      if (!(this instanceof Range)) {
        return new Range(start, end, step);
      }
      invariant(step !== 0, "Cannot step a Range by 0");
      start = start || 0;
      if (end === undefined) {
        end = Infinity;
      }
      step = step === undefined ? 1 : Math.abs(step);
      if (end < start) {
        step = -step;
      }
      this._start = start;
      this._end = end;
      this._step = step;
      this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);
      if (this.size === 0) {
        if (EMPTY_RANGE) {
          return EMPTY_RANGE;
        }
        EMPTY_RANGE = this;
      }
    }

    Range.prototype.toString = function() {
      if (this.size === 0) {
        return "Range []";
      }
      return (
        "Range [ " +
        this._start +
        "..." +
        this._end +
        (this._step > 1 ? " by " + this._step : "") +
        " ]"
      );
    };

    Range.prototype.get = function(index, notSetValue) {
      return this.has(index)
        ? this._start + wrapIndex(this, index) * this._step
        : notSetValue;
    };

    Range.prototype.includes = function(searchValue) {
      var possibleIndex = (searchValue - this._start) / this._step;
      return (
        possibleIndex >= 0 &&
        possibleIndex < this.size &&
        possibleIndex === Math.floor(possibleIndex)
      );
    };

    Range.prototype.slice = function(begin, end) {
      if (wholeSlice(begin, end, this.size)) {
        return this;
      }
      begin = resolveBegin(begin, this.size);
      end = resolveEnd(end, this.size);
      if (end <= begin) {
        return new Range(0, 0);
      }
      return new Range(
        this.get(begin, this._end),
        this.get(end, this._end),
        this._step
      );
    };

    Range.prototype.indexOf = function(searchValue) {
      var offsetValue = searchValue - this._start;
      if (offsetValue % this._step === 0) {
        var index = offsetValue / this._step;
        if (index >= 0 && index < this.size) {
          return index;
        }
      }
      return -1;
    };

    Range.prototype.lastIndexOf = function(searchValue) {
      return this.indexOf(searchValue);
    };

    Range.prototype.__iterate = function(fn, reverse) {
      var maxIndex = this.size - 1;
      var step = this._step;
      var value = reverse ? this._start + maxIndex * step : this._start;
      for (var ii = 0; ii <= maxIndex; ii++) {
        if (fn(value, ii, this) === false) {
          return ii + 1;
        }
        value += reverse ? -step : step;
      }
      return ii;
    };

    Range.prototype.__iterator = function(type, reverse) {
      var maxIndex = this.size - 1;
      var step = this._step;
      var value = reverse ? this._start + maxIndex * step : this._start;
      var ii = 0;
      return new Iterator(function() {
        var v = value;
        value += reverse ? -step : step;
        return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii++, v);
      });
    };

    Range.prototype.equals = function(other) {
      return other instanceof Range
        ? this._start === other._start &&
            this._end === other._end &&
            this._step === other._step
        : deepEqual(this, other);
    };

    var EMPTY_RANGE;

    createClass(Collection, Iterable);
    function Collection() {
      throw TypeError("Abstract");
    }

    createClass(KeyedCollection, Collection);
    function KeyedCollection() {}

    createClass(IndexedCollection, Collection);
    function IndexedCollection() {}

    createClass(SetCollection, Collection);
    function SetCollection() {}

    Collection.Keyed = KeyedCollection;
    Collection.Indexed = IndexedCollection;
    Collection.Set = SetCollection;

    var imul =
      typeof Math.imul === "function" && Math.imul(0xffffffff, 2) === -2
        ? Math.imul
        : function imul(a, b) {
            a = a | 0; // int
            b = b | 0; // int
            var c = a & 0xffff;
            var d = b & 0xffff;
            // Shift by 0 fixes the sign on the high part.
            return (
              (c * d + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0)) | 0
            ); // int
          };

    // v8 has an optimization for storing 31-bit signed numbers.
    // Values which have either 00 or 11 as the high order bits qualify.
    // This function drops the highest order bit in a signed number, maintaining
    // the sign bit.
    function smi(i32) {
      return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff);
    }

    function hash(o) {
      if (o === false || o === null || o === undefined) {
        return 0;
      }
      if (typeof o.valueOf === "function") {
        o = o.valueOf();
        if (o === false || o === null || o === undefined) {
          return 0;
        }
      }
      if (o === true) {
        return 1;
      }
      var type = typeof o;
      if (type === "number") {
        var h = o | 0;
        if (h !== o) {
          h ^= o * 0xffffffff;
        }
        while (o > 0xffffffff) {
          o /= 0xffffffff;
          h ^= o;
        }
        return smi(h);
      }
      if (type === "string") {
        return o.length > STRING_HASH_CACHE_MIN_STRLEN
          ? cachedHashString(o)
          : hashString(o);
      }
      if (typeof o.hashCode === "function") {
        return o.hashCode();
      }
      if (type === "object") {
        return hashJSObj(o);
      }
      if (typeof o.toString === "function") {
        return hashString(o.toString());
      }
      throw new Error("Value type " + type + " cannot be hashed.");
    }

    function cachedHashString(string) {
      var hash = stringHashCache[string];
      if (hash === undefined) {
        hash = hashString(string);
        if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {
          STRING_HASH_CACHE_SIZE = 0;
          stringHashCache = {};
        }
        STRING_HASH_CACHE_SIZE++;
        stringHashCache[string] = hash;
      }
      return hash;
    }

    // http://jsperf.com/hashing-strings
    function hashString(string) {
      // This is the hash from JVM
      // The hash code for a string is computed as
      // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],
      // where s[i] is the ith character of the string and n is the length of
      // the string. We "mod" the result to make it between 0 (inclusive) and 2^31
      // (exclusive) by dropping high bits.
      var hash = 0;
      for (var ii = 0; ii < string.length; ii++) {
        hash = (31 * hash + string.charCodeAt(ii)) | 0;
      }
      return smi(hash);
    }

    function hashJSObj(obj) {
      var hash;
      if (usingWeakMap) {
        hash = weakMap.get(obj);
        if (hash !== undefined) {
          return hash;
        }
      }

      hash = obj[UID_HASH_KEY];
      if (hash !== undefined) {
        return hash;
      }

      if (!canDefineProperty) {
        hash =
          obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];
        if (hash !== undefined) {
          return hash;
        }

        hash = getIENodeHash(obj);
        if (hash !== undefined) {
          return hash;
        }
      }

      hash = ++objHashUID;
      if (objHashUID & 0x40000000) {
        objHashUID = 0;
      }

      if (usingWeakMap) {
        weakMap.set(obj, hash);
      } else if (isExtensible !== undefined && isExtensible(obj) === false) {
        throw new Error("Non-extensible objects are not allowed as keys.");
      } else if (canDefineProperty) {
        Object.defineProperty(obj, UID_HASH_KEY, {
          enumerable: false,
          configurable: false,
          writable: false,
          value: hash
        });
      } else if (
        obj.propertyIsEnumerable !== undefined &&
        obj.propertyIsEnumerable ===
          obj.constructor.prototype.propertyIsEnumerable
      ) {
        // Since we can't define a non-enumerable property on the object
        // we'll hijack one of the less-used non-enumerable properties to
        // save our hash on it. Since this is a function it will not show up in
        // `JSON.stringify` which is what we want.
        obj.propertyIsEnumerable = function() {
          return this.constructor.prototype.propertyIsEnumerable.apply(
            this,
            arguments
          );
        };
        obj.propertyIsEnumerable[UID_HASH_KEY] = hash;
      } else if (obj.nodeType !== undefined) {
        // At this point we couldn't get the IE `uniqueID` to use as a hash
        // and we couldn't use a non-enumerable property to exploit the
        // dontEnum bug so we simply add the `UID_HASH_KEY` on the node
        // itself.
        obj[UID_HASH_KEY] = hash;
      } else {
        throw new Error("Unable to set a non-enumerable property on object.");
      }

      return hash;
    }

    // Get references to ES5 object methods.
    var isExtensible = Object.isExtensible;

    // True if Object.defineProperty works as expected. IE8 fails this test.
    var canDefineProperty = (function() {
      try {
        Object.defineProperty({}, "@", {});
        return true;
      } catch (e) {
        return false;
      }
    })();

    // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it
    // and avoid memory leaks from the IE cloneNode bug.
    function getIENodeHash(node) {
      if (node && node.nodeType > 0) {
        switch (node.nodeType) {
          case 1: // Element
            return node.uniqueID;
          case 9: // Document
            return node.documentElement && node.documentElement.uniqueID;
        }
      }
    }

    // If possible, use a WeakMap.
    var usingWeakMap = typeof WeakMap === "function";
    var weakMap;
    if (usingWeakMap) {
      weakMap = new WeakMap();
    }

    var objHashUID = 0;

    var UID_HASH_KEY = "__immutablehash__";
    if (typeof Symbol === "function") {
      UID_HASH_KEY = Symbol(UID_HASH_KEY);
    }

    var STRING_HASH_CACHE_MIN_STRLEN = 16;
    var STRING_HASH_CACHE_MAX_SIZE = 255;
    var STRING_HASH_CACHE_SIZE = 0;
    var stringHashCache = {};

    function assertNotInfinite(size) {
      invariant(
        size !== Infinity,
        "Cannot perform this action with an infinite size."
      );
    }

    createClass(Map, KeyedCollection);

    // @pragma Construction

    function Map(value) {
      return value === null || value === undefined
        ? emptyMap()
        : isMap(value) && !isOrdered(value)
        ? value
        : emptyMap().withMutations(function(map) {
            var iter = KeyedIterable(value);
            assertNotInfinite(iter.size);
            iter.forEach(function(v, k) {
              return map.set(k, v);
            });
          });
    }

    Map.prototype.toString = function() {
      return this.__toString("Map {", "}");
    };

    // @pragma Access

    Map.prototype.get = function(k, notSetValue) {
      return this._root
        ? this._root.get(0, undefined, k, notSetValue)
        : notSetValue;
    };

    // @pragma Modification

    Map.prototype.set = function(k, v) {
      return updateMap(this, k, v);
    };

    Map.prototype.setIn = function(keyPath, v) {
      return this.updateIn(keyPath, NOT_SET, function() {
        return v;
      });
    };

    Map.prototype.remove = function(k) {
      return updateMap(this, k, NOT_SET);
    };

    Map.prototype.deleteIn = function(keyPath) {
      return this.updateIn(keyPath, function() {
        return NOT_SET;
      });
    };

    Map.prototype.update = function(k, notSetValue, updater) {
      return arguments.length === 1
        ? k(this)
        : this.updateIn([k], notSetValue, updater);
    };

    Map.prototype.updateIn = function(keyPath, notSetValue, updater) {
      if (!updater) {
        updater = notSetValue;
        notSetValue = undefined;
      }
      var updatedValue = updateInDeepMap(
        this,
        forceIterator(keyPath),
        notSetValue,
        updater
      );
      return updatedValue === NOT_SET ? undefined : updatedValue;
    };

    Map.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = 0;
        this._root = null;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return emptyMap();
    };

    // @pragma Composition

    Map.prototype.merge = function(/*...iters*/) {
      return mergeIntoMapWith(this, undefined, arguments);
    };

    Map.prototype.mergeWith = function(merger) {
      var iters = SLICE$0.call(arguments, 1);
      return mergeIntoMapWith(this, merger, iters);
    };

    Map.prototype.mergeIn = function(keyPath) {
      var iters = SLICE$0.call(arguments, 1);
      return this.updateIn(keyPath, emptyMap(), function(m) {
        return typeof m.merge === "function"
          ? m.merge.apply(m, iters)
          : iters[iters.length - 1];
      });
    };

    Map.prototype.mergeDeep = function(/*...iters*/) {
      return mergeIntoMapWith(this, deepMerger, arguments);
    };

    Map.prototype.mergeDeepWith = function(merger) {
      var iters = SLICE$0.call(arguments, 1);
      return mergeIntoMapWith(this, deepMergerWith(merger), iters);
    };

    Map.prototype.mergeDeepIn = function(keyPath) {
      var iters = SLICE$0.call(arguments, 1);
      return this.updateIn(keyPath, emptyMap(), function(m) {
        return typeof m.mergeDeep === "function"
          ? m.mergeDeep.apply(m, iters)
          : iters[iters.length - 1];
      });
    };

    Map.prototype.sort = function(comparator) {
      // Late binding
      return OrderedMap(sortFactory(this, comparator));
    };

    Map.prototype.sortBy = function(mapper, comparator) {
      // Late binding
      return OrderedMap(sortFactory(this, comparator, mapper));
    };

    // @pragma Mutability

    Map.prototype.withMutations = function(fn) {
      var mutable = this.asMutable();
      fn(mutable);
      return mutable.wasAltered()
        ? mutable.__ensureOwner(this.__ownerID)
        : this;
    };

    Map.prototype.asMutable = function() {
      return this.__ownerID ? this : this.__ensureOwner(new OwnerID());
    };

    Map.prototype.asImmutable = function() {
      return this.__ensureOwner();
    };

    Map.prototype.wasAltered = function() {
      return this.__altered;
    };

    Map.prototype.__iterator = function(type, reverse) {
      return new MapIterator(this, type, reverse);
    };

    Map.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      var iterations = 0;
      this._root &&
        this._root.iterate(function(entry) {
          iterations++;
          return fn(entry[1], entry[0], this$0);
        }, reverse);
      return iterations;
    };

    Map.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {
        this.__ownerID = ownerID;
        this.__altered = false;
        return this;
      }
      return makeMap(this.size, this._root, ownerID, this.__hash);
    };

    function isMap(maybeMap) {
      return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]);
    }

    Map.isMap = isMap;

    var IS_MAP_SENTINEL = "@@__IMMUTABLE_MAP__@@";

    var MapPrototype = Map.prototype;
    MapPrototype[IS_MAP_SENTINEL] = true;
    MapPrototype[DELETE] = MapPrototype.remove;
    MapPrototype.removeIn = MapPrototype.deleteIn;

    // #pragma Trie Nodes

    function ArrayMapNode(ownerID, entries) {
      this.ownerID = ownerID;
      this.entries = entries;
    }

    ArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {
      var entries = this.entries;
      for (var ii = 0, len = entries.length; ii < len; ii++) {
        if (is(key, entries[ii][0])) {
          return entries[ii][1];
        }
      }
      return notSetValue;
    };

    ArrayMapNode.prototype.update = function(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      var removed = value === NOT_SET;

      var entries = this.entries;
      var idx = 0;
      for (var len = entries.length; idx < len; idx++) {
        if (is(key, entries[idx][0])) {
          break;
        }
      }
      var exists = idx < len;

      if (exists ? entries[idx][1] === value : removed) {
        return this;
      }

      SetRef(didAlter);
      (removed || !exists) && SetRef(didChangeSize);

      if (removed && entries.length === 1) {
        return; // undefined
      }

      if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {
        return createNodes(ownerID, entries, key, value);
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newEntries = isEditable ? entries : arrCopy(entries);

      if (exists) {
        if (removed) {
          idx === len - 1
            ? newEntries.pop()
            : (newEntries[idx] = newEntries.pop());
        } else {
          newEntries[idx] = [key, value];
        }
      } else {
        newEntries.push([key, value]);
      }

      if (isEditable) {
        this.entries = newEntries;
        return this;
      }

      return new ArrayMapNode(ownerID, newEntries);
    };

    function BitmapIndexedNode(ownerID, bitmap, nodes) {
      this.ownerID = ownerID;
      this.bitmap = bitmap;
      this.nodes = nodes;
    }

    BitmapIndexedNode.prototype.get = function(
      shift,
      keyHash,
      key,
      notSetValue
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var bit = 1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK);
      var bitmap = this.bitmap;
      return (bitmap & bit) === 0
        ? notSetValue
        : this.nodes[popCount(bitmap & (bit - 1))].get(
            shift + SHIFT,
            keyHash,
            key,
            notSetValue
          );
    };

    BitmapIndexedNode.prototype.update = function(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
      var bit = 1 << keyHashFrag;
      var bitmap = this.bitmap;
      var exists = (bitmap & bit) !== 0;

      if (!exists && value === NOT_SET) {
        return this;
      }

      var idx = popCount(bitmap & (bit - 1));
      var nodes = this.nodes;
      var node = exists ? nodes[idx] : undefined;
      var newNode = updateNode(
        node,
        ownerID,
        shift + SHIFT,
        keyHash,
        key,
        value,
        didChangeSize,
        didAlter
      );

      if (newNode === node) {
        return this;
      }

      if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {
        return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);
      }

      if (
        exists &&
        !newNode &&
        nodes.length === 2 &&
        isLeafNode(nodes[idx ^ 1])
      ) {
        return nodes[idx ^ 1];
      }

      if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {
        return newNode;
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newBitmap = exists ? (newNode ? bitmap : bitmap ^ bit) : bitmap | bit;
      var newNodes = exists
        ? newNode
          ? setIn(nodes, idx, newNode, isEditable)
          : spliceOut(nodes, idx, isEditable)
        : spliceIn(nodes, idx, newNode, isEditable);

      if (isEditable) {
        this.bitmap = newBitmap;
        this.nodes = newNodes;
        return this;
      }

      return new BitmapIndexedNode(ownerID, newBitmap, newNodes);
    };

    function HashArrayMapNode(ownerID, count, nodes) {
      this.ownerID = ownerID;
      this.count = count;
      this.nodes = nodes;
    }

    HashArrayMapNode.prototype.get = function(
      shift,
      keyHash,
      key,
      notSetValue
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
      var node = this.nodes[idx];
      return node
        ? node.get(shift + SHIFT, keyHash, key, notSetValue)
        : notSetValue;
    };

    HashArrayMapNode.prototype.update = function(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
      var removed = value === NOT_SET;
      var nodes = this.nodes;
      var node = nodes[idx];

      if (removed && !node) {
        return this;
      }

      var newNode = updateNode(
        node,
        ownerID,
        shift + SHIFT,
        keyHash,
        key,
        value,
        didChangeSize,
        didAlter
      );
      if (newNode === node) {
        return this;
      }

      var newCount = this.count;
      if (!node) {
        newCount++;
      } else if (!newNode) {
        newCount--;
        if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {
          return packNodes(ownerID, nodes, newCount, idx);
        }
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newNodes = setIn(nodes, idx, newNode, isEditable);

      if (isEditable) {
        this.count = newCount;
        this.nodes = newNodes;
        return this;
      }

      return new HashArrayMapNode(ownerID, newCount, newNodes);
    };

    function HashCollisionNode(ownerID, keyHash, entries) {
      this.ownerID = ownerID;
      this.keyHash = keyHash;
      this.entries = entries;
    }

    HashCollisionNode.prototype.get = function(
      shift,
      keyHash,
      key,
      notSetValue
    ) {
      var entries = this.entries;
      for (var ii = 0, len = entries.length; ii < len; ii++) {
        if (is(key, entries[ii][0])) {
          return entries[ii][1];
        }
      }
      return notSetValue;
    };

    HashCollisionNode.prototype.update = function(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }

      var removed = value === NOT_SET;

      if (keyHash !== this.keyHash) {
        if (removed) {
          return this;
        }
        SetRef(didAlter);
        SetRef(didChangeSize);
        return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);
      }

      var entries = this.entries;
      var idx = 0;
      for (var len = entries.length; idx < len; idx++) {
        if (is(key, entries[idx][0])) {
          break;
        }
      }
      var exists = idx < len;

      if (exists ? entries[idx][1] === value : removed) {
        return this;
      }

      SetRef(didAlter);
      (removed || !exists) && SetRef(didChangeSize);

      if (removed && len === 2) {
        return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newEntries = isEditable ? entries : arrCopy(entries);

      if (exists) {
        if (removed) {
          idx === len - 1
            ? newEntries.pop()
            : (newEntries[idx] = newEntries.pop());
        } else {
          newEntries[idx] = [key, value];
        }
      } else {
        newEntries.push([key, value]);
      }

      if (isEditable) {
        this.entries = newEntries;
        return this;
      }

      return new HashCollisionNode(ownerID, this.keyHash, newEntries);
    };

    function ValueNode(ownerID, keyHash, entry) {
      this.ownerID = ownerID;
      this.keyHash = keyHash;
      this.entry = entry;
    }

    ValueNode.prototype.get = function(shift, keyHash, key, notSetValue) {
      return is(key, this.entry[0]) ? this.entry[1] : notSetValue;
    };

    ValueNode.prototype.update = function(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      var removed = value === NOT_SET;
      var keyMatch = is(key, this.entry[0]);
      if (keyMatch ? value === this.entry[1] : removed) {
        return this;
      }

      SetRef(didAlter);

      if (removed) {
        SetRef(didChangeSize);
        return; // undefined
      }

      if (keyMatch) {
        if (ownerID && ownerID === this.ownerID) {
          this.entry[1] = value;
          return this;
        }
        return new ValueNode(ownerID, this.keyHash, [key, value]);
      }

      SetRef(didChangeSize);
      return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);
    };

    // #pragma Iterators

    ArrayMapNode.prototype.iterate = HashCollisionNode.prototype.iterate = function(
      fn,
      reverse
    ) {
      var entries = this.entries;
      for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {
        if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {
          return false;
        }
      }
    };

    BitmapIndexedNode.prototype.iterate = HashArrayMapNode.prototype.iterate = function(
      fn,
      reverse
    ) {
      var nodes = this.nodes;
      for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {
        var node = nodes[reverse ? maxIndex - ii : ii];
        if (node && node.iterate(fn, reverse) === false) {
          return false;
        }
      }
    };

    ValueNode.prototype.iterate = function(fn, reverse) {
      return fn(this.entry);
    };

    createClass(MapIterator, Iterator);

    function MapIterator(map, type, reverse) {
      this._type = type;
      this._reverse = reverse;
      this._stack = map._root && mapIteratorFrame(map._root);
    }

    MapIterator.prototype.next = function() {
      var type = this._type;
      var stack = this._stack;
      while (stack) {
        var node = stack.node;
        var index = stack.index++;
        var maxIndex;
        if (node.entry) {
          if (index === 0) {
            return mapIteratorValue(type, node.entry);
          }
        } else if (node.entries) {
          maxIndex = node.entries.length - 1;
          if (index <= maxIndex) {
            return mapIteratorValue(
              type,
              node.entries[this._reverse ? maxIndex - index : index]
            );
          }
        } else {
          maxIndex = node.nodes.length - 1;
          if (index <= maxIndex) {
            var subNode = node.nodes[this._reverse ? maxIndex - index : index];
            if (subNode) {
              if (subNode.entry) {
                return mapIteratorValue(type, subNode.entry);
              }
              stack = this._stack = mapIteratorFrame(subNode, stack);
            }
            continue;
          }
        }
        stack = this._stack = this._stack.__prev;
      }
      return iteratorDone();
    };

    function mapIteratorValue(type, entry) {
      return iteratorValue(type, entry[0], entry[1]);
    }

    function mapIteratorFrame(node, prev) {
      return {
        node: node,
        index: 0,
        __prev: prev
      };
    }

    function makeMap(size, root, ownerID, hash) {
      var map = Object.create(MapPrototype);
      map.size = size;
      map._root = root;
      map.__ownerID = ownerID;
      map.__hash = hash;
      map.__altered = false;
      return map;
    }

    var EMPTY_MAP;
    function emptyMap() {
      return EMPTY_MAP || (EMPTY_MAP = makeMap(0));
    }

    function updateMap(map, k, v) {
      var newRoot;
      var newSize;
      if (!map._root) {
        if (v === NOT_SET) {
          return map;
        }
        newSize = 1;
        newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);
      } else {
        var didChangeSize = MakeRef(CHANGE_LENGTH);
        var didAlter = MakeRef(DID_ALTER);
        newRoot = updateNode(
          map._root,
          map.__ownerID,
          0,
          undefined,
          k,
          v,
          didChangeSize,
          didAlter
        );
        if (!didAlter.value) {
          return map;
        }
        newSize =
          map.size + (didChangeSize.value ? (v === NOT_SET ? -1 : 1) : 0);
      }
      if (map.__ownerID) {
        map.size = newSize;
        map._root = newRoot;
        map.__hash = undefined;
        map.__altered = true;
        return map;
      }
      return newRoot ? makeMap(newSize, newRoot) : emptyMap();
    }

    function updateNode(
      node,
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (!node) {
        if (value === NOT_SET) {
          return node;
        }
        SetRef(didAlter);
        SetRef(didChangeSize);
        return new ValueNode(ownerID, keyHash, [key, value]);
      }
      return node.update(
        ownerID,
        shift,
        keyHash,
        key,
        value,
        didChangeSize,
        didAlter
      );
    }

    function isLeafNode(node) {
      return (
        node.constructor === ValueNode || node.constructor === HashCollisionNode
      );
    }

    function mergeIntoNode(node, ownerID, shift, keyHash, entry) {
      if (node.keyHash === keyHash) {
        return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);
      }

      var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;
      var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;

      var newNode;
      var nodes =
        idx1 === idx2
          ? [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)]
          : ((newNode = new ValueNode(ownerID, keyHash, entry)),
            idx1 < idx2 ? [node, newNode] : [newNode, node]);

      return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);
    }

    function createNodes(ownerID, entries, key, value) {
      if (!ownerID) {
        ownerID = new OwnerID();
      }
      var node = new ValueNode(ownerID, hash(key), [key, value]);
      for (var ii = 0; ii < entries.length; ii++) {
        var entry = entries[ii];
        node = node.update(ownerID, 0, undefined, entry[0], entry[1]);
      }
      return node;
    }

    function packNodes(ownerID, nodes, count, excluding) {
      var bitmap = 0;
      var packedII = 0;
      var packedNodes = new Array(count);
      for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {
        var node = nodes[ii];
        if (node !== undefined && ii !== excluding) {
          bitmap |= bit;
          packedNodes[packedII++] = node;
        }
      }
      return new BitmapIndexedNode(ownerID, bitmap, packedNodes);
    }

    function expandNodes(ownerID, nodes, bitmap, including, node) {
      var count = 0;
      var expandedNodes = new Array(SIZE);
      for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {
        expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;
      }
      expandedNodes[including] = node;
      return new HashArrayMapNode(ownerID, count + 1, expandedNodes);
    }

    function mergeIntoMapWith(map, merger, iterables) {
      var iters = [];
      for (var ii = 0; ii < iterables.length; ii++) {
        var value = iterables[ii];
        var iter = KeyedIterable(value);
        if (!isIterable(value)) {
          iter = iter.map(function(v) {
            return fromJS(v);
          });
        }
        iters.push(iter);
      }
      return mergeIntoCollectionWith(map, merger, iters);
    }

    function deepMerger(existing, value, key) {
      return existing && existing.mergeDeep && isIterable(value)
        ? existing.mergeDeep(value)
        : is(existing, value)
        ? existing
        : value;
    }

    function deepMergerWith(merger) {
      return function(existing, value, key) {
        if (existing && existing.mergeDeepWith && isIterable(value)) {
          return existing.mergeDeepWith(merger, value);
        }
        var nextValue = merger(existing, value, key);
        return is(existing, nextValue) ? existing : nextValue;
      };
    }

    function mergeIntoCollectionWith(collection, merger, iters) {
      iters = iters.filter(function(x) {
        return x.size !== 0;
      });
      if (iters.length === 0) {
        return collection;
      }
      if (
        collection.size === 0 &&
        !collection.__ownerID &&
        iters.length === 1
      ) {
        return collection.constructor(iters[0]);
      }
      return collection.withMutations(function(collection) {
        var mergeIntoMap = merger
          ? function(value, key) {
              collection.update(key, NOT_SET, function(existing) {
                return existing === NOT_SET
                  ? value
                  : merger(existing, value, key);
              });
            }
          : function(value, key) {
              collection.set(key, value);
            };
        for (var ii = 0; ii < iters.length; ii++) {
          iters[ii].forEach(mergeIntoMap);
        }
      });
    }

    function updateInDeepMap(existing, keyPathIter, notSetValue, updater) {
      var isNotSet = existing === NOT_SET;
      var step = keyPathIter.next();
      if (step.done) {
        var existingValue = isNotSet ? notSetValue : existing;
        var newValue = updater(existingValue);
        return newValue === existingValue ? existing : newValue;
      }
      invariant(isNotSet || (existing && existing.set), "invalid keyPath");
      var key = step.value;
      var nextExisting = isNotSet ? NOT_SET : existing.get(key, NOT_SET);
      var nextUpdated = updateInDeepMap(
        nextExisting,
        keyPathIter,
        notSetValue,
        updater
      );
      return nextUpdated === nextExisting
        ? existing
        : nextUpdated === NOT_SET
        ? existing.remove(key)
        : (isNotSet ? emptyMap() : existing).set(key, nextUpdated);
    }

    function popCount(x) {
      x = x - ((x >> 1) & 0x55555555);
      x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
      x = (x + (x >> 4)) & 0x0f0f0f0f;
      x = x + (x >> 8);
      x = x + (x >> 16);
      return x & 0x7f;
    }

    function setIn(array, idx, val, canEdit) {
      var newArray = canEdit ? array : arrCopy(array);
      newArray[idx] = val;
      return newArray;
    }

    function spliceIn(array, idx, val, canEdit) {
      var newLen = array.length + 1;
      if (canEdit && idx + 1 === newLen) {
        array[idx] = val;
        return array;
      }
      var newArray = new Array(newLen);
      var after = 0;
      for (var ii = 0; ii < newLen; ii++) {
        if (ii === idx) {
          newArray[ii] = val;
          after = -1;
        } else {
          newArray[ii] = array[ii + after];
        }
      }
      return newArray;
    }

    function spliceOut(array, idx, canEdit) {
      var newLen = array.length - 1;
      if (canEdit && idx === newLen) {
        array.pop();
        return array;
      }
      var newArray = new Array(newLen);
      var after = 0;
      for (var ii = 0; ii < newLen; ii++) {
        if (ii === idx) {
          after = 1;
        }
        newArray[ii] = array[ii + after];
      }
      return newArray;
    }

    var MAX_ARRAY_MAP_SIZE = SIZE / 4;
    var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;
    var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;

    createClass(List, IndexedCollection);

    // @pragma Construction

    function List(value) {
      var empty = emptyList();
      if (value === null || value === undefined) {
        return empty;
      }
      if (isList(value)) {
        return value;
      }
      var iter = IndexedIterable(value);
      var size = iter.size;
      if (size === 0) {
        return empty;
      }
      assertNotInfinite(size);
      if (size > 0 && size < SIZE) {
        return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));
      }
      return empty.withMutations(function(list) {
        list.setSize(size);
        iter.forEach(function(v, i) {
          return list.set(i, v);
        });
      });
    }

    List.of = function(/*...values*/) {
      return this(arguments);
    };

    List.prototype.toString = function() {
      return this.__toString("List [", "]");
    };

    // @pragma Access

    List.prototype.get = function(index, notSetValue) {
      index = wrapIndex(this, index);
      if (index >= 0 && index < this.size) {
        index += this._origin;
        var node = listNodeFor(this, index);
        return node && node.array[index & MASK];
      }
      return notSetValue;
    };

    // @pragma Modification

    List.prototype.set = function(index, value) {
      return updateList(this, index, value);
    };

    List.prototype.remove = function(index) {
      return !this.has(index)
        ? this
        : index === 0
        ? this.shift()
        : index === this.size - 1
        ? this.pop()
        : this.splice(index, 1);
    };

    List.prototype.insert = function(index, value) {
      return this.splice(index, 0, value);
    };

    List.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = this._origin = this._capacity = 0;
        this._level = SHIFT;
        this._root = this._tail = null;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return emptyList();
    };

    List.prototype.push = function(/*...values*/) {
      var values = arguments;
      var oldSize = this.size;
      return this.withMutations(function(list) {
        setListBounds(list, 0, oldSize + values.length);
        for (var ii = 0; ii < values.length; ii++) {
          list.set(oldSize + ii, values[ii]);
        }
      });
    };

    List.prototype.pop = function() {
      return setListBounds(this, 0, -1);
    };

    List.prototype.unshift = function(/*...values*/) {
      var values = arguments;
      return this.withMutations(function(list) {
        setListBounds(list, -values.length);
        for (var ii = 0; ii < values.length; ii++) {
          list.set(ii, values[ii]);
        }
      });
    };

    List.prototype.shift = function() {
      return setListBounds(this, 1);
    };

    // @pragma Composition

    List.prototype.merge = function(/*...iters*/) {
      return mergeIntoListWith(this, undefined, arguments);
    };

    List.prototype.mergeWith = function(merger) {
      var iters = SLICE$0.call(arguments, 1);
      return mergeIntoListWith(this, merger, iters);
    };

    List.prototype.mergeDeep = function(/*...iters*/) {
      return mergeIntoListWith(this, deepMerger, arguments);
    };

    List.prototype.mergeDeepWith = function(merger) {
      var iters = SLICE$0.call(arguments, 1);
      return mergeIntoListWith(this, deepMergerWith(merger), iters);
    };

    List.prototype.setSize = function(size) {
      return setListBounds(this, 0, size);
    };

    // @pragma Iteration

    List.prototype.slice = function(begin, end) {
      var size = this.size;
      if (wholeSlice(begin, end, size)) {
        return this;
      }
      return setListBounds(
        this,
        resolveBegin(begin, size),
        resolveEnd(end, size)
      );
    };

    List.prototype.__iterator = function(type, reverse) {
      var index = 0;
      var values = iterateList(this, reverse);
      return new Iterator(function() {
        var value = values();
        return value === DONE
          ? iteratorDone()
          : iteratorValue(type, index++, value);
      });
    };

    List.prototype.__iterate = function(fn, reverse) {
      var index = 0;
      var values = iterateList(this, reverse);
      var value;
      while ((value = values()) !== DONE) {
        if (fn(value, index++, this) === false) {
          break;
        }
      }
      return index;
    };

    List.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {
        this.__ownerID = ownerID;
        return this;
      }
      return makeList(
        this._origin,
        this._capacity,
        this._level,
        this._root,
        this._tail,
        ownerID,
        this.__hash
      );
    };

    function isList(maybeList) {
      return !!(maybeList && maybeList[IS_LIST_SENTINEL]);
    }

    List.isList = isList;

    var IS_LIST_SENTINEL = "@@__IMMUTABLE_LIST__@@";

    var ListPrototype = List.prototype;
    ListPrototype[IS_LIST_SENTINEL] = true;
    ListPrototype[DELETE] = ListPrototype.remove;
    ListPrototype.setIn = MapPrototype.setIn;
    ListPrototype.deleteIn = ListPrototype.removeIn = MapPrototype.removeIn;
    ListPrototype.update = MapPrototype.update;
    ListPrototype.updateIn = MapPrototype.updateIn;
    ListPrototype.mergeIn = MapPrototype.mergeIn;
    ListPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;
    ListPrototype.withMutations = MapPrototype.withMutations;
    ListPrototype.asMutable = MapPrototype.asMutable;
    ListPrototype.asImmutable = MapPrototype.asImmutable;
    ListPrototype.wasAltered = MapPrototype.wasAltered;

    function VNode(array, ownerID) {
      this.array = array;
      this.ownerID = ownerID;
    }

    // TODO: seems like these methods are very similar

    VNode.prototype.removeBefore = function(ownerID, level, index) {
      if (index === level ? 1 << level : this.array.length === 0) {
        return this;
      }
      var originIndex = (index >>> level) & MASK;
      if (originIndex >= this.array.length) {
        return new VNode([], ownerID);
      }
      var removingFirst = originIndex === 0;
      var newChild;
      if (level > 0) {
        var oldChild = this.array[originIndex];
        newChild =
          oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);
        if (newChild === oldChild && removingFirst) {
          return this;
        }
      }
      if (removingFirst && !newChild) {
        return this;
      }
      var editable = editableVNode(this, ownerID);
      if (!removingFirst) {
        for (var ii = 0; ii < originIndex; ii++) {
          editable.array[ii] = undefined;
        }
      }
      if (newChild) {
        editable.array[originIndex] = newChild;
      }
      return editable;
    };

    VNode.prototype.removeAfter = function(ownerID, level, index) {
      if (index === (level ? 1 << level : 0) || this.array.length === 0) {
        return this;
      }
      var sizeIndex = ((index - 1) >>> level) & MASK;
      if (sizeIndex >= this.array.length) {
        return this;
      }

      var newChild;
      if (level > 0) {
        var oldChild = this.array[sizeIndex];
        newChild =
          oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);
        if (newChild === oldChild && sizeIndex === this.array.length - 1) {
          return this;
        }
      }

      var editable = editableVNode(this, ownerID);
      editable.array.splice(sizeIndex + 1);
      if (newChild) {
        editable.array[sizeIndex] = newChild;
      }
      return editable;
    };

    var DONE = {};

    function iterateList(list, reverse) {
      var left = list._origin;
      var right = list._capacity;
      var tailPos = getTailOffset(right);
      var tail = list._tail;

      return iterateNodeOrLeaf(list._root, list._level, 0);

      function iterateNodeOrLeaf(node, level, offset) {
        return level === 0
          ? iterateLeaf(node, offset)
          : iterateNode(node, level, offset);
      }

      function iterateLeaf(node, offset) {
        var array =
          offset === tailPos ? tail && tail.array : node && node.array;
        var from = offset > left ? 0 : left - offset;
        var to = right - offset;
        if (to > SIZE) {
          to = SIZE;
        }
        return function() {
          if (from === to) {
            return DONE;
          }
          var idx = reverse ? --to : from++;
          return array && array[idx];
        };
      }

      function iterateNode(node, level, offset) {
        var values;
        var array = node && node.array;
        var from = offset > left ? 0 : (left - offset) >> level;
        var to = ((right - offset) >> level) + 1;
        if (to > SIZE) {
          to = SIZE;
        }
        return function() {
          do {
            if (values) {
              var value = values();
              if (value !== DONE) {
                return value;
              }
              values = null;
            }
            if (from === to) {
              return DONE;
            }
            var idx = reverse ? --to : from++;
            values = iterateNodeOrLeaf(
              array && array[idx],
              level - SHIFT,
              offset + (idx << level)
            );
          } while (true);
        };
      }
    }

    function makeList(origin, capacity, level, root, tail, ownerID, hash) {
      var list = Object.create(ListPrototype);
      list.size = capacity - origin;
      list._origin = origin;
      list._capacity = capacity;
      list._level = level;
      list._root = root;
      list._tail = tail;
      list.__ownerID = ownerID;
      list.__hash = hash;
      list.__altered = false;
      return list;
    }

    var EMPTY_LIST;
    function emptyList() {
      return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));
    }

    function updateList(list, index, value) {
      index = wrapIndex(list, index);

      if (index !== index) {
        return list;
      }

      if (index >= list.size || index < 0) {
        return list.withMutations(function(list) {
          index < 0
            ? setListBounds(list, index).set(0, value)
            : setListBounds(list, 0, index + 1).set(index, value);
        });
      }

      index += list._origin;

      var newTail = list._tail;
      var newRoot = list._root;
      var didAlter = MakeRef(DID_ALTER);
      if (index >= getTailOffset(list._capacity)) {
        newTail = updateVNode(
          newTail,
          list.__ownerID,
          0,
          index,
          value,
          didAlter
        );
      } else {
        newRoot = updateVNode(
          newRoot,
          list.__ownerID,
          list._level,
          index,
          value,
          didAlter
        );
      }

      if (!didAlter.value) {
        return list;
      }

      if (list.__ownerID) {
        list._root = newRoot;
        list._tail = newTail;
        list.__hash = undefined;
        list.__altered = true;
        return list;
      }
      return makeList(
        list._origin,
        list._capacity,
        list._level,
        newRoot,
        newTail
      );
    }

    function updateVNode(node, ownerID, level, index, value, didAlter) {
      var idx = (index >>> level) & MASK;
      var nodeHas = node && idx < node.array.length;
      if (!nodeHas && value === undefined) {
        return node;
      }

      var newNode;

      if (level > 0) {
        var lowerNode = node && node.array[idx];
        var newLowerNode = updateVNode(
          lowerNode,
          ownerID,
          level - SHIFT,
          index,
          value,
          didAlter
        );
        if (newLowerNode === lowerNode) {
          return node;
        }
        newNode = editableVNode(node, ownerID);
        newNode.array[idx] = newLowerNode;
        return newNode;
      }

      if (nodeHas && node.array[idx] === value) {
        return node;
      }

      SetRef(didAlter);

      newNode = editableVNode(node, ownerID);
      if (value === undefined && idx === newNode.array.length - 1) {
        newNode.array.pop();
      } else {
        newNode.array[idx] = value;
      }
      return newNode;
    }

    function editableVNode(node, ownerID) {
      if (ownerID && node && ownerID === node.ownerID) {
        return node;
      }
      return new VNode(node ? node.array.slice() : [], ownerID);
    }

    function listNodeFor(list, rawIndex) {
      if (rawIndex >= getTailOffset(list._capacity)) {
        return list._tail;
      }
      if (rawIndex < 1 << (list._level + SHIFT)) {
        var node = list._root;
        var level = list._level;
        while (node && level > 0) {
          node = node.array[(rawIndex >>> level) & MASK];
          level -= SHIFT;
        }
        return node;
      }
    }

    function setListBounds(list, begin, end) {
      // Sanitize begin & end using this shorthand for ToInt32(argument)
      // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
      if (begin !== undefined) {
        begin = begin | 0;
      }
      if (end !== undefined) {
        end = end | 0;
      }
      var owner = list.__ownerID || new OwnerID();
      var oldOrigin = list._origin;
      var oldCapacity = list._capacity;
      var newOrigin = oldOrigin + begin;
      var newCapacity =
        end === undefined
          ? oldCapacity
          : end < 0
          ? oldCapacity + end
          : oldOrigin + end;
      if (newOrigin === oldOrigin && newCapacity === oldCapacity) {
        return list;
      }

      // If it's going to end after it starts, it's empty.
      if (newOrigin >= newCapacity) {
        return list.clear();
      }

      var newLevel = list._level;
      var newRoot = list._root;

      // New origin might need creating a higher root.
      var offsetShift = 0;
      while (newOrigin + offsetShift < 0) {
        newRoot = new VNode(
          newRoot && newRoot.array.length ? [undefined, newRoot] : [],
          owner
        );
        newLevel += SHIFT;
        offsetShift += 1 << newLevel;
      }
      if (offsetShift) {
        newOrigin += offsetShift;
        oldOrigin += offsetShift;
        newCapacity += offsetShift;
        oldCapacity += offsetShift;
      }

      var oldTailOffset = getTailOffset(oldCapacity);
      var newTailOffset = getTailOffset(newCapacity);

      // New size might need creating a higher root.
      while (newTailOffset >= 1 << (newLevel + SHIFT)) {
        newRoot = new VNode(
          newRoot && newRoot.array.length ? [newRoot] : [],
          owner
        );
        newLevel += SHIFT;
      }

      // Locate or create the new tail.
      var oldTail = list._tail;
      var newTail =
        newTailOffset < oldTailOffset
          ? listNodeFor(list, newCapacity - 1)
          : newTailOffset > oldTailOffset
          ? new VNode([], owner)
          : oldTail;

      // Merge Tail into tree.
      if (
        oldTail &&
        newTailOffset > oldTailOffset &&
        newOrigin < oldCapacity &&
        oldTail.array.length
      ) {
        newRoot = editableVNode(newRoot, owner);
        var node = newRoot;
        for (var level = newLevel; level > SHIFT; level -= SHIFT) {
          var idx = (oldTailOffset >>> level) & MASK;
          node = node.array[idx] = editableVNode(node.array[idx], owner);
        }
        node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;
      }

      // If the size has been reduced, there's a chance the tail needs to be trimmed.
      if (newCapacity < oldCapacity) {
        newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);
      }

      // If the new origin is within the tail, then we do not need a root.
      if (newOrigin >= newTailOffset) {
        newOrigin -= newTailOffset;
        newCapacity -= newTailOffset;
        newLevel = SHIFT;
        newRoot = null;
        newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);

        // Otherwise, if the root has been trimmed, garbage collect.
      } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {
        offsetShift = 0;

        // Identify the new top root node of the subtree of the old root.
        while (newRoot) {
          var beginIndex = (newOrigin >>> newLevel) & MASK;
          if ((beginIndex !== newTailOffset >>> newLevel) & MASK) {
            break;
          }
          if (beginIndex) {
            offsetShift += (1 << newLevel) * beginIndex;
          }
          newLevel -= SHIFT;
          newRoot = newRoot.array[beginIndex];
        }

        // Trim the new sides of the new root.
        if (newRoot && newOrigin > oldOrigin) {
          newRoot = newRoot.removeBefore(
            owner,
            newLevel,
            newOrigin - offsetShift
          );
        }
        if (newRoot && newTailOffset < oldTailOffset) {
          newRoot = newRoot.removeAfter(
            owner,
            newLevel,
            newTailOffset - offsetShift
          );
        }
        if (offsetShift) {
          newOrigin -= offsetShift;
          newCapacity -= offsetShift;
        }
      }

      if (list.__ownerID) {
        list.size = newCapacity - newOrigin;
        list._origin = newOrigin;
        list._capacity = newCapacity;
        list._level = newLevel;
        list._root = newRoot;
        list._tail = newTail;
        list.__hash = undefined;
        list.__altered = true;
        return list;
      }
      return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);
    }

    function mergeIntoListWith(list, merger, iterables) {
      var iters = [];
      var maxSize = 0;
      for (var ii = 0; ii < iterables.length; ii++) {
        var value = iterables[ii];
        var iter = IndexedIterable(value);
        if (iter.size > maxSize) {
          maxSize = iter.size;
        }
        if (!isIterable(value)) {
          iter = iter.map(function(v) {
            return fromJS(v);
          });
        }
        iters.push(iter);
      }
      if (maxSize > list.size) {
        list = list.setSize(maxSize);
      }
      return mergeIntoCollectionWith(list, merger, iters);
    }

    function getTailOffset(size) {
      return size < SIZE ? 0 : ((size - 1) >>> SHIFT) << SHIFT;
    }

    createClass(OrderedMap, Map);

    // @pragma Construction

    function OrderedMap(value) {
      return value === null || value === undefined
        ? emptyOrderedMap()
        : isOrderedMap(value)
        ? value
        : emptyOrderedMap().withMutations(function(map) {
            var iter = KeyedIterable(value);
            assertNotInfinite(iter.size);
            iter.forEach(function(v, k) {
              return map.set(k, v);
            });
          });
    }

    OrderedMap.of = function(/*...values*/) {
      return this(arguments);
    };

    OrderedMap.prototype.toString = function() {
      return this.__toString("OrderedMap {", "}");
    };

    // @pragma Access

    OrderedMap.prototype.get = function(k, notSetValue) {
      var index = this._map.get(k);
      return index !== undefined ? this._list.get(index)[1] : notSetValue;
    };

    // @pragma Modification

    OrderedMap.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = 0;
        this._map.clear();
        this._list.clear();
        return this;
      }
      return emptyOrderedMap();
    };

    OrderedMap.prototype.set = function(k, v) {
      return updateOrderedMap(this, k, v);
    };

    OrderedMap.prototype.remove = function(k) {
      return updateOrderedMap(this, k, NOT_SET);
    };

    OrderedMap.prototype.wasAltered = function() {
      return this._map.wasAltered() || this._list.wasAltered();
    };

    OrderedMap.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      return this._list.__iterate(function(entry) {
        return entry && fn(entry[1], entry[0], this$0);
      }, reverse);
    };

    OrderedMap.prototype.__iterator = function(type, reverse) {
      return this._list.fromEntrySeq().__iterator(type, reverse);
    };

    OrderedMap.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      var newMap = this._map.__ensureOwner(ownerID);
      var newList = this._list.__ensureOwner(ownerID);
      if (!ownerID) {
        this.__ownerID = ownerID;
        this._map = newMap;
        this._list = newList;
        return this;
      }
      return makeOrderedMap(newMap, newList, ownerID, this.__hash);
    };

    function isOrderedMap(maybeOrderedMap) {
      return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);
    }

    OrderedMap.isOrderedMap = isOrderedMap;

    OrderedMap.prototype[IS_ORDERED_SENTINEL] = true;
    OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;

    function makeOrderedMap(map, list, ownerID, hash) {
      var omap = Object.create(OrderedMap.prototype);
      omap.size = map ? map.size : 0;
      omap._map = map;
      omap._list = list;
      omap.__ownerID = ownerID;
      omap.__hash = hash;
      return omap;
    }

    var EMPTY_ORDERED_MAP;
    function emptyOrderedMap() {
      return (
        EMPTY_ORDERED_MAP ||
        (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()))
      );
    }

    function updateOrderedMap(omap, k, v) {
      var map = omap._map;
      var list = omap._list;
      var i = map.get(k);
      var has = i !== undefined;
      var newMap;
      var newList;
      if (v === NOT_SET) {
        // removed
        if (!has) {
          return omap;
        }
        if (list.size >= SIZE && list.size >= map.size * 2) {
          newList = list.filter(function(entry, idx) {
            return entry !== undefined && i !== idx;
          });
          newMap = newList
            .toKeyedSeq()
            .map(function(entry) {
              return entry[0];
            })
            .flip()
            .toMap();
          if (omap.__ownerID) {
            newMap.__ownerID = newList.__ownerID = omap.__ownerID;
          }
        } else {
          newMap = map.remove(k);
          newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);
        }
      } else {
        if (has) {
          if (v === list.get(i)[1]) {
            return omap;
          }
          newMap = map;
          newList = list.set(i, [k, v]);
        } else {
          newMap = map.set(k, list.size);
          newList = list.set(list.size, [k, v]);
        }
      }
      if (omap.__ownerID) {
        omap.size = newMap.size;
        omap._map = newMap;
        omap._list = newList;
        omap.__hash = undefined;
        return omap;
      }
      return makeOrderedMap(newMap, newList);
    }

    createClass(ToKeyedSequence, KeyedSeq);
    function ToKeyedSequence(indexed, useKeys) {
      this._iter = indexed;
      this._useKeys = useKeys;
      this.size = indexed.size;
    }

    ToKeyedSequence.prototype.get = function(key, notSetValue) {
      return this._iter.get(key, notSetValue);
    };

    ToKeyedSequence.prototype.has = function(key) {
      return this._iter.has(key);
    };

    ToKeyedSequence.prototype.valueSeq = function() {
      return this._iter.valueSeq();
    };

    ToKeyedSequence.prototype.reverse = function() {
      var this$0 = this;
      var reversedSequence = reverseFactory(this, true);
      if (!this._useKeys) {
        reversedSequence.valueSeq = function() {
          return this$0._iter.toSeq().reverse();
        };
      }
      return reversedSequence;
    };

    ToKeyedSequence.prototype.map = function(mapper, context) {
      var this$0 = this;
      var mappedSequence = mapFactory(this, mapper, context);
      if (!this._useKeys) {
        mappedSequence.valueSeq = function() {
          return this$0._iter.toSeq().map(mapper, context);
        };
      }
      return mappedSequence;
    };

    ToKeyedSequence.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      var ii;
      return this._iter.__iterate(
        this._useKeys
          ? function(v, k) {
              return fn(v, k, this$0);
            }
          : ((ii = reverse ? resolveSize(this) : 0),
            function(v) {
              return fn(v, reverse ? --ii : ii++, this$0);
            }),
        reverse
      );
    };

    ToKeyedSequence.prototype.__iterator = function(type, reverse) {
      if (this._useKeys) {
        return this._iter.__iterator(type, reverse);
      }
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      var ii = reverse ? resolveSize(this) : 0;
      return new Iterator(function() {
        var step = iterator.next();
        return step.done
          ? step
          : iteratorValue(type, reverse ? --ii : ii++, step.value, step);
      });
    };

    ToKeyedSequence.prototype[IS_ORDERED_SENTINEL] = true;

    createClass(ToIndexedSequence, IndexedSeq);
    function ToIndexedSequence(iter) {
      this._iter = iter;
      this.size = iter.size;
    }

    ToIndexedSequence.prototype.includes = function(value) {
      return this._iter.includes(value);
    };

    ToIndexedSequence.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      var iterations = 0;
      return this._iter.__iterate(function(v) {
        return fn(v, iterations++, this$0);
      }, reverse);
    };

    ToIndexedSequence.prototype.__iterator = function(type, reverse) {
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      var iterations = 0;
      return new Iterator(function() {
        var step = iterator.next();
        return step.done
          ? step
          : iteratorValue(type, iterations++, step.value, step);
      });
    };

    createClass(ToSetSequence, SetSeq);
    function ToSetSequence(iter) {
      this._iter = iter;
      this.size = iter.size;
    }

    ToSetSequence.prototype.has = function(key) {
      return this._iter.includes(key);
    };

    ToSetSequence.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      return this._iter.__iterate(function(v) {
        return fn(v, v, this$0);
      }, reverse);
    };

    ToSetSequence.prototype.__iterator = function(type, reverse) {
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      return new Iterator(function() {
        var step = iterator.next();
        return step.done
          ? step
          : iteratorValue(type, step.value, step.value, step);
      });
    };

    createClass(FromEntriesSequence, KeyedSeq);
    function FromEntriesSequence(entries) {
      this._iter = entries;
      this.size = entries.size;
    }

    FromEntriesSequence.prototype.entrySeq = function() {
      return this._iter.toSeq();
    };

    FromEntriesSequence.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      return this._iter.__iterate(function(entry) {
        // Check if entry exists first so array access doesn't throw for holes
        // in the parent iteration.
        if (entry) {
          validateEntry(entry);
          var indexedIterable = isIterable(entry);
          return fn(
            indexedIterable ? entry.get(1) : entry[1],
            indexedIterable ? entry.get(0) : entry[0],
            this$0
          );
        }
      }, reverse);
    };

    FromEntriesSequence.prototype.__iterator = function(type, reverse) {
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      return new Iterator(function() {
        while (true) {
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          var entry = step.value;
          // Check if entry exists first so array access doesn't throw for holes
          // in the parent iteration.
          if (entry) {
            validateEntry(entry);
            var indexedIterable = isIterable(entry);
            return iteratorValue(
              type,
              indexedIterable ? entry.get(0) : entry[0],
              indexedIterable ? entry.get(1) : entry[1],
              step
            );
          }
        }
      });
    };

    ToIndexedSequence.prototype.cacheResult = ToKeyedSequence.prototype.cacheResult = ToSetSequence.prototype.cacheResult = FromEntriesSequence.prototype.cacheResult = cacheResultThrough;

    function flipFactory(iterable) {
      var flipSequence = makeSequence(iterable);
      flipSequence._iter = iterable;
      flipSequence.size = iterable.size;
      flipSequence.flip = function() {
        return iterable;
      };
      flipSequence.reverse = function() {
        var reversedSequence = iterable.reverse.apply(this); // super.reverse()
        reversedSequence.flip = function() {
          return iterable.reverse();
        };
        return reversedSequence;
      };
      flipSequence.has = function(key) {
        return iterable.includes(key);
      };
      flipSequence.includes = function(key) {
        return iterable.has(key);
      };
      flipSequence.cacheResult = cacheResultThrough;
      flipSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        return iterable.__iterate(function(v, k) {
          return fn(k, v, this$0) !== false;
        }, reverse);
      };
      flipSequence.__iteratorUncached = function(type, reverse) {
        if (type === ITERATE_ENTRIES) {
          var iterator = iterable.__iterator(type, reverse);
          return new Iterator(function() {
            var step = iterator.next();
            if (!step.done) {
              var k = step.value[0];
              step.value[0] = step.value[1];
              step.value[1] = k;
            }
            return step;
          });
        }
        return iterable.__iterator(
          type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,
          reverse
        );
      };
      return flipSequence;
    }

    function mapFactory(iterable, mapper, context) {
      var mappedSequence = makeSequence(iterable);
      mappedSequence.size = iterable.size;
      mappedSequence.has = function(key) {
        return iterable.has(key);
      };
      mappedSequence.get = function(key, notSetValue) {
        var v = iterable.get(key, NOT_SET);
        return v === NOT_SET
          ? notSetValue
          : mapper.call(context, v, key, iterable);
      };
      mappedSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        return iterable.__iterate(function(v, k, c) {
          return fn(mapper.call(context, v, k, c), k, this$0) !== false;
        }, reverse);
      };
      mappedSequence.__iteratorUncached = function(type, reverse) {
        var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
        return new Iterator(function() {
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          var entry = step.value;
          var key = entry[0];
          return iteratorValue(
            type,
            key,
            mapper.call(context, entry[1], key, iterable),
            step
          );
        });
      };
      return mappedSequence;
    }

    function reverseFactory(iterable, useKeys) {
      var reversedSequence = makeSequence(iterable);
      reversedSequence._iter = iterable;
      reversedSequence.size = iterable.size;
      reversedSequence.reverse = function() {
        return iterable;
      };
      if (iterable.flip) {
        reversedSequence.flip = function() {
          var flipSequence = flipFactory(iterable);
          flipSequence.reverse = function() {
            return iterable.flip();
          };
          return flipSequence;
        };
      }
      reversedSequence.get = function(key, notSetValue) {
        return iterable.get(useKeys ? key : -1 - key, notSetValue);
      };
      reversedSequence.has = function(key) {
        return iterable.has(useKeys ? key : -1 - key);
      };
      reversedSequence.includes = function(value) {
        return iterable.includes(value);
      };
      reversedSequence.cacheResult = cacheResultThrough;
      reversedSequence.__iterate = function(fn, reverse) {
        var this$0 = this;
        return iterable.__iterate(function(v, k) {
          return fn(v, k, this$0);
        }, !reverse);
      };
      reversedSequence.__iterator = function(type, reverse) {
        return iterable.__iterator(type, !reverse);
      };
      return reversedSequence;
    }

    function filterFactory(iterable, predicate, context, useKeys) {
      var filterSequence = makeSequence(iterable);
      if (useKeys) {
        filterSequence.has = function(key) {
          var v = iterable.get(key, NOT_SET);
          return v !== NOT_SET && !!predicate.call(context, v, key, iterable);
        };
        filterSequence.get = function(key, notSetValue) {
          var v = iterable.get(key, NOT_SET);
          return v !== NOT_SET && predicate.call(context, v, key, iterable)
            ? v
            : notSetValue;
        };
      }
      filterSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        var iterations = 0;
        iterable.__iterate(function(v, k, c) {
          if (predicate.call(context, v, k, c)) {
            iterations++;
            return fn(v, useKeys ? k : iterations - 1, this$0);
          }
        }, reverse);
        return iterations;
      };
      filterSequence.__iteratorUncached = function(type, reverse) {
        var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
        var iterations = 0;
        return new Iterator(function() {
          while (true) {
            var step = iterator.next();
            if (step.done) {
              return step;
            }
            var entry = step.value;
            var key = entry[0];
            var value = entry[1];
            if (predicate.call(context, value, key, iterable)) {
              return iteratorValue(
                type,
                useKeys ? key : iterations++,
                value,
                step
              );
            }
          }
        });
      };
      return filterSequence;
    }

    function countByFactory(iterable, grouper, context) {
      var groups = Map().asMutable();
      iterable.__iterate(function(v, k) {
        groups.update(grouper.call(context, v, k, iterable), 0, function(a) {
          return a + 1;
        });
      });
      return groups.asImmutable();
    }

    function groupByFactory(iterable, grouper, context) {
      var isKeyedIter = isKeyed(iterable);
      var groups = (isOrdered(iterable) ? OrderedMap() : Map()).asMutable();
      iterable.__iterate(function(v, k) {
        groups.update(grouper.call(context, v, k, iterable), function(a) {
          return (a = a || []), a.push(isKeyedIter ? [k, v] : v), a;
        });
      });
      var coerce = iterableClass(iterable);
      return groups.map(function(arr) {
        return reify(iterable, coerce(arr));
      });
    }

    function sliceFactory(iterable, begin, end, useKeys) {
      var originalSize = iterable.size;

      // Sanitize begin & end using this shorthand for ToInt32(argument)
      // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
      if (begin !== undefined) {
        begin = begin | 0;
      }
      if (end !== undefined) {
        end = end | 0;
      }

      if (wholeSlice(begin, end, originalSize)) {
        return iterable;
      }

      var resolvedBegin = resolveBegin(begin, originalSize);
      var resolvedEnd = resolveEnd(end, originalSize);

      // begin or end will be NaN if they were provided as negative numbers and
      // this iterable's size is unknown. In that case, cache first so there is
      // a known size and these do not resolve to NaN.
      if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {
        return sliceFactory(
          iterable.toSeq().cacheResult(),
          begin,
          end,
          useKeys
        );
      }

      // Note: resolvedEnd is undefined when the original sequence's length is
      // unknown and this slice did not supply an end and should contain all
      // elements after resolvedBegin.
      // In that case, resolvedSize will be NaN and sliceSize will remain undefined.
      var resolvedSize = resolvedEnd - resolvedBegin;
      var sliceSize;
      if (resolvedSize === resolvedSize) {
        sliceSize = resolvedSize < 0 ? 0 : resolvedSize;
      }

      var sliceSeq = makeSequence(iterable);

      // If iterable.size is undefined, the size of the realized sliceSeq is
      // unknown at this point unless the number of items to slice is 0
      sliceSeq.size =
        sliceSize === 0 ? sliceSize : (iterable.size && sliceSize) || undefined;

      if (!useKeys && isSeq(iterable) && sliceSize >= 0) {
        sliceSeq.get = function(index, notSetValue) {
          index = wrapIndex(this, index);
          return index >= 0 && index < sliceSize
            ? iterable.get(index + resolvedBegin, notSetValue)
            : notSetValue;
        };
      }

      sliceSeq.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        if (sliceSize === 0) {
          return 0;
        }
        if (reverse) {
          return this.cacheResult().__iterate(fn, reverse);
        }
        var skipped = 0;
        var isSkipping = true;
        var iterations = 0;
        iterable.__iterate(function(v, k) {
          if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {
            iterations++;
            return (
              fn(v, useKeys ? k : iterations - 1, this$0) !== false &&
              iterations !== sliceSize
            );
          }
        });
        return iterations;
      };

      sliceSeq.__iteratorUncached = function(type, reverse) {
        if (sliceSize !== 0 && reverse) {
          return this.cacheResult().__iterator(type, reverse);
        }
        // Don't bother instantiating parent iterator if taking 0.
        var iterator = sliceSize !== 0 && iterable.__iterator(type, reverse);
        var skipped = 0;
        var iterations = 0;
        return new Iterator(function() {
          while (skipped++ < resolvedBegin) {
            iterator.next();
          }
          if (++iterations > sliceSize) {
            return iteratorDone();
          }
          var step = iterator.next();
          if (useKeys || type === ITERATE_VALUES) {
            return step;
          } else if (type === ITERATE_KEYS) {
            return iteratorValue(type, iterations - 1, undefined, step);
          } else {
            return iteratorValue(type, iterations - 1, step.value[1], step);
          }
        });
      };

      return sliceSeq;
    }

    function takeWhileFactory(iterable, predicate, context) {
      var takeSequence = makeSequence(iterable);
      takeSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        if (reverse) {
          return this.cacheResult().__iterate(fn, reverse);
        }
        var iterations = 0;
        iterable.__iterate(function(v, k, c) {
          return (
            predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$0)
          );
        });
        return iterations;
      };
      takeSequence.__iteratorUncached = function(type, reverse) {
        var this$0 = this;
        if (reverse) {
          return this.cacheResult().__iterator(type, reverse);
        }
        var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
        var iterating = true;
        return new Iterator(function() {
          if (!iterating) {
            return iteratorDone();
          }
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          var entry = step.value;
          var k = entry[0];
          var v = entry[1];
          if (!predicate.call(context, v, k, this$0)) {
            iterating = false;
            return iteratorDone();
          }
          return type === ITERATE_ENTRIES
            ? step
            : iteratorValue(type, k, v, step);
        });
      };
      return takeSequence;
    }

    function skipWhileFactory(iterable, predicate, context, useKeys) {
      var skipSequence = makeSequence(iterable);
      skipSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        if (reverse) {
          return this.cacheResult().__iterate(fn, reverse);
        }
        var isSkipping = true;
        var iterations = 0;
        iterable.__iterate(function(v, k, c) {
          if (
            !(isSkipping && (isSkipping = predicate.call(context, v, k, c)))
          ) {
            iterations++;
            return fn(v, useKeys ? k : iterations - 1, this$0);
          }
        });
        return iterations;
      };
      skipSequence.__iteratorUncached = function(type, reverse) {
        var this$0 = this;
        if (reverse) {
          return this.cacheResult().__iterator(type, reverse);
        }
        var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
        var skipping = true;
        var iterations = 0;
        return new Iterator(function() {
          var step, k, v;
          do {
            step = iterator.next();
            if (step.done) {
              if (useKeys || type === ITERATE_VALUES) {
                return step;
              } else if (type === ITERATE_KEYS) {
                return iteratorValue(type, iterations++, undefined, step);
              } else {
                return iteratorValue(type, iterations++, step.value[1], step);
              }
            }
            var entry = step.value;
            k = entry[0];
            v = entry[1];
            skipping && (skipping = predicate.call(context, v, k, this$0));
          } while (skipping);
          return type === ITERATE_ENTRIES
            ? step
            : iteratorValue(type, k, v, step);
        });
      };
      return skipSequence;
    }

    function concatFactory(iterable, values) {
      var isKeyedIterable = isKeyed(iterable);
      var iters = [iterable]
        .concat(values)
        .map(function(v) {
          if (!isIterable(v)) {
            v = isKeyedIterable
              ? keyedSeqFromValue(v)
              : indexedSeqFromValue(Array.isArray(v) ? v : [v]);
          } else if (isKeyedIterable) {
            v = KeyedIterable(v);
          }
          return v;
        })
        .filter(function(v) {
          return v.size !== 0;
        });

      if (iters.length === 0) {
        return iterable;
      }

      if (iters.length === 1) {
        var singleton = iters[0];
        if (
          singleton === iterable ||
          (isKeyedIterable && isKeyed(singleton)) ||
          (isIndexed(iterable) && isIndexed(singleton))
        ) {
          return singleton;
        }
      }

      var concatSeq = new ArraySeq(iters);
      if (isKeyedIterable) {
        concatSeq = concatSeq.toKeyedSeq();
      } else if (!isIndexed(iterable)) {
        concatSeq = concatSeq.toSetSeq();
      }
      concatSeq = concatSeq.flatten(true);
      concatSeq.size = iters.reduce(function(sum, seq) {
        if (sum !== undefined) {
          var size = seq.size;
          if (size !== undefined) {
            return sum + size;
          }
        }
      }, 0);
      return concatSeq;
    }

    function flattenFactory(iterable, depth, useKeys) {
      var flatSequence = makeSequence(iterable);
      flatSequence.__iterateUncached = function(fn, reverse) {
        var iterations = 0;
        var stopped = false;
        function flatDeep(iter, currentDepth) {
          var this$0 = this;
          iter.__iterate(function(v, k) {
            if ((!depth || currentDepth < depth) && isIterable(v)) {
              flatDeep(v, currentDepth + 1);
            } else if (fn(v, useKeys ? k : iterations++, this$0) === false) {
              stopped = true;
            }
            return !stopped;
          }, reverse);
        }
        flatDeep(iterable, 0);
        return iterations;
      };
      flatSequence.__iteratorUncached = function(type, reverse) {
        var iterator = iterable.__iterator(type, reverse);
        var stack = [];
        var iterations = 0;
        return new Iterator(function() {
          while (iterator) {
            var step = iterator.next();
            if (step.done !== false) {
              iterator = stack.pop();
              continue;
            }
            var v = step.value;
            if (type === ITERATE_ENTRIES) {
              v = v[1];
            }
            if ((!depth || stack.length < depth) && isIterable(v)) {
              stack.push(iterator);
              iterator = v.__iterator(type, reverse);
            } else {
              return useKeys
                ? step
                : iteratorValue(type, iterations++, v, step);
            }
          }
          return iteratorDone();
        });
      };
      return flatSequence;
    }

    function flatMapFactory(iterable, mapper, context) {
      var coerce = iterableClass(iterable);
      return iterable
        .toSeq()
        .map(function(v, k) {
          return coerce(mapper.call(context, v, k, iterable));
        })
        .flatten(true);
    }

    function interposeFactory(iterable, separator) {
      var interposedSequence = makeSequence(iterable);
      interposedSequence.size = iterable.size && iterable.size * 2 - 1;
      interposedSequence.__iterateUncached = function(fn, reverse) {
        var this$0 = this;
        var iterations = 0;
        iterable.__iterate(function(v, k) {
          return (
            (!iterations || fn(separator, iterations++, this$0) !== false) &&
            fn(v, iterations++, this$0) !== false
          );
        }, reverse);
        return iterations;
      };
      interposedSequence.__iteratorUncached = function(type, reverse) {
        var iterator = iterable.__iterator(ITERATE_VALUES, reverse);
        var iterations = 0;
        var step;
        return new Iterator(function() {
          if (!step || iterations % 2) {
            step = iterator.next();
            if (step.done) {
              return step;
            }
          }
          return iterations % 2
            ? iteratorValue(type, iterations++, separator)
            : iteratorValue(type, iterations++, step.value, step);
        });
      };
      return interposedSequence;
    }

    function sortFactory(iterable, comparator, mapper) {
      if (!comparator) {
        comparator = defaultComparator;
      }
      var isKeyedIterable = isKeyed(iterable);
      var index = 0;
      var entries = iterable
        .toSeq()
        .map(function(v, k) {
          return [k, v, index++, mapper ? mapper(v, k, iterable) : v];
        })
        .toArray();
      entries
        .sort(function(a, b) {
          return comparator(a[3], b[3]) || a[2] - b[2];
        })
        .forEach(
          isKeyedIterable
            ? function(v, i) {
                entries[i].length = 2;
              }
            : function(v, i) {
                entries[i] = v[1];
              }
        );
      return isKeyedIterable
        ? KeyedSeq(entries)
        : isIndexed(iterable)
        ? IndexedSeq(entries)
        : SetSeq(entries);
    }

    function maxFactory(iterable, comparator, mapper) {
      if (!comparator) {
        comparator = defaultComparator;
      }
      if (mapper) {
        var entry = iterable
          .toSeq()
          .map(function(v, k) {
            return [v, mapper(v, k, iterable)];
          })
          .reduce(function(a, b) {
            return maxCompare(comparator, a[1], b[1]) ? b : a;
          });
        return entry && entry[0];
      } else {
        return iterable.reduce(function(a, b) {
          return maxCompare(comparator, a, b) ? b : a;
        });
      }
    }

    function maxCompare(comparator, a, b) {
      var comp = comparator(b, a);
      // b is considered the new max if the comparator declares them equal, but
      // they are not equal and b is in fact a nullish value.
      return (
        (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) ||
        comp > 0
      );
    }

    function zipWithFactory(keyIter, zipper, iters) {
      var zipSequence = makeSequence(keyIter);
      zipSequence.size = new ArraySeq(iters)
        .map(function(i) {
          return i.size;
        })
        .min();
      // Note: this a generic base implementation of __iterate in terms of
      // __iterator which may be more generically useful in the future.
      zipSequence.__iterate = function(fn, reverse) {
        /* generic:
      var iterator = this.__iterator(ITERATE_ENTRIES, reverse);
      var step;
      var iterations = 0;
      while (!(step = iterator.next()).done) {
        iterations++;
        if (fn(step.value[1], step.value[0], this) === false) {
          break;
        }
      }
      return iterations;
      */
        // indexed:
        var iterator = this.__iterator(ITERATE_VALUES, reverse);
        var step;
        var iterations = 0;
        while (!(step = iterator.next()).done) {
          if (fn(step.value, iterations++, this) === false) {
            break;
          }
        }
        return iterations;
      };
      zipSequence.__iteratorUncached = function(type, reverse) {
        var iterators = iters.map(function(i) {
          return (i = Iterable(i)), getIterator(reverse ? i.reverse() : i);
        });
        var iterations = 0;
        var isDone = false;
        return new Iterator(function() {
          var steps;
          if (!isDone) {
            steps = iterators.map(function(i) {
              return i.next();
            });
            isDone = steps.some(function(s) {
              return s.done;
            });
          }
          if (isDone) {
            return iteratorDone();
          }
          return iteratorValue(
            type,
            iterations++,
            zipper.apply(
              null,
              steps.map(function(s) {
                return s.value;
              })
            )
          );
        });
      };
      return zipSequence;
    }

    // #pragma Helper Functions

    function reify(iter, seq) {
      return isSeq(iter) ? seq : iter.constructor(seq);
    }

    function validateEntry(entry) {
      if (entry !== Object(entry)) {
        throw new TypeError("Expected [K, V] tuple: " + entry);
      }
    }

    function resolveSize(iter) {
      assertNotInfinite(iter.size);
      return ensureSize(iter);
    }

    function iterableClass(iterable) {
      return isKeyed(iterable)
        ? KeyedIterable
        : isIndexed(iterable)
        ? IndexedIterable
        : SetIterable;
    }

    function makeSequence(iterable) {
      return Object.create(
        (isKeyed(iterable)
          ? KeyedSeq
          : isIndexed(iterable)
          ? IndexedSeq
          : SetSeq
        ).prototype
      );
    }

    function cacheResultThrough() {
      if (this._iter.cacheResult) {
        this._iter.cacheResult();
        this.size = this._iter.size;
        return this;
      } else {
        return Seq.prototype.cacheResult.call(this);
      }
    }

    function defaultComparator(a, b) {
      return a > b ? 1 : a < b ? -1 : 0;
    }

    function forceIterator(keyPath) {
      var iter = getIterator(keyPath);
      if (!iter) {
        // Array might not be iterable in this environment, so we need a fallback
        // to our wrapped type.
        if (!isArrayLike(keyPath)) {
          throw new TypeError("Expected iterable or array-like: " + keyPath);
        }
        iter = getIterator(Iterable(keyPath));
      }
      return iter;
    }

    createClass(Record, KeyedCollection);

    function Record(defaultValues, name) {
      var hasInitialized;

      var RecordType = function Record(values) {
        if (values instanceof RecordType) {
          return values;
        }
        if (!(this instanceof RecordType)) {
          return new RecordType(values);
        }
        if (!hasInitialized) {
          hasInitialized = true;
          var keys = Object.keys(defaultValues);
          setProps(RecordTypePrototype, keys);
          RecordTypePrototype.size = keys.length;
          RecordTypePrototype._name = name;
          RecordTypePrototype._keys = keys;
          RecordTypePrototype._defaultValues = defaultValues;
        }
        this._map = Map(values);
      };

      var RecordTypePrototype = (RecordType.prototype = Object.create(
        RecordPrototype
      ));
      RecordTypePrototype.constructor = RecordType;

      return RecordType;
    }

    Record.prototype.toString = function() {
      return this.__toString(recordName(this) + " {", "}");
    };

    // @pragma Access

    Record.prototype.has = function(k) {
      return this._defaultValues.hasOwnProperty(k);
    };

    Record.prototype.get = function(k, notSetValue) {
      if (!this.has(k)) {
        return notSetValue;
      }
      var defaultVal = this._defaultValues[k];
      return this._map ? this._map.get(k, defaultVal) : defaultVal;
    };

    // @pragma Modification

    Record.prototype.clear = function() {
      if (this.__ownerID) {
        this._map && this._map.clear();
        return this;
      }
      var RecordType = this.constructor;
      return (
        RecordType._empty || (RecordType._empty = makeRecord(this, emptyMap()))
      );
    };

    Record.prototype.set = function(k, v) {
      if (!this.has(k)) {
        throw new Error(
          'Cannot set unknown key "' + k + '" on ' + recordName(this)
        );
      }
      var newMap = this._map && this._map.set(k, v);
      if (this.__ownerID || newMap === this._map) {
        return this;
      }
      return makeRecord(this, newMap);
    };

    Record.prototype.remove = function(k) {
      if (!this.has(k)) {
        return this;
      }
      var newMap = this._map && this._map.remove(k);
      if (this.__ownerID || newMap === this._map) {
        return this;
      }
      return makeRecord(this, newMap);
    };

    Record.prototype.wasAltered = function() {
      return this._map.wasAltered();
    };

    Record.prototype.__iterator = function(type, reverse) {
      var this$0 = this;
      return KeyedIterable(this._defaultValues)
        .map(function(_, k) {
          return this$0.get(k);
        })
        .__iterator(type, reverse);
    };

    Record.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      return KeyedIterable(this._defaultValues)
        .map(function(_, k) {
          return this$0.get(k);
        })
        .__iterate(fn, reverse);
    };

    Record.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      var newMap = this._map && this._map.__ensureOwner(ownerID);
      if (!ownerID) {
        this.__ownerID = ownerID;
        this._map = newMap;
        return this;
      }
      return makeRecord(this, newMap, ownerID);
    };

    var RecordPrototype = Record.prototype;
    RecordPrototype[DELETE] = RecordPrototype.remove;
    RecordPrototype.deleteIn = RecordPrototype.removeIn = MapPrototype.removeIn;
    RecordPrototype.merge = MapPrototype.merge;
    RecordPrototype.mergeWith = MapPrototype.mergeWith;
    RecordPrototype.mergeIn = MapPrototype.mergeIn;
    RecordPrototype.mergeDeep = MapPrototype.mergeDeep;
    RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith;
    RecordPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;
    RecordPrototype.setIn = MapPrototype.setIn;
    RecordPrototype.update = MapPrototype.update;
    RecordPrototype.updateIn = MapPrototype.updateIn;
    RecordPrototype.withMutations = MapPrototype.withMutations;
    RecordPrototype.asMutable = MapPrototype.asMutable;
    RecordPrototype.asImmutable = MapPrototype.asImmutable;

    function makeRecord(likeRecord, map, ownerID) {
      var record = Object.create(Object.getPrototypeOf(likeRecord));
      record._map = map;
      record.__ownerID = ownerID;
      return record;
    }

    function recordName(record) {
      return record._name || record.constructor.name || "Record";
    }

    function setProps(prototype, names) {
      try {
        names.forEach(setProp.bind(undefined, prototype));
      } catch (error) {
        // Object.defineProperty failed. Probably IE8.
      }
    }

    function setProp(prototype, name) {
      Object.defineProperty(prototype, name, {
        get: function() {
          return this.get(name);
        },
        set: function(value) {
          invariant(this.__ownerID, "Cannot set on an immutable record.");
          this.set(name, value);
        }
      });
    }

    createClass(Set, SetCollection);

    // @pragma Construction

    function Set(value) {
      return value === null || value === undefined
        ? emptySet()
        : isSet(value) && !isOrdered(value)
        ? value
        : emptySet().withMutations(function(set) {
            var iter = SetIterable(value);
            assertNotInfinite(iter.size);
            iter.forEach(function(v) {
              return set.add(v);
            });
          });
    }

    Set.of = function(/*...values*/) {
      return this(arguments);
    };

    Set.fromKeys = function(value) {
      return this(KeyedIterable(value).keySeq());
    };

    Set.prototype.toString = function() {
      return this.__toString("Set {", "}");
    };

    // @pragma Access

    Set.prototype.has = function(value) {
      return this._map.has(value);
    };

    // @pragma Modification

    Set.prototype.add = function(value) {
      return updateSet(this, this._map.set(value, true));
    };

    Set.prototype.remove = function(value) {
      return updateSet(this, this._map.remove(value));
    };

    Set.prototype.clear = function() {
      return updateSet(this, this._map.clear());
    };

    // @pragma Composition

    Set.prototype.union = function() {
      var iters = SLICE$0.call(arguments, 0);
      iters = iters.filter(function(x) {
        return x.size !== 0;
      });
      if (iters.length === 0) {
        return this;
      }
      if (this.size === 0 && !this.__ownerID && iters.length === 1) {
        return this.constructor(iters[0]);
      }
      return this.withMutations(function(set) {
        for (var ii = 0; ii < iters.length; ii++) {
          SetIterable(iters[ii]).forEach(function(value) {
            return set.add(value);
          });
        }
      });
    };

    Set.prototype.intersect = function() {
      var iters = SLICE$0.call(arguments, 0);
      if (iters.length === 0) {
        return this;
      }
      iters = iters.map(function(iter) {
        return SetIterable(iter);
      });
      var originalSet = this;
      return this.withMutations(function(set) {
        originalSet.forEach(function(value) {
          if (
            !iters.every(function(iter) {
              return iter.includes(value);
            })
          ) {
            set.remove(value);
          }
        });
      });
    };

    Set.prototype.subtract = function() {
      var iters = SLICE$0.call(arguments, 0);
      if (iters.length === 0) {
        return this;
      }
      iters = iters.map(function(iter) {
        return SetIterable(iter);
      });
      var originalSet = this;
      return this.withMutations(function(set) {
        originalSet.forEach(function(value) {
          if (
            iters.some(function(iter) {
              return iter.includes(value);
            })
          ) {
            set.remove(value);
          }
        });
      });
    };

    Set.prototype.merge = function() {
      return this.union.apply(this, arguments);
    };

    Set.prototype.mergeWith = function(merger) {
      var iters = SLICE$0.call(arguments, 1);
      return this.union.apply(this, iters);
    };

    Set.prototype.sort = function(comparator) {
      // Late binding
      return OrderedSet(sortFactory(this, comparator));
    };

    Set.prototype.sortBy = function(mapper, comparator) {
      // Late binding
      return OrderedSet(sortFactory(this, comparator, mapper));
    };

    Set.prototype.wasAltered = function() {
      return this._map.wasAltered();
    };

    Set.prototype.__iterate = function(fn, reverse) {
      var this$0 = this;
      return this._map.__iterate(function(_, k) {
        return fn(k, k, this$0);
      }, reverse);
    };

    Set.prototype.__iterator = function(type, reverse) {
      return this._map
        .map(function(_, k) {
          return k;
        })
        .__iterator(type, reverse);
    };

    Set.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      var newMap = this._map.__ensureOwner(ownerID);
      if (!ownerID) {
        this.__ownerID = ownerID;
        this._map = newMap;
        return this;
      }
      return this.__make(newMap, ownerID);
    };

    function isSet(maybeSet) {
      return !!(maybeSet && maybeSet[IS_SET_SENTINEL]);
    }

    Set.isSet = isSet;

    var IS_SET_SENTINEL = "@@__IMMUTABLE_SET__@@";

    var SetPrototype = Set.prototype;
    SetPrototype[IS_SET_SENTINEL] = true;
    SetPrototype[DELETE] = SetPrototype.remove;
    SetPrototype.mergeDeep = SetPrototype.merge;
    SetPrototype.mergeDeepWith = SetPrototype.mergeWith;
    SetPrototype.withMutations = MapPrototype.withMutations;
    SetPrototype.asMutable = MapPrototype.asMutable;
    SetPrototype.asImmutable = MapPrototype.asImmutable;

    SetPrototype.__empty = emptySet;
    SetPrototype.__make = makeSet;

    function updateSet(set, newMap) {
      if (set.__ownerID) {
        set.size = newMap.size;
        set._map = newMap;
        return set;
      }
      return newMap === set._map
        ? set
        : newMap.size === 0
        ? set.__empty()
        : set.__make(newMap);
    }

    function makeSet(map, ownerID) {
      var set = Object.create(SetPrototype);
      set.size = map ? map.size : 0;
      set._map = map;
      set.__ownerID = ownerID;
      return set;
    }

    var EMPTY_SET;
    function emptySet() {
      return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));
    }

    createClass(OrderedSet, Set);

    // @pragma Construction

    function OrderedSet(value) {
      return value === null || value === undefined
        ? emptyOrderedSet()
        : isOrderedSet(value)
        ? value
        : emptyOrderedSet().withMutations(function(set) {
            var iter = SetIterable(value);
            assertNotInfinite(iter.size);
            iter.forEach(function(v) {
              return set.add(v);
            });
          });
    }

    OrderedSet.of = function(/*...values*/) {
      return this(arguments);
    };

    OrderedSet.fromKeys = function(value) {
      return this(KeyedIterable(value).keySeq());
    };

    OrderedSet.prototype.toString = function() {
      return this.__toString("OrderedSet {", "}");
    };

    function isOrderedSet(maybeOrderedSet) {
      return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);
    }

    OrderedSet.isOrderedSet = isOrderedSet;

    var OrderedSetPrototype = OrderedSet.prototype;
    OrderedSetPrototype[IS_ORDERED_SENTINEL] = true;

    OrderedSetPrototype.__empty = emptyOrderedSet;
    OrderedSetPrototype.__make = makeOrderedSet;

    function makeOrderedSet(map, ownerID) {
      var set = Object.create(OrderedSetPrototype);
      set.size = map ? map.size : 0;
      set._map = map;
      set.__ownerID = ownerID;
      return set;
    }

    var EMPTY_ORDERED_SET;
    function emptyOrderedSet() {
      return (
        EMPTY_ORDERED_SET ||
        (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()))
      );
    }

    createClass(Stack, IndexedCollection);

    // @pragma Construction

    function Stack(value) {
      return value === null || value === undefined
        ? emptyStack()
        : isStack(value)
        ? value
        : emptyStack().unshiftAll(value);
    }

    Stack.of = function(/*...values*/) {
      return this(arguments);
    };

    Stack.prototype.toString = function() {
      return this.__toString("Stack [", "]");
    };

    // @pragma Access

    Stack.prototype.get = function(index, notSetValue) {
      var head = this._head;
      index = wrapIndex(this, index);
      while (head && index--) {
        head = head.next;
      }
      return head ? head.value : notSetValue;
    };

    Stack.prototype.peek = function() {
      return this._head && this._head.value;
    };

    // @pragma Modification

    Stack.prototype.push = function(/*...values*/) {
      if (arguments.length === 0) {
        return this;
      }
      var newSize = this.size + arguments.length;
      var head = this._head;
      for (var ii = arguments.length - 1; ii >= 0; ii--) {
        head = {
          value: arguments[ii],
          next: head
        };
      }
      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return makeStack(newSize, head);
    };

    Stack.prototype.pushAll = function(iter) {
      iter = IndexedIterable(iter);
      if (iter.size === 0) {
        return this;
      }
      assertNotInfinite(iter.size);
      var newSize = this.size;
      var head = this._head;
      iter.reverse().forEach(function(value) {
        newSize++;
        head = {
          value: value,
          next: head
        };
      });
      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return makeStack(newSize, head);
    };

    Stack.prototype.pop = function() {
      return this.slice(1);
    };

    Stack.prototype.unshift = function(/*...values*/) {
      return this.push.apply(this, arguments);
    };

    Stack.prototype.unshiftAll = function(iter) {
      return this.pushAll(iter);
    };

    Stack.prototype.shift = function() {
      return this.pop.apply(this, arguments);
    };

    Stack.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = 0;
        this._head = undefined;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return emptyStack();
    };

    Stack.prototype.slice = function(begin, end) {
      if (wholeSlice(begin, end, this.size)) {
        return this;
      }
      var resolvedBegin = resolveBegin(begin, this.size);
      var resolvedEnd = resolveEnd(end, this.size);
      if (resolvedEnd !== this.size) {
        // super.slice(begin, end);
        return IndexedCollection.prototype.slice.call(this, begin, end);
      }
      var newSize = this.size - resolvedBegin;
      var head = this._head;
      while (resolvedBegin--) {
        head = head.next;
      }
      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return makeStack(newSize, head);
    };

    // @pragma Mutability

    Stack.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {
        this.__ownerID = ownerID;
        this.__altered = false;
        return this;
      }
      return makeStack(this.size, this._head, ownerID, this.__hash);
    };

    // @pragma Iteration

    Stack.prototype.__iterate = function(fn, reverse) {
      if (reverse) {
        return this.reverse().__iterate(fn);
      }
      var iterations = 0;
      var node = this._head;
      while (node) {
        if (fn(node.value, iterations++, this) === false) {
          break;
        }
        node = node.next;
      }
      return iterations;
    };

    Stack.prototype.__iterator = function(type, reverse) {
      if (reverse) {
        return this.reverse().__iterator(type);
      }
      var iterations = 0;
      var node = this._head;
      return new Iterator(function() {
        if (node) {
          var value = node.value;
          node = node.next;
          return iteratorValue(type, iterations++, value);
        }
        return iteratorDone();
      });
    };

    function isStack(maybeStack) {
      return !!(maybeStack && maybeStack[IS_STACK_SENTINEL]);
    }

    Stack.isStack = isStack;

    var IS_STACK_SENTINEL = "@@__IMMUTABLE_STACK__@@";

    var StackPrototype = Stack.prototype;
    StackPrototype[IS_STACK_SENTINEL] = true;
    StackPrototype.withMutations = MapPrototype.withMutations;
    StackPrototype.asMutable = MapPrototype.asMutable;
    StackPrototype.asImmutable = MapPrototype.asImmutable;
    StackPrototype.wasAltered = MapPrototype.wasAltered;

    function makeStack(size, head, ownerID, hash) {
      var map = Object.create(StackPrototype);
      map.size = size;
      map._head = head;
      map.__ownerID = ownerID;
      map.__hash = hash;
      map.__altered = false;
      return map;
    }

    var EMPTY_STACK;
    function emptyStack() {
      return EMPTY_STACK || (EMPTY_STACK = makeStack(0));
    }

    /**
     * Contributes additional methods to a constructor
     */
    function mixin(ctor, methods) {
      var keyCopier = function(key) {
        ctor.prototype[key] = methods[key];
      };
      Object.keys(methods).forEach(keyCopier);
      Object.getOwnPropertySymbols &&
        Object.getOwnPropertySymbols(methods).forEach(keyCopier);
      return ctor;
    }

    Iterable.Iterator = Iterator;

    mixin(Iterable, {
      // ### Conversion to other types

      toArray: function() {
        assertNotInfinite(this.size);
        var array = new Array(this.size || 0);
        this.valueSeq().__iterate(function(v, i) {
          array[i] = v;
        });
        return array;
      },

      toIndexedSeq: function() {
        return new ToIndexedSequence(this);
      },

      toJS: function() {
        return this.toSeq()
          .map(function(value) {
            return value && typeof value.toJS === "function"
              ? value.toJS()
              : value;
          })
          .__toJS();
      },

      toJSON: function() {
        return this.toSeq()
          .map(function(value) {
            return value && typeof value.toJSON === "function"
              ? value.toJSON()
              : value;
          })
          .__toJS();
      },

      toKeyedSeq: function() {
        return new ToKeyedSequence(this, true);
      },

      toMap: function() {
        // Use Late Binding here to solve the circular dependency.
        return Map(this.toKeyedSeq());
      },

      toObject: function() {
        assertNotInfinite(this.size);
        var object = {};
        this.__iterate(function(v, k) {
          object[k] = v;
        });
        return object;
      },

      toOrderedMap: function() {
        // Use Late Binding here to solve the circular dependency.
        return OrderedMap(this.toKeyedSeq());
      },

      toOrderedSet: function() {
        // Use Late Binding here to solve the circular dependency.
        return OrderedSet(isKeyed(this) ? this.valueSeq() : this);
      },

      toSet: function() {
        // Use Late Binding here to solve the circular dependency.
        return Set(isKeyed(this) ? this.valueSeq() : this);
      },

      toSetSeq: function() {
        return new ToSetSequence(this);
      },

      toSeq: function() {
        return isIndexed(this)
          ? this.toIndexedSeq()
          : isKeyed(this)
          ? this.toKeyedSeq()
          : this.toSetSeq();
      },

      toStack: function() {
        // Use Late Binding here to solve the circular dependency.
        return Stack(isKeyed(this) ? this.valueSeq() : this);
      },

      toList: function() {
        // Use Late Binding here to solve the circular dependency.
        return List(isKeyed(this) ? this.valueSeq() : this);
      },

      // ### Common JavaScript methods and properties

      toString: function() {
        return "[Iterable]";
      },

      __toString: function(head, tail) {
        if (this.size === 0) {
          return head + tail;
        }
        return (
          head +
          " " +
          this.toSeq()
            .map(this.__toStringMapper)
            .join(", ") +
          " " +
          tail
        );
      },

      // ### ES6 Collection methods (ES6 Array and Map)

      concat: function() {
        var values = SLICE$0.call(arguments, 0);
        return reify(this, concatFactory(this, values));
      },

      includes: function(searchValue) {
        return this.some(function(value) {
          return is(value, searchValue);
        });
      },

      entries: function() {
        return this.__iterator(ITERATE_ENTRIES);
      },

      every: function(predicate, context) {
        assertNotInfinite(this.size);
        var returnValue = true;
        this.__iterate(function(v, k, c) {
          if (!predicate.call(context, v, k, c)) {
            returnValue = false;
            return false;
          }
        });
        return returnValue;
      },

      filter: function(predicate, context) {
        return reify(this, filterFactory(this, predicate, context, true));
      },

      find: function(predicate, context, notSetValue) {
        var entry = this.findEntry(predicate, context);
        return entry ? entry[1] : notSetValue;
      },

      findEntry: function(predicate, context) {
        var found;
        this.__iterate(function(v, k, c) {
          if (predicate.call(context, v, k, c)) {
            found = [k, v];
            return false;
          }
        });
        return found;
      },

      findLastEntry: function(predicate, context) {
        return this.toSeq()
          .reverse()
          .findEntry(predicate, context);
      },

      forEach: function(sideEffect, context) {
        assertNotInfinite(this.size);
        return this.__iterate(context ? sideEffect.bind(context) : sideEffect);
      },

      join: function(separator) {
        assertNotInfinite(this.size);
        separator = separator !== undefined ? "" + separator : ",";
        var joined = "";
        var isFirst = true;
        this.__iterate(function(v) {
          isFirst ? (isFirst = false) : (joined += separator);
          joined += v !== null && v !== undefined ? v.toString() : "";
        });
        return joined;
      },

      keys: function() {
        return this.__iterator(ITERATE_KEYS);
      },

      map: function(mapper, context) {
        return reify(this, mapFactory(this, mapper, context));
      },

      reduce: function(reducer, initialReduction, context) {
        assertNotInfinite(this.size);
        var reduction;
        var useFirst;
        if (arguments.length < 2) {
          useFirst = true;
        } else {
          reduction = initialReduction;
        }
        this.__iterate(function(v, k, c) {
          if (useFirst) {
            useFirst = false;
            reduction = v;
          } else {
            reduction = reducer.call(context, reduction, v, k, c);
          }
        });
        return reduction;
      },

      reduceRight: function(reducer, initialReduction, context) {
        var reversed = this.toKeyedSeq().reverse();
        return reversed.reduce.apply(reversed, arguments);
      },

      reverse: function() {
        return reify(this, reverseFactory(this, true));
      },

      slice: function(begin, end) {
        return reify(this, sliceFactory(this, begin, end, true));
      },

      some: function(predicate, context) {
        return !this.every(not(predicate), context);
      },

      sort: function(comparator) {
        return reify(this, sortFactory(this, comparator));
      },

      values: function() {
        return this.__iterator(ITERATE_VALUES);
      },

      // ### More sequential methods

      butLast: function() {
        return this.slice(0, -1);
      },

      isEmpty: function() {
        return this.size !== undefined
          ? this.size === 0
          : !this.some(function() {
              return true;
            });
      },

      count: function(predicate, context) {
        return ensureSize(
          predicate ? this.toSeq().filter(predicate, context) : this
        );
      },

      countBy: function(grouper, context) {
        return countByFactory(this, grouper, context);
      },

      equals: function(other) {
        return deepEqual(this, other);
      },

      entrySeq: function() {
        var iterable = this;
        if (iterable._cache) {
          // We cache as an entries array, so we can just return the cache!
          return new ArraySeq(iterable._cache);
        }
        var entriesSequence = iterable
          .toSeq()
          .map(entryMapper)
          .toIndexedSeq();
        entriesSequence.fromEntrySeq = function() {
          return iterable.toSeq();
        };
        return entriesSequence;
      },

      filterNot: function(predicate, context) {
        return this.filter(not(predicate), context);
      },

      findLast: function(predicate, context, notSetValue) {
        return this.toKeyedSeq()
          .reverse()
          .find(predicate, context, notSetValue);
      },

      first: function() {
        return this.find(returnTrue);
      },

      flatMap: function(mapper, context) {
        return reify(this, flatMapFactory(this, mapper, context));
      },

      flatten: function(depth) {
        return reify(this, flattenFactory(this, depth, true));
      },

      fromEntrySeq: function() {
        return new FromEntriesSequence(this);
      },

      get: function(searchKey, notSetValue) {
        return this.find(
          function(_, key) {
            return is(key, searchKey);
          },
          undefined,
          notSetValue
        );
      },

      getIn: function(searchKeyPath, notSetValue) {
        var nested = this;
        // Note: in an ES6 environment, we would prefer:
        // for (var key of searchKeyPath) {
        var iter = forceIterator(searchKeyPath);
        var step;
        while (!(step = iter.next()).done) {
          var key = step.value;
          nested = nested && nested.get ? nested.get(key, NOT_SET) : NOT_SET;
          if (nested === NOT_SET) {
            return notSetValue;
          }
        }
        return nested;
      },

      groupBy: function(grouper, context) {
        return groupByFactory(this, grouper, context);
      },

      has: function(searchKey) {
        return this.get(searchKey, NOT_SET) !== NOT_SET;
      },

      hasIn: function(searchKeyPath) {
        return this.getIn(searchKeyPath, NOT_SET) !== NOT_SET;
      },

      isSubset: function(iter) {
        iter = typeof iter.includes === "function" ? iter : Iterable(iter);
        return this.every(function(value) {
          return iter.includes(value);
        });
      },

      isSuperset: function(iter) {
        iter = typeof iter.isSubset === "function" ? iter : Iterable(iter);
        return iter.isSubset(this);
      },

      keySeq: function() {
        return this.toSeq()
          .map(keyMapper)
          .toIndexedSeq();
      },

      last: function() {
        return this.toSeq()
          .reverse()
          .first();
      },

      max: function(comparator) {
        return maxFactory(this, comparator);
      },

      maxBy: function(mapper, comparator) {
        return maxFactory(this, comparator, mapper);
      },

      min: function(comparator) {
        return maxFactory(
          this,
          comparator ? neg(comparator) : defaultNegComparator
        );
      },

      minBy: function(mapper, comparator) {
        return maxFactory(
          this,
          comparator ? neg(comparator) : defaultNegComparator,
          mapper
        );
      },

      rest: function() {
        return this.slice(1);
      },

      skip: function(amount) {
        return this.slice(Math.max(0, amount));
      },

      skipLast: function(amount) {
        return reify(
          this,
          this.toSeq()
            .reverse()
            .skip(amount)
            .reverse()
        );
      },

      skipWhile: function(predicate, context) {
        return reify(this, skipWhileFactory(this, predicate, context, true));
      },

      skipUntil: function(predicate, context) {
        return this.skipWhile(not(predicate), context);
      },

      sortBy: function(mapper, comparator) {
        return reify(this, sortFactory(this, comparator, mapper));
      },

      take: function(amount) {
        return this.slice(0, Math.max(0, amount));
      },

      takeLast: function(amount) {
        return reify(
          this,
          this.toSeq()
            .reverse()
            .take(amount)
            .reverse()
        );
      },

      takeWhile: function(predicate, context) {
        return reify(this, takeWhileFactory(this, predicate, context));
      },

      takeUntil: function(predicate, context) {
        return this.takeWhile(not(predicate), context);
      },

      valueSeq: function() {
        return this.toIndexedSeq();
      },

      // ### Hashable Object

      hashCode: function() {
        return this.__hash || (this.__hash = hashIterable(this));
      }

      // ### Internal

      // abstract __iterate(fn, reverse)

      // abstract __iterator(type, reverse)
    });

    // var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
    // var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
    // var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';
    // var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';

    var IterablePrototype = Iterable.prototype;
    IterablePrototype[IS_ITERABLE_SENTINEL] = true;
    IterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.values;
    IterablePrototype.__toJS = IterablePrototype.toArray;
    IterablePrototype.__toStringMapper = quoteString;
    IterablePrototype.inspect = IterablePrototype.toSource = function() {
      return this.toString();
    };
    IterablePrototype.chain = IterablePrototype.flatMap;
    IterablePrototype.contains = IterablePrototype.includes;

    // Temporary warning about using length
    (function() {
      try {
        Object.defineProperty(IterablePrototype, "length", {
          get: function() {
            if (!Iterable.noLengthWarning) {
              var stack;
              try {
                throw new Error();
              } catch (error) {
                stack = error.stack;
              }
              if (stack.indexOf("_wrapObject") === -1) {
                console &&
                  console.warn &&
                  console.warn(
                    "iterable.length has been deprecated, " +
                      "use iterable.size or iterable.count(). " +
                      "This warning will become a silent error in a future version. " +
                      stack
                  );
                return this.size;
              }
            }
          }
        });
      } catch (e) {}
    })();

    mixin(KeyedIterable, {
      // ### More sequential methods

      flip: function() {
        return reify(this, flipFactory(this));
      },

      findKey: function(predicate, context) {
        var entry = this.findEntry(predicate, context);
        return entry && entry[0];
      },

      findLastKey: function(predicate, context) {
        return this.toSeq()
          .reverse()
          .findKey(predicate, context);
      },

      keyOf: function(searchValue) {
        return this.findKey(function(value) {
          return is(value, searchValue);
        });
      },

      lastKeyOf: function(searchValue) {
        return this.findLastKey(function(value) {
          return is(value, searchValue);
        });
      },

      mapEntries: function(mapper, context) {
        var this$0 = this;
        var iterations = 0;
        return reify(
          this,
          this.toSeq()
            .map(function(v, k) {
              return mapper.call(context, [k, v], iterations++, this$0);
            })
            .fromEntrySeq()
        );
      },

      mapKeys: function(mapper, context) {
        var this$0 = this;
        return reify(
          this,
          this.toSeq()
            .flip()
            .map(function(k, v) {
              return mapper.call(context, k, v, this$0);
            })
            .flip()
        );
      }
    });

    var KeyedIterablePrototype = KeyedIterable.prototype;
    KeyedIterablePrototype[IS_KEYED_SENTINEL] = true;
    KeyedIterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.entries;
    KeyedIterablePrototype.__toJS = IterablePrototype.toObject;
    KeyedIterablePrototype.__toStringMapper = function(v, k) {
      return JSON.stringify(k) + ": " + quoteString(v);
    };

    mixin(IndexedIterable, {
      // ### Conversion to other types

      toKeyedSeq: function() {
        return new ToKeyedSequence(this, false);
      },

      // ### ES6 Collection methods (ES6 Array and Map)

      filter: function(predicate, context) {
        return reify(this, filterFactory(this, predicate, context, false));
      },

      findIndex: function(predicate, context) {
        var entry = this.findEntry(predicate, context);
        return entry ? entry[0] : -1;
      },

      indexOf: function(searchValue) {
        var key = this.toKeyedSeq().keyOf(searchValue);
        return key === undefined ? -1 : key;
      },

      lastIndexOf: function(searchValue) {
        var key = this.toKeyedSeq()
          .reverse()
          .keyOf(searchValue);
        return key === undefined ? -1 : key;

        // var index =
        // return this.toSeq().reverse().indexOf(searchValue);
      },

      reverse: function() {
        return reify(this, reverseFactory(this, false));
      },

      slice: function(begin, end) {
        return reify(this, sliceFactory(this, begin, end, false));
      },

      splice: function(index, removeNum /*, ...values*/) {
        var numArgs = arguments.length;
        removeNum = Math.max(removeNum | 0, 0);
        if (numArgs === 0 || (numArgs === 2 && !removeNum)) {
          return this;
        }
        // If index is negative, it should resolve relative to the size of the
        // collection. However size may be expensive to compute if not cached, so
        // only call count() if the number is in fact negative.
        index = resolveBegin(index, index < 0 ? this.count() : this.size);
        var spliced = this.slice(0, index);
        return reify(
          this,
          numArgs === 1
            ? spliced
            : spliced.concat(
                arrCopy(arguments, 2),
                this.slice(index + removeNum)
              )
        );
      },

      // ### More collection methods

      findLastIndex: function(predicate, context) {
        var key = this.toKeyedSeq().findLastKey(predicate, context);
        return key === undefined ? -1 : key;
      },

      first: function() {
        return this.get(0);
      },

      flatten: function(depth) {
        return reify(this, flattenFactory(this, depth, false));
      },

      get: function(index, notSetValue) {
        index = wrapIndex(this, index);
        return index < 0 ||
          this.size === Infinity ||
            (this.size !== undefined && index > this.size)
          ? notSetValue
          : this.find(
              function(_, key) {
                return key === index;
              },
              undefined,
              notSetValue
            );
      },

      has: function(index) {
        index = wrapIndex(this, index);
        return (
          index >= 0 &&
          (this.size !== undefined
            ? this.size === Infinity || index < this.size
            : this.indexOf(index) !== -1)
        );
      },

      interpose: function(separator) {
        return reify(this, interposeFactory(this, separator));
      },

      interleave: function(/*...iterables*/) {
        var iterables = [this].concat(arrCopy(arguments));
        var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, iterables);
        var interleaved = zipped.flatten(true);
        if (zipped.size) {
          interleaved.size = zipped.size * iterables.length;
        }
        return reify(this, interleaved);
      },

      last: function() {
        return this.get(-1);
      },

      skipWhile: function(predicate, context) {
        return reify(this, skipWhileFactory(this, predicate, context, false));
      },

      zip: function(/*, ...iterables */) {
        var iterables = [this].concat(arrCopy(arguments));
        return reify(this, zipWithFactory(this, defaultZipper, iterables));
      },

      zipWith: function(zipper /*, ...iterables */) {
        var iterables = arrCopy(arguments);
        iterables[0] = this;
        return reify(this, zipWithFactory(this, zipper, iterables));
      }
    });

    IndexedIterable.prototype[IS_INDEXED_SENTINEL] = true;
    IndexedIterable.prototype[IS_ORDERED_SENTINEL] = true;

    mixin(SetIterable, {
      // ### ES6 Collection methods (ES6 Array and Map)

      get: function(value, notSetValue) {
        return this.has(value) ? value : notSetValue;
      },

      includes: function(value) {
        return this.has(value);
      },

      // ### More sequential methods

      keySeq: function() {
        return this.valueSeq();
      }
    });

    SetIterable.prototype.has = IterablePrototype.includes;

    // Mixin subclasses

    mixin(KeyedSeq, KeyedIterable.prototype);
    mixin(IndexedSeq, IndexedIterable.prototype);
    mixin(SetSeq, SetIterable.prototype);

    mixin(KeyedCollection, KeyedIterable.prototype);
    mixin(IndexedCollection, IndexedIterable.prototype);
    mixin(SetCollection, SetIterable.prototype);

    // #pragma Helper functions

    function keyMapper(v, k) {
      return k;
    }

    function entryMapper(v, k) {
      return [k, v];
    }

    function not(predicate) {
      return function() {
        return !predicate.apply(this, arguments);
      };
    }

    function neg(predicate) {
      return function() {
        return -predicate.apply(this, arguments);
      };
    }

    function quoteString(value) {
      return typeof value === "string" ? JSON.stringify(value) : value;
    }

    function defaultZipper() {
      return arrCopy(arguments);
    }

    function defaultNegComparator(a, b) {
      return a < b ? 1 : a > b ? -1 : 0;
    }

    function hashIterable(iterable) {
      if (iterable.size === Infinity) {
        return 0;
      }
      var ordered = isOrdered(iterable);
      var keyed = isKeyed(iterable);
      var h = ordered ? 1 : 0;
      var size = iterable.__iterate(
        keyed
          ? ordered
            ? function(v, k) {
                h = (31 * h + hashMerge(hash(v), hash(k))) | 0;
              }
            : function(v, k) {
                h = (h + hashMerge(hash(v), hash(k))) | 0;
              }
          : ordered
          ? function(v) {
              h = (31 * h + hash(v)) | 0;
            }
          : function(v) {
              h = (h + hash(v)) | 0;
            }
      );
      return murmurHashOfSize(size, h);
    }

    function murmurHashOfSize(size, h) {
      h = imul(h, 0xcc9e2d51);
      h = imul((h << 15) | (h >>> -15), 0x1b873593);
      h = imul((h << 13) | (h >>> -13), 5);
      h = ((h + 0xe6546b64) | 0) ^ size;
      h = imul(h ^ (h >>> 16), 0x85ebca6b);
      h = imul(h ^ (h >>> 13), 0xc2b2ae35);
      h = smi(h ^ (h >>> 16));
      return h;
    }

    function hashMerge(a, b) {
      return (a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2))) | 0; // int
    }

    var Immutable = {
      Iterable: Iterable,

      Seq: Seq,
      Collection: Collection,
      Map: Map,
      OrderedMap: OrderedMap,
      List: List,
      Stack: Stack,
      Set: Set,
      OrderedSet: OrderedSet,

      Record: Record,
      Range: Range,
      Repeat: Repeat,

      is: is,
      fromJS: fromJS
    };

    return Immutable;
  });
});

var parseHTML_1 = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = parseHTML;

  var fallback = function fallback(html) {
    var doc = document.implementation.createHTMLDocument("");
    doc.documentElement.innerHTML = html;
    return doc;
  };

  function parseHTML(html) {
    var doc;

    if (typeof DOMParser !== "undefined") {
      var parser = new DOMParser();
      doc = parser.parseFromString(html, "text/html");

      if (doc === null || doc.body === null) {
        doc = fallback(html);
      }
    } else {
      doc = fallback(html);
    }

    return doc.body;
  }
});

_commonjsHelpers.unwrapExports(parseHTML_1);

var convertFromHTML_1 = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports["default"] = void 0;

  var _parseHTML = interopRequireDefault(parseHTML_1);

  var _rangeSort = interopRequireDefault(rangeSort);

  /**
   * Copyright (c) 2013-present, Facebook, Inc.
   * All rights reserved.
   *
   * Copyright (c) 2013-present, Facebook, Inc.
   * All rights reserved.
   *
   * This source code is licensed under the BSD-style license found in the
   * LICENSE file in the /src directory of this source tree. An additional grant
   * of patent rights can be found in the PATENTS file in the same directory.
   */
  var NBSP = "&nbsp;";
  var SPACE = " "; // Arbitrary max indent

  var MAX_DEPTH = 4; // used for replacing characters in HTML

  /* eslint-disable no-control-regex */

  var REGEX_CR = new RegExp("\r", "g");
  var REGEX_LF = new RegExp("\n", "g");
  var REGEX_NBSP = new RegExp(NBSP, "g");
  var REGEX_BLOCK_DELIMITER = new RegExp("\r", "g");
  /* eslint-enable no-control-regex */
  // Block tag flow is different because LIs do not have
  // a deterministic style ;_;

  var blockTags = [
    "p",
    "h1",
    "h2",
    "h3",
    "h4",
    "h5",
    "h6",
    "li",
    "blockquote",
    "pre"
  ];
  var inlineTags = {
    b: "BOLD",
    code: "CODE",
    del: "STRIKETHROUGH",
    em: "ITALIC",
    i: "ITALIC",
    s: "STRIKETHROUGH",
    strike: "STRIKETHROUGH",
    strong: "BOLD",
    u: "UNDERLINE"
  };

  var handleMiddleware = function handleMiddleware(maybeMiddleware, base) {
    if (maybeMiddleware && maybeMiddleware.__isMiddleware === true) {
      return maybeMiddleware(base);
    }

    return maybeMiddleware;
  };

  var defaultHTMLToBlock = function defaultHTMLToBlock(
    nodeName,
    node,
    lastList
  ) {
    return undefined;
  };

  var defaultHTMLToStyle = function defaultHTMLToStyle(
    nodeName,
    node,
    currentStyle
  ) {
    return currentStyle;
  };

  var defaultHTMLToEntity = function defaultHTMLToEntity(nodeName, node) {
    return undefined;
  };

  var defaultTextToEntity = function defaultTextToEntity(text) {
    return [];
  };

  var nullthrows = function nullthrows(x) {
    if (x != null) {
      return x;
    }

    throw new Error("Got unexpected null or undefined");
  };

  var sanitizeDraftText = function sanitizeDraftText(input) {
    return input.replace(REGEX_BLOCK_DELIMITER, "");
  };

  function getEmptyChunk() {
    return {
      text: "",
      inlines: [],
      entities: [],
      blocks: []
    };
  }

  function getWhitespaceChunk(inEntity) {
    var entities = new Array(1);

    if (inEntity) {
      entities[0] = inEntity;
    }

    return {
      text: SPACE,
      inlines: [(0, immutable$2.OrderedSet)()],
      entities: entities,
      blocks: []
    };
  }

  function getSoftNewlineChunk(block, depth) {
    var flat =
      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
    var data =
      arguments.length > 3 && arguments[3] !== undefined
        ? arguments[3]
        : (0, immutable$2.Map)();

    if (flat === true) {
      return {
        text: "\r",
        inlines: [(0, immutable$2.OrderedSet)()],
        entities: new Array(1),
        blocks: [
          {
            type: block,
            data: data,
            depth: Math.max(0, Math.min(MAX_DEPTH, depth))
          }
        ],
        isNewline: true
      };
    }

    return {
      text: "\n",
      inlines: [(0, immutable$2.OrderedSet)()],
      entities: new Array(1),
      blocks: []
    };
  }

  function getBlockDividerChunk(block, depth) {
    var data =
      arguments.length > 2 && arguments[2] !== undefined
        ? arguments[2]
        : (0, immutable$2.Map)();
    return {
      text: "\r",
      inlines: [(0, immutable$2.OrderedSet)()],
      entities: new Array(1),
      blocks: [
        {
          type: block,
          data: data,
          depth: Math.max(0, Math.min(MAX_DEPTH, depth))
        }
      ]
    };
  }

  function getBlockTypeForTag(tag, lastList) {
    switch (tag) {
      case "h1":
        return "header-one";

      case "h2":
        return "header-two";

      case "h3":
        return "header-three";

      case "h4":
        return "header-four";

      case "h5":
        return "header-five";

      case "h6":
        return "header-six";

      case "li":
        if (lastList === "ol") {
          return "ordered-list-item";
        }

        return "unordered-list-item";

      case "blockquote":
        return "blockquote";

      case "pre":
        return "code-block";

      case "div":
      case "p":
        return "unstyled";

      default:
        return null;
    }
  }

  function baseCheckBlockType(nodeName, node, lastList) {
    return getBlockTypeForTag(nodeName, lastList);
  }

  function processInlineTag(tag, node, currentStyle) {
    var styleToCheck = inlineTags[tag];

    if (styleToCheck) {
      currentStyle = currentStyle.add(styleToCheck).toOrderedSet();
    } else if (node instanceof HTMLElement) {
      var htmlElement = node;
      currentStyle = currentStyle
        .withMutations(function(style) {
          if (htmlElement.style.fontWeight === "bold") {
            style.add("BOLD");
          }

          if (htmlElement.style.fontStyle === "italic") {
            style.add("ITALIC");
          }

          if (htmlElement.style.textDecoration === "underline") {
            style.add("UNDERLINE");
          }

          if (htmlElement.style.textDecoration === "line-through") {
            style.add("STRIKETHROUGH");
          }
        })
        .toOrderedSet();
    }

    return currentStyle;
  }

  function baseProcessInlineTag(tag, node) {
    var inlineStyles =
      arguments.length > 2 && arguments[2] !== undefined
        ? arguments[2]
        : (0, immutable$2.OrderedSet)();
    return processInlineTag(tag, node, inlineStyles);
  }

  function joinChunks(A, B) {
    var flat =
      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
    // Sometimes two blocks will touch in the DOM and we need to strip the
    // extra delimiter to preserve niceness.
    var firstInB = B.text.slice(0, 1);
    var lastInA = A.text.slice(-1);
    var adjacentDividers = lastInA === "\r" && firstInB === "\r";
    var isJoiningBlocks = A.text !== "\r" && B.text !== "\r"; // when joining two full blocks like this we want to pop one divider

    var addingNewlineToEmptyBlock =
      A.text === "\r" && !A.isNewline && B.isNewline; // when joining a newline to an empty block we want to remove the newline

    if (adjacentDividers && (isJoiningBlocks || addingNewlineToEmptyBlock)) {
      A.text = A.text.slice(0, -1);
      A.inlines.pop();
      A.entities.pop();
      A.blocks.pop();
    } // Kill whitespace after blocks if flat mode is on

    if (A.text.slice(-1) === "\r" && flat === true) {
      if (B.text === SPACE || B.text === "\n") {
        return A;
      } else if (firstInB === SPACE || firstInB === "\n") {
        B.text = B.text.slice(1);
        B.inlines.shift();
        B.entities.shift();
      }
    }

    var isNewline = A.text.length === 0 && B.isNewline;
    return {
      text: A.text + B.text,
      inlines: A.inlines.concat(B.inlines),
      entities: A.entities.concat(B.entities),
      blocks: A.blocks.concat(B.blocks),
      isNewline: isNewline
    };
  }
  /*
   * Check to see if we have anything like <p> <blockquote> <h1>... to create
   * block tags from. If we do, we can use those and ignore <div> tags. If we
   * don't, we can treat <div> tags as meaningful (unstyled) blocks.
   */

  function containsSemanticBlockMarkup(html) {
    return blockTags.some(function(tag) {
      return html.indexOf("<".concat(tag)) !== -1;
    });
  }

  function genFragment(
    node,
    inlineStyle,
    lastList,
    inBlock,
    fragmentBlockTags,
    depth,
    processCustomInlineStyles,
    checkEntityNode,
    checkEntityText,
    checkBlockType,
    createEntity,
    getEntity,
    mergeEntityData,
    replaceEntityData,
    options,
    inEntity
  ) {
    var nodeName = node.nodeName.toLowerCase();
    var newBlock = false;
    var nextBlockType = "unstyled"; // Base Case

    if (nodeName === "#text") {
      var text = node.textContent;

      if (text.trim() === "" && inBlock === null) {
        return getEmptyChunk();
      }

      if (text.trim() === "" && inBlock !== "code-block") {
        return getWhitespaceChunk(inEntity);
      }

      if (inBlock !== "code-block") {
        // Can't use empty string because MSWord
        text = text.replace(REGEX_LF, SPACE);
      }

      var entities = Array(text.length).fill(inEntity);
      var offsetChange = 0;
      var textEntities = checkEntityText(
        text,
        createEntity,
        getEntity,
        mergeEntityData,
        replaceEntityData
      ).sort(_rangeSort["default"]);
      textEntities.forEach(function(_ref) {
        var entity = _ref.entity,
          offset = _ref.offset,
          length = _ref.length,
          result = _ref.result;
        var adjustedOffset = offset + offsetChange;

        if (result === null || result === undefined) {
          result = text.substr(adjustedOffset, length);
        }

        var textArray = text.split("");
        textArray.splice
          .bind(textArray, adjustedOffset, length)
          .apply(textArray, result.split(""));
        text = textArray.join("");
        entities.splice
          .bind(entities, adjustedOffset, length)
          .apply(entities, Array(result.length).fill(entity));
        offsetChange += result.length - length;
      });
      return {
        text: text,
        inlines: Array(text.length).fill(inlineStyle),
        entities: entities,
        blocks: []
      };
    } // BR tags

    if (nodeName === "br") {
      var _blockType = inBlock;

      if (_blockType === null) {
        //  BR tag is at top level, treat it as an unstyled block
        return getSoftNewlineChunk("unstyled", depth, true);
      }

      return getSoftNewlineChunk(_blockType || "unstyled", depth, options.flat);
    }

    var chunk = getEmptyChunk();
    var newChunk = null; // Inline tags

    inlineStyle = processInlineTag(nodeName, node, inlineStyle);
    inlineStyle = processCustomInlineStyles(nodeName, node, inlineStyle); // Handle lists

    if (nodeName === "ul" || nodeName === "ol") {
      if (lastList) {
        depth += 1;
      }

      lastList = nodeName;
      inBlock = null;
    } // Block Tags

    var blockInfo = checkBlockType(nodeName, node, lastList, inBlock);
    var blockType;
    var blockDataMap;

    if (blockInfo === false) {
      return getEmptyChunk();
    }

    blockInfo = blockInfo || {};

    if (typeof blockInfo === "string") {
      blockType = blockInfo;
      blockDataMap = (0, immutable$2.Map)();
    } else {
      blockType = typeof blockInfo === "string" ? blockInfo : blockInfo.type;
      blockDataMap = blockInfo.data
        ? (0, immutable$2.Map)(blockInfo.data)
        : (0, immutable$2.Map)();
    }

    if (!inBlock && (fragmentBlockTags.indexOf(nodeName) !== -1 || blockType)) {
      chunk = getBlockDividerChunk(
        blockType || getBlockTypeForTag(nodeName, lastList),
        depth,
        blockDataMap
      );
      inBlock = blockType || getBlockTypeForTag(nodeName, lastList);
      newBlock = true;
    } else if (
      lastList &&
      (inBlock === "ordered-list-item" || inBlock === "unordered-list-item") &&
      nodeName === "li"
    ) {
      var listItemBlockType = getBlockTypeForTag(nodeName, lastList);
      chunk = getBlockDividerChunk(listItemBlockType, depth);
      inBlock = listItemBlockType;
      newBlock = true;
      nextBlockType =
        lastList === "ul" ? "unordered-list-item" : "ordered-list-item";
    } else if (inBlock && inBlock !== "atomic" && blockType === "atomic") {
      inBlock = blockType;
      newBlock = true;
      chunk = getSoftNewlineChunk(
        blockType,
        depth,
        true, // atomic blocks within non-atomic blocks must always be split out
        blockDataMap
      );
    } // Recurse through children

    var child = node.firstChild; // hack to allow conversion of atomic blocks from HTML (e.g. <figure><img
    // src="..." /></figure>). since metadata must be stored on an entity text
    // must exist for the entity to apply to. the way chunks are joined strips
    // whitespace at the end so it cannot be a space character.

    if (
      child == null &&
      inEntity &&
      (blockType === "atomic" || inBlock === "atomic")
    ) {
      child = document.createTextNode("a");
    }

    if (child != null) {
      nodeName = child.nodeName.toLowerCase();
    }

    var entityId = null;

    while (child) {
      entityId = checkEntityNode(
        nodeName,
        child,
        createEntity,
        getEntity,
        mergeEntityData,
        replaceEntityData
      );
      newChunk = genFragment(
        child,
        inlineStyle,
        lastList,
        inBlock,
        fragmentBlockTags,
        depth,
        processCustomInlineStyles,
        checkEntityNode,
        checkEntityText,
        checkBlockType,
        createEntity,
        getEntity,
        mergeEntityData,
        replaceEntityData,
        options,
        entityId || inEntity
      );
      chunk = joinChunks(chunk, newChunk, options.flat);
      var sibling = child.nextSibling; // Put in a newline to break up blocks inside blocks

      if (sibling && fragmentBlockTags.indexOf(nodeName) >= 0 && inBlock) {
        var newBlockInfo = checkBlockType(nodeName, child, lastList, inBlock);
        var newBlockType = void 0;
        var newBlockData = void 0;

        if (newBlockInfo !== false) {
          newBlockInfo = newBlockInfo || {};

          if (typeof newBlockInfo === "string") {
            newBlockType = newBlockInfo;
            newBlockData = (0, immutable$2.Map)();
          } else {
            newBlockType =
              newBlockInfo.type || getBlockTypeForTag(nodeName, lastList);
            newBlockData = newBlockInfo.data
              ? (0, immutable$2.Map)(newBlockInfo.data)
              : (0, immutable$2.Map)();
          }

          chunk = joinChunks(
            chunk,
            getSoftNewlineChunk(
              newBlockType,
              depth,
              options.flat,
              newBlockData
            ),
            options.flat
          );
        }
      }

      if (sibling) {
        nodeName = sibling.nodeName.toLowerCase();
      }

      child = sibling;
    }

    if (newBlock) {
      chunk = joinChunks(
        chunk,
        getBlockDividerChunk(nextBlockType, depth, (0, immutable$2.Map)()),
        options.flat
      );
    }

    return chunk;
  }

  function getChunkForHTML(
    html,
    processCustomInlineStyles,
    checkEntityNode,
    checkEntityText,
    checkBlockType,
    createEntity,
    getEntity,
    mergeEntityData,
    replaceEntityData,
    options,
    DOMBuilder
  ) {
    html = html
      .trim()
      .replace(REGEX_CR, "")
      .replace(REGEX_NBSP, SPACE);
    var safeBody = DOMBuilder(html);

    if (!safeBody) {
      return null;
    } // Sometimes we aren't dealing with content that contains nice semantic
    // tags. In this case, use divs to separate everything out into paragraphs
    // and hope for the best.

    var workingBlocks = containsSemanticBlockMarkup(html)
      ? blockTags.concat(["div"])
      : ["div"]; // Start with -1 block depth to offset the fact that we are passing in a fake
    // UL block to sta rt with.

    var chunk = genFragment(
      safeBody,
      (0, immutable$2.OrderedSet)(),
      "ul",
      null,
      workingBlocks,
      -1,
      processCustomInlineStyles,
      checkEntityNode,
      checkEntityText,
      checkBlockType,
      createEntity,
      getEntity,
      mergeEntityData,
      replaceEntityData,
      options
    ); // join with previous block to prevent weirdness on paste

    if (chunk.text.indexOf("\r") === 0) {
      chunk = {
        text: chunk.text.slice(1),
        inlines: chunk.inlines.slice(1),
        entities: chunk.entities.slice(1),
        blocks: chunk.blocks
      };
    } // Kill block delimiter at the end

    if (chunk.text.slice(-1) === "\r") {
      chunk.text = chunk.text.slice(0, -1);
      chunk.inlines = chunk.inlines.slice(0, -1);
      chunk.entities = chunk.entities.slice(0, -1);
      chunk.blocks.pop();
    } // If we saw no block tags, put an unstyled one in

    if (chunk.blocks.length === 0) {
      chunk.blocks.push({
        type: "unstyled",
        data: (0, immutable$2.Map)(),
        depth: 0
      });
    } // Sometimes we start with text that isn't in a block, which is then
    // followed by blocks. Need to fix up the blocks to add in
    // an unstyled block for this content

    if (chunk.text.split("\r").length === chunk.blocks.length + 1) {
      chunk.blocks.unshift({
        type: "unstyled",
        data: (0, immutable$2.Map)(),
        depth: 0
      });
    }

    return chunk;
  }

  function convertFromHTMLtoContentBlocks(
    html,
    processCustomInlineStyles,
    checkEntityNode,
    checkEntityText,
    checkBlockType,
    createEntity,
    getEntity,
    mergeEntityData,
    replaceEntityData,
    options,
    DOMBuilder,
    generateKey
  ) {
    // Be ABSOLUTELY SURE that the dom builder you pass hare won't execute
    // arbitrary code in whatever environment you're running this in. For an
    // example of how we try to do this in-browser, see getSafeBodyFromHTML.
    var chunk = getChunkForHTML(
      html,
      processCustomInlineStyles,
      checkEntityNode,
      checkEntityText,
      checkBlockType,
      createEntity,
      getEntity,
      mergeEntityData,
      replaceEntityData,
      options,
      DOMBuilder
    );

    if (chunk == null) {
      return [];
    }

    var start = 0;
    return chunk.text.split("\r").map(function(textBlock, blockIndex) {
      // Make absolutely certain that our text is acceptable.
      textBlock = sanitizeDraftText(textBlock);
      var end = start + textBlock.length;
      var inlines = nullthrows(chunk).inlines.slice(start, end);
      var entities = nullthrows(chunk).entities.slice(start, end);
      var characterList = (0, immutable$2.List)(
        inlines.map(function(style, entityIndex) {
          var data = {
            style: style,
            entity: null
          };

          if (entities[entityIndex]) {
            data.entity = entities[entityIndex];
          }

          return Draft.CharacterMetadata.create(data);
        })
      );
      start = end + 1;
      return new Draft.ContentBlock({
        key: generateKey(),
        type: nullthrows(chunk).blocks[blockIndex].type,
        data: nullthrows(chunk).blocks[blockIndex].data,
        depth: nullthrows(chunk).blocks[blockIndex].depth,
        text: textBlock,
        characterList: characterList
      });
    });
  }

  var convertFromHTML = function convertFromHTML(_ref2) {
    var _ref2$htmlToStyle = _ref2.htmlToStyle,
      htmlToStyle =
        _ref2$htmlToStyle === void 0 ? defaultHTMLToStyle : _ref2$htmlToStyle,
      _ref2$htmlToEntity = _ref2.htmlToEntity,
      htmlToEntity =
        _ref2$htmlToEntity === void 0
          ? defaultHTMLToEntity
          : _ref2$htmlToEntity,
      _ref2$textToEntity = _ref2.textToEntity,
      textToEntity =
        _ref2$textToEntity === void 0
          ? defaultTextToEntity
          : _ref2$textToEntity,
      _ref2$htmlToBlock = _ref2.htmlToBlock,
      htmlToBlock =
        _ref2$htmlToBlock === void 0 ? defaultHTMLToBlock : _ref2$htmlToBlock;
    return function(html) {
      var options =
        arguments.length > 1 && arguments[1] !== undefined
          ? arguments[1]
          : {
              flat: false
            };
      var DOMBuilder =
        arguments.length > 2 && arguments[2] !== undefined
          ? arguments[2]
          : _parseHTML["default"];
      var generateKey =
        arguments.length > 3 && arguments[3] !== undefined
          ? arguments[3]
          : Draft.genKey;

      var contentState = Draft.ContentState.createFromText("");

      var createEntityWithContentState = function createEntityWithContentState() {
        if (contentState.createEntity) {
          var _contentState;

          contentState = (_contentState = contentState).createEntity.apply(
            _contentState,
            arguments
          );
          return contentState.getLastCreatedEntityKey();
        }

        return Draft.Entity.create.apply(Draft.Entity, arguments);
      };

      var getEntityWithContentState = function getEntityWithContentState() {
        if (contentState.getEntity) {
          var _contentState2;

          return (_contentState2 = contentState).getEntity.apply(
            _contentState2,
            arguments
          );
        }

        return Draft.Entity.get.apply(Draft.Entity, arguments);
      };

      var mergeEntityDataWithContentState = function mergeEntityDataWithContentState() {
        if (contentState.mergeEntityData) {
          var _contentState3;

          contentState = (_contentState3 = contentState).mergeEntityData.apply(
            _contentState3,
            arguments
          );
          return;
        }

        Draft.Entity.mergeData.apply(Draft.Entity, arguments);
      };

      var replaceEntityDataWithContentState = function replaceEntityDataWithContentState() {
        if (contentState.replaceEntityData) {
          var _contentState4;

          contentState = (_contentState4 = contentState).replaceEntityData.apply(
            _contentState4,
            arguments
          );
          return;
        }

        Draft.Entity.replaceData.apply(Draft.Entity, arguments);
      };

      var contentBlocks = convertFromHTMLtoContentBlocks(
        html,
        handleMiddleware(htmlToStyle, baseProcessInlineTag),
        handleMiddleware(htmlToEntity, defaultHTMLToEntity),
        handleMiddleware(textToEntity, defaultTextToEntity),
        handleMiddleware(htmlToBlock, baseCheckBlockType),
        createEntityWithContentState,
        getEntityWithContentState,
        mergeEntityDataWithContentState,
        replaceEntityDataWithContentState,
        options,
        DOMBuilder,
        generateKey
      );

      var blockMap = Draft.BlockMapBuilder.createFromArray(contentBlocks);

      var firstBlockKey = contentBlocks[0].getKey();
      return contentState.merge({
        blockMap: blockMap,
        selectionBefore: Draft.SelectionState.createEmpty(firstBlockKey),
        selectionAfter: Draft.SelectionState.createEmpty(firstBlockKey)
      });
    };
  };

  var _default = function _default() {
    if (
      arguments.length >= 1 &&
      typeof (arguments.length <= 0 ? undefined : arguments[0]) === "string"
    ) {
      return convertFromHTML({}).apply(void 0, arguments);
    }

    return convertFromHTML.apply(void 0, arguments);
  };

  exports["default"] = _default;
});

_commonjsHelpers.unwrapExports(convertFromHTML_1);

var lib = _commonjsHelpers.createCommonjsModule(function(module, exports) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  Object.defineProperty(exports, "convertToHTML", {
    enumerable: true,
    get: function get() {
      return _convertToHTML["default"];
    }
  });
  Object.defineProperty(exports, "convertFromHTML", {
    enumerable: true,
    get: function get() {
      return _convertFromHTML["default"];
    }
  });
  Object.defineProperty(exports, "parseHTML", {
    enumerable: true,
    get: function get() {
      return _parseHTML["default"];
    }
  });

  var _convertToHTML = interopRequireDefault(convertToHTML_1);

  var _convertFromHTML = interopRequireDefault(convertFromHTML_1);

  var _parseHTML = interopRequireDefault(parseHTML_1);
});

_commonjsHelpers.unwrapExports(lib);

var configs = _commonjsHelpers.createCommonjsModule(function(module, exports) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.getFromHTMLConfig = exports.getToHTMLConfig = exports.blocks = exports.getHexColor = exports.defaultFontFamilies = exports.namedColors = undefined;

  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;
    };

  var _react2 = _interopRequireDefault(React__default);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }

  function _objectWithoutProperties(obj, keys) {
    var target = {};
    for (var i in obj) {
      if (keys.indexOf(i) >= 0) continue;
      if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
      target[i] = obj[i];
    }
    return target;
  }

  var namedColors = (exports.namedColors = {
    aliceblue: "#f0f8ff",
    antiquewhite: "#faebd7",
    aqua: "#00ffff",
    aquamarine: "#7fffd4",
    azure: "#f0ffff",
    beige: "#f5f5dc",
    bisque: "#ffe4c4",
    black: "#000000",
    blanchedalmond: "#ffebcd",
    blue: "#0000ff",
    blueviolet: "#8a2be2",
    brown: "#a52a2a",
    burlywood: "#deb887",
    cadetblue: "#5f9ea0",
    chartreuse: "#7fff00",
    chocolate: "#d2691e",
    coral: "#ff7f50",
    cornflowerblue: "#6495ed",
    cornsilk: "#fff8dc",
    crimson: "#dc143c",
    cyan: "#00ffff",
    darkblue: "#00008b",
    darkcyan: "#008b8b",
    darkgoldenrod: "#b8860b",
    darkgray: "#a9a9a9",
    darkgreen: "#006400",
    darkkhaki: "#bdb76b",
    darkmagenta: "#8b008b",
    darkolivegreen: "#556b2f",
    darkorange: "#ff8c00",
    darkorchid: "#9932cc",
    darkred: "#8b0000",
    darksalmon: "#e9967a",
    darkseagreen: "#8fbc8f",
    darkslateblue: "#483d8b",
    darkslategray: "#2f4f4f",
    darkturquoise: "#00ced1",
    darkviolet: "#9400d3",
    deeppink: "#ff1493",
    deepskyblue: "#00bfff",
    dimgray: "#696969",
    dodgerblue: "#1e90ff",
    firebrick: "#b22222",
    floralwhite: "#fffaf0",
    forestgreen: "#228b22",
    fuchsia: "#ff00ff",
    gainsboro: "#dcdcdc",
    ghostwhite: "#f8f8ff",
    gold: "#ffd700",
    goldenrod: "#daa520",
    gray: "#808080",
    green: "#008000",
    greenyellow: "#adff2f",
    honeydew: "#f0fff0",
    hotpink: "#ff69b4",
    "indianred ": "#cd5c5c",
    indigo: "#4b0082",
    ivory: "#fffff0",
    khaki: "#f0e68c",
    lavender: "#e6e6fa",
    lavenderblush: "#fff0f5",
    lawngreen: "#7cfc00",
    lemonchiffon: "#fffacd",
    lightblue: "#add8e6",
    lightcoral: "#f08080",
    lightcyan: "#e0ffff",
    lightgoldenrodyellow: "#fafad2",
    lightgrey: "#d3d3d3",
    lightgreen: "#90ee90",
    lightpink: "#ffb6c1",
    lightsalmon: "#ffa07a",
    lightseagreen: "#20b2aa",
    lightskyblue: "#87cefa",
    lightslategray: "#778899",
    lightsteelblue: "#b0c4de",
    lightyellow: "#ffffe0",
    lime: "#00ff00",
    limegreen: "#32cd32",
    linen: "#faf0e6",
    magenta: "#ff00ff",
    maroon: "#800000",
    mediumaquamarine: "#66cdaa",
    mediumblue: "#0000cd",
    mediumorchid: "#ba55d3",
    mediumpurple: "#9370d8",
    mediumseagreen: "#3cb371",
    mediumslateblue: "#7b68ee",
    mediumspringgreen: "#00fa9a",
    mediumturquoise: "#48d1cc",
    mediumvioletred: "#c71585",
    midnightblue: "#191970",
    mintcream: "#f5fffa",
    mistyrose: "#ffe4e1",
    moccasin: "#ffe4b5",
    navajowhite: "#ffdead",
    navy: "#000080",
    oldlace: "#fdf5e6",
    olive: "#808000",
    olivedrab: "#6b8e23",
    orange: "#ffa500",
    orangered: "#ff4500",
    orchid: "#da70d6",
    palegoldenrod: "#eee8aa",
    palegreen: "#98fb98",
    paleturquoise: "#afeeee",
    palevioletred: "#d87093",
    papayawhip: "#ffefd5",
    peachpuff: "#ffdab9",
    peru: "#cd853f",
    pink: "#ffc0cb",
    plum: "#dda0dd",
    powderblue: "#b0e0e6",
    purple: "#800080",
    rebeccapurple: "#663399",
    red: "#ff0000",
    rosybrown: "#bc8f8f",
    royalblue: "#4169e1",
    saddlebrown: "#8b4513",
    salmon: "#fa8072",
    sandybrown: "#f4a460",
    seagreen: "#2e8b57",
    seashell: "#fff5ee",
    sienna: "#a0522d",
    silver: "#c0c0c0",
    skyblue: "#87ceeb",
    slateblue: "#6a5acd",
    slategray: "#708090",
    snow: "#fffafa",
    springgreen: "#00ff7f",
    steelblue: "#4682b4",
    tan: "#d2b48c",
    teal: "#008080",
    thistle: "#d8bfd8",
    tomato: "#ff6347",
    turquoise: "#40e0d0",
    violet: "#ee82ee",
    wheat: "#f5deb3",
    white: "#ffffff",
    whitesmoke: "#f5f5f5",
    yellow: "#ffff00",
    yellowgreen: "#9acd32"
  });

  var getStyleValue = function getStyleValue(style) {
    return style.split("-")[1];
  };
  var defaultUnitExportFn = function defaultUnitExportFn(unit) {
    return unit + "px";
  };
  var defaultUnitImportFn = function defaultUnitImportFn(unit) {
    return unit.replace("px", "");
  };

  var ignoredNodeAttributes = ["style"];
  var ignoredEntityNodeAttributes = [
    "style",
    "href",
    "target",
    "alt",
    "title",
    "id",
    "controls",
    "autoplay",
    "loop",
    "poster"
  ];

  var spreadNodeAttributes = function spreadNodeAttributes(attributesObject) {
    return Object.keys(attributesObject)
      .reduce(function(attributeString, attributeName) {
        return (
          attributeString +
          " " +
          attributeName +
          '="' +
          attributesObject[attributeName] +
          '"'
        );
      }, "")
      .replace(/^\s$/, "");
  };

  var defaultFontFamilies = (exports.defaultFontFamilies = [
    {
      name: "Araial",
      family: "Arial, Helvetica, sans-serif"
    },
    {
      name: "Georgia",
      family: "Georgia, serif"
    },
    {
      name: "Impact",
      family: "Impact, serif"
    },
    {
      name: "Monospace",
      family: '"Courier New", Courier, monospace'
    },
    {
      name: "Tahoma",
      family: "tahoma, arial, 'Hiragino Sans GB', 宋体, sans-serif"
    }
  ]);

  var getHexColor = (exports.getHexColor = function getHexColor(color) {
    color = color
      .replace("color:", "")
      .replace(";", "")
      .replace(" ", "");

    if (/^#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})$/.test(color)) {
      return color;
    } else if (namedColors[color]) {
      return namedColors[color];
    } else if (color.indexOf("rgb") === 0) {
      var rgbArray = color.split(",");
      var convertedColor =
        rgbArray.length < 3
          ? null
          : "#" +
            [rgbArray[0], rgbArray[1], rgbArray[2]]
              .map(function(x) {
                var hex = parseInt(x.replace(/\D/g, ""), 10).toString(16);
                return hex.length === 1 ? "0" + hex : hex;
              })
              .join("");

      return /^#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})$/.test(convertedColor)
        ? convertedColor
        : null;
    } else {
      return null;
    }
  });

  var blocks = (exports.blocks = {
    "header-one": "h1",
    "header-two": "h2",
    "header-three": "h3",
    "header-four": "h4",
    "header-five": "h5",
    "header-six": "h6",
    unstyled: "p",
    blockquote: "blockquote"
  });

  var blockTypes = Object.keys(blocks);
  var blockNames = blockTypes.map(function(key) {
    return blocks[key];
  });

  var convertAtomicBlock = function convertAtomicBlock(
    block,
    contentState,
    blockNodeAttributes
  ) {
    if (!block || !block.key) {
      return _react2.default.createElement("p", null);
    }

    var contentBlock = contentState.getBlockForKey(block.key);

    var className = blockNodeAttributes.class,
      nodeAttrAsProps = _objectWithoutProperties(blockNodeAttributes, [
        "class"
      ]);

    nodeAttrAsProps.className = className;

    if (!contentBlock) {
      return _react2.default.createElement("p", null);
    }

    var entityKey = contentBlock.getEntityAt(0);

    if (!entityKey) {
      return _react2.default.createElement("p", null);
    }

    var entity = contentState.getEntity(entityKey);
    var mediaType = entity.getType().toLowerCase();

    var _block$data = block.data,
      float = _block$data.float,
      alignment = _block$data.alignment;

    var _entity$getData = entity.getData(),
      url = _entity$getData.url,
      link = _entity$getData.link,
      link_target = _entity$getData.link_target,
      width = _entity$getData.width,
      height = _entity$getData.height,
      meta = _entity$getData.meta;

    if (mediaType === "image") {
      var imageWrapStyle = {};
      var styledClassName = "";

      if (float) {
        imageWrapStyle.float = float;
        styledClassName += " float-" + float;
      } else if (alignment) {
        imageWrapStyle.textAlign = alignment;
        styledClassName += " align-" + alignment;
      }

      if (link) {
        return _react2.default.createElement(
          "div",
          {
            className: "media-wrap image-wrap" + styledClassName,
            style: imageWrapStyle
          },
          _react2.default.createElement(
            "a",
            {
              style: { display: "inline-block" },
              href: link,
              target: link_target
            },
            _react2.default.createElement(
              "img",
              _extends({}, nodeAttrAsProps, meta, {
                src: url,
                width: width,
                height: height,
                style: { width: width, height: height }
              })
            )
          )
        );
      } else {
        return _react2.default.createElement(
          "div",
          {
            className: "media-wrap image-wrap" + styledClassName,
            style: imageWrapStyle
          },
          _react2.default.createElement(
            "img",
            _extends({}, nodeAttrAsProps, meta, {
              src: url,
              width: width,
              height: height,
              style: { width: width, height: height }
            })
          )
        );
      }
    } else if (mediaType === "audio") {
      return _react2.default.createElement(
        "div",
        { className: "media-wrap audio-wrap" },
        _react2.default.createElement(
          "audio",
          _extends({ controls: true }, nodeAttrAsProps, meta, { src: url })
        )
      );
    } else if (mediaType === "video") {
      return _react2.default.createElement(
        "div",
        { className: "media-wrap video-wrap" },
        _react2.default.createElement(
          "video",
          _extends({ controls: true }, nodeAttrAsProps, meta, {
            src: url,
            width: width,
            height: height
          })
        )
      );
    } else if (mediaType === "embed") {
      return _react2.default.createElement(
        "div",
        { className: "media-wrap embed-wrap" },
        _react2.default.createElement("div", {
          dangerouslySetInnerHTML: { __html: url }
        })
      );
    } else if (mediaType === "hr") {
      return _react2.default.createElement("hr", null);
    } else {
      return _react2.default.createElement("p", null);
    }
  };

  var entityToHTML = function entityToHTML(options) {
    return function(entity, originalText) {
      var entityExportFn = options.entityExportFn;

      var entityType = entity.type.toLowerCase();

      if (entityExportFn) {
        var customOutput = entityExportFn(entity, originalText);
        if (customOutput) {
          return customOutput;
        }
      }

      if (entityType === "link") {
        var _ref = entity.data.nodeAttributes || {},
          className = _ref.class,
          nodeAttrAsProps = _objectWithoutProperties(_ref, ["class"]);

        nodeAttrAsProps.className = className;
        return _react2.default.createElement(
          "a",
          _extends(
            { href: entity.data.href, target: entity.data.target },
            nodeAttrAsProps
          )
        );
      }
    };
  };

  var styleToHTML = function styleToHTML(options) {
    return function(style) {
      var unitExportFn = options.unitExportFn || defaultUnitExportFn;

      if (options.styleExportFn) {
        var customOutput = options.styleExportFn(style, options);
        if (customOutput) {
          return customOutput;
        }
      }

      style = style.toLowerCase();

      if (style === "strikethrough") {
        return _react2.default.createElement("span", {
          style: { textDecoration: "line-through" }
        });
      } else if (style === "superscript") {
        return _react2.default.createElement("sup", null);
      } else if (style === "subscript") {
        return _react2.default.createElement("sub", null);
      } else if (style.indexOf("color-") === 0) {
        return _react2.default.createElement("span", {
          style: { color: "#" + getStyleValue(style) }
        });
      } else if (style.indexOf("bgcolor-") === 0) {
        return _react2.default.createElement("span", {
          style: { backgroundColor: "#" + getStyleValue(style) }
        });
      } else if (style.indexOf("fontsize-") === 0) {
        return _react2.default.createElement("span", {
          style: {
            fontSize: unitExportFn(getStyleValue(style), "font-size", "html")
          }
        });
      } else if (style.indexOf("lineheight-") === 0) {
        return _react2.default.createElement("span", {
          style: {
            lineHeight: unitExportFn(
              getStyleValue(style),
              "line-height",
              "html"
            )
          }
        });
      } else if (style.indexOf("letterspacing-") === 0) {
        return _react2.default.createElement("span", {
          style: {
            letterSpacing: unitExportFn(
              getStyleValue(style),
              "letter-spacing",
              "html"
            )
          }
        });
      } else if (style.indexOf("fontfamily-") === 0) {
        var fontFamily = options.fontFamilies.find(function(item) {
          return item.name.toLowerCase() === getStyleValue(style);
        });
        if (!fontFamily) return;
        return _react2.default.createElement("span", {
          style: { fontFamily: fontFamily.family }
        });
      }
    };
  };

  var blockToHTML = function blockToHTML(options) {
    return function(block) {
      var blockExportFn = options.blockExportFn,
        contentState = options.contentState;

      if (blockExportFn) {
        var customOutput = blockExportFn(contentState, block);
        if (customOutput) {
          return customOutput;
        }
      }

      var blockStyle = "";

      var blockType = block.type.toLowerCase();
      var _block$data2 = block.data,
        textAlign = _block$data2.textAlign,
        textIndent = _block$data2.textIndent,
        _block$data2$nodeAttr = _block$data2.nodeAttributes,
        nodeAttributes =
          _block$data2$nodeAttr === undefined ? {} : _block$data2$nodeAttr;

      var attributeString = spreadNodeAttributes(nodeAttributes);

      if (textAlign || textIndent) {
        blockStyle = ' style="';

        if (textAlign) {
          blockStyle += "text-align:" + textAlign + ";";
        }

        if (textIndent && !isNaN(textIndent) && textIndent > 0) {
          blockStyle += "text-indent:" + textIndent * 2 + "em;";
        }

        blockStyle += '"';
      }

      if (blockType === "atomic") {
        return convertAtomicBlock(block, contentState, nodeAttributes);
      } else if (blockType === "code-block") {
        var previousBlock = contentState.getBlockBefore(block.key);
        var nextBlock = contentState.getBlockAfter(block.key);
        var previousBlockType = previousBlock && previousBlock.getType();
        var nextBlockType = nextBlock && nextBlock.getType();

        var start = "";
        var end = "";

        if (previousBlockType !== "code-block") {
          start = "<pre" + attributeString + "><code>";
        } else {
          start = "";
        }

        if (nextBlockType !== "code-block") {
          end = "</code></pre>";
        } else {
          end = "<br/>";
        }

        return { start: start, end: end };
      } else if (blocks[blockType]) {
        return {
          start: "<" + blocks[blockType] + blockStyle + attributeString + ">",
          end: "</" + blocks[blockType] + ">"
        };
      } else if (blockType === "unordered-list-item") {
        return {
          start: "<li" + blockStyle + attributeString + ">",
          end: "</li>",
          nest: _react2.default.createElement("ul", null)
        };
      } else if (blockType === "ordered-list-item") {
        return {
          start: "<li" + blockStyle + attributeString + ">",
          end: "</li>",
          nest: _react2.default.createElement("ol", null)
        };
      }
    };
  };

  var htmlToStyle = function htmlToStyle(options, source) {
    return function(nodeName, node, currentStyle) {
      if (!node || !node.style) {
        return currentStyle;
      }

      var unitImportFn = options.unitImportFn || defaultUnitImportFn;
      var newStyle = currentStyle;

      [].forEach.call(node.style, function(style) {
        if (nodeName === "span" && style === "color") {
          var color = getHexColor(node.style.color);
          newStyle = color
            ? newStyle.add("COLOR-" + color.replace("#", "").toUpperCase())
            : newStyle;
        } else if (nodeName === "span" && style === "background-color") {
          var _color = getHexColor(node.style.backgroundColor);
          newStyle = _color
            ? newStyle.add("BGCOLOR-" + _color.replace("#", "").toUpperCase())
            : newStyle;
        } else if (nodeName === "span" && style === "font-size") {
          newStyle = newStyle.add(
            "FONTSIZE-" + unitImportFn(node.style.fontSize, "font-size", source)
          );
        } else if (
          nodeName === "span" &&
          style === "line-height" &&
          !isNaN(parseFloat(node.style.lineHeight, 10))
        ) {
          newStyle = newStyle.add(
            "LINEHEIGHT-" +
              unitImportFn(node.style.lineHeight, "line-height", source)
          );
        } else if (
          nodeName === "span" &&
          style === "letter-spacing" &&
          !isNaN(parseFloat(node.style.letterSpacing, 10))
        ) {
          newStyle = newStyle.add(
            "LETTERSPACING-" +
              unitImportFn(node.style.letterSpacing, "letter-spacing", source)
          );
        } else if (nodeName === "span" && style === "text-decoration") {
          if (node.style.textDecoration === "line-through") {
            newStyle = newStyle.add("STRIKETHROUGH");
          } else if (node.style.textDecoration === "underline") {
            newStyle = newStyle.add("UNDERLINE");
          }
        } else if (nodeName === "span" && style === "font-family") {
          var fontFamily = options.fontFamilies.find(function(item) {
            return (
              item.family.toLowerCase() === node.style.fontFamily.toLowerCase()
            );
          });
          if (!fontFamily) return;
          newStyle = newStyle.add(
            "FONTFAMILY-" + fontFamily.name.toUpperCase()
          );
        }
      });

      if (nodeName === "sup") {
        newStyle = newStyle.add("SUPERSCRIPT");
      } else if (nodeName === "sub") {
        newStyle = newStyle.add("SUBSCRIPT");
      }

      options.styleImportFn &&
        (newStyle =
          options.styleImportFn(nodeName, node, newStyle, source) || newStyle);
      return newStyle;
    };
  };

  var htmlToEntity = function htmlToEntity(options, source) {
    return function(nodeName, node, createEntity) {
      if (options && options.entityImportFn) {
        var customInput = options.entityImportFn(
          nodeName,
          node,
          createEntity,
          source
        );
        if (customInput) {
          return customInput;
        }
      }

      nodeName = nodeName.toLowerCase();

      var alt = node.alt,
        title = node.title,
        id = node.id,
        controls = node.controls,
        autoplay = node.autoplay,
        loop = node.loop,
        poster = node.poster;

      var meta = {};
      var nodeAttributes = {};

      id && (meta.id = id);
      alt && (meta.alt = alt);
      title && (meta.title = title);
      controls && (meta.controls = controls);
      autoplay && (meta.autoPlay = autoplay);
      loop && (meta.loop = loop);
      poster && (meta.poster = poster);

      node.attributes &&
        Object.keys(node.attributes).forEach(function(key) {
          var attr = node.attributes[key];
          ignoredEntityNodeAttributes.indexOf(attr.name) === -1 &&
            (nodeAttributes[attr.name] = attr.value);
        });

      if (nodeName === "a" && !node.querySelectorAll("img").length) {
        var href = node.getAttribute("href");
        var _target = node.getAttribute("target");
        return createEntity("LINK", "MUTABLE", {
          href: href,
          target: _target,
          nodeAttributes: nodeAttributes
        });
      } else if (nodeName === "audio") {
        return createEntity("AUDIO", "IMMUTABLE", {
          url: node.getAttribute("src"),
          meta: meta,
          nodeAttributes: nodeAttributes
        });
      } else if (nodeName === "video") {
        return createEntity("VIDEO", "IMMUTABLE", {
          url: node.getAttribute("src"),
          meta: meta,
          nodeAttributes: nodeAttributes
        });
      } else if (nodeName === "img") {
        var parentNode = node.parentNode;
        var entityData = { meta: meta };
        var _node$style = node.style,
          width = _node$style.width,
          height = _node$style.height;

        entityData.url = node.getAttribute("src");
        width && (entityData.width = width);
        height && (entityData.height = height);

        if (parentNode.nodeName.toLowerCase() === "a") {
          entityData.link = parentNode.getAttribute("href");
          entityData.link_target = parentNode.getAttribute("target");
        }

        return createEntity("IMAGE", "IMMUTABLE", entityData);
      } else if (nodeName === "hr") {
        return createEntity("HR", "IMMUTABLE", {});
      } else if (
        node.parentNode &&
        node.parentNode.classList.contains("embed-wrap")
      ) {
        var embedContent = node.innerHTML || node.outerHTML;

        if (embedContent) {
          return createEntity("EMBED", "IMMUTABLE", {
            url: embedContent
          });
        }
      }
    };
  };

  var htmlToBlock = function htmlToBlock(options, source) {
    return function(nodeName, node) {
      if (options && options.blockImportFn) {
        var customInput = options.blockImportFn(nodeName, node, source);
        if (customInput) {
          return customInput;
        }
      }

      var nodeAttributes = {};
      var nodeStyle = node.style || {};

      node.attributes &&
        Object.keys(node.attributes).forEach(function(key) {
          var attr = node.attributes[key];
          ignoredNodeAttributes.indexOf(attr.name) === -1 &&
            (nodeAttributes[attr.name] = attr.value);
        });

      if (node.classList && node.classList.contains("media-wrap")) {
        return {
          type: "atomic",
          data: {
            nodeAttributes: nodeAttributes,
            float: nodeStyle.float,
            alignment: nodeStyle.textAlign
          }
        };
      } else if (nodeName === "img") {
        return {
          type: "atomic",
          data: {
            nodeAttributes: nodeAttributes,
            float: nodeStyle.float,
            alignment: nodeStyle.textAlign
          }
        };
      } else if (nodeName === "hr") {
        return {
          type: "atomic",
          data: { nodeAttributes: nodeAttributes }
        };
      } else if (nodeName === "pre") {
        node.innerHTML = node.innerHTML
          .replace(/<code(.*?)>/g, "")
          .replace(/<\/code>/g, "");

        return {
          type: "code-block",
          data: { nodeAttributes: nodeAttributes }
        };
      } else if (blockNames.indexOf(nodeName) !== -1) {
        var blockData = { nodeAttributes: nodeAttributes };

        if (nodeStyle.textAlign) {
          blockData.textAlign = nodeStyle.textAlign;
        }

        if (nodeStyle.textIndent) {
          blockData.textIndent = /^\d+em$/.test(nodeStyle.textIndent)
            ? Math.ceil(parseInt(nodeStyle.textIndent, 10) / 2)
            : 1;
        }

        return {
          type: blockTypes[blockNames.indexOf(nodeName)],
          data: blockData
        };
      }
    };
  };

  var getToHTMLConfig = (exports.getToHTMLConfig = function getToHTMLConfig(
    options
  ) {
    return {
      styleToHTML: styleToHTML(options),
      entityToHTML: entityToHTML(options),
      blockToHTML: blockToHTML(options)
    };
  });

  var getFromHTMLConfig = (exports.getFromHTMLConfig = function getFromHTMLConfig(
    options
  ) {
    var source =
      arguments.length > 1 && arguments[1] !== undefined
        ? arguments[1]
        : "unknow";

    return {
      htmlToStyle: htmlToStyle(options, source),
      htmlToEntity: htmlToEntity(options, source),
      htmlToBlock: htmlToBlock(options, source)
    };
  });
});

_commonjsHelpers.unwrapExports(configs);
var configs_1 = configs.getFromHTMLConfig;
var configs_2 = configs.getToHTMLConfig;
var configs_3 = configs.blocks;
var configs_4 = configs.getHexColor;
var configs_5 = configs.defaultFontFamilies;
var configs_6 = configs.namedColors;

var dist = _commonjsHelpers.createCommonjsModule(function(module, exports) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.convertRawToEditorState = exports.convertEditorStateToRaw = exports.convertHTMLToEditorState = exports.convertEditorStateToHTML = exports.convertHTMLToRaw = exports.convertRawToHTML = undefined;

  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;
    };

  var defaultConvertOptions = {
    fontFamilies: configs.defaultFontFamilies
  };

  var convertRawToHTML = (exports.convertRawToHTML = function convertRawToHTML(
    rawContent,
    options
  ) {
    options = _extends({}, defaultConvertOptions, options);

    try {
      var contentState = (0, Draft.convertFromRaw)(rawContent);
      options.contentState = contentState;
      return (0, lib.convertToHTML)((0, configs.getToHTMLConfig)(options))(
        contentState
      );
    } catch (error) {
      console.warn(error);
      return "";
    }
  });

  var convertHTMLToRaw = (exports.convertHTMLToRaw = function convertHTMLToRaw(
    HTMLString,
    options,
    source
  ) {
    options = _extends({}, defaultConvertOptions, options);

    try {
      var contentState = (0, lib.convertFromHTML)(
        (0, configs.getFromHTMLConfig)(options, source)
      )(HTMLString);
      return (0, Draft.convertToRaw)(contentState);
    } catch (error) {
      console.warn(error);
      return {};
    }
  });

  var convertEditorStateToHTML = (exports.convertEditorStateToHTML = function convertEditorStateToHTML(
    editorState,
    options
  ) {
    options = _extends({}, defaultConvertOptions, options);

    try {
      var contentState = editorState.getCurrentContent();
      options.contentState = contentState;
      return (0, lib.convertToHTML)((0, configs.getToHTMLConfig)(options))(
        contentState
      );
    } catch (error) {
      console.warn(error);
      return "";
    }
  });

  var convertHTMLToEditorState = (exports.convertHTMLToEditorState = function convertHTMLToEditorState(
    HTMLString,
    editorDecorators,
    options,
    source
  ) {
    options = _extends({}, defaultConvertOptions, options);

    try {
      return Draft.EditorState.createWithContent(
        (0, lib.convertFromHTML)(
          (0, configs.getFromHTMLConfig)(options, source)
        )(HTMLString),
        editorDecorators
      );
    } catch (error) {
      console.warn(error);
      return Draft.EditorState.createEmpty(editorDecorators);
    }
  });

  var convertEditorStateToRaw = (exports.convertEditorStateToRaw = function convertEditorStateToRaw(
    editorState
  ) {
    return (0, Draft.convertToRaw)(editorState.getCurrentContent());
  });

  var convertRawToEditorState = (exports.convertRawToEditorState = function convertRawToEditorState(
    rawContent,
    editorDecorators
  ) {
    try {
      return Draft.EditorState.createWithContent(
        (0, Draft.convertFromRaw)(rawContent),
        editorDecorators
      );
    } catch (error) {
      console.warn(error);
      return Draft.EditorState.createEmpty(editorDecorators);
    }
  });
});

_commonjsHelpers.unwrapExports(dist);
var dist_1 = dist.convertRawToEditorState;
var dist_2 = dist.convertEditorStateToRaw;
var dist_3 = dist.convertHTMLToEditorState;
var dist_4 = dist.convertEditorStateToHTML;
var dist_5 = dist.convertHTMLToRaw;
var dist_6 = dist.convertRawToHTML;

var content = _commonjsHelpers.createCommonjsModule(function(module, exports) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.redo = exports.undo = exports.handleKeyCommand = exports.clear = exports.setMediaPosition = exports.removeMedia = exports.setMediaData = exports.insertMedias = exports.insertHorizontalLine = exports.insertAtomicBlock = exports.insertHTML = exports.insertText = exports.toggleSelectionLetterSpacing = exports.toggleSelectionFontFamily = exports.toggleSelectionLineHeight = exports.toggleSelectionFontSize = exports.toggleSelectionBackgroundColor = exports.toggleSelectionColor = exports.decreaseSelectionIndent = exports.increaseSelectionIndent = exports.toggleSelectionIndent = exports.toggleSelectionAlignment = exports.removeSelectionInlineStyles = exports.toggleSelectionInlineStyle = exports.selectionHasInlineStyle = exports.getSelectionInlineStyle = exports.toggleSelectionLink = exports.toggleSelectionEntity = exports.getSelectionEntityData = exports.getSelectionEntityType = exports.toggleSelectionBlockType = exports.getSelectionText = exports.getSelectionBlockType = exports.getSelectionBlockData = exports.setSelectionBlockData = exports.getSelectedBlocks = exports.updateEachCharacterOfSelection = exports.getSelectionBlock = exports.removeBlock = exports.selectNextBlock = exports.selectBlock = exports.selectionContainsStrictBlock = exports.selectionContainsBlockType = exports.isSelectionCollapsed = exports.createEditorState = exports.createEmptyEditorState = exports.isEditorState = exports.registerStrictBlockType = undefined;

  var _immutable2 = _interopRequireDefault(immutable$1);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }

  var strictBlockTypes = ["atomic"];

  var registerStrictBlockType = (exports.registerStrictBlockType = function registerStrictBlockType(
    blockType
  ) {
    strictBlockTypes.indexOf(blockType) === -1 &&
      strictBlockTypes.push(blockType);
  });

  var isEditorState = (exports.isEditorState = function isEditorState(
    editorState
  ) {
    return editorState instanceof Draft.EditorState;
  });

  var createEmptyEditorState = (exports.createEmptyEditorState = function createEmptyEditorState(
    editorDecorators
  ) {
    return Draft.EditorState.createEmpty(editorDecorators);
  });

  var createEditorState = (exports.createEditorState = function createEditorState(
    contentState,
    editorDecorators
  ) {
    return Draft.EditorState.createWithContent(contentState, editorDecorators);
  });

  var isSelectionCollapsed = (exports.isSelectionCollapsed = function isSelectionCollapsed(
    editorState
  ) {
    return editorState.getSelection().isCollapsed();
  });

  var selectionContainsBlockType = (exports.selectionContainsBlockType = function selectionContainsBlockType(
    editorState,
    blockType
  ) {
    return getSelectedBlocks(editorState).find(function(block) {
      return block.getType() === blockType;
    });
  });

  var selectionContainsStrictBlock = (exports.selectionContainsStrictBlock = function selectionContainsStrictBlock(
    editorState
  ) {
    return getSelectedBlocks(editorState).find(function(block) {
      return ~strictBlockTypes.indexOf(block.getType());
    });
  });

  var selectBlock = (exports.selectBlock = function selectBlock(
    editorState,
    block
  ) {
    var blockKey = block.getKey();

    return Draft.EditorState.forceSelection(
      editorState,
      new Draft.SelectionState({
        anchorKey: blockKey,
        anchorOffset: 0,
        focusKey: blockKey,
        focusOffset: block.getLength()
      })
    );
  });

  var selectNextBlock = (exports.selectNextBlock = function selectNextBlock(
    editorState,
    block
  ) {
    var nextBlock = editorState
      .getCurrentContent()
      .getBlockAfter(block.getKey());
    return nextBlock ? selectBlock(editorState, nextBlock) : editorState;
  });

  var removeBlock = (exports.removeBlock = function removeBlock(
    editorState,
    block
  ) {
    var lastSelection =
      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;

    var nextContentState = void 0,
      nextEditorState = void 0;
    var blockKey = block.getKey();

    nextContentState = Draft.Modifier.removeRange(
      editorState.getCurrentContent(),
      new Draft.SelectionState({
        anchorKey: blockKey,
        anchorOffset: 0,
        focusKey: blockKey,
        focusOffset: block.getLength()
      }),
      "backward"
    );

    nextContentState = Draft.Modifier.setBlockType(
      nextContentState,
      nextContentState.getSelectionAfter(),
      "unstyled"
    );
    nextEditorState = Draft.EditorState.push(
      editorState,
      nextContentState,
      "remove-range"
    );
    return Draft.EditorState.forceSelection(
      nextEditorState,
      lastSelection || nextContentState.getSelectionAfter()
    );
  });

  var getSelectionBlock = (exports.getSelectionBlock = function getSelectionBlock(
    editorState
  ) {
    return editorState
      .getCurrentContent()
      .getBlockForKey(editorState.getSelection().getAnchorKey());
  });

  var updateEachCharacterOfSelection = (exports.updateEachCharacterOfSelection = function updateEachCharacterOfSelection(
    editorState,
    callback
  ) {
    var selectionState = editorState.getSelection();
    var contentState = editorState.getCurrentContent();
    var contentBlocks = contentState.getBlockMap();
    var selectedBlocks = getSelectedBlocks(editorState);

    if (selectedBlocks.length === 0) {
      return editorState;
    }

    var startKey = selectionState.getStartKey();
    var startOffset = selectionState.getStartOffset();
    var endKey = selectionState.getEndKey();
    var endOffset = selectionState.getEndOffset();

    var nextContentBlocks = contentBlocks.map(function(block) {
      if (selectedBlocks.indexOf(block) === -1) {
        return block;
      }

      var blockKey = block.getKey();
      var charactersList = block.getCharacterList();
      var nextCharactersList = null;

      if (blockKey === startKey && blockKey === endKey) {
        nextCharactersList = charactersList.map(function(character, index) {
          if (index >= startOffset && index < endOffset) {
            return callback(character);
          }
          return character;
        });
      } else if (blockKey === startKey) {
        nextCharactersList = charactersList.map(function(character, index) {
          if (index >= startOffset) {
            return callback(character);
          }
          return character;
        });
      } else if (blockKey === endKey) {
        nextCharactersList = charactersList.map(function(character, index) {
          if (index < endOffset) {
            return callback(character);
          }
          return character;
        });
      } else {
        nextCharactersList = charactersList.map(function(character) {
          return callback(character);
        });
      }

      return block.merge({
        characterList: nextCharactersList
      });
    });

    return Draft.EditorState.push(
      editorState,
      contentState.merge({
        blockMap: nextContentBlocks,
        selectionBefore: selectionState,
        selectionAfter: selectionState
      }),
      "update-selection-character-list"
    );
  });

  var getSelectedBlocks = (exports.getSelectedBlocks = function getSelectedBlocks(
    editorState
  ) {
    var selectionState = editorState.getSelection();
    var contentState = editorState.getCurrentContent();

    var startKey = selectionState.getStartKey();
    var endKey = selectionState.getEndKey();
    var isSameBlock = startKey === endKey;
    var startingBlock = contentState.getBlockForKey(startKey);
    var selectedBlocks = [startingBlock];

    if (!isSameBlock) {
      var blockKey = startKey;

      while (blockKey !== endKey) {
        var nextBlock = contentState.getBlockAfter(blockKey);
        selectedBlocks.push(nextBlock);
        blockKey = nextBlock.getKey();
      }
    }

    return selectedBlocks;
  });

  var setSelectionBlockData = (exports.setSelectionBlockData = function setSelectionBlockData(
    editorState,
    blockData,
    override
  ) {
    var newBlockData = override
      ? blockData
      : Object.assign({}, getSelectionBlockData(editorState).toJS(), blockData);

    Object.keys(newBlockData).forEach(function(key) {
      if (newBlockData.hasOwnProperty(key) && newBlockData[key] === undefined) {
        delete newBlockData[key];
      }
    });

    return (0, draftjsUtils.setBlockData)(editorState, newBlockData);
  });

  var getSelectionBlockData = (exports.getSelectionBlockData = function getSelectionBlockData(
    editorState,
    name
  ) {
    var blockData = getSelectionBlock(editorState).getData();
    return name ? blockData.get(name) : blockData;
  });

  var getSelectionBlockType = (exports.getSelectionBlockType = function getSelectionBlockType(
    editorState
  ) {
    return getSelectionBlock(editorState).getType();
  });

  var getSelectionText = (exports.getSelectionText = function getSelectionText(
    editorState
  ) {
    var selectionState = editorState.getSelection();
    var contentState = editorState.getCurrentContent();

    if (
      selectionState.isCollapsed() ||
      getSelectionBlockType(editorState) === "atomic"
    ) {
      return "";
    }

    var anchorKey = selectionState.getAnchorKey();
    var currentContentBlock = contentState.getBlockForKey(anchorKey);
    var start = selectionState.getStartOffset();
    var end = selectionState.getEndOffset();

    return currentContentBlock.getText().slice(start, end);
  });

  var toggleSelectionBlockType = (exports.toggleSelectionBlockType = function toggleSelectionBlockType(
    editorState,
    blockType
  ) {
    if (selectionContainsStrictBlock(editorState)) {
      return editorState;
    }

    return Draft.RichUtils.toggleBlockType(editorState, blockType);
  });

  var getSelectionEntityType = (exports.getSelectionEntityType = function getSelectionEntityType(
    editorState
  ) {
    var entityKey = (0, draftjsUtils.getSelectionEntity)(editorState);

    if (entityKey) {
      var entity = editorState.getCurrentContent().getEntity(entityKey);
      return entity ? entity.get("type") : null;
    }

    return null;
  });

  var getSelectionEntityData = (exports.getSelectionEntityData = function getSelectionEntityData(
    editorState,
    type
  ) {
    var entityKey = (0, draftjsUtils.getSelectionEntity)(editorState);

    if (entityKey) {
      var entity = editorState.getCurrentContent().getEntity(entityKey);
      if (entity && entity.get("type") === type) {
        return entity.getData();
      } else {
        return {};
      }
    } else {
      return {};
    }
  });

  var toggleSelectionEntity = (exports.toggleSelectionEntity = function toggleSelectionEntity(
    editorState,
    entity
  ) {
    var contentState = editorState.getCurrentContent();
    var selectionState = editorState.getSelection();

    if (
      selectionState.isCollapsed() ||
      getSelectionBlockType(editorState) === "atomic"
    ) {
      return editorState;
    }

    if (
      !entity ||
      !entity.type ||
      getSelectionEntityType(editorState) === entity.type
    ) {
      return Draft.EditorState.push(
        editorState,
        Draft.Modifier.applyEntity(contentState, selectionState, null),
        "apply-entity"
      );
    }

    try {
      var nextContentState = contentState.createEntity(
        entity.type,
        entity.mutability,
        entity.data
      );
      var entityKey = nextContentState.getLastCreatedEntityKey();

      var nextEditorState = Draft.EditorState.set(editorState, {
        currentContent: nextContentState
      });

      return Draft.EditorState.push(
        nextEditorState,
        Draft.Modifier.applyEntity(nextContentState, selectionState, entityKey),
        "apply-entity"
      );
    } catch (error) {
      console.warn(error);
      return editorState;
    }
  });

  var toggleSelectionLink = (exports.toggleSelectionLink = function toggleSelectionLink(
    editorState,
    href,
    target
  ) {
    var contentState = editorState.getCurrentContent();
    var selectionState = editorState.getSelection();

    var entityData = { href: href, target: target };

    if (
      selectionState.isCollapsed() ||
      getSelectionBlockType(editorState) === "atomic"
    ) {
      return editorState;
    }

    if (href === false) {
      return Draft.RichUtils.toggleLink(editorState, selectionState, null);
    }

    if (href === null) {
      delete entityData.href;
    }

    try {
      var nextContentState = contentState.createEntity(
        "LINK",
        "MUTABLE",
        entityData
      );
      var entityKey = nextContentState.getLastCreatedEntityKey();

      var nextEditorState = Draft.EditorState.set(editorState, {
        currentContent: nextContentState
      });

      nextEditorState = Draft.RichUtils.toggleLink(
        nextEditorState,
        selectionState,
        entityKey
      );
      nextEditorState = Draft.EditorState.forceSelection(
        nextEditorState,
        selectionState.merge({
          anchorOffset: selectionState.getEndOffset(),
          focusOffset: selectionState.getEndOffset()
        })
      );

      nextEditorState = Draft.EditorState.push(
        nextEditorState,
        Draft.Modifier.insertText(
          nextEditorState.getCurrentContent(),
          nextEditorState.getSelection(),
          ""
        ),
        "insert-text"
      );

      return nextEditorState;
    } catch (error) {
      console.warn(error);
      return editorState;
    }
  });

  var getSelectionInlineStyle = (exports.getSelectionInlineStyle = function getSelectionInlineStyle(
    editorState
  ) {
    return editorState.getCurrentInlineStyle();
  });

  var selectionHasInlineStyle = (exports.selectionHasInlineStyle = function selectionHasInlineStyle(
    editorState,
    style
  ) {
    return getSelectionInlineStyle(editorState).has(style.toUpperCase());
  });

  var toggleSelectionInlineStyle = (exports.toggleSelectionInlineStyle = function toggleSelectionInlineStyle(
    editorState,
    style
  ) {
    var prefix =
      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "";

    var nextEditorState = editorState;
    style = prefix + style.toUpperCase();

    if (prefix) {
      nextEditorState = updateEachCharacterOfSelection(
        nextEditorState,
        function(characterMetadata) {
          return characterMetadata
            .toJS()
            .style.reduce(function(characterMetadata, characterStyle) {
              if (
                characterStyle.indexOf(prefix) === 0 &&
                style !== characterStyle
              ) {
                return Draft.CharacterMetadata.removeStyle(
                  characterMetadata,
                  characterStyle
                );
              } else {
                return characterMetadata;
              }
            }, characterMetadata);
        }
      );
    }

    return Draft.RichUtils.toggleInlineStyle(nextEditorState, style);
  });

  var removeSelectionInlineStyles = (exports.removeSelectionInlineStyles = function removeSelectionInlineStyles(
    editorState
  ) {
    return updateEachCharacterOfSelection(editorState, function(
      characterMetadata
    ) {
      return characterMetadata.merge({
        style: _immutable2.default.OrderedSet([])
      });
    });
  });

  var toggleSelectionAlignment = (exports.toggleSelectionAlignment = function toggleSelectionAlignment(
    editorState,
    alignment
  ) {
    return setSelectionBlockData(editorState, {
      textAlign:
        getSelectionBlockData(editorState, "textAlign") !== alignment
          ? alignment
          : undefined
    });
  });

  var toggleSelectionIndent = (exports.toggleSelectionIndent = function toggleSelectionIndent(
    editorState,
    textIndent
  ) {
    var maxIndent =
      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 6;

    return textIndent < 0 || textIndent > maxIndent || isNaN(textIndent)
      ? editorState
      : setSelectionBlockData(editorState, {
          textIndent: textIndent || undefined
        });
  });

  var increaseSelectionIndent = (exports.increaseSelectionIndent = function increaseSelectionIndent(
    editorState
  ) {
    var maxIndent =
      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 6;

    var currentIndent = getSelectionBlockData(editorState, "textIndent") || 0;
    return toggleSelectionIndent(editorState, currentIndent + 1, maxIndent);
  });

  var decreaseSelectionIndent = (exports.decreaseSelectionIndent = function decreaseSelectionIndent(
    editorState
  ) {
    var currentIndent = getSelectionBlockData(editorState, "textIndent") || 0;
    return toggleSelectionIndent(editorState, currentIndent - 1);
  });

  var toggleSelectionColor = (exports.toggleSelectionColor = function toggleSelectionColor(
    editorState,
    color
  ) {
    return toggleSelectionInlineStyle(
      editorState,
      color.replace("#", ""),
      "COLOR-"
    );
  });

  var toggleSelectionBackgroundColor = (exports.toggleSelectionBackgroundColor = function toggleSelectionBackgroundColor(
    editorState,
    color
  ) {
    return toggleSelectionInlineStyle(
      editorState,
      color.replace("#", ""),
      "BGCOLOR-"
    );
  });

  var toggleSelectionFontSize = (exports.toggleSelectionFontSize = function toggleSelectionFontSize(
    editorState,
    fontSize
  ) {
    return toggleSelectionInlineStyle(editorState, fontSize, "FONTSIZE-");
  });

  var toggleSelectionLineHeight = (exports.toggleSelectionLineHeight = function toggleSelectionLineHeight(
    editorState,
    lineHeight
  ) {
    return toggleSelectionInlineStyle(editorState, lineHeight, "LINEHEIGHT-");
  });

  var toggleSelectionFontFamily = (exports.toggleSelectionFontFamily = function toggleSelectionFontFamily(
    editorState,
    fontFamily
  ) {
    return toggleSelectionInlineStyle(editorState, fontFamily, "FONTFAMILY-");
  });

  var toggleSelectionLetterSpacing = (exports.toggleSelectionLetterSpacing = function toggleSelectionLetterSpacing(
    editorState,
    letterSpacing
  ) {
    return toggleSelectionInlineStyle(
      editorState,
      letterSpacing,
      "LETTERSPACING-"
    );
  });

  var insertText = (exports.insertText = function insertText(
    editorState,
    text,
    inlineStyle,
    entity
  ) {
    var selectionState = editorState.getSelection();
    var currentSelectedBlockType = getSelectionBlockType(editorState);

    if (currentSelectedBlockType === "atomic") {
      return editorState;
    }

    var entityKey = void 0;
    var contentState = editorState.getCurrentContent();

    if (entity && entity.type) {
      contentState = contentState.createEntity(
        entity.type,
        entity.mutability || "MUTABLE",
        entity.data || entityData
      );
      entityKey = contentState.getLastCreatedEntityKey();
    }

    if (!selectionState.isCollapsed()) {
      return Draft.EditorState.push(
        editorState,
        Draft.Modifier.replaceText(
          contentState,
          selectionState,
          text,
          inlineStyle,
          entityKey
        ),
        "replace-text"
      );
    } else {
      return Draft.EditorState.push(
        editorState,
        Draft.Modifier.insertText(
          contentState,
          selectionState,
          text,
          inlineStyle,
          entityKey
        ),
        "insert-text"
      );
    }
  });

  var insertHTML = (exports.insertHTML = function insertHTML(
    editorState,
    htmlString,
    source
  ) {
    if (!htmlString) {
      return editorState;
    }

    var selectionState = editorState.getSelection();
    var contentState = editorState.getCurrentContent();
    var options = editorState.convertOptions || {};

    try {
      var _convertFromRaw = (0, Draft.convertFromRaw)(
          (0, dist.convertHTMLToRaw)(htmlString, options, source)
        ),
        blockMap = _convertFromRaw.blockMap;

      return Draft.EditorState.push(
        editorState,
        Draft.Modifier.replaceWithFragment(
          contentState,
          selectionState,
          blockMap
        ),
        "insert-fragment"
      );
    } catch (error) {
      console.warn(error);
      return editorState;
    }
  });

  var insertAtomicBlock = (exports.insertAtomicBlock = function insertAtomicBlock(
    editorState,
    type
  ) {
    var immutable =
      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
    var data =
      arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};

    if (selectionContainsStrictBlock(editorState)) {
      return insertAtomicBlock(
        selectNextBlock(editorState, getSelectionBlock(editorState)),
        type,
        immutable,
        data
      );
    }

    var selectionState = editorState.getSelection();
    var contentState = editorState.getCurrentContent();

    if (
      !selectionState.isCollapsed() ||
      getSelectionBlockType(editorState) === "atomic"
    ) {
      return editorState;
    }

    var contentStateWithEntity = contentState.createEntity(
      type,
      immutable ? "IMMUTABLE" : "MUTABLE",
      data
    );
    var entityKey = contentStateWithEntity.getLastCreatedEntityKey();
    var newEditorState = Draft.AtomicBlockUtils.insertAtomicBlock(
      editorState,
      entityKey,
      " "
    );

    return newEditorState;
  });

  var insertHorizontalLine = (exports.insertHorizontalLine = function insertHorizontalLine(
    editorState
  ) {
    return insertAtomicBlock(editorState, "HR");
  });

  var insertMedias = (exports.insertMedias = function insertMedias(
    editorState
  ) {
    var medias =
      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];

    if (!medias.length) {
      return editorState;
    }

    return medias.reduce(function(editorState, media) {
      var url = media.url,
        link = media.link,
        link_target = media.link_target,
        name = media.name,
        type = media.type,
        width = media.width,
        height = media.height,
        meta = media.meta;

      return insertAtomicBlock(editorState, type, true, {
        url: url,
        link: link,
        link_target: link_target,
        name: name,
        type: type,
        width: width,
        height: height,
        meta: meta
      });
    }, editorState);
  });

  var setMediaData = (exports.setMediaData = function setMediaData(
    editorState,
    entityKey,
    data
  ) {
    return Draft.EditorState.push(
      editorState,
      editorState.getCurrentContent().mergeEntityData(entityKey, data),
      "change-block-data"
    );
  });

  var removeMedia = (exports.removeMedia = function removeMedia(
    editorState,
    mediaBlock
  ) {
    return removeBlock(editorState, mediaBlock);
  });

  var setMediaPosition = (exports.setMediaPosition = function setMediaPosition(
    editorState,
    mediaBlock,
    position
  ) {
    var newPosition = {};
    var float = position.float,
      alignment = position.alignment;

    if (typeof float !== "undefined") {
      newPosition.float =
        mediaBlock.getData().get("float") === float ? null : float;
    }

    if (typeof alignment !== "undefined") {
      newPosition.alignment =
        mediaBlock.getData().get("alignment") === alignment ? null : alignment;
    }

    return setSelectionBlockData(
      selectBlock(editorState, mediaBlock),
      newPosition
    );
  });

  var clear = (exports.clear = function clear(editorState) {
    var contentState = editorState.getCurrentContent();

    var firstBlock = contentState.getFirstBlock();
    var lastBlock = contentState.getLastBlock();

    var allSelected = new Draft.SelectionState({
      anchorKey: firstBlock.getKey(),
      anchorOffset: 0,
      focusKey: lastBlock.getKey(),
      focusOffset: lastBlock.getLength(),
      hasFocus: true
    });

    return Draft.RichUtils.toggleBlockType(
      Draft.EditorState.push(
        editorState,
        Draft.Modifier.removeRange(contentState, allSelected, "backward"),
        "remove-range"
      ),
      "unstyled"
    );
  });

  var handleKeyCommand = (exports.handleKeyCommand = function handleKeyCommand(
    editorState,
    command
  ) {
    return Draft.RichUtils.handleKeyCommand(editorState, command);
  });

  var undo = (exports.undo = function undo(editorState) {
    return Draft.EditorState.undo(editorState);
  });

  var redo = (exports.redo = function redo(editorState) {
    return Draft.EditorState.redo(editorState);
  });
});

_commonjsHelpers.unwrapExports(content);
var content_1 = content.redo;
var content_2 = content.undo;
var content_3 = content.handleKeyCommand;
var content_4 = content.clear;
var content_5 = content.setMediaPosition;
var content_6 = content.removeMedia;
var content_7 = content.setMediaData;
var content_8 = content.insertMedias;
var content_9 = content.insertHorizontalLine;
var content_10 = content.insertAtomicBlock;
var content_11 = content.insertHTML;
var content_12 = content.insertText;
var content_13 = content.toggleSelectionLetterSpacing;
var content_14 = content.toggleSelectionFontFamily;
var content_15 = content.toggleSelectionLineHeight;
var content_16 = content.toggleSelectionFontSize;
var content_17 = content.toggleSelectionBackgroundColor;
var content_18 = content.toggleSelectionColor;
var content_19 = content.decreaseSelectionIndent;
var content_20 = content.increaseSelectionIndent;
var content_21 = content.toggleSelectionIndent;
var content_22 = content.toggleSelectionAlignment;
var content_23 = content.removeSelectionInlineStyles;
var content_24 = content.toggleSelectionInlineStyle;
var content_25 = content.selectionHasInlineStyle;
var content_26 = content.getSelectionInlineStyle;
var content_27 = content.toggleSelectionLink;
var content_28 = content.toggleSelectionEntity;
var content_29 = content.getSelectionEntityData;
var content_30 = content.getSelectionEntityType;
var content_31 = content.toggleSelectionBlockType;
var content_32 = content.getSelectionText;
var content_33 = content.getSelectionBlockType;
var content_34 = content.getSelectionBlockData;
var content_35 = content.setSelectionBlockData;
var content_36 = content.getSelectedBlocks;
var content_37 = content.updateEachCharacterOfSelection;
var content_38 = content.getSelectionBlock;
var content_39 = content.removeBlock;
var content_40 = content.selectNextBlock;
var content_41 = content.selectBlock;
var content_42 = content.selectionContainsStrictBlock;
var content_43 = content.selectionContainsBlockType;
var content_44 = content.isSelectionCollapsed;
var content_45 = content.createEditorState;
var content_46 = content.createEmptyEditorState;
var content_47 = content.isEditorState;
var content_48 = content.registerStrictBlockType;

var base = _commonjsHelpers.createCommonjsModule(function(module, exports) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  var braftUniqueIndex = 0;

  var UniqueIndex = (exports.UniqueIndex = function UniqueIndex() {
    return (braftUniqueIndex += 1);
  });
});

_commonjsHelpers.unwrapExports(base);
var base_1 = base.UniqueIndex;

var color = _commonjsHelpers.createCommonjsModule(function(module, exports) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  var _namedColors = {
    aliceblue: "#f0f8ff",
    antiquewhite: "#faebd7",
    aqua: "#00ffff",
    aquamarine: "#7fffd4",
    azure: "#f0ffff",
    beige: "#f5f5dc",
    bisque: "#ffe4c4",
    black: "#000000",
    blanchedalmond: "#ffebcd",
    blue: "#0000ff",
    blueviolet: "#8a2be2",
    brown: "#a52a2a",
    burlywood: "#deb887",
    cadetblue: "#5f9ea0",
    chartreuse: "#7fff00",
    chocolate: "#d2691e",
    coral: "#ff7f50",
    cornflowerblue: "#6495ed",
    cornsilk: "#fff8dc",
    crimson: "#dc143c",
    cyan: "#00ffff",
    darkblue: "#00008b",
    darkcyan: "#008b8b",
    darkgoldenrod: "#b8860b",
    darkgray: "#a9a9a9",
    darkgreen: "#006400",
    darkkhaki: "#bdb76b",
    darkmagenta: "#8b008b",
    darkolivegreen: "#556b2f",
    darkorange: "#ff8c00",
    darkorchid: "#9932cc",
    darkred: "#8b0000",
    darksalmon: "#e9967a",
    darkseagreen: "#8fbc8f",
    darkslateblue: "#483d8b",
    darkslategray: "#2f4f4f",
    darkturquoise: "#00ced1",
    darkviolet: "#9400d3",
    deeppink: "#ff1493",
    deepskyblue: "#00bfff",
    dimgray: "#696969",
    dodgerblue: "#1e90ff",
    firebrick: "#b22222",
    floralwhite: "#fffaf0",
    forestgreen: "#228b22",
    fuchsia: "#ff00ff",
    gainsboro: "#dcdcdc",
    ghostwhite: "#f8f8ff",
    gold: "#ffd700",
    goldenrod: "#daa520",
    gray: "#808080",
    green: "#008000",
    greenyellow: "#adff2f",
    honeydew: "#f0fff0",
    hotpink: "#ff69b4",
    "indianred ": "#cd5c5c",
    indigo: "#4b0082",
    ivory: "#fffff0",
    khaki: "#f0e68c",
    lavender: "#e6e6fa",
    lavenderblush: "#fff0f5",
    lawngreen: "#7cfc00",
    lemonchiffon: "#fffacd",
    lightblue: "#add8e6",
    lightcoral: "#f08080",
    lightcyan: "#e0ffff",
    lightgoldenrodyellow: "#fafad2",
    lightgrey: "#d3d3d3",
    lightgreen: "#90ee90",
    lightpink: "#ffb6c1",
    lightsalmon: "#ffa07a",
    lightseagreen: "#20b2aa",
    lightskyblue: "#87cefa",
    lightslategray: "#778899",
    lightsteelblue: "#b0c4de",
    lightyellow: "#ffffe0",
    lime: "#00ff00",
    limegreen: "#32cd32",
    linen: "#faf0e6",
    magenta: "#ff00ff",
    maroon: "#800000",
    mediumaquamarine: "#66cdaa",
    mediumblue: "#0000cd",
    mediumorchid: "#ba55d3",
    mediumpurple: "#9370d8",
    mediumseagreen: "#3cb371",
    mediumslateblue: "#7b68ee",
    mediumspringgreen: "#00fa9a",
    mediumturquoise: "#48d1cc",
    mediumvioletred: "#c71585",
    midnightblue: "#191970",
    mintcream: "#f5fffa",
    mistyrose: "#ffe4e1",
    moccasin: "#ffe4b5",
    navajowhite: "#ffdead",
    navy: "#000080",
    oldlace: "#fdf5e6",
    olive: "#808000",
    olivedrab: "#6b8e23",
    orange: "#ffa500",
    orangered: "#ff4500",
    orchid: "#da70d6",
    palegoldenrod: "#eee8aa",
    palegreen: "#98fb98",
    paleturquoise: "#afeeee",
    palevioletred: "#d87093",
    papayawhip: "#ffefd5",
    peachpuff: "#ffdab9",
    peru: "#cd853f",
    pink: "#ffc0cb",
    plum: "#dda0dd",
    powderblue: "#b0e0e6",
    purple: "#800080",
    rebeccapurple: "#663399",
    red: "#ff0000",
    rosybrown: "#bc8f8f",
    royalblue: "#4169e1",
    saddlebrown: "#8b4513",
    salmon: "#fa8072",
    sandybrown: "#f4a460",
    seagreen: "#2e8b57",
    seashell: "#fff5ee",
    sienna: "#a0522d",
    silver: "#c0c0c0",
    skyblue: "#87ceeb",
    slateblue: "#6a5acd",
    slategray: "#708090",
    snow: "#fffafa",
    springgreen: "#00ff7f",
    steelblue: "#4682b4",
    tan: "#d2b48c",
    teal: "#008080",
    thistle: "#d8bfd8",
    tomato: "#ff6347",
    turquoise: "#40e0d0",
    violet: "#ee82ee",
    wheat: "#f5deb3",
    white: "#ffffff",
    whitesmoke: "#f5f5f5",
    yellow: "#ffff00",
    yellowgreen: "#9acd32"
  };

  var _getHexColor = function _getHexColor(color) {
    color = color
      .replace("color:", "")
      .replace(";", "")
      .replace(" ", "");

    if (/^#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})$/.test(color)) {
      return color;
    } else if (namedColors[color]) {
      return namedColors[color];
    } else if (color.indexOf("rgb") === 0) {
      var rgbArray = color.split(",");
      var convertedColor =
        rgbArray.length < 3
          ? null
          : "#" +
            [rgbArray[0], rgbArray[1], rgbArray[2]]
              .map(function(x) {
                var hex = parseInt(x.replace(/\D/g, ""), 10).toString(16);
                return hex.length === 1 ? "0" + hex : hex;
              })
              .join("");

      return /^#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})$/.test(convertedColor)
        ? convertedColor
        : null;
    } else {
      return null;
    }
  };

  var namedColors = (exports.namedColors = _namedColors);
  var getHexColor = (exports.getHexColor = _getHexColor);

  var detectColorsFromHTMLString = (exports.detectColorsFromHTMLString = function detectColorsFromHTMLString(
    html
  ) {
    return typeof html !== "string"
      ? []
      : (html.match(/color:[^;]{3,24};/g) || [])
          .map(getHexColor)
          .filter(function(color) {
            return color;
          });
  });

  var detectColorsFromDraftState = (exports.detectColorsFromDraftState = function detectColorsFromDraftState(
    draftState
  ) {
    var result = [];

    if (!draftState || !draftState.blocks || !draftState.blocks.length) {
      return result;
    }

    draftState.blocks.forEach(function(block) {
      if (block && block.inlineStyleRanges && block.inlineStyleRanges.length) {
        block.inlineStyleRanges.forEach(function(inlineStyle) {
          if (inlineStyle.style && inlineStyle.style.indexOf("COLOR-") >= 0) {
            result.push("#" + inlineStyle.style.split("COLOR-")[1]);
          }
        });
      }
    });

    return result.filter(function(color) {
      return color;
    });
  });
});

_commonjsHelpers.unwrapExports(color);
var color_1 = color.namedColors;
var color_2 = color.getHexColor;
var color_3 = color.detectColorsFromHTMLString;
var color_4 = color.detectColorsFromDraftState;

var dist$1 = _commonjsHelpers.createCommonjsModule(function(module, exports) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.ColorUtils = exports.BaseUtils = exports.ContentUtils = undefined;

  var _ContentUtils = _interopRequireWildcard(content);

  var _BaseUtils = _interopRequireWildcard(base);

  var _ColorUtils = _interopRequireWildcard(color);

  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;
    }
  }

  var ContentUtils = (exports.ContentUtils = _ContentUtils);
  var BaseUtils = (exports.BaseUtils = _BaseUtils);
  var ColorUtils = (exports.ColorUtils = _ColorUtils);
});

_commonjsHelpers.unwrapExports(dist$1);
var dist_1$1 = dist$1.ColorUtils;
var dist_2$1 = dist$1.BaseUtils;
var dist_3$1 = dist$1.ContentUtils;

var dist$2 = _commonjsHelpers.createCommonjsModule(function(module, exports) {
  (function webpackUniversalModuleDefinition(root, factory) {
    module.exports = factory(React__default);
  })(window, function(__WEBPACK_EXTERNAL_MODULE__2__) {
    return /******/ (function(modules) {
      // webpackBootstrap
      /******/ // The module cache
      /******/ var installedModules = {}; // The require function
      /******/
      /******/ /******/ function __webpack_require__(moduleId) {
        /******/
        /******/ // Check if module is in cache
        /******/ if (installedModules[moduleId]) {
          /******/ return installedModules[moduleId].exports;
          /******/
        } // Create a new module (and put it into the cache)
        /******/ /******/ var module = (installedModules[moduleId] = {
          /******/ i: moduleId,
          /******/ l: false,
          /******/ exports: {}
          /******/
        }); // Execute the module function
        /******/
        /******/ /******/ modules[moduleId].call(
          module.exports,
          module,
          module.exports,
          __webpack_require__
        ); // Flag the module as loaded
        /******/
        /******/ /******/ module.l = true; // Return the exports of the module
        /******/
        /******/ /******/ return module.exports;
        /******/
      } // expose the modules object (__webpack_modules__)
      /******/
      /******/
      /******/ /******/ __webpack_require__.m = modules; // expose the module cache
      /******/
      /******/ /******/ __webpack_require__.c = installedModules; // define getter function for harmony exports
      /******/
      /******/ /******/ __webpack_require__.d = function(
        exports,
        name,
        getter
      ) {
        /******/ if (!__webpack_require__.o(exports, name)) {
          /******/ Object.defineProperty(exports, name, {
            enumerable: true,
            get: getter
          });
          /******/
        }
        /******/
      }; // define __esModule on exports
      /******/
      /******/ /******/ __webpack_require__.r = function(exports) {
        /******/ if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
          /******/ Object.defineProperty(exports, Symbol.toStringTag, {
            value: "Module"
          });
          /******/
        }
        /******/ Object.defineProperty(exports, "__esModule", { value: true });
        /******/
      }; // create a fake namespace object // mode & 1: value is a module id, require it // mode & 2: merge all properties of value into the ns // mode & 4: return value when already ns object // mode & 8|1: behave like require
      /******/
      /******/ /******/ /******/ /******/ /******/ /******/ __webpack_require__.t = function(
        value,
        mode
      ) {
        /******/ if (mode & 1) value = __webpack_require__(value);
        /******/ if (mode & 8) return value;
        /******/ if (
          mode & 4 &&
          typeof value === "object" &&
          value &&
          value.__esModule
        )
          return value;
        /******/ var ns = Object.create(null);
        /******/ __webpack_require__.r(ns);
        /******/ Object.defineProperty(ns, "default", {
          enumerable: true,
          value: value
        });
        /******/ if (mode & 2 && typeof value != "string")
          for (var key in value)
            __webpack_require__.d(
              ns,
              key,
              function(key) {
                return value[key];
              }.bind(null, key)
            );
        /******/ return ns;
        /******/
      }; // getDefaultExport function for compatibility with non-harmony modules
      /******/
      /******/ /******/ __webpack_require__.n = function(module) {
        /******/ var getter =
          module && module.__esModule
            ? /******/ function getDefault() {
                return module["default"];
              }
            : /******/ function getModuleExports() {
                return module;
              };
        /******/ __webpack_require__.d(getter, "a", getter);
        /******/ return getter;
        /******/
      }; // Object.prototype.hasOwnProperty.call
      /******/
      /******/ /******/ __webpack_require__.o = function(object, property) {
        return Object.prototype.hasOwnProperty.call(object, property);
      }; // __webpack_public_path__
      /******/
      /******/ /******/ __webpack_require__.p = "/"; // Load entry module and return exports
      /******/
      /******/
      /******/ /******/ return __webpack_require__(
        (__webpack_require__.s = 20)
      );
      /******/
    })(
      /************************************************************************/
      /******/ [
        /* 0 */
        /***/ function(module, exports, __webpack_require__) {
          Object.defineProperty(exports, "__esModule", {
            value: true
          });
          var compressImage = (exports.compressImage = function compressImage(
            url
          ) {
            var width =
              arguments.length > 1 && arguments[1] !== undefined
                ? arguments[1]
                : 1280;
            var height =
              arguments.length > 2 && arguments[2] !== undefined
                ? arguments[2]
                : 800;

            return new Promise(function(resolve, reject) {
              var image = new Image();

              image.src = url;

              image.onerror = function(error) {
                reject(error);
              };

              image.onload = function() {
                try {
                  var compressCanvas = document.createElement("canvas");
                  var scale =
                    this.width > width || this.height > height
                      ? this.width > this.height
                        ? width / this.width
                        : height / this.height
                      : 1;

                  compressCanvas.width = this.width * scale;
                  compressCanvas.height = this.height * scale;

                  var canvasContext = compressCanvas.getContext("2d");
                  canvasContext.drawImage(
                    this,
                    0,
                    0,
                    compressCanvas.width,
                    compressCanvas.height
                  );

                  resolve({
                    url: compressCanvas.toDataURL("image/png", 1),
                    width: compressCanvas.width,
                    height: compressCanvas.height
                  });
                } catch (error) {
                  reject(error);
                }
              };
            });
          });

          /***/
        },
        /* 1 */
        /***/ function(module, exports, __webpack_require__) {
          Object.defineProperty(exports, "__esModule", {
            value: true
          });
          var UniqueIndex = (exports.UniqueIndex = function UniqueIndex() {
            if (isNaN(window.__BRAFT_MM_UNIQUE_INDEX__)) {
              window.__BRAFT_MM_UNIQUE_INDEX__ = 1;
            } else {
              window.__BRAFT_MM_UNIQUE_INDEX__ += 1;
            }

            return window.__BRAFT_MM_UNIQUE_INDEX__;
          });

          /***/
        },
        /* 2 */
        /***/ function(module, exports) {
          module.exports = __WEBPACK_EXTERNAL_MODULE__2__;

          /***/
        },
        /* 3 */
        /***/ function(module, exports, __webpack_require__) {
          Object.defineProperty(exports, "__esModule", {
            value: true
          });
          exports.default = {
            remove: "Kaldır",
            cancel: "İptal",
            confirm: "Onayla",
            insert: "Seçilenleri ekle",
            width: "Genişlik",
            height: "Yükseklik",
            image: "Resim",
            video: "Görüntü",
            audio: "Ses",
            embed: "Nesne göm",
            caption: "Kitaplık",
            dragTip: "Tıkla ya da dosya sürükle",
            dropTip: "Yüklemek için sürükleyin",
            selectAll: "Tümünü seç",
            deselect: "Seçimi kaldır",
            removeSelected: "Seçilenleri kaldır",
            externalInputPlaceHolder: "Kaynak adı|Kaynak bağlantısı",
            externalInputTip:
              'Kaynak asını ve bağlantısını "|" ile ayırın ve Enter\' a basın.',
            addLocalFile: "Yerel' den ekle",
            addExternalSource: "Harici kaynaktan ekle",
            unnamedItem: "Adlandırılmamış giriş",
            confirmInsert: "Seçilenleri ekle"
          };

          /***/
        },
        /* 4 */
        /***/ function(module, exports, __webpack_require__) {
          Object.defineProperty(exports, "__esModule", {
            value: true
          });
          exports.default = {
            remove: "削除する",
            cancel: "キャンセル",
            confirm: "確認する",
            insert: "選択したアイテムを挿入",
            width: "幅",
            height: "身長",
            image: "絵",
            video: "ビデオ",
            audio: "音声",
            embed: "埋め込みメディア",
            caption: "メディアライブラリー",
            dragTip: "ファイルをこの位置までクリックまたはドラッグします",
            dropTip: "アップロードするマウスを放します",
            selectAll: "すべて選択",
            deselect: "選択を解除",
            removeSelected: "選択したアイテムを削除",
            externalInputPlaceHolder: "リソース名|リソースアドレス",
            externalInputTip:
              'リソース名とリソースアドレスは "|"で区切ります。',
            addLocalFile: "ローカルリソースを追加する",
            addExternalSource: "ネットワークリソースを追加する",
            unnamedItem: "名前のないアイテム",
            confirmInsert: "選択したアイテムを挿入"
          };

          /***/
        },
        /* 5 */
        /***/ function(module, exports, __webpack_require__) {
          Object.defineProperty(exports, "__esModule", {
            value: true
          });
          exports.default = {
            remove: "삭제",
            cancel: "취소",
            confirm: "확인",
            insert: "선택한항목삽입",
            width: "너비",
            height: "높이",
            image: "그림",
            video: "비디오",
            audio: "오디오",
            embed: "임베디드미디어",
            caption: "미디어라이브러리",
            dragTip: "파일을 클릭하거나이 지점으로 드래그하십시오.",
            dropTip: "업로드하려면마우스를놓으십시오.",
            selectAll: "모두 선택",
            deselect: "선택 취소",
            removeSelected: "선택한 항목 삭제",
            externalInputPlaceHolder: "리소스 이름 | 리소스 주소",
            externalInputTip: '자원 이름과 자원 주소를 "|"',
            addLocalFile: "로컬 리소스 추가",
            addExternalSource: "네트워크 리소스 추가",
            unnamedItem: "이름없는 항목",
            confirmInsert: "선택한 항목 삽입"
          };

          /***/
        },
        /* 6 */
        /***/ function(module, exports, __webpack_require__) {
          Object.defineProperty(exports, "__esModule", {
            value: true
          });
          exports.default = {
            remove: "Usuń",
            cancel: "Anuluj",
            confirm: "Potwierdź",
            insert: "Wstaw wybrane elementy",
            width: "Szerokość",
            height: "Wysokość",
            image: "Obraz",
            video: "Wideo",
            audio: "Dźwięk",
            embed: "Obiekt",
            caption: "Biblioteka mediów",
            dragTip: "Kliknij lub przenieś tu pliki",
            dropTip: "Upuść aby dodać plik",
            selectAll: "Zaznacz wszystko",
            deselect: "Odznacz",
            removeSelected: "Usuń wybrane",
            externalInputPlaceHolder: "Nazwa źródła|Adres URL",
            externalInputTip:
              'Oddziel nazwę i adres URL źródła z pomocą "|", Potwierdź Enter-em',
            addLocalFile: "Dodaj z komputera",
            addExternalSource: "Dodaj z Internetu",
            unnamedItem: "Bez nazwy",
            confirmInsert: "Dodaj wybrane elementy"
          };

          /***/
        },
        /* 7 */
        /***/ function(module, exports, __webpack_require__) {
          Object.defineProperty(exports, "__esModule", {
            value: true
          });
          exports.default = {
            remove: "删除",
            cancel: "取消",
            confirm: "确认",
            insert: "插入所选项目",
            width: "宽度",
            height: "高度",
            image: "图片",
            video: "视频",
            audio: "音频",
            embed: "嵌入式媒体",
            caption: "媒体库",
            dragTip: "点击或拖动文件至此",
            dropTip: "放开鼠标以上传",
            selectAll: "选择全部",
            deselect: "取消选择",
            removeSelected: "删除选中项目",
            externalInputPlaceHolder: "资源名称|资源地址",
            externalInputTip: "使用“|”分隔资源名称和资源地址",
            addLocalFile: "添加本地资源",
            addExternalSource: "添加网络资源",
            unnamedItem: "未命名项目",
            confirmInsert: "插入选中项目"
          };

          /***/
        },
        /* 8 */
        /***/ function(module, exports, __webpack_require__) {
          Object.defineProperty(exports, "__esModule", {
            value: true
          });
          exports.default = {
            remove: "删除",
            cancel: "取消",
            confirm: "确认",
            insert: "插入所选项目",
            width: "宽度",
            height: "高度",
            image: "图片",
            video: "视频",
            audio: "音频",
            embed: "嵌入式媒体",
            caption: "媒体库",
            dragTip: "点击或拖动文件至此",
            dropTip: "放开鼠标以上传",
            selectAll: "选择全部",
            deselect: "取消选择",
            removeSelected: "删除选中项目",
            externalInputPlaceHolder: "资源名称|资源地址",
            externalInputTip: "使用“|”分隔资源名称和资源地址",
            addLocalFile: "添加本地资源",
            addExternalSource: "添加网络资源",
            unnamedItem: "未命名项目",
            confirmInsert: "插入选中项目"
          };

          /***/
        },
        /* 9 */
        /***/ function(module, exports, __webpack_require__) {
          Object.defineProperty(exports, "__esModule", {
            value: true
          });
          exports.default = {
            remove: "Remove",
            cancel: "Cancel",
            confirm: "Confirm",
            insert: "Insert Selected Items",
            width: "Width",
            height: "Height",
            image: "Image",
            video: "Video",
            audio: "Audio",
            embed: "Embed",
            caption: "Media Library",
            dragTip: "Click Or Drag Files Here",
            dropTip: "Drop To Upload",
            selectAll: "Select All",
            deselect: "Deselect",
            removeSelected: "Remove Selected Items",
            externalInputPlaceHolder: "Source Name|Source URL",
            externalInputTip:
              'Split source name and source URL with "|", confirm by hit Enter.',
            addLocalFile: "Add from local",
            addExternalSource: "Add from Internet",
            unnamedItem: "Unnamed Item",
            confirmInsert: "Insert selected items"
          };

          /***/
        },
        /* 10 */
        /***/ function(module, exports, __webpack_require__) {
          Object.defineProperty(exports, "__esModule", {
            value: true
          });

          var _en = __webpack_require__(9);

          var _en2 = _interopRequireDefault(_en);

          var _zh = __webpack_require__(8);

          var _zh2 = _interopRequireDefault(_zh);

          var _zhHant = __webpack_require__(7);

          var _zhHant2 = _interopRequireDefault(_zhHant);

          var _pl = __webpack_require__(6);

          var _pl2 = _interopRequireDefault(_pl);

          var _kr = __webpack_require__(5);

          var _kr2 = _interopRequireDefault(_kr);

          var _jpn = __webpack_require__(4);

          var _jpn2 = _interopRequireDefault(_jpn);

          var _tr = __webpack_require__(3);

          var _tr2 = _interopRequireDefault(_tr);

          function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : { default: obj };
          }

          exports.default = {
            en: _en2.default,
            zh: _zh2.default,
            "zh-hant": _zhHant2.default,
            pl: _pl2.default,
            kr: _kr2.default,
            jpn: _jpn2.default,
            tr: _tr2.default
          };

          /***/
        },
        /* 11 */
        /***/ function(module, exports) {
          /**
           * When source maps are enabled, `style-loader` uses a link element with a data-uri to
           * embed the css on the page. This breaks all relative urls because now they are relative to a
           * bundle instead of the current page.
           *
           * One solution is to only use full urls, but that may be impossible.
           *
           * Instead, this function "fixes" the relative urls to be absolute according to the current page location.
           *
           * A rudimentary test suite is located at `test/fixUrls.js` and can be run via the `npm test` command.
           *
           */

          module.exports = function(css) {
            // get current location
            var location = typeof window !== "undefined" && window.location;

            if (!location) {
              throw new Error("fixUrls requires window.location");
            }

            // blank or null?
            if (!css || typeof css !== "string") {
              return css;
            }

            var baseUrl = location.protocol + "//" + location.host;
            var currentDir =
              baseUrl + location.pathname.replace(/\/[^\/]*$/, "/");

            // convert each url(...)
            /*
	This regular expression is just a way to recursively match brackets within
	a string.

	 /url\s*\(  = Match on the word "url" with any whitespace after it and then a parens
	   (  = Start a capturing group
	     (?:  = Start a non-capturing group
	         [^)(]  = Match anything that isn't a parentheses
	         |  = OR
	         \(  = Match a start parentheses
	             (?:  = Start another non-capturing groups
	                 [^)(]+  = Match anything that isn't a parentheses
	                 |  = OR
	                 \(  = Match a start parentheses
	                     [^)(]*  = Match anything that isn't a parentheses
	                 \)  = Match a end parentheses
	             )  = End Group
              *\) = Match anything and then a close parens
          )  = Close non-capturing group
          *  = Match anything
       )  = Close capturing group
	 \)  = Match a close parens

	 /gi  = Get all matches, not the first.  Be case insensitive.
	 */
            var fixedCss = css.replace(
              /url\s*\(((?:[^)(]|\((?:[^)(]+|\([^)(]*\))*\))*)\)/gi,
              function(fullMatch, origUrl) {
                // strip quotes (if they exist)
                var unquotedOrigUrl = origUrl
                  .trim()
                  .replace(/^"(.*)"$/, function(o, $1) {
                    return $1;
                  })
                  .replace(/^'(.*)'$/, function(o, $1) {
                    return $1;
                  });

                // already a full url? no change
                if (
                  /^(#|data:|http:\/\/|https:\/\/|file:\/\/\/|\s*$)/i.test(
                    unquotedOrigUrl
                  )
                ) {
                  return fullMatch;
                }

                // convert the url to a full url
                var newUrl;

                if (unquotedOrigUrl.indexOf("//") === 0) {
                  //TODO: should we add protocol?
                  newUrl = unquotedOrigUrl;
                } else if (unquotedOrigUrl.indexOf("/") === 0) {
                  // path should be relative to the base url
                  newUrl = baseUrl + unquotedOrigUrl; // already starts with '/'
                } else {
                  // path should be relative to current directory
                  newUrl = currentDir + unquotedOrigUrl.replace(/^\.\//, ""); // Strip leading './'
                }

                // send back the fixed url(...)
                return "url(" + JSON.stringify(newUrl) + ")";
              }
            );

            // send back the fixed css
            return fixedCss;
          };

          /***/
        },
        /* 12 */
        /***/ function(module, exports, __webpack_require__) {
          /*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/

          var stylesInDom = {};

          var memoize = function(fn) {
            var memo;

            return function() {
              if (typeof memo === "undefined") memo = fn.apply(this, arguments);
              return memo;
            };
          };

          var isOldIE = memoize(function() {
            // Test for IE <= 9 as proposed by Browserhacks
            // @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805
            // Tests for existence of standard globals is to allow style-loader
            // to operate correctly into non-standard environments
            // @see https://github.com/webpack-contrib/style-loader/issues/177
            return window && document && document.all && !window.atob;
          });

          var getTarget = function(target) {
            return document.querySelector(target);
          };

          var getElement = (function(fn) {
            var memo = {};

            return function(target) {
              // If passing function in options, then use it for resolve "head" element.
              // Useful for Shadow Root style i.e
              // {
              //   insertInto: function () { return document.querySelector("#foo").shadowRoot }
              // }
              if (typeof target === "function") {
                return target();
              }
              if (typeof memo[target] === "undefined") {
                var styleTarget = getTarget.call(this, target);
                // Special case to return head of iframe instead of iframe itself
                if (
                  window.HTMLIFrameElement &&
                  styleTarget instanceof window.HTMLIFrameElement
                ) {
                  try {
                    // This will throw an exception if access to iframe is blocked
                    // due to cross-origin restrictions
                    styleTarget = styleTarget.contentDocument.head;
                  } catch (e) {
                    styleTarget = null;
                  }
                }
                memo[target] = styleTarget;
              }
              return memo[target];
            };
          })();

          var singleton = null;
          var singletonCounter = 0;
          var stylesInsertedAtTop = [];

          var fixUrls = __webpack_require__(11);

          module.exports = function(list, options) {
            if (typeof DEBUG !== "undefined" && DEBUG) {
              if (typeof document !== "object")
                throw new Error(
                  "The style-loader cannot be used in a non-browser environment"
                );
            }

            options = options || {};

            options.attrs =
              typeof options.attrs === "object" ? options.attrs : {};

            // Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
            // tags it will allow on a page
            if (!options.singleton && typeof options.singleton !== "boolean")
              options.singleton = isOldIE();

            // By default, add <style> tags to the <head> element
            if (!options.insertInto) options.insertInto = "head";

            // By default, add <style> tags to the bottom of the target
            if (!options.insertAt) options.insertAt = "bottom";

            var styles = listToStyles(list, options);

            addStylesToDom(styles, options);

            return function update(newList) {
              var mayRemove = [];

              for (var i = 0; i < styles.length; i++) {
                var item = styles[i];
                var domStyle = stylesInDom[item.id];

                domStyle.refs--;
                mayRemove.push(domStyle);
              }

              if (newList) {
                var newStyles = listToStyles(newList, options);
                addStylesToDom(newStyles, options);
              }

              for (var i = 0; i < mayRemove.length; i++) {
                var domStyle = mayRemove[i];

                if (domStyle.refs === 0) {
                  for (var j = 0; j < domStyle.parts.length; j++)
                    domStyle.parts[j]();

                  delete stylesInDom[domStyle.id];
                }
              }
            };
          };

          function addStylesToDom(styles, options) {
            for (var i = 0; i < styles.length; i++) {
              var item = styles[i];
              var domStyle = stylesInDom[item.id];

              if (domStyle) {
                domStyle.refs++;

                for (var j = 0; j < domStyle.parts.length; j++) {
                  domStyle.parts[j](item.parts[j]);
                }

                for (; j < item.parts.length; j++) {
                  domStyle.parts.push(addStyle(item.parts[j], options));
                }
              } else {
                var parts = [];

                for (var j = 0; j < item.parts.length; j++) {
                  parts.push(addStyle(item.parts[j], options));
                }

                stylesInDom[item.id] = { id: item.id, refs: 1, parts: parts };
              }
            }
          }

          function listToStyles(list, options) {
            var styles = [];
            var newStyles = {};

            for (var i = 0; i < list.length; i++) {
              var item = list[i];
              var id = options.base ? item[0] + options.base : item[0];
              var css = item[1];
              var media = item[2];
              var sourceMap = item[3];
              var part = { css: css, media: media, sourceMap: sourceMap };

              if (!newStyles[id])
                styles.push((newStyles[id] = { id: id, parts: [part] }));
              else newStyles[id].parts.push(part);
            }

            return styles;
          }

          function insertStyleElement(options, style) {
            var target = getElement(options.insertInto);

            if (!target) {
              throw new Error(
                "Couldn't find a style target. This probably means that the value for the 'insertInto' parameter is invalid."
              );
            }

            var lastStyleElementInsertedAtTop =
              stylesInsertedAtTop[stylesInsertedAtTop.length - 1];

            if (options.insertAt === "top") {
              if (!lastStyleElementInsertedAtTop) {
                target.insertBefore(style, target.firstChild);
              } else if (lastStyleElementInsertedAtTop.nextSibling) {
                target.insertBefore(
                  style,
                  lastStyleElementInsertedAtTop.nextSibling
                );
              } else {
                target.appendChild(style);
              }
              stylesInsertedAtTop.push(style);
            } else if (options.insertAt === "bottom") {
              target.appendChild(style);
            } else if (
              typeof options.insertAt === "object" &&
              options.insertAt.before
            ) {
              var nextSibling = getElement(
                options.insertInto + " " + options.insertAt.before
              );
              target.insertBefore(style, nextSibling);
            } else {
              throw new Error(
                "[Style Loader]\n\n Invalid value for parameter 'insertAt' ('options.insertAt') found.\n Must be 'top', 'bottom', or Object.\n (https://github.com/webpack-contrib/style-loader#insertat)\n"
              );
            }
          }

          function removeStyleElement(style) {
            if (style.parentNode === null) return false;
            style.parentNode.removeChild(style);

            var idx = stylesInsertedAtTop.indexOf(style);
            if (idx >= 0) {
              stylesInsertedAtTop.splice(idx, 1);
            }
          }

          function createStyleElement(options) {
            var style = document.createElement("style");

            if (options.attrs.type === undefined) {
              options.attrs.type = "text/css";
            }

            addAttrs(style, options.attrs);
            insertStyleElement(options, style);

            return style;
          }

          function createLinkElement(options) {
            var link = document.createElement("link");

            if (options.attrs.type === undefined) {
              options.attrs.type = "text/css";
            }
            options.attrs.rel = "stylesheet";

            addAttrs(link, options.attrs);
            insertStyleElement(options, link);

            return link;
          }

          function addAttrs(el, attrs) {
            Object.keys(attrs).forEach(function(key) {
              el.setAttribute(key, attrs[key]);
            });
          }

          function addStyle(obj, options) {
            var style, update, remove, result;

            // If a transform function was defined, run it on the css
            if (options.transform && obj.css) {
              result = options.transform(obj.css);

              if (result) {
                // If transform returns a value, use that instead of the original css.
                // This allows running runtime transformations on the css.
                obj.css = result;
              } else {
                // If the transform function returns a falsy value, don't add this css.
                // This allows conditional loading of css
                return function() {
                  // noop
                };
              }
            }

            if (options.singleton) {
              var styleIndex = singletonCounter++;

              style = singleton || (singleton = createStyleElement(options));

              update = applyToSingletonTag.bind(null, style, styleIndex, false);
              remove = applyToSingletonTag.bind(null, style, styleIndex, true);
            } else if (
              obj.sourceMap &&
              typeof URL === "function" &&
              typeof URL.createObjectURL === "function" &&
              typeof URL.revokeObjectURL === "function" &&
              typeof Blob === "function" &&
              typeof btoa === "function"
            ) {
              style = createLinkElement(options);
              update = updateLink.bind(null, style, options);
              remove = function() {
                removeStyleElement(style);

                if (style.href) URL.revokeObjectURL(style.href);
              };
            } else {
              style = createStyleElement(options);
              update = applyToTag.bind(null, style);
              remove = function() {
                removeStyleElement(style);
              };
            }

            update(obj);

            return function updateStyle(newObj) {
              if (newObj) {
                if (
                  newObj.css === obj.css &&
                  newObj.media === obj.media &&
                  newObj.sourceMap === obj.sourceMap
                ) {
                  return;
                }

                update((obj = newObj));
              } else {
                remove();
              }
            };
          }

          var replaceText = (function() {
            var textStore = [];

            return function(index, replacement) {
              textStore[index] = replacement;

              return textStore.filter(Boolean).join("\n");
            };
          })();

          function applyToSingletonTag(style, index, remove, obj) {
            var css = remove ? "" : obj.css;

            if (style.styleSheet) {
              style.styleSheet.cssText = replaceText(index, css);
            } else {
              var cssNode = document.createTextNode(css);
              var childNodes = style.childNodes;

              if (childNodes[index]) style.removeChild(childNodes[index]);

              if (childNodes.length) {
                style.insertBefore(cssNode, childNodes[index]);
              } else {
                style.appendChild(cssNode);
              }
            }
          }

          function applyToTag(style, obj) {
            var css = obj.css;
            var media = obj.media;

            if (media) {
              style.setAttribute("media", media);
            }

            if (style.styleSheet) {
              style.styleSheet.cssText = css;
            } else {
              while (style.firstChild) {
                style.removeChild(style.firstChild);
              }

              style.appendChild(document.createTextNode(css));
            }
          }

          function updateLink(link, options, obj) {
            var css = obj.css;
            var sourceMap = obj.sourceMap;

            /*
		If convertToAbsoluteUrls isn't defined, but sourcemaps are enabled
		and there is no publicPath defined then lets turn convertToAbsoluteUrls
		on by default.  Otherwise default to the convertToAbsoluteUrls option
		directly
	*/
            var autoFixUrls =
              options.convertToAbsoluteUrls === undefined && sourceMap;

            if (options.convertToAbsoluteUrls || autoFixUrls) {
              css = fixUrls(css);
            }

            if (sourceMap) {
              // http://stackoverflow.com/a/26603875
              css +=
                "\n/*# sourceMappingURL=data:application/json;base64," +
                btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) +
                " */";
            }

            var blob = new Blob([css], { type: "text/css" });

            var oldSrc = link.href;

            link.href = URL.createObjectURL(blob);

            if (oldSrc) URL.revokeObjectURL(oldSrc);
          }

          /***/
        },
        /* 13 */
        /***/ function(module, exports) {
          module.exports =
            "data:font/ttf;base64,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";

          /***/
        },
        /* 14 */
        /***/ function(module, exports) {
          /*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/
          // css base code, injected by the css-loader
          module.exports = function(useSourceMap) {
            var list = [];

            // return the list of modules as css string
            list.toString = function toString() {
              return this.map(function(item) {
                var content = cssWithMappingToString(item, useSourceMap);
                if (item[2]) {
                  return "@media " + item[2] + "{" + content + "}";
                } else {
                  return content;
                }
              }).join("");
            };

            // import a list of modules into the list
            list.i = function(modules, mediaQuery) {
              if (typeof modules === "string") modules = [[null, modules, ""]];
              var alreadyImportedModules = {};
              for (var i = 0; i < this.length; i++) {
                var id = this[i][0];
                if (typeof id === "number") alreadyImportedModules[id] = true;
              }
              for (i = 0; i < modules.length; i++) {
                var item = modules[i];
                // skip already imported module
                // this implementation is not 100% perfect for weird media query combinations
                //  when a module is imported multiple times with different media queries.
                //  I hope this will never occur (Hey this way we have smaller bundles)
                if (
                  typeof item[0] !== "number" ||
                  !alreadyImportedModules[item[0]]
                ) {
                  if (mediaQuery && !item[2]) {
                    item[2] = mediaQuery;
                  } else if (mediaQuery) {
                    item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
                  }
                  list.push(item);
                }
              }
            };
            return list;
          };

          function cssWithMappingToString(item, useSourceMap) {
            var content = item[1] || "";
            var cssMapping = item[3];
            if (!cssMapping) {
              return content;
            }

            if (useSourceMap && typeof btoa === "function") {
              var sourceMapping = toComment(cssMapping);
              var sourceURLs = cssMapping.sources.map(function(source) {
                return (
                  "/*# sourceURL=" + cssMapping.sourceRoot + source + " */"
                );
              });

              return [content]
                .concat(sourceURLs)
                .concat([sourceMapping])
                .join("\n");
            }

            return [content].join("\n");
          }

          // Adapted from convert-source-map (MIT)
          function toComment(sourceMap) {
            // eslint-disable-next-line no-undef
            var base64 = btoa(
              unescape(encodeURIComponent(JSON.stringify(sourceMap)))
            );
            var data =
              "sourceMappingURL=data:application/json;charset=utf-8;base64," +
              base64;

            return "/*# " + data + " */";
          }

          /***/
        },
        /* 15 */
        /***/ function(module, exports) {
          module.exports = function escape(url) {
            if (typeof url !== "string") {
              return url;
            }
            // If url is already wrapped in quotes, remove them
            if (/^['"].*['"]$/.test(url)) {
              url = url.slice(1, -1);
            }
            // Should url be wrapped?
            // See https://drafts.csswg.org/css-values-3/#urls
            if (/["'() \t\n]/.test(url)) {
              return '"' + url.replace(/"/g, '\\"').replace(/\n/g, "\\n") + '"';
            }

            return url;
          };

          /***/
        },
        /* 16 */
        /***/ function(module, exports, __webpack_require__) {
          var escape = __webpack_require__(15);
          exports = module.exports = __webpack_require__(14)(false);
          // imports

          // module
          exports.push([
            module.i,
            "@font-face {\n  font-family: 'bf-icons';\n  src: url(" +
              escape(__webpack_require__(13)) +
              ') format("truetype");\n  font-weight: normal;\n  font-style: normal; }\n\n.braft-finder [class^="braft-icon-"], .braft-finder [class*=" braft-icon-"] {\n  /* use !important to prevent issues with browser extensions that change fonts */\n  font-family: \'bf-icons\' !important;\n  font-style: normal;\n  font-weight: normal;\n  font-variant: normal;\n  text-transform: none;\n  /* Better Font Rendering =========== */\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale; }\n\n.braft-finder .braft-icon-code:before {\n  content: "\\E903"; }\n\n.braft-finder .braft-icon-pause:before {\n  content: "\\E034"; }\n\n.braft-finder .braft-icon-play_arrow:before {\n  content: "\\E037"; }\n\n.braft-finder .braft-icon-bin:before {\n  content: "\\E9AC"; }\n\n.braft-finder .braft-icon-replay:before {\n  content: "\\E042"; }\n\n.braft-finder .braft-icon-close:before {\n  content: "\\E913"; }\n\n.braft-finder .braft-icon-music:before {\n  content: "\\E90E"; }\n\n.braft-finder .braft-icon-camera:before {\n  content: "\\E911"; }\n\n.braft-finder .braft-icon-file-text:before {\n  content: "\\E926"; }\n\n.braft-finder .braft-icon-film:before {\n  content: "\\E91C"; }\n\n.braft-finder .braft-icon-paste:before {\n  content: "\\E92D"; }\n\n.braft-finder .braft-icon-spinner:before {\n  content: "\\E980"; }\n\n.braft-finder .braft-icon-media:before {\n  content: "\\E90F"; }\n\n.braft-finder .braft-icon-add:before {\n  content: "\\E918"; }\n\n.braft-finder .braft-icon-done:before {\n  content: "\\E912"; }\n\n.braft-finder .braft-icon-drop-down:before {\n  content: "\\E906"; }\n\n.braft-finder .braft-icon-drop-up:before {\n  content: "\\E909"; }\n\n.braft-finder .braft-icon-help:before {\n  content: "\\E902"; }\n\n.braft-finder .braft-icon-info:before {\n  content: "\\E901"; }\n\n.braft-finder .braft-icon-menu:before {\n  content: "\\E908"; }\n\n.pull-left {\n  float: left; }\n\n.pull-right {\n  float: right; }\n\n.braft-finder .bf-uploader {\n  position: relative;\n  height: 370px;\n  margin: 0; }\n  .braft-finder .bf-uploader.draging .bf-list-wrap,\n  .braft-finder .bf-uploader.draging .bf-add-external {\n    pointer-events: none; }\n  .braft-finder .bf-uploader input::-webkit-input-placeholder {\n    color: #ccc; }\n  .braft-finder .bf-uploader input::-moz-placeholder {\n    color: #ccc; }\n  .braft-finder .bf-uploader input::-ms-input-placeholder {\n    color: #ccc; }\n\n.braft-finder .bf-list-wrap {\n  position: relative;\n  height: 370px; }\n\n.braft-finder .bf-list-tools {\n  z-index: 1;\n  position: absolute;\n  top: 0;\n  right: 0;\n  left: 0;\n  height: 20px;\n  padding: 0 15px;\n  background-color: #fff; }\n  .braft-finder .bf-list-tools span {\n    height: 26px;\n    font-size: 12px;\n    line-height: 20px;\n    cursor: pointer;\n    user-select: none; }\n    .braft-finder .bf-list-tools span[disabled] {\n      opacity: .3;\n      pointer-events: none; }\n  .braft-finder .bf-list-tools .bf-select-all,\n  .braft-finder .bf-list-tools .bf-deselect-all {\n    float: left;\n    margin-right: 5px;\n    color: #bbb; }\n    .braft-finder .bf-list-tools .bf-select-all:hover,\n    .braft-finder .bf-list-tools .bf-deselect-all:hover {\n      color: #3498db; }\n  .braft-finder .bf-list-tools .bf-remove-selected {\n    float: right;\n    color: #e74c3c; }\n    .braft-finder .bf-list-tools .bf-remove-selected:hover {\n      color: #c92e1e; }\n\n.braft-finder .bf-list {\n  position: absolute;\n  z-index: 1;\n  top: 30px;\n  right: 0;\n  left: 0;\n  bottom: 0;\n  margin: 0;\n  padding: 0 10px;\n  list-style: none;\n  overflow: auto; }\n  .braft-finder .bf-list::-webkit-scrollbar {\n    width: 5px;\n    height: 5px;\n    background-color: #fff; }\n  .braft-finder .bf-list::-webkit-scrollbar-track {\n    background-color: #fff; }\n  .braft-finder .bf-list::-webkit-scrollbar-thumb {\n    background-color: rgba(0, 0, 0, 0.1); }\n\n.braft-finder .bf-item,\n.braft-finder .bf-add-item {\n  position: relative;\n  display: block;\n  float: left;\n  width: 113px;\n  height: 113px;\n  margin: 5px;\n  overflow: hidden;\n  border-radius: 3px; }\n\n.braft-finder .bf-item.uploading {\n  pointer-events: none; }\n\n.braft-finder .bf-item.error::before {\n  display: block;\n  content: "\\E901"; }\n\n.braft-finder .bf-item.error::after {\n  position: absolute;\n  z-index: 1;\n  top: 0;\n  right: 0;\n  bottom: 0;\n  left: 0;\n  background-color: rgba(231, 76, 60, 0.8);\n  content: \'\'; }\n\n.braft-finder .bf-item.error:hover::after {\n  background-color: rgba(231, 76, 60, 0.9); }\n\n.braft-finder .bf-item.error .bf-item-uploading {\n  display: none; }\n\n.braft-finder .bf-add-item {\n  background-color: #ecedef;\n  color: #999; }\n  .braft-finder .bf-add-item:hover {\n    background-color: #e1e2e3; }\n  .braft-finder .bf-add-item i {\n    display: block;\n    width: 113px;\n    height: 113px;\n    font-size: 48px;\n    line-height: 113px;\n    text-align: center; }\n  .braft-finder .bf-add-item input {\n    position: absolute;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    opacity: 0;\n    cursor: pointer; }\n\n.braft-finder .bf-item::before {\n  display: none;\n  position: absolute;\n  z-index: 2;\n  top: 0;\n  left: 0;\n  width: 113px;\n  height: 113px;\n  color: #fff;\n  font-size: 48px;\n  font-family: \'bf-icons\';\n  line-height: 113px;\n  text-align: center; }\n\n.braft-finder .bf-item::after {\n  position: absolute;\n  z-index: 1;\n  top: 0;\n  right: 0;\n  bottom: 0;\n  left: 0;\n  background-color: rgba(52, 152, 219, 0);\n  content: \'\'; }\n\n.braft-finder .bf-item:hover::after {\n  background-color: rgba(52, 152, 219, 0.3); }\n\n.braft-finder .bf-item:hover .bf-item-remove {\n  display: block; }\n\n.braft-finder .bf-item.active::before {\n  display: block;\n  content: "\\E912"; }\n\n.braft-finder .bf-item.active::after {\n  background-color: rgba(52, 152, 219, 0.6); }\n\n.braft-finder .bf-item.active:hover::after {\n  background-color: rgba(52, 152, 219, 0.8); }\n\n.braft-finder .bf-item.active:hover .bf-item-remove {\n  display: none; }\n\n.braft-finder .bf-item-uploading {\n  box-sizing: border-box;\n  position: absolute;\n  z-index: 3;\n  top: 52px;\n  left: 10px;\n  width: 93px;\n  height: 10px;\n  overflow: hidden;\n  background-color: rgba(255, 255, 255, 0.3);\n  border-radius: 5px;\n  box-shadow: 0 0 0 100px rgba(0, 0, 0, 0.5); }\n\n.braft-finder .bf-item-uploading-bar {\n  height: 10px;\n  background-color: #3498db;\n  border-radius: 0; }\n\n.braft-finder .bf-item-remove {\n  display: none;\n  position: absolute;\n  z-index: 2;\n  top: 0;\n  right: 0;\n  width: 28px;\n  height: 28px;\n  color: #fff;\n  font-size: 18px;\n  line-height: 28px;\n  text-align: center;\n  cursor: pointer; }\n  .braft-finder .bf-item-remove:hover {\n    color: #e74c3c; }\n\n.braft-finder .bf-item-title {\n  display: none;\n  box-sizing: border-box;\n  position: absolute;\n  z-index: 2;\n  bottom: 0;\n  left: 0;\n  width: 100%;\n  height: 40px;\n  padding: 0 5px;\n  overflow: hidden;\n  background-image: linear-gradient(rgba(0, 0, 0, 0), black);\n  color: #fff;\n  font-size: 12px;\n  line-height: 55px;\n  text-align: center;\n  text-overflow: ellipsis;\n  white-space: nowrap; }\n\n.braft-finder .bf-image {\n  width: 100%;\n  height: 100%;\n  background-color: #eee;\n  user-select: none; }\n  .braft-finder .bf-image img {\n    display: block;\n    width: 100%;\n    height: 100%;\n    object-fit: cover; }\n\n.braft-finder .bf-video {\n  background-color: #8e44ad; }\n\n.braft-finder .bf-audio {\n  background-color: #f39c12; }\n\n.braft-finder .bf-embed {\n  background-color: #f1c40f; }\n\n.braft-finder .bf-icon {\n  display: block;\n  width: 113px;\n  height: 113px;\n  overflow: hidden;\n  color: #fff;\n  text-align: center;\n  text-decoration: none; }\n  .braft-finder .bf-icon i, .braft-finder .bf-icon span {\n    display: block; }\n  .braft-finder .bf-icon i {\n    margin-top: 35px;\n    font-size: 24px; }\n  .braft-finder .bf-icon span {\n    width: 103px;\n    margin: 10px auto;\n    overflow: hidden;\n    font-size: 12px;\n    text-overflow: ellipsis;\n    white-space: nowrap; }\n\n.braft-finder .bf-drag-uploader {\n  box-sizing: border-box;\n  position: absolute;\n  z-index: 2;\n  top: 0;\n  right: 15px;\n  left: 15px;\n  height: 100%;\n  background-color: #fff;\n  border: dashed 1px #bbb;\n  text-align: center;\n  opacity: 0;\n  pointer-events: none; }\n  .braft-finder .bf-drag-uploader:hover, .braft-finder .bf-drag-uploader.draging {\n    background-color: #f1f2f3; }\n  .braft-finder .bf-drag-uploader.active {\n    opacity: 1;\n    pointer-events: auto; }\n\n.braft-finder .bf-uploader-buttons {\n  height: 370px;\n  margin: auto;\n  text-align: center; }\n\n.braft-finder .bf-drag-tip {\n  display: inline-block;\n  margin-top: 150px;\n  color: #ccc;\n  text-align: center;\n  font-size: 28px;\n  font-weight: normal;\n  line-height: 40px; }\n  .braft-finder .bf-drag-tip input {\n    position: absolute;\n    top: 0;\n    right: 0;\n    bottom: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    opacity: 0;\n    color: #fff;\n    text-indent: -100px;\n    cursor: pointer; }\n\n.braft-finder .bf-manager-footer {\n  height: 36px;\n  margin: 10px 0;\n  padding: 0 15px; }\n  .braft-finder .bf-manager-footer .button {\n    float: right;\n    height: 36px;\n    margin-left: 5px;\n    padding: 0 35px;\n    font-size: 12px;\n    font-weight: 700;\n    border: none;\n    border-radius: 3px;\n    cursor: pointer; }\n  .braft-finder .bf-manager-footer .button-insert {\n    color: #fff;\n    background-color: #3498db; }\n    .braft-finder .bf-manager-footer .button-insert:hover {\n      background-color: #2084c7; }\n    .braft-finder .bf-manager-footer .button-insert[disabled] {\n      opacity: .3;\n      pointer-events: none;\n      filter: grayscale(0.4); }\n  .braft-finder .bf-manager-footer .button-cancel {\n    color: #999;\n    background-color: #e8e8e9; }\n    .braft-finder .bf-manager-footer .button-cancel:hover {\n      background-color: #d8d8d9; }\n\n.braft-finder .bf-toggle-external-form {\n  color: #666;\n  font-size: 12px;\n  line-height: 36px; }\n  .braft-finder .bf-toggle-external-form span {\n    color: #bbb;\n    line-height: 16px;\n    cursor: pointer;\n    user-select: none; }\n    .braft-finder .bf-toggle-external-form span:hover {\n      color: #3498db; }\n    .braft-finder .bf-toggle-external-form span i {\n      position: relative;\n      top: 2px;\n      font-size: 16px; }\n\n.braft-finder .bf-add-external {\n  position: absolute;\n  z-index: 3;\n  top: 0;\n  right: 0;\n  bottom: 0;\n  left: 0;\n  background-color: #fff; }\n  .braft-finder .bf-add-external input {\n    border: solid 1px rgba(0, 0, 0, 0.3);\n    border: solid 0.5px rgba(0, 0, 0, 0.3);\n    box-shadow: none; }\n    .braft-finder .bf-add-external input:focus {\n      border-color: #3498db;\n      box-shadow: none; }\n\n.braft-finder .bf-external-form {\n  width: 500px;\n  max-width: 90%;\n  margin: 91px auto 0 auto; }\n\n.braft-finder .bf-external-input {\n  position: relative;\n  width: 100%;\n  height: 40px;\n  margin-bottom: 10px; }\n  .braft-finder .bf-external-input div {\n    position: absolute;\n    top: 0;\n    right: 85px;\n    left: 0;\n    height: 40px; }\n  .braft-finder .bf-external-input input,\n  .braft-finder .bf-external-input textarea {\n    display: block;\n    box-sizing: border-box;\n    width: 100%;\n    height: 40px;\n    padding: 0 10px;\n    border: none;\n    border-radius: 3px;\n    outline: none;\n    box-shadow: inset 0 0 0 1px rgba(0, 0, 0, 0.3);\n    color: #999;\n    font-size: 18px; }\n    .braft-finder .bf-external-input input:focus,\n    .braft-finder .bf-external-input textarea:focus {\n      box-shadow: inset 0 0 0 1px #3498db; }\n  .braft-finder .bf-external-input textarea {\n    height: 100px;\n    font-size: 14px; }\n  .braft-finder .bf-external-input button {\n    position: absolute;\n    top: 0;\n    right: 0;\n    width: 80px;\n    height: 40px;\n    background-color: #3498db;\n    border: none;\n    border-radius: 3px;\n    color: #fff;\n    font-size: 14px;\n    font-weight: bold;\n    cursor: pointer; }\n    .braft-finder .bf-external-input button:disabled {\n      opacity: .3;\n      pointer-events: none;\n      filter: grayscale(0.4); }\n    .braft-finder .bf-external-input button:hover {\n      background-color: #2084c7; }\n\n.braft-finder .bf-switch-external-type {\n  overflow: hidden;\n  text-align: center; }\n  .braft-finder .bf-switch-external-type button {\n    width: auto;\n    height: 30px;\n    margin: 10px 5px;\n    padding: 0 10px;\n    background-color: #e8e9ea;\n    border: none;\n    border-radius: 3px;\n    color: #999;\n    font-size: 12px;\n    cursor: pointer; }\n    .braft-finder .bf-switch-external-type button:hover {\n      background-color: #d8d9da; }\n    .braft-finder .bf-switch-external-type button:only-child {\n      display: none; }\n  .braft-finder .bf-switch-external-type[data-type="IMAGE"] [data-type="IMAGE"],\n  .braft-finder .bf-switch-external-type[data-type="VIDEO"] [data-type="VIDEO"],\n  .braft-finder .bf-switch-external-type[data-type="AUDIO"] [data-type="AUDIO"],\n  .braft-finder .bf-switch-external-type[data-type="EMBED"] [data-type="EMBED"],\n  .braft-finder .bf-switch-external-type[data-type="FILE"] [data-type="FILE"] {\n    background-color: #3498db;\n    color: #fff; }\n\n.braft-finder .bf-external-tip {\n  display: block;\n  margin-top: 15px;\n  color: #ccc;\n  font-size: 12px;\n  text-align: center; }\n',
            ""
          ]);

          // exports

          /***/
        },
        /* 17 */
        /***/ function(module, exports, __webpack_require__) {
          var content = __webpack_require__(16);

          if (typeof content === "string") content = [[module.i, content, ""]];

          var transform;

          var options = { hmr: true };

          options.transform = transform;
          options.insertInto = undefined;

          var update = __webpack_require__(12)(content, options);

          if (content.locals) module.exports = content.locals;

          /***/
        },
        /* 18 */
        /***/ function(module, exports, __webpack_require__) {
          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;
            };

          var _createClass = (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);
              }
            }
            return function(Constructor, protoProps, staticProps) {
              if (protoProps)
                defineProperties(Constructor.prototype, protoProps);
              if (staticProps) defineProperties(Constructor, staticProps);
              return Constructor;
            };
          })();

          __webpack_require__(17);

          var _react = __webpack_require__(2);

          var _react2 = _interopRequireDefault(_react);

          var _base = __webpack_require__(1);

          function _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : { default: obj };
          }

          function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
              throw new TypeError("Cannot call a class as a function");
            }
          }

          function _possibleConstructorReturn(self, call) {
            if (!self) {
              throw new ReferenceError(
                "this hasn't been initialised - super() hasn't been called"
              );
            }
            return call &&
              (typeof call === "object" || typeof call === "function")
              ? call
              : self;
          }

          function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
              throw new TypeError(
                "Super expression must either be null or a function, not " +
                  typeof superClass
              );
            }
            subClass.prototype = Object.create(
              superClass && superClass.prototype,
              {
                constructor: {
                  value: subClass,
                  enumerable: false,
                  writable: true,
                  configurable: true
                }
              }
            );
            if (superClass)
              Object.setPrototypeOf
                ? Object.setPrototypeOf(subClass, superClass)
                : (subClass.__proto__ = superClass);
          }

          var defaultAccepts = {
            image:
              "image/png,image/jpeg,image/gif,image/webp,image/apng,image/svg",
            video: "video/mp4",
            audio: "audio/mp3"
          };

          var BraftFinderView = (function(_React$Component) {
            _inherits(BraftFinderView, _React$Component);

            function BraftFinderView(props) {
              _classCallCheck(this, BraftFinderView);

              var _this = _possibleConstructorReturn(
                this,
                (
                  BraftFinderView.__proto__ ||
                  Object.getPrototypeOf(BraftFinderView)
                ).call(this, props)
              );

              _this.toggleSelectItem = function(event) {
                var itemId = event.currentTarget.dataset.id;
                var item = _this.controller.getMediaItem(itemId);

                if (!item) {
                  return false;
                }

                if (item.selected) {
                  if (
                    !_this.props.onBeforeDeselect ||
                    _this.props.onBeforeDeselect(
                      [item],
                      _this.controller.getItems()
                    ) !== false
                  ) {
                    _this.controller.deselectMediaItem(itemId);
                    _this.props.onDeselect &&
                      _this.props.onDeselect(
                        [item],
                        _this.controller.getItems()
                      );
                  }
                } else {
                  if (
                    !_this.props.onBeforeSelect ||
                    _this.props.onBeforeSelect(
                      [item],
                      _this.controller.getItems()
                    ) !== false
                  ) {
                    _this.controller.selectMediaItem(itemId);
                    _this.props.onSelect &&
                      _this.props.onSelect([item], _this.controller.getItems());
                  }
                }
              };

              _this.removeItem = function(event) {
                var itemId = event.currentTarget.dataset.id;
                var item = _this.controller.getMediaItem(itemId);

                if (!item) {
                  return false;
                }

                if (
                  !_this.props.onBeforeRemove ||
                  _this.props.onBeforeRemove(
                    [item],
                    _this.controller.getItems()
                  ) !== false
                ) {
                  _this.controller.removeMediaItem(itemId);
                  _this.props.onRemove &&
                    _this.props.onRemove([item], _this.controller.getItems());
                }

                event.stopPropagation();
              };

              _this.selectAllItems = function() {
                var allItems = _this.controller.getItems();

                if (
                  !_this.props.onBeforeSelect ||
                  _this.props.onBeforeSelect(allItems, allItems) !== false
                ) {
                  _this.controller.selectAllItems();
                  _this.props.onSelect &&
                    _this.props.onSelect(allItems, allItems);
                }
              };

              _this.deselectAllItems = function() {
                var allItems = _this.controller.getItems();

                if (
                  !_this.props.onBeforeDeselect ||
                  _this.props.onBeforeDeselect(allItems, allItems) !== false
                ) {
                  _this.controller.deselectAllItems();
                  _this.props.onDeselect &&
                    _this.props.onDeselect(allItems, allItems);
                }
              };

              _this.removeSelectedItems = function() {
                var selectedItems = _this.controller.getSelectedItems();

                if (
                  !_this.props.onBeforeRemove ||
                  _this.props.onBeforeRemove(
                    selectedItems,
                    _this.controller.getItems()
                  ) !== false
                ) {
                  _this.controller.removeSelectedItems();
                  _this.props.onRemove &&
                    _this.props.onRemove(
                      selectedItems,
                      _this.controller.getItems()
                    );
                }
              };

              _this.handleDragLeave = function(event) {
                event.preventDefault();
                _this.dragCounter--;
                _this.dragCounter === 0 &&
                  _this.setState({
                    draging: false
                  });
              };

              _this.handleDragDrop = function(event) {
                event.preventDefault();
                _this.dragCounter = 0;
                _this.setState({ draging: false });
                _this.reslovePickedFiles(event);
              };

              _this.handleDragEnter = function(event) {
                event.preventDefault();
                _this.dragCounter++;
                _this.setState({ draging: true });
              };

              _this.reslovePickedFiles = function(event) {
                event.persist();

                var _ref =
                    event.type === "drop" ? event.dataTransfer : event.target,
                  files = _ref.files;

                if (_this.props.onFileSelect) {
                  var result = _this.props.onFileSelect(files);
                  if (result === false) {
                    return false;
                  } else if (
                    result instanceof FileList ||
                    result instanceof Array
                  ) {
                    files = result;
                  }
                }

                var accepts = _extends({}, defaultAccepts, _this.props.accepts);

                _this.controller.resolveFiles(
                  {
                    files: files,
                    onItemReady: function onItemReady(_ref2) {
                      var id = _ref2.id;
                      return _this.controller.selectMediaItem(id);
                    },
                    onAllReady: function onAllReady() {
                      return (event.target.value = null);
                    }
                  },
                  0,
                  accepts
                );
              };

              _this.inputExternal = function(event) {
                _this.setState({
                  external: _extends({}, _this.state.external, {
                    url: event.target.value
                  })
                });
              };

              _this.switchExternalType = function(event) {
                _this.setState({
                  external: _extends({}, _this.state.external, {
                    type: event.target.dataset.type
                  })
                });
              };

              _this.confirmAddExternal = function(event) {
                if (
                  event.target.nodeName.toLowerCase() === "button" ||
                  event.keyCode === 13
                ) {
                  var _this$state$external = _this.state.external,
                    url = _this$state$external.url,
                    type = _this$state$external.type;

                  url = url.split("|");
                  var name =
                    url.length > 1 ? url[0] : _this.props.language.unnamedItem;
                  url = url.length > 1 ? url[1] : url[0];
                  var thumbnail = type === "IMAGE" ? url : null;

                  _this.controller.addItems([
                    {
                      thumbnail: thumbnail,
                      url: url,
                      name: name,
                      type: type,
                      id: new Date().getTime() + "_" + (0, _base.UniqueIndex)(),
                      uploading: false,
                      uploadProgress: 1,
                      selected: true
                    }
                  ]);

                  _this.setState({
                    showExternalForm: false,
                    external: {
                      url: "",
                      type: "IMAGE"
                    }
                  });
                }
              };

              _this.toggleExternalForm = function() {
                _this.setState({
                  showExternalForm: !_this.state.showExternalForm
                });
              };

              _this.cancelInsert = function() {
                _this.props.onCancel && _this.props.onCancel();
              };

              _this.confirmInsert = function() {
                var selectedItems = _this.controller.getSelectedItems();

                if (_this.props.onBeforeInsert) {
                  var filteredItems = _this.props.onBeforeInsert(selectedItems);

                  if (filteredItems && filteredItems instanceof Array) {
                    _this.controller.deselectAllItems();
                    _this.props.onInsert && _this.props.onInsert(filteredItems);
                  } else if (filteredItems !== false) {
                    _this.controller.deselectAllItems();
                    _this.props.onInsert && _this.props.onInsert(selectedItems);
                  }
                } else {
                  _this.controller.deselectAllItems();
                  _this.props.onInsert && _this.props.onInsert(selectedItems);
                }
              };

              _this.dragCounter = 0;
              _this.controller = _this.props.controller;
              var initialItems = _this.controller.getItems();

              _this.state = {
                draging: false,
                error: false,
                confirmable: initialItems.find(function(_ref3) {
                  var selected = _ref3.selected;
                  return selected;
                }),
                external: {
                  url: "",
                  type: "IMAGE"
                },
                fileAccept: "",
                showExternalForm: false,
                allowExternal: false,
                items: initialItems
              };

              _this.changeListenerId = _this.controller.onChange(function(
                items
              ) {
                _this.setState({
                  items: items,
                  confirmable: items.find(function(_ref4) {
                    var selected = _ref4.selected;
                    return selected;
                  })
                });
                _this.props.onChange && _this.props.onChange(items);
              });

              return _this;
            }

            _createClass(BraftFinderView, [
              {
                key: "mapPropsToState",
                value: function mapPropsToState(props) {
                  var accepts = props.accepts,
                    externals = props.externals;

                  accepts = _extends({}, defaultAccepts, accepts);

                  var fileAccept = !accepts
                    ? [
                        defaultAccepts.image,
                        defaultAccepts.video,
                        defaultAccepts.audio
                      ].join(",")
                    : [accepts.image, accepts.video, accepts.audio]
                        .filter(function(item) {
                          return item;
                        })
                        .join(",");

                  var external = {
                    url: "",
                    type: externals.image
                      ? "IMAGE"
                      : externals.audio
                      ? "AUDIO"
                      : externals.video
                      ? "VIDEO"
                      : externals.embed
                      ? "EMBED"
                      : ""
                  };

                  return {
                    fileAccept: fileAccept,
                    external: external,
                    allowExternal:
                      externals &&
                      (externals.image ||
                        externals.audio ||
                        externals.video ||
                        externals.embed)
                  };
                }
              },
              {
                key: "componentDidMount",
                value: function componentDidMount() {
                  this.setState(this.mapPropsToState(this.props));
                }
              },
              {
                key: "componentWillReceiveProps",
                value: function componentWillReceiveProps(nextProps) {
                  this.setState(this.mapPropsToState(nextProps));
                }
              },
              {
                key: "componentWillUnmount",
                value: function componentWillUnmount() {
                  this.controller.offChange(this.changeListenerId);
                }
              },
              {
                key: "render",
                value: function render() {
                  var _props = this.props,
                    language = _props.language,
                    externals = _props.externals;
                  var _state = this.state,
                    items = _state.items,
                    draging = _state.draging,
                    confirmable = _state.confirmable,
                    fileAccept = _state.fileAccept,
                    external = _state.external,
                    showExternalForm = _state.showExternalForm,
                    allowExternal = _state.allowExternal;

                  return _react2.default.createElement(
                    "div",
                    { className: "braft-finder" },
                    _react2.default.createElement(
                      "div",
                      {
                        onDragEnter: this.handleDragEnter,
                        onDragOver: this.handleDragEnter,
                        onDragLeave: this.handleDragLeave,
                        onDrop: this.handleDragDrop,
                        className: "bf-uploader"
                      },
                      _react2.default.createElement(
                        "div",
                        {
                          className:
                            "bf-drag-uploader " +
                            (draging || !items.length ? "active " : " ") +
                            (draging ? "draging" : "")
                        },
                        _react2.default.createElement(
                          "span",
                          { className: "bf-drag-tip" },
                          _react2.default.createElement("input", {
                            accept: fileAccept,
                            onChange: this.reslovePickedFiles,
                            multiple: true,
                            type: "file"
                          }),
                          draging ? language.dropTip : language.dragTip
                        )
                      ),
                      items.length
                        ? _react2.default.createElement(
                            "div",
                            { className: "bf-list-wrap" },
                            _react2.default.createElement(
                              "div",
                              { className: "bf-list-tools" },
                              _react2.default.createElement(
                                "span",
                                {
                                  onClick: this.selectAllItems,
                                  className: "bf-select-all"
                                },
                                _react2.default.createElement("i", {
                                  className: "braft-icon-done"
                                }),
                                " ",
                                language.selectAll
                              ),
                              _react2.default.createElement(
                                "span",
                                {
                                  onClick: this.deselectAllItems,
                                  disabled: !confirmable,
                                  className: "bf-deselect-all"
                                },
                                _react2.default.createElement("i", {
                                  className: "braft-icon-close"
                                }),
                                " ",
                                language.deselect
                              ),
                              _react2.default.createElement(
                                "span",
                                {
                                  onClick: this.removeSelectedItems,
                                  disabled: !confirmable,
                                  className: "bf-remove-selected"
                                },
                                _react2.default.createElement("i", {
                                  className: "braft-icon-bin"
                                }),
                                " ",
                                language.removeSelected
                              )
                            ),
                            this.buildItemList()
                          )
                        : null,
                      showExternalForm && allowExternal
                        ? _react2.default.createElement(
                            "div",
                            { className: "bf-add-external" },
                            _react2.default.createElement(
                              "div",
                              { className: "bf-external-form" },
                              _react2.default.createElement(
                                "div",
                                { className: "bf-external-input" },
                                _react2.default.createElement(
                                  "div",
                                  null,
                                  _react2.default.createElement("input", {
                                    onKeyDown: this.confirmAddExternal,
                                    value: external.url,
                                    onChange: this.inputExternal,
                                    placeholder:
                                      language.externalInputPlaceHolder
                                  })
                                ),
                                _react2.default.createElement(
                                  "button",
                                  {
                                    type: "button",
                                    onClick: this.confirmAddExternal,
                                    disabled: !external.url.trim().length
                                  },
                                  language.confirm
                                )
                              ),
                              _react2.default.createElement(
                                "div",
                                {
                                  "data-type": external.type,
                                  className: "bf-switch-external-type"
                                },
                                externals.image
                                  ? _react2.default.createElement(
                                      "button",
                                      {
                                        type: "button",
                                        onClick: this.switchExternalType,
                                        "data-type": "IMAGE"
                                      },
                                      language.image
                                    )
                                  : null,
                                externals.audio
                                  ? _react2.default.createElement(
                                      "button",
                                      {
                                        type: "button",
                                        onClick: this.switchExternalType,
                                        "data-type": "AUDIO"
                                      },
                                      language.audio
                                    )
                                  : null,
                                externals.video
                                  ? _react2.default.createElement(
                                      "button",
                                      {
                                        type: "button",
                                        onClick: this.switchExternalType,
                                        "data-type": "VIDEO"
                                      },
                                      language.video
                                    )
                                  : null,
                                externals.embed
                                  ? _react2.default.createElement(
                                      "button",
                                      {
                                        type: "button",
                                        onClick: this.switchExternalType,
                                        "data-type": "EMBED"
                                      },
                                      language.embed
                                    )
                                  : null
                              ),
                              _react2.default.createElement(
                                "span",
                                { className: "bf-external-tip" },
                                language.externalInputTip
                              )
                            )
                          )
                        : null
                    ),
                    _react2.default.createElement(
                      "footer",
                      { className: "bf-manager-footer" },
                      _react2.default.createElement(
                        "div",
                        { className: "pull-left" },
                        allowExternal
                          ? _react2.default.createElement(
                              "span",
                              {
                                onClick: this.toggleExternalForm,
                                className: "bf-toggle-external-form"
                              },
                              showExternalForm
                                ? _react2.default.createElement(
                                    "span",
                                    { className: "bf-bottom-text" },
                                    _react2.default.createElement("i", {
                                      className: "braft-icon-add"
                                    }),
                                    " ",
                                    language.addLocalFile
                                  )
                                : _react2.default.createElement(
                                    "span",
                                    { className: "bf-bottom-text" },
                                    _react2.default.createElement("i", {
                                      className: "braft-icon-add"
                                    }),
                                    " ",
                                    language.addExternalSource
                                  )
                            )
                          : null
                      ),
                      _react2.default.createElement(
                        "div",
                        { className: "pull-right" },
                        _react2.default.createElement(
                          "button",
                          {
                            onClick: this.confirmInsert,
                            className: "button button-insert",
                            disabled: !confirmable
                          },
                          language.insert
                        ),
                        _react2.default.createElement(
                          "button",
                          {
                            onClick: this.cancelInsert,
                            className: "button button-cancel"
                          },
                          language.cancel
                        )
                      )
                    )
                  );
                }
              },
              {
                key: "buildItemList",
                value: function buildItemList() {
                  var _this2 = this;

                  return _react2.default.createElement(
                    "ul",
                    { className: "bf-list" },
                    _react2.default.createElement(
                      "li",
                      { className: "bf-add-item" },
                      _react2.default.createElement("i", {
                        className: "braft-icon-add"
                      }),
                      _react2.default.createElement("input", {
                        accept: this.state.fileAccept,
                        onChange: this.reslovePickedFiles,
                        multiple: true,
                        type: "file"
                      })
                    ),
                    this.state.items.map(function(item, index) {
                      var previewerComponents = null;
                      var progressMarker =
                        item.uploading && !_this2.props.hideProgress
                          ? _react2.default.createElement(
                              "div",
                              { className: "bf-item-uploading" },
                              _react2.default.createElement("div", {
                                className: "bf-item-uploading-bar",
                                style: { width: item.uploadProgress / 1 + "%" }
                              })
                            )
                          : "";

                      switch (item.type) {
                        case "IMAGE":
                          previewerComponents = _react2.default.createElement(
                            "div",
                            { className: "bf-image" },
                            progressMarker,
                            _react2.default.createElement("img", {
                              src: item.thumbnail || item.url
                            })
                          );
                          break;
                        case "VIDEO":
                          previewerComponents = _react2.default.createElement(
                            "div",
                            { className: "bf-icon bf-video", title: item.url },
                            progressMarker,
                            _react2.default.createElement("i", {
                              className: "braft-icon-film"
                            }),
                            _react2.default.createElement(
                              "span",
                              null,
                              item.name || item.url
                            )
                          );
                          break;
                        case "AUDIO":
                          previewerComponents = _react2.default.createElement(
                            "div",
                            { className: "bf-icon bf-audio", title: item.url },
                            progressMarker,
                            _react2.default.createElement("i", {
                              className: "braft-icon-music"
                            }),
                            _react2.default.createElement(
                              "span",
                              null,
                              item.name || item.url
                            )
                          );
                          break;
                        case "EMBED":
                          previewerComponents = _react2.default.createElement(
                            "div",
                            { className: "bf-icon bf-embed", title: item.url },
                            progressMarker,
                            _react2.default.createElement("i", {
                              className: "braft-icon-code"
                            }),
                            _react2.default.createElement(
                              "span",
                              null,
                              item.name || _this2.props.language.embed
                            )
                          );
                          break;
                        default:
                          previewerComponents = _react2.default.createElement(
                            "a",
                            {
                              className: "bf-icon bf-file",
                              title: item.url,
                              href: item.url
                            },
                            progressMarker,
                            _react2.default.createElement("i", {
                              className: "braft-icon-file-text"
                            }),
                            _react2.default.createElement(
                              "span",
                              null,
                              item.name || item.url
                            )
                          );
                          break;
                      }

                      var className = ["bf-item"];
                      item.selected && className.push("active");
                      item.uploading && className.push("uploading");
                      item.error && className.push("error");

                      return _react2.default.createElement(
                        "li",
                        {
                          key: index,
                          title: item.name,
                          "data-id": item.id,
                          className: className.join(" "),
                          onClick: _this2.toggleSelectItem
                        },
                        previewerComponents,
                        _react2.default.createElement("span", {
                          "data-id": item.id,
                          onClick: _this2.removeItem,
                          className: "bf-item-remove braft-icon-close"
                        }),
                        _react2.default.createElement(
                          "span",
                          { className: "bf-item-title" },
                          item.name
                        )
                      );
                    })
                  );
                }
              }
            ]);

            return BraftFinderView;
          })(_react2.default.Component);

          BraftFinderView.defaultProps = {
            accepts: defaultAccepts,
            externals: {
              image: true,
              video: true,
              audio: true,
              embed: true
            }
          };
          exports.default = BraftFinderView;

          /***/
        },
        /* 19 */
        /***/ function(module, exports, __webpack_require__) {
          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;
            };

          var _base = __webpack_require__(1);

          var _image = __webpack_require__(0);

          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);
            }
          }

          function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
              throw new TypeError("Cannot call a class as a function");
            }
          }

          var defaultValidator = function defaultValidator() {
            return true;
          };

          var BraftFinderController = function BraftFinderController() {
            var props =
              arguments.length > 0 && arguments[0] !== undefined
                ? arguments[0]
                : {};

            _classCallCheck(this, BraftFinderController);

            _initialiseProps.call(this);

            this.items = props.items || [];
            this.uploadFn = props.uploader;
            this.validateFn = props.validator || defaultValidator;

            this.changeListeners = [];
          };

          // resolvePastedFiles ({ clipboardData }, callback) {

          //   if (clipboardData && clipboardData.items && clipboardData.items[0].type.indexOf('image') > -1) {
          //     this.uploadImage(clipboardData.items[0].getAsFile(), callback)
          //   }

          // }

          var _initialiseProps = function _initialiseProps() {
            var _this = this;

            this.setProps = function() {
              var props =
                arguments.length > 0 && arguments[0] !== undefined
                  ? arguments[0]
                  : {};

              _this.items = props.items || _this.items || [];
              _this.uploadFn = props.uploader;
              _this.validateFn = props.validator || defaultValidator;
            };

            this.getMediaItem = function(id) {
              return _this.items.find(function(item) {
                return item.id === id;
              });
            };

            this.getSelectedItems = function() {
              return _this.items.filter(function(item) {
                return item.selected;
              });
            };

            this.getItems = function() {
              return _this.items;
            };

            this.setItems = function(items) {
              _this.items =
                items.map(function(item) {
                  return _extends({}, item, { id: item.id.toString() });
                }) || [];
              _this.applyChange();
              _this.uploadItems();
            };

            this.addMediaItem = function(item) {
              _this.addItems([item]);
            };

            this.addItems = function(items) {
              _this.items = [].concat(
                _toConsumableArray(_this.items),
                _toConsumableArray(
                  items.map(function(item) {
                    return _extends({}, item, { id: item.id.toString() });
                  })
                )
              );
              _this.applyChange();
              _this.uploadItems();
            };

            this.selectMediaItem = function(id) {
              var item = _this.getMediaItem(id);
              if (item && (item.uploading || item.error)) {
                return false;
              }
              _this.setMediaItemState(id, {
                selected: true
              });
            };

            this.selectAllItems = function() {
              _this.items = _this.items
                .filter(function(item) {
                  return !item.error && !item.uploading;
                })
                .map(function(item) {
                  return _extends({}, item, { selected: true });
                });
              _this.applyChange();
            };

            this.deselectMediaItem = function(id) {
              _this.setMediaItemState(id, {
                selected: false
              });
            };

            this.deselectAllItems = function() {
              _this.items = _this.items.map(function(item) {
                return _extends({}, item, { selected: false });
              });
              _this.applyChange();
            };

            this.removeMediaItem = function(id) {
              _this.items = _this.items.filter(function(item) {
                return item.id !== id;
              });
              _this.applyChange();
            };

            this.removeItems = function() {
              var ids =
                arguments.length > 0 && arguments[0] !== undefined
                  ? arguments[0]
                  : [];

              _this.items = _this.items.filter(function(item) {
                return !ids.includes(item.id);
              });
              _this.applyChange();
            };

            this.removeSelectedItems = function() {
              _this.items = _this.items.filter(function(item) {
                return !item.selected;
              });
              _this.applyChange();
            };

            this.removeErrorItems = function() {
              _this.items = _this.items.filter(function(item) {
                return !item.error;
              });
              _this.applyChange();
            };

            this.removeAllItems = function() {
              _this.items = [];
              _this.applyChange();
            };

            this.setMediaItemState = function(id, state) {
              _this.items = _this.items.map(function(item) {
                return item.id === id ? _extends({}, item, state) : item;
              });
              _this.applyChange();
            };

            this.reuploadErrorItems = function() {
              _this.uploadItems(true);
            };

            this.uploadItems = function() {
              var ignoreError =
                arguments.length > 0 && arguments[0] !== undefined
                  ? arguments[0]
                  : false;

              _this.items.forEach(function(item, index) {
                if (item.uploading || item.url) {
                  return false;
                }

                if (!ignoreError && item.error) {
                  return false;
                }

                if (item.type === "IMAGE") {
                  _this.createThumbnail(item);
                  _this.uploadFn = _this.uploadFn || _this.createInlineImage;
                } else if (!_this.uploadFn) {
                  _this.setMediaItemState(item.id, { error: 1 });
                  return false;
                }

                _this.setMediaItemState(item.id, {
                  uploading: true,
                  uploadProgress: 0,
                  error: 0
                });

                _this.uploadFn({
                  id: item.id,
                  file: item.file,
                  success: function success(res) {
                    _this.handleUploadSuccess(item.id, res);
                  },
                  progress: function progress(_progress) {
                    _this.setMediaItemState(item.id, {
                      uploading: true,
                      uploadProgress: _progress
                    });
                  },
                  error: function error(_error) {
                    _this.setMediaItemState(item.id, {
                      uploading: false,
                      error: 2
                    });
                  }
                });
              });
            };

            this.createThumbnail = function(_ref) {
              var id = _ref.id,
                file = _ref.file;

              (0, _image.compressImage)(
                URL.createObjectURL(file),
                226,
                226
              ).then(function(result) {
                _this.setMediaItemState(id, { thumbnail: result.url });
              });
            };

            this.createInlineImage = function(param) {
              (0, _image.compressImage)(
                URL.createObjectURL(param.file),
                1280,
                800
              )
                .then(function(result) {
                  param.success({ url: result.url });
                })
                .catch(function(error) {
                  param.error(error);
                });
            };

            this.handleUploadSuccess = function(id, data) {
              _this.setMediaItemState(
                id,
                _extends({}, data, {
                  file: null,
                  uploadProgress: 1,
                  uploading: false,
                  selected: false
                })
              );

              var item = _this.getMediaItem(data.id || id);
              item.onReady && item.onReady(item);
            };

            this.applyChange = function() {
              _this.changeListeners.forEach(function(_ref2) {
                var callback = _ref2.callback;
                return callback(_this.items);
              });
            };

            this.uploadImage = function(file, callback) {
              var fileId =
                new Date().getTime() + "_" + (0, _base.UniqueIndex)();

              _this.addMediaItem({
                type: "IMAGE",
                id: fileId,
                file: file,
                name: fileId,
                size: file.size,
                uploadProgress: 0,
                uploading: false,
                selected: false,
                error: 0,
                onReady: callback
              });
            };

            this.uploadImageRecursively = function(files, callback) {
              var index =
                arguments.length > 2 && arguments[2] !== undefined
                  ? arguments[2]
                  : 0;

              if (files[index] && files[index].type.indexOf("image") > -1) {
                _this.uploadImage(files[index], function(image) {
                  callback && callback(image);
                  index < files.length - 1 &&
                    _this.uploadImageRecursively(files, callback, index + 1);
                });
              } else {
                index < files.length - 1 &&
                  _this.uploadImageRecursively(files, callback, index + 1);
              }
            };

            this.addResolvedFiles = function(param, index, accepts) {
              var data = {
                id: new Date().getTime() + "_" + (0, _base.UniqueIndex)(),
                file: param.files[index],
                name: param.files[index].name,
                size: param.files[index].size,
                uploadProgress: 0,
                uploading: false,
                selected: false,
                error: 0,
                onReady: function onReady(item) {
                  param.onItemReady && param.onItemReady(item);
                }
              };

              if (
                param.files[index].type.indexOf("image/") === 0 &&
                accepts.image
              ) {
                data.type = "IMAGE";
                _this.addMediaItem(data);
              } else if (
                param.files[index].type.indexOf("video/") === 0 &&
                accepts.video
              ) {
                data.type = "VIDEO";
                _this.addMediaItem(data);
              } else if (
                param.files[index].type.indexOf("audio/") === 0 &&
                accepts.audio
              ) {
                data.type = "AUDIO";
                _this.addMediaItem(data);
              }

              setTimeout(function() {
                _this.resolveFiles(param, index + 1, accepts);
              }, 60);
            };

            this.resolveFiles = function(param, index, accepts) {
              if (index < param.files.length) {
                var validateResult = _this.validateFn(param.files[index]);

                if (validateResult instanceof Promise) {
                  validateResult.then(function() {
                    _this.addResolvedFiles(param, index, accepts);
                  });
                } else if (validateResult) {
                  _this.addResolvedFiles(param, index, accepts);
                }
              } else {
                param.onAllReady && param.onAllReady();
              }
            };

            this.onChange = function(callback) {
              var listenerId = (0, _base.UniqueIndex)();

              _this.changeListeners.push({
                id: listenerId,
                callback: callback
              });

              return listenerId;
            };

            this.offChange = function(listenerId) {
              _this.changeListeners = _this.changeListeners.filter(function(
                _ref3
              ) {
                var id = _ref3.id;
                return id !== listenerId;
              });
            };
          };

          exports.default = BraftFinderController;

          /***/
        },
        /* 20 */
        /***/ function(module, exports, __webpack_require__) {
          Object.defineProperty(exports, "__esModule", {
            value: true
          });
          exports.ImageUtils = undefined;

          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;
            };

          var _react = __webpack_require__(2);

          var _react2 = _interopRequireDefault(_react);

          var _controller = __webpack_require__(19);

          var _controller2 = _interopRequireDefault(_controller);

          var _view = __webpack_require__(18);

          var _view2 = _interopRequireDefault(_view);

          var _languages = __webpack_require__(10);

          var _languages2 = _interopRequireDefault(_languages);

          var _image = __webpack_require__(0);

          var ImageUtils = _interopRequireWildcard(_image);

          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 _interopRequireDefault(obj) {
            return obj && obj.__esModule ? obj : { default: obj };
          }

          function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
              throw new TypeError("Cannot call a class as a function");
            }
          }

          function _possibleConstructorReturn(self, call) {
            if (!self) {
              throw new ReferenceError(
                "this hasn't been initialised - super() hasn't been called"
              );
            }
            return call &&
              (typeof call === "object" || typeof call === "function")
              ? call
              : self;
          }

          function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
              throw new TypeError(
                "Super expression must either be null or a function, not " +
                  typeof superClass
              );
            }
            subClass.prototype = Object.create(
              superClass && superClass.prototype,
              {
                constructor: {
                  value: subClass,
                  enumerable: false,
                  writable: true,
                  configurable: true
                }
              }
            );
            if (superClass)
              Object.setPrototypeOf
                ? Object.setPrototypeOf(subClass, superClass)
                : (subClass.__proto__ = superClass);
          }

          var BraftFinder = (function(_FinderController) {
            _inherits(BraftFinder, _FinderController);

            function BraftFinder(props) {
              _classCallCheck(this, BraftFinder);

              var _this = _possibleConstructorReturn(
                this,
                (
                  BraftFinder.__proto__ || Object.getPrototypeOf(BraftFinder)
                ).call(this, props)
              );

              _initialiseProps.call(_this);

              _this.superProps = props;
              return _this;
            }

            return BraftFinder;
          })(_controller2.default);

          var _initialiseProps = function _initialiseProps() {
            var _this2 = this;

            this.ReactComponent = function() {
              var props =
                arguments.length > 0 && arguments[0] !== undefined
                  ? arguments[0]
                  : {};

              var componentProps = _extends({}, _this2.superProps, props);

              var language =
                (typeof componentProps.language === "function"
                  ? componentProps.language(_languages2.default, "braft-finder")
                  : _languages2.default[componentProps.language]) ||
                _languages2.default["zh"];

              return _react2.default.createElement(
                _view2.default,
                _extends({}, componentProps, {
                  language: language,
                  controller: _this2
                })
              );
            };
          };

          exports.default = BraftFinder;
          exports.ImageUtils = ImageUtils;

          /***/
        }
        /******/
      ]
    );
  });
});

_commonjsHelpers.unwrapExports(dist$2);

var dist$3 = _commonjsHelpers.createCommonjsModule(function(module, exports) {
  (function webpackUniversalModuleDefinition(root, factory) {
    module.exports = factory(
      React__default,
      dist$1,
      Draft,
      immutable$1,
      dist,
      reactDom__default,
      dist$2,
      draftjsUtils
    );
  })(window, function(
    __WEBPACK_EXTERNAL_MODULE__0__,
    __WEBPACK_EXTERNAL_MODULE__3__,
    __WEBPACK_EXTERNAL_MODULE__6__,
    __WEBPACK_EXTERNAL_MODULE__13__,
    __WEBPACK_EXTERNAL_MODULE__14__,
    __WEBPACK_EXTERNAL_MODULE__16__,
    __WEBPACK_EXTERNAL_MODULE__17__,
    __WEBPACK_EXTERNAL_MODULE__23__
  ) {
    return /******/ (function(modules) {
      // webpackBootstrap
      /******/ // The module cache
      /******/ var installedModules = {}; // The require function
      /******/
      /******/ /******/ function __webpack_require__(moduleId) {
        /******/
        /******/ // Check if module is in cache
        /******/ if (installedModules[moduleId]) {
          /******/ return installedModules[moduleId].exports;
          /******/
        } // Create a new module (and put it into the cache)
        /******/ /******/ var module = (installedModules[moduleId] = {
          /******/ i: moduleId,
          /******/ l: false,
          /******/ exports: {}
          /******/
        }); // Execute the module function
        /******/
        /******/ /******/ modules[moduleId].call(
          module.exports,
          module,
          module.exports,
          __webpack_require__
        ); // Flag the module as loaded
        /******/
        /******/ /******/ module.l = true; // Return the exports of the module
        /******/
        /******/ /******/ return module.exports;
        /******/
      } // expose the modules object (__webpack_modules__)
      /******/
      /******/
      /******/ /******/ __webpack_require__.m = modules; // expose the module cache
      /******/
      /******/ /******/ __webpack_require__.c = installedModules; // define getter function for harmony exports
      /******/
      /******/ /******/ __webpack_require__.d = function(
        exports,
        name,
        getter
      ) {
        /******/ if (!__webpack_require__.o(exports, name)) {
          /******/ Object.defineProperty(exports, name, {
            enumerable: true,
            get: getter
          });
          /******/
        }
        /******/
      }; // define __esModule on exports
      /******/
      /******/ /******/ __webpack_require__.r = function(exports) {
        /******/ if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
          /******/ Object.defineProperty(exports, Symbol.toStringTag, {
            value: "Module"
          });
          /******/
        }
        /******/ Object.defineProperty(exports, "__esModule", { value: true });
        /******/
      }; // create a fake namespace object // mode & 1: value is a module id, require it // mode & 2: merge all properties of value into the ns // mode & 4: return value when already ns object // mode & 8|1: behave like require
      /******/
      /******/ /******/ /******/ /******/ /******/ /******/ __webpack_require__.t = function(
        value,
        mode
      ) {
        /******/ if (mode & 1) value = __webpack_require__(value);
        /******/ if (mode & 8) return value;
        /******/ if (
          mode & 4 &&
          typeof value === "object" &&
          value &&
          value.__esModule
        )
          return value;
        /******/ var ns = Object.create(null);
        /******/ __webpack_require__.r(ns);
        /******/ Object.defineProperty(ns, "default", {
          enumerable: true,
          value: value
        });
        /******/ if (mode & 2 && typeof value != "string")
          for (var key in value)
            __webpack_require__.d(
              ns,
              key,
              function(key) {
                return value[key];
              }.bind(null, key)
            );
        /******/ return ns;
        /******/
      }; // getDefaultExport function for compatibility with non-harmony modules
      /******/
      /******/ /******/ __webpack_require__.n = function(module) {
        /******/ var getter =
          module && module.__esModule
            ? /******/ function getDefault() {
                return module["default"];
              }
            : /******/ function getModuleExports() {
                return module;
              };
        /******/ __webpack_require__.d(getter, "a", getter);
        /******/ return getter;
        /******/
      }; // Object.prototype.hasOwnProperty.call
      /******/
      /******/ /******/ __webpack_require__.o = function(object, property) {
        return Object.prototype.hasOwnProperty.call(object, property);
      }; // __webpack_public_path__
      /******/
      /******/ /******/ __webpack_require__.p = "/"; // Load entry module and return exports
      /******/
      /******/
      /******/ /******/ return __webpack_require__(
        (__webpack_require__.s = 39)
      );
      /******/
    })(
      /************************************************************************/
      /******/ [
        /* 0 */
        /***/ function(module, exports) {
          module.exports = __WEBPACK_EXTERNAL_MODULE__0__;

          /***/
        },
        /* 1 */
        /***/ function(module, exports) {
          function _assertThisInitialized(self) {
            if (self === void 0) {
              throw new ReferenceError(
                "this hasn't been initialised - super() hasn't been called"
              );
            }

            return self;
          }

          module.exports = _assertThisInitialized;

          /***/
        },
        /* 2 */
        /***/ function(module, exports) {
          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;
          }

          module.exports = _defineProperty;

          /***/
        },
        /* 3 */
        /***/ function(module, exports) {
          module.exports = __WEBPACK_EXTERNAL_MODULE__3__;

          /***/
        },
        /* 4 */
        /***/ function(module, exports) {
          function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
              throw new TypeError("Cannot call a class as a function");
            }
          }

          module.exports = _classCallCheck;

          /***/
        },
        /* 5 */
        /***/ function(module, exports, __webpack_require__) {
          var defineProperty = __webpack_require__(2);

          function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
              var source = arguments[i] != null ? arguments[i] : {};
              var ownKeys = Object.keys(source);

              if (typeof Object.getOwnPropertySymbols === "function") {
                ownKeys = ownKeys.concat(
                  Object.getOwnPropertySymbols(source).filter(function(sym) {
                    return Object.getOwnPropertyDescriptor(
                      source,
                      sym
                    ).enumerable;
                  })
                );
              }

              ownKeys.forEach(function(key) {
                defineProperty(target, key, source[key]);
              });
            }

            return target;
          }

          module.exports = _objectSpread;

          /***/
        },
        /* 6 */
        /***/ function(module, exports) {
          module.exports = __WEBPACK_EXTERNAL_MODULE__6__;

          /***/
        },
        /* 7 */
        /***/ function(module, exports) {
          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;
          }

          module.exports = _createClass;

          /***/
        },
        /* 8 */
        /***/ function(module, exports, __webpack_require__) {
          var _typeof = __webpack_require__(15);

          var assertThisInitialized = __webpack_require__(1);

          function _possibleConstructorReturn(self, call) {
            if (
              call &&
              (_typeof(call) === "object" || typeof call === "function")
            ) {
              return call;
            }

            return assertThisInitialized(self);
          }

          module.exports = _possibleConstructorReturn;

          /***/
        },
        /* 9 */
        /***/ function(module, exports) {
          function _getPrototypeOf(o) {
            module.exports = _getPrototypeOf = Object.setPrototypeOf
              ? Object.getPrototypeOf
              : function _getPrototypeOf(o) {
                  return o.__proto__ || Object.getPrototypeOf(o);
                };
            return _getPrototypeOf(o);
          }

          module.exports = _getPrototypeOf;

          /***/
        },
        /* 10 */
        /***/ function(module, exports, __webpack_require__) {
          var setPrototypeOf = __webpack_require__(26);

          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);
          }

          module.exports = _inherits;

          /***/
        },
        /* 11 */
        /***/ function(module, exports) {
          function _extends() {
            module.exports = _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);
          }

          module.exports = _extends;

          /***/
        },
        /* 12 */
        /***/ function(module, exports, __webpack_require__) {
          var arrayWithoutHoles = __webpack_require__(27);

          var iterableToArray = __webpack_require__(28);

          var nonIterableSpread = __webpack_require__(29);

          function _toConsumableArray(arr) {
            return (
              arrayWithoutHoles(arr) ||
              iterableToArray(arr) ||
              nonIterableSpread()
            );
          }

          module.exports = _toConsumableArray;

          /***/
        },
        /* 13 */
        /***/ function(module, exports) {
          module.exports = __WEBPACK_EXTERNAL_MODULE__13__;

          /***/
        },
        /* 14 */
        /***/ function(module, exports) {
          module.exports = __WEBPACK_EXTERNAL_MODULE__14__;

          /***/
        },
        /* 15 */
        /***/ function(module, exports) {
          function _typeof2(obj) {
            if (
              typeof Symbol === "function" &&
              typeof Symbol.iterator === "symbol"
            ) {
              _typeof2 = function _typeof2(obj) {
                return typeof obj;
              };
            } else {
              _typeof2 = function _typeof2(obj) {
                return obj &&
                  typeof Symbol === "function" &&
                  obj.constructor === Symbol &&
                  obj !== Symbol.prototype
                  ? "symbol"
                  : typeof obj;
              };
            }
            return _typeof2(obj);
          }

          function _typeof(obj) {
            if (
              typeof Symbol === "function" &&
              _typeof2(Symbol.iterator) === "symbol"
            ) {
              module.exports = _typeof = function _typeof(obj) {
                return _typeof2(obj);
              };
            } else {
              module.exports = _typeof = function _typeof(obj) {
                return obj &&
                  typeof Symbol === "function" &&
                  obj.constructor === Symbol &&
                  obj !== Symbol.prototype
                  ? "symbol"
                  : _typeof2(obj);
              };
            }

            return _typeof(obj);
          }

          module.exports = _typeof;

          /***/
        },
        /* 16 */
        /***/ function(module, exports) {
          module.exports = __WEBPACK_EXTERNAL_MODULE__16__;

          /***/
        },
        /* 17 */
        /***/ function(module, exports) {
          module.exports = __WEBPACK_EXTERNAL_MODULE__17__;

          /***/
        },
        /* 18 */
        /***/ function(module, exports, __webpack_require__) {
          var Immutable = __webpack_require__(13);

          var KEY_SEPARATOR = "-";

          function MultiDecorator(decorators) {
            this.decorators = Immutable.List(decorators);
          }

          /**
    Return list of decoration IDs per character

    @param {ContentBlock}
    @return {List<String>}
*/
          MultiDecorator.prototype.getDecorations = function(block) {
            var decorations = Array(block.getText().length).fill(null);

            this.decorators.forEach(function(decorator, i) {
              var _decorations = decorator.getDecorations(block);

              _decorations.forEach(function(key, offset) {
                if (!key) {
                  return;
                }

                key = i + KEY_SEPARATOR + key;

                decorations[offset] = key;
              });
            });

            return Immutable.List(decorations);
          };

          /**
    Return component to render a decoration

    @param {String}
    @return {Function}
*/
          MultiDecorator.prototype.getComponentForKey = function(key) {
            var decorator = this.getDecoratorForKey(key);
            return decorator.getComponentForKey(this.getInnerKey(key));
          };

          /**
    Return props to render a decoration

    @param {String}
    @return {Object}
*/
          MultiDecorator.prototype.getPropsForKey = function(key) {
            var decorator = this.getDecoratorForKey(key);
            return decorator.getPropsForKey(this.getInnerKey(key));
          };

          /**
    Return a decorator for a specific key

    @param {String}
    @return {Decorator}
*/
          MultiDecorator.prototype.getDecoratorForKey = function(key) {
            var parts = key.split(KEY_SEPARATOR);
            var index = Number(parts[0]);

            return this.decorators.get(index);
          };

          /**
    Return inner key for a decorator

    @param {String}
    @return {String}
*/
          MultiDecorator.prototype.getInnerKey = function(key) {
            var parts = key.split(KEY_SEPARATOR);
            return parts.slice(1).join(KEY_SEPARATOR);
          };

          module.exports = MultiDecorator;

          /***/
        },
        /* 19 */
        /***/ function(module, exports, __webpack_require__) {
          /**
           * Copyright (c) 2013-present, Facebook, Inc.
           * All rights reserved.
           *
           * This source code is licensed under the BSD-style license found in the
           * LICENSE file in the root directory of this source tree. An additional grant
           * of patent rights can be found in the PATENTS file in the same directory.
           *
           * @providesModule CharacterMetadata
           * @format
           *
           */

          function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
              throw new TypeError("Cannot call a class as a function");
            }
          }

          function _possibleConstructorReturn(self, call) {
            if (!self) {
              throw new ReferenceError(
                "this hasn't been initialised - super() hasn't been called"
              );
            }
            return call &&
              (typeof call === "object" || typeof call === "function")
              ? call
              : self;
          }

          function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
              throw new TypeError(
                "Super expression must either be null or a function, not " +
                  typeof superClass
              );
            }
            subClass.prototype = Object.create(
              superClass && superClass.prototype,
              {
                constructor: {
                  value: subClass,
                  enumerable: false,
                  writable: true,
                  configurable: true
                }
              }
            );
            if (superClass)
              Object.setPrototypeOf
                ? Object.setPrototypeOf(subClass, superClass)
                : (subClass.__proto__ = superClass);
          }

          var _require = __webpack_require__(13),
            Map = _require.Map,
            OrderedSet = _require.OrderedSet,
            Record = _require.Record;

          // Immutable.map is typed such that the value for every key in the map
          // must be the same type

          var EMPTY_SET = OrderedSet();

          var defaultRecord = {
            style: EMPTY_SET,
            entity: null
          };

          var CharacterMetadataRecord = Record(defaultRecord);

          var CharacterMetadata = (function(_CharacterMetadataRec) {
            _inherits(CharacterMetadata, _CharacterMetadataRec);

            function CharacterMetadata() {
              _classCallCheck(this, CharacterMetadata);

              return _possibleConstructorReturn(
                this,
                _CharacterMetadataRec.apply(this, arguments)
              );
            }

            CharacterMetadata.prototype.getStyle = function getStyle() {
              return this.get("style");
            };

            CharacterMetadata.prototype.getEntity = function getEntity() {
              return this.get("entity");
            };

            CharacterMetadata.prototype.hasStyle = function hasStyle(style) {
              return this.getStyle().includes(style);
            };

            CharacterMetadata.applyStyle = function applyStyle(record, style) {
              var withStyle = record.set("style", record.getStyle().add(style));
              return CharacterMetadata.create(withStyle);
            };

            CharacterMetadata.removeStyle = function removeStyle(
              record,
              style
            ) {
              var withoutStyle = record.set(
                "style",
                record.getStyle().remove(style)
              );
              return CharacterMetadata.create(withoutStyle);
            };

            CharacterMetadata.applyEntity = function applyEntity(
              record,
              entityKey
            ) {
              var withEntity =
                record.getEntity() === entityKey
                  ? record
                  : record.set("entity", entityKey);
              return CharacterMetadata.create(withEntity);
            };

            /**
             * Use this function instead of the `CharacterMetadata` constructor.
             * Since most content generally uses only a very small number of
             * style/entity permutations, we can reuse these objects as often as
             * possible.
             */

            CharacterMetadata.create = function create(config) {
              if (!config) {
                return EMPTY;
              }

              var defaultConfig = {
                style: EMPTY_SET,
                entity: null
              };

              // Fill in unspecified properties, if necessary.
              var configMap = Map(defaultConfig).merge(config);

              var existing = pool.get(configMap);
              if (existing) {
                return existing;
              }

              var newCharacter = new CharacterMetadata(configMap);
              pool = pool.set(configMap, newCharacter);
              return newCharacter;
            };

            return CharacterMetadata;
          })(CharacterMetadataRecord);

          var EMPTY = new CharacterMetadata();
          var pool = Map([[Map(defaultRecord), EMPTY]]);

          CharacterMetadata.EMPTY = EMPTY;

          module.exports = CharacterMetadata;

          /***/
        },
        /* 20 */
        /***/ function(module, exports, __webpack_require__) {
          /**
           * Copyright (c) 2013-present, Facebook, Inc.
           * All rights reserved.
           *
           * This source code is licensed under the BSD-style license found in the
           * LICENSE file in the root directory of this source tree. An additional grant
           * of patent rights can be found in the PATENTS file in the same directory.
           *
           * @providesModule findRangesImmutable
           * @format
           *
           */

          /**
           * Search through an array to find contiguous stretches of elements that
           * match a specified filter function.
           *
           * When ranges are found, execute a specified `found` function to supply
           * the values to the caller.
           */
          function findRangesImmutable(
            haystack,
            areEqualFn,
            filterFn,
            foundFn
          ) {
            if (!haystack.size) {
              return;
            }

            var cursor = 0;

            haystack.reduce(function(value, nextValue, nextIndex) {
              if (!areEqualFn(value, nextValue)) {
                if (filterFn(value)) {
                  foundFn(cursor, nextIndex);
                }
                cursor = nextIndex;
              }
              return nextValue;
            });

            filterFn(haystack.last()) && foundFn(cursor, haystack.count());
          }

          module.exports = findRangesImmutable;

          /***/
        },
        /* 21 */
        /***/ function(module, exports, __webpack_require__) {
          var objectWithoutPropertiesLoose = __webpack_require__(25);

          function _objectWithoutProperties(source, excluded) {
            if (source == null) return {};
            var target = objectWithoutPropertiesLoose(source, excluded);
            var key, i;

            if (Object.getOwnPropertySymbols) {
              var sourceSymbolKeys = Object.getOwnPropertySymbols(source);

              for (i = 0; i < sourceSymbolKeys.length; i++) {
                key = sourceSymbolKeys[i];
                if (excluded.indexOf(key) >= 0) continue;
                if (!Object.prototype.propertyIsEnumerable.call(source, key))
                  continue;
                target[key] = source[key];
              }
            }

            return target;
          }

          module.exports = _objectWithoutProperties;

          /***/
        },
        /* 22 */
        /***/ function(module, exports, __webpack_require__) {
          /**
           * Copyright (c) 2013-present, Facebook, Inc.
           * All rights reserved.
           *
           * This source code is licensed under the BSD-style license found in the
           * LICENSE file in the root directory of this source tree. An additional grant
           * of patent rights can be found in the PATENTS file in the same directory.
           *
           * @providesModule getFragmentFromSelection
           * @format
           *
           */

          var getContentStateFragment = __webpack_require__(30);

          function getFragmentFromSelection(editorState) {
            var selectionState = editorState.getSelection();

            if (selectionState.isCollapsed()) {
              return null;
            }

            return getContentStateFragment(
              editorState.getCurrentContent(),
              selectionState
            );
          }

          module.exports = getFragmentFromSelection;

          /***/
        },
        /* 23 */
        /***/ function(module, exports) {
          module.exports = __WEBPACK_EXTERNAL_MODULE__23__;

          /***/
        },
        /* 24 */
        /***/ function(module, exports, __webpack_require__) {
          var arrayWithHoles = __webpack_require__(36);

          var iterableToArrayLimit = __webpack_require__(37);

          var nonIterableRest = __webpack_require__(38);

          function _slicedToArray(arr, i) {
            return (
              arrayWithHoles(arr) ||
              iterableToArrayLimit(arr, i) ||
              nonIterableRest()
            );
          }

          module.exports = _slicedToArray;

          /***/
        },
        /* 25 */
        /***/ function(module, exports) {
          function _objectWithoutPropertiesLoose(source, excluded) {
            if (source == null) return {};
            var target = {};
            var sourceKeys = Object.keys(source);
            var key, i;

            for (i = 0; i < sourceKeys.length; i++) {
              key = sourceKeys[i];
              if (excluded.indexOf(key) >= 0) continue;
              target[key] = source[key];
            }

            return target;
          }

          module.exports = _objectWithoutPropertiesLoose;

          /***/
        },
        /* 26 */
        /***/ function(module, exports) {
          function _setPrototypeOf(o, p) {
            module.exports = _setPrototypeOf =
              Object.setPrototypeOf ||
              function _setPrototypeOf(o, p) {
                o.__proto__ = p;
                return o;
              };

            return _setPrototypeOf(o, p);
          }

          module.exports = _setPrototypeOf;

          /***/
        },
        /* 27 */
        /***/ function(module, exports) {
          function _arrayWithoutHoles(arr) {
            if (Array.isArray(arr)) {
              for (
                var i = 0, arr2 = new Array(arr.length);
                i < arr.length;
                i++
              ) {
                arr2[i] = arr[i];
              }

              return arr2;
            }
          }

          module.exports = _arrayWithoutHoles;

          /***/
        },
        /* 28 */
        /***/ function(module, exports) {
          function _iterableToArray(iter) {
            if (
              Symbol.iterator in Object(iter) ||
              Object.prototype.toString.call(iter) === "[object Arguments]"
            )
              return Array.from(iter);
          }

          module.exports = _iterableToArray;

          /***/
        },
        /* 29 */
        /***/ function(module, exports) {
          function _nonIterableSpread() {
            throw new TypeError(
              "Invalid attempt to spread non-iterable instance"
            );
          }

          module.exports = _nonIterableSpread;

          /***/
        },
        /* 30 */
        /***/ function(module, exports, __webpack_require__) {
          /**
           * Copyright (c) 2013-present, Facebook, Inc.
           * All rights reserved.
           *
           * This source code is licensed under the BSD-style license found in the
           * LICENSE file in the root directory of this source tree. An additional grant
           * of patent rights can be found in the PATENTS file in the same directory.
           *
           * @providesModule getContentStateFragment
           * @format
           *
           */

          var randomizeBlockMapKeys = __webpack_require__(31);
          var removeEntitiesAtEdges = __webpack_require__(34);

          var getContentStateFragment = function getContentStateFragment(
            contentState,
            selectionState
          ) {
            var startKey = selectionState.getStartKey();
            var startOffset = selectionState.getStartOffset();
            var endKey = selectionState.getEndKey();
            var endOffset = selectionState.getEndOffset();

            // Edge entities should be stripped to ensure that we don't preserve
            // invalid partial entities when the fragment is reused. We do, however,
            // preserve entities that are entirely within the selection range.
            var contentWithoutEdgeEntities = removeEntitiesAtEdges(
              contentState,
              selectionState
            );

            var blockMap = contentWithoutEdgeEntities.getBlockMap();
            var blockKeys = blockMap.keySeq();
            var startIndex = blockKeys.indexOf(startKey);
            var endIndex = blockKeys.indexOf(endKey) + 1;

            return randomizeBlockMapKeys(
              blockMap
                .slice(startIndex, endIndex)
                .map(function(block, blockKey) {
                  var text = block.getText();
                  var chars = block.getCharacterList();

                  if (startKey === endKey) {
                    return block.merge({
                      text: text.slice(startOffset, endOffset),
                      characterList: chars.slice(startOffset, endOffset)
                    });
                  }

                  if (blockKey === startKey) {
                    return block.merge({
                      text: text.slice(startOffset),
                      characterList: chars.slice(startOffset)
                    });
                  }

                  if (blockKey === endKey) {
                    return block.merge({
                      text: text.slice(0, endOffset),
                      characterList: chars.slice(0, endOffset)
                    });
                  }

                  return block;
                })
            );
          };

          module.exports = getContentStateFragment;

          /***/
        },
        /* 31 */
        /***/ function(module, exports, __webpack_require__) {
          /**
           * Copyright (c) 2013-present, Facebook, Inc.
           * All rights reserved.
           *
           * This source code is licensed under the BSD-style license found in the
           * LICENSE file in the root directory of this source tree. An additional grant
           * of patent rights can be found in the PATENTS file in the same directory.
           *
           * @providesModule randomizeBlockMapKeys
           * @format
           *
           */

          var ContentBlockNode = __webpack_require__(32);
          var Immutable = __webpack_require__(13);

          var generateRandomKey = __webpack_require__(33);

          var OrderedMap = Immutable.OrderedMap;

          var randomizeContentBlockNodeKeys = function randomizeContentBlockNodeKeys(
            blockMap
          ) {
            var newKeysRef = {};

            // we keep track of root blocks in order to update subsequent sibling links
            var lastRootBlock = void 0;

            return OrderedMap(
              blockMap
                .withMutations(function(blockMapState) {
                  blockMapState.forEach(function(block, index) {
                    var oldKey = block.getKey();
                    var nextKey = block.getNextSiblingKey();
                    var prevKey = block.getPrevSiblingKey();
                    var childrenKeys = block.getChildKeys();
                    var parentKey = block.getParentKey();

                    // new key that we will use to build linking
                    var key = generateRandomKey();

                    // we will add it here to re-use it later
                    newKeysRef[oldKey] = key;

                    if (nextKey) {
                      var nextBlock = blockMapState.get(nextKey);
                      if (nextBlock) {
                        blockMapState.setIn([nextKey, "prevSibling"], key);
                      } else {
                        // this can happen when generating random keys for fragments
                        blockMapState.setIn([oldKey, "nextSibling"], null);
                      }
                    }

                    if (prevKey) {
                      var prevBlock = blockMapState.get(prevKey);
                      if (prevBlock) {
                        blockMapState.setIn([prevKey, "nextSibling"], key);
                      } else {
                        // this can happen when generating random keys for fragments
                        blockMapState.setIn([oldKey, "prevSibling"], null);
                      }
                    }

                    if (parentKey && blockMapState.get(parentKey)) {
                      var parentBlock = blockMapState.get(parentKey);
                      var parentChildrenList = parentBlock.getChildKeys();
                      blockMapState.setIn(
                        [parentKey, "children"],
                        parentChildrenList.set(
                          parentChildrenList.indexOf(block.getKey()),
                          key
                        )
                      );
                    } else {
                      // blocks will then be treated as root block nodes
                      blockMapState.setIn([oldKey, "parent"], null);

                      if (lastRootBlock) {
                        blockMapState.setIn(
                          [lastRootBlock.getKey(), "nextSibling"],
                          key
                        );
                        blockMapState.setIn(
                          [oldKey, "prevSibling"],
                          newKeysRef[lastRootBlock.getKey()]
                        );
                      }

                      lastRootBlock = blockMapState.get(oldKey);
                    }

                    childrenKeys.forEach(function(childKey) {
                      var childBlock = blockMapState.get(childKey);
                      if (childBlock) {
                        blockMapState.setIn([childKey, "parent"], key);
                      } else {
                        blockMapState.setIn(
                          [oldKey, "children"],
                          block.getChildKeys().filter(function(child) {
                            return child !== childKey;
                          })
                        );
                      }
                    });
                  });
                })
                .toArray()
                .map(function(block) {
                  return [
                    newKeysRef[block.getKey()],
                    block.set("key", newKeysRef[block.getKey()])
                  ];
                })
            );
          };

          var randomizeContentBlockKeys = function randomizeContentBlockKeys(
            blockMap
          ) {
            return OrderedMap(
              blockMap.toArray().map(function(block) {
                var key = generateRandomKey();
                return [key, block.set("key", key)];
              })
            );
          };

          var randomizeBlockMapKeys = function randomizeBlockMapKeys(blockMap) {
            var isTreeBasedBlockMap =
              blockMap.first() instanceof ContentBlockNode;

            if (!isTreeBasedBlockMap) {
              return randomizeContentBlockKeys(blockMap);
            }

            return randomizeContentBlockNodeKeys(blockMap);
          };

          module.exports = randomizeBlockMapKeys;

          /***/
        },
        /* 32 */
        /***/ function(module, exports, __webpack_require__) {
          /**
           * Copyright (c) 2013-present, Facebook, Inc.
           * All rights reserved.
           *
           * This source code is licensed under the BSD-style license found in the
           * LICENSE file in the root directory of this source tree. An additional grant
           * of patent rights can be found in the PATENTS file in the same directory.
           *
           * @providesModule ContentBlockNode
           * @format
           *
           *
           * This file is a fork of ContentBlock adding support for nesting references by
           * providing links to children, parent, prevSibling, and nextSibling.
           *
           * This is unstable and not part of the public API and should not be used by
           * production systems. This file may be update/removed without notice.
           */

          function _classCallCheck(instance, Constructor) {
            if (!(instance instanceof Constructor)) {
              throw new TypeError("Cannot call a class as a function");
            }
          }

          function _possibleConstructorReturn(self, call) {
            if (!self) {
              throw new ReferenceError(
                "this hasn't been initialised - super() hasn't been called"
              );
            }
            return call &&
              (typeof call === "object" || typeof call === "function")
              ? call
              : self;
          }

          function _inherits(subClass, superClass) {
            if (typeof superClass !== "function" && superClass !== null) {
              throw new TypeError(
                "Super expression must either be null or a function, not " +
                  typeof superClass
              );
            }
            subClass.prototype = Object.create(
              superClass && superClass.prototype,
              {
                constructor: {
                  value: subClass,
                  enumerable: false,
                  writable: true,
                  configurable: true
                }
              }
            );
            if (superClass)
              Object.setPrototypeOf
                ? Object.setPrototypeOf(subClass, superClass)
                : (subClass.__proto__ = superClass);
          }

          var CharacterMetadata = __webpack_require__(19);
          var Immutable = __webpack_require__(13);

          var findRangesImmutable = __webpack_require__(20);

          var List = Immutable.List,
            Map = Immutable.Map,
            OrderedSet = Immutable.OrderedSet,
            Record = Immutable.Record,
            Repeat = Immutable.Repeat;

          var EMPTY_SET = OrderedSet();

          var defaultRecord = {
            parent: null,
            characterList: List(),
            data: Map(),
            depth: 0,
            key: "",
            text: "",
            type: "unstyled",
            children: List(),
            prevSibling: null,
            nextSibling: null
          };

          var haveEqualStyle = function haveEqualStyle(charA, charB) {
            return charA.getStyle() === charB.getStyle();
          };

          var haveEqualEntity = function haveEqualEntity(charA, charB) {
            return charA.getEntity() === charB.getEntity();
          };

          var decorateCharacterList = function decorateCharacterList(config) {
            if (!config) {
              return config;
            }

            var characterList = config.characterList,
              text = config.text;

            if (text && !characterList) {
              config.characterList = List(
                Repeat(CharacterMetadata.EMPTY, text.length)
              );
            }

            return config;
          };

          var ContentBlockNode = (function(_Record) {
            _inherits(ContentBlockNode, _Record);

            function ContentBlockNode() {
              var props =
                arguments.length > 0 && arguments[0] !== undefined
                  ? arguments[0]
                  : defaultRecord;

              _classCallCheck(this, ContentBlockNode);

              return _possibleConstructorReturn(
                this,
                _Record.call(this, decorateCharacterList(props))
              );
            }

            ContentBlockNode.prototype.getKey = function getKey() {
              return this.get("key");
            };

            ContentBlockNode.prototype.getType = function getType() {
              return this.get("type");
            };

            ContentBlockNode.prototype.getText = function getText() {
              return this.get("text");
            };

            ContentBlockNode.prototype.getCharacterList = function getCharacterList() {
              return this.get("characterList");
            };

            ContentBlockNode.prototype.getLength = function getLength() {
              return this.getText().length;
            };

            ContentBlockNode.prototype.getDepth = function getDepth() {
              return this.get("depth");
            };

            ContentBlockNode.prototype.getData = function getData() {
              return this.get("data");
            };

            ContentBlockNode.prototype.getInlineStyleAt = function getInlineStyleAt(
              offset
            ) {
              var character = this.getCharacterList().get(offset);
              return character ? character.getStyle() : EMPTY_SET;
            };

            ContentBlockNode.prototype.getEntityAt = function getEntityAt(
              offset
            ) {
              var character = this.getCharacterList().get(offset);
              return character ? character.getEntity() : null;
            };

            ContentBlockNode.prototype.getChildKeys = function getChildKeys() {
              return this.get("children");
            };

            ContentBlockNode.prototype.getParentKey = function getParentKey() {
              return this.get("parent");
            };

            ContentBlockNode.prototype.getPrevSiblingKey = function getPrevSiblingKey() {
              return this.get("prevSibling");
            };

            ContentBlockNode.prototype.getNextSiblingKey = function getNextSiblingKey() {
              return this.get("nextSibling");
            };

            ContentBlockNode.prototype.findStyleRanges = function findStyleRanges(
              filterFn,
              callback
            ) {
              findRangesImmutable(
                this.getCharacterList(),
                haveEqualStyle,
                filterFn,
                callback
              );
            };

            ContentBlockNode.prototype.findEntityRanges = function findEntityRanges(
              filterFn,
              callback
            ) {
              findRangesImmutable(
                this.getCharacterList(),
                haveEqualEntity,
                filterFn,
                callback
              );
            };

            return ContentBlockNode;
          })(Record(defaultRecord));

          module.exports = ContentBlockNode;

          /***/
        },
        /* 33 */
        /***/ function(module, exports, __webpack_require__) {
          /**
           * Copyright (c) 2013-present, Facebook, Inc.
           * All rights reserved.
           *
           * This source code is licensed under the BSD-style license found in the
           * LICENSE file in the root directory of this source tree. An additional grant
           * of patent rights can be found in the PATENTS file in the same directory.
           *
           * @providesModule generateRandomKey
           * @format
           *
           */

          var seenKeys = {};
          var MULTIPLIER = Math.pow(2, 24);

          function generateRandomKey() {
            var key = void 0;
            while (
              key === undefined ||
              seenKeys.hasOwnProperty(key) ||
              !isNaN(+key)
            ) {
              key = Math.floor(Math.random() * MULTIPLIER).toString(32);
            }
            seenKeys[key] = true;
            return key;
          }

          module.exports = generateRandomKey;

          /***/
        },
        /* 34 */
        /***/ function(module, exports, __webpack_require__) {
          /**
           * Copyright (c) 2013-present, Facebook, Inc.
           * All rights reserved.
           *
           * This source code is licensed under the BSD-style license found in the
           * LICENSE file in the root directory of this source tree. An additional grant
           * of patent rights can be found in the PATENTS file in the same directory.
           *
           * @providesModule removeEntitiesAtEdges
           * @format
           *
           */

          var CharacterMetadata = __webpack_require__(19);

          var findRangesImmutable = __webpack_require__(20);
          var invariant = __webpack_require__(35);

          function removeEntitiesAtEdges(contentState, selectionState) {
            var blockMap = contentState.getBlockMap();
            var entityMap = contentState.getEntityMap();

            var updatedBlocks = {};

            var startKey = selectionState.getStartKey();
            var startOffset = selectionState.getStartOffset();
            var startBlock = blockMap.get(startKey);
            var updatedStart = removeForBlock(
              entityMap,
              startBlock,
              startOffset
            );

            if (updatedStart !== startBlock) {
              updatedBlocks[startKey] = updatedStart;
            }

            var endKey = selectionState.getEndKey();
            var endOffset = selectionState.getEndOffset();
            var endBlock = blockMap.get(endKey);
            if (startKey === endKey) {
              endBlock = updatedStart;
            }

            var updatedEnd = removeForBlock(entityMap, endBlock, endOffset);

            if (updatedEnd !== endBlock) {
              updatedBlocks[endKey] = updatedEnd;
            }

            if (!Object.keys(updatedBlocks).length) {
              return contentState.set("selectionAfter", selectionState);
            }

            return contentState.merge({
              blockMap: blockMap.merge(updatedBlocks),
              selectionAfter: selectionState
            });
          }

          function getRemovalRange(characters, key, offset) {
            var removalRange;
            findRangesImmutable(
              characters,
              function(a, b) {
                return a.getEntity() === b.getEntity();
              },
              function(element) {
                return element.getEntity() === key;
              },
              function(start, end) {
                if (start <= offset && end >= offset) {
                  removalRange = { start: start, end: end };
                }
              }
            );
            !(typeof removalRange === "object") ? invariant(false) : void 0;
            return removalRange;
          }

          function removeForBlock(entityMap, block, offset) {
            var chars = block.getCharacterList();
            var charBefore = offset > 0 ? chars.get(offset - 1) : undefined;
            var charAfter =
              offset < chars.count() ? chars.get(offset) : undefined;
            var entityBeforeCursor = charBefore
              ? charBefore.getEntity()
              : undefined;
            var entityAfterCursor = charAfter
              ? charAfter.getEntity()
              : undefined;

            if (entityAfterCursor && entityAfterCursor === entityBeforeCursor) {
              var entity = entityMap.__get(entityAfterCursor);
              if (entity.getMutability() !== "MUTABLE") {
                var _getRemovalRange = getRemovalRange(
                    chars,
                    entityAfterCursor,
                    offset
                  ),
                  start = _getRemovalRange.start,
                  end = _getRemovalRange.end;

                var current;
                while (start < end) {
                  current = chars.get(start);
                  chars = chars.set(
                    start,
                    CharacterMetadata.applyEntity(current, null)
                  );
                  start++;
                }
                return block.set("characterList", chars);
              }
            }

            return block;
          }

          module.exports = removeEntitiesAtEdges;

          /***/
        },
        /* 35 */
        /***/ function(module, exports, __webpack_require__) {
          function invariant(condition, format, a, b, c, d, e, f) {
            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 args = [a, b, c, d, e, f];
                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;
            }
          }

          module.exports = invariant;

          /***/
        },
        /* 36 */
        /***/ function(module, exports) {
          function _arrayWithHoles(arr) {
            if (Array.isArray(arr)) return arr;
          }

          module.exports = _arrayWithHoles;

          /***/
        },
        /* 37 */
        /***/ function(module, exports) {
          function _iterableToArrayLimit(arr, i) {
            var _arr = [];
            var _n = true;
            var _d = false;
            var _e = undefined;

            try {
              for (
                var _i = arr[Symbol.iterator](), _s;
                !(_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;
          }

          module.exports = _iterableToArrayLimit;

          /***/
        },
        /* 38 */
        /***/ function(module, exports) {
          function _nonIterableRest() {
            throw new TypeError(
              "Invalid attempt to destructure non-iterable instance"
            );
          }

          module.exports = _nonIterableRest;

          /***/
        },
        /* 39 */
        /***/ function(module, __webpack_exports__, __webpack_require__) {
          __webpack_require__.r(__webpack_exports__);

          // EXTERNAL MODULE: ../node_modules/@babel/runtime/helpers/typeof.js
          var helpers_typeof = __webpack_require__(15);
          var typeof_default = /*#__PURE__*/ __webpack_require__.n(
            helpers_typeof
          );

          // EXTERNAL MODULE: ../node_modules/@babel/runtime/helpers/objectSpread.js
          var objectSpread = __webpack_require__(5);
          var objectSpread_default = /*#__PURE__*/ __webpack_require__.n(
            objectSpread
          );

          // EXTERNAL MODULE: ../node_modules/@babel/runtime/helpers/objectWithoutProperties.js
          var objectWithoutProperties = __webpack_require__(21);
          var objectWithoutProperties_default = /*#__PURE__*/ __webpack_require__.n(
            objectWithoutProperties
          );

          // EXTERNAL MODULE: ../node_modules/@babel/runtime/helpers/classCallCheck.js
          var classCallCheck = __webpack_require__(4);
          var classCallCheck_default = /*#__PURE__*/ __webpack_require__.n(
            classCallCheck
          );

          // EXTERNAL MODULE: ../node_modules/@babel/runtime/helpers/createClass.js
          var createClass = __webpack_require__(7);
          var createClass_default = /*#__PURE__*/ __webpack_require__.n(
            createClass
          );

          // EXTERNAL MODULE: ../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js
          var possibleConstructorReturn = __webpack_require__(8);
          var possibleConstructorReturn_default = /*#__PURE__*/ __webpack_require__.n(
            possibleConstructorReturn
          );

          // EXTERNAL MODULE: ../node_modules/@babel/runtime/helpers/getPrototypeOf.js
          var getPrototypeOf = __webpack_require__(9);
          var getPrototypeOf_default = /*#__PURE__*/ __webpack_require__.n(
            getPrototypeOf
          );

          // EXTERNAL MODULE: ../node_modules/@babel/runtime/helpers/inherits.js
          var inherits = __webpack_require__(10);
          var inherits_default = /*#__PURE__*/ __webpack_require__.n(inherits);

          // EXTERNAL MODULE: ../node_modules/@babel/runtime/helpers/assertThisInitialized.js
          var assertThisInitialized = __webpack_require__(1);
          var assertThisInitialized_default = /*#__PURE__*/ __webpack_require__.n(
            assertThisInitialized
          );

          // EXTERNAL MODULE: ../node_modules/@babel/runtime/helpers/defineProperty.js
          var defineProperty = __webpack_require__(2);
          var defineProperty_default = /*#__PURE__*/ __webpack_require__.n(
            defineProperty
          );

          // EXTERNAL MODULE: ../node_modules/@babel/runtime/helpers/toConsumableArray.js
          var toConsumableArray = __webpack_require__(12);
          var toConsumableArray_default = /*#__PURE__*/ __webpack_require__.n(
            toConsumableArray
          );

          // EXTERNAL MODULE: ../node_modules/draft-js/dist/Draft.css
          var Draft = __webpack_require__(40);

          // EXTERNAL MODULE: ./assets/scss/_base.scss
          var _base = __webpack_require__(42);

          // EXTERNAL MODULE: external "react"
          var external_react_ = __webpack_require__(0);
          var external_react_default = /*#__PURE__*/ __webpack_require__.n(
            external_react_
          );

          // CONCATENATED MODULE: ./languages/en.js
          /* harmony default export */ var en = {
            base: {
              remove: "Remove",
              cancel: "Cancel",
              confirm: "Confirm",
              inert: "Insert",
              width: "Width",
              height: "Height"
            },
            controls: {
              clear: "Clear",
              undo: "Undo",
              redo: "Redo",
              fontSize: "Font Size",
              color: "Color",
              textColor: "Text",
              tempColors: "Temp Colors",
              backgroundColor: "Background",
              bold: "Bold",
              lineHeight: "Line Height",
              letterSpacing: "Letter Spacing",
              textIndent: "Text Indent",
              increaseIndent: "Increase Indent",
              decreaseIndent: "Decrease Indent",
              italic: "Italic",
              underline: "Underline",
              strikeThrough: "Strike Through",
              fontFamily: "Font Family",
              textAlign: "Text Alignment",
              alignLeft: "Left Alignment",
              alignCenter: "Center Alignment",
              alignRight: "Right Alignment",
              alignJustify: "Justify Alignment",
              floatLeft: "Left Float",
              floatRight: "Right Float",
              superScript: "Super Script",
              subScript: "Sub Script",
              removeStyles: "Remove Styles",
              headings: "Headings",
              header: "Header",
              normal: "Normal",
              orderedList: "Ordered List",
              unorderedList: "Unordered List",
              blockQuote: "Quote",
              code: "Code",
              link: "Link",
              unlink: "Unlink",
              hr: "Horizontal Line",
              media: "Media",
              mediaLibirary: "Media Library",
              emoji: "Emoji",
              fullscreen: "Fullscreen",
              exitFullscreen: "Exit Fullscreen"
            },
            linkEditor: {
              textInputPlaceHolder: "Input link text",
              linkInputPlaceHolder: "Input link URL",
              inputWithEnterPlaceHolder: "Input link URL and press Enter",
              openInNewWindow: "Open in new window",
              removeLink: "Remove Link"
            },
            audioPlayer: {
              title: "Play Audio"
            },
            videoPlayer: {
              title: "Play Video",
              embedTitle: "Embed Media"
            },
            media: {
              image: "Image",
              video: "Video",
              audio: "Audio",
              embed: "Embed"
            }
          };
          // CONCATENATED MODULE: ./languages/zh.js
          /* harmony default export */ var zh = {
            base: {
              remove: "删除",
              cancel: "取消",
              confirm: "确定",
              inert: "插入",
              width: "宽度",
              height: "高度"
            },
            controls: {
              clear: "清除内容",
              undo: "撤销",
              redo: "重做",
              fontSize: "字号",
              lineHeight: "行高",
              letterSpacing: "字间距",
              textIndent: "段落缩进",
              increaseIndent: "增加缩进",
              decreaseIndent: "减少缩进",
              border: "边框",
              color: "颜色",
              textColor: "文字颜色",
              backgroundColor: "背景颜色",
              tempColors: "临时颜色",
              bold: "加粗",
              italic: "斜体",
              underline: "下划线",
              strikeThrough: "删除线",
              fontFamily: "字体",
              textAlign: "文本对齐",
              alignLeft: "居左",
              alignCenter: "居中",
              alignRight: "居右",
              alignJustify: "两端",
              floatLeft: "左浮动",
              floatRight: "右浮动",
              superScript: "上标",
              subScript: "下标",
              removeStyles: "清除样式",
              headings: "标题",
              header: "标题",
              normal: "常规",
              orderedList: "有序列表",
              unorderedList: "无序列表",
              blockQuote: "引用",
              code: "代码",
              link: "链接",
              unlink: "清除链接",
              hr: "水平线",
              media: "媒体",
              mediaLibirary: "媒体库",
              emoji: "小表情",
              fullscreen: "全屏",
              exitFullscreen: "退出全屏"
            },
            linkEditor: {
              textInputPlaceHolder: "输入链接文字",
              linkInputPlaceHolder: "输入链接地址",
              inputWithEnterPlaceHolder: "输入链接地址并回车",
              openInNewWindow: "在新窗口打开",
              removeLink: "移除链接"
            },
            audioPlayer: {
              title: "播放音频文件"
            },
            videoPlayer: {
              title: "播放视频文件",
              embedTitle: "嵌入式媒体"
            },
            media: {
              image: "图像",
              video: "视频",
              audio: "音频",
              embed: "嵌入式媒体"
            }
          };
          // CONCATENATED MODULE: ./languages/zh-hant.js
          /* harmony default export */ var zh_hant = {
            base: {
              remove: "刪除",
              cancel: "取消",
              confirm: "確定",
              inert: "插入",
              width: "宽度",
              height: "高度"
            },
            controls: {
              clear: "清除内容",
              undo: "撤銷",
              redo: "重做",
              fontSize: "字號",
              color: "顏色",
              textColor: "文字顏色",
              backgroundColor: "背景顏色",
              tempColors: "臨時顏色",
              bold: "加粗",
              lineHeight: "行高",
              letterSpacing: "字間距",
              textIndent: "段落縮進",
              increaseIndent: "增加縮進",
              decreaseIndent: "减少縮進",
              border: "邊框",
              italic: "斜體",
              underline: "下劃線",
              strikeThrough: "刪除線",
              fontFamily: "字體",
              textAlign: "文本對齊",
              alignLeft: "居左",
              alignCenter: "居中",
              alignRight: "居右",
              alignJustify: "兩端對齊",
              floatLeft: "左浮動",
              floatRight: "右浮動",
              superScript: "上標",
              subScript: "下標",
              removeStyles: "清除样式",
              headings: "標題",
              header: "標題",
              normal: "常規",
              orderedList: "有序列表",
              unorderedList: "無序列表",
              blockQuote: "引用",
              code: "代碼",
              link: "鏈接",
              unlink: "清除鏈接",
              hr: "水平线",
              media: "媒體",
              mediaLibirary: "媒體库",
              emoji: "小表情",
              fullscreen: "全熒幕",
              exitFullscreen: "退出全熒幕"
            },
            linkEditor: {
              textInputPlaceHolder: "輸入鏈接文字",
              linkInputPlaceHolder: "輸入鏈接地址",
              inputWithEnterPlaceHolder: "輸入鏈接地址並回車",
              openInNewWindow: "在新窗口打開",
              removeLink: "移除鏈接"
            },
            audioPlayer: {
              title: "播放音頻文件"
            },
            videoPlayer: {
              title: "播放視頻文件",
              embedTitle: "嵌入式媒體"
            },
            media: {
              image: "圖像",
              video: "視頻",
              audio: "音頻",
              embed: "嵌入式媒體"
            }
          };
          // CONCATENATED MODULE: ./languages/pl.js
          /* harmony default export */ var pl = {
            base: {
              remove: "Usuń",
              cancel: "Anuluj",
              confirm: "Potwierdź",
              inert: "Wstaw",
              width: "Szerokość",
              height: "Wysokość"
            },
            controls: {
              clear: "Wyczyść",
              undo: "Cofnij",
              redo: "Przywróć",
              fontSize: "Wielkość",
              color: "Kolor",
              textColor: "Kolor tekstu",
              tempColors: "Kolory",
              backgroundColor: "Tło",
              bold: "Pogrubienie",
              lineHeight: "Wysokość linii",
              letterSpacing: "Odstęp znaków",
              textIndent: "Wcięcie tekstu",
              increaseIndent: "Zwiększ wcięcie",
              decreaseIndent: "Zmniejsz wcięcie",
              italic: "Italiki",
              underline: "Podkreślenie",
              strikeThrough: "Przekreślenie",
              fontFamily: "Czcionka",
              textAlign: "Wyrównanie tekstu",
              alignLeft: "Do lewej",
              alignCenter: "Wycentruj",
              alignRight: "Do prawej",
              alignJustify: "Wyjustuj",
              floatLeft: "Do lewej",
              floatRight: "Do prawej",
              superScript: "Superskrypt",
              subScript: "Subskrypt",
              removeStyles: "Usuń stylowanie",
              headings: "Nagłówki",
              header: "Nagłówek",
              normal: "Normalny",
              orderedList: "Lista uporządkowana",
              unorderedList: "Lista nieuporządkowana",
              blockQuote: "Cytat",
              code: "Kod",
              link: "Link",
              unlink: "Usuń link",
              hr: "Linia pozioma",
              media: "Media",
              mediaLibirary: "Biblioteka mediów",
              emoji: "Emoji"
            },
            linkEditor: {
              textInputPlaceHolder: "Wpisz tekst linku",
              linkInputPlaceHolder: "Wpisz Adres URL",
              inputWithEnterPlaceHolder: "Wpisz adres URL i naciśnij Enter",
              openInNewWindow: "Otwórz w nowym oknie",
              removeLink: "Usuń link"
            },
            audioPlayer: {
              title: "Odtwórz audio"
            },
            videoPlayer: {
              title: "Odtwórz wideo",
              embedTitle: "Tytuł"
            },
            media: {
              image: "Obraz",
              video: "Wideo",
              audio: "Audio",
              embed: "Obiekt osadzony"
            }
          };
          // CONCATENATED MODULE: ./languages/kr.js
          /* harmony default export */ var kr = {
            base: {
              remove: "삭제",
              cancel: "취소",
              confirm: "결정",
              inert: "삽입",
              width: "너비",
              height: "높이"
            },
            controls: {
              clear: "콘텐츠지우기",
              undo: "취소",
              redo: "다시하기",
              fontSize: "글자크기",
              lineHeight: "행높이",
              letterSpacing: "단어간격",
              textIndent: "단락들여쓰기",
              increaseIndent: "들여쓰기늘리기",
              decreaseIndent: "들여쓰기줄이기",
              border: "국경",
              color: "색상",
              textColor: "텍스트색상",
              backgroundColor: "배경색상",
              tempColors: "임시색",
              bold: "굵게",
              italic: "기울임꼴",
              underline: "밑줄",
              strikeThrough: "취소선",
              fontFamily: "글꼴",
              textAlign: "텍스트정렬",
              alignLeft: "왼쪽",
              alignCenter: "중심",
              alignRight: "오른쪽",
              alignJustify: "양쪽끝",
              floatLeft: "떠다니기",
              floatRight: "오른쪽부동",
              superScript: "위첨자",
              subScript: "첨자",
              removeStyles: "스타일지우기",
              headings: "제목",
              header: "제목",
              normal: "재래식",
              orderedList: "순서가지정된목록",
              unorderedList: "정렬되지않은목록",
              blockQuote: "참고문헌",
              code: "코드",
              link: "링크",
              unlink: "링크삭제",
              hr: "수평선",
              media: "미디어",
              mediaLibirary: "미디어라이브러리",
              emoji: "작은표현",
              fullscreen: "전체화면",
              exitFullscreen: "전체화면종료"
            },
            linkEditor: {
              textInputPlaceHolder: "링크텍스트입력",
              linkInputPlaceHolder: "링크주소입력",
              inputWithEnterPlaceHolder: "링크주소입력.",
              openInNewWindow: "새창열기",
              removeLink: "링크삭제"
            },
            audioPlayer: {
              title: "오디오파일재생"
            },
            videoPlayer: {
              title: "비디오파일재생",
              embedTitle: "임베디드미디어"
            },
            media: {
              image: "이미지",
              video: "비디오",
              audio: "오디오",
              embed: "임베디드미디어"
            }
          };
          // CONCATENATED MODULE: ./languages/tr.js
          /* harmony default export */ var tr = {
            base: {
              remove: "Kaldır",
              cancel: "İptal",
              confirm: "Onayla",
              inert: "Ekle",
              width: "Genişlik",
              height: "Yükseklik"
            },
            controls: {
              clear: "Temizle",
              undo: "Geri al",
              redo: "İleri al",
              fontSize: "Yazı boyutu",
              color: "Renk",
              textColor: "Yazı rengi",
              tempColors: "Geçici renkler",
              backgroundColor: "Arkaplan",
              bold: "Kalın",
              lineHeight: "Satır yüksekliği",
              letterSpacing: "Harf aralığı",
              textIndent: "Çentik aralığı",
              increaseIndent: "Çentiği genişlet",
              decreaseIndent: "Çentiği daralt",
              italic: "Eğik",
              underline: "Altı çizili",
              strikeThrough: "Üstü çizili",
              fontFamily: "Yazı tipi",
              textAlign: "Metin Hizalama",
              alignLeft: "Sola hizala",
              alignCenter: "Ortaya hizala",
              alignRight: "Sağa hizala",
              alignJustify: "Her iki tarafa hizala",
              floatLeft: "Sola yatır",
              floatRight: "Sağa yatır",
              superScript: "Ana kod",
              subScript: "Alt kod",
              removeStyles: "Stilleri kaldır",
              headings: "Başlıklar",
              header: "Başlık",
              normal: "Normal",
              orderedList: "Sıralı liste",
              unorderedList: "Sırasız liste",
              blockQuote: "Alıntı",
              code: "Kod",
              link: "Bağlantı",
              unlink: "Bağlantıyı kaldır",
              hr: "Yatay çizgi",
              media: "Medya",
              mediaLibirary: "Kütüphane",
              emoji: "İfade",
              fullscreen: "Tam ekran",
              exitFullscreen: "Tam ekrandan çık"
            },
            linkEditor: {
              textInputPlaceHolder: "Bağlantı metnini girin",
              linkInputPlaceHolder: "Bağlantı URL' si girin",
              inputWithEnterPlaceHolder:
                "Bağlantı URL'si girin ve Enter' a basın",
              openInNewWindow: "Yeni pencerede aç",
              removeLink: "Bağlantıyı kaldır"
            },
            audioPlayer: {
              title: "Ses çal"
            },
            videoPlayer: {
              title: "Görüntü oynat",
              embedTitle: "Görüntüyü göm"
            },
            media: {
              image: "Resim",
              video: "Görüntü",
              audio: "Ses",
              embed: "Gömülü nesne"
            }
          };
          // CONCATENATED MODULE: ./languages/jpn.js
          /* harmony default export */ var jpn = {
            base: {
              remove: "削除",
              cancel: "キャンセル",
              confirm: "決定",
              inert: "挿入",
              width: "幅",
              height: "高さ"
            },
            controls: {
              clear: "クリアコンテンツ",
              undo: "キャンセル",
              redo: "キャンセル",
              fontSize: "フォントサイズ",
              lineHeight: "フォントサイズ",
              letterSpacing: "ワード間隔",
              textIndent: "段落のインデント",
              increaseIndent: "インデントを増やす",
              decreaseIndent: "インデントを減らす",
              border: "国境",
              color: "色",
              textColor: "テキストの色",
              backgroundColor: "背景色",
              tempColors: "仮色",
              bold: "太字",
              italic: "イタリック体",
              underline: "下線",
              strikeThrough: "取り消し線",
              fontFamily: "フォント",
              textAlign: "テキストの配置",
              alignLeft: "左",
              alignCenter: "中央揃え",
              alignRight: "右に立つ",
              alignJustify: "両端",
              floatLeft: "左フローティング",
              floatRight: "右フローティング",
              superScript: "上付き",
              subScript: "下付き文字",
              removeStyles: "クリアスタイル",
              headings: "役職",
              header: "役職",
              normal: "従来の",
              orderedList: "順序付きリスト",
              unorderedList: "番号なしリスト",
              blockQuote: "参照",
              code: "コード",
              link: "リンク",
              unlink: "リンクを解除",
              hr: "横線",
              media: "メディア",
              mediaLibirary: "メディアライブラリー",
              emoji: "小さな表現",
              fullscreen: "全画面",
              exitFullscreen: "全画面を退く"
            },
            linkEditor: {
              textInputPlaceHolder: "リンクテキストを入力",
              linkInputPlaceHolder: "リンクアドレスを入力",
              inputWithEnterPlaceHolder: "リンクアドレスを入力して戻ります",
              openInNewWindow: "新しいウィンドウで開く",
              removeLink: "新しいウィンドウで開く"
            },
            audioPlayer: {
              title: "オーディオファイルを再生する"
            },
            videoPlayer: {
              title: "ビデオファイルを再生する",
              embedTitle: "埋め込みメディア"
            },
            media: {
              image: "画像",
              video: "ビデオ",
              audio: "音声",
              embed: "埋め込みメディア"
            }
          };
          // CONCATENATED MODULE: ./languages/ru.js
          /* harmony default export */ var ru = {
            base: {
              remove: "Удалить",
              cancel: "Отмена",
              confirm: "Подтвердить",
              insert: "Вставить",
              width: "Ширина",
              height: "Высота"
            },
            controls: {
              clear: "Очистить",
              undo: "Отменить",
              redo: "Повторить",
              fontSize: "Размер шрифта",
              color: "Цвет",
              textColor: "Цвет текста",
              tempColors: "Temp Colors",
              backgroundColor: "Цвет фона",
              bold: "Жирный",
              lineHeight: "Межстрочный интервал",
              letterSpacing: "Межбуквенный интервал",
              textIndent: "Отступ",
              increaseIndent: "Увеличить отступ",
              decreaseIndent: "Уменьшить отступ",
              italic: "Курсив",
              underline: "Подчеркнутый",
              strikeThrough: "Перечеркнутый",
              fontFamily: "Шрифт",
              textAlign: "Расположение текста",
              alignLeft: "По левому краю",
              alignCenter: "По центру",
              alignRight: "По правому краю",
              alignJustify: "По ширине",
              floatLeft: "Обтекание слева",
              floatRight: "Обтекание справа",
              superScript: "Надстрочный индекс",
              subScript: "Подстрочный индекс",
              removeStyles: "Убрать стили",
              headings: "Заголовки",
              header: "Заголовок",
              normal: "Обычный",
              orderedList: "Упорядоченный список",
              unorderedList: "Неупорядоченный список",
              blockQuote: "Цитата",
              code: "Код",
              link: "Вставить ссылку",
              unlink: "Убрать ссылку",
              hr: "Горизонтальная линия",
              media: "Медиа",
              mediaLibirary: "Медиа библиотека",
              emoji: "Emoji",
              fullscreen: "Полноэкранный режим",
              exitFullscreen: "Выйти из полноэкранного режима"
            },
            linkEditor: {
              textInputPlaceHolder: "Введите текст ссылки",
              linkInputPlaceHolder: "Вставить ссылку",
              inputWithEnterPlaceHolder: "Вставить ссылку и нажать Enter",
              openInNewWindow: "Открыть в новом окне",
              removeLink: "Убрать ссылку"
            },
            audioPlayer: {
              title: "Воспроизвести аудиофайл"
            },
            videoPlayer: {
              title: "Воспроизвести видеофайл",
              embedTitle: "Embed Media"
            },
            media: {
              image: "Картинка",
              video: "Видео",
              audio: "Аудио",
              embed: "Встроенное"
            }
          };
          // CONCATENATED MODULE: ./languages/fr.js
          /* harmony default export */ var fr = {
            base: {
              remove: "Supprimer",
              cancel: "Annuler",
              confirm: "Confirmer",
              inert: "Insérer",
              width: "Largeur",
              height: "Hauteur"
            },
            controls: {
              clear: "Effacer",
              undo: "Annuler",
              redo: "Refaire",
              fontSize: "Taille de police",
              color: "Couleur",
              textColor: "Texte",
              tempColors: "Couleurs temporaire",
              backgroundColor: "Couleur d'arrière plan",
              bold: "Gras",
              lineHeight: "Hauteur de ligne",
              letterSpacing: "Espacement des lettres",
              textIndent: "Indentation du texte",
              increaseIndent: "Augmenter l'indentation",
              decreaseIndent: "Réduire l'indentation",
              italic: "Italique",
              underline: "Souligner",
              strikeThrough: "Barrer",
              fontFamily: "Police d'écriture",
              textAlign: "Alignement du texte",
              alignLeft: "Aligner à gauche",
              alignCenter: "Aligner au centre",
              alignRight: "Aligner à droite",
              alignJustify: "Justifier",
              floatLeft: "Déplacer à gauche",
              floatRight: "Déplacer à droite",
              superScript: "Super-script",
              subScript: "Sous-script",
              removeStyles: "Supprimer les styles",
              headings: "Titres",
              header: "Entêtes",
              normal: "Normal",
              orderedList: "Liste ordonnée",
              unorderedList: "Liste non-ordonnée",
              blockQuote: "Citation",
              code: "Code",
              link: "Insérer un lien",
              unlink: "Supprimer le lien",
              hr: "Ligne horizontale",
              media: "Média",
              mediaLibirary: "Bibliothêque",
              emoji: "Emoji",
              fullscreen: "Plein écran",
              exitFullscreen: "Quitter le plein écran"
            },
            linkEditor: {
              textInputPlaceHolder: "Insérer le texte à afficher",
              linkInputPlaceHolder: "Insérer le lien URL",
              inputWithEnterPlaceHolder:
                "Insérer le lien URL puis appuyer sur Entrée",
              openInNewWindow: "Ouvrir dans une nouvelle fenêtre",
              removeLink: "Supprimer le lien"
            },
            audioPlayer: {
              title: "Lancer le son audio"
            },
            videoPlayer: {
              title: "Lancer la video",
              embedTitle: "Intégrer média"
            },
            media: {
              image: "Image",
              video: "Vidéo",
              audio: "Audio",
              embed: "Intégré"
            }
          };
          // CONCATENATED MODULE: ./languages/pt-br.js
          /* harmony default export */ var pt_br = {
            base: {
              remove: "Remover",
              cancel: "Cancelar",
              confirm: "Confirmar",
              inert: "Inserir",
              width: "Largura",
              height: "Altura"
            },
            controls: {
              clear: "Limpar",
              undo: "Desfazer",
              redo: "Refazer",
              fontSize: "Tamanho da Fonte",
              color: "Cor",
              textColor: "Texto",
              tempColors: "Temp Colors",
              backgroundColor: "Cor de Fundo",
              bold: "Negrito",
              lineHeight: "Altura da LinhaLine Height",
              letterSpacing: "Espaçamento entre Letras",
              textIndent: "Identação de Texto",
              increaseIndent: "Aumentar Identação",
              decreaseIndent: "Diminuir Identção",
              italic: "Itálico",
              underline: "Sublinhado",
              strikeThrough: "Riscado",
              fontFamily: "Família da Fonte",
              textAlign: "Alinhamento de Texto",
              alignLeft: "Alinhamento à Esquerda",
              alignCenter: "Alinhamento Centralizado",
              alignRight: "Alinhamento à Direita",
              alignJustify: "Alinhamento Justificado",
              floatLeft: "Flutuação à Esquerda",
              floatRight: "Flutuação à Direita",
              superScript: "Sobrescrito",
              subScript: "Subscrito",
              removeStyles: "Remover Estilos",
              headings: "Cabeçalhos",
              header: "Cabeçalho",
              normal: "Normal",
              orderedList: "Lista Ordenada",
              unorderedList: "Lista Não Ordenada",
              blockQuote: "Citação",
              code: "Código",
              link: "Link",
              unlink: "Remover Link",
              hr: "Linha Horizontal",
              media: "Mídia",
              mediaLibirary: "Biblioteca de Mídia",
              emoji: "Emoji",
              fullscreen: "Tela Cheia",
              exitFullscreen: "Sair de Tela Cheia"
            },
            linkEditor: {
              textInputPlaceHolder: "Insira o texto do link",
              linkInputPlaceHolder: "Insira a URL do link",
              inputWithEnterPlaceHolder: "Insira a URL do link e aperte Enter",
              openInNewWindow: "Abrir em nova janela",
              removeLink: "Remover Link"
            },
            audioPlayer: {
              title: "Tocar Áudio"
            },
            videoPlayer: {
              title: "Tocar Vídeo",
              embedTitle: "Mídia Embutida"
            },
            media: {
              image: "Imagem",
              video: "Vídeo",
              audio: "Áudio",
              embed: "Embutido"
            }
          };
          // CONCATENATED MODULE: ./languages/index.js

          /* harmony default export */ var languages = {
            en: en,
            zh: zh,
            "zh-hant": zh_hant,
            pl: pl,
            kr: kr,
            tr: tr,
            jpn: jpn,
            ru: ru,
            fr: fr,
            "pt-br": pt_br
          };
          // EXTERNAL MODULE: external "braft-finder"
          var external_braft_finder_ = __webpack_require__(17);
          var external_braft_finder_default = /*#__PURE__*/ __webpack_require__.n(
            external_braft_finder_
          );

          // EXTERNAL MODULE: external "braft-utils"
          var external_braft_utils_ = __webpack_require__(3);

          // EXTERNAL MODULE: external "draft-js"
          var external_draft_js_ = __webpack_require__(6);

          // EXTERNAL MODULE: external "immutable"
          var external_immutable_ = __webpack_require__(13);
          var external_immutable_default = /*#__PURE__*/ __webpack_require__.n(
            external_immutable_
          );

          // CONCATENATED MODULE: ./configs/keybindings.js
          // TODO
          // 允许自定义的快捷键设置

          /* harmony default export */ var keybindings = function(
            customKeyBindingFn
          ) {
            return function(event) {
              if (
                event.keyCode === 83 &&
                (external_draft_js_["KeyBindingUtil"].hasCommandModifier(
                  event
                ) ||
                  external_draft_js_["KeyBindingUtil"].isCtrlKeyCommand(event))
              ) {
                return "braft-save";
              }

              if (customKeyBindingFn) {
                return (
                  customKeyBindingFn(event) ||
                  Object(external_draft_js_["getDefaultKeyBinding"])(event)
                );
              }

              return Object(external_draft_js_["getDefaultKeyBinding"])(event);
            };
          };
          // CONCATENATED MODULE: ./configs/props.js
          /* harmony default export */ var configs_props = {
            language: "zh",
            controls: [
              "undo",
              "redo",
              "separator",
              "font-size",
              "line-height",
              "letter-spacing",
              "separator",
              "text-color",
              "bold",
              "italic",
              "underline",
              "strike-through",
              "separator",
              "superscript",
              "subscript",
              "remove-styles",
              "emoji",
              "separator",
              "text-indent",
              "text-align",
              "separator",
              "headings",
              "list-ul",
              "list-ol",
              "blockquote",
              "code",
              "separator",
              "media",
              "link",
              "table",
              "split",
              "hr",
              "separator",
              "clear",
              "separator",
              "fullscreen"
            ],
            excludeControls: [],
            extendControls: [],
            extendAtomics: [],
            componentBelowControlBar: null,
            media: {
              pasteImage: true,
              imagePasteLimit: 5,
              image: true,
              video: true,
              audio: true,
              uploadFn: null,
              validateFn: null,
              onBeforeDeselect: null,
              onDeselect: null,
              onBeforeSelect: null,
              onSelect: null,
              onBeforeRemove: null,
              onRemove: null,
              onCancel: null,
              onFileSelect: null,
              onBeforeInsert: null,
              onInsert: null,
              onChange: null,
              accepts: {
                image:
                  "image/png,image/jpeg,image/gif,image/webp,image/apng,image/svg",
                video: "video/mp4",
                audio: "audio/mp3"
              },
              externals: {
                audio: true,
                video: true,
                image: true,
                embed: true
              }
            },
            imageControls: [
              "float-left",
              "float-right",
              "align-left",
              "align-center",
              "align-right",
              "link",
              "size",
              "remove"
            ],
            imageResizable: true,
            colors: [
              "#000000",
              "#333333",
              "#666666",
              "#999999",
              "#cccccc",
              "#ffffff",
              "#61a951",
              "#16a085",
              "#07a9fe",
              "#003ba5",
              "#8e44ad",
              "#f32784",
              "#c0392b",
              "#d35400",
              "#f39c12",
              "#fdda00"
            ],
            colorPicker: null,
            colorPickerTheme: "dark",
            colorPickerAutoHide: true,
            codeTabIndents: 2,
            headings: [
              "header-one",
              "header-two",
              "header-three",
              "header-four",
              "header-five",
              "header-six",
              "unstyled"
            ],
            textAligns: ["left", "center", "right", "justify"],
            textBackgroundColor: true,
            allowInsertLinkText: false,
            defaultLinkTarget: "",
            letterSpacings: [0, 1, 2, 3, 4, 5, 6],
            lineHeights: [1, 1.2, 1.5, 1.75, 2, 2.5, 3, 4],
            fontSizes: [
              12,
              14,
              16,
              18,
              20,
              24,
              28,
              30,
              32,
              36,
              40,
              48,
              56,
              64,
              72,
              96,
              120,
              144
            ],
            fontFamilies: [
              {
                name: "Araial",
                family: "Arial, Helvetica, sans-serif"
              },
              {
                name: "Georgia",
                family: "Georgia, serif"
              },
              {
                name: "Impact",
                family: "Impact, serif"
              },
              {
                name: "Monospace",
                family: '"Courier New", Courier, monospace'
              },
              {
                name: "Tahoma",
                family: 'tahoma, arial, "Hiragino Sans GB", 宋体, sans-serif'
              }
            ],
            converts: {
              unitExportFn: function unitExportFn(value, type) {
                return type === "line-height" ? value : "".concat(value, "px");
              }
            },
            emojis: [
              "🤣",
              "🙌",
              "💚",
              "💛",
              "👏",
              "😉",
              "💯",
              "💕",
              "💞",
              "💘",
              "💙",
              "💝",
              "🖤",
              "💜",
              "❤️",
              "😍",
              "😻",
              "💓",
              "💗",
              "😋",
              "😇",
              "😂",
              "😹",
              "😘",
              "💖",
              "😁",
              "😀",
              "🤞",
              "😲",
              "😄",
              "😊",
              "👍",
              "😌",
              "😃",
              "😅",
              "✌️",
              "🤗",
              "💋",
              "😗",
              "😽",
              "😚",
              "🤠",
              "😙",
              "😺",
              "👄",
              "😸",
              "😏",
              "😼",
              "👌",
              "😎",
              "😆",
              "😛",
              "🙏",
              "🤝",
              "🙂",
              "🤑",
              "😝",
              "😐",
              "😑",
              "🤤",
              "😤",
              "🙃",
              "🤡",
              "😶",
              "😪",
              "😴",
              "😵",
              "😓",
              "👊",
              "😦",
              "😷",
              "🤐",
              "😜",
              "🤓",
              "👻",
              "😥",
              "🙄",
              "🤔",
              "🤒",
              "🙁",
              "😔",
              "😯",
              "☹️",
              "☠️",
              "😰",
              "😩",
              "😖",
              "😕",
              "😒",
              "😣",
              "😢",
              "😮",
              "😿",
              "🤧",
              "😫",
              "🤥",
              "😞",
              "😬",
              "👎",
              "💀",
              "😳",
              "😨",
              "🤕",
              "🤢",
              "😱",
              "😭",
              "😠",
              "😈",
              "😧",
              "💔",
              "😟",
              "🙀",
              "💩",
              "👿",
              "😡",
              "😾",
              "🖕"
            ],
            stripPastedStyles: false,
            triggerChangeOnMount: true,
            className: "",
            style: {},
            controlBarClassName: "",
            controlBarStyle: {},
            contentClassName: "",
            contentStyle: {},
            draftProps: {},
            hooks: {},
            onChange: null,
            onFocus: null,
            onBlur: null,
            onTab: null,
            onDelete: null,
            onSave: null,
            fixPlaceholder: false
          };
          // EXTERNAL MODULE: ../node_modules/draft-js/lib/getFragmentFromSelection.js
          var getFragmentFromSelection = __webpack_require__(22);
          var getFragmentFromSelection_default = /*#__PURE__*/ __webpack_require__.n(
            getFragmentFromSelection
          );

          // EXTERNAL MODULE: external "draftjs-utils"
          var external_draftjs_utils_ = __webpack_require__(23);

          // CONCATENATED MODULE: ./configs/handlers.js

          var handlers_keyCommandHandlers = function keyCommandHandlers(
            command,
            editorState,
            editor
          ) {
            if (
              editor.editorProps.handleKeyCommand &&
              editor.editorProps.handleKeyCommand(
                command,
                editorState,
                editor
              ) === "handled"
            ) {
              return "handled";
            }

            if (command === "braft-save") {
              editor.editorProps.onSave &&
                editor.editorProps.onSave(editorState);
              return "handled";
            }

            var _editor$editorProps = editor.editorProps,
              controls = _editor$editorProps.controls,
              excludeControls = _editor$editorProps.excludeControls;
            var allowIndent =
              (controls.indexOf("text-indent") !== 0 ||
                controls.find(function(item) {
                  return item.key === "text-indent";
                })) &&
              excludeControls.indexOf("text-indent") === -1;
            var cursorStart = editorState.getSelection().getStartOffset();
            var cursorEnd = editorState.getSelection().getEndOffset();
            var cursorIsAtFirst = cursorStart === 0 && cursorEnd === 0;

            if (command === "backspace") {
              if (
                editor.editorProps.onDelete &&
                editor.editorProps.onDelete(editorState) === false
              ) {
                return "handled";
              }

              var blockType = external_braft_utils_[
                "ContentUtils"
              ].getSelectionBlockType(editorState);

              if (
                allowIndent &&
                cursorIsAtFirst &&
                blockType !== "code-block"
              ) {
                editor.setValue(
                  external_braft_utils_["ContentUtils"].decreaseSelectionIndent(
                    editorState
                  )
                );
              }
            }

            if (command === "tab") {
              var _blockType = external_braft_utils_[
                "ContentUtils"
              ].getSelectionBlockType(editorState);

              if (_blockType === "code-block") {
                editor.setValue(
                  external_braft_utils_["ContentUtils"].insertText(
                    editorState,
                    " ".repeat(editor.editorProps.codeTabIndents)
                  )
                );
                return "handled";
              } else if (
                _blockType === "ordered-list-item" ||
                _blockType === "unordered-list-item"
              ) {
                var newEditorState = external_draft_js_["RichUtils"].onTab(
                  event,
                  editorState,
                  4
                );

                if (newEditorState !== editorState) {
                  editor.setValue(newEditorState);
                }

                return "handled";
              } else if (
                _blockType !== "atomic" &&
                allowIndent &&
                cursorIsAtFirst
              ) {
                editor.setValue(
                  external_braft_utils_["ContentUtils"].increaseSelectionIndent(
                    editorState
                  )
                );
                return "handled";
              }
            }

            var nextEditorState = external_braft_utils_[
              "ContentUtils"
            ].handleKeyCommand(editorState, command);

            if (nextEditorState) {
              editor.setValue(nextEditorState);
              return "handled";
            }

            return "not-handled";
          };
          var handlers_returnHandlers = function returnHandlers(
            event,
            editorState,
            editor
          ) {
            if (
              editor.editorProps.handleReturn &&
              editor.editorProps.handleReturn(event, editorState, editor) ===
                "handled"
            ) {
              return "handled";
            }

            var currentBlock = external_braft_utils_[
              "ContentUtils"
            ].getSelectionBlock(editorState);
            var currentBlockType = currentBlock.getType();

            if (
              currentBlockType === "unordered-list-item" ||
              currentBlockType === "ordered-list-item"
            ) {
              if (currentBlock.getLength() === 0) {
                editor.setValue(
                  external_braft_utils_[
                    "ContentUtils"
                  ].toggleSelectionBlockType(editorState, "unstyled")
                );
                return "handled";
              }

              return "not-handled";
            } else if (currentBlockType === "code-block") {
              if (
                event.which === 13 &&
                (event.getModifierState("Shift") ||
                  event.getModifierState("Alt") ||
                  event.getModifierState("Control"))
              ) {
                editor.setValue(
                  external_braft_utils_[
                    "ContentUtils"
                  ].toggleSelectionBlockType(editorState, "unstyled")
                );
                return "handled";
              }

              return "not-handled";
            } else if (currentBlockType === "blockquote") {
              if (event.which === 13) {
                if (
                  event.getModifierState("Shift") ||
                  event.getModifierState("Alt") ||
                  event.getModifierState("Control")
                ) {
                  event.which = 0;
                } else {
                  editor.setValue(
                    external_draft_js_["RichUtils"].insertSoftNewline(
                      editorState
                    )
                  );
                  return "handled";
                }
              }
            }

            var nextEditorState = Object(
              external_draftjs_utils_["handleNewLine"]
            )(editorState, event);

            if (nextEditorState) {
              editor.setValue(nextEditorState);
              return "handled";
            }

            return "not-handled";
          };
          var beforeInputHandlers = function beforeInputHandlers(
            chars,
            editorState,
            editor
          ) {
            if (
              editor.editorProps.handleBeforeInput &&
              editor.editorProps.handleBeforeInput(
                chars,
                editorState,
                editor
              ) === "handled"
            ) {
              return "handled";
            }

            return "not-handled";
          };
          var handlers_compositionStartHandler = function compositionStartHandler(
            _,
            editor
          ) {
            var editorState = editor.state.editorState;
            var selectedBlocks = external_braft_utils_[
              "ContentUtils"
            ].getSelectedBlocks(editorState);

            if (selectedBlocks && selectedBlocks.length > 1) {
              var nextEditorState = external_draft_js_["EditorState"].push(
                editorState,
                external_draft_js_["Modifier"].removeRange(
                  editorState.getCurrentContent(),
                  editorState.getSelection(),
                  "backward"
                ),
                "remove-range"
              );
              editor.setValue(nextEditorState);
            }
          };
          var handlers_dropHandlers = function dropHandlers(
            selectionState,
            dataTransfer,
            editor
          ) {
            if (editor.editorProps.readOnly || editor.editorProps.disabled) {
              return "handled";
            }

            if (window && window.__BRAFT_DRAGING__IMAGE__) {
              var nextEditorState = external_draft_js_[
                "EditorState"
              ].forceSelection(editor.state.editorState, selectionState);
              nextEditorState = external_braft_utils_[
                "ContentUtils"
              ].insertMedias(nextEditorState, [
                window.__BRAFT_DRAGING__IMAGE__.mediaData
              ]);
              nextEditorState = external_braft_utils_[
                "ContentUtils"
              ].removeBlock(
                nextEditorState,
                window.__BRAFT_DRAGING__IMAGE__.block,
                nextEditorState.getSelection()
              );
              window.__BRAFT_DRAGING__IMAGE__ = null;
              editor.lockOrUnlockEditor(true);
              editor.setValue(nextEditorState);
              return "handled";
            } else if (!dataTransfer || !dataTransfer.getText()) {
              return "handled";
            }

            return "not-handled";
          };
          var handlers_handleFiles = function handleFiles(files, editor) {
            var _editor$constructor$d = objectSpread_default()(
                {},
                editor.constructor.defaultProps.media,
                editor.editorProps.media
              ),
              pasteImage = _editor$constructor$d.pasteImage,
              validateFn = _editor$constructor$d.validateFn,
              imagePasteLimit = _editor$constructor$d.imagePasteLimit;

            pasteImage &&
              files.slice(0, imagePasteLimit).forEach(function(file) {
                if (
                  file &&
                  file.type.indexOf("image") > -1 &&
                  editor.braftFinder
                ) {
                  var validateResult = validateFn ? validateFn(file) : true;

                  if (validateResult instanceof Promise) {
                    validateResult.then(function() {
                      editor.braftFinder.uploadImage(file, function(image) {
                        editor.isLiving &&
                          editor.setValue(
                            external_braft_utils_[
                              "ContentUtils"
                            ].insertMedias(editor.state.editorState, [image])
                          );
                      });
                    });
                  } else if (validateResult) {
                    editor.braftFinder.uploadImage(file, function(image) {
                      editor.isLiving &&
                        editor.setValue(
                          external_braft_utils_[
                            "ContentUtils"
                          ].insertMedias(editor.state.editorState, [image])
                        );
                    });
                  }
                }
              });

            if (files[0] && files[0].type.indexOf("image") > -1 && pasteImage) {
              return "handled";
            }

            return "not-handled";
          };
          var droppedFilesHandlers = function droppedFilesHandlers(
            selectionState,
            files,
            editor
          ) {
            if (
              editor.editorProps.handleDroppedFiles &&
              editor.editorProps.handleDroppedFiles(
                selectionState,
                files,
                editor
              ) === "handled"
            ) {
              return "handled";
            }

            return handlers_handleFiles(files, editor);
          };
          var pastedFilesHandlers = function pastedFilesHandlers(
            files,
            editor
          ) {
            if (
              editor.editorProps.handlePastedFiles &&
              editor.editorProps.handlePastedFiles(files, editor) === "handled"
            ) {
              return "handled";
            }

            return handlers_handleFiles(files, editor);
          };
          var handlers_copyHandlers = function copyHandlers(event, editor) {
            var blockMap = getFragmentFromSelection_default()(
              editor.state.editorState
            );

            if (blockMap && blockMap.toArray) {
              try {
                var tempContentState = external_draft_js_[
                  "ContentState"
                ].createFromBlockArray(blockMap.toArray());
                var tempEditorState = external_draft_js_[
                  "EditorState"
                ].createWithContent(tempContentState);
                var clipboardData =
                  event.clipboardData ||
                  window.clipboardData ||
                  event.originalEvent.clipboardData;
                tempEditorState.setConvertOptions(
                  editor.state.editorState.convertOptions
                );
                clipboardData.setData("text/html", tempEditorState.toHTML());
                clipboardData.setData("text/plain", tempEditorState.toText());
                event.preventDefault();
              } catch (error) {
                console.warn(error);
              }
            }
          };
          var handlers_pastedTextHandlers = function pastedTextHandlers(
            text,
            html,
            editorState,
            editor
          ) {
            if (
              editor.editorProps.handlePastedText &&
              editor.editorProps.handlePastedText(
                text,
                html,
                editorState,
                editor
              ) === "handled"
            ) {
              return "handled";
            }

            if (!html || editor.editorProps.stripPastedStyles) {
              return false;
            }

            var tempColors = external_braft_utils_[
              "ColorUtils"
            ].detectColorsFromHTMLString(html);
            editor.setState(
              {
                tempColors: toConsumableArray_default()(editor.state.tempColors)
                  .concat(toConsumableArray_default()(tempColors))
                  .filter(function(item) {
                    return editor.editorProps.colors.indexOf(item) === -1;
                  })
                  .filter(function(item, index, array) {
                    return array.indexOf(item) === index;
                  })
              },
              function() {
                editor.setValue(
                  external_braft_utils_["ContentUtils"].insertHTML(
                    editorState,
                    html,
                    "paste"
                  )
                );
              }
            );
            return "handled";
          };
          // CONCATENATED MODULE: ./helpers/extension.js

          // TODO
          // - block-style和atomic类型的扩展支持

          var extension_extensionControls = [];
          var extension_extensionDecorators = [];
          var extension_propInterceptors = [];
          var extension_extensionBlockRenderMaps = [];
          var extension_extensionBlockRendererFns = [];
          var extensionInlineStyleMaps = [];
          var extension_extensionInlineStyleFns = [];
          var extensionEntities = [];
          var inlineStyleImporters = [];
          var inlineStyleExporters = [];
          var blockImporters = [];
          var blockExporters = [];

          var filterByEditorId = function filterByEditorId(items, editorId) {
            if (!editorId) {
              return items
                .filter(function(item) {
                  return !item.includeEditors;
                })
                .map(function(item) {
                  return item.data;
                });
            }

            return items
              .map(function(item) {
                if (!item.includeEditors && !item.excludeEditors) {
                  return item.data;
                }

                if (item.includeEditors) {
                  return item.includeEditors.indexOf(editorId) !== -1
                    ? item.data
                    : false;
                }

                if (item.excludeEditors) {
                  return item.excludeEditors.indexOf(editorId) !== -1
                    ? false
                    : item.data;
                }

                return false;
              })
              .filter(function(item) {
                return item;
              });
          };

          var getPropInterceptors = function getPropInterceptors(editorId) {
            return filterByEditorId(extension_propInterceptors, editorId);
          };
          var getExtensionControls = function getExtensionControls(editorId) {
            return filterByEditorId(extension_extensionControls, editorId);
          };
          var getExtensionDecorators = function getExtensionDecorators(
            editorId
          ) {
            return filterByEditorId(extension_extensionDecorators, editorId);
          };
          var getExtensionBlockRenderMaps = function getExtensionBlockRenderMaps(
            editorId
          ) {
            return filterByEditorId(
              extension_extensionBlockRenderMaps,
              editorId
            );
          };
          var getExtensionBlockRendererFns = function getExtensionBlockRendererFns(
            editorId
          ) {
            return filterByEditorId(
              extension_extensionBlockRendererFns,
              editorId
            );
          };
          var getExtensionInlineStyleMap = function getExtensionInlineStyleMap(
            editorId
          ) {
            var inlineStyleMap = {};
            filterByEditorId(extensionInlineStyleMaps, editorId).forEach(
              function(item) {
                inlineStyleMap[item.inlineStyleName] = item.styleMap;
              }
            );
            return inlineStyleMap;
          };
          var getExtensionInlineStyleFns = function getExtensionInlineStyleFns(
            editorId
          ) {
            return filterByEditorId(
              extension_extensionInlineStyleFns,
              editorId
            );
          };
          var compositeStyleImportFn = function compositeStyleImportFn(
            styleImportFn,
            editorId
          ) {
            return function(nodeName, node, style) {
              filterByEditorId(inlineStyleImporters, editorId).forEach(function(
                styleImporter
              ) {
                if (
                  styleImporter.importer &&
                  styleImporter.importer(nodeName, node)
                ) {
                  style = style.add(styleImporter.inlineStyleName);
                }
              });
              return styleImportFn
                ? styleImportFn(nodeName, node, style)
                : style;
            };
          };
          var compositeStyleExportFn = function compositeStyleExportFn(
            styleExportFn,
            editorId
          ) {
            return function(style) {
              style = style.toUpperCase();
              var result = styleExportFn ? styleExportFn(style) : undefined;

              if (result) {
                return result;
              }

              filterByEditorId(inlineStyleExporters, editorId).find(function(
                item
              ) {
                if (item.inlineStyleName === style) {
                  result = item.exporter;
                  return true;
                }
              });
              return result;
            };
          };
          var compositeEntityImportFn = function compositeEntityImportFn(
            entityImportFn,
            editorId
          ) {
            return function(nodeName, node, createEntity, source) {
              var result = entityImportFn
                ? entityImportFn(nodeName, node, createEntity, source)
                : null;

              if (result) {
                return result;
              }

              filterByEditorId(extensionEntities, editorId).find(function(
                entityItem
              ) {
                var matched = entityItem.importer
                  ? entityItem.importer(nodeName, node, source)
                  : null;
                matched &&
                  (result = createEntity(
                    entityItem.entityType,
                    matched.mutability || "MUTABLE",
                    matched.data || {}
                  ));
                return !!matched;
              });
              return result;
            };
          };
          var compositeEntityExportFn = function compositeEntityExportFn(
            entityExportFn,
            editorId
          ) {
            return function(entity, originalText) {
              var result = entityExportFn
                ? entityExportFn(entity, originalText)
                : undefined;

              if (result) {
                return result;
              }

              var entityType = entity.type.toUpperCase();
              filterByEditorId(extensionEntities, editorId).find(function(
                entityItem
              ) {
                if (entityItem.entityType === entityType) {
                  result = entityItem.exporter
                    ? entityItem.exporter(entity, originalText)
                    : undefined;
                  return true;
                }
              });
              return result;
            };
          };
          var compositeBlockImportFn = function compositeBlockImportFn(
            blockImportFn,
            editorId
          ) {
            return function(nodeName, node, source) {
              var result = blockImportFn
                ? blockImportFn(nodeName, node, source)
                : null;

              if (result) {
                return result;
              }

              filterByEditorId(blockImporters, editorId).find(function(
                blockImporter
              ) {
                var matched = blockImporter.importer
                  ? blockImporter.importer(nodeName, node, source)
                  : undefined;
                matched && (result = matched);
                return !!matched;
              });
              return result;
            };
          };
          var compositeBlockExportFn = function compositeBlockExportFn(
            blockExportFn,
            editorId
          ) {
            return function(contentState, block) {
              var result = blockExportFn
                ? blockExportFn(contentState, block)
                : null;

              if (result) {
                return result;
              }

              filterByEditorId(blockExporters, editorId).find(function(
                blockExporter
              ) {
                var matched = blockExporter.exporter
                  ? blockExporter.exporter(contentState, block)
                  : undefined;
                matched && (result = matched);
                return !!matched;
              });
              return result;
            };
          };

          var extension_useExtension = function useExtension(extension) {
            if (extension instanceof Array) {
              extension.forEach(useExtension);
              return false;
            }

            if (
              !extension ||
              !extension.type ||
              typeof extension.type !== "string"
            ) {
              return false;
            }

            var includeEditors = extension.includeEditors,
              excludeEditors = extension.excludeEditors;

            if (extension.type === "control") {
              extension_extensionControls.push({
                includeEditors: includeEditors,
                excludeEditors: excludeEditors,
                data: extension.control
              });
            } else if (extension.type === "inline-style") {
              var inlineStyleName = extension.name.toUpperCase();

              if (extension.control) {
                extension_extensionControls.push({
                  includeEditors: includeEditors,
                  excludeEditors: excludeEditors,
                  data: objectSpread_default()(
                    {
                      key: inlineStyleName,
                      type: "inline-style",
                      command: inlineStyleName
                    },
                    extension.control
                  )
                });
              }

              if (extension.style) {
                extensionInlineStyleMaps.push({
                  includeEditors: includeEditors,
                  excludeEditors: excludeEditors,
                  data: {
                    inlineStyleName: inlineStyleName,
                    styleMap: extension.style
                  }
                });
              }

              if (extension.styleFn) {
                extension_extensionInlineStyleFns.push({
                  includeEditors: includeEditors,
                  excludeEditors: excludeEditors,
                  data: {
                    inlineStyleName: inlineStyleName,
                    styleFn: extension.styleFn
                  }
                });
              }

              if (extension.importer) {
                inlineStyleImporters.push({
                  includeEditors: includeEditors,
                  excludeEditors: excludeEditors,
                  data: {
                    inlineStyleName: inlineStyleName,
                    importer: extension.importer
                  }
                });
              }

              inlineStyleExporters.push({
                includeEditors: includeEditors,
                excludeEditors: excludeEditors,
                data: {
                  inlineStyleName: inlineStyleName,
                  exporter: extension.exporter
                    ? extension.exporter(extension)
                    : external_react_default.a.createElement("span", {
                        style: extension.style
                      })
                }
              });
            } else if (extension.type === "block-style");
            else if (extension.type === "entity") {
              var entityType = extension.name.toUpperCase();

              if (extension.control) {
                extension_extensionControls.push({
                  includeEditors: includeEditors,
                  excludeEditors: excludeEditors,
                  data:
                    typeof extension.control === "function"
                      ? extension.control
                      : objectSpread_default()(
                          {
                            key: entityType,
                            type: "entity",
                            command: entityType,
                            data: {
                              mutability: extension.mutability || "MUTABLE",
                              data: extension.data || {}
                            }
                          },
                          extension.control
                        )
                });
              }

              extensionEntities.push({
                includeEditors: includeEditors,
                excludeEditors: excludeEditors,
                data: {
                  entityType: entityType,
                  importer: extension.importer,
                  exporter: extension.exporter
                }
              });
              extension_extensionDecorators.push({
                includeEditors: includeEditors,
                excludeEditors: excludeEditors,
                data: {
                  type: "entity",
                  decorator: {
                    key: entityType,
                    component: extension.component
                  }
                }
              });
            } else if (extension.type === "block") {
              var blockType = extension.name;

              if (extension.renderMap) {
                extension_extensionBlockRenderMaps.push({
                  includeEditors: includeEditors,
                  excludeEditors: excludeEditors,
                  data: {
                    blockType: blockType,
                    renderMap: extension.renderMap
                  }
                });
              }

              if (extension.rendererFn) {
                extension_extensionBlockRendererFns.push({
                  includeEditors: includeEditors,
                  excludeEditors: excludeEditors,
                  data: {
                    blockType: blockType,
                    rendererFn: extension.rendererFn
                  }
                });
              }

              if (extension.importer) {
                blockImporters.push({
                  includeEditors: includeEditors,
                  excludeEditors: excludeEditors,
                  data: {
                    blockType: blockType,
                    importer: extension.importer
                  }
                });
              }

              if (extension.exporter) {
                blockExporters.push({
                  includeEditors: includeEditors,
                  excludeEditors: excludeEditors,
                  data: {
                    blockType: blockType,
                    exporter: extension.exporter
                  }
                });
              }
            } else if (extension.type === "atomic");
            else if (extension.type === "decorator") {
              var decorator = extension.decorator;

              if (decorator && decorator.strategy && decorator.component) {
                extension_extensionDecorators.push({
                  includeEditors: includeEditors,
                  excludeEditors: excludeEditors,
                  data: {
                    type: "strategy",
                    decorator: decorator
                  }
                });
              } else if (decorator && decorator.getDecorations) {
                extension_extensionDecorators.push({
                  includeEditors: includeEditors,
                  excludeEditors: excludeEditors,
                  data: {
                    type: "class",
                    decorator: decorator
                  }
                });
              }
            } else if (extension.type === "prop-interception") {
              extension_propInterceptors.push({
                includeEditors: includeEditors,
                excludeEditors: excludeEditors,
                data: extension.interceptor
              });
            }
          };

          var createExtensibleEditor = function createExtensibleEditor(
            BraftEditor
          ) {
            BraftEditor.use = extension_useExtension;
            return BraftEditor;
          };
          // CONCATENATED MODULE: ./renderers/block/blockRenderMap.js

          /* harmony default export */ var block_blockRenderMap = function(
            props,
            blockRenderMap
          ) {
            var customBlockRenderMap = Object(external_immutable_["Map"])({
              atomic: {
                element: ""
              },
              "code-block": {
                element: "code",
                wrapper: external_react_default.a.createElement("pre", {
                  className: "braft-code-block"
                })
              }
            });

            try {
              var extensionBlockRenderMaps = getExtensionBlockRenderMaps(
                props.editorId
              );
              customBlockRenderMap = extensionBlockRenderMaps.reduce(function(
                customBlockRenderMap,
                item
              ) {
                return customBlockRenderMap.merge(
                  typeof item.renderMap === "function"
                    ? item.renderMap(props)
                    : item.renderMap
                );
              },
              customBlockRenderMap);

              if (blockRenderMap) {
                if (typeof blockRenderMap === "function") {
                  customBlockRenderMap = customBlockRenderMap.merge(
                    blockRenderMap(props)
                  );
                } else {
                  customBlockRenderMap = customBlockRenderMap.merge(
                    blockRenderMap
                  );
                }
              }

              customBlockRenderMap = external_draft_js_[
                "DefaultDraftBlockRenderMap"
              ].merge(customBlockRenderMap);
            } catch (error) {
              console.warn(error);
            }

            return customBlockRenderMap;
          };
          // EXTERNAL MODULE: ../node_modules/@babel/runtime/helpers/extends.js
          var helpers_extends = __webpack_require__(11);
          var extends_default = /*#__PURE__*/ __webpack_require__.n(
            helpers_extends
          );

          // EXTERNAL MODULE: ../node_modules/@babel/runtime/helpers/slicedToArray.js
          var slicedToArray = __webpack_require__(24);
          var slicedToArray_default = /*#__PURE__*/ __webpack_require__.n(
            slicedToArray
          );

          // EXTERNAL MODULE: ./renderers/atomics/Image/style.scss
          var Image_style = __webpack_require__(45);

          // EXTERNAL MODULE: ./components/common/Switch/style.scss
          var Switch_style = __webpack_require__(46);

          // CONCATENATED MODULE: ./components/common/Switch/index.jsx

          /* harmony default export */ var Switch = function(props) {
            var active = props.active,
              _onClick = props.onClick,
              className = props.className;
            return external_react_default.a.createElement("div", {
              onClick: function onClick() {
                return _onClick();
              },
              className: "bf-switch " + className + (active ? " active" : "")
            });
          };
          // CONCATENATED MODULE: ./configs/controls.js

          /* harmony default export */ var configs_controls = function(
            lang,
            editor
          ) {
            return [
              {
                key: "undo",
                title: lang.controls.undo,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-undo"
                }),
                type: "editor-method",
                command: "undo"
              },
              {
                key: "redo",
                title: lang.controls.redo,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-redo"
                }),
                type: "editor-method",
                command: "redo"
              },
              {
                key: "remove-styles",
                title: lang.controls.removeStyles,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-format_clear"
                }),
                type: "editor-method",
                command: "removeSelectionInlineStyles"
              },
              {
                key: "hr",
                title: lang.controls.hr,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-hr"
                }),
                type: "editor-method",
                command: "insertHorizontalLine"
              },
              {
                key: "bold",
                title: lang.controls.bold,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-bold"
                }),
                type: "inline-style",
                command: "bold"
              },
              {
                key: "italic",
                title: lang.controls.italic,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-italic"
                }),
                type: "inline-style",
                command: "italic"
              },
              {
                key: "underline",
                title: lang.controls.underline,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-underlined"
                }),
                type: "inline-style",
                command: "underline"
              },
              {
                key: "strike-through",
                title: lang.controls.strikeThrough,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-strikethrough"
                }),
                type: "inline-style",
                command: "strikethrough"
              },
              {
                key: "superscript",
                title: lang.controls.superScript,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-superscript"
                }),
                type: "inline-style",
                command: "superscript"
              },
              {
                key: "subscript",
                title: lang.controls.subScript,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-subscript"
                }),
                type: "inline-style",
                command: "subscript"
              },
              {
                key: "headings",
                title: lang.controls.headings,
                type: "headings"
              },
              {
                key: "blockquote",
                title: lang.controls.blockQuote,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-quote"
                }),
                type: "block-type",
                command: "blockquote"
              },
              {
                key: "code",
                title: lang.controls.code,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-code"
                }),
                type: "block-type",
                command: "code-block"
              },
              {
                key: "list-ul",
                title: lang.controls.unorderedList,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-list"
                }),
                type: "block-type",
                command: "unordered-list-item"
              },
              {
                key: "list-ol",
                title: lang.controls.orderedList,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-list-numbered"
                }),
                type: "block-type",
                command: "ordered-list-item"
              },
              {
                key: "link",
                title: lang.controls.link,
                type: "link"
              },
              {
                key: "text-color",
                title: lang.controls.color,
                type: "text-color"
              },
              {
                key: "line-height",
                title: lang.controls.lineHeight,
                type: "line-height"
              },
              {
                key: "letter-spacing",
                title: lang.controls.letterSpacing,
                type: "letter-spacing"
              },
              {
                key: "text-indent",
                title: lang.controls.textIndent,
                type: "text-indent"
              },
              {
                key: "font-size",
                title: lang.controls.fontSize,
                type: "font-size"
              },
              {
                key: "font-family",
                title: lang.controls.fontFamily,
                type: "font-family"
              },
              {
                key: "text-align",
                title: lang.controls.textAlign,
                type: "text-align"
              },
              {
                key: "media",
                title: lang.controls.media,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-media"
                }),
                type: "media"
              },
              {
                key: "emoji",
                title: lang.controls.emoji,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-emoji"
                }),
                type: "emoji"
              },
              {
                key: "clear",
                title: lang.controls.clear,
                text: external_react_default.a.createElement("i", {
                  className: "bfi-clear_all"
                }),
                type: "editor-method",
                command: "clearEditorContent"
              },
              {
                key: "fullscreen",
                title: editor.state.isFullscreen
                  ? lang.controls.exitFullscreen
                  : lang.controls.fullscreen,
                text: external_react_default.a.createElement("i", {
                  className: editor.state.isFullscreen
                    ? "bfi-fullscreen-exit"
                    : "bfi-fullscreen"
                }),
                type: "editor-method",
                command: "toggleFullscreen"
              },
              {
                key: "modal",
                type: "modal"
              },
              {
                key: "button",
                type: "button"
              },
              {
                key: "dropdown",
                type: "dropdown"
              },
              {
                key: "component",
                type: "component"
              }
            ];
          };
          var imageControlItems = {
            "float-left": {
              text: external_react_default.a.createElement(
                "span",
                {
                  "data-float": "left"
                },
                "\uE91E"
              ),
              command: "setImageFloat|left"
            },
            "float-right": {
              text: external_react_default.a.createElement(
                "span",
                {
                  "data-float": "right"
                },
                "\uE914"
              ),
              command: "setImageFloat|right"
            },
            "align-left": {
              text: external_react_default.a.createElement(
                "span",
                {
                  "data-align": "left"
                },
                "\uE027"
              ),
              command: "setImageAlignment|left"
            },
            "align-center": {
              text: external_react_default.a.createElement(
                "span",
                {
                  "data-align": "center"
                },
                "\uE028"
              ),
              command: "setImageAlignment|center"
            },
            "align-right": {
              text: external_react_default.a.createElement(
                "span",
                {
                  "data-align": "right"
                },
                "\uE029"
              ),
              command: "setImageAlignment|right"
            },
            size: {
              text: external_react_default.a.createElement(
                "span",
                null,
                "\uE3C2"
              ),
              command: "toggleSizeEditor"
            },
            link: {
              text: external_react_default.a.createElement(
                "span",
                null,
                "\uE91A"
              ),
              command: "toggleLinkEditor"
            },
            remove: {
              text: external_react_default.a.createElement(
                "span",
                null,
                "\uE9AC"
              ),
              command: "removeImage"
            }
          };
          // CONCATENATED MODULE: ./renderers/atomics/Image/index.jsx

          var Image_Image =
            /*#__PURE__*/
            (function(_React$Component) {
              inherits_default()(Image, _React$Component);

              function Image() {
                var _getPrototypeOf2;

                var _this;

                classCallCheck_default()(this, Image);

                for (
                  var _len = arguments.length, args = new Array(_len), _key = 0;
                  _key < _len;
                  _key++
                ) {
                  args[_key] = arguments[_key];
                }

                _this = possibleConstructorReturn_default()(
                  this,
                  (_getPrototypeOf2 = getPrototypeOf_default()(
                    Image
                  )).call.apply(_getPrototypeOf2, [this].concat(args))
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "state",
                  {
                    toolbarVisible: false,
                    toolbarOffset: 0,
                    linkEditorVisible: false,
                    sizeEditorVisible: false,
                    tempLink: null,
                    tempWidth: null,
                    tempHeight: null
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "initialLeft",
                  void 0
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "initialTop",
                  void 0
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "initialWidth",
                  void 0
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "initialHeight",
                  void 0
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "reSizeType",
                  void 0
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "changeSize",
                  function(e) {
                    var type = _this.reSizeType;

                    if (!_this.initialLeft) {
                      _this.initialLeft = e.screenX;
                      _this.initialTop = e.screenY;
                    }

                    if (type === "rightbottom") {
                      _this.initialHeight += e.screenY - _this.initialTop;
                      _this.initialWidth += e.screenX - _this.initialLeft;
                    }

                    if (type === "leftbottom") {
                      _this.initialHeight += e.screenY - _this.initialTop;
                      _this.initialWidth += -e.screenX + _this.initialLeft;
                    }

                    _this.initialLeft = e.screenX;
                    _this.initialTop = e.screenY;
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "moveImage",
                  function(e) {
                    _this.changeSize(e);

                    _this.setState({
                      tempWidth: Math.abs(_this.initialWidth),
                      tempHeight: Math.abs(_this.initialHeight)
                    });
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "upImage",
                  function() {
                    _this.confirmImageSize();

                    document.removeEventListener("mousemove", _this.moveImage);
                    document.removeEventListener("mouseup", _this.upImage);
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "repareChangeSize",
                  function(type) {
                    return function(e) {
                      _this.reSizeType = type;

                      var imageRect = _this.imageElement.getBoundingClientRect();

                      _this.initialLeft = _this.initialTop = 0;
                      _this.initialWidth = imageRect.width;
                      _this.initialHeight = imageRect.height;
                      e.preventDefault();
                      document.addEventListener("mousemove", _this.moveImage);
                      document.addEventListener("mouseup", _this.upImage);
                    };
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "preventDragEvent",
                  function(event) {
                    event.stopPropagation();
                    event.preventDefault();
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleDragStart",
                  function() {
                    if (
                      _this.props.editor.editorProps.readOnly ||
                      _this.props.editor.editorProps.disabled
                    ) {
                      return false;
                    }

                    window.__BRAFT_DRAGING__IMAGE__ = {
                      block: _this.props.block,
                      mediaData: objectSpread_default()(
                        {
                          type: "IMAGE"
                        },
                        _this.props.mediaData
                      )
                    };

                    _this.setState(
                      {
                        toolbarVisible: false
                      },
                      function() {
                        _this.unlockEditor();
                      }
                    );

                    return true;
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleDragEnd",
                  function() {
                    window.__BRAFT_DRAGING__IMAGE__ = null;
                    return false;
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "executeCommand",
                  function(command) {
                    if (typeof command === "string") {
                      var _command$split = command.split("|"),
                        _command$split2 = slicedToArray_default()(
                          _command$split,
                          2
                        ),
                        method = _command$split2[0],
                        param = _command$split2[1];

                      _this[method] && _this[method](param);
                    } else if (typeof command === "function") {
                      command(
                        _this.props.block,
                        _this.props.mediaData,
                        _this.props.editor.getValue()
                      );
                    }
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "removeImage",
                  function() {
                    _this.props.editor.setValue(
                      external_braft_utils_["ContentUtils"].removeBlock(
                        _this.props.editor.getValue(),
                        _this.props.block
                      )
                    );

                    _this.unlockEditor();
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "toggleLinkEditor",
                  function() {
                    _this.setState({
                      linkEditorVisible: !_this.state.linkEditorVisible,
                      sizeEditorVisible: false
                    });
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "toggleSizeEditor",
                  function() {
                    _this.setState({
                      linkEditorVisible: false,
                      sizeEditorVisible: !_this.state.sizeEditorVisible
                    });
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleLinkInputKeyDown",
                  function(e) {
                    if (e.keyCode === 13) {
                      _this.confirmImageLink();
                    } else {
                      return;
                    }
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "setImageLink",
                  function(e) {
                    _this.setState({
                      tempLink: e.currentTarget.value
                    });

                    return;
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "confirmImageLink",
                  function() {
                    var link = _this.state.tempLink;

                    var hookReturns = _this.props.hooks(
                      "set-image-link",
                      link
                    )(link);

                    if (hookReturns === false) {
                      return false;
                    }

                    if (typeof hookReturns === "string") {
                      link = hookReturns;
                    }

                    if (link !== null) {
                      _this.props.editor.setValue(
                        external_braft_utils_["ContentUtils"].setMediaData(
                          _this.props.editor.getValue(),
                          _this.props.entityKey,
                          {
                            link: link
                          }
                        )
                      );

                      window.setImmediate(_this.props.editor.forceRender);
                    }
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleSizeInputKeyDown",
                  function(e) {
                    if (e.keyCode === 13) {
                      _this.confirmImageSize();
                    } else {
                      return;
                    }
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "setImageWidth",
                  function(_ref) {
                    var currentTarget = _ref.currentTarget;
                    var value = currentTarget.value;
                    value && !isNaN(value) && (value = value + "px");

                    _this.setState({
                      tempWidth: value
                    });

                    return;
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "setImageHeight",
                  function(_ref2) {
                    var currentTarget = _ref2.currentTarget;
                    var value = currentTarget.value;
                    value && !isNaN(value) && (value = value + "px");

                    _this.setState({
                      tempHeight: value
                    });

                    return;
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "confirmImageSize",
                  function() {
                    var _this$state = _this.state,
                      width = _this$state.tempWidth,
                      height = _this$state.tempHeight;
                    var newImageSize = {};
                    width !== null && (newImageSize.width = width);
                    height !== null && (newImageSize.height = height);

                    var hookReturns = _this.props.hooks(
                      "set-image-size",
                      newImageSize
                    )(newImageSize);

                    if (hookReturns === false) {
                      return false;
                    }

                    if (
                      hookReturns &&
                      (hookReturns.width || hookReturns.height)
                    ) {
                      newImageSize = hookReturns;
                    }

                    _this.props.editor.setValue(
                      external_braft_utils_["ContentUtils"].setMediaData(
                        _this.props.editor.getValue(),
                        _this.props.entityKey,
                        newImageSize
                      )
                    );

                    window.setImmediate(_this.props.editor.forceRender);
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "setImageFloat",
                  function(float) {
                    var hookReturns = _this.props.hooks(
                      "set-image-float",
                      float
                    )(float);

                    if (hookReturns === false) {
                      return false;
                    }

                    if (typeof hookReturns === "string") {
                      float = hookReturns;
                    }

                    _this.props.editor.setValue(
                      external_braft_utils_["ContentUtils"].setMediaPosition(
                        _this.props.editor.getValue(),
                        _this.props.block,
                        {
                          float: float
                        }
                      )
                    );

                    _this.unlockEditor();
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "setImageAlignment",
                  function(alignment) {
                    var hookReturns = _this.props.hooks(
                      "set-image-alignment",
                      alignment
                    )(alignment);

                    if (hookReturns === false) {
                      return false;
                    }

                    if (typeof hookReturns === "string") {
                      alignment = hookReturns;
                    }

                    _this.props.editor.setValue(
                      external_braft_utils_["ContentUtils"].setMediaPosition(
                        _this.props.editor.getValue(),
                        _this.props.block,
                        {
                          alignment: alignment
                        }
                      )
                    );

                    _this.unlockEditor();
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "showToolbar",
                  function(event) {
                    if (
                      _this.props.editor.editorProps.readOnly ||
                      _this.props.editor.editorProps.disabled
                    ) {
                      return false;
                    }

                    event.preventDefault();

                    if (!_this.state.toolbarVisible) {
                      _this.setState(
                        {
                          toolbarVisible: true
                        },
                        function() {
                          _this.lockEditor();

                          _this.setState({
                            toolbarOffset: _this.calcToolbarOffset()
                          });
                        }
                      );
                    }
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "hideToolbar",
                  function(event) {
                    event.preventDefault();

                    _this.setState(
                      {
                        toolbarVisible: false
                      },
                      function() {
                        _this.unlockEditor(); // this.props.editor.requestFocus()
                      }
                    );
                  }
                );

                return _this;
              }

              createClass_default()(Image, [
                {
                  key: "render",
                  value: function render() {
                    var _this2 = this;

                    var _this$props = this.props,
                      mediaData = _this$props.mediaData,
                      language = _this$props.language,
                      imageControls = _this$props.imageControls,
                      imageResizable = _this$props.imageResizable;
                    var _this$state2 = this.state,
                      toolbarVisible = _this$state2.toolbarVisible,
                      toolbarOffset = _this$state2.toolbarOffset,
                      linkEditorVisible = _this$state2.linkEditorVisible,
                      sizeEditorVisible = _this$state2.sizeEditorVisible,
                      tempWidth = _this$state2.tempWidth,
                      tempHeight = _this$state2.tempHeight;
                    var blockData = this.props.block.getData();
                    var float = blockData.get("float");
                    var alignment = blockData.get("alignment");
                    var url = mediaData.url,
                      link = mediaData.link,
                      link_target = mediaData.link_target,
                      width = mediaData.width,
                      height = mediaData.height,
                      meta = mediaData.meta;
                    var imageStyles = {};
                    var clearFix = false;

                    if (float) {
                      alignment = null;
                    } else if (alignment === "left") {
                      imageStyles.float = "left";
                      clearFix = true;
                    } else if (alignment === "right") {
                      imageStyles.float = "right";
                      clearFix = true;
                    } else if (alignment === "center") {
                      imageStyles.textAlign = "center";
                    } else {
                      imageStyles.float = "left";
                      clearFix = true;
                    }

                    var renderedControlItems = imageControls.map(function(
                      item,
                      index
                    ) {
                      if (typeof item === "string" && imageControlItems[item]) {
                        return external_react_default.a.createElement(
                          "a",
                          {
                            className: item === "link" && link ? "active" : "",
                            key: index,
                            onClick: function onClick() {
                              return _this2.executeCommand(
                                imageControlItems[item].command
                              );
                            }
                          },
                          imageControlItems[item].text
                        );
                      } else if (item && (item.render || item.text)) {
                        return item.render
                          ? item.render(mediaData, _this2.props.block)
                          : external_react_default.a.createElement(
                              "a",
                              {
                                key: index,
                                onClick: function onClick() {
                                  return (
                                    item.onClick &&
                                    _this2.executeCommand(item.onClick)
                                  );
                                }
                              },
                              item.text
                            );
                      } else {
                        return null;
                      }
                    });
                    return external_react_default.a.createElement(
                      "div",
                      {
                        className: "bf-media"
                      },
                      external_react_default.a.createElement(
                        "div",
                        {
                          style: imageStyles,
                          draggable: true,
                          onMouseEnter: this.showToolbar,
                          onMouseMove: this.showToolbar,
                          onMouseLeave: this.hideToolbar,
                          onDragStart: this.handleDragStart,
                          onDragEnd: this.handleDragEnd,
                          ref: function ref(instance) {
                            return (_this2.mediaEmbederInstance = instance);
                          },
                          className: "bf-image"
                        },
                        toolbarVisible
                          ? external_react_default.a.createElement(
                              "div",
                              {
                                style: {
                                  marginLeft: toolbarOffset
                                },
                                ref: function ref(instance) {
                                  return (_this2.toolbarElement = instance);
                                },
                                "data-float": float,
                                "data-align": alignment,
                                className: "bf-media-toolbar"
                              },
                              linkEditorVisible
                                ? external_react_default.a.createElement(
                                    "div",
                                    {
                                      className: "bf-image-link-editor"
                                    },
                                    external_react_default.a.createElement(
                                      "div",
                                      {
                                        className: "editor-input-group"
                                      },
                                      external_react_default.a.createElement(
                                        "input",
                                        {
                                          type: "text",
                                          placeholder:
                                            language.linkEditor
                                              .inputWithEnterPlaceHolder,
                                          onKeyDown: this
                                            .handleLinkInputKeyDown,
                                          onChange: this.setImageLink,
                                          defaultValue: link
                                        }
                                      ),
                                      external_react_default.a.createElement(
                                        "button",
                                        {
                                          type: "button",
                                          onClick: this.confirmImageLink
                                        },
                                        language.base.confirm
                                      )
                                    ),
                                    external_react_default.a.createElement(
                                      "div",
                                      {
                                        className: "switch-group"
                                      },
                                      external_react_default.a.createElement(
                                        Switch,
                                        {
                                          active: link_target === "_blank",
                                          onClick: function onClick() {
                                            return _this2.setImageLinkTarget(
                                              link_target
                                            );
                                          }
                                        }
                                      ),
                                      external_react_default.a.createElement(
                                        "label",
                                        null,
                                        language.linkEditor.openInNewWindow
                                      )
                                    )
                                  )
                                : null,
                              sizeEditorVisible
                                ? external_react_default.a.createElement(
                                    "div",
                                    {
                                      className: "bf-image-size-editor"
                                    },
                                    external_react_default.a.createElement(
                                      "div",
                                      {
                                        className: "editor-input-group"
                                      },
                                      external_react_default.a.createElement(
                                        "input",
                                        {
                                          type: "text",
                                          placeholder: language.base.width,
                                          onKeyDown: this
                                            .handleSizeInputKeyDown,
                                          onChange: this.setImageWidth,
                                          defaultValue: width
                                        }
                                      ),
                                      external_react_default.a.createElement(
                                        "input",
                                        {
                                          type: "text",
                                          placeholder: language.base.height,
                                          onKeyDown: this
                                            .handleSizeInputKeyDown,
                                          onChange: this.setImageHeight,
                                          defaultValue: height
                                        }
                                      ),
                                      external_react_default.a.createElement(
                                        "button",
                                        {
                                          type: "button",
                                          onClick: this.confirmImageSize
                                        },
                                        language.base.confirm
                                      )
                                    )
                                  )
                                : null,
                              renderedControlItems,
                              external_react_default.a.createElement("i", {
                                style: {
                                  marginLeft: toolbarOffset * -1
                                },
                                className: "bf-media-toolbar-arrow"
                              })
                            )
                          : null,
                        external_react_default.a.createElement(
                          "div",
                          {
                            style: {
                              position: "relative",
                              width: "".concat(width, "px"),
                              height: "".concat(height, "px"),
                              display: "inline-block"
                            }
                          },
                          external_react_default.a.createElement(
                            "img",
                            extends_default()(
                              {
                                ref: function ref(instance) {
                                  return (_this2.imageElement = instance);
                                },
                                src: url,
                                width: width,
                                height: height
                              },
                              meta
                            )
                          ),
                          toolbarVisible && imageResizable
                            ? external_react_default.a.createElement("div", {
                                className: "bf-csize-icon right-bottom",
                                onMouseDown: this.repareChangeSize(
                                  "rightbottom"
                                )
                              })
                            : null,
                          toolbarVisible && imageResizable
                            ? external_react_default.a.createElement("div", {
                                className: "bf-csize-icon left-bottom",
                                onMouseDown: this.repareChangeSize("leftbottom")
                              })
                            : null,
                          external_react_default.a.createElement("div", {
                            className: "bf-pre-csize ".concat(this.reSizeType),
                            style: {
                              width: "".concat(tempWidth, "px"),
                              height: "".concat(tempHeight, "px")
                            }
                          })
                        )
                      ),
                      clearFix &&
                        external_react_default.a.createElement("div", {
                          className: "clearfix",
                          style: {
                            clear: "both",
                            height: 0,
                            lineHeight: 0,
                            float: "none"
                          }
                        })
                    );
                  }
                },
                {
                  key: "lockEditor",
                  value: function lockEditor() {
                    this.props.editor.lockOrUnlockEditor(true);
                  }
                },
                {
                  key: "unlockEditor",
                  value: function unlockEditor() {
                    this.props.editor.lockOrUnlockEditor(false);
                  }
                },
                {
                  key: "calcToolbarOffset",
                  value: function calcToolbarOffset() {
                    var _this$props2 = this.props,
                      getContainerNode = _this$props2.getContainerNode,
                      containerNode = _this$props2.containerNode;
                    var container = getContainerNode
                      ? getContainerNode()
                      : containerNode;

                    if (!container) {
                      return 0;
                    }

                    var viewRect = container
                      .querySelector(".bf-content")
                      .getBoundingClientRect();
                    var toolbarRect = this.toolbarElement.getBoundingClientRect();
                    var imageRect = this.imageElement.getBoundingClientRect();
                    var right =
                      viewRect.right -
                      (imageRect.right -
                        imageRect.width / 2 +
                        toolbarRect.width / 2);
                    var left =
                      imageRect.left +
                      imageRect.width / 2 -
                      toolbarRect.width / 2 -
                      viewRect.left;

                    if (right < 10) {
                      return right - 10;
                    } else if (left < 10) {
                      return left * -1 + 10;
                    } else {
                      return 0;
                    }
                  }
                },
                {
                  key: "setImageLinkTarget",
                  value: function setImageLinkTarget(link_target) {
                    var hookReturns = this.props.hooks(
                      "set-image-link-target",
                      link_target
                    )(link_target);

                    if (hookReturns === false) {
                      return false;
                    }

                    if (typeof hookReturns === "string") {
                      link_target = hookReturns;
                    }

                    link_target = link_target === "_blank" ? "" : "_blank";
                    this.props.editor.setValue(
                      external_braft_utils_["ContentUtils"].setMediaData(
                        this.props.editor.getValue(),
                        this.props.entityKey,
                        {
                          link_target: link_target
                        }
                      )
                    );
                    window.setImmediate(this.props.editor.forceRender);
                  }
                }
              ]);

              return Image;
            })(external_react_default.a.Component);

          // EXTERNAL MODULE: ./renderers/atomics/Video/style.scss
          var Video_style = __webpack_require__(47);

          // EXTERNAL MODULE: ./components/common/Modal/style.scss
          var Modal_style = __webpack_require__(48);

          // EXTERNAL MODULE: external "react-dom"
          var external_react_dom_ = __webpack_require__(16);
          var external_react_dom_default = /*#__PURE__*/ __webpack_require__.n(
            external_react_dom_
          );

          // CONCATENATED MODULE: ./components/common/Modal/index.jsx

          var Modal_Modal =
            /*#__PURE__*/
            (function(_React$Component) {
              inherits_default()(Modal, _React$Component);

              function Modal(props) {
                var _this;

                classCallCheck_default()(this, Modal);

                _this = possibleConstructorReturn_default()(
                  this,
                  getPrototypeOf_default()(Modal).call(this, props)
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleTransitionEnd",
                  function() {
                    if (!_this.rootElement || !_this.rootElement.classList) {
                      return false;
                    }

                    if (!_this.rootElement.classList.contains("active")) {
                      external_react_dom_default.a.unmountComponentAtNode(
                        _this.rootElement
                      ) &&
                        _this.rootElement.parentNode.removeChild(
                          _this.rootElement
                        );
                    }
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleMouseDown",
                  function(event) {
                    var tagName = event.target.tagName.toLowerCase();

                    if (tagName === "input" || tagName === "textarea") {
                      return false;
                    }

                    event.preventDefault();
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleCancel",
                  function() {
                    _this.props.closeOnCancel && _this.close();
                    _this.props.onCancel && _this.props.onCancel();
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleConfirm",
                  function() {
                    _this.props.closeOnConfirm && _this.close();
                    _this.props.onConfirm && _this.props.onConfirm();
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleMaskClick",
                  function() {
                    _this.props.closeOnBlur && _this.close();
                    _this.props.onBlue && _this.props.onBlue();
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "close",
                  function() {
                    _this.unrenderComponent();

                    _this.props.onClose && _this.props.onClose();
                  }
                );

                _this.active = false;
                _this.componentId =
                  "BRAFT-MODAL-" +
                  external_braft_utils_["BaseUtils"].UniqueIndex();
                return _this;
              }

              createClass_default()(Modal, [
                {
                  key: "componentDidMount",
                  value: function componentDidMount() {
                    if (this.props.visible) {
                      this.active = true;
                      this.renderComponent(this.props);
                    }
                  }
                },
                {
                  key: "componentWillReceiveProps",
                  value: function componentWillReceiveProps(next) {
                    if (this.props.visible && !next.visible) {
                      this.unrenderComponent();
                    } else if (this.props.visible || next.visible) {
                      this.active = true;
                      this.renderComponent(next);
                    }
                  }
                },
                {
                  key: "render",
                  value: function render() {
                    return null;
                  }
                },
                {
                  key: "unrenderComponent",
                  value: function unrenderComponent() {
                    this.active = false;
                    this.activeId && window.clearImmediate(this.activeId);

                    if (this.rootElement && this.rootElement.classList) {
                      this.rootElement.classList.remove("active");
                    }
                  }
                },
                {
                  key: "renderComponent",
                  value: function renderComponent(props) {
                    var _this2 = this;

                    if (!this.active) {
                      return false;
                    }

                    var title = props.title,
                      className = props.className,
                      width = props.width,
                      height = props.height,
                      children = props.children,
                      component = props.component,
                      confirmable = props.confirmable,
                      showFooter = props.showFooter,
                      showCancel = props.showCancel,
                      showConfirm = props.showConfirm,
                      showClose = props.showClose,
                      cancelText = props.cancelText,
                      confirmText = props.confirmText,
                      bottomText = props.bottomText,
                      language = props.language;
                    typeof showCancel === "undefined" && (showCancel = true);
                    typeof showClose === "undefined" && (showClose = true);
                    typeof showConfirm === "undefined" && (showConfirm = true);
                    typeof showFooter === "undefined" && (showFooter = true);
                    var childComponent = external_react_default.a.createElement(
                      "div",
                      {
                        onMouseDown: this.handleMouseDown,
                        className: "bf-modal " + (className || "")
                      },
                      external_react_default.a.createElement("div", {
                        className: "bf-modal-mask",
                        onClick: this.handleMaskClick
                      }),
                      external_react_default.a.createElement(
                        "div",
                        {
                          onTransitionEnd: this.handleTransitionEnd,
                          style: {
                            width: width,
                            height: height
                          },
                          className: "bf-modal-content"
                        },
                        external_react_default.a.createElement(
                          "div",
                          {
                            className: "bf-modal-header"
                          },
                          external_react_default.a.createElement(
                            "h3",
                            {
                              className: "bf-modal-caption"
                            },
                            title
                          ),
                          showClose &&
                            external_react_default.a.createElement(
                              "button",
                              {
                                type: "button",
                                onClick: this.close,
                                className: "bf-modal-close-button"
                              },
                              external_react_default.a.createElement("i", {
                                className: "bfi-close"
                              })
                            )
                        ),
                        external_react_default.a.createElement(
                          "div",
                          {
                            className: "bf-modal-body"
                          },
                          children || component
                        ),
                        showFooter
                          ? external_react_default.a.createElement(
                              "div",
                              {
                                className: "bf-modal-footer"
                              },
                              external_react_default.a.createElement(
                                "div",
                                {
                                  className: "bf-modal-addon-text"
                                },
                                bottomText
                              ),
                              external_react_default.a.createElement(
                                "div",
                                {
                                  className: "bf-modal-buttons"
                                },
                                showCancel &&
                                  external_react_default.a.createElement(
                                    "button",
                                    {
                                      type: "button",
                                      onClick: this.handleCancel,
                                      className: "bf-modal-cancel"
                                    },
                                    cancelText || language.base.cancel
                                  ),
                                showConfirm &&
                                  external_react_default.a.createElement(
                                    "button",
                                    {
                                      type: "button",
                                      onClick: this.handleConfirm,
                                      className:
                                        "bf-modal-confirm " +
                                        (!confirmable ? "disabled" : "")
                                    },
                                    confirmText || language.base.confirm
                                  )
                              )
                            )
                          : null
                      )
                    );
                    this.rootElement = document.querySelector(
                      "#" + this.componentId
                    );

                    if (!this.rootElement) {
                      this.rootElement = document.createElement("div");
                      this.rootElement.id = this.componentId;
                      this.rootElement.className = "bf-modal-root";
                      document.body.appendChild(this.rootElement);
                    }

                    external_react_dom_default.a.render(
                      childComponent,
                      this.rootElement
                    );
                    this.activeId = window.setImmediate(function() {
                      _this2.rootElement.classList.add("active");
                    });
                  }
                }
              ]);

              return Modal;
            })(external_react_default.a.Component);

          defineProperty_default()(Modal_Modal, "defaultProps", {
            showFooter: true,
            closeOnBlur: true
          });

          var Modal_showModal = function showModal(props) {
            var hostNode = document.createElement("div");
            hostNode.style.display = "none";
            document.body.appendChild(hostNode);
            props = objectSpread_default()(
              {
                visible: true,
                closeOnConfirm: true,
                closeOnCancel: true
              },
              props
            );

            var close = function close() {
              external_react_dom_default.a.unmountComponentAtNode(hostNode) &&
                hostNode.parentNode.removeChild(hostNode);
            };

            var onConfirm = function onConfirm() {
              props.onConfirm && props.onConfirm();
            };

            var onCancel = function onCancel() {
              props.onCancel && props.onCancel();
            };

            var onClose = function onClose() {
              close();
              props.onClose && props.onClose();
            };

            var modalInstance = external_react_dom_default.a.render(
              external_react_default.a.createElement(
                Modal_Modal,
                extends_default()({}, props, {
                  onConfirm: onConfirm,
                  onCancel: onCancel,
                  onClose: onClose
                })
              ),
              hostNode
            );
            modalInstance.destroy = close;
            modalInstance.update = modalInstance.renderComponent;
            return modalInstance;
          };
          // EXTERNAL MODULE: ./components/business/PlayerModal/style.scss
          var PlayerModal_style = __webpack_require__(49);

          // CONCATENATED MODULE: ./components/business/PlayerModal/index.jsx

          var PlayerModal_playViaModal = function playViaModal(
            title,
            component,
            language
          ) {
            return Modal_showModal({
              title: title,
              component: component,
              language: language,
              showFooter: false
            });
          };

          var typeIconsMap = {
            video: "bfi-film",
            audio: "bfi-music",
            embed: "bfi-code"
          };
          /* harmony default export */ var PlayerModal = function(_ref) {
            var title = _ref.title,
              type = _ref.type,
              language = _ref.language,
              name = _ref.name,
              url = _ref.url,
              poster = _ref.poster,
              children = _ref.children,
              onRemove = _ref.onRemove;
            return external_react_default.a.createElement(
              "div",
              {
                className: "bf-player-holder ".concat(type)
              },
              external_react_default.a.createElement(
                "div",
                {
                  className: "icon-badge"
                },
                external_react_default.a.createElement("i", {
                  className: typeIconsMap[type]
                }),
                external_react_default.a.createElement(
                  "span",
                  {
                    className: "text"
                  },
                  language.media[type]
                )
              ),
              external_react_default.a.createElement(
                "button",
                {
                  onMouseDown: onRemove,
                  className: "button-remove"
                },
                external_react_default.a.createElement("i", {
                  className: "bfi-close"
                })
              ),
              external_react_default.a.createElement(
                "button",
                {
                  onMouseDown: function onMouseDown() {
                    return PlayerModal_playViaModal(
                      name ? "".concat(title, ":").concat(name) : title,
                      children,
                      language
                    );
                  },
                  className: "button-play"
                },
                external_react_default.a.createElement("i", {
                  className: "bfi-play_arrow"
                })
              ),
              name
                ? external_react_default.a.createElement(
                    "h5",
                    {
                      className: "bf-name"
                    },
                    name
                  )
                : null,
              external_react_default.a.createElement(
                "h6",
                {
                  className: "bf-url"
                },
                url
              ),
              poster
                ? external_react_default.a.createElement("div", {
                    className: "bf-poster",
                    style: {
                      backgroundImage: "url(".concat(poster, ")")
                    }
                  })
                : null
            );
          };
          // CONCATENATED MODULE: ./renderers/atomics/Video/index.jsx

          var Video_Video =
            /*#__PURE__*/
            (function(_React$Component) {
              inherits_default()(Video, _React$Component);

              function Video() {
                var _getPrototypeOf2;

                var _this;

                classCallCheck_default()(this, Video);

                for (
                  var _len = arguments.length, args = new Array(_len), _key = 0;
                  _key < _len;
                  _key++
                ) {
                  args[_key] = arguments[_key];
                }

                _this = possibleConstructorReturn_default()(
                  this,
                  (_getPrototypeOf2 = getPrototypeOf_default()(
                    Video
                  )).call.apply(_getPrototypeOf2, [this].concat(args))
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "removeVideo",
                  function() {
                    _this.props.editor.setValue(
                      external_braft_utils_["ContentUtils"].removeBlock(
                        _this.props.editorState,
                        _this.props.block
                      )
                    );
                  }
                );

                return _this;
              }

              createClass_default()(Video, [
                {
                  key: "render",
                  value: function render() {
                    var _this$props = this.props,
                      mediaData = _this$props.mediaData,
                      language = _this$props.language;
                    var url = mediaData.url,
                      name = mediaData.name,
                      meta = mediaData.meta;
                    return external_react_default.a.createElement(
                      "div",
                      {
                        className: "bf-video-wrap"
                      },
                      external_react_default.a.createElement(
                        PlayerModal,
                        {
                          type: "video",
                          onRemove: this.removeVideo,
                          poster: meta ? meta.poster || "" : "",
                          language: language,
                          url: url,
                          name: name,
                          title: language.videoPlayer.title
                        },
                        external_react_default.a.createElement(
                          "div",
                          {
                            className: "bf-video-player"
                          },
                          external_react_default.a.createElement(
                            "video",
                            {
                              controls: true,
                              poster: meta ? meta.poster || "" : ""
                            },
                            external_react_default.a.createElement("source", {
                              src: url
                            })
                          )
                        )
                      )
                    );
                  }
                }
              ]);

              return Video;
            })(external_react_default.a.Component);

          // EXTERNAL MODULE: ./renderers/atomics/Audio/style.scss
          var Audio_style = __webpack_require__(50);

          // CONCATENATED MODULE: ./renderers/atomics/Audio/index.jsx

          var Audio_Audio =
            /*#__PURE__*/
            (function(_React$Component) {
              inherits_default()(Audio, _React$Component);

              function Audio() {
                var _getPrototypeOf2;

                var _this;

                classCallCheck_default()(this, Audio);

                for (
                  var _len = arguments.length, args = new Array(_len), _key = 0;
                  _key < _len;
                  _key++
                ) {
                  args[_key] = arguments[_key];
                }

                _this = possibleConstructorReturn_default()(
                  this,
                  (_getPrototypeOf2 = getPrototypeOf_default()(
                    Audio
                  )).call.apply(_getPrototypeOf2, [this].concat(args))
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "removeAudio",
                  function() {
                    _this.props.editor.setValue(
                      external_braft_utils_["ContentUtils"].removeBlock(
                        _this.props.editorState,
                        _this.props.block
                      )
                    );
                  }
                );

                return _this;
              }

              createClass_default()(Audio, [
                {
                  key: "render",
                  value: function render() {
                    var _this$props = this.props,
                      mediaData = _this$props.mediaData,
                      language = _this$props.language;
                    var url = mediaData.url,
                      name = mediaData.name,
                      meta = mediaData.meta;
                    return external_react_default.a.createElement(
                      "div",
                      {
                        className: "bf-audio-wrap"
                      },
                      external_react_default.a.createElement(
                        PlayerModal,
                        {
                          type: "audio",
                          onRemove: this.removeAudio,
                          poster: meta ? meta.poster || "" : "",
                          language: language,
                          url: url,
                          name: name,
                          title: language.audioPlayer.title
                        },
                        external_react_default.a.createElement(
                          "div",
                          {
                            className: "bf-audio-player"
                          },
                          external_react_default.a.createElement("audio", {
                            controls: true,
                            src: url
                          })
                        )
                      )
                    );
                  }
                }
              ]);

              return Audio;
            })(external_react_default.a.Component);

          // EXTERNAL MODULE: ./renderers/atomics/Embed/style.scss
          var Embed_style = __webpack_require__(51);

          // CONCATENATED MODULE: ./renderers/atomics/Embed/index.jsx

          var Embed_Embed =
            /*#__PURE__*/
            (function(_React$Component) {
              inherits_default()(Embed, _React$Component);

              function Embed() {
                var _getPrototypeOf2;

                var _this;

                classCallCheck_default()(this, Embed);

                for (
                  var _len = arguments.length, args = new Array(_len), _key = 0;
                  _key < _len;
                  _key++
                ) {
                  args[_key] = arguments[_key];
                }

                _this = possibleConstructorReturn_default()(
                  this,
                  (_getPrototypeOf2 = getPrototypeOf_default()(
                    Embed
                  )).call.apply(_getPrototypeOf2, [this].concat(args))
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "removeEmbed",
                  function() {
                    _this.props.editor.setValue(
                      external_braft_utils_["ContentUtils"].removeBlock(
                        _this.props.editorState,
                        _this.props.block
                      )
                    );
                  }
                );

                return _this;
              }

              createClass_default()(Embed, [
                {
                  key: "render",
                  value: function render() {
                    var _this$props = this.props,
                      mediaData = _this$props.mediaData,
                      language = _this$props.language;
                    var name = mediaData.name,
                      url = mediaData.url,
                      meta = mediaData.meta;
                    return external_react_default.a.createElement(
                      "div",
                      {
                        className: "bf-embed-wrap"
                      },
                      external_react_default.a.createElement(
                        PlayerModal,
                        {
                          type: "embed",
                          onRemove: this.removeEmbed,
                          poster: meta ? meta.poster || "" : "",
                          language: language,
                          url: url,
                          name: name,
                          title: language.videoPlayer.embedTitle
                        },
                        external_react_default.a.createElement("div", {
                          className: "bf-embed-player",
                          dangerouslySetInnerHTML: {
                            __html: url
                          }
                        })
                      )
                    );
                  }
                }
              ]);

              return Embed;
            })(external_react_default.a.Component);

          // EXTERNAL MODULE: ./renderers/atomics/HorizontalLine/style.scss
          var HorizontalLine_style = __webpack_require__(52);

          // CONCATENATED MODULE: ./renderers/atomics/HorizontalLine/index.jsx

          var HorizontalLine_HorizontalLine =
            /*#__PURE__*/
            (function(_React$Component) {
              inherits_default()(HorizontalLine, _React$Component);

              function HorizontalLine() {
                var _getPrototypeOf2;

                var _this;

                classCallCheck_default()(this, HorizontalLine);

                for (
                  var _len = arguments.length, args = new Array(_len), _key = 0;
                  _key < _len;
                  _key++
                ) {
                  args[_key] = arguments[_key];
                }

                _this = possibleConstructorReturn_default()(
                  this,
                  (_getPrototypeOf2 = getPrototypeOf_default()(
                    HorizontalLine
                  )).call.apply(_getPrototypeOf2, [this].concat(args))
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "removeHorizontalLine",
                  function() {
                    _this.props.editor.setValue(
                      external_braft_utils_["ContentUtils"].removeBlock(
                        _this.props.editorState,
                        _this.props.block
                      )
                    );
                  }
                );

                return _this;
              }

              createClass_default()(HorizontalLine, [
                {
                  key: "render",
                  value: function render() {
                    return external_react_default.a.createElement(
                      "div",
                      {
                        className: "bf-hr"
                      },
                      external_react_default.a.createElement(
                        "div",
                        {
                          className: "bf-media-toolbar"
                        },
                        external_react_default.a.createElement(
                          "a",
                          {
                            onClick: this.removeHorizontalLine
                          },
                          "\uE9AC"
                        )
                      )
                    );
                  }
                }
              ]);

              return HorizontalLine;
            })(external_react_default.a.Component);

          // CONCATENATED MODULE: ./renderers/block/blockRendererFn.js

          var blockRendererFn_BlockRenderFnContext = function BlockRenderFnContext() {
            var _this = this;

            classCallCheck_default()(this, BlockRenderFnContext);

            defineProperty_default()(this, "superProps", void 0);

            defineProperty_default()(this, "customBlockRendererFn", void 0);

            defineProperty_default()(this, "getRenderFn", function(
              superProps,
              customBlockRendererFn
            ) {
              _this.superProps = superProps;
              _this.customBlockRendererFn = customBlockRendererFn;
              return _this.blockRendererFn;
            });

            defineProperty_default()(this, "renderAtomicBlock", function(
              props
            ) {
              var superProps = _this.superProps;
              var entityKey = props.block.getEntityAt(0);

              if (!entityKey) {
                return null;
              }

              var entity = props.contentState.getEntity(entityKey);
              var mediaData = entity.getData();
              var mediaType = entity.getType();

              var mediaProps = objectSpread_default()({}, superProps, {
                block: props.block,
                mediaData: mediaData,
                entityKey: entityKey
              });

              if (mediaType === "IMAGE") {
                return external_react_default.a.createElement(
                  Image_Image,
                  mediaProps
                );
              } else if (mediaType === "AUDIO") {
                return external_react_default.a.createElement(
                  Audio_Audio,
                  mediaProps
                );
              } else if (mediaType === "VIDEO") {
                return external_react_default.a.createElement(
                  Video_Video,
                  mediaProps
                );
              } else if (mediaType === "EMBED") {
                return external_react_default.a.createElement(
                  Embed_Embed,
                  mediaProps
                );
              } else if (mediaType === "HR") {
                return external_react_default.a.createElement(
                  HorizontalLine_HorizontalLine,
                  mediaProps
                );
              }

              if (superProps.extendAtomics) {
                var atomics = superProps.extendAtomics;

                for (var i = 0; i < atomics.length; i++) {
                  if (mediaType === atomics[i].type) {
                    var Component = atomics[i].component;
                    return external_react_default.a.createElement(
                      Component,
                      mediaProps
                    );
                  }
                }
              }

              return null;
            });

            defineProperty_default()(this, "blockRendererFn", function(block) {
              var customBlockRendererFn = _this.customBlockRendererFn,
                superProps = _this.superProps;
              var blockType = block.getType();
              var blockRenderer = null;

              if (customBlockRendererFn) {
                blockRenderer =
                  customBlockRendererFn(block, superProps) || null;
              }

              if (blockRenderer) {
                return blockRenderer;
              }

              var extensionBlockRendererFns = getExtensionBlockRendererFns(
                superProps.editorId
              );
              extensionBlockRendererFns.find(function(item) {
                if (
                  item.blockType === blockType ||
                  (item.blockType instanceof RegExp &&
                    item.blockType.test(blockType))
                ) {
                  blockRenderer = item.rendererFn
                    ? item.rendererFn(superProps)
                    : null;
                  return true;
                }
              });

              if (blockRenderer) {
                return blockRenderer;
              }

              if (blockType === "atomic") {
                blockRenderer = {
                  component: _this.renderAtomicBlock,
                  editable: false
                };
              }

              return blockRenderer;
            });
          };

          var blockRenderFnContext = new blockRendererFn_BlockRenderFnContext();
          /* harmony default export */ var block_blockRendererFn =
            blockRenderFnContext.getRenderFn;
          // CONCATENATED MODULE: ./renderers/block/blockStyleFn.js
          /* harmony default export */ var block_blockStyleFn = function(
            customBlockStyleFn
          ) {
            return function(block) {
              var blockAlignment =
                block.getData() && block.getData().get("textAlign");
              var blockIndent =
                block.getData() && block.getData().get("textIndent");
              var blockFloat = block.getData() && block.getData().get("float");
              var result = "";

              if (blockAlignment) {
                result = "bfa-".concat(blockAlignment);
              }

              if (blockIndent && blockIndent !== 0) {
                result += " bftd-".concat(blockIndent);
              }

              if (blockFloat) {
                result += " bff-".concat(blockFloat);
              }

              if (customBlockStyleFn) {
                result += customBlockStyleFn(block) || "";
              }

              return result;
            };
          };
          // CONCATENATED MODULE: ./renderers/inline/inlineStyleMap.js

          /* harmony default export */ var inlineStyleMap = function(props) {
            var customStyleMap =
              arguments.length > 1 && arguments[1] !== undefined
                ? arguments[1]
                : {};
            var extensionInlineStyleMap = getExtensionInlineStyleMap(
              props.editorId
            );
            return objectSpread_default()(
              {
                SUPERSCRIPT: {
                  position: "relative",
                  top: "-8px",
                  fontSize: "11px"
                },
                SUBSCRIPT: {
                  position: "relative",
                  bottom: "-8px",
                  fontSize: "11px"
                }
              },
              extensionInlineStyleMap,
              customStyleMap
            );
          };
          // CONCATENATED MODULE: ./renderers/inline/inlineStyleFn.js

          var getStyleValue = function getStyleValue(style) {
            return style.split("-")[1];
          };

          /* harmony default export */ var inlineStyleFn = function(
            props,
            options
          ) {
            return function(styles, block) {
              var output = {};
              var fontFamilies = options.fontFamilies,
                unitExportFn = options.unitExportFn,
                customStyleFn = options.customStyleFn;
              var extensionInlineStyleFns = getExtensionInlineStyleFns(
                props.editorId
              );
              extensionInlineStyleFns.forEach(function(item) {
                output = item.styleFn
                  ? item.styleFn(styles, block, output)
                  : output;
              });
              output = customStyleFn
                ? customStyleFn(styles, block, output)
                : {};
              styles.forEach(function(style) {
                if (style.indexOf("COLOR-") === 0) {
                  output.color = "#" + getStyleValue(style);
                } else if (style.indexOf("BGCOLOR-") === 0) {
                  output.backgroundColor = "#" + getStyleValue(style);
                } else if (style.indexOf("FONTSIZE-") === 0) {
                  output.fontSize = unitExportFn(
                    getStyleValue(style),
                    "font-size",
                    "editor"
                  );
                } else if (style.indexOf("LINEHEIGHT-") === 0) {
                  output.lineHeight = unitExportFn(
                    getStyleValue(style),
                    "line-height",
                    "editor"
                  );
                } else if (style.indexOf("LETTERSPACING-") === 0) {
                  output.letterSpacing = unitExportFn(
                    getStyleValue(style),
                    "letter-spacing",
                    "editor"
                  );
                } else if (style.indexOf("TEXTINDENT-") === 0) {
                  output.textIndent = unitExportFn(
                    getStyleValue(style),
                    "text-indent",
                    "editor"
                  );
                } else if (style.indexOf("FONTFAMILY-") === 0) {
                  output.fontFamily =
                    (
                      fontFamilies.find(function(item) {
                        return item.name.toUpperCase() === getStyleValue(style);
                      }) || {}
                    ).family || "";
                }
              });
              return output;
            };
          };
          // EXTERNAL MODULE: ../node_modules/draft-js-multidecorators/index.js
          var draft_js_multidecorators = __webpack_require__(18);
          var draft_js_multidecorators_default = /*#__PURE__*/ __webpack_require__.n(
            draft_js_multidecorators
          );

          // CONCATENATED MODULE: ./renderers/decorators/Link/index.jsx

          /* harmony default export */ var Link = function(props) {
            var children = props.children,
              entityKey = props.entityKey,
              contentState = props.contentState;

            var _contentState$getEnti = contentState
                .getEntity(entityKey)
                .getData(),
              href = _contentState$getEnti.href,
              target = _contentState$getEnti.target;

            return external_react_default.a.createElement(
              "span",
              {
                className: "bf-link-wrap"
              },
              external_react_default.a.createElement(
                "a",
                {
                  onClick: function onClick(event) {
                    return viewLink(event, href);
                  },
                  className: "bf-link",
                  href: href,
                  target: target
                },
                children
              )
            );
          };

          var viewLink = function viewLink(event, link) {
            // 当按下Ctrl/command键时，点击打开链接文字中的url
            if (
              event.getModifierState("Control") ||
              event.getModifierState("Meta")
            ) {
              var tempLink = document.createElement("a");
              tempLink.href = link;
              tempLink.target = event.currentTarget.target;
              tempLink.click();
            }
          };
          // CONCATENATED MODULE: ./renderers/decorators/index.js

          var KEY_SEPARATOR = "-";

          draft_js_multidecorators_default.a.prototype.getDecorations = function(
            block,
            contentState
          ) {
            var decorations = Array(block.getText().length).fill(null);
            this.decorators.forEach(function(decorator, i) {
              decorator
                .getDecorations(block, contentState)
                .forEach(function(key, offset) {
                  if (!key) {
                    return;
                  }

                  key = i + KEY_SEPARATOR + key;
                  decorations[offset] = key;
                });
            });
            return external_immutable_default.a.List(decorations);
          };

          var builtinDecorators = [
            {
              type: "entity",
              decorator: {
                key: "LINK",
                component: Link
              }
            }
          ];

          var createStrategy = function createStrategy(type) {
            return function(block, callback, contentState) {
              block.findEntityRanges(function(character) {
                var entityKey = character.getEntity();
                return (
                  entityKey !== null &&
                  contentState.getEntity(entityKey).getType() === type
                );
              }, callback);
            };
          };

          /* harmony default export */ var decorators = function(editorId) {
            var extensionDecorators = getExtensionDecorators(editorId);
            var entityDecorators = builtinDecorators.concat(
              toConsumableArray_default()(
                extensionDecorators.filter(function(item) {
                  return item.type === "entity";
                })
              )
            );
            var strategyDecorators = extensionDecorators.filter(function(item) {
              return item.type === "strategy";
            });
            var classDecorators = extensionDecorators.filter(function(item) {
              return item.type === "class";
            });
            return new draft_js_multidecorators_default.a(
              toConsumableArray_default()(
                classDecorators.map(function(item) {
                  return item.decorator;
                })
              ).concat([
                // combine decorators created with strategy
                new external_draft_js_["CompositeDecorator"](
                  strategyDecorators.map(function(item) {
                    return item.decorator;
                  })
                ), // combine decorators for entities
                new external_draft_js_["CompositeDecorator"](
                  entityDecorators.map(function(item) {
                    return {
                      strategy: createStrategy(item.decorator.key),
                      component: item.decorator.component
                    };
                  })
                )
              ])
            );
          };
          // CONCATENATED MODULE: ./renderers/index.js

          var getBlockRenderMap = block_blockRenderMap;
          var getBlockRendererFn = block_blockRendererFn;
          var getBlockStyleFn = block_blockStyleFn;
          var getCustomStyleMap = inlineStyleMap;
          var getCustomStyleFn = inlineStyleFn;
          var getDecorators = decorators;
          // EXTERNAL MODULE: ./components/business/ControlBar/style.scss
          var ControlBar_style = __webpack_require__(53);

          // EXTERNAL MODULE: ./components/business/LinkEditor/style.scss
          var LinkEditor_style = __webpack_require__(54);

          // EXTERNAL MODULE: ./components/common/DropDown/style.scss
          var DropDown_style = __webpack_require__(55);

          // CONCATENATED MODULE: ./helpers/responsive.js

          var resizeEventHandlers = [];
          var responsiveHelperInited = false;
          var debouce = false;
          /* harmony default export */ var responsive = {
            resolve: function resolve(eventHandler) {
              var id = external_braft_utils_["BaseUtils"].UniqueIndex();
              resizeEventHandlers.push({
                id: id,
                eventHandler: eventHandler
              });
              return id;
            },
            unresolve: function unresolve(id) {
              resizeEventHandlers = resizeEventHandlers.filter(function(item) {
                return item.id !== id;
              });
            }
          };

          if (
            !responsiveHelperInited &&
            (typeof window === "undefined"
              ? "undefined"
              : typeof_default()(window)) === "object"
          ) {
            window.addEventListener("resize", function(event) {
              clearTimeout(debouce);
              debouce = setTimeout(function() {
                resizeEventHandlers.map(function(item) {
                  typeof item.eventHandler === "function" &&
                    item.eventHandler(event);
                });
                debouce = false;
              }, 100);
            });
            responsiveHelperInited = true;
          }
          // CONCATENATED MODULE: ./components/common/DropDown/index.jsx

          var DropDown_DropDown =
            /*#__PURE__*/
            (function(_React$Component) {
              inherits_default()(DropDown, _React$Component);

              function DropDown() {
                var _getPrototypeOf2;

                var _this;

                classCallCheck_default()(this, DropDown);

                for (
                  var _len = arguments.length, args = new Array(_len), _key = 0;
                  _key < _len;
                  _key++
                ) {
                  args[_key] = arguments[_key];
                }

                _this = possibleConstructorReturn_default()(
                  this,
                  (_getPrototypeOf2 = getPrototypeOf_default()(
                    DropDown
                  )).call.apply(_getPrototypeOf2, [this].concat(args))
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "responsiveResolveId",
                  null
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "dropDownHandlerElement",
                  null
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "dropDownContentElement",
                  null
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "state",
                  {
                    active: false,
                    offset: 0
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "fixDropDownPosition",
                  function() {
                    var viewRect = _this.props
                      .getContainerNode()
                      .getBoundingClientRect();

                    var handlerRect = _this.dropDownHandlerElement.getBoundingClientRect();

                    var contentRect = _this.dropDownContentElement.getBoundingClientRect();

                    var offset = 0;
                    var right =
                      handlerRect.right -
                      handlerRect.width / 2 +
                      contentRect.width / 2;
                    var left =
                      handlerRect.left +
                      handlerRect.width / 2 -
                      contentRect.width / 2;
                    right = viewRect.right - right;
                    left = left - viewRect.left;

                    if (right < 10) {
                      offset = right - 10;
                    } else if (left < 10) {
                      offset = left * -1 + 10;
                    }

                    if (offset !== _this.state.offset) {
                      _this.setState({
                        offset: offset
                      });
                    }
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "registerClickEvent",
                  function(event) {
                    var autoHide = _this.props.autoHide;
                    var active = _this.state.active;

                    if (
                      _this.dropDownContentElement.contains(event.target) ||
                      _this.dropDownHandlerElement.contains(event.target)
                    ) {
                      return false;
                    }

                    autoHide && active && _this.hide();
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "toggle",
                  function() {
                    _this.setState({
                      active: !_this.state.active
                    });
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "show",
                  function() {
                    _this.setState({
                      active: true
                    });
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "hide",
                  function() {
                    _this.setState({
                      active: false
                    });
                  }
                );

                return _this;
              }

              createClass_default()(DropDown, [
                {
                  key: "componentDidMount",
                  value: function componentDidMount() {
                    if (document) {
                      document.body.addEventListener(
                        "click",
                        this.registerClickEvent
                      );
                      this.responsiveResolveId = responsive.resolve(
                        this.fixDropDownPosition
                      );
                    }
                  }
                },
                {
                  key: "componentWillReceiveProps",
                  value: function componentWillReceiveProps(next) {
                    if (!this.props.disabled && next.disabled) {
                      this.hide();
                    }
                  }
                },
                {
                  key: "componentDidUpdate",
                  value: function componentDidUpdate(prevState) {
                    if (!prevState.active && this.state.active) {
                      this.fixDropDownPosition();
                    }
                  }
                },
                {
                  key: "componentWillUnmount",
                  value: function componentWillUnmount() {
                    if (document) {
                      document.body.removeEventListener(
                        "click",
                        this.registerClickEvent
                      );
                      responsive.unresolve(this.responsiveResolveId);
                    }
                  }
                },
                {
                  key: "render",
                  value: function render() {
                    var _this2 = this;

                    var _this$state = this.state,
                      active = _this$state.active,
                      offset = _this$state.offset;
                    var _this$props = this.props,
                      caption = _this$props.caption,
                      htmlCaption = _this$props.htmlCaption,
                      title = _this$props.title,
                      disabled = _this$props.disabled,
                      showArrow = _this$props.showArrow,
                      arrowActive = _this$props.arrowActive,
                      className = _this$props.className,
                      children = _this$props.children,
                      theme = _this$props.theme;
                    disabled && (active = false);
                    theme === "light" &&
                      (className = " light-theme " + className);
                    return external_react_default.a.createElement(
                      "div",
                      {
                        className:
                          "bf-dropdown " +
                          (active ? "active " : "") +
                          (disabled ? "disabled " : "") +
                          className
                      },
                      htmlCaption
                        ? external_react_default.a.createElement("button", {
                            type: "button",
                            className: "dropdown-handler",
                            "data-title": title,
                            onClick: this.toggle,
                            dangerouslySetInnerHTML: htmlCaption
                              ? {
                                  __html: htmlCaption
                                }
                              : null,
                            ref: function ref(instance) {
                              return (_this2.dropDownHandlerElement = instance);
                            }
                          })
                        : external_react_default.a.createElement(
                            "button",
                            {
                              type: "button",
                              className: "dropdown-handler",
                              "data-title": title,
                              onClick: this.toggle,
                              ref: function ref(instance) {
                                return (_this2.dropDownHandlerElement = instance);
                              }
                            },
                            external_react_default.a.createElement(
                              "span",
                              null,
                              caption
                            ),
                            showArrow !== false
                              ? external_react_default.a.createElement("i", {
                                  className: "bfi-drop-down"
                                })
                              : null
                          ),
                      external_react_default.a.createElement(
                        "div",
                        {
                          className: "dropdown-content",
                          style: {
                            marginLeft: offset
                          },
                          ref: function ref(instance) {
                            return (_this2.dropDownContentElement = instance);
                          }
                        },
                        external_react_default.a.createElement("i", {
                          style: {
                            marginLeft: offset * -1
                          },
                          className:
                            "dropdown-arrow" + (arrowActive ? " active" : "")
                        }),
                        external_react_default.a.createElement(
                          "div",
                          {
                            className: "dropdown-content-inner"
                          },
                          children
                        )
                      )
                    );
                  }
                }
              ]);

              return DropDown;
            })(external_react_default.a.Component);

          // CONCATENATED MODULE: ./components/business/ControlGroup/index.jsx

          /* harmony default export */ var ControlGroup = function(props) {
            if (external_react_default.a.Fragment) {
              return external_react_default.a.createElement(
                external_react_default.a.Fragment,
                null,
                props.children
              );
            } else {
              return external_react_default.a.createElement(
                "div",
                {
                  className: "control-item-group"
                },
                props.children
              );
            }
          };
          // CONCATENATED MODULE: ./components/business/LinkEditor/index.jsx

          var LinkEditor_LinkEditor =
            /*#__PURE__*/
            (function(_React$Component) {
              inherits_default()(LinkEditor, _React$Component);

              function LinkEditor(props) {
                var _this;

                classCallCheck_default()(this, LinkEditor);

                _this = possibleConstructorReturn_default()(
                  this,
                  getPrototypeOf_default()(LinkEditor).call(this, props)
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "dropDownInstance",
                  null
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handeKeyDown",
                  function(e) {
                    if (e.keyCode === 13) {
                      _this.handleConfirm();

                      e.preventDefault();
                      return false;
                    }
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleTnputText",
                  function(e) {
                    _this.setState({
                      text: e.currentTarget.value
                    });
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleInputLink",
                  function(e) {
                    _this.setState({
                      href: e.currentTarget.value
                    });
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "setTarget",
                  function() {
                    _this.setState({
                      target: _this.state.target === "_blank" ? "" : "_blank"
                    });
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleCancel",
                  function() {
                    _this.dropDownInstance.hide();
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleUnlink",
                  function() {
                    _this.dropDownInstance.hide();

                    _this.props.editor.setValue(
                      external_braft_utils_["ContentUtils"].toggleSelectionLink(
                        _this.props.editorState,
                        false
                      )
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleConfirm",
                  function() {
                    var _this$state = _this.state,
                      text = _this$state.text,
                      href = _this$state.href,
                      target = _this$state.target,
                      textSelected = _this$state.textSelected;

                    var hookReturns = _this.props.hooks("toggle-link", {
                      href: href,
                      target: target
                    })({
                      href: href,
                      target: target
                    });

                    _this.dropDownInstance.hide();

                    _this.props.editor.requestFocus();

                    if (hookReturns === false) {
                      return false;
                    }

                    if (hookReturns) {
                      typeof hookReturns.href === "string" &&
                        (href = hookReturns.href);
                      typeof hookReturns.target === "string" &&
                        (target = hookReturns.target);
                    }

                    if (textSelected) {
                      if (href) {
                        _this.props.editor.setValue(
                          external_braft_utils_[
                            "ContentUtils"
                          ].toggleSelectionLink(
                            _this.props.editorState,
                            href,
                            target
                          )
                        );
                      } else {
                        _this.props.editor.setValue(
                          external_braft_utils_[
                            "ContentUtils"
                          ].toggleSelectionLink(_this.props.editorState, false)
                        );
                      }
                    } else {
                      _this.props.editor.setValue(
                        external_braft_utils_["ContentUtils"].insertText(
                          _this.props.editorState,
                          text || href,
                          null,
                          {
                            type: "LINK",
                            data: {
                              href: href,
                              target: target
                            }
                          }
                        )
                      );
                    }
                  }
                );

                _this.state = {
                  text: "",
                  href: "",
                  target: props.defaultLinkTarget || "",
                  textSelected: false
                };
                return _this;
              }

              createClass_default()(LinkEditor, [
                {
                  key: "componentWillReceiveProps",
                  value: function componentWillReceiveProps(nextProps) {
                    var _ContentUtils$getSele = external_braft_utils_[
                        "ContentUtils"
                      ].getSelectionEntityData(nextProps.editorState, "LINK"),
                      href = _ContentUtils$getSele.href,
                      target = _ContentUtils$getSele.target;

                    var textSelected =
                      !external_braft_utils_[
                        "ContentUtils"
                      ].isSelectionCollapsed(this.props.editorState) &&
                      external_braft_utils_[
                        "ContentUtils"
                      ].getSelectionBlockType(this.props.editorState) !==
                        "atomic";
                    var selectedText = "";

                    if (textSelected) {
                      selectedText = external_braft_utils_[
                        "ContentUtils"
                      ].getSelectionText(this.props.editorState);
                    }

                    this.setState({
                      textSelected: textSelected,
                      text: selectedText,
                      href: href || "",
                      target:
                        typeof target === "undefined"
                          ? nextProps.defaultLinkTarget || ""
                          : target || ""
                    });
                  }
                },
                {
                  key: "render",
                  value: function render() {
                    var _this2 = this;

                    var allowInsertLinkText = this.props.allowInsertLinkText;
                    var _this$state2 = this.state,
                      text = _this$state2.text,
                      href = _this$state2.href,
                      target = _this$state2.target,
                      textSelected = _this$state2.textSelected;
                    var caption = external_react_default.a.createElement("i", {
                      className: "bfi-link"
                    });
                    return external_react_default.a.createElement(
                      ControlGroup,
                      null,
                      external_react_default.a.createElement(
                        DropDown_DropDown,
                        {
                          key: 0,
                          caption: caption,
                          title: this.props.language.controls.link,
                          autoHide: true,
                          getContainerNode: this.props.getContainerNode,
                          showArrow: false,
                          ref: function ref(instance) {
                            return (_this2.dropDownInstance = instance);
                          },
                          className:
                            "control-item dropdown link-editor-dropdown"
                        },
                        external_react_default.a.createElement(
                          "div",
                          {
                            className: "bf-link-editor"
                          },
                          allowInsertLinkText
                            ? external_react_default.a.createElement(
                                "div",
                                {
                                  className: "input-group"
                                },
                                external_react_default.a.createElement(
                                  "input",
                                  {
                                    type: "text",
                                    value: text,
                                    spellCheck: false,
                                    disabled: textSelected,
                                    placeholder: this.props.language.linkEditor
                                      .textInputPlaceHolder,
                                    onKeyDown: this.handeKeyDown,
                                    onChange: this.handleTnputText
                                  }
                                )
                              )
                            : null,
                          external_react_default.a.createElement(
                            "div",
                            {
                              className: "input-group"
                            },
                            external_react_default.a.createElement("input", {
                              type: "text",
                              value: href,
                              spellCheck: false,
                              placeholder: this.props.language.linkEditor
                                .linkInputPlaceHolder,
                              onKeyDown: this.handeKeyDown,
                              onChange: this.handleInputLink
                            })
                          ),
                          external_react_default.a.createElement(
                            "div",
                            {
                              className: "switch-group"
                            },
                            external_react_default.a.createElement(Switch, {
                              active: target === "_blank",
                              onClick: this.setTarget
                            }),
                            external_react_default.a.createElement(
                              "label",
                              null,
                              this.props.language.linkEditor.openInNewWindow
                            )
                          ),
                          external_react_default.a.createElement(
                            "div",
                            {
                              className: "buttons"
                            },
                            external_react_default.a.createElement(
                              "a",
                              {
                                onClick: this.handleUnlink,
                                className:
                                  "primary button-remove-link pull-left"
                              },
                              external_react_default.a.createElement("i", {
                                className: "bfi-close"
                              }),
                              external_react_default.a.createElement(
                                "span",
                                null,
                                this.props.language.linkEditor.removeLink
                              )
                            ),
                            external_react_default.a.createElement(
                              "button",
                              {
                                type: "button",
                                onClick: this.handleConfirm,
                                className: "primary pull-right"
                              },
                              this.props.language.base.confirm
                            ),
                            external_react_default.a.createElement(
                              "button",
                              {
                                type: "button",
                                onClick: this.handleCancel,
                                className: "default pull-right"
                              },
                              this.props.language.base.cancel
                            )
                          )
                        )
                      ),
                      external_react_default.a.createElement(
                        "button",
                        {
                          key: 1,
                          type: "button",
                          "data-title": this.props.language.controls.unlink,
                          className: "control-item button",
                          onClick: this.handleUnlink,
                          disabled: !textSelected || !href
                        },
                        external_react_default.a.createElement("i", {
                          className: "bfi-link-off"
                        })
                      )
                    );
                  }
                }
              ]);

              return LinkEditor;
            })(external_react_default.a.Component);

          // EXTERNAL MODULE: ./components/business/Headings/style.scss
          var Headings_style = __webpack_require__(56);

          // CONCATENATED MODULE: ./configs/maps.js

          var maps_getHeadings = function getHeadings(lang) {
            return [
              {
                key: "header-one",
                title: lang.controls.header + " 1",
                text: external_react_default.a.createElement(
                  "h1",
                  null,
                  lang.controls.header,
                  " 1"
                ),
                type: "block-type",
                command: "header-one"
              },
              {
                key: "header-two",
                title: lang.controls.header + " 2",
                text: external_react_default.a.createElement(
                  "h2",
                  null,
                  lang.controls.header,
                  " 2"
                ),
                type: "block-type",
                command: "header-two"
              },
              {
                key: "header-three",
                title: lang.controls.header + " 3",
                text: external_react_default.a.createElement(
                  "h3",
                  null,
                  lang.controls.header,
                  " 3"
                ),
                type: "block-type",
                command: "header-three"
              },
              {
                key: "header-four",
                title: lang.controls.header + " 4",
                text: external_react_default.a.createElement(
                  "h4",
                  null,
                  lang.controls.header,
                  " 4"
                ),
                type: "block-type",
                command: "header-four"
              },
              {
                key: "header-five",
                title: lang.controls.header + " 5",
                text: external_react_default.a.createElement(
                  "h5",
                  null,
                  lang.controls.header,
                  " 5"
                ),
                type: "block-type",
                command: "header-five"
              },
              {
                key: "header-six",
                title: lang.controls.header + " 6",
                text: external_react_default.a.createElement(
                  "h6",
                  null,
                  lang.controls.header,
                  " 6"
                ),
                type: "block-type",
                command: "header-six"
              },
              {
                key: "unstyled",
                title: lang.controls.normal,
                text: lang.controls.normal,
                type: "block-type",
                command: "unstyled"
              }
            ];
          };
          // CONCATENATED MODULE: ./components/business/Headings/index.jsx

          /* harmony default export */ var Headings = function(props) {
            var dropDownInstance = null;
            var headings = maps_getHeadings(props.language).filter(function(
              item
            ) {
              return props.headings.indexOf(item.key) !== -1;
            });
            var currentHeadingIndex = headings.findIndex(function(item) {
              return item.command === props.current;
            });
            var caption = headings[currentHeadingIndex]
              ? headings[currentHeadingIndex].title
              : props.language.controls.normal;
            return external_react_default.a.createElement(
              DropDown_DropDown,
              {
                caption: caption,
                autoHide: true,
                getContainerNode: props.getContainerNode,
                title: props.language.controls.headings,
                arrowActive: currentHeadingIndex === 0,
                ref: function ref(instance) {
                  return (dropDownInstance = instance);
                },
                className: "control-item dropdown headings-dropdown"
              },
              external_react_default.a.createElement(
                "ul",
                {
                  className: "menu"
                },
                headings.map(function(item, index) {
                  var isActive = props.current === item.command;
                  return external_react_default.a.createElement(
                    "li",
                    {
                      key: index,
                      className: "menu-item" + (isActive ? " active" : ""),
                      onClick: function onClick() {
                        props.onChange(item.command, item.type),
                          dropDownInstance.hide();
                      }
                    },
                    item.text
                  );
                })
              )
            );
          };
          // EXTERNAL MODULE: ./components/business/TextColor/style.scss
          var TextColor_style = __webpack_require__(57);

          // EXTERNAL MODULE: ./components/common/ColorPicker/style.scss
          var ColorPicker_style = __webpack_require__(58);

          // CONCATENATED MODULE: ./components/common/ColorPicker/index.jsx

          /* harmony default export */ var common_ColorPicker = function(
            props
          ) {
            return external_react_default.a.createElement(
              "div",
              {
                className: "bf-colors-wrap"
              },
              external_react_default.a.createElement(
                "ul",
                {
                  className: "bf-colors"
                },
                props.presetColors.map(function(item, index) {
                  var className =
                    props.color &&
                    item.toLowerCase() === props.color.toLowerCase()
                      ? "color-item active"
                      : "color-item";
                  return external_react_default.a.createElement("li", {
                    key: index,
                    title: item,
                    className: className,
                    style: {
                      color: item
                    },
                    "data-color": item.replace("#", ""),
                    onClick: function onClick(e) {
                      props.onChange(e.currentTarget.dataset.color, true);
                    }
                  });
                })
              )
            );
          };
          // CONCATENATED MODULE: ./components/business/TextColor/index.jsx

          var TextColor_TextColor =
            /*#__PURE__*/
            (function(_React$Component) {
              inherits_default()(TextColor, _React$Component);

              function TextColor() {
                var _getPrototypeOf2;

                var _this;

                classCallCheck_default()(this, TextColor);

                for (
                  var _len = arguments.length, args = new Array(_len), _key = 0;
                  _key < _len;
                  _key++
                ) {
                  args[_key] = arguments[_key];
                }

                _this = possibleConstructorReturn_default()(
                  this,
                  (_getPrototypeOf2 = getPrototypeOf_default()(
                    TextColor
                  )).call.apply(_getPrototypeOf2, [this].concat(args))
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "state",
                  {
                    colorType: "color"
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "switchColorType",
                  function(_ref) {
                    var currentTarget = _ref.currentTarget;

                    _this.setState({
                      colorType: currentTarget.dataset.type
                    });
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "toggleColor",
                  function(color, closePicker) {
                    if (color) {
                      var hookReturns = _this.props.hooks(
                        "toggle-text-".concat(_this.state.colorType),
                        color
                      )(color);

                      if (hookReturns === false) {
                        return false;
                      }

                      if (typeof hookReturns === "string") {
                        color = hookReturns;
                      }

                      if (_this.state.colorType === "color") {
                        _this.props.editor.setValue(
                          external_braft_utils_[
                            "ContentUtils"
                          ].toggleSelectionColor(_this.props.editorState, color)
                        );
                      } else {
                        _this.props.editor.setValue(
                          external_braft_utils_[
                            "ContentUtils"
                          ].toggleSelectionBackgroundColor(
                            _this.props.editorState,
                            color
                          )
                        );
                      }
                    }

                    if (closePicker) {
                      _this.dropDownInstance.hide();

                      _this.props.editor.requestFocus();
                    }
                  }
                );

                return _this;
              }

              createClass_default()(TextColor, [
                {
                  key: "render",
                  value: function render() {
                    var _this2 = this;

                    var captionStyle = {};
                    var currentColor = null;
                    var colorType = this.state.colorType;
                    var selectionStyles = this.props.editorState
                      .getCurrentInlineStyle()
                      .toJS();
                    selectionStyles.forEach(function(style) {
                      if (style.indexOf("COLOR-") === 0) {
                        captionStyle.color = "#" + style.split("-")[1];
                        colorType === "color" &&
                          (currentColor = captionStyle.color);
                      }

                      if (style.indexOf("BGCOLOR-") === 0) {
                        captionStyle.backgroundColor =
                          "#" + style.split("-")[1];
                        colorType === "background-color" &&
                          (currentColor = captionStyle.backgroundColor);
                      }
                    });
                    var caption = external_react_default.a.createElement(
                      "i",
                      {
                        style: captionStyle,
                        className: "bfi-text-color"
                      },
                      external_react_default.a.createElement("span", {
                        className: "path1"
                      }),
                      external_react_default.a.createElement("span", {
                        className: "path2"
                      })
                    );
                    var ColorPicker =
                      this.props.colorPicker || common_ColorPicker;
                    return external_react_default.a.createElement(
                      DropDown_DropDown,
                      {
                        caption: caption,
                        title: this.props.language.controls.color,
                        showArrow: false,
                        autoHide: this.props.autoHide,
                        theme: this.props.theme,
                        getContainerNode: this.props.getContainerNode,
                        ref: function ref(instance) {
                          return (_this2.dropDownInstance = instance);
                        },
                        className: "control-item dropdown text-color-dropdown"
                      },
                      external_react_default.a.createElement(
                        "div",
                        {
                          className: "bf-text-color-picker-wrap"
                        },
                        external_react_default.a.createElement(
                          "div",
                          {
                            className: "bf-color-switch-buttons",
                            style: this.props.enableBackgroundColor
                              ? {}
                              : {
                                  display: "none"
                                }
                          },
                          external_react_default.a.createElement(
                            "button",
                            {
                              type: "button",
                              "data-type": "color",
                              className: colorType === "color" ? "active" : "",
                              onClick: this.switchColorType
                            },
                            this.props.language.controls.textColor
                          ),
                          external_react_default.a.createElement(
                            "button",
                            {
                              type: "button",
                              "data-type": "background-color",
                              className:
                                colorType === "background-color"
                                  ? "active"
                                  : "",
                              onClick: this.switchColorType
                            },
                            this.props.language.controls.backgroundColor
                          )
                        ),
                        external_react_default.a.createElement(ColorPicker, {
                          width: 200,
                          color: currentColor,
                          disableAlpha: true,
                          presetColors: this.props.colors,
                          onChange: this.toggleColor
                        })
                      )
                    );
                  }
                }
              ]);

              return TextColor;
            })(external_react_default.a.Component);

          // EXTERNAL MODULE: ./components/business/FontSize/style.scss
          var FontSize_style = __webpack_require__(59);

          // CONCATENATED MODULE: ./components/business/FontSize/index.jsx

          var FontSize_toggleFontSize = function toggleFontSize(event, props) {
            var fontSize = event.currentTarget.dataset.size;
            var hookReturns = props.hooks(
              "toggle-font-size",
              fontSize
            )(fontSize);

            if (hookReturns === false) {
              return false;
            }

            if (!isNaN(fontSize)) {
              fontSize = hookReturns;
            }

            props.editor.setValue(
              external_braft_utils_["ContentUtils"].toggleSelectionFontSize(
                props.editorState,
                fontSize
              )
            );
            props.editor.requestFocus();
          };

          /* harmony default export */ var FontSize = function(props) {
            var caption = null;
            var currentFontSize = null;
            var dropDownInstance = null;
            props.fontSizes.find(function(item) {
              if (
                external_braft_utils_["ContentUtils"].selectionHasInlineStyle(
                  props.editorState,
                  "FONTSIZE-" + item
                )
              ) {
                caption = item;
                currentFontSize = item;
                return true;
              }

              return false;
            });
            return external_react_default.a.createElement(
              DropDown_DropDown,
              {
                autoHide: true,
                caption: caption || props.defaultCaption,
                getContainerNode: props.getContainerNode,
                title: props.language.controls.fontSize,
                ref: function ref(instance) {
                  return (dropDownInstance = instance);
                },
                className: "control-item dropdown bf-font-size-dropdown"
              },
              external_react_default.a.createElement(
                "ul",
                {
                  className: "bf-font-sizes"
                },
                props.fontSizes.map(function(item, index) {
                  return external_react_default.a.createElement(
                    "li",
                    {
                      key: index,
                      className: item === currentFontSize ? "active" : null,
                      "data-size": item,
                      onClick: function onClick(event) {
                        FontSize_toggleFontSize(event, props),
                          dropDownInstance.hide();
                      }
                    },
                    item
                  );
                })
              )
            );
          };
          // EXTERNAL MODULE: ./components/business/LineHeight/style.scss
          var LineHeight_style = __webpack_require__(60);

          // CONCATENATED MODULE: ./components/business/LineHeight/index.jsx

          var LineHeight_toggleLineHeight = function toggleLineHeight(
            event,
            props
          ) {
            var lineHeight = event.currentTarget.dataset.size;
            var hookReturns = props.hooks(
              "toggle-line-height",
              lineHeight
            )(lineHeight);

            if (hookReturns === false) {
              return false;
            }

            if (!isNaN(hookReturns)) {
              lineHeight = hookReturns;
            }

            props.editor.setValue(
              external_braft_utils_["ContentUtils"].toggleSelectionLineHeight(
                props.editorState,
                lineHeight
              )
            );
            props.editor.requestFocus();
          };

          /* harmony default export */ var LineHeight = function(props) {
            var caption = null;
            var currentLineHeight = null;
            var dropDownInstance = null;
            props.lineHeights.find(function(item) {
              if (
                external_braft_utils_["ContentUtils"].selectionHasInlineStyle(
                  props.editorState,
                  "LINEHEIGHT-" + item
                )
              ) {
                caption = item;
                currentLineHeight = item;
                return true;
              }

              return false;
            });
            return external_react_default.a.createElement(
              DropDown_DropDown,
              {
                autoHide: true,
                caption: caption || props.defaultCaption,
                getContainerNode: props.getContainerNode,
                title: props.language.controls.lineHeight,
                ref: function ref(instance) {
                  return (dropDownInstance = instance);
                },
                className: "control-item dropdown bf-line-height-dropdown"
              },
              external_react_default.a.createElement(
                "ul",
                {
                  className: "bf-line-heights"
                },
                props.lineHeights.map(function(item, index) {
                  return external_react_default.a.createElement(
                    "li",
                    {
                      key: index,
                      className: item === currentLineHeight ? "active" : null,
                      "data-size": item,
                      onClick: function onClick(event) {
                        LineHeight_toggleLineHeight(event, props),
                          dropDownInstance.hide();
                      }
                    },
                    item
                  );
                })
              )
            );
          };
          // EXTERNAL MODULE: ./components/business/FontFamily/style.scss
          var FontFamily_style = __webpack_require__(61);

          // CONCATENATED MODULE: ./components/business/FontFamily/index.jsx

          var FontFamily_toggleFontFamily = function toggleFontFamily(
            event,
            props
          ) {
            var fontFamilyName = event.currentTarget.dataset.name;
            var hookReturns = props.hooks("toggle-font-family", fontFamilyName)(
              fontFamilyName,
              props.fontFamilies
            );

            if (hookReturns === false) {
              return false;
            }

            if (typeof hookReturns === "string") {
              fontFamilyName = hookReturns;
            }

            props.editor.setValue(
              external_braft_utils_["ContentUtils"].toggleSelectionFontFamily(
                props.editorState,
                fontFamilyName
              )
            );
            props.editor.requestFocus();
          };

          /* harmony default export */ var FontFamily = function(props) {
            var caption = null;
            var currentIndex = null;
            var dropDownInstance = null;
            props.fontFamilies.find(function(item, index) {
              if (
                external_braft_utils_["ContentUtils"].selectionHasInlineStyle(
                  props.editorState,
                  "FONTFAMILY-" + item.name
                )
              ) {
                caption = item.name;
                currentIndex = index;
                return true;
              }

              return false;
            });
            return external_react_default.a.createElement(
              DropDown_DropDown,
              {
                caption: caption || props.defaultCaption,
                getContainerNode: props.getContainerNode,
                title: props.language.controls.fontFamily,
                autoHide: true,
                arrowActive: currentIndex === 0,
                ref: function ref(instance) {
                  return (dropDownInstance = instance);
                },
                className: "control-item dropdown font-family-dropdown"
              },
              external_react_default.a.createElement(
                "ul",
                {
                  className: "menu"
                },
                props.fontFamilies.map(function(item, index) {
                  return external_react_default.a.createElement(
                    "li",
                    {
                      key: index,
                      className:
                        "menu-item " + (index === currentIndex ? "active" : ""),
                      "data-name": item.name,
                      onClick: function onClick(event) {
                        FontFamily_toggleFontFamily(event, props),
                          dropDownInstance.hide();
                      }
                    },
                    external_react_default.a.createElement(
                      "span",
                      {
                        style: {
                          fontFamily: item.family
                        }
                      },
                      item.name
                    )
                  );
                })
              )
            );
          };
          // CONCATENATED MODULE: ./components/business/TextAlign/index.jsx

          var TextAlign_TextAlign =
            /*#__PURE__*/
            (function(_React$Component) {
              inherits_default()(TextAlign, _React$Component);

              function TextAlign() {
                var _getPrototypeOf2;

                var _this;

                classCallCheck_default()(this, TextAlign);

                for (
                  var _len = arguments.length, args = new Array(_len), _key = 0;
                  _key < _len;
                  _key++
                ) {
                  args[_key] = arguments[_key];
                }

                _this = possibleConstructorReturn_default()(
                  this,
                  (_getPrototypeOf2 = getPrototypeOf_default()(
                    TextAlign
                  )).call.apply(_getPrototypeOf2, [this].concat(args))
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "state",
                  {
                    currentAlignment: undefined
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "setAlignment",
                  function(event) {
                    var alignment = event.currentTarget.dataset.alignment;

                    var hookReturns = _this.props.hooks(
                      "toggle-text-alignment",
                      alignment
                    )(alignment);

                    if (_this.props.textAligns.indexOf(hookReturns) > -1) {
                      alignment = hookReturns;
                    }

                    _this.props.editor.setValue(
                      external_braft_utils_[
                        "ContentUtils"
                      ].toggleSelectionAlignment(
                        _this.props.editorState,
                        alignment
                      )
                    );

                    _this.props.editor.requestFocus();
                  }
                );

                return _this;
              }

              createClass_default()(TextAlign, [
                {
                  key: "componentWillReceiveProps",
                  value: function componentWillReceiveProps(next) {
                    this.setState({
                      currentAlignment: external_braft_utils_[
                        "ContentUtils"
                      ].getSelectionBlockData(next.editorState, "textAlign")
                    });
                  }
                },
                {
                  key: "render",
                  value: function render() {
                    var _this2 = this;

                    var textAlignmentTitles = [
                      this.props.language.controls.alignLeft,
                      this.props.language.controls.alignCenter,
                      this.props.language.controls.alignRight,
                      this.props.language.controls.alignJustify
                    ];
                    return external_react_default.a.createElement(
                      ControlGroup,
                      null,
                      this.props.textAligns.map(function(item, index) {
                        return external_react_default.a.createElement(
                          "button",
                          {
                            type: "button",
                            key: index,
                            "data-title": textAlignmentTitles[index],
                            "data-alignment": item,
                            className:
                              "control-item button " +
                              (item === _this2.state.currentAlignment
                                ? "active"
                                : null),
                            onClick: _this2.setAlignment
                          },
                          external_react_default.a.createElement("i", {
                            className: "bfi-align-" + item
                          })
                        );
                      })
                    );
                  }
                }
              ]);

              return TextAlign;
            })(external_react_default.a.Component);

          // EXTERNAL MODULE: ./components/business/EmojiPicker/style.scss
          var EmojiPicker_style = __webpack_require__(62);

          // CONCATENATED MODULE: ./components/business/EmojiPicker/index.jsx

          var EmojiPicker_insertEmoji = function insertEmoji(event, props) {
            var emoji = event.currentTarget.dataset.emoji;
            var hookReturns = props.hooks("insert-emoji", emoji)(emoji);

            if (hookReturns === false) {
              return false;
            }

            if (typeof hookReturns === "string") {
              emoji = hookReturns;
            }

            props.editor.setValue(
              external_braft_utils_["ContentUtils"].insertText(
                props.editorState,
                emoji
              )
            );
            props.editor.requestFocus();
          };

          /* harmony default export */ var EmojiPicker = function(props) {
            return external_react_default.a.createElement(
              DropDown_DropDown,
              {
                caption: props.defaultCaption,
                autoHide: true,
                showArrow: false,
                getContainerNode: props.getContainerNode,
                title: props.language.controls.emoji,
                className: "control-item dropdown bf-emoji-dropdown"
              },
              external_react_default.a.createElement(
                "div",
                {
                  className: "bf-emojis-wrap"
                },
                external_react_default.a.createElement(
                  "ul",
                  {
                    className: "bf-emojis"
                  },
                  props.emojis.map(function(item, index) {
                    return external_react_default.a.createElement(
                      "li",
                      {
                        key: index,
                        "data-emoji": item,
                        onClick: function onClick(event) {
                          return EmojiPicker_insertEmoji(event, props);
                        }
                      },
                      item
                    );
                  })
                )
              )
            );
          };
          // EXTERNAL MODULE: ./components/business/LetterSpacing/style.scss
          var LetterSpacing_style = __webpack_require__(63);

          // CONCATENATED MODULE: ./components/business/LetterSpacing/index.jsx

          var LetterSpacing_toggleLetterSpacing = function toggleLetterSpacing(
            event,
            props
          ) {
            var letterSpacing = event.currentTarget.dataset.size;
            var hookReturns = props.hooks(
              "toggle-letter-spacing",
              letterSpacing
            )(letterSpacing);

            if (hookReturns === false) {
              return false;
            }

            if (!isNaN(hookReturns)) {
              letterSpacing = hookReturns;
            }

            props.editor.setValue(
              external_braft_utils_[
                "ContentUtils"
              ].toggleSelectionLetterSpacing(props.editorState, letterSpacing)
            );
            props.editor.requestFocus();
          };

          /* harmony default export */ var LetterSpacing = function(props) {
            var caption = null;
            var currentLetterSpacing = null;
            var dropDownInstance = null;
            props.letterSpacings.find(function(item) {
              if (
                external_braft_utils_["ContentUtils"].selectionHasInlineStyle(
                  props.editorState,
                  "LETTERSPACING-" + item
                )
              ) {
                caption = item;
                currentLetterSpacing = item;
                return true;
              }

              return false;
            });
            return external_react_default.a.createElement(
              DropDown_DropDown,
              {
                autoHide: true,
                caption: caption || props.defaultCaption,
                getContainerNode: props.getContainerNode,
                title: props.language.controls.letterSpacing,
                ref: function ref(instance) {
                  return (dropDownInstance = instance);
                },
                className: "control-item dropdown bf-letter-spacing-dropdown"
              },
              external_react_default.a.createElement(
                "ul",
                {
                  className: "bf-letter-spacings"
                },
                props.letterSpacings.map(function(item, index) {
                  return external_react_default.a.createElement(
                    "li",
                    {
                      key: index,
                      className:
                        item === currentLetterSpacing ? "active" : null,
                      "data-size": item,
                      onClick: function onClick(event) {
                        LetterSpacing_toggleLetterSpacing(event, props),
                          dropDownInstance.hide();
                      }
                    },
                    item
                  );
                })
              )
            );
          };
          // CONCATENATED MODULE: ./components/business/TextIndent/index.jsx

          var TextIndent_TextAlign =
            /*#__PURE__*/
            (function(_React$Component) {
              inherits_default()(TextAlign, _React$Component);

              function TextAlign() {
                var _getPrototypeOf2;

                var _this;

                classCallCheck_default()(this, TextAlign);

                for (
                  var _len = arguments.length, args = new Array(_len), _key = 0;
                  _key < _len;
                  _key++
                ) {
                  args[_key] = arguments[_key];
                }

                _this = possibleConstructorReturn_default()(
                  this,
                  (_getPrototypeOf2 = getPrototypeOf_default()(
                    TextAlign
                  )).call.apply(_getPrototypeOf2, [this].concat(args))
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "state",
                  {
                    currentIndent: 0
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "increaseIndent",
                  function() {
                    _this.props.editor.setValue(
                      external_braft_utils_[
                        "ContentUtils"
                      ].increaseSelectionIndent(_this.props.editorState)
                    );

                    _this.props.editor.requestFocus();
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "decreaseIndent",
                  function() {
                    _this.props.editor.setValue(
                      external_braft_utils_[
                        "ContentUtils"
                      ].decreaseSelectionIndent(_this.props.editorState)
                    );

                    _this.props.editor.requestFocus();
                  }
                );

                return _this;
              }

              createClass_default()(TextAlign, [
                {
                  key: "componentWillReceiveProps",
                  value: function componentWillReceiveProps(nextProps) {
                    this.setState({
                      currentIndent:
                        external_braft_utils_[
                          "ContentUtils"
                        ].getSelectionBlockData(
                          nextProps.editorState,
                          "textIndent"
                        ) || 0
                    });
                  }
                },
                {
                  key: "render",
                  value: function render() {
                    var currentIndent = this.state.currentIndent;
                    var language = this.props.language;
                    return external_react_default.a.createElement(
                      ControlGroup,
                      null,
                      external_react_default.a.createElement(
                        "button",
                        {
                          key: 0,
                          type: "button",
                          "data-title": language.controls.increaseIndent,
                          disabled: currentIndent >= 6,
                          className: "control-item button button-indent-increase".concat(
                            currentIndent > 0 && currentIndent < 6
                              ? " active"
                              : ""
                          ),
                          onClick: this.increaseIndent
                        },
                        external_react_default.a.createElement("i", {
                          className: "bfi-indent-increase"
                        })
                      ),
                      external_react_default.a.createElement(
                        "button",
                        {
                          key: 1,
                          type: "button",
                          "data-title": language.controls.decreaseIndent,
                          disabled: currentIndent <= 0,
                          className:
                            "control-item button button-indent-decrease",
                          onClick: this.decreaseIndent
                        },
                        external_react_default.a.createElement("i", {
                          className: "bfi-indent-decrease"
                        })
                      )
                    );
                  }
                }
              ]);

              return TextAlign;
            })(external_react_default.a.Component);

          // CONCATENATED MODULE: ./components/business/ControlBar/index.jsx

          var commandHookMap = {
            "inline-style": "toggle-inline-style",
            "block-type": "change-block-type",
            "editor-method": "exec-editor-command"
          };
          var exclusiveInlineStyles = {
            superscript: "subscript",
            subscript: "superscript"
          };

          var mergeControls = function mergeControls(
            commonProps,
            builtControls,
            extensionControls,
            extendControls
          ) {
            extensionControls = extensionControls.map(function(item) {
              return typeof item === "function" ? item(commonProps) : item;
            });
            extendControls = extendControls.map(function(item) {
              return typeof item === "function" ? item(commonProps) : item;
            });

            if (extensionControls.length === 0 && extendControls.length === 0) {
              return builtControls;
            }

            return builtControls
              .map(function(item) {
                return (
                  extendControls.find(function(subItem) {
                    return subItem.replace === (item.key || item);
                  }) ||
                  extensionControls.find(function(subItem) {
                    return subItem.replace === (item.key || item);
                  }) ||
                  item
                );
              })
              .concat(extensionControls.length ? "separator" : "")
              .concat(
                extensionControls.filter(function(item) {
                  return !item.replace;
                })
              )
              .concat(
                extendControls.filter(function(item) {
                  return typeof item === "string" || !item.replace;
                })
              );
          };

          var ControlBar_ControlBar =
            /*#__PURE__*/
            (function(_React$Component) {
              inherits_default()(ControlBar, _React$Component);

              function ControlBar() {
                var _getPrototypeOf2;

                var _this;

                classCallCheck_default()(this, ControlBar);

                for (
                  var _len = arguments.length, args = new Array(_len), _key = 0;
                  _key < _len;
                  _key++
                ) {
                  args[_key] = arguments[_key];
                }

                _this = possibleConstructorReturn_default()(
                  this,
                  (_getPrototypeOf2 = getPrototypeOf_default()(
                    ControlBar
                  )).call.apply(_getPrototypeOf2, [this].concat(args))
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "allControls",
                  []
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "mediaLibiraryModal",
                  null
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "extendedModals",
                  {}
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "openBraftFinder",
                  function() {
                    if (
                      !_this.props.braftFinder ||
                      !_this.props.braftFinder.ReactComponent
                    ) {
                      return false;
                    }

                    if (_this.props.hooks("open-braft-finder")() === false) {
                      return false;
                    }

                    var mediaProps = _this.props.media;
                    var MediaLibrary = _this.props.braftFinder.ReactComponent;
                    _this.mediaLibiraryModal = Modal_showModal({
                      title: _this.props.language.controls.mediaLibirary,
                      language: _this.props.language,
                      width: 640,
                      showFooter: false,
                      component: external_react_default.a.createElement(
                        MediaLibrary,
                        {
                          accepts: mediaProps.accepts,
                          onCancel: _this.closeBraftFinder,
                          onInsert: _this.insertMedias,
                          onChange: mediaProps.onChange,
                          externals: mediaProps.externals,
                          onBeforeSelect: _this.bindBraftFinderHook(
                            "select-medias"
                          ),
                          onBeforeDeselect: _this.bindBraftFinderHook(
                            "deselect-medias"
                          ),
                          onBeforeRemove: _this.bindBraftFinderHook(
                            "remove-medias"
                          ),
                          onBeforeInsert: _this.bindBraftFinderHook(
                            "insert-medias"
                          ),
                          onFileSelect: _this.bindBraftFinderHook(
                            "select-files"
                          )
                        }
                      )
                    });
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "bindBraftFinderHook",
                  function(hookName) {
                    return function() {
                      return _this.props
                        .hooks(
                          hookName,
                          arguments.length <= 0 ? undefined : arguments[0]
                        )
                        .apply(void 0, arguments);
                    };
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "insertMedias",
                  function(medias) {
                    _this.props.editor.setValue(
                      external_braft_utils_["ContentUtils"].insertMedias(
                        _this.props.editorState,
                        medias
                      )
                    );

                    _this.props.editor.requestFocus();

                    _this.props.media.onInsert &&
                      _this.props.media.onInsert(medias);

                    _this.closeBraftFinder();
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "closeBraftFinder",
                  function() {
                    _this.props.media.onCancel && _this.props.media.onCancel();
                    _this.mediaLibiraryModal &&
                      _this.mediaLibiraryModal.close();
                  }
                );

                return _this;
              }

              createClass_default()(ControlBar, [
                {
                  key: "componentDidUpdate",
                  value: function componentDidUpdate() {
                    var _this2 = this;

                    var language = this.props.language;
                    this.allControls.forEach(function(item) {
                      if (item.type === "modal") {
                        if (
                          item.modal &&
                          item.modal.id &&
                          _this2.extendedModals[item.modal.id]
                        ) {
                          _this2.extendedModals[item.modal.id].update(
                            objectSpread_default()({}, item.modal, {
                              language: language
                            })
                          );
                        }
                      }
                    });
                  }
                },
                {
                  key: "getControlItemClassName",
                  value: function getControlItemClassName(data) {
                    var className = "control-item button";
                    var type = data.type,
                      command = data.command;

                    if (
                      type === "inline-style" &&
                      external_braft_utils_[
                        "ContentUtils"
                      ].selectionHasInlineStyle(this.props.editorState, command)
                    ) {
                      className += " active";
                    } else if (
                      type === "block-type" &&
                      external_braft_utils_[
                        "ContentUtils"
                      ].getSelectionBlockType(this.props.editorState) ===
                        command
                    ) {
                      className += " active";
                    } else if (
                      type === "entity" &&
                      external_braft_utils_[
                        "ContentUtils"
                      ].getSelectionEntityType(this.props.editorState) ===
                        command
                    ) {
                      className += " active";
                    }

                    return className;
                  }
                },
                {
                  key: "applyControl",
                  value: function applyControl(command, type) {
                    var data =
                      arguments.length > 2 && arguments[2] !== undefined
                        ? arguments[2]
                        : {};
                    var hookReturns = this.props.hooks(
                      commandHookMap[type] || type,
                      command
                    )(command);
                    var editorState = this.props.editorState;

                    if (hookReturns === false) {
                      return false;
                    }

                    if (typeof hookReturns === "string") {
                      command = hookReturns;
                    }

                    if (type === "inline-style") {
                      var exclusiveInlineStyle = exclusiveInlineStyles[command];

                      if (
                        exclusiveInlineStyle &&
                        external_braft_utils_[
                          "ContentUtils"
                        ].selectionHasInlineStyle(
                          editorState,
                          exclusiveInlineStyle
                        )
                      ) {
                        editorState = external_braft_utils_[
                          "ContentUtils"
                        ].toggleSelectionInlineStyle(
                          editorState,
                          exclusiveInlineStyle
                        );
                      }

                      this.props.editor.setValue(
                        external_braft_utils_[
                          "ContentUtils"
                        ].toggleSelectionInlineStyle(editorState, command)
                      );
                    } else if (type === "block-type") {
                      this.props.editor.setValue(
                        external_braft_utils_[
                          "ContentUtils"
                        ].toggleSelectionBlockType(editorState, command)
                      );
                    } else if (type === "entity") {
                      this.props.editor.setValue(
                        external_braft_utils_[
                          "ContentUtils"
                        ].toggleSelectionEntity(editorState, {
                          type: command,
                          mutability: data.mutability || "MUTABLE",
                          data: data.data || {}
                        })
                      );
                    } else if (type === "editor-method") {
                      this.props.editor[command] &&
                        this.props.editor[command]();
                    }
                  }
                },
                {
                  key: "render",
                  value: function render() {
                    var _this3 = this;

                    var _this$props = this.props,
                      editor = _this$props.editor,
                      editorId = _this$props.editorId,
                      editorState = _this$props.editorState,
                      className = _this$props.className,
                      style = _this$props.style,
                      controls = _this$props.controls,
                      media = _this$props.media,
                      extendControls = _this$props.extendControls,
                      language = _this$props.language,
                      hooks = _this$props.hooks,
                      colors = _this$props.colors,
                      colorPicker = _this$props.colorPicker,
                      colorPickerTheme = _this$props.colorPickerTheme,
                      colorPickerAutoHide = _this$props.colorPickerAutoHide,
                      headings = _this$props.headings,
                      fontSizes = _this$props.fontSizes,
                      fontFamilies = _this$props.fontFamilies,
                      emojis = _this$props.emojis,
                      getContainerNode = _this$props.getContainerNode,
                      lineHeights = _this$props.lineHeights,
                      letterSpacings = _this$props.letterSpacings,
                      textAligns = _this$props.textAligns,
                      textBackgroundColor = _this$props.textBackgroundColor,
                      allowInsertLinkText = _this$props.allowInsertLinkText,
                      defaultLinkTarget = _this$props.defaultLinkTarget;
                    var currentBlockType = external_braft_utils_[
                      "ContentUtils"
                    ].getSelectionBlockType(editorState);
                    var commonProps = {
                      editor: editor,
                      editorId: editorId,
                      editorState: editorState,
                      language: language,
                      getContainerNode: getContainerNode,
                      hooks: hooks
                    };
                    var renderedControls = [];
                    var editorControls = configs_controls(language, editor);
                    var extensionControls = getExtensionControls(editorId);
                    var allControls = mergeControls(
                      commonProps,
                      controls,
                      extensionControls,
                      extendControls
                    );
                    this.allControls = allControls;
                    return external_react_default.a.createElement(
                      "div",
                      {
                        className: "bf-controlbar ".concat(className || ""),
                        style: style,
                        onMouseDown: this.preventDefault
                      },
                      allControls.map(function(item, index) {
                        var itemKey =
                          typeof item === "string" ? item : item.key;

                        if (typeof itemKey !== "string") {
                          return null;
                        }

                        if (renderedControls.indexOf(itemKey) > -1) {
                          return null;
                        }

                        if (itemKey.toLowerCase() === "separator") {
                          return external_react_default.a.createElement(
                            "span",
                            {
                              key: index,
                              className: "separator-line"
                            }
                          );
                        }

                        var controlItem = editorControls.find(function(
                          subItem
                        ) {
                          return (
                            subItem.key.toLowerCase() === itemKey.toLowerCase()
                          );
                        });

                        if (typeof item !== "string") {
                          controlItem = objectSpread_default()(
                            {},
                            controlItem,
                            item
                          );
                        }

                        if (!controlItem) {
                          return null;
                        }

                        renderedControls.push(itemKey);

                        if (controlItem.type === "headings") {
                          return external_react_default.a.createElement(
                            Headings,
                            extends_default()(
                              {
                                key: index,
                                headings: headings,
                                current: currentBlockType,
                                onChange: function onChange(command) {
                                  return _this3.applyControl(
                                    command,
                                    "block-type"
                                  );
                                }
                              },
                              commonProps
                            )
                          );
                        } else if (controlItem.type === "text-color") {
                          return external_react_default.a.createElement(
                            TextColor_TextColor,
                            extends_default()(
                              {
                                key: index,
                                colors: colors,
                                colorPicker: colorPicker,
                                theme: colorPickerTheme,
                                autoHide: colorPickerAutoHide,
                                enableBackgroundColor: textBackgroundColor
                              },
                              commonProps
                            )
                          );
                        } else if (controlItem.type === "font-size") {
                          return external_react_default.a.createElement(
                            FontSize,
                            extends_default()(
                              {
                                key: index,
                                fontSizes: fontSizes,
                                defaultCaption: controlItem.title
                              },
                              commonProps
                            )
                          );
                        } else if (controlItem.type === "line-height") {
                          return external_react_default.a.createElement(
                            LineHeight,
                            extends_default()(
                              {
                                key: index,
                                lineHeights: lineHeights,
                                defaultCaption: controlItem.title
                              },
                              commonProps
                            )
                          );
                        } else if (controlItem.type === "letter-spacing") {
                          return external_react_default.a.createElement(
                            LetterSpacing,
                            extends_default()(
                              {
                                key: index,
                                letterSpacings: letterSpacings,
                                defaultCaption: controlItem.title
                              },
                              commonProps
                            )
                          );
                        } else if (controlItem.type === "text-indent") {
                          return external_react_default.a.createElement(
                            TextIndent_TextAlign,
                            extends_default()(
                              {
                                key: index,
                                defaultCaption: controlItem.title
                              },
                              commonProps
                            )
                          );
                        } else if (controlItem.type === "font-family") {
                          return external_react_default.a.createElement(
                            FontFamily,
                            extends_default()(
                              {
                                key: index,
                                fontFamilies: fontFamilies,
                                defaultCaption: controlItem.title
                              },
                              commonProps
                            )
                          );
                        } else if (controlItem.type === "emoji") {
                          return external_react_default.a.createElement(
                            EmojiPicker,
                            extends_default()(
                              {
                                key: index,
                                emojis: emojis,
                                defaultCaption: controlItem.text
                              },
                              commonProps
                            )
                          );
                        } else if (controlItem.type === "link") {
                          return external_react_default.a.createElement(
                            LinkEditor_LinkEditor,
                            extends_default()(
                              {
                                key: index,
                                defaultLinkTarget: defaultLinkTarget,
                                allowInsertLinkText: allowInsertLinkText
                              },
                              commonProps
                            )
                          );
                        } else if (controlItem.type === "text-align") {
                          return external_react_default.a.createElement(
                            TextAlign_TextAlign,
                            extends_default()(
                              {
                                key: index,
                                textAligns: textAligns
                              },
                              commonProps
                            )
                          );
                        } else if (controlItem.type === "media") {
                          if (!media.image && !media.video && !media.audio) {
                            return null;
                          }

                          return external_react_default.a.createElement(
                            "button",
                            {
                              type: "button",
                              key: index,
                              "data-title": controlItem.title,
                              disabled: controlItem.disabled,
                              className: "control-item media button",
                              onClick: _this3.openBraftFinder
                            },
                            controlItem.text
                          );
                        } else if (controlItem.type === "dropdown") {
                          return external_react_default.a.createElement(
                            DropDown_DropDown,
                            extends_default()(
                              {
                                key: index,
                                className: "control-item extend-control-item dropdown ".concat(
                                  controlItem.className || ""
                                ),
                                caption: controlItem.text,
                                htmlCaption: controlItem.html,
                                showArrow: controlItem.showArrow,
                                title: controlItem.title,
                                arrowActive: controlItem.arrowActive,
                                theme: controlItem.theme,
                                autoHide: controlItem.autoHide,
                                disabled: controlItem.disabled,
                                ref: controlItem.ref
                              },
                              commonProps
                            ),
                            controlItem.component
                          );
                        } else if (controlItem.type === "modal") {
                          return external_react_default.a.createElement(
                            "button",
                            {
                              type: "button",
                              key: index,
                              "data-title": controlItem.title,
                              disabled: controlItem.disabled,
                              className: "control-item extend-control-item button ".concat(
                                controlItem.className || ""
                              ),
                              dangerouslySetInnerHTML: controlItem.html
                                ? {
                                    __html: controlItem.html
                                  }
                                : null,
                              onClick: function onClick(event) {
                                if (controlItem.modal && controlItem.modal.id) {
                                  if (
                                    _this3.extendedModals[controlItem.modal.id]
                                  ) {
                                    _this3.extendedModals[
                                      controlItem.modal.id
                                    ].active = true;

                                    _this3.extendedModals[
                                      controlItem.modal.id
                                    ].update(
                                      objectSpread_default()(
                                        {},
                                        controlItem.modal,
                                        {
                                          language: language
                                        }
                                      )
                                    );
                                  } else {
                                    _this3.extendedModals[
                                      controlItem.modal.id
                                    ] = Modal_showModal(
                                      objectSpread_default()(
                                        {},
                                        controlItem.modal,
                                        {
                                          language: language
                                        }
                                      )
                                    );
                                    controlItem.modal.onCreate &&
                                      controlItem.modal.onCreate(
                                        _this3.extendedModals[
                                          controlItem.modal.id
                                        ]
                                      );
                                  }
                                }

                                controlItem.onClick &&
                                  controlItem.onClick(event);
                              }
                            },
                            !controlItem.html ? controlItem.text : null
                          );
                        } else if (controlItem.type === "component") {
                          return external_react_default.a.createElement(
                            "div",
                            {
                              key: index,
                              className: "component-wrapper ".concat(
                                controlItem.className || ""
                              )
                            },
                            controlItem.component
                          );
                        } else if (controlItem.type === "button") {
                          return external_react_default.a.createElement(
                            "button",
                            {
                              type: "button",
                              key: index,
                              "data-title": controlItem.title,
                              disabled: controlItem.disabled,
                              className: "control-item button ".concat(
                                controlItem.className || ""
                              ),
                              dangerouslySetInnerHTML: controlItem.html
                                ? {
                                    __html: controlItem.html
                                  }
                                : null,
                              onClick: function onClick(event) {
                                return (
                                  controlItem.onClick &&
                                  controlItem.onClick(event)
                                );
                              }
                            },
                            !controlItem.html ? controlItem.text : null
                          );
                        } else if (controlItem) {
                          var disabled = false;

                          if (controlItem.command === "undo") {
                            disabled = editorState.getUndoStack().size === 0;
                          } else if (controlItem.command === "redo") {
                            disabled = editorState.getRedoStack().size === 0;
                          }

                          return external_react_default.a.createElement(
                            "button",
                            {
                              type: "button",
                              key: index,
                              disabled: disabled,
                              "data-title": controlItem.title,
                              className: _this3.getControlItemClassName({
                                type: controlItem.type,
                                command: controlItem.command
                              }),
                              onClick: function onClick() {
                                return _this3.applyControl(
                                  controlItem.command,
                                  controlItem.type,
                                  controlItem.data
                                );
                              }
                            },
                            controlItem.text
                          );
                        }
                      })
                    );
                  }
                },
                {
                  key: "preventDefault",
                  value: function preventDefault(event) {
                    var tagName = event.target.tagName.toLowerCase();

                    if (tagName === "input" || tagName === "label");
                    else {
                      event.preventDefault();
                    }
                  }
                }
              ]);

              return ControlBar;
            })(external_react_default.a.Component);

          // CONCATENATED MODULE: ./editor/index.jsx

          var buildHooks = function buildHooks(hooks) {
            return function(hookName) {
              var defaultReturns =
                arguments.length > 1 && arguments[1] !== undefined
                  ? arguments[1]
                  : {};
              return (
                hooks[hookName] ||
                function() {
                  return defaultReturns;
                }
              );
            };
          };

          var filterColors = function filterColors(colors, colors2) {
            return colors
              .filter(function(item) {
                return !colors2.find(function(color) {
                  return color.toLowerCase() === item.toLowerCase();
                });
              })
              .filter(function(item, index, array) {
                return array.indexOf(item) === index;
              });
          };

          var editor_isControlEnabled = function isControlEnabled(
            props,
            controlName
          ) {
            return (
              toConsumableArray_default()(props.controls)
                .concat(toConsumableArray_default()(props.extendControls))
                .find(function(item) {
                  return item === controlName || item.key === controlName;
                }) && props.excludeControls.indexOf(controlName) === -1
            );
          };

          var editor_getConvertOptions = function getConvertOptions(props) {
            var editorId = props.editorId || props.id;

            var convertOptions = objectSpread_default()(
              {},
              configs_props.converts,
              props.converts,
              {
                fontFamilies: props.fontFamilies
              }
            );

            convertOptions.styleImportFn = compositeStyleImportFn(
              convertOptions.styleImportFn,
              editorId
            );
            convertOptions.styleExportFn = compositeStyleExportFn(
              convertOptions.styleExportFn,
              editorId
            );
            convertOptions.entityImportFn = compositeEntityImportFn(
              convertOptions.entityImportFn,
              editorId
            );
            convertOptions.entityExportFn = compositeEntityExportFn(
              convertOptions.entityExportFn,
              editorId
            );
            convertOptions.blockImportFn = compositeBlockImportFn(
              convertOptions.blockImportFn,
              editorId
            );
            convertOptions.blockExportFn = compositeBlockExportFn(
              convertOptions.blockExportFn,
              editorId
            );
            return convertOptions;
          };

          var editor_BraftEditor =
            /*#__PURE__*/
            (function(_React$Component) {
              inherits_default()(BraftEditor, _React$Component);

              function BraftEditor(props) {
                var _this;

                classCallCheck_default()(this, BraftEditor);

                _this = possibleConstructorReturn_default()(
                  this,
                  getPrototypeOf_default()(BraftEditor).call(this, props)
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "onChange",
                  function(editorState, callback) {
                    if (
                      !(
                        editorState instanceof external_draft_js_["EditorState"]
                      )
                    ) {
                      editorState = external_draft_js_["EditorState"].set(
                        editorState,
                        {
                          decorator: _this.editorDecorators
                        }
                      );
                    }

                    if (!editorState.convertOptions) {
                      editorState.setConvertOptions(
                        editor_getConvertOptions(_this.editorProps)
                      );
                    }

                    _this.setState(
                      {
                        editorState: editorState
                      },
                      function() {
                        _this.props.onChange &&
                          _this.props.onChange(editorState);
                        callback && callback(editorState);
                      }
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "getDraftInstance",
                  function() {
                    return _this.draftInstance;
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "getFinderInstance",
                  function() {
                    return _this.braftFinder;
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "getValue",
                  function() {
                    return _this.state.editorState;
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "setValue",
                  function(editorState, callback) {
                    return _this.onChange(editorState, callback);
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "forceRender",
                  function() {
                    var selectionState = _this.state.editorState.getSelection();

                    _this.setValue(
                      external_draft_js_["EditorState"].set(
                        _this.state.editorState,
                        {
                          decorator: _this.editorDecorators
                        }
                      ),
                      function() {
                        _this.setValue(
                          external_draft_js_["EditorState"].forceSelection(
                            _this.state.editorState,
                            selectionState
                          )
                        );
                      }
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "onTab",
                  function(event) {
                    if (
                      handlers_keyCommandHandlers(
                        "tab",
                        _this.state.editorState,
                        assertThisInitialized_default()(
                          assertThisInitialized_default()(_this)
                        )
                      ) === "handled"
                    ) {
                      event.preventDefault();
                    }

                    _this.editorProps.onTab && _this.editorProps.onTab(event);
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "onFocus",
                  function() {
                    _this.isFocused = true;
                    _this.editorProps.onFocus &&
                      _this.editorProps.onFocus(_this.state.editorState);
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "onBlur",
                  function() {
                    _this.isFocused = false;
                    _this.editorProps.onBlur &&
                      _this.editorProps.onBlur(_this.state.editorState);
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "requestFocus",
                  function() {
                    setTimeout(function() {
                      return _this.draftInstance.focus();
                    }, 0);
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleKeyCommand",
                  function(command, editorState) {
                    return handlers_keyCommandHandlers(
                      command,
                      editorState,
                      assertThisInitialized_default()(
                        assertThisInitialized_default()(_this)
                      )
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleReturn",
                  function(event, editorState) {
                    return handlers_returnHandlers(
                      event,
                      editorState,
                      assertThisInitialized_default()(
                        assertThisInitialized_default()(_this)
                      )
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleBeforeInput",
                  function(chars, editorState) {
                    return beforeInputHandlers(
                      chars,
                      editorState,
                      assertThisInitialized_default()(
                        assertThisInitialized_default()(_this)
                      )
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleDrop",
                  function(selectionState, dataTransfer) {
                    return handlers_dropHandlers(
                      selectionState,
                      dataTransfer,
                      assertThisInitialized_default()(
                        assertThisInitialized_default()(_this)
                      )
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleDroppedFiles",
                  function(selectionState, files) {
                    return droppedFilesHandlers(
                      selectionState,
                      files,
                      assertThisInitialized_default()(
                        assertThisInitialized_default()(_this)
                      )
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handlePastedFiles",
                  function(files) {
                    return pastedFilesHandlers(
                      files,
                      assertThisInitialized_default()(
                        assertThisInitialized_default()(_this)
                      )
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleCopyContent",
                  function(event) {
                    return handlers_copyHandlers(
                      event,
                      assertThisInitialized_default()(
                        assertThisInitialized_default()(_this)
                      )
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handlePastedText",
                  function(text, html, editorState) {
                    return handlers_pastedTextHandlers(
                      text,
                      html,
                      editorState,
                      assertThisInitialized_default()(
                        assertThisInitialized_default()(_this)
                      )
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "handleCompositionStart",
                  function(event) {
                    return handlers_compositionStartHandler(
                      event,
                      assertThisInitialized_default()(
                        assertThisInitialized_default()(_this)
                      )
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "undo",
                  function() {
                    _this.setValue(
                      external_braft_utils_["ContentUtils"].undo(
                        _this.state.editorState
                      )
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "redo",
                  function() {
                    _this.setValue(
                      external_braft_utils_["ContentUtils"].redo(
                        _this.state.editorState
                      )
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "removeSelectionInlineStyles",
                  function() {
                    _this.setValue(
                      external_braft_utils_[
                        "ContentUtils"
                      ].removeSelectionInlineStyles(_this.state.editorState)
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "insertHorizontalLine",
                  function() {
                    _this.setValue(
                      external_braft_utils_[
                        "ContentUtils"
                      ].insertHorizontalLine(_this.state.editorState)
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "clearEditorContent",
                  function() {
                    _this.setValue(
                      external_braft_utils_["ContentUtils"].clear(
                        _this.state.editorState
                      ),
                      function(editorState) {
                        _this.setValue(
                          external_braft_utils_[
                            "ContentUtils"
                          ].toggleSelectionIndent(editorState, 0)
                        );
                      }
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "toggleFullscreen",
                  function(fullscreen) {
                    _this.setState(
                      {
                        isFullscreen:
                          typeof fullscreen !== "undefined"
                            ? fullscreen
                            : !_this.state.isFullscreen
                      },
                      function() {
                        _this.editorProps.onFullscreen &&
                          _this.editorProps.onFullscreen(
                            _this.state.isFullscreen
                          );
                      }
                    );
                  }
                );

                defineProperty_default()(
                  assertThisInitialized_default()(
                    assertThisInitialized_default()(_this)
                  ),
                  "setEditorContainerNode",
                  function(containerNode) {
                    _this.containerNode = containerNode;
                  }
                );

                _this.editorProps = _this.getEditorProps(props);
                _this.editorDecorators = getDecorators(
                  _this.editorProps.editorId || _this.editorProps.id
                );
                _this.isFocused = false;
                _this.isLiving = false;
                _this.braftFinder = null;
                _this.valueInitialized = !!(
                  _this.props.defaultValue || _this.props.value
                );
                var defaultEditorState =
                  (_this.props.defaultValue || _this.props.value) instanceof
                  external_draft_js_["EditorState"]
                    ? _this.props.defaultValue || _this.props.value
                    : external_draft_js_["EditorState"].createEmpty(
                        _this.editorDecorators
                      );
                defaultEditorState.setConvertOptions(
                  editor_getConvertOptions(_this.editorProps)
                );
                var tempColors = [];

                if (
                  external_braft_utils_["ContentUtils"].isEditorState(
                    defaultEditorState
                  )
                ) {
                  var colors = external_braft_utils_[
                    "ColorUtils"
                  ].detectColorsFromDraftState(defaultEditorState.toRAW(true));
                  defaultEditorState.setConvertOptions(
                    editor_getConvertOptions(_this.editorProps)
                  );
                  tempColors = filterColors(colors, _this.editorProps.colors);
                }

                _this.state = {
                  tempColors: tempColors,
                  editorState: defaultEditorState,
                  isFullscreen: false,
                  draftProps: {}
                };
                _this.containerNode = null;
                return _this;
              }

              createClass_default()(BraftEditor, [
                {
                  key: "getEditorProps",
                  value: function getEditorProps(props) {
                    var _this2 = this;

                    props = props || this.props;

                    var _props = props,
                      value = _props.value,
                      defaultValue = _props.defaultValue,
                      onChange = _props.onChange,
                      restProps = objectWithoutProperties_default()(_props, [
                        "value",
                        "defaultValue",
                        "onChange"
                      ]); // eslint-disable-line no-unused-vars

                    var propInterceptors = getPropInterceptors(
                      restProps.editorId || restProps.id
                    );

                    if (propInterceptors.length === 0) {
                      return restProps;
                    }

                    var porpsMap = Object(external_immutable_["Map"])(
                      restProps
                    );
                    propInterceptors.forEach(function(interceptor) {
                      porpsMap = porpsMap.merge(
                        Object(external_immutable_["Map"])(
                          interceptor(porpsMap.toJS(), _this2) || {}
                        )
                      );
                    });
                    return porpsMap.toJS();
                  }
                },
                {
                  key: "componentWillMount",
                  value: function componentWillMount() {
                    if (editor_isControlEnabled(this.editorProps, "media")) {
                      var _this$editorProps = this.editorProps,
                        language = _this$editorProps.language,
                        media = _this$editorProps.media;

                      var _defaultProps$media$m = objectSpread_default()(
                          {},
                          configs_props.media,
                          media
                        ),
                        uploadFn = _defaultProps$media$m.uploadFn,
                        validateFn = _defaultProps$media$m.validateFn,
                        items = _defaultProps$media$m.items;

                      this.braftFinder = new external_braft_finder_default.a({
                        items: items,
                        language: language,
                        uploader: uploadFn,
                        validator: validateFn
                      });
                      this.forceUpdate();
                    }
                  }
                },
                {
                  key: "componentDidMount",
                  value: function componentDidMount() {
                    this.isLiving = true;
                  }
                },
                {
                  key: "componentDidUpdate",
                  value: function componentDidUpdate(_, prevState) {
                    if (prevState.editorState !== this.state.editorState) {
                      this.state.editorState.setConvertOptions(
                        editor_getConvertOptions(this.editorProps)
                      );
                    }
                  }
                },
                {
                  key: "componentWillReceiveProps",
                  value: function componentWillReceiveProps(props) {
                    var _this3 = this;

                    this.editorProps = this.getEditorProps(props);
                    var editorState = props.value;
                    var _this$editorProps2 = this.editorProps,
                      media = _this$editorProps2.media,
                      language = _this$editorProps2.language;
                    var currentProps = this.getEditorProps();

                    if (
                      !editor_isControlEnabled(currentProps, "media") &&
                      editor_isControlEnabled(this.editorProps, "media") &&
                      !this.braftFinder
                    ) {
                      var _defaultProps$media$m2 = objectSpread_default()(
                          {},
                          configs_props.media,
                          media
                        ),
                        uploadFn = _defaultProps$media$m2.uploadFn,
                        validateFn = _defaultProps$media$m2.validateFn,
                        items = _defaultProps$media$m2.items;

                      this.braftFinder = new external_braft_finder_default.a({
                        items: items,
                        language: language,
                        uploader: uploadFn,
                        validator: validateFn
                      });
                      this.forceUpdate();
                    }

                    if (media && media.items && this.braftFinder) {
                      this.braftFinder.setItems(media.items);
                    }

                    var nextEditorState;

                    if (
                      !this.valueInitialized &&
                      typeof this.props.defaultValue === "undefined" &&
                      external_braft_utils_["ContentUtils"].isEditorState(
                        props.defaultValue
                      )
                    ) {
                      nextEditorState = props.defaultValue;
                    } else if (
                      external_braft_utils_["ContentUtils"].isEditorState(
                        editorState
                      )
                    ) {
                      nextEditorState = editorState;
                    }

                    if (nextEditorState) {
                      if (
                        nextEditorState &&
                        nextEditorState !== this.state.editorState
                      ) {
                        var tempColors = external_braft_utils_[
                          "ColorUtils"
                        ].detectColorsFromDraftState(
                          nextEditorState.toRAW(true)
                        );
                        nextEditorState.setConvertOptions(
                          editor_getConvertOptions(this.editorProps)
                        );
                        this.setState(
                          {
                            tempColors: filterColors(
                              toConsumableArray_default()(
                                this.state.tempColors
                              ).concat(toConsumableArray_default()(tempColors)),
                              currentProps.colors
                            ),
                            editorState: nextEditorState
                          },
                          function() {
                            _this3.props.onChange &&
                              _this3.props.onChange(nextEditorState);
                          }
                        );
                      } else {
                        this.setState({
                          editorState: nextEditorState
                        });
                      }
                    }
                  }
                },
                {
                  key: "componentWillUnmount",
                  value: function componentWillUnmount() {
                    this.isLiving = false;
                    this.controlBarInstance &&
                      this.controlBarInstance.closeBraftFinder();
                  }
                },
                {
                  key: "lockOrUnlockEditor",
                  value: function lockOrUnlockEditor(editorLocked) {
                    this.setState({
                      editorLocked: editorLocked
                    });
                  }
                },
                {
                  key: "render",
                  value: function render() {
                    var _this4 = this;

                    var _this$editorProps3 = this.editorProps,
                      id = _this$editorProps3.id,
                      editorId = _this$editorProps3.editorId,
                      controls = _this$editorProps3.controls,
                      excludeControls = _this$editorProps3.excludeControls,
                      extendControls = _this$editorProps3.extendControls,
                      readOnly = _this$editorProps3.readOnly,
                      disabled = _this$editorProps3.disabled,
                      media = _this$editorProps3.media,
                      language = _this$editorProps3.language,
                      colors = _this$editorProps3.colors,
                      colorPicker = _this$editorProps3.colorPicker,
                      colorPickerTheme = _this$editorProps3.colorPickerTheme,
                      colorPickerAutoHide =
                        _this$editorProps3.colorPickerAutoHide,
                      hooks = _this$editorProps3.hooks,
                      fontSizes = _this$editorProps3.fontSizes,
                      fontFamilies = _this$editorProps3.fontFamilies,
                      emojis = _this$editorProps3.emojis,
                      placeholder = _this$editorProps3.placeholder,
                      fixPlaceholder = _this$editorProps3.fixPlaceholder,
                      headings = _this$editorProps3.headings,
                      imageControls = _this$editorProps3.imageControls,
                      imageResizable = _this$editorProps3.imageResizable,
                      lineHeights = _this$editorProps3.lineHeights,
                      letterSpacings = _this$editorProps3.letterSpacings,
                      textAligns = _this$editorProps3.textAligns,
                      textBackgroundColor =
                        _this$editorProps3.textBackgroundColor,
                      allowInsertLinkText =
                        _this$editorProps3.allowInsertLinkText,
                      defaultLinkTarget = _this$editorProps3.defaultLinkTarget,
                      extendAtomics = _this$editorProps3.extendAtomics,
                      className = _this$editorProps3.className,
                      style = _this$editorProps3.style,
                      controlBarClassName =
                        _this$editorProps3.controlBarClassName,
                      controlBarStyle = _this$editorProps3.controlBarStyle,
                      contentClassName = _this$editorProps3.contentClassName,
                      contentStyle = _this$editorProps3.contentStyle,
                      stripPastedStyles = _this$editorProps3.stripPastedStyles,
                      componentBelowControlBar =
                        _this$editorProps3.componentBelowControlBar;
                    var _this$state = this.state,
                      isFullscreen = _this$state.isFullscreen,
                      editorState = _this$state.editorState;
                    editorId = editorId || id;
                    hooks = buildHooks(hooks);
                    controls = controls.filter(function(item) {
                      return excludeControls.indexOf(item) === -1;
                    });
                    language =
                      (typeof language === "function"
                        ? language(languages, "braft-editor")
                        : languages[language]) ||
                      languages[configs_props.language];
                    var externalMedias =
                      media && media.externals
                        ? objectSpread_default()(
                            {},
                            configs_props.media.externals,
                            media.externals
                          )
                        : configs_props.media.externals;
                    var accepts =
                      media && media.accepts
                        ? objectSpread_default()(
                            {},
                            configs_props.media.accepts,
                            media.accepts
                          )
                        : configs_props.media.accepts;
                    media = objectSpread_default()(
                      {},
                      configs_props.media,
                      media,
                      {
                        externalMedias: externalMedias,
                        accepts: accepts
                      }
                    );

                    if (!media.uploadFn) {
                      media.video = false;
                      media.audio = false;
                    }

                    var controlBarProps = {
                      editor: this,
                      editorState: editorState,
                      braftFinder: this.braftFinder,
                      ref: function ref(instance) {
                        return (_this4.controlBarInstance = instance);
                      },
                      getContainerNode: function getContainerNode() {
                        return _this4.containerNode;
                      },
                      className: controlBarClassName,
                      style: controlBarStyle,
                      colors: toConsumableArray_default()(colors).concat(
                        toConsumableArray_default()(this.state.tempColors)
                      ),
                      colorPicker: colorPicker,
                      colorPickerTheme: colorPickerTheme,
                      colorPickerAutoHide: colorPickerAutoHide,
                      hooks: hooks,
                      editorId: editorId,
                      media: media,
                      controls: controls,
                      language: language,
                      extendControls: extendControls,
                      headings: headings,
                      fontSizes: fontSizes,
                      fontFamilies: fontFamilies,
                      emojis: emojis,
                      lineHeights: lineHeights,
                      letterSpacings: letterSpacings,
                      textAligns: textAligns,
                      textBackgroundColor: textBackgroundColor,
                      allowInsertLinkText: allowInsertLinkText,
                      defaultLinkTarget: defaultLinkTarget
                    };
                    var unitExportFn = editorState.convertOptions.unitExportFn;
                    var commonProps = {
                      editor: this,
                      editorId: editorId,
                      hooks: hooks,
                      editorState: editorState,
                      containerNode: this.containerNode,
                      imageControls: imageControls,
                      imageResizable: imageResizable,
                      language: language,
                      extendAtomics: extendAtomics
                    };
                    var blockRendererFn = getBlockRendererFn(
                      commonProps,
                      this.editorProps.blockRendererFn
                    );
                    var blockRenderMap = getBlockRenderMap(
                      commonProps,
                      this.editorProps.blockRenderMap
                    );
                    var blockStyleFn = getBlockStyleFn(
                      this.editorProps.blockStyleFn
                    );
                    var customStyleMap = getCustomStyleMap(
                      commonProps,
                      this.editorProps.customStyleMap
                    );
                    var customStyleFn = getCustomStyleFn(commonProps, {
                      fontFamilies: fontFamilies,
                      unitExportFn: unitExportFn,
                      customStyleFn: this.editorProps.customStyleFn
                    });
                    var keyBindingFn = keybindings(
                      this.editorProps.keyBindingFn
                    );
                    var mixedProps = {};

                    if (
                      this.state.editorLocked ||
                      this.editorProps.disabled ||
                      this.editorProps.readOnly ||
                      this.editorProps.draftProps.readOnly
                    ) {
                      mixedProps.readOnly = true;
                    }

                    if (
                      placeholder &&
                      fixPlaceholder &&
                      editorState.isEmpty() &&
                      editorState
                        .getCurrentContent()
                        .getFirstBlock()
                        .getType() !== "unstyled"
                    ) {
                      placeholder = "";
                    }

                    var draftProps = objectSpread_default()(
                      {
                        ref: function ref(instance) {
                          _this4.draftInstance = instance;
                        },
                        editorState: editorState,
                        handleKeyCommand: this.handleKeyCommand,
                        handleReturn: this.handleReturn,
                        handleBeforeInput: this.handleBeforeInput,
                        handleDrop: this.handleDrop,
                        handleDroppedFiles: this.handleDroppedFiles,
                        handlePastedText: this.handlePastedText,
                        handlePastedFiles: this.handlePastedFiles,
                        onChange: this.onChange,
                        onTab: this.onTab,
                        onFocus: this.onFocus,
                        onBlur: this.onBlur,
                        blockRenderMap: blockRenderMap,
                        blockRendererFn: blockRendererFn,
                        blockStyleFn: blockStyleFn,
                        customStyleMap: customStyleMap,
                        customStyleFn: customStyleFn,
                        keyBindingFn: keyBindingFn,
                        placeholder: placeholder,
                        stripPastedStyles: stripPastedStyles
                      },
                      this.editorProps.draftProps,
                      mixedProps
                    );

                    return external_react_default.a.createElement(
                      "div",
                      {
                        style: style,
                        ref: this.setEditorContainerNode,
                        className: "bf-container "
                          .concat(className)
                          .concat(disabled ? " disabled" : "")
                          .concat(readOnly ? " read-only" : "")
                          .concat(isFullscreen ? " fullscreen" : "")
                      },
                      external_react_default.a.createElement(
                        ControlBar_ControlBar,
                        controlBarProps
                      ),
                      componentBelowControlBar,
                      external_react_default.a.createElement(
                        "div",
                        {
                          onCompositionStart: this.handleCompositionStart,
                          className: "bf-content ".concat(contentClassName),
                          onCopy: this.handleCopyContent,
                          style: contentStyle
                        },
                        external_react_default.a.createElement(
                          external_draft_js_["Editor"],
                          draftProps
                        )
                      )
                    );
                  }
                }
              ]);

              return BraftEditor;
            })(external_react_default.a.Component);

          defineProperty_default()(
            editor_BraftEditor,
            "defaultProps",
            configs_props
          );

          // EXTERNAL MODULE: external "braft-convert"
          var external_braft_convert_ = __webpack_require__(14);

          // CONCATENATED MODULE: ./index.jsx
          /* concated harmony reexport EditorState */ __webpack_require__.d(
            __webpack_exports__,
            "EditorState",
            function() {
              return external_draft_js_["EditorState"];
            }
          );
          /* concated harmony reexport getDecorators */ __webpack_require__.d(
            __webpack_exports__,
            "getDecorators",
            function() {
              return getDecorators;
            }
          );

          external_draft_js_[
            "EditorState"
          ].prototype.setConvertOptions = function() {
            var options =
              arguments.length > 0 && arguments[0] !== undefined
                ? arguments[0]
                : {};
            this.convertOptions = options;
          };

          external_draft_js_["EditorState"].prototype.toHTML = function() {
            var options =
              arguments.length > 0 && arguments[0] !== undefined
                ? arguments[0]
                : {};
            var convertOptions = this.convertOptions || {};
            return Object(external_braft_convert_["convertEditorStateToHTML"])(
              this,
              objectSpread_default()({}, convertOptions, options)
            );
          };

          external_draft_js_["EditorState"].prototype.toRAW = function(
            noStringify
          ) {
            return noStringify
              ? Object(external_braft_convert_["convertEditorStateToRaw"])(this)
              : JSON.stringify(
                  Object(external_braft_convert_["convertEditorStateToRaw"])(
                    this
                  )
                );
          };

          external_draft_js_["EditorState"].prototype.toText = function() {
            return this.getCurrentContent().getPlainText();
          };

          external_draft_js_["EditorState"].prototype.isEmpty = function() {
            return !this.getCurrentContent().hasText();
          };

          editor_BraftEditor.createEditorState = external_draft_js_[
            "EditorState"
          ].createFrom = function(content) {
            var options =
              arguments.length > 1 && arguments[1] !== undefined
                ? arguments[1]
                : {};
            options.unitExportFn =
              options.unitExportFn ||
              editor_BraftEditor.defaultProps.converts.unitExportFn;
            options.styleImportFn = compositeStyleImportFn(
              options.styleImportFn,
              options.editorId
            );
            options.entityImportFn = compositeEntityImportFn(
              options.entityImportFn,
              options.editorId
            );
            options.blockImportFn = compositeBlockImportFn(
              options.blockImportFn,
              options.editorId
            );
            var editorState = null;

            if (content instanceof external_draft_js_["EditorState"]) {
              editorState = content;
            } else if (
              typeof_default()(content) === "object" &&
              content &&
              content.blocks &&
              content.entityMap
            ) {
              editorState = Object(
                external_braft_convert_["convertRawToEditorState"]
              )(content, getDecorators(options.editorId));
            } else if (typeof content === "string") {
              try {
                if (/^(-)?\d+$/.test(content)) {
                  editorState = Object(
                    external_braft_convert_["convertHTMLToEditorState"]
                  )(
                    content,
                    getDecorators(options.editorId),
                    options,
                    "create"
                  );
                } else {
                  editorState = external_draft_js_["EditorState"].createFrom(
                    JSON.parse(content),
                    options
                  );
                }
              } catch (error) {
                editorState = Object(
                  external_braft_convert_["convertHTMLToEditorState"]
                )(content, getDecorators(options.editorId), options, "create");
              }
            } else if (typeof content === "number") {
              editorState = Object(
                external_braft_convert_["convertHTMLToEditorState"]
              )(
                content.toLocaleString().replace(/,/g, ""),
                getDecorators(options.editorId),
                options,
                "create"
              );
            } else {
              editorState = external_draft_js_["EditorState"].createEmpty(
                getDecorators(options.editorId)
              );
            }

            options.styleExportFn = compositeStyleExportFn(
              options.styleExportFn,
              options.editorId
            );
            options.entityExportFn = compositeEntityExportFn(
              options.entityExportFn,
              options.editorId
            );
            options.blockExportFn = compositeBlockExportFn(
              options.blockExportFn,
              options.editorId
            );
            editorState.setConvertOptions(options);
            return editorState;
          };

          /* harmony default export */ var index_0 = (__webpack_exports__[
            "default"
          ] = createExtensibleEditor(editor_BraftEditor));
          // 2.1版本开发计划
          // [ ]优化选中多行文字是插入链接报错的问题
          // [ ]新增编辑器内图片删除hook
          // 2.2版本开发计划
          // [ ]表格功能
          // [ ]美化UI，包括图标和界面风格
          // 2.3版本开发计划
          // [ ]初级md快捷输入支持
          // [ ]图片裁切等简单的编辑功能
          // [ ]允许自定义快捷键

          /***/
        },
        /* 40 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        ,
        /* 41 */ /* 42 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        ,
        ,
        /* 43 */ /* 44 */ /* 45 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 46 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 47 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 48 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 49 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 50 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 51 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 52 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 53 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 54 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 55 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 56 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 57 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 58 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 59 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 60 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 61 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 62 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },
        /* 63 */
        /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        }
        /******/
      ]
    );
  });
});

var BraftEditor = _commonjsHelpers.unwrapExports(dist$3);

var css =
  '.index_bf-controlbar__ej8fA{margin:0;padding:0 5px;box-shadow:inset 0 -1px 0 0 rgba(0,0,0,.2)}.index_bf-controlbar__ej8fA:after{display:block;content:"";clear:both}.index_bf-controlbar__ej8fA button{padding:0;outline:none}.index_bf-controlbar__ej8fA button[disabled]{pointer-events:none;opacity:.3}.index_bf-controlbar__ej8fA [data-title]{position:relative}.index_bf-controlbar__ej8fA [data-title]:after,.index_bf-controlbar__ej8fA [data-title]:before{position:absolute;z-index:10;top:100%;left:50%;pointer-events:none;opacity:0;transform:translateX(-50%) translateY(-5px);transition:opacity .3s,transform .3s}.index_bf-controlbar__ej8fA [data-title]:before{margin-top:3px;border:5px solid transparent;border-bottom-color:#21242a;content:""}.index_bf-controlbar__ej8fA [data-title]:after{margin-top:12px;padding:5px;background-color:#21242a;border-radius:2px;box-shadow:0 5px 15px rgba(0,0,0,.2);color:#fff;font-size:12px;line-height:16px;white-space:nowrap;content:attr(data-title)}.index_bf-controlbar__ej8fA [data-title]:hover:after,.index_bf-controlbar__ej8fA [data-title]:hover:before{opacity:1;transform:translateX(-50%) translateY(0)}.index_bf-controlbar__ej8fA input{outline:none}.index_bf-controlbar__ej8fA .index_separator-line__3SV92{display:block;float:left;height:26px;width:1px;margin:10px;box-shadow:inset -1px 0 0 0 rgba(0,0,0,.1)}.index_bf-controlbar__ej8fA .index_separator-line__3SV92+.index_control-item__2E9Ul,.index_bf-controlbar__ej8fA .index_separator-line__3SV92+.index_control-item-group__2GENZ{margin-left:0}.index_bf-controlbar__ej8fA .index_separator-line__3SV92+.index_separator-line__3SV92,.index_bf-controlbar__ej8fA .index_separator-line__3SV92.index_first-child__2fRfM,.index_bf-controlbar__ej8fA .index_separator-line__3SV92.index_last-child__1d0yb{display:none}.index_bf-controlbar__ej8fA .index_control-item-group__2GENZ{float:left;height:36px;margin:5px 0 5px 3px}.index_bf-controlbar__ej8fA .index_control-item-group__2GENZ:first-child{margin-left:0}.index_bf-controlbar__ej8fA .index_control-item-group__2GENZ>.index_control-item__2E9Ul{margin-top:0;margin-bottom:0}.index_bf-controlbar__ej8fA .index_dropdown-handler__1xChS{border-radius:2px}.index_bf-controlbar__ej8fA .index_control-item__2E9Ul{display:block;float:left;height:36px;margin:5px 0 5px 3px;border-radius:2px;cursor:pointer}.index_bf-controlbar__ej8fA .index_control-item__2E9Ul.index_component-wrapper__OLlmp{cursor:default}.index_bf-controlbar__ej8fA .index_control-item__2E9Ul:first-child{margin-left:0}.index_bf-controlbar__ej8fA .index_control-item__2E9Ul.index_button__2IaUw{box-sizing:border-box;min-width:36px;padding:0 8px;background-color:transparent;border:none;color:#6a6f7b;font-size:14px}.index_bf-controlbar__ej8fA .index_control-item__2E9Ul.index_button__2IaUw:hover{background-color:rgba(0,0,0,.05)}.index_bf-controlbar__ej8fA .index_control-item__2E9Ul.index_button__2IaUw.index_active__3_mlp{color:#3498db}.index_bf-controlbar__ej8fA .index_control-item__2E9Ul.index_button__2IaUw i:before{display:block;height:36px;font-size:18px;line-height:36px}.index_bf-controlbar__ej8fA .index_control-item__2E9Ul.index_button__2IaUw .index_bfi-redo__1Q-LG:before,.index_bf-controlbar__ej8fA .index_control-item__2E9Ul.index_button__2IaUw .index_bfi-undo___pDce:before{font-size:14px}.index_bf-controlbar__ej8fA .index_dropdown__1rkgF .index_control-item__2E9Ul{width:100%;float:none;margin:0}.index_DraftEditor-editorContainer__1FR0o,.index_DraftEditor-root__mlfOI,.index_public-DraftEditor-content__T2mZu{height:inherit;text-align:initial}.index_public-DraftEditor-content__T2mZu[contenteditable=true]{-webkit-user-modify:read-write-plaintext-only}.index_DraftEditor-root__mlfOI{position:relative}.index_DraftEditor-editorContainer__1FR0o{background-color:hsla(0,0%,100%,0);border-left:.1px solid transparent;position:relative;z-index:1}.index_public-DraftEditor-block__IOQ0s{position:relative}.index_DraftEditor-alignLeft__gR9_E .index_public-DraftStyleDefault-block__3m05I{text-align:left}.index_DraftEditor-alignLeft__gR9_E .index_public-DraftEditorPlaceholder-root__1T6lJ{left:0;text-align:left}.index_DraftEditor-alignCenter__3Fyko .index_public-DraftStyleDefault-block__3m05I{text-align:center}.index_DraftEditor-alignCenter__3Fyko .index_public-DraftEditorPlaceholder-root__1T6lJ{margin:0 auto;text-align:center;width:100%}.index_DraftEditor-alignRight__3ghf4 .index_public-DraftStyleDefault-block__3m05I{text-align:right}.index_DraftEditor-alignRight__3ghf4 .index_public-DraftEditorPlaceholder-root__1T6lJ{right:0;text-align:right}.index_public-DraftEditorPlaceholder-root__1T6lJ{color:#9197a3;position:absolute;z-index:1}.index_public-DraftEditorPlaceholder-hasFocus__kQoHC{color:#bdc1c9}.index_DraftEditorPlaceholder-hidden__22I_U{display:none}.index_public-DraftStyleDefault-block__3m05I{position:relative;white-space:pre-wrap}.index_public-DraftStyleDefault-ltr__3qMdW{direction:ltr;text-align:left}.index_public-DraftStyleDefault-rtl__2k3sG{direction:rtl;text-align:right}.index_public-DraftStyleDefault-listLTR__Mmamr{direction:ltr}.index_public-DraftStyleDefault-listRTL__2WhLE{direction:rtl}.index_public-DraftStyleDefault-ol__32plX,.index_public-DraftStyleDefault-ul__1_opE{margin:16px 0;padding:0}.index_public-DraftStyleDefault-depth0__2YvNJ.index_public-DraftStyleDefault-listLTR__Mmamr{margin-left:1.5em}.index_public-DraftStyleDefault-depth0__2YvNJ.index_public-DraftStyleDefault-listRTL__2WhLE{margin-right:1.5em}.index_public-DraftStyleDefault-depth1__3dbfg.index_public-DraftStyleDefault-listLTR__Mmamr{margin-left:3em}.index_public-DraftStyleDefault-depth1__3dbfg.index_public-DraftStyleDefault-listRTL__2WhLE{margin-right:3em}.index_public-DraftStyleDefault-depth2__2mADP.index_public-DraftStyleDefault-listLTR__Mmamr{margin-left:4.5em}.index_public-DraftStyleDefault-depth2__2mADP.index_public-DraftStyleDefault-listRTL__2WhLE{margin-right:4.5em}.index_public-DraftStyleDefault-depth3__1V80Q.index_public-DraftStyleDefault-listLTR__Mmamr{margin-left:6em}.index_public-DraftStyleDefault-depth3__1V80Q.index_public-DraftStyleDefault-listRTL__2WhLE{margin-right:6em}.index_public-DraftStyleDefault-depth4__9Zzf6.index_public-DraftStyleDefault-listLTR__Mmamr{margin-left:7.5em}.index_public-DraftStyleDefault-depth4__9Zzf6.index_public-DraftStyleDefault-listRTL__2WhLE{margin-right:7.5em}.index_public-DraftStyleDefault-unorderedListItem__fNkjl{list-style-type:square;position:relative}.index_public-DraftStyleDefault-unorderedListItem__fNkjl.index_public-DraftStyleDefault-depth0__2YvNJ{list-style-type:disc}.index_public-DraftStyleDefault-unorderedListItem__fNkjl.index_public-DraftStyleDefault-depth1__3dbfg{list-style-type:circle}.index_public-DraftStyleDefault-orderedListItem__3J0MZ{list-style-type:none;position:relative}.index_public-DraftStyleDefault-orderedListItem__3J0MZ.index_public-DraftStyleDefault-listLTR__Mmamr:before{left:-36px;position:absolute;text-align:right;width:30px}.index_public-DraftStyleDefault-orderedListItem__3J0MZ.index_public-DraftStyleDefault-listRTL__2WhLE:before{position:absolute;right:-36px;text-align:left;width:30px}.index_public-DraftStyleDefault-orderedListItem__3J0MZ:before{content:counter(a) ". ";counter-increment:a}.index_public-DraftStyleDefault-orderedListItem__3J0MZ.index_public-DraftStyleDefault-depth1__3dbfg:before{content:counter(b) ". ";counter-increment:b}.index_public-DraftStyleDefault-orderedListItem__3J0MZ.index_public-DraftStyleDefault-depth2__2mADP:before{content:counter(c) ". ";counter-increment:c}.index_public-DraftStyleDefault-orderedListItem__3J0MZ.index_public-DraftStyleDefault-depth3__1V80Q:before{content:counter(d) ". ";counter-increment:d}.index_public-DraftStyleDefault-orderedListItem__3J0MZ.index_public-DraftStyleDefault-depth4__9Zzf6:before{content:counter(e) ". ";counter-increment:e}.index_public-DraftStyleDefault-depth0__2YvNJ.index_public-DraftStyleDefault-reset__1awm7{counter-reset:a}.index_public-DraftStyleDefault-depth1__3dbfg.index_public-DraftStyleDefault-reset__1awm7{counter-reset:b}.index_public-DraftStyleDefault-depth2__2mADP.index_public-DraftStyleDefault-reset__1awm7{counter-reset:c}.index_public-DraftStyleDefault-depth3__1V80Q.index_public-DraftStyleDefault-reset__1awm7{counter-reset:d}.index_public-DraftStyleDefault-depth4__9Zzf6.index_public-DraftStyleDefault-reset__1awm7{counter-reset:e}.index_bf-switch__1LPr-{position:relative;width:32px;height:16px;background-color:hsla(0,0%,100%,.15);border-radius:8px;transition:background .3s}.index_bf-switch__1LPr-.index_active__3_mlp{background-color:#3498db}.index_bf-switch__1LPr-.index_active__3_mlp:before{left:16px}.index_bf-switch__1LPr-:before{position:absolute;left:0;display:block;width:16px;height:16px;border-radius:8px;background-color:#eee;content:"";transform:scale(1.2);transition:.3s}@font-face{font-family:braft-icons;src:url(data:application/font-woff;base64,d09GRgABAAAAACxUAAsAAAAALAgAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAABPUy8yAAABCAAAAGAAAABgDxIH02NtYXAAAAFoAAAA9AAAAPQXCcwWZ2FzcAAAAlwAAAAIAAAACAAAABBnbHlmAAACZAAAJggAACYI9aImY2hlYWQAAChsAAAANgAAADYTSfwFaGhlYQAAKKQAAAAkAAAAJAfCBAxobXR4AAAoyAAAASwAAAEsIgAgXGxvY2EAACn0AAAAmAAAAJhQxVqgbWF4cAAAKowAAAAgAAAAIABVAH1uYW1lAAAqrAAAAYYAAAGGmUoJ+3Bvc3QAACw0AAAAIAAAACAAAwAAAAMD+QGQAAUAAAKZAswAAACPApkCzAAAAesAMwEJAAAAAAAAAAAAAAAAAAAAARAAAAAAAAAAAAAAAAAAAAAAQAAA6rADwP/AAEADwABAAAAAAQAAAAAAAAAAAAAAIAAAAAAAAwAAAAMAAAAcAAEAAwAAABwAAwABAAAAHAAEANgAAAAyACAABAASAAEAIOAp4DTgN+BC4LjiKOI547jjwuQp6SbpMelG6WjpgOms6mjqbOpu6nXqsP/9//8AAAAAACDgJuA04DfgQuC44ijiOeO448LkKekA6SzpRuln6YDprOpo6mvqbupz6rD//f//AAH/4x/eH9Qf0h/IH1Md5B3UHFYcTRvnFxEXDBb4FtgWwRaWFdsV2RXYFdQVmgADAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAH//wAPAAEAAAAAAAAAAAACAAA3OQEAAAAAAQAAAAAAAAAAAAIAADc5AQAAAAABAAAAAAAAAAAAAgAANzkBAAAAAAQAVQCAA6sC1QARACMANQBHAAATITIXFhUUBwYjISInJjU0NzYTITIXFhUUBwYjISInJjU0NzY3ITIXFhUUBwYjISInJjU0NzY3ITIXFhUUBwYjISInJjU0NzaAAwASDA0NDBL9ABIMDQ0MEgMAEgwNDQwS/QASDA0NDBIDABIMDQ0MEv0AEgwNDQwSAwASDA0NDBL9ABIMDQ0MAtUMDRESDQwMDRIRDQz+AAwNERINDAwNEhENDKsNDBIRDQwMDRESDA2rDQwSEgwNDQwSEgwNAAAABABVAIADqwLVABEAIwA1AEcAABMhMhcWFRQHBiMhIicmNTQ3NhMhMhcWFRQHBiMhIicmNTQ3NjchMhcWFRQHBiMhIicmNTQ3NjchMhcWFRQHBiMhIicmNTQ3NoADABIMDQ0MEv0AEgwNDQwSAlUSDA0MDRL9qxIMDQ0MEgMAEgwNDQwS/QASDA0NDBICVRIMDQwNEv2rEgwNDQwC1QwNERINDAwNEhENDP4ADA0REg0MDA0SEQ0Mqw0MEhENDAwNERIMDasNDBISDA0NDBISDA0AAAAEAFUAgAOrAtUAEQAkADYASQAAEyEyFxYVFAcGIyEiJyY1NDc2EyEyFxYVFAcGIyEiJyY1NDc2MychMhcWFRQHBiMhIicmNTQ3NjchMhcWFRQHBiMhIicmNTQ3NjOAAwASDA0NDBL9ABIMDQ0MZwJWEQ0MDA0R/aoRDQwMDRFVAwASDA0NDBL9ABIMDQ0MZwJWEQ0MDA0R/aoRDQwMDREC1QwNERINDAwNEhENDP4ADA0REg0MDA0SEQ0Mqw0MEhENDAwNERIMDasNDBISDA0NDBISDA0AAAAEAFUAgAOrAtUAEQAkADYASQAAEyEyFxYVFAcGIyEiJyY1NDc2EyEyFxYVFAcGIyEiJyY1NDc2MychMhcWFRQHBiMhIicmNTQ3NjchMhcWFRQHBiMhIicmNTQ3NjOAAwASDA0NDBL9ABIMDQ0MvQJVEgwNDQwS/asSDA0MDRKrAwASDA0NDBL9ABIMDQ0MvQJVEgwNDQwS/asSDA0MDRIC1QwNERINDAwNEhENDP4ADA0REg0MDA0SEQ0Mqw0MEhENDAwNERIMDasNDBISDA0NDBISDA0AAAACAQAAgQMAAtUAAwAHAAABMxEjIREzEQJWqqr+qqoC1f2sAlT9rAAAAQFWAIEDKgLVAAIAAAkCAVYB1P4sAtX+1v7WAAEAqgArA1YDgQAuAAABMhceARcWFRQHDgEHBiMiJy4BJyY1MxQXHgEXFjMyNz4BNzY1NCcuAScmIxUnNwIARj8+XRsbGxtdPj5HRj8+XRsbVhQURS8vNTUvL0UUFBQURS8vNdbWAtUbG1w+PkZHPj5dGxsbG10+Pkc2Li9FFBQUFEUvLjY1Ly5GFBSs1tYAAAMAMwCqA80CqwAEAAkADQAAEyEVITUDNSEVITc1IRX/As79MswCzv0yaALKAqtnZ/3/Z2fOZWUABQCAACsDgAMrAAMABwALAA8AEwAAAREhEQERIREDESERAREhEQMhESEDKv8AAQD/AFT/AAEA/wBWAwD9AAHVAQD/AP6sAQD/AAFUAQD/AP6sAQD/AAKq/QAAAAACAFYAKwNWAtUACAARAAABIRUjByc3IycnFwEHJwcjNwEBAAJW+ERaHmZ4dAwCaDbyQoBo/tgC1YCgWEh4CAr9ljbynPYBKAACAIAAKwN0Ax8AAwAWAAAlAScBAR4BDwEXBycBIzUBJzcXNzYyFwEoAVhS/qgCngwBDYZSPDz+gsoBfDw8UoYMJAyBAVhS/qgB6AwjDYZSPDz+hMoBfjw8UoYMDAAAAAAEAIAAKwOAAysACAARABoAIwAAATIWHQEjNSM1EzUzFRQGKwE1JRUzFSMiJj0BETQ2OwEVIxUjAyoiNFaqqlYzI6r+VqqqIjQzI6qqVgMrNCKqqlb9VqqqIzNWqqpWMyOqAaoiNFaqAAYAgAArA4ADKwAHAAsAEwAbAB8AIwAAAREzFTMVIxUXITUhJTMRIzUjNTMBIxEzFSEVIQEhFSERIRUhAoBWqqqq/lYBqv2qVlaqqgEAVFQBVv6q/lYBqv5WAQD/AAIrAQBWVFaqVFb/AFZU/lYBAFZUAlRU/lRUAAIAgABNA4ADTQATAB0AACUhESE1ISIGFREUFjMhMjY1ESMRAxUzARcBFTMRIQMr/aoBK/7VIzIyIwJWIzJV1pr+XDwBpFX+1aICVVYyJP2rIzIyIwEr/tUCq1b+XTwBo5kBKwAEAFUAIgOrA3cABAAhAD0AQgAAJTMRIxETIgcOAQcGFRQXHgEXFjMyNz4BNzY1NCcuAScmIxEiJy4BJyY1NDc+ATc2MzIXHgEXFhUUBw4BBwYDMzUjFQHVVlYrWE5OdCEiIiF0Tk5YWE5OdCEiIiF0Tk5YRz4+XRobGxpdPj5HRz4+XRobGxpdPj5yVlb3AQD/AAKAISJzTk5YWU1OdCEiIiF0Tk1ZWE5OcyIh/QAbG10+PkdGPz5cGxsbG1w+P0ZHPj5dGxsB1lVVAAAEAFUAIgOrA3cABAAhAD0AUgAAJTM1IxUTIgcOAQcGFRQXHgEXFjMyNz4BNzY1NCcuAScmIxEiJy4BJyY1NDc+ATc2MzIXHgEXFhUUBw4BBwYDIgYVMzQ2MzIWFRQGFTM0NjU0JiMB1VZWK1hOTnQhIiIhdE5OWFhOTnQhIiIhdE5OWEc+Pl0aGxsaXT4+R0c+Pl0aGxsaXT4+R0dkVjIjIzKAVoBkR81VVQKqISJzTk5YWU1OdCEiIiF0Tk1ZWE5OcyIh/QAbG10+PkdGPz5cGxsbG1w+P0ZHPj5dGxsCVmRHIzIyI0AtaEg9UEdkAAACAFUAzQOrAs0ABQALAAABJzcnCQElNyc3CQEBkcTEPP8AAQABGsTEPAEA/wABCcTEPP8A/wA8xMQ8/wD/AAAAAwErAM0C9QMiAA8AGQAiAAABPgE1NCYjIREhMjY1NCYnJzMyFhUUBisBNRMjNTMyFhUUBgKaHydjSP72ASxDWzIp74AaJiYagJWVlRslJQIAFkEgSWL9q19DME4TtyUbGiaA/oCAJRsaJgAAAQCAACYDgAN3ADQAAAEiBgclPgE1NCYnJR4BMzI2NTQmIyIGFRQWFwUuASMiBhUUFjMyNjcFDgEVFBYzMjY1NCYjAwAYKxH+0AICAgIBLREtGTVLSzU1SwIC/tMRLRk1S0s1GS0RATACAkk0NElJNAEfEg+xBw8IBw8IrxATSzU2Sko2Bw8HsBATSzU1SxIQsQcOBzNJSTM0SQAAAQErAU0C1QIiAAIAAAEXNwEr1dUCItXVAAAAAAMAVQAiA6sDdwAcACsAOgAAASIHDgEHBhUUFx4BFxYzMjc+ATc2NTQnLgEnJiMBNDc+ATc2MzIWFwEuATUBIiYnAR4BFRQHDgEHBiMCAFhOTXQiIiIidE1OWFhOTXQiIiIidE1OWP6rGxtcPj9GOmot/iIjJQFVOmotAd4jJRsbXD4/RgN3ISJ0Tk1YWE5OdCEiIiF0Tk5YWE1OdCIh/lZGPj5dGxslI/4iLWo6/qomIwHeLWs5Rz4+XRsbAAAAAAMAgADNA4ACzQADAAcACwAANyE1ITUhNSE1FSE1gAMA/QADAP0AAwDNVYBV1lZWAAEBKwF3AtUCTQACAAABNxcBK9XVAXfW1gAAAAADAasAdwJVAyIADAAYACQAAAEyNjU0JiMiBhUUFjMVIgYVFBYzMjY1NCYDIgYVFBYzMjY1NCYCACMyMiMjMjIjIzIyIyMyMiMjMjIjIzIyAnczIyMyMiMjM1UyIyMzMyMjMv8AMiMjMzMjIzIAAAAAAwCrAXcDVQIiAAwAGAAkAAABIgYVFBYzMjY1NCYjISIGFRQWMzI2NTQmISIGFRQWMzI2NTQmAQAjMjIjIzIyIwIAIzIyIyMyMv7dIzIyIyMyMgIiMiMjMzMjIzIyIyMzMyMjMjIjIzMzIyMyAAAAAAIAAP/ABAADgAApAC0AAAERIzU0JiMhIgYdARQWMyEyNj0BMxEhFSMiBhURFBY7ATI2NRE0JisBNQEhNSEEAMAmGv1AGiYmGgLAGiaA/cAgDRMTDYANExMNIAFA/UACwAGAAYBAGiYmGsAaJiYaQP8AgBMN/sANExMNAUANE0ABgEAAAAQA1QCiAysC9wAGAA0AEwAaAAATMxUzNSMVEyMVMzUjFQEzNTM1IxM1IxUzNSPVgFbWgIDWVgEAVoDWVlbWgAEigNVVAVVV1YD+K4BVAQCA1VUAAAEAZAAlA1wDXABEAAABERQHBgcGBwYjIicmJyYnJjU0NzY3Njc2MzIXEQURFAcGBwYHBiMiJyYnJicmNTQ3Njc2NzYzMhcRNDc2NyU2MzIXFhUDXBERGhkaGRYXGRoZGhEREREaGRoZFzMr/oURERoZGhkXFhkaGRoRERERGhkaGRY0KwoJDwGbBggUDg4DLP3WGBQTCgsFBQUFCwoTFBgZExQKCwUFEwEKdv6iGRMTCwsFBQUFCwsTExkZExMLCgYFEwHeDw0MBX8CDg4UAAAEAHUAQgOJA1YALwA8AGIAeAAAAS4BBw4BJy4BJy4BBwYiJyYGBw4BJyYGBxQVHAEVFBUeATM2MzoBMzIzMjY3PAE1BSImNTQ2MzIWFRQGJyUqASM8ATU6ATMUFhUUFxwBFQYHFAYHDgEnLgE3PgE3OgEzPAE1BT4BNzoBMxQWBw4BJy4BNz4BNzoBMwKBARkZChUJCxcEFEMvBw8HHikMDCgdFyILCxgWNDM0ZzQzNBsaAf77L0FBMDBAQDEBtx8/IDRoNgEBAQENCxVFICIlBgc3JAcNCf7OAQICEyQTAwUFSiMmOAIBOiYHEAkCzhcaAQEBAwIJCC0fCAEBBhgbGxYGBBMVKCgpUCgoKQ8VARcaSpRK7T8uMEA/LzBAARchPyAKEgkzMjNmMjMzFCwRIBAOD0IjJjQDN2053QwUCi5dLSUsBgVEJig+BAAAAAAEANUAogMrAvcABQALABEAFwAAASMVMzUjAzM1MzUjASMVMzUjAxUzFTM1AStW1oBWVoDWAgCA1laAgFYBd9VVASuAVf4AVdUBgFWA1QAAAAQAAAAABAADQAAbADMATwBTAAABFBceARcWMzI3PgE3NjU0Jy4BJyYjIgcOAQcGASMuASMhIgYHIyIGFREUFjMhMjY1ETQmASInLgEnJjU0Nz4BNzYzMhceARcWFRQHDgEHBgEjNTMBMBAROCYmKysmJjgREBAROCYmKysmJjgREAKQ4AwkMP8AMCQM4BomJhoDgBomJv4mOzQzTRcWFhdNMzQ7OzQzTRcWFhdNMzQBhYCAAWArJiY4ERAQETgmJisrJiY4ERAQETgmJgE1MFBQMCYa/cAaJiYaAkAaJv2EFhdNMzQ7OzQzTRcWFhdNMzQ7OzQzTRcWAbxAAAEAkQCiA4AC3gAGAAABJwcXAScBAYCzPO8CADz+PAEaszzvAgA8/jwAAAAAAQDiAIADHgLJACYAAAE3NjQnJiIPAScmIgcGFB8BBwYUFx4BMzI2PwEXHgEzMjY3NjQvAQI84g0NDCQM4uIMJAwNDeLiDQ0GEAgIEAbi4gYQCAgQBg0N4gGr4gwjDQwM4uIMDA0jDOLiDSMMBwYGB+HhBwYGBwwjDeIAAAUAVQCVA6sC6wAZACoARABeAHgAAAEhIgYHDgEVFBYXHgEzITI2Nz4BNTQmJy4BJTQmIyEiBh0BFBYzITI2PQEDISIGBw4BFRQWFx4BMyEyNjc+ATU0JicuAQMhIgYHDgEVFBYXHgEzITI2Nz4BNTQmJy4BBSEiBgcOARUUFhceATMhMjY3PgE1NCYnLgEB1f6rCQ8GBgcHBgYPCQFVCQ8GBwYGBwYPAc0ZEv8AEhkZEgEAEhkr/QAJDwYGBwcGBg8JAwAJDwYGBwcGBg8J/QAJDwYGBwcGBg8JAwAJDwYGBwcGBg/+TP6rCQ8GBgcHBgYPCQFVCQ8GBwYGBwYPAZUGBgYQCAkPBgcGBgcGDwkIEAYGBoERGRkRrBEZGRGs/tUHBgYPCQkPBgYHBwYGDwkJDwYGBwIABwYGDwkJDwYGBwcGBg8JCQ8GBgerBgcGDwkIEAYGBgYGBhAICQ8GBwYAAAAABABVAE0DqwNNAA4AEgAeACIAAAEhIgYVETMVITUzETQmIwMhNSE3IiY1NDYzMhYVFAYDIRUhAyv9qjVLqwIAq0s1gP6qAVaAEhkZEhEZGTz+AAIAAndKNv8AqqoBADZK/ivVVhkREhkZEhEZAYCrAAIAgABjA2oDTQAiAC8AAAEjJz4BNTQnLgEnJiMiBw4BBwYVFBceARcWMzI2NxcVFzcnISImNTQ2MzIWFRQGIwKVIQwfJBYWSzMyOjkzMksWFhYWSzIzOTRcJQvWP9X/AE9xcU9QcHBQAXcMJF0zOjIzSxYWFhZLMzI6OTIzSxYWJB8MItQ/1XFPUHBwUE9xAAIAZAAiA5wDdwBNAFkAAAE+ATU0Jic3PgEvAS4BDwEuAS8BLgErASIGDwEOAQcnJgYPAQYWHwEOARUUFhcHDgEfAR4BPwEeAR8BHgE7ATI2PwE+ATcXFjY/ATYmJwUiJjU0NjMyFhUUBgM9AQICAVoGAwRVBA8HahEkFBABDAiqCAwBEBQkEWoHDwRVBAMGWgECAgFaBgMEVQQPB2oRJBQQAQwIqggMARAUJBFqBw8EVQQDBv5pPldXPj5XVwGjChULCxQLRgUPB5QHBQMqDBUIcgcKCgdyCBUMKgMFB5QHDwVGCxUKCxUKRgUQB5MHBQIrDRUIcQgKCghxCBUNKwMGB5MHEAUmWD4+V1c+PlgAAQDVAKIDKwL3AAsAAAEhESMRITUhETMRIQMr/wBW/wABAFYBAAGi/wABAFUBAP8AAAAAAAQAVf/vA6sC7wAeADMAOAA9AAATNwEHJyM1JyM1Jw4BFRQWOwEVIyInLgEnJjU0NjcnBTIXHgEXFhUUBgcnPgE1NCYrATUzITMVIycFFSMnM1U3Ask2q0mMSmogJWdIgIA1Li9FFRQyKlwCVjUuL0UVFEc5PC88Z0iAgP6qgDZRAV0zVYgCuTb9NzerSYxKaxhIKklmURQURS8vNTpnIlwfFRRFLy41R3YhPRRWN0hnUVFR1lVVAAADAFUAmgOrApoAGgA1ADkAAAEjFTMyFhUUBisBFTMyNz4BNzY1NCcuAScmIwE0NjsBNSMiBw4BBwYVFBceARcWOwE1IyImNRchNSECq4CASGdnSICANS4vRRUUFBVFLy41/ftnSICANS4vRRUUFBVFLy41gIBIZ68BVv6qAppRZ0hJZlEUFEUvLzU1Li9FFRT/AEhnURUURS8uNTUvL0UUFFFmSStVAAAFAFUAIgOrA3cAHAA4AEQAUABYAAABIgcOAQcGFRQXHgEXFjMyNz4BNzY1NCcuAScmIxEiJy4BJyY1NDc+ATc2MzIXHgEXFhUUBw4BBwYTMjY1NCYjIgYVFBYhMjY1NCYjIgYVFBYTMjY3IR4BMwIAWU1OdCEiIiF0Tk1ZWE5OdCEiIiF0Tk5YRz4+XRsaGhtdPj5HRz4+XRsaGhtdPj5OGyUlGxomJv7wGiYmGhslJbBLdRr+TBp1SwN3ISJzTk5YWU1OdCEiIiF0Tk1ZWE5OcyIh/QAbG10+PkdHPj5dGhsbGl0+PkdHPj5dGxsBgCYaGyUlGxomJhobJSUbGib+61RBQVQAAAAJAAAAQAQAA0AAAwAHAAsADwATABcAGwAfACIAABMRIREBIzUzNSM1MzUjNTMBIREhEyM1MzUjNTM1IzUzBRElAAQA/MCAgICAgIACQP4AAgDAgICAgICA/cABAANA/QADAP1AgICAgID9gAKA/YCAgICAgID+gMAAAAAAAgDVAE0DKwNNABkAHgAAJTI3PgE3NjURIxEUBiMiJjURIxEUFx4BFxYHFSE1IQIANS8uRhQUa1c+PldrFBRGLi/2Alb9qvcVFEUvLzQBVv6qPVhYPQFW/qo0Ly9FFBVVVVUAAAUAVQCVA6sC6wAaACsARQBfAHoAAAEhMhYXHgEVFAYHDgEjISImJy4BNTQ2Nz4BMyU0NjMhMhYdARQGIyEiJj0BEyEyFhceARUUBgcOASMhIiYnLgE1NDY3PgETITIWFx4BFRQGBw4BIyEiJicuATU0Njc+AQUhMhYXHgEVFAYHDgEjISImJy4BNTQ2Nz4BMwIrAVUJDwYGBwcGBg8J/qsJDwYHBgYHBg8J/ioZEgEAEhkZEv8AEhkrAwAJDwYGBwcGBg8J/QAJDwYGBwcGBg8JAwAJDwYGBwcGBg8J/QAJDwYGBwcGBg8BtAFVCQ8GBgcHBgYPCf6rCQ8GBwYGBwYPCQGVBgYGEAgJDwYHBgYHBg8JCBAGBgaBERkZEawRGRkRrP7VBwYGDwkJDwYGBwcGBg8JCQ8GBgcCAAcGBg8JCQ8GBgcHBgYPCQkPBgYHqwYHBg8JCBAGBgYGBgYQCAkPBgcGAAAAAAMAgACiA4ADIgAEAA0AEQAAJTM1IxUDFTMVMzUzNSEDITUhAauqqtbWqtb9qlUDAP0AooCAAoCAgICA/lVWAAACAIAAogOrAyIACAARAAABFTMRMxEzNSEBMxEzETM1IRUBgNWA1v3V/wCAgID+gAMigP4AAgCA/qv+1QErgIAAAgDVAPcDKwKiAAYADQAAJTM3ESERMwUzNxEhETMBAIBV/wCAAQCAVv8AgPerAQD/AKurAQD/AAAGAFUAdwOAAyIACwASAB0AIgAnACwAADczFSMVMxUjFTM1IxMzNSMVMxUHMwcVMzUjNzUjFRMVITUhESE1IRURITUhFVVWKytWgIArK1YrK01NgExMgNYCVf2rAlX9qwJV/av3FSsVK6sBVasrgIBZJytaJisBAFVV/atVVQEAVVUAAAAGAGsAjQOAAw0ACwAXACMAKAAtADIAABMiBhUUFjMyNjU0JgMiBhUUFjMyNjU0JgMiBhUUFjMyNjU0JhchNSEVESE1IRURFSE1IasbJSUbGiYmGhslJRsaJiYaGyUlGxomJmYCVf2rAlX9qwJV/asCDSYaGyUlGxomAQAmGhslJRsaJv4AJhoaJiYaGiZrVVUBAFVVAVVVVQAAAAABAQAAzQMAAyIACwAAARUzAyMVITUjEzM1AatekncBVV6SdwMigP6rgIABVYAAAAABAAABawQAAesAAwAAEyEVIQAEAPwAAeuAAAAABgBA/8ADwAPAABkAIQA5AEcAVQBjAAABLgEnLgEnLgEjISIGFREUFjMhMjY1ETQmJyceARcjNR4BExQGIyEiJjURNDYzMDM6ATMyMRUUFjsBAyEiJjU0NjMhMhYVFAYnISImNTQ2MyEyFhUUBichIiY1NDYzITIWFRQGA5YRLRkaMxcnKQv+ECEvLyEC4CEvDhyFFyUNmhEphgkH/SAHCQkHTU66TU4TDeCg/kANExMNAcANExMN/kANExMNAcANExMN/kANExMNAcANExMC2xczGhktERwOLyH8oCEvLyECcAspJzYXKRGaDSX86AcJCQcDYAcJ4A0T/gATDQ0TEw0NE4ATDQ0TEw0NE4ATDQ0TEw0NEwAAAAUAAP/ABAADwAAIAAsAEwAWABwAAAERIQcRIREhESUVIwMRMzUhFQcRExUjASERMzUhAoD+QMABgAKA/MBlG8ABQMDAZQHl/gDAAUACwAEAwP3A/wADAKVl/gABwMDAwP8AAWVl/gABwMAAAAUAQP/ABAADwAANABgANAA3AD0AAAEjNTQmKwEiBh0BIxUhJyM1OAExMzgBMRUFNTQmKwEVMxUjBxEhETM1IyIGFREUFjMhFSERBRUjASERMzUhAsCAJhqAGiaAAgDAgIABQBMNQCDAwP8AIEANExMNASACgP5AZQHl/gDAAUADQEAaJiYaQICAQEDAoA0TQIDA/wACQEATDf2ADRPAAsBbZf5AAYDAAAYAgABNA4ADTQADAAcACwAPABMAFwAANyE1IRkBNycBITUhARUhNQEhNSERITUhgAMA/QCrqwFVAav+Vf6rAwD+VQGr/lUBq/5VTVUB1f6rq6r+gFYCAFZW/wBV/wBVAAYAgABNA4ADTQADAAcACwAPABMAFwAAJSE1ISUXEQcRITUhERUhNQEhNSERITUhAdUBq/5V/qurqwMA/QADAP5VAav+VQGr/lX3VoCrAVWq/oBVAqtWVv8AVf8AVQAAAAEAAP/NBAAAdwADAAA3IRUhAAQA/AB3qgAAAAACAOsA9wMVA00ACAAMAAABAzM3IRczAyMDGwEjAdXqYC8BCzBg6lY7ZmbMA039qoCAAlb+gAEO/vIAAAACAAD/wAQAA8AADgASAAABBxcDIxcBFTMBFzUlFzcFJzcXAiBgYODgsP7wJwFpsAEAYGD9wEDgQAPAYGD/ALD+lycBELDg4GBgQEDgQAAAAAEAQP/AA4oDwAARAAAFNjc2JicmBxUJARU2Fx4BBwYC+isTEzhVVqj+gAGAyXFyRignQE1bW5ozMgT+AYABgPgFTk7siokAAAEAdv/AA8ADwAASAAABNQkBNSYHDgEXFhcmJyY2NzYXAkABgP6AqFZVOBMTK2knKEZycckCyPj+gP6A/gQyM5pbW01yiYrsTk4FAAAHAAD/wAQAA0YACwAXACMALwA7AEcAUwAAJTQ2MzIWFRQGIyImATQ2MzIWFRQGIyImJTQ2MzIWFRQGIyImATQ2MzIWFRQGIyImATQ2MzIWFRQGIyImJTQ2MzIWFRQGIyImATQ2MzIWFRQGIyImAaA4KCg4OCgoOP5gOCgoODgoKDgDQDgoKDg4KCg4/To4KCg4OCgoOAJMOCgoODgoKDj9tDgoKDg4KCg4Akw4KCg4OCgoOCAoODgoKDg4AcgoODgoKDg4KCg4OCgoODgBTig4OCgoODj93Cg4OCgoODgoKDg4KCg4OAJ0KDg4KCg4OAAFAHwAAAOEA1UAIgAtADgARgBUAAABIzU0JisBIgYdASMiBhUUFjsBERQWMyEyNjURMzI2NTQmIyU0NjsBMhYdASM1ARQGIyEiJjURIREBIgYdARQWMzI2PQE0JjMiBh0BFBYzMjY9ATQmA12bRDCcMESbEBcXECdEMAGEMEQnEBcXEP4vFhCcEBboAV0XEP58EBcB0v7JEBYWEBAXF4wQFxcQEBYWAronMEREMCcXEBAW/gcwREQwAfkWEBAXJxAXFxAnJ/2TEBYWEAH5/gcBhBcQ6BAXFxDoEBcXEOgQFxcQ6BAXAAAABwAA/8AEAAPAAAMABwALAA8AEwAbACMAABMzFSM3MxUjJTMVIzczFSMlMxUjAxMhEzMTIRMBAyEDIwMhAwCAgMDAwAEAgIDAwMABAICAEBD9ABAgEAKAEP1AEAMAECAQ/YAQAcBAQEBAQEBAQEACQP5AAcD+gAGA/AABgP6AAUD+wAAABABQAIAEAAPAAAgADQAQAEAAAD8BIRczAyMDMxMzFyM3ARsBAyMiJjU0NjsBMjY1NCYrASIGFRQWFx4BOwEyFhUUBisBIgYVFBY7ATI2NTQmJy4BwjoBCDpywODAcppIOrw6AWSgoKBADRMTDYANExMNgCg4DQwNJRVADRMTDYANExMNgCg4DQwNJYDAwAKA/YACAMDA/gABAP8AAsATDQ0TEw0NEzgoEiENDxETDQ0TEw0NEzgoEiENDxEAAAAABABQ/8AEAAMAAAgADQAQAEAAAD8BIRczAyMDMxMzFyM3JQsBEyMiJjU0NjsBMjY1NCYrASIGFRQWFx4BOwEyFhUUBisBIgYVFBY7ATI2NTQmJy4BwjoBCDpywODAcppIOrw6AqSgoKBADRMTDYANExMNgCg4DQwNJRVADRMTDYANExMNgCg4DQwNJYDAwAKA/YACAMDAgP8AAQD9gBMNDRMTDQ0TOCgSIQ0PERMNDRMTDQ0TOCgSIQ0PEQAHAAD/wAQAA8AABwAPABMAFwAbAB8AIgAAAREhESMRIREFESERMxEhESUzFSMnMxUjJTMVIzczFSMlFwcBAAMAQP2AAsD9AEACgP5AgIDAgIABgICAwICA/IDAwAJAAYD+gAFA/sDA/kABwP6AAYCAQEBAQEBAQODAwAAAAQCA/8ADgAPAABcAAAEhFSMRIxEjESMRIicuAScmNTQ3PgE3NgGAAgCAgICANS8uRhQUFBRGLi8DwID8gAOA/IACABQURi4vNTUvLkYUFAACAAD/wAQAA8AAFwAaAAABIgcOAQcGFRQXHgEXFjMRMxEzETMRMzUJAgIANS8uRhQUFBRGLi81gICAgPwAAQD/AAPAFBRGLi81NS8uRhQU/gADgPyAA4CA/UABAAEAAAACAAD/wAQAA8AAFwAaAAABIgcOAQcGFRQXHgEXFjMRMxEzETMRMzUFCQEBADUvLkYUFBQURi4vNYCAgIABAP8AAQADwBQURi4vNTUvLkYUFP4AA4D8gAOAgMD/AP8AAAABAAD/zgQAA7MAYwAAASIHDgEHBhUUFx4BFxYXFjY1PAEnBiYxLgExJjYxHgExFjY3PgE3JicuAScmNTQ2Ny4BNzAWFz4BMzIWFz4BMRYGBx4BFRQHDgEHBgceARUUBhUUFjc2Nz4BNzY1NCcuAScmIwIAal1eiygoGhpdQUBMExABakISJyMnJigiXRYEEgsrKipCFBUcGQQMFUNKHkEhIUEeSkMVDAQZHBUUQyopKw4VARATTEFAXRoaKCiLXl1qA7MoKItdXmpUTU2ALy8ZBBIKCTYgF1QsHxgHAzI7BwoYIgoFDA04Ly9JKkUbCUk1AzEICQkIMQM1SQkbRSpKLy44DA0FCzAjNEwNChIEGS8wf01NVGpeXYsoKAAAAAABAAAAAQAAt9HlfV8PPPUACwQAAAAAANgVW8QAAAAA2BVbxAAA/8AEAAPAAAAACAACAAAAAAAAAAEAAAPA/8AAAAQAAAAAAAQAAAEAAAAAAAAAAAAAAAAAAABLBAAAAAAAAAAAAAAAAgAAAAQAAFUEAABVBAAAVQQAAFUEAAEABAABVgQAAKoEAAAzBAAAgAQAAFYEAACABAAAgAQAAIAEAACABAAAVQQAAFUEAABVBAABKwQAAIAEAAErBAAAVQQAAIAEAAErBAABqwQAAKsEAAAABAAA1QQAAGQEAAB1BAAA1QQAAAAEAACRBAAA4gQAAFUEAABVBAAAgAQAAGQEAADVBAAAVQQAAFUEAABVBAAAAAQAANUEAABVBAAAgAQAAIAEAADVBAAAVQQAAGsEAAEABAAAAAQAAEAEAAAABAAAQAQAAIAEAACABAAAAAQAAOsEAAAABAAAQAQAAHYEAAAABAAAfAQAAAAEAABQBAAAUAQAAAAEAACABAAAAAQAAAAEAAAAAAAAAAAKABQAHgCIAPIBXgHKAd4B7AI0AlACfgKiAtIDBgNCA3QD2gRSBHIEqAT2BQQFZAV8BYoFwgX6BjwGZgbOB3YHnggcCDIIcAkiCVoJogoqCkQKoAr0C3gLtgvoDJwMvAzcDPgNOg2IDaANrg46DnAOxA70DyQPMg9QD3gPnA/CEDoQrhDwEVARrhHsEhQSRBJ0EwQAAQAAAEsAewAJAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAA4ArgABAAAAAAABAAcAAAABAAAAAAACAAcAYAABAAAAAAADAAcANgABAAAAAAAEAAcAdQABAAAAAAAFAAsAFQABAAAAAAAGAAcASwABAAAAAAAKABoAigADAAEECQABAA4ABwADAAEECQACAA4AZwADAAEECQADAA4APQADAAEECQAEAA4AfAADAAEECQAFABYAIAADAAEECQAGAA4AUgADAAEECQAKADQApGljb21vb24AaQBjAG8AbQBvAG8AblZlcnNpb24gMS4wAFYAZQByAHMAaQBvAG4AIAAxAC4AMGljb21vb24AaQBjAG8AbQBvAG8Abmljb21vb24AaQBjAG8AbQBvAG8AblJlZ3VsYXIAUgBlAGcAdQBsAGEAcmljb21vb24AaQBjAG8AbQBvAG8AbkZvbnQgZ2VuZXJhdGVkIGJ5IEljb01vb24uAEYAbwBuAHQAIABnAGUAbgBlAHIAYQB0AGUAZAAgAGIAeQAgAEkAYwBvAE0AbwBvAG4ALgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=);font-weight:400;font-style:normal}.index_bf-container__1HxhF [class*=" bfi-"],.index_bf-container__1HxhF [class^=bfi-],.index_bf-modal-root__1P_VQ [class*=" bfi-"],.index_bf-modal-root__1P_VQ [class^=bfi-]{font-family:braft-icons!important;speak:none;font-style:normal;font-weight:400;font-variant:normal;text-transform:none;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.index_bf-container__1HxhF .index_bfi-table__2fSIV:before,.index_bf-modal-root__1P_VQ .index_bfi-table__2fSIV:before{content:"\\E228"}.index_bf-container__1HxhF .index_bfi-clear_all__2OHjw:before,.index_bf-modal-root__1P_VQ .index_bfi-clear_all__2OHjw:before{content:"\\E0B8"}.index_bf-container__1HxhF .index_bfi-format_clear__2Z6-D:before,.index_bf-modal-root__1P_VQ .index_bfi-format_clear__2Z6-D:before{content:"\\E239"}.index_bf-container__1HxhF .index_bfi-hr__1-frF:before,.index_bf-modal-root__1P_VQ .index_bfi-hr__1-frF:before{content:"\\E925"}.index_bf-container__1HxhF .index_bfi-colorize__itEld:before,.index_bf-modal-root__1P_VQ .index_bfi-colorize__itEld:before{content:"\\E3B8"}.index_bf-container__1HxhF .index_bfi-crop_free__1UXYS:before,.index_bf-modal-root__1P_VQ .index_bfi-crop_free__1UXYS:before{content:"\\E3C2"}.index_bf-container__1HxhF .index_bfi-pause__1OwwZ:before,.index_bf-modal-root__1P_VQ .index_bfi-pause__1OwwZ:before{content:"\\E034"}.index_bf-container__1HxhF .index_bfi-play_arrow__1hL7J:before,.index_bf-modal-root__1P_VQ .index_bfi-play_arrow__1hL7J:before{content:"\\E037"}.index_bf-container__1HxhF .index_bfi-bin__h1RKN:before,.index_bf-modal-root__1P_VQ .index_bfi-bin__h1RKN:before{content:"\\E9AC"}.index_bf-container__1HxhF .index_bfi-replay__11NQk:before,.index_bf-modal-root__1P_VQ .index_bfi-replay__11NQk:before{content:"\\E042"}.index_bf-container__1HxhF .index_bfi-tune__axH8Q:before,.index_bf-modal-root__1P_VQ .index_bfi-tune__axH8Q:before{content:"\\E429"}.index_bf-container__1HxhF .index_bfi-close__3PhYm:before,.index_bf-modal-root__1P_VQ .index_bfi-close__3PhYm:before{content:"\\E913"}.index_bf-container__1HxhF .index_bfi-align-center__3WjMb:before,.index_bf-modal-root__1P_VQ .index_bfi-align-center__3WjMb:before{content:"\\E028"}.index_bf-container__1HxhF .index_bfi-align-justify__1QkRU:before,.index_bf-modal-root__1P_VQ .index_bfi-align-justify__1QkRU:before{content:"\\E026"}.index_bf-container__1HxhF .index_bfi-align-left__1oX7J:before,.index_bf-modal-root__1P_VQ .index_bfi-align-left__1oX7J:before{content:"\\E027"}.index_bf-container__1HxhF .index_bfi-align-right__1eM5M:before,.index_bf-modal-root__1P_VQ .index_bfi-align-right__1eM5M:before{content:"\\E029"}.index_bf-container__1HxhF .index_bfi-image-right__2H-ST:before,.index_bf-modal-root__1P_VQ .index_bfi-image-right__2H-ST:before{content:"\\E914"}.index_bf-container__1HxhF .index_bfi-image-left__zW8ok:before,.index_bf-modal-root__1P_VQ .index_bfi-image-left__zW8ok:before{content:"\\E91E"}.index_bf-container__1HxhF .index_bfi-music__1XtpY:before,.index_bf-modal-root__1P_VQ .index_bfi-music__1XtpY:before{content:"\\E90E"}.index_bf-container__1HxhF .index_bfi-camera__2X5Zb:before,.index_bf-modal-root__1P_VQ .index_bfi-camera__2X5Zb:before{content:"\\E911"}.index_bf-container__1HxhF .index_bfi-copy__16C-6:before,.index_bf-modal-root__1P_VQ .index_bfi-copy__16C-6:before{content:"\\E92C"}.index_bf-container__1HxhF .index_bfi-file-text__12Obf:before,.index_bf-modal-root__1P_VQ .index_bfi-file-text__12Obf:before{content:"\\E926"}.index_bf-container__1HxhF .index_bfi-film__2C48n:before,.index_bf-modal-root__1P_VQ .index_bfi-film__2C48n:before{content:"\\E91C"}.index_bf-container__1HxhF .index_bfi-github__3XePr:before,.index_bf-modal-root__1P_VQ .index_bfi-github__3XePr:before{content:"\\EAB0"}.index_bf-container__1HxhF .index_bfi-ltr__rDkrQ:before,.index_bf-modal-root__1P_VQ .index_bfi-ltr__rDkrQ:before{content:"\\EA74"}.index_bf-container__1HxhF .index_bfi-page-break__DhcNp:before,.index_bf-modal-root__1P_VQ .index_bfi-page-break__DhcNp:before{content:"\\EA68"}.index_bf-container__1HxhF .index_bfi-pagebreak__m3gAm:before,.index_bf-modal-root__1P_VQ .index_bfi-pagebreak__m3gAm:before{content:"\\EA6E"}.index_bf-container__1HxhF .index_bfi-paint-format__pjAiv:before,.index_bf-modal-root__1P_VQ .index_bfi-paint-format__pjAiv:before{content:"\\E90C"}.index_bf-container__1HxhF .index_bfi-paste__G7Hrh:before,.index_bf-modal-root__1P_VQ .index_bfi-paste__G7Hrh:before{content:"\\E92D"}.index_bf-container__1HxhF .index_bfi-pilcrow__4zJYM:before,.index_bf-modal-root__1P_VQ .index_bfi-pilcrow__4zJYM:before{content:"\\EA73"}.index_bf-container__1HxhF .index_bfi-pushpin__3PUoC:before,.index_bf-modal-root__1P_VQ .index_bfi-pushpin__3PUoC:before{content:"\\E946"}.index_bf-container__1HxhF .index_bfi-redo__1Q-LG:before,.index_bf-modal-root__1P_VQ .index_bfi-redo__1Q-LG:before{content:"\\E968"}.index_bf-container__1HxhF .index_bfi-rtl__sPVOR:before,.index_bf-modal-root__1P_VQ .index_bfi-rtl__sPVOR:before{content:"\\EA75"}.index_bf-container__1HxhF .index_bfi-spinner__Dek6M:before,.index_bf-modal-root__1P_VQ .index_bfi-spinner__Dek6M:before{content:"\\E980"}.index_bf-container__1HxhF .index_bfi-subscript__kYu6m:before,.index_bf-modal-root__1P_VQ .index_bfi-subscript__kYu6m:before{content:"\\EA6C"}.index_bf-container__1HxhF .index_bfi-superscript__3qvwy:before,.index_bf-modal-root__1P_VQ .index_bfi-superscript__3qvwy:before{content:"\\EA6B"}.index_bf-container__1HxhF .index_bfi-undo___pDce:before,.index_bf-modal-root__1P_VQ .index_bfi-undo___pDce:before{content:"\\E967"}.index_bf-container__1HxhF .index_bfi-media__3Ijxb:before,.index_bf-modal-root__1P_VQ .index_bfi-media__3Ijxb:before{content:"\\E90F"}.index_bf-container__1HxhF .index_bfi-add__LigZq:before,.index_bf-modal-root__1P_VQ .index_bfi-add__LigZq:before{content:"\\E918"}.index_bf-container__1HxhF .index_bfi-bold__dn9AC:before,.index_bf-modal-root__1P_VQ .index_bfi-bold__dn9AC:before{content:"\\E904"}.index_bf-container__1HxhF .index_bfi-code__3tDKj:before,.index_bf-modal-root__1P_VQ .index_bfi-code__3tDKj:before{content:"\\E903"}.index_bf-container__1HxhF .index_bfi-done__J_3zM:before,.index_bf-modal-root__1P_VQ .index_bfi-done__J_3zM:before{content:"\\E912"}.index_bf-container__1HxhF .index_bfi-drop-down__2-Azn:before,.index_bf-modal-root__1P_VQ .index_bfi-drop-down__2-Azn:before{content:"\\E906"}.index_bf-container__1HxhF .index_bfi-drop-up__f9cHI:before,.index_bf-modal-root__1P_VQ .index_bfi-drop-up__f9cHI:before{content:"\\E909"}.index_bf-container__1HxhF .index_bfi-emoji__37yM6:before,.index_bf-modal-root__1P_VQ .index_bfi-emoji__37yM6:before{content:"\\E91B"}.index_bf-container__1HxhF .index_bfi-font-size__1cbPf:before,.index_bf-modal-root__1P_VQ .index_bfi-font-size__1cbPf:before{content:"\\E920"}.index_bf-container__1HxhF .index_bfi-fullscreen__2txWy:before,.index_bf-modal-root__1P_VQ .index_bfi-fullscreen__2txWy:before{content:"\\E910"}.index_bf-container__1HxhF .index_bfi-fullscreen-exit__33svQ:before,.index_bf-modal-root__1P_VQ .index_bfi-fullscreen-exit__33svQ:before{content:"\\E90D"}.index_bf-container__1HxhF .index_bfi-help__xa9vi:before,.index_bf-modal-root__1P_VQ .index_bfi-help__xa9vi:before{content:"\\E902"}.index_bf-container__1HxhF .index_bfi-indent-decrease__1CtRw:before,.index_bf-modal-root__1P_VQ .index_bfi-indent-decrease__1CtRw:before{content:"\\E92F"}.index_bf-container__1HxhF .index_bfi-indent-increase__2kSOy:before,.index_bf-modal-root__1P_VQ .index_bfi-indent-increase__2kSOy:before{content:"\\E92E"}.index_bf-container__1HxhF .index_bfi-info__3gDtD:before,.index_bf-modal-root__1P_VQ .index_bfi-info__3gDtD:before{content:"\\E901"}.index_bf-container__1HxhF .index_bfi-italic__1ENXj:before,.index_bf-modal-root__1P_VQ .index_bfi-italic__1ENXj:before{content:"\\E924"}.index_bf-container__1HxhF .index_bfi-link__3-0Rp:before,.index_bf-modal-root__1P_VQ .index_bfi-link__3-0Rp:before{content:"\\E91A"}.index_bf-container__1HxhF .index_bfi-link-off__2xzYa:before,.index_bf-modal-root__1P_VQ .index_bfi-link-off__2xzYa:before{content:"\\E919"}.index_bf-container__1HxhF .index_bfi-list__3GI0k:before,.index_bf-modal-root__1P_VQ .index_bfi-list__3GI0k:before{content:"\\E923"}.index_bf-container__1HxhF .index_bfi-list-numbered__U2An6:before,.index_bf-modal-root__1P_VQ .index_bfi-list-numbered__U2An6:before{content:"\\E922"}.index_bf-container__1HxhF .index_bfi-menu__YEtEG:before,.index_bf-modal-root__1P_VQ .index_bfi-menu__YEtEG:before{content:"\\E908"}.index_bf-container__1HxhF .index_bfi-more-horiz__38Kqk:before,.index_bf-modal-root__1P_VQ .index_bfi-more-horiz__38Kqk:before{content:"\\E90B"}.index_bf-container__1HxhF .index_bfi-more-vert__1Xpoy:before,.index_bf-modal-root__1P_VQ .index_bfi-more-vert__1Xpoy:before{content:"\\E90A"}.index_bf-container__1HxhF .index_bfi-not-disturb__2wwfA:before,.index_bf-modal-root__1P_VQ .index_bfi-not-disturb__2wwfA:before{content:"\\E907"}.index_bf-container__1HxhF .index_bfi-print__1Vdsh:before,.index_bf-modal-root__1P_VQ .index_bfi-print__1Vdsh:before{content:"\\E915"}.index_bf-container__1HxhF .index_bfi-quote__1xD3O:before,.index_bf-modal-root__1P_VQ .index_bfi-quote__1xD3O:before{content:"\\E921"}.index_bf-container__1HxhF .index_bfi-search__2G21G:before,.index_bf-modal-root__1P_VQ .index_bfi-search__2G21G:before{content:"\\E916"}.index_bf-container__1HxhF .index_bfi-settingsx__5qqai:before,.index_bf-modal-root__1P_VQ .index_bfi-settingsx__5qqai:before{content:"\\E917"}.index_bf-container__1HxhF .index_bfi-share__LmF7D:before,.index_bf-modal-root__1P_VQ .index_bfi-share__LmF7D:before{content:"\\E905"}.index_bf-container__1HxhF .index_bfi-share-square__sA_aV:before,.index_bf-modal-root__1P_VQ .index_bfi-share-square__sA_aV:before{content:"\\E900"}.index_bf-container__1HxhF .index_bfi-strikethrough__3Oij6:before,.index_bf-modal-root__1P_VQ .index_bfi-strikethrough__3Oij6:before{content:"\\E91F"}.index_bf-container__1HxhF .index_bfi-text-color__1p69s .index_path1__1i_Zc:before,.index_bf-modal-root__1P_VQ .index_bfi-text-color__1p69s .index_path1__1i_Zc:before{font-family:braft-icons!important;content:"\\E930";opacity:.36}.index_bf-container__1HxhF .index_bfi-text-color__1p69s .index_path2__DFG_e:before,.index_bf-modal-root__1P_VQ .index_bfi-text-color__1p69s .index_path2__DFG_e:before{font-family:braft-icons!important;content:"\\E931";margin-left:-1em}.index_bf-container__1HxhF .index_bfi-underlined__oAOe6:before,.index_bf-modal-root__1P_VQ .index_bfi-underlined__oAOe6:before{content:"\\E91D"}.index_bf-content__5lf-j{height:500px;padding-bottom:10px;overflow:auto;font-size:16px}.index_bf-content__5lf-j img{-webkit-user-select:none;user-select:none}.index_bf-content__5lf-j *{line-height:normal}.index_bf-container__1HxhF{position:relative;height:100%;padding:0}.index_bf-container__1HxhF.index_disabled__KFBp_{pointer-events:none;opacity:.7;filter:grayscale(70%)}.index_bf-container__1HxhF.index_read-only__3HgNB .index_bf-controlbar__ej8fA{pointer-events:none}.index_bf-container__1HxhF.index_read-only__3HgNB .index_bf-image__1MXDI img:hover{outline:none}.index_bf-container__1HxhF.index_read-only__3HgNB .index_bf-hr__39L4E{pointer-events:none}.index_bf-container__1HxhF.index_fullscreen__2MrQv{position:fixed;display:flex;flex-direction:column;z-index:99999;top:0;right:0;bottom:0;left:0;background-color:#fff;height:100%!important}.index_bf-container__1HxhF.index_fullscreen__2MrQv .index_bf-content__5lf-j{flex-grow:1;height:auto}.index_bf-container__1HxhF .index_input-group__1Y0_d{display:block}.index_bf-container__1HxhF .index_input-group__1Y0_d input{box-sizing:border-box;width:100%;height:36px;padding:0 15px;font-size:14px}.index_bf-container__1HxhF .index_pull-left__33hHK{float:left}.index_bf-container__1HxhF .index_pull-right__22QW0{float:right}.index_bf-container__1HxhF button{line-height:normal}.index_bf-container__1HxhF button.index_default__11aE1,.index_bf-container__1HxhF button.index_ghost__q2A8s,.index_bf-container__1HxhF button.index_primary__1ex4f{height:32px;padding:0 20px;color:#fff;font-size:12px}.index_bf-container__1HxhF button.index_default__11aE1{background-color:hsla(0,0%,100%,.15);border:none}.index_bf-container__1HxhF button.index_default__11aE1:hover{background-color:hsla(0,0%,100%,.1)}.index_bf-container__1HxhF button.index_ghost__q2A8s{background-color:transparent;border:none;box-shadow:inset 0 0 0 .5px hsla(0,0%,100%,.5)}.index_bf-container__1HxhF button.index_ghost__q2A8s:hover{box-shadow:inset 0 0 0 .5px hsla(0,0%,100%,.7)}.index_bf-container__1HxhF button.index_primary__1ex4f{background-color:#3498db;border:none;color:#fff}.index_bf-container__1HxhF button.index_primary__1ex4f:hover{background-color:#2084c7}.index_bf-container__1HxhF .index_public-DraftEditorPlaceholder-root__1T6lJ{top:15px;left:15px;font-size:16px;pointer-events:none}.index_bf-container__1HxhF .index_DraftEditor-editorContainer__1FR0o{box-sizing:border-box;border:none}.index_bf-container__1HxhF .index_DraftEditor-root__mlfOI,.index_bf-container__1HxhF .index_public-DraftEditor-content__T2mZu{height:100%}.index_bf-container__1HxhF .index_public-DraftEditor-content__T2mZu{box-sizing:border-box;padding:15px;word-wrap:break-word;word-break:break-all}.index_bf-container__1HxhF .index_public-DraftEditor-content__T2mZu>div{padding-bottom:20px}.index_bf-container__1HxhF .index_public-DraftEditor-content__T2mZu .index_braft-link__1ZeMr{color:#4078c0}.index_bf-container__1HxhF .index_public-DraftEditor-content__T2mZu blockquote{margin:0 0 10px;padding:15px 20px;background-color:#f1f2f3;border-left:5px solid #ccc;color:#666;font-style:italic}.index_bf-container__1HxhF .index_public-DraftEditor-content__T2mZu pre{max-width:100%;max-height:100%;margin:10px 0;padding:15px;overflow:auto;background-color:#f1f2f3;border-radius:3px;color:#666;font-family:monospace;font-size:14px;font-weight:400;line-height:16px;word-wrap:break-word;white-space:pre-wrap}.index_bf-container__1HxhF .index_public-DraftEditor-content__T2mZu pre pre{margin:0;padding:0}.index_bf-container__1HxhF .index_bfa-left__3CWAj,.index_bf-container__1HxhF .index_bfa-left__3CWAj .index_public-DraftStyleDefault-ltr__3qMdW{text-align:left}.index_bf-container__1HxhF .index_bfa-right__Sy5sn,.index_bf-container__1HxhF .index_bfa-right__Sy5sn .index_public-DraftStyleDefault-ltr__3qMdW{text-align:right}.index_bf-container__1HxhF .index_bfa-center__3iBxk,.index_bf-container__1HxhF .index_bfa-center__3iBxk .index_public-DraftStyleDefault-ltr__3qMdW{text-align:center}.index_bf-container__1HxhF .index_bfa-justify__C4cm4,.index_bf-container__1HxhF .index_bfa-justify__C4cm4 .index_public-DraftStyleDefault-ltr__3qMdW{text-align:justify}.index_bf-container__1HxhF .index_bfa-center__3iBxk>div,.index_bf-container__1HxhF .index_bfa-justify__C4cm4>div,.index_bf-container__1HxhF .index_bfa-left__3CWAj>div,.index_bf-container__1HxhF .index_bfa-right__Sy5sn>div{display:inline-block}.index_bf-container__1HxhF .index_bff-left__pCNho:hover,.index_bf-container__1HxhF .index_bff-right__vpxtc:hover{z-index:2}.index_bf-container__1HxhF .index_bff-left__pCNho{position:relative;z-index:1;float:left;margin:0 10px 0 0}.index_bf-container__1HxhF .index_bff-right__vpxtc{position:relative;z-index:1;float:right;margin:0 0 0 10px}.index_bf-container__1HxhF .index_bftd-1__382qR{text-indent:2em;display:initial}.index_bf-container__1HxhF .index_bftd-2__11te-{text-indent:4em;display:initial}.index_bf-container__1HxhF .index_bftd-3__2BZeG{text-indent:6em;display:initial}.index_bf-container__1HxhF .index_bftd-4__4c1Sw{text-indent:8em;display:initial}.index_bf-container__1HxhF .index_bftd-5__34mlP{text-indent:10em;display:initial}.index_bf-container__1HxhF .index_bftd-6__1bsox{text-indent:12em;display:initial}.index_bf-container__1HxhF .index_bf-image__1MXDI,.index_bf-container__1HxhF .index_bf-media__33Dic{position:relative}.index_bf-container__1HxhF .index_bf-image__1MXDI img{display:block;max-width:100%;font-size:0;resize:both;outline-offset:1px}.index_bf-container__1HxhF .index_bf-image__1MXDI img:hover{outline:1px solid #3498db}.index_bf-container__1HxhF .index_bf-media-toolbar__28qi5{position:absolute;z-index:3;bottom:15px;left:50%;width:auto;background-color:#21242a;border-radius:2px;font-weight:400;text-align:center;white-space:nowrap;transform:translateX(-50%);box-shadow:0 5px 15px rgba(0,0,0,.2);-webkit-user-select:none;user-select:none}.index_bf-container__1HxhF .index_bf-media-toolbar__28qi5 .index_bf-media-toolbar-arrow__M3uMb,.index_bf-container__1HxhF .index_bf-media-toolbar__28qi5:before{position:absolute;bottom:-10px;left:50%;display:block;border:5px solid transparent;border-top-color:#21242a;content:"";transform:translateX(-5px)}.index_bf-container__1HxhF .index_bf-media-toolbar__28qi5 a{display:inline-block;min-width:40px;height:40px;color:hsla(0,0%,100%,.5);font-family:braft-icons!important;font-size:18px;font-weight:400;line-height:40px;text-align:center;text-decoration:none;text-transform:uppercase;cursor:pointer}.index_bf-container__1HxhF .index_bf-media-toolbar__28qi5 a:hover{color:#fff}.index_bf-container__1HxhF .index_bf-media-toolbar__28qi5 a:first-child{border-radius:2px 0 0 2px}.index_bf-container__1HxhF .index_bf-media-toolbar__28qi5 a:last-child{border-radius:0 2px 2px 0}.index_bf-container__1HxhF .index_bf-media-toolbar__28qi5 a.index_active__3_mlp{color:#3498db}.index_bf-video-player__3Eqxs video{display:block;width:640px;max-width:80vw;height:auto;margin:0 10px 10px;object-fit:contain}.index_bf-audio-player__67sKu audio{width:480px;max-width:80vw;margin:0 10px 10px}.index_bf-player-holder__1k4R5{position:relative;height:240px;overflow:hidden;background-color:#21242a;border-radius:3px}.index_bf-player-holder__1k4R5 .index_icon-badge__35ukN{position:absolute;z-index:2;top:0;left:0;height:30px;padding:0 15px;border-radius:0 0 3px 0;color:#fff;background-color:hsla(0,0%,100%,.1)}.index_bf-player-holder__1k4R5 .index_icon-badge__35ukN i,.index_bf-player-holder__1k4R5 .index_icon-badge__35ukN span{display:block;float:left;line-height:30px}.index_bf-player-holder__1k4R5 .index_icon-badge__35ukN span{margin-left:5px;font-size:12px}.index_bf-player-holder__1k4R5 .index_button-remove__cTw4D{position:absolute;z-index:2;top:5px;right:5px;width:40px;height:40px;background-color:transparent;border:none;border-radius:50%;outline:none;color:#fff;font-size:24px;text-align:center;cursor:pointer}.index_bf-player-holder__1k4R5 .index_button-remove__cTw4D:hover{color:#e74c3c}.index_bf-player-holder__1k4R5 .index_button-play__1GpMM{position:relative;z-index:2;display:block;width:80px;height:80px;margin:40px auto 20px;background-color:rgba(0,0,0,.7);border:none;border-radius:50%;outline:none;color:#fff;font-size:48px;line-height:80px;text-align:center;backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);cursor:pointer}.index_bf-player-holder__1k4R5 .index_button-play__1GpMM:hover{background-color:#3498db}.index_bf-player-holder__1k4R5 .index_bf-name__3FBAI{position:relative;z-index:2;margin:0;color:#fff;font-size:14px;font-weight:500;text-align:center}.index_bf-player-holder__1k4R5 .index_bf-url__1di3g{position:relative;z-index:2;width:70%;margin:10px auto;color:hsla(0,0%,100%,.5);font-size:12px;font-weight:400;text-align:center}.index_bf-player-holder__1k4R5 .index_bf-poster__drCvq{position:absolute;top:0;left:0;width:100%;height:100%;background-repeat:no-repeat;background-position:50% 50%;background-size:cover;opacity:.3}.index_bf-modal__23mEu{position:fixed;z-index:99999;top:0;left:0;width:100%;height:100%}.index_bf-modal__23mEu button{outline:none}.index_bf-modal-mask__3MKbg{position:absolute;z-index:1;top:0;left:0;width:100%;height:100%;background-color:rgba(0,0,0,.1);opacity:0;transition:opacity .2s}.index_bf-modal-content__1RScF{position:absolute;z-index:2;top:45%;left:50%;max-width:95%;background-color:#fff;border-radius:2px;box-shadow:0 15px 30px rgba(0,0,0,.1);opacity:0;transform:translate(-50%,-40%);transition:transform .2s,opacity .2s}.index_bf-modal-header__3jeX-{height:50px}.index_bf-modal-caption__2z9hD{float:left;margin:0;padding:0 15px;color:#999;font-size:14px;font-weight:400;line-height:50px}.index_bf-modal-close-button__13UMv{float:right;width:50px;height:50px;background-color:transparent;border:none;color:#ccc;font-size:18px;cursor:pointer}.index_bf-modal-close-button__13UMv:hover{color:#e74c3c}.index_bf-modal-body__3MjbZ{overflow:auto}.index_bf-modal-footer__3Pc0k{min-height:15px;padding:0 15px;overflow:hidden}.index_bf-modal-addon-text__3dQDG{float:left;color:#999;font-size:12px;line-height:60px}.index_bf-modal-buttons__2IuAO{float:right}.index_bf-modal-cancel__30ePe,.index_bf-modal-confirm__3woeJ{height:36px;margin:12px 0 12px 15px;padding:0 30px;border:none;border-radius:2px;font-size:12px;font-weight:700;cursor:pointer}.index_bf-modal-cancel__30ePe{background-color:#e8e9ea;color:#999}.index_bf-modal-cancel__30ePe:hover{background-color:#d8d9da}.index_bf-modal-confirm__3woeJ{background-color:#3498db;color:#fff}.index_bf-modal-confirm__3woeJ:hover{background-color:#2084c7}.index_bf-modal-confirm__3woeJ.index_disabled__KFBp_{opacity:.3;pointer-events:none;filter:grayscale(.4)}.index_bf-modal-root__1P_VQ.index_active__3_mlp .index_bf-modal-mask__3MKbg{opacity:1}.index_bf-modal-root__1P_VQ.index_active__3_mlp .index_bf-modal-content__1RScF{opacity:1;transform:translate(-50%,-50%)}.index_bf-content__5lf-j .index_bf-hr__39L4E{position:relative;box-sizing:content-box;height:15px;padding-top:15px;text-align:center}.index_bf-content__5lf-j .index_bf-hr__39L4E:before{display:block;height:1px;background-color:rgba(0,0,0,.1);content:""}.index_bf-content__5lf-j .index_bf-hr__39L4E:hover:before{background-color:rgba(0,0,0,.3)}.index_bf-content__5lf-j .index_bf-hr__39L4E:hover .index_bf-media-toolbar__28qi5{display:block}.index_bf-content__5lf-j .index_bf-hr__39L4E .index_bf-media-toolbar__28qi5{display:none}.index_bf-image-link-editor__L5XLU,.index_bf-image-size-editor__3DAVi{padding-bottom:1px;overflow:hidden;border-radius:2px 2px 0 0;box-shadow:inset 0 -1px 0 0 hsla(0,0%,100%,.1)}.index_bf-image-link-editor__L5XLU .index_editor-input-group__1hcX3,.index_bf-image-size-editor__3DAVi .index_editor-input-group__1hcX3{width:300px;margin:8px 10px;overflow:hidden}.index_bf-image-link-editor__L5XLU input,.index_bf-image-size-editor__3DAVi input{display:block;float:left;box-sizing:content-box;height:32px;margin:0 5px 0 0;padding:0 10px;background-color:hsla(0,0%,100%,.1);border:none;border-radius:2px;outline:none;box-shadow:inset 0 0 0 1px hsla(0,0%,100%,.1);color:#fff;font-weight:700}.index_bf-image-link-editor__L5XLU input:hover,.index_bf-image-size-editor__3DAVi input:hover{box-shadow:inset 0 0 0 1px rgba(52,152,219,.5)}.index_bf-image-link-editor__L5XLU input:focus,.index_bf-image-size-editor__3DAVi input:focus{box-shadow:inset 0 0 0 1px #3498db}.index_bf-image-link-editor__L5XLU button,.index_bf-image-size-editor__3DAVi button{float:left;width:90px;height:32px;margin:0;padding:0 20px;background-color:#3498db;border:none;color:#fff;font-size:12px;border-radius:2px;cursor:pointer}.index_bf-image-link-editor__L5XLU button:hover,.index_bf-image-size-editor__3DAVi button:hover{background-color:#2084c7}.index_bf-image-size-editor__3DAVi input{width:80px}.index_bf-image-link-editor__L5XLU input{width:185px}.index_bf-image-link-editor__L5XLU .index_switch-group__3nsEF{height:16px;margin:10px}.index_bf-image-link-editor__L5XLU .index_switch-group__3nsEF .index_bf-switch__1LPr-{float:left}.index_bf-image-link-editor__L5XLU .index_switch-group__3nsEF label{float:left;margin-left:15px;color:#999;font-size:12px;line-height:16px}.index_bf-content__5lf-j .index_bf-image__1MXDI{position:relative}.index_bf-content__5lf-j .index_bf-image__1MXDI .index_bf-csize-icon__13EM-{position:absolute;z-index:2;width:10px;height:10px;background-color:rgba(52,152,219,.3)}.index_bf-content__5lf-j .index_bf-image__1MXDI .index_bf-csize-icon__13EM-.index_right-bottom__2jlUD{right:0;bottom:0;cursor:se-resize}.index_bf-content__5lf-j .index_bf-image__1MXDI .index_bf-csize-icon__13EM-.index_left-bottom__1H0sb{left:0;bottom:0;cursor:sw-resize}.index_bf-content__5lf-j .index_bf-image__1MXDI .index_bf-pre-csize__2lLOX{position:absolute;z-index:1;background:transparent}.index_bf-content__5lf-j .index_bf-image__1MXDI .index_bf-pre-csize__2lLOX.index_rightbottom__S1Zly{left:0;top:0;border:1px dashed #00bfff}.index_bf-content__5lf-j .index_bf-image__1MXDI .index_bf-pre-csize__2lLOX.index_leftbottom__wbQiO{right:0;top:0;border:1px dashed #00bfff}.index_bf-content__5lf-j .index_bf-image__1MXDI .index_bf-media-toolbar__28qi5:before{visibility:hidden}.index_bf-content__5lf-j .index_bf-image__1MXDI .index_bf-media-toolbar__28qi5[data-align=center] [data-align=center],.index_bf-content__5lf-j .index_bf-image__1MXDI .index_bf-media-toolbar__28qi5[data-align=left] [data-align=left],.index_bf-content__5lf-j .index_bf-image__1MXDI .index_bf-media-toolbar__28qi5[data-align=right] [data-align=right],.index_bf-content__5lf-j .index_bf-image__1MXDI .index_bf-media-toolbar__28qi5[data-float=left] [data-float=left],.index_bf-content__5lf-j .index_bf-image__1MXDI .index_bf-media-toolbar__28qi5[data-float=right] [data-float=right]{color:#3498db}.index_headings-dropdown__1KzQP{min-width:110px}.index_headings-dropdown__1KzQP .index_menu__10kCt{width:200px;overflow:hidden}.index_headings-dropdown__1KzQP .index_menu__10kCt .index_menu-item__2_Ov-{padding:15px 20px;text-align:left;line-height:normal}.index_headings-dropdown__1KzQP .index_menu__10kCt .index_menu-item__2_Ov- h1,.index_headings-dropdown__1KzQP .index_menu__10kCt .index_menu-item__2_Ov- h2,.index_headings-dropdown__1KzQP .index_menu__10kCt .index_menu-item__2_Ov- h3,.index_headings-dropdown__1KzQP .index_menu__10kCt .index_menu-item__2_Ov- h4,.index_headings-dropdown__1KzQP .index_menu__10kCt .index_menu-item__2_Ov- h5,.index_headings-dropdown__1KzQP .index_menu__10kCt .index_menu-item__2_Ov- h6{margin:0;padding:0;color:inherit}.index_headings-dropdown__1KzQP .index_menu__10kCt .index_menu-item__2_Ov- h1{font-size:28px}.index_headings-dropdown__1KzQP .index_menu__10kCt .index_menu-item__2_Ov- h2{font-size:24px}.index_headings-dropdown__1KzQP .index_menu__10kCt .index_menu-item__2_Ov- h3{font-size:20px}.index_headings-dropdown__1KzQP .index_menu__10kCt .index_menu-item__2_Ov- h4{font-size:16px}.index_headings-dropdown__1KzQP .index_menu__10kCt .index_menu-item__2_Ov- h5{font-size:14px}.index_headings-dropdown__1KzQP .index_menu__10kCt .index_menu-item__2_Ov- h6{font-size:12px}.index_bf-link-editor__w7aBK{width:360px;padding-top:25px}.index_bf-link-editor__w7aBK .index_input-group__1Y0_d{margin:0 15px 8px}.index_bf-link-editor__w7aBK .index_input-group__1Y0_d input{background-color:hsla(0,0%,100%,.07);border:none;border-radius:2px;box-shadow:inset 0 0 0 1px hsla(0,0%,100%,.1);color:#fff;font-weight:700}.index_bf-link-editor__w7aBK .index_input-group__1Y0_d input:hover{box-shadow:inset 0 0 0 1px rgba(52,152,219,.5)}.index_bf-link-editor__w7aBK .index_input-group__1Y0_d input:focus{box-shadow:inset 0 0 0 1px #3498db}.index_bf-link-editor__w7aBK .index_input-group__1Y0_d input:disabled{color:hsla(0,0%,100%,.7);box-shadow:none}.index_bf-link-editor__w7aBK .index_switch-group__3nsEF{height:16px;margin:15px}.index_bf-link-editor__w7aBK .index_switch-group__3nsEF .index_bf-switch__1LPr-{float:left}.index_bf-link-editor__w7aBK .index_switch-group__3nsEF label{float:left;margin-left:15px;color:#999;font-size:12px;line-height:16px}.index_bf-link-editor__w7aBK .index_buttons__3QT_I{box-sizing:content-box;height:32px;margin-top:20px;padding:15px;overflow:hidden;box-shadow:inset 0 1px 0 0 hsla(0,0%,100%,.1)}.index_bf-link-editor__w7aBK .index_buttons__3QT_I .index_button-remove-link__2004W{color:#999;font-size:12px;line-height:32px;cursor:pointer}.index_bf-link-editor__w7aBK .index_buttons__3QT_I .index_button-remove-link__2004W:hover{color:#e74c3c}.index_bf-link-editor__w7aBK .index_buttons__3QT_I .index_button-remove-link__2004W i{margin-right:5px;font-size:16px}.index_bf-link-editor__w7aBK .index_buttons__3QT_I .index_button-remove-link__2004W i,.index_bf-link-editor__w7aBK .index_buttons__3QT_I .index_button-remove-link__2004W span{display:block;float:left;line-height:32px}.index_bf-link-editor__w7aBK .index_buttons__3QT_I button{margin-left:10px;border-radius:2px;font-weight:700;cursor:pointer}.index_bf-dropdown__zgKp1{position:relative;width:auto;height:36px;margin:0}.index_bf-dropdown__zgKp1.index_disabled__KFBp_{pointer-events:none;opacity:.3}.index_bf-dropdown__zgKp1.index_light-theme__iYoel .index_dropdown-content__2HerW{border:1px solid #ccc}.index_bf-dropdown__zgKp1.index_light-theme__iYoel .index_dropdown-content__2HerW .index_dropdown-arrow__3KWgU{background-color:#fff;border:1px solid #ccc}.index_bf-dropdown__zgKp1.index_light-theme__iYoel .index_dropdown-content__2HerW .index_dropdown-content-inner__5r4YN{background-color:#fff}.index_bf-dropdown__zgKp1 .index_dropdown-content__2HerW{box-sizing:content-box;position:absolute;z-index:10;top:100%;left:50%;visibility:hidden;float:left;width:auto;min-width:100%;margin-top:9px;border-radius:2px;box-shadow:0 5px 15px rgba(0,0,0,.2);opacity:0;cursor:default;transform:translate(-50%,20px);transition:.2s}.index_bf-dropdown__zgKp1 .index_dropdown-content__2HerW ::-webkit-scrollbar-track{background-color:transparent}.index_bf-dropdown__zgKp1 .index_dropdown-content__2HerW ::-webkit-scrollbar{width:4px;background-color:transparent;border-radius:2px}.index_bf-dropdown__zgKp1 .index_dropdown-content__2HerW ::-webkit-scrollbar-thumb{background-color:hsla(0,0%,100%,.3);border-radius:2px}.index_bf-dropdown__zgKp1 .index_dropdown-content__2HerW .index_dropdown-arrow__3KWgU{position:absolute;z-index:1;top:-3px;left:50%;width:10px;height:10px;background-color:#21242a;transform:translateX(-50%) rotate(45deg);transition:margin .2s}.index_bf-dropdown__zgKp1 .index_dropdown-content__2HerW .index_dropdown-arrow__3KWgU.index_active__3_mlp{background-color:#3498db}.index_bf-dropdown__zgKp1 .index_dropdown-content__2HerW .index_menu__10kCt{list-style:none;margin:0;padding:0;overflow:hidden;border-radius:2px}.index_bf-dropdown__zgKp1 .index_dropdown-content__2HerW .index_menu-item__2_Ov-{display:block;list-style:none;margin:0;font-size:16px;cursor:pointer}.index_bf-dropdown__zgKp1 .index_dropdown-content__2HerW .index_menu-item__2_Ov-:hover{background-color:rgba(0,0,0,.1)}.index_bf-dropdown__zgKp1 .index_dropdown-content__2HerW .index_menu-item__2_Ov-.index_active__3_mlp{background-color:#3498db;color:#fff}.index_bf-dropdown__zgKp1 .index_dropdown-content__2HerW .index_menu-item__2_Ov-:not(.index_active__3_mlp){color:hsla(0,0%,100%,.6);box-shadow:inset 0 -1px 0 0 hsla(0,0%,100%,.1)}.index_bf-dropdown__zgKp1 .index_dropdown-content-inner__5r4YN{position:relative;z-index:2;overflow:auto;background-color:#21242a;border-radius:2px}.index_bf-dropdown__zgKp1 .index_dropdown-handler__1xChS{position:relative;display:block;width:100%;height:36px;background-color:transparent;border:none;color:#6a6f7b;cursor:pointer}.index_bf-dropdown__zgKp1 .index_dropdown-handler__1xChS:hover{background-color:rgba(0,0,0,.05)}.index_bf-dropdown__zgKp1 .index_dropdown-handler__1xChS *{display:inline;padding:0;font-size:inherit;font-weight:400}.index_bf-dropdown__zgKp1 .index_dropdown-handler__1xChS>span{float:left;padding:0 10px;font-size:14px;line-height:36px;pointer-events:none}.index_bf-dropdown__zgKp1 .index_dropdown-handler__1xChS>span i{display:block;height:36px;font-size:16px;line-height:36px;text-align:center}.index_bf-dropdown__zgKp1 .index_dropdown-handler__1xChS .index_bfi-drop-down__2-Azn{float:right;width:30px;height:36px;font-size:16px;line-height:36px;text-align:center;pointer-events:none}.index_bf-dropdown__zgKp1.index_active__3_mlp .index_dropdown-handler__1xChS{background-color:rgba(0,0,0,.05)}.index_bf-dropdown__zgKp1.index_active__3_mlp .index_dropdown-content__2HerW{visibility:visible;opacity:1;transform:translate(-50%)}.index_text-color-dropdown__pnJCI.index_light-theme__iYoel .index_bf-color-switch-buttons__R4l-y button{border-bottom:1px solid #ccc;color:#616569}.index_text-color-dropdown__pnJCI.index_light-theme__iYoel .index_bf-color-switch-buttons__R4l-y button.index_active__3_mlp{border-bottom-color:#3498db;color:#3498db}.index_text-color-dropdown__pnJCI button.index_dropdown-handler__1xChS span{width:36px;padding:0;overflow:hidden;border-radius:2px}.index_text-color-dropdown__pnJCI .index_bf-text-color-picker-wrap__2xWAh{overflow:hidden}.index_text-color-dropdown__pnJCI .index_bf-color-switch-buttons__R4l-y{height:36px}.index_text-color-dropdown__pnJCI .index_bf-color-switch-buttons__R4l-y button{float:left;width:50%;height:36px;background-color:transparent;border:none;border-bottom:1px solid hsla(0,0%,100%,.1);color:hsla(0,0%,100%,.5);font-size:12px;font-weight:400;text-transform:uppercase;cursor:pointer}.index_text-color-dropdown__pnJCI .index_bf-color-switch-buttons__R4l-y button.index_active__3_mlp{border-bottom-color:#3498db;color:#3498db}.index_bf-colors__2Jog3{box-sizing:content-box;list-style:none;width:240px;margin:0;padding:15px;overflow:hidden}.index_bf-colors__2Jog3 li{box-sizing:content-box;display:block;float:left;width:24px;height:24px;margin:5px;padding:0;background-color:currentColor;border:3px solid transparent;border-radius:50%;cursor:pointer;transition:transform .2s}.index_bf-colors__2Jog3 li:hover{transform:scale(1.3)}.index_bf-colors__2Jog3 li.index_active__3_mlp{box-shadow:0 0 0 2px #3498db}.index_bf-font-size-dropdown__38pES{min-width:95px}.index_bf-font-sizes__2rRGp{box-sizing:content-box;width:210px;list-style:none;margin:0;padding:5px;overflow:hidden}.index_bf-font-sizes__2rRGp li{display:block;float:left;width:60px;height:30px;background-color:hsla(0,0%,100%,.1);border-radius:2px;margin:5px;color:#fff;font-size:12px;line-height:30px;text-align:center;text-transform:uppercase;cursor:pointer}.index_bf-font-sizes__2rRGp li:hover{background-color:hsla(0,0%,100%,.2)}.index_bf-font-sizes__2rRGp li.index_active__3_mlp{background-color:#3498db}.index_font-family-dropdown__rYXD5{min-width:120px}.index_font-family-dropdown__rYXD5 .index_dropdown-content__2HerW{width:180px}.index_font-family-dropdown__rYXD5 .index_menu-item__2_Ov-{padding:12px 15px}.index_bf-line-height-dropdown__ee0Ld{min-width:95px}.index_bf-line-heights__2Oa0w{box-sizing:content-box;width:210px;list-style:none;margin:0;padding:5px;overflow:hidden}.index_bf-line-heights__2Oa0w li{display:block;float:left;width:60px;height:30px;background-color:hsla(0,0%,100%,.1);border-radius:2px;margin:5px;color:#fff;font-size:12px;line-height:30px;text-align:center;text-transform:uppercase;cursor:pointer}.index_bf-line-heights__2Oa0w li:hover{background-color:hsla(0,0%,100%,.2)}.index_bf-line-heights__2Oa0w li.index_active__3_mlp{background-color:#3498db}.index_bf-letter-spacing-dropdown__1t21I{min-width:95px}.index_bf-letter-spacings__MYcL5{box-sizing:content-box;width:210px;list-style:none;margin:0;padding:5px;overflow:hidden}.index_bf-letter-spacings__MYcL5 li{display:block;float:left;width:60px;height:30px;background-color:hsla(0,0%,100%,.1);border-radius:2px;margin:5px;color:#fff;font-size:12px;line-height:30px;text-align:center;text-transform:uppercase;cursor:pointer}.index_bf-letter-spacings__MYcL5 li:hover{background-color:hsla(0,0%,100%,.2)}.index_bf-letter-spacings__MYcL5 li.index_active__3_mlp{background-color:#3498db}.index_bf-emojis-wrap__3FqEM{position:relative;width:210px;height:220px;overflow:hidden}.index_bf-emojis-wrap__3FqEM:after,.index_bf-emojis-wrap__3FqEM:before{position:absolute;z-index:1;right:0;left:0;height:30px;border-radius:2px;content:"";pointer-events:none}.index_bf-emojis-wrap__3FqEM:before{top:0;background-image:linear-gradient(0deg,rgba(33,36,42,0),#21242a)}.index_bf-emojis-wrap__3FqEM:after{bottom:0;background-image:linear-gradient(rgba(33,36,42,0),#21242a)}.index_bf-emojis__3p4Ps{box-sizing:content-box;width:200px;height:195px;list-style:none;margin:0;padding:15px 15px 20px;overflow:auto}.index_bf-emojis__3p4Ps li{display:block;float:left;width:30px;height:30px;margin:0;padding:0;color:#fff;border-radius:2px;font-family:Apple Color Emoji,Segoe UI,Segoe UI Emoji,Segoe UI Symbol;font-size:18px;line-height:32px;text-align:center;cursor:pointer;-webkit-user-select:none;user-select:none;transition:transform .2s}.index_bf-emojis__3p4Ps li:hover{transform:scale(1.5)}';
styleInject_es.styleInject(css);

var css$1 =
  '.emoticon_braft-emoticon-picker__26_HU{box-sizing:border-box;width:210px;height:210px;overflow:hidden}.emoticon_braft-emoticon-picker__26_HU:after,.emoticon_braft-emoticon-picker__26_HU:before{position:absolute;z-index:1;right:0;left:0;height:30px;border-radius:2px;content:"";pointer-events:none}.emoticon_braft-emoticon-picker__26_HU:before{top:0;background-image:linear-gradient(0deg,rgba(33,36,42,0),#21242a)}.emoticon_braft-emoticon-picker__26_HU:after{bottom:0;background-image:linear-gradient(rgba(33,36,42,0),#21242a)}.emoticon_braft-emoticon-picker__26_HU .emoticon_braft-emoticons-list__P1AeK{box-sizing:content-box;width:200px;height:190px;margin:0;padding:15px 15px 20px;overflow:auto}.emoticon_braft-emoticon-picker__26_HU .emoticon_braft-emoticons-list__P1AeK img{display:block;box-sizing:content-box;float:left;width:20px;height:20px;margin:3px;padding:5px;border-radius:3px}.emoticon_braft-emoticon-picker__26_HU .emoticon_braft-emoticons-list__P1AeK img:hover{background-color:#3498db}.emoticon_braft-emoticon-in-editor__10cwl{position:relative;padding:0 2px;letter-spacing:12px}.emoticon_braft-emoticon-in-editor__10cwl img{position:absolute;top:0;left:2px;width:16px;height:16px}';
styleInject_es.styleInject(css$1);

var immutable$3 = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  /**
   * Copyright (c) 2014-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.
   */

  (function(global, factory) {
    factory(exports);
  })(_commonjsHelpers.commonjsGlobal, function(exports) {
    // Used for setting prototype methods that IE8 chokes on.
    var DELETE = "delete";

    // Constants describing the size of trie nodes.
    var SHIFT = 5; // Resulted in best performance after ______?
    var SIZE = 1 << SHIFT;
    var MASK = SIZE - 1;

    // A consistent shared value representing "not set" which equals nothing other
    // than itself, and nothing that could be provided externally.
    var NOT_SET = {};

    // Boolean references, Rough equivalent of `bool &`.
    function MakeRef() {
      return { value: false };
    }

    function SetRef(ref) {
      if (ref) {
        ref.value = true;
      }
    }

    // A function which returns a value representing an "owner" for transient writes
    // to tries. The return value will only ever equal itself, and will not equal
    // the return of any subsequent call of this function.
    function OwnerID() {}

    function ensureSize(iter) {
      if (iter.size === undefined) {
        iter.size = iter.__iterate(returnTrue);
      }
      return iter.size;
    }

    function wrapIndex(iter, index) {
      // This implements "is array index" which the ECMAString spec defines as:
      //
      //     A String property name P is an array index if and only if
      //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal
      //     to 2^32−1.
      //
      // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects
      if (typeof index !== "number") {
        var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32
        if ("" + uint32Index !== index || uint32Index === 4294967295) {
          return NaN;
        }
        index = uint32Index;
      }
      return index < 0 ? ensureSize(iter) + index : index;
    }

    function returnTrue() {
      return true;
    }

    function wholeSlice(begin, end, size) {
      return (
        ((begin === 0 && !isNeg(begin)) ||
          (size !== undefined && begin <= -size)) &&
        (end === undefined || (size !== undefined && end >= size))
      );
    }

    function resolveBegin(begin, size) {
      return resolveIndex(begin, size, 0);
    }

    function resolveEnd(end, size) {
      return resolveIndex(end, size, size);
    }

    function resolveIndex(index, size, defaultIndex) {
      // Sanitize indices using this shorthand for ToInt32(argument)
      // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
      return index === undefined
        ? defaultIndex
        : isNeg(index)
        ? size === Infinity
          ? size
          : Math.max(0, size + index) | 0
        : size === undefined || size === index
        ? index
        : Math.min(size, index) | 0;
    }

    function isNeg(value) {
      // Account for -0 which is negative, but not less than 0.
      return value < 0 || (value === 0 && 1 / value === -Infinity);
    }

    // Note: value is unchanged to not break immutable-devtools.
    var IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";

    function isCollection(maybeCollection) {
      return Boolean(maybeCollection && maybeCollection[IS_COLLECTION_SYMBOL]);
    }

    var IS_KEYED_SYMBOL = "@@__IMMUTABLE_KEYED__@@";

    function isKeyed(maybeKeyed) {
      return Boolean(maybeKeyed && maybeKeyed[IS_KEYED_SYMBOL]);
    }

    var IS_INDEXED_SYMBOL = "@@__IMMUTABLE_INDEXED__@@";

    function isIndexed(maybeIndexed) {
      return Boolean(maybeIndexed && maybeIndexed[IS_INDEXED_SYMBOL]);
    }

    function isAssociative(maybeAssociative) {
      return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);
    }

    var Collection = function Collection(value) {
      return isCollection(value) ? value : Seq(value);
    };

    var KeyedCollection = /*@__PURE__*/ (function(Collection) {
      function KeyedCollection(value) {
        return isKeyed(value) ? value : KeyedSeq(value);
      }

      if (Collection) KeyedCollection.__proto__ = Collection;
      KeyedCollection.prototype = Object.create(
        Collection && Collection.prototype
      );
      KeyedCollection.prototype.constructor = KeyedCollection;

      return KeyedCollection;
    })(Collection);

    var IndexedCollection = /*@__PURE__*/ (function(Collection) {
      function IndexedCollection(value) {
        return isIndexed(value) ? value : IndexedSeq(value);
      }

      if (Collection) IndexedCollection.__proto__ = Collection;
      IndexedCollection.prototype = Object.create(
        Collection && Collection.prototype
      );
      IndexedCollection.prototype.constructor = IndexedCollection;

      return IndexedCollection;
    })(Collection);

    var SetCollection = /*@__PURE__*/ (function(Collection) {
      function SetCollection(value) {
        return isCollection(value) && !isAssociative(value)
          ? value
          : SetSeq(value);
      }

      if (Collection) SetCollection.__proto__ = Collection;
      SetCollection.prototype = Object.create(
        Collection && Collection.prototype
      );
      SetCollection.prototype.constructor = SetCollection;

      return SetCollection;
    })(Collection);

    Collection.Keyed = KeyedCollection;
    Collection.Indexed = IndexedCollection;
    Collection.Set = SetCollection;

    var IS_SEQ_SYMBOL = "@@__IMMUTABLE_SEQ__@@";

    function isSeq(maybeSeq) {
      return Boolean(maybeSeq && maybeSeq[IS_SEQ_SYMBOL]);
    }

    var IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";

    function isRecord(maybeRecord) {
      return Boolean(maybeRecord && maybeRecord[IS_RECORD_SYMBOL]);
    }

    function isImmutable(maybeImmutable) {
      return isCollection(maybeImmutable) || isRecord(maybeImmutable);
    }

    var IS_ORDERED_SYMBOL = "@@__IMMUTABLE_ORDERED__@@";

    function isOrdered(maybeOrdered) {
      return Boolean(maybeOrdered && maybeOrdered[IS_ORDERED_SYMBOL]);
    }

    var ITERATE_KEYS = 0;
    var ITERATE_VALUES = 1;
    var ITERATE_ENTRIES = 2;

    var REAL_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
    var FAUX_ITERATOR_SYMBOL = "@@iterator";

    var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;

    var Iterator = function Iterator(next) {
      this.next = next;
    };

    Iterator.prototype.toString = function toString() {
      return "[Iterator]";
    };

    Iterator.KEYS = ITERATE_KEYS;
    Iterator.VALUES = ITERATE_VALUES;
    Iterator.ENTRIES = ITERATE_ENTRIES;

    Iterator.prototype.inspect = Iterator.prototype.toSource = function() {
      return this.toString();
    };
    Iterator.prototype[ITERATOR_SYMBOL] = function() {
      return this;
    };

    function iteratorValue(type, k, v, iteratorResult) {
      var value = type === 0 ? k : type === 1 ? v : [k, v];
      iteratorResult
        ? (iteratorResult.value = value)
        : (iteratorResult = {
            value: value,
            done: false
          });
      return iteratorResult;
    }

    function iteratorDone() {
      return { value: undefined, done: true };
    }

    function hasIterator(maybeIterable) {
      return !!getIteratorFn(maybeIterable);
    }

    function isIterator(maybeIterator) {
      return maybeIterator && typeof maybeIterator.next === "function";
    }

    function getIterator(iterable) {
      var iteratorFn = getIteratorFn(iterable);
      return iteratorFn && iteratorFn.call(iterable);
    }

    function getIteratorFn(iterable) {
      var iteratorFn =
        iterable &&
        ((REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||
          iterable[FAUX_ITERATOR_SYMBOL]);
      if (typeof iteratorFn === "function") {
        return iteratorFn;
      }
    }

    var hasOwnProperty = Object.prototype.hasOwnProperty;

    function isArrayLike(value) {
      if (Array.isArray(value) || typeof value === "string") {
        return true;
      }

      return (
        value &&
        typeof value === "object" &&
        Number.isInteger(value.length) &&
        value.length >= 0 &&
        (value.length === 0
          ? // Only {length: 0} is considered Array-like.
            Object.keys(value).length === 1
          : // An object is only Array-like if it has a property where the last value
            // in the array-like may be found (which could be undefined).
            value.hasOwnProperty(value.length - 1))
      );
    }

    var Seq = /*@__PURE__*/ (function(Collection$$1) {
      function Seq(value) {
        return value === null || value === undefined
          ? emptySequence()
          : isImmutable(value)
          ? value.toSeq()
          : seqFromValue(value);
      }

      if (Collection$$1) Seq.__proto__ = Collection$$1;
      Seq.prototype = Object.create(Collection$$1 && Collection$$1.prototype);
      Seq.prototype.constructor = Seq;

      Seq.prototype.toSeq = function toSeq() {
        return this;
      };

      Seq.prototype.toString = function toString() {
        return this.__toString("Seq {", "}");
      };

      Seq.prototype.cacheResult = function cacheResult() {
        if (!this._cache && this.__iterateUncached) {
          this._cache = this.entrySeq().toArray();
          this.size = this._cache.length;
        }
        return this;
      };

      // abstract __iterateUncached(fn, reverse)

      Seq.prototype.__iterate = function __iterate(fn, reverse) {
        var cache = this._cache;
        if (cache) {
          var size = cache.length;
          var i = 0;
          while (i !== size) {
            var entry = cache[reverse ? size - ++i : i++];
            if (fn(entry[1], entry[0], this) === false) {
              break;
            }
          }
          return i;
        }
        return this.__iterateUncached(fn, reverse);
      };

      // abstract __iteratorUncached(type, reverse)

      Seq.prototype.__iterator = function __iterator(type, reverse) {
        var cache = this._cache;
        if (cache) {
          var size = cache.length;
          var i = 0;
          return new Iterator(function() {
            if (i === size) {
              return iteratorDone();
            }
            var entry = cache[reverse ? size - ++i : i++];
            return iteratorValue(type, entry[0], entry[1]);
          });
        }
        return this.__iteratorUncached(type, reverse);
      };

      return Seq;
    })(Collection);

    var KeyedSeq = /*@__PURE__*/ (function(Seq) {
      function KeyedSeq(value) {
        return value === null || value === undefined
          ? emptySequence().toKeyedSeq()
          : isCollection(value)
          ? isKeyed(value)
            ? value.toSeq()
            : value.fromEntrySeq()
          : isRecord(value)
          ? value.toSeq()
          : keyedSeqFromValue(value);
      }

      if (Seq) KeyedSeq.__proto__ = Seq;
      KeyedSeq.prototype = Object.create(Seq && Seq.prototype);
      KeyedSeq.prototype.constructor = KeyedSeq;

      KeyedSeq.prototype.toKeyedSeq = function toKeyedSeq() {
        return this;
      };

      return KeyedSeq;
    })(Seq);

    var IndexedSeq = /*@__PURE__*/ (function(Seq) {
      function IndexedSeq(value) {
        return value === null || value === undefined
          ? emptySequence()
          : isCollection(value)
          ? isKeyed(value)
            ? value.entrySeq()
            : value.toIndexedSeq()
          : isRecord(value)
          ? value.toSeq().entrySeq()
          : indexedSeqFromValue(value);
      }

      if (Seq) IndexedSeq.__proto__ = Seq;
      IndexedSeq.prototype = Object.create(Seq && Seq.prototype);
      IndexedSeq.prototype.constructor = IndexedSeq;

      IndexedSeq.of = function of(/*...values*/) {
        return IndexedSeq(arguments);
      };

      IndexedSeq.prototype.toIndexedSeq = function toIndexedSeq() {
        return this;
      };

      IndexedSeq.prototype.toString = function toString() {
        return this.__toString("Seq [", "]");
      };

      return IndexedSeq;
    })(Seq);

    var SetSeq = /*@__PURE__*/ (function(Seq) {
      function SetSeq(value) {
        return (isCollection(value) && !isAssociative(value)
          ? value
          : IndexedSeq(value)
        ).toSetSeq();
      }

      if (Seq) SetSeq.__proto__ = Seq;
      SetSeq.prototype = Object.create(Seq && Seq.prototype);
      SetSeq.prototype.constructor = SetSeq;

      SetSeq.of = function of(/*...values*/) {
        return SetSeq(arguments);
      };

      SetSeq.prototype.toSetSeq = function toSetSeq() {
        return this;
      };

      return SetSeq;
    })(Seq);

    Seq.isSeq = isSeq;
    Seq.Keyed = KeyedSeq;
    Seq.Set = SetSeq;
    Seq.Indexed = IndexedSeq;

    Seq.prototype[IS_SEQ_SYMBOL] = true;

    // #pragma Root Sequences

    var ArraySeq = /*@__PURE__*/ (function(IndexedSeq) {
      function ArraySeq(array) {
        this._array = array;
        this.size = array.length;
      }

      if (IndexedSeq) ArraySeq.__proto__ = IndexedSeq;
      ArraySeq.prototype = Object.create(IndexedSeq && IndexedSeq.prototype);
      ArraySeq.prototype.constructor = ArraySeq;

      ArraySeq.prototype.get = function get(index, notSetValue) {
        return this.has(index)
          ? this._array[wrapIndex(this, index)]
          : notSetValue;
      };

      ArraySeq.prototype.__iterate = function __iterate(fn, reverse) {
        var array = this._array;
        var size = array.length;
        var i = 0;
        while (i !== size) {
          var ii = reverse ? size - ++i : i++;
          if (fn(array[ii], ii, this) === false) {
            break;
          }
        }
        return i;
      };

      ArraySeq.prototype.__iterator = function __iterator(type, reverse) {
        var array = this._array;
        var size = array.length;
        var i = 0;
        return new Iterator(function() {
          if (i === size) {
            return iteratorDone();
          }
          var ii = reverse ? size - ++i : i++;
          return iteratorValue(type, ii, array[ii]);
        });
      };

      return ArraySeq;
    })(IndexedSeq);

    var ObjectSeq = /*@__PURE__*/ (function(KeyedSeq) {
      function ObjectSeq(object) {
        var keys = Object.keys(object);
        this._object = object;
        this._keys = keys;
        this.size = keys.length;
      }

      if (KeyedSeq) ObjectSeq.__proto__ = KeyedSeq;
      ObjectSeq.prototype = Object.create(KeyedSeq && KeyedSeq.prototype);
      ObjectSeq.prototype.constructor = ObjectSeq;

      ObjectSeq.prototype.get = function get(key, notSetValue) {
        if (notSetValue !== undefined && !this.has(key)) {
          return notSetValue;
        }
        return this._object[key];
      };

      ObjectSeq.prototype.has = function has(key) {
        return hasOwnProperty.call(this._object, key);
      };

      ObjectSeq.prototype.__iterate = function __iterate(fn, reverse) {
        var object = this._object;
        var keys = this._keys;
        var size = keys.length;
        var i = 0;
        while (i !== size) {
          var key = keys[reverse ? size - ++i : i++];
          if (fn(object[key], key, this) === false) {
            break;
          }
        }
        return i;
      };

      ObjectSeq.prototype.__iterator = function __iterator(type, reverse) {
        var object = this._object;
        var keys = this._keys;
        var size = keys.length;
        var i = 0;
        return new Iterator(function() {
          if (i === size) {
            return iteratorDone();
          }
          var key = keys[reverse ? size - ++i : i++];
          return iteratorValue(type, key, object[key]);
        });
      };

      return ObjectSeq;
    })(KeyedSeq);
    ObjectSeq.prototype[IS_ORDERED_SYMBOL] = true;

    var CollectionSeq = /*@__PURE__*/ (function(IndexedSeq) {
      function CollectionSeq(collection) {
        this._collection = collection;
        this.size = collection.length || collection.size;
      }

      if (IndexedSeq) CollectionSeq.__proto__ = IndexedSeq;
      CollectionSeq.prototype = Object.create(
        IndexedSeq && IndexedSeq.prototype
      );
      CollectionSeq.prototype.constructor = CollectionSeq;

      CollectionSeq.prototype.__iterateUncached = function __iterateUncached(
        fn,
        reverse
      ) {
        if (reverse) {
          return this.cacheResult().__iterate(fn, reverse);
        }
        var collection = this._collection;
        var iterator = getIterator(collection);
        var iterations = 0;
        if (isIterator(iterator)) {
          var step;
          while (!(step = iterator.next()).done) {
            if (fn(step.value, iterations++, this) === false) {
              break;
            }
          }
        }
        return iterations;
      };

      CollectionSeq.prototype.__iteratorUncached = function __iteratorUncached(
        type,
        reverse
      ) {
        if (reverse) {
          return this.cacheResult().__iterator(type, reverse);
        }
        var collection = this._collection;
        var iterator = getIterator(collection);
        if (!isIterator(iterator)) {
          return new Iterator(iteratorDone);
        }
        var iterations = 0;
        return new Iterator(function() {
          var step = iterator.next();
          return step.done
            ? step
            : iteratorValue(type, iterations++, step.value);
        });
      };

      return CollectionSeq;
    })(IndexedSeq);

    // # pragma Helper functions

    var EMPTY_SEQ;

    function emptySequence() {
      return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));
    }

    function keyedSeqFromValue(value) {
      var seq = Array.isArray(value)
        ? new ArraySeq(value)
        : hasIterator(value)
        ? new CollectionSeq(value)
        : undefined;
      if (seq) {
        return seq.fromEntrySeq();
      }
      if (typeof value === "object") {
        return new ObjectSeq(value);
      }
      throw new TypeError(
        "Expected Array or collection object of [k, v] entries, or keyed object: " +
          value
      );
    }

    function indexedSeqFromValue(value) {
      var seq = maybeIndexedSeqFromValue(value);
      if (seq) {
        return seq;
      }
      throw new TypeError(
        "Expected Array or collection object of values: " + value
      );
    }

    function seqFromValue(value) {
      var seq = maybeIndexedSeqFromValue(value);
      if (seq) {
        return seq;
      }
      if (typeof value === "object") {
        return new ObjectSeq(value);
      }
      throw new TypeError(
        "Expected Array or collection object of values, or keyed object: " +
          value
      );
    }

    function maybeIndexedSeqFromValue(value) {
      return isArrayLike(value)
        ? new ArraySeq(value)
        : hasIterator(value)
        ? new CollectionSeq(value)
        : undefined;
    }

    var IS_MAP_SYMBOL = "@@__IMMUTABLE_MAP__@@";

    function isMap(maybeMap) {
      return Boolean(maybeMap && maybeMap[IS_MAP_SYMBOL]);
    }

    function isOrderedMap(maybeOrderedMap) {
      return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);
    }

    function isValueObject(maybeValue) {
      return Boolean(
        maybeValue &&
          typeof maybeValue.equals === "function" &&
          typeof maybeValue.hashCode === "function"
      );
    }

    /**
     * An extension of the "same-value" algorithm as [described for use by ES6 Map
     * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)
     *
     * NaN is considered the same as NaN, however -0 and 0 are considered the same
     * value, which is different from the algorithm described by
     * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
     *
     * This is extended further to allow Objects to describe the values they
     * represent, by way of `valueOf` or `equals` (and `hashCode`).
     *
     * Note: because of this extension, the key equality of Immutable.Map and the
     * value equality of Immutable.Set will differ from ES6 Map and Set.
     *
     * ### Defining custom values
     *
     * The easiest way to describe the value an object represents is by implementing
     * `valueOf`. For example, `Date` represents a value by returning a unix
     * timestamp for `valueOf`:
     *
     *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...
     *     var date2 = new Date(1234567890000);
     *     date1.valueOf(); // 1234567890000
     *     assert( date1 !== date2 );
     *     assert( Immutable.is( date1, date2 ) );
     *
     * Note: overriding `valueOf` may have other implications if you use this object
     * where JavaScript expects a primitive, such as implicit string coercion.
     *
     * For more complex types, especially collections, implementing `valueOf` may
     * not be performant. An alternative is to implement `equals` and `hashCode`.
     *
     * `equals` takes another object, presumably of similar type, and returns true
     * if it is equal. Equality is symmetrical, so the same result should be
     * returned if this and the argument are flipped.
     *
     *     assert( a.equals(b) === b.equals(a) );
     *
     * `hashCode` returns a 32bit integer number representing the object which will
     * be used to determine how to store the value object in a Map or Set. You must
     * provide both or neither methods, one must not exist without the other.
     *
     * Also, an important relationship between these methods must be upheld: if two
     * values are equal, they *must* return the same hashCode. If the values are not
     * equal, they might have the same hashCode; this is called a hash collision,
     * and while undesirable for performance reasons, it is acceptable.
     *
     *     if (a.equals(b)) {
     *       assert( a.hashCode() === b.hashCode() );
     *     }
     *
     * All Immutable collections are Value Objects: they implement `equals()`
     * and `hashCode()`.
     */
    function is(valueA, valueB) {
      if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
        return true;
      }
      if (!valueA || !valueB) {
        return false;
      }
      if (
        typeof valueA.valueOf === "function" &&
        typeof valueB.valueOf === "function"
      ) {
        valueA = valueA.valueOf();
        valueB = valueB.valueOf();
        if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
          return true;
        }
        if (!valueA || !valueB) {
          return false;
        }
      }
      return !!(
        isValueObject(valueA) &&
        isValueObject(valueB) &&
        valueA.equals(valueB)
      );
    }

    var imul =
      typeof Math.imul === "function" && Math.imul(0xffffffff, 2) === -2
        ? Math.imul
        : function imul(a, b) {
            a |= 0; // int
            b |= 0; // int
            var c = a & 0xffff;
            var d = b & 0xffff;
            // Shift by 0 fixes the sign on the high part.
            return (
              (c * d + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0)) | 0
            ); // int
          };

    // v8 has an optimization for storing 31-bit signed numbers.
    // Values which have either 00 or 11 as the high order bits qualify.
    // This function drops the highest order bit in a signed number, maintaining
    // the sign bit.
    function smi(i32) {
      return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff);
    }

    var defaultValueOf = Object.prototype.valueOf;

    function hash(o) {
      switch (typeof o) {
        case "boolean":
          // The hash values for built-in constants are a 1 value for each 5-byte
          // shift region expect for the first, which encodes the value. This
          // reduces the odds of a hash collision for these common values.
          return o ? 0x42108421 : 0x42108420;
        case "number":
          return hashNumber(o);
        case "string":
          return o.length > STRING_HASH_CACHE_MIN_STRLEN
            ? cachedHashString(o)
            : hashString(o);
        case "object":
        case "function":
          if (o === null) {
            return 0x42108422;
          }
          if (typeof o.hashCode === "function") {
            // Drop any high bits from accidentally long hash codes.
            return smi(o.hashCode(o));
          }
          if (o.valueOf !== defaultValueOf && typeof o.valueOf === "function") {
            o = o.valueOf(o);
          }
          return hashJSObj(o);
        case "undefined":
          return 0x42108423;
        default:
          if (typeof o.toString === "function") {
            return hashString(o.toString());
          }
          throw new Error("Value type " + typeof o + " cannot be hashed.");
      }
    }

    // Compress arbitrarily large numbers into smi hashes.
    function hashNumber(n) {
      if (n !== n || n === Infinity) {
        return 0;
      }
      var hash = n | 0;
      if (hash !== n) {
        hash ^= n * 0xffffffff;
      }
      while (n > 0xffffffff) {
        n /= 0xffffffff;
        hash ^= n;
      }
      return smi(hash);
    }

    function cachedHashString(string) {
      var hashed = stringHashCache[string];
      if (hashed === undefined) {
        hashed = hashString(string);
        if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {
          STRING_HASH_CACHE_SIZE = 0;
          stringHashCache = {};
        }
        STRING_HASH_CACHE_SIZE++;
        stringHashCache[string] = hashed;
      }
      return hashed;
    }

    // http://jsperf.com/hashing-strings
    function hashString(string) {
      // This is the hash from JVM
      // The hash code for a string is computed as
      // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],
      // where s[i] is the ith character of the string and n is the length of
      // the string. We "mod" the result to make it between 0 (inclusive) and 2^31
      // (exclusive) by dropping high bits.
      var hashed = 0;
      for (var ii = 0; ii < string.length; ii++) {
        hashed = (31 * hashed + string.charCodeAt(ii)) | 0;
      }
      return smi(hashed);
    }

    function hashJSObj(obj) {
      var hashed;
      if (usingWeakMap) {
        hashed = weakMap.get(obj);
        if (hashed !== undefined) {
          return hashed;
        }
      }

      hashed = obj[UID_HASH_KEY];
      if (hashed !== undefined) {
        return hashed;
      }

      if (!canDefineProperty) {
        hashed =
          obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];
        if (hashed !== undefined) {
          return hashed;
        }

        hashed = getIENodeHash(obj);
        if (hashed !== undefined) {
          return hashed;
        }
      }

      hashed = ++objHashUID;
      if (objHashUID & 0x40000000) {
        objHashUID = 0;
      }

      if (usingWeakMap) {
        weakMap.set(obj, hashed);
      } else if (isExtensible !== undefined && isExtensible(obj) === false) {
        throw new Error("Non-extensible objects are not allowed as keys.");
      } else if (canDefineProperty) {
        Object.defineProperty(obj, UID_HASH_KEY, {
          enumerable: false,
          configurable: false,
          writable: false,
          value: hashed
        });
      } else if (
        obj.propertyIsEnumerable !== undefined &&
        obj.propertyIsEnumerable ===
          obj.constructor.prototype.propertyIsEnumerable
      ) {
        // Since we can't define a non-enumerable property on the object
        // we'll hijack one of the less-used non-enumerable properties to
        // save our hash on it. Since this is a function it will not show up in
        // `JSON.stringify` which is what we want.
        obj.propertyIsEnumerable = function() {
          return this.constructor.prototype.propertyIsEnumerable.apply(
            this,
            arguments
          );
        };
        obj.propertyIsEnumerable[UID_HASH_KEY] = hashed;
      } else if (obj.nodeType !== undefined) {
        // At this point we couldn't get the IE `uniqueID` to use as a hash
        // and we couldn't use a non-enumerable property to exploit the
        // dontEnum bug so we simply add the `UID_HASH_KEY` on the node
        // itself.
        obj[UID_HASH_KEY] = hashed;
      } else {
        throw new Error("Unable to set a non-enumerable property on object.");
      }

      return hashed;
    }

    // Get references to ES5 object methods.
    var isExtensible = Object.isExtensible;

    // True if Object.defineProperty works as expected. IE8 fails this test.
    var canDefineProperty = (function() {
      try {
        Object.defineProperty({}, "@", {});
        return true;
      } catch (e) {
        return false;
      }
    })();

    // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it
    // and avoid memory leaks from the IE cloneNode bug.
    function getIENodeHash(node) {
      if (node && node.nodeType > 0) {
        switch (node.nodeType) {
          case 1: // Element
            return node.uniqueID;
          case 9: // Document
            return node.documentElement && node.documentElement.uniqueID;
        }
      }
    }

    // If possible, use a WeakMap.
    var usingWeakMap = typeof WeakMap === "function";
    var weakMap;
    if (usingWeakMap) {
      weakMap = new WeakMap();
    }

    var objHashUID = 0;

    var UID_HASH_KEY = "__immutablehash__";
    if (typeof Symbol === "function") {
      UID_HASH_KEY = Symbol(UID_HASH_KEY);
    }

    var STRING_HASH_CACHE_MIN_STRLEN = 16;
    var STRING_HASH_CACHE_MAX_SIZE = 255;
    var STRING_HASH_CACHE_SIZE = 0;
    var stringHashCache = {};

    var ToKeyedSequence = /*@__PURE__*/ (function(KeyedSeq$$1) {
      function ToKeyedSequence(indexed, useKeys) {
        this._iter = indexed;
        this._useKeys = useKeys;
        this.size = indexed.size;
      }

      if (KeyedSeq$$1) ToKeyedSequence.__proto__ = KeyedSeq$$1;
      ToKeyedSequence.prototype = Object.create(
        KeyedSeq$$1 && KeyedSeq$$1.prototype
      );
      ToKeyedSequence.prototype.constructor = ToKeyedSequence;

      ToKeyedSequence.prototype.get = function get(key, notSetValue) {
        return this._iter.get(key, notSetValue);
      };

      ToKeyedSequence.prototype.has = function has(key) {
        return this._iter.has(key);
      };

      ToKeyedSequence.prototype.valueSeq = function valueSeq() {
        return this._iter.valueSeq();
      };

      ToKeyedSequence.prototype.reverse = function reverse() {
        var this$1 = this;

        var reversedSequence = reverseFactory(this, true);
        if (!this._useKeys) {
          reversedSequence.valueSeq = function() {
            return this$1._iter.toSeq().reverse();
          };
        }
        return reversedSequence;
      };

      ToKeyedSequence.prototype.map = function map(mapper, context) {
        var this$1 = this;

        var mappedSequence = mapFactory(this, mapper, context);
        if (!this._useKeys) {
          mappedSequence.valueSeq = function() {
            return this$1._iter.toSeq().map(mapper, context);
          };
        }
        return mappedSequence;
      };

      ToKeyedSequence.prototype.__iterate = function __iterate(fn, reverse) {
        var this$1 = this;

        return this._iter.__iterate(function(v, k) {
          return fn(v, k, this$1);
        }, reverse);
      };

      ToKeyedSequence.prototype.__iterator = function __iterator(
        type,
        reverse
      ) {
        return this._iter.__iterator(type, reverse);
      };

      return ToKeyedSequence;
    })(KeyedSeq);
    ToKeyedSequence.prototype[IS_ORDERED_SYMBOL] = true;

    var ToIndexedSequence = /*@__PURE__*/ (function(IndexedSeq$$1) {
      function ToIndexedSequence(iter) {
        this._iter = iter;
        this.size = iter.size;
      }

      if (IndexedSeq$$1) ToIndexedSequence.__proto__ = IndexedSeq$$1;
      ToIndexedSequence.prototype = Object.create(
        IndexedSeq$$1 && IndexedSeq$$1.prototype
      );
      ToIndexedSequence.prototype.constructor = ToIndexedSequence;

      ToIndexedSequence.prototype.includes = function includes(value) {
        return this._iter.includes(value);
      };

      ToIndexedSequence.prototype.__iterate = function __iterate(fn, reverse) {
        var this$1 = this;

        var i = 0;
        reverse && ensureSize(this);
        return this._iter.__iterate(function(v) {
          return fn(v, reverse ? this$1.size - ++i : i++, this$1);
        }, reverse);
      };

      ToIndexedSequence.prototype.__iterator = function __iterator(
        type,
        reverse
      ) {
        var this$1 = this;

        var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
        var i = 0;
        reverse && ensureSize(this);
        return new Iterator(function() {
          var step = iterator.next();
          return step.done
            ? step
            : iteratorValue(
                type,
                reverse ? this$1.size - ++i : i++,
                step.value,
                step
              );
        });
      };

      return ToIndexedSequence;
    })(IndexedSeq);

    var ToSetSequence = /*@__PURE__*/ (function(SetSeq$$1) {
      function ToSetSequence(iter) {
        this._iter = iter;
        this.size = iter.size;
      }

      if (SetSeq$$1) ToSetSequence.__proto__ = SetSeq$$1;
      ToSetSequence.prototype = Object.create(SetSeq$$1 && SetSeq$$1.prototype);
      ToSetSequence.prototype.constructor = ToSetSequence;

      ToSetSequence.prototype.has = function has(key) {
        return this._iter.includes(key);
      };

      ToSetSequence.prototype.__iterate = function __iterate(fn, reverse) {
        var this$1 = this;

        return this._iter.__iterate(function(v) {
          return fn(v, v, this$1);
        }, reverse);
      };

      ToSetSequence.prototype.__iterator = function __iterator(type, reverse) {
        var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
        return new Iterator(function() {
          var step = iterator.next();
          return step.done
            ? step
            : iteratorValue(type, step.value, step.value, step);
        });
      };

      return ToSetSequence;
    })(SetSeq);

    var FromEntriesSequence = /*@__PURE__*/ (function(KeyedSeq$$1) {
      function FromEntriesSequence(entries) {
        this._iter = entries;
        this.size = entries.size;
      }

      if (KeyedSeq$$1) FromEntriesSequence.__proto__ = KeyedSeq$$1;
      FromEntriesSequence.prototype = Object.create(
        KeyedSeq$$1 && KeyedSeq$$1.prototype
      );
      FromEntriesSequence.prototype.constructor = FromEntriesSequence;

      FromEntriesSequence.prototype.entrySeq = function entrySeq() {
        return this._iter.toSeq();
      };

      FromEntriesSequence.prototype.__iterate = function __iterate(
        fn,
        reverse
      ) {
        var this$1 = this;

        return this._iter.__iterate(function(entry) {
          // Check if entry exists first so array access doesn't throw for holes
          // in the parent iteration.
          if (entry) {
            validateEntry(entry);
            var indexedCollection = isCollection(entry);
            return fn(
              indexedCollection ? entry.get(1) : entry[1],
              indexedCollection ? entry.get(0) : entry[0],
              this$1
            );
          }
        }, reverse);
      };

      FromEntriesSequence.prototype.__iterator = function __iterator(
        type,
        reverse
      ) {
        var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
        return new Iterator(function() {
          while (true) {
            var step = iterator.next();
            if (step.done) {
              return step;
            }
            var entry = step.value;
            // Check if entry exists first so array access doesn't throw for holes
            // in the parent iteration.
            if (entry) {
              validateEntry(entry);
              var indexedCollection = isCollection(entry);
              return iteratorValue(
                type,
                indexedCollection ? entry.get(0) : entry[0],
                indexedCollection ? entry.get(1) : entry[1],
                step
              );
            }
          }
        });
      };

      return FromEntriesSequence;
    })(KeyedSeq);

    ToIndexedSequence.prototype.cacheResult = ToKeyedSequence.prototype.cacheResult = ToSetSequence.prototype.cacheResult = FromEntriesSequence.prototype.cacheResult = cacheResultThrough;

    function flipFactory(collection) {
      var flipSequence = makeSequence(collection);
      flipSequence._iter = collection;
      flipSequence.size = collection.size;
      flipSequence.flip = function() {
        return collection;
      };
      flipSequence.reverse = function() {
        var reversedSequence = collection.reverse.apply(this); // super.reverse()
        reversedSequence.flip = function() {
          return collection.reverse();
        };
        return reversedSequence;
      };
      flipSequence.has = function(key) {
        return collection.includes(key);
      };
      flipSequence.includes = function(key) {
        return collection.has(key);
      };
      flipSequence.cacheResult = cacheResultThrough;
      flipSequence.__iterateUncached = function(fn, reverse) {
        var this$1 = this;

        return collection.__iterate(function(v, k) {
          return fn(k, v, this$1) !== false;
        }, reverse);
      };
      flipSequence.__iteratorUncached = function(type, reverse) {
        if (type === ITERATE_ENTRIES) {
          var iterator = collection.__iterator(type, reverse);
          return new Iterator(function() {
            var step = iterator.next();
            if (!step.done) {
              var k = step.value[0];
              step.value[0] = step.value[1];
              step.value[1] = k;
            }
            return step;
          });
        }
        return collection.__iterator(
          type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,
          reverse
        );
      };
      return flipSequence;
    }

    function mapFactory(collection, mapper, context) {
      var mappedSequence = makeSequence(collection);
      mappedSequence.size = collection.size;
      mappedSequence.has = function(key) {
        return collection.has(key);
      };
      mappedSequence.get = function(key, notSetValue) {
        var v = collection.get(key, NOT_SET);
        return v === NOT_SET
          ? notSetValue
          : mapper.call(context, v, key, collection);
      };
      mappedSequence.__iterateUncached = function(fn, reverse) {
        var this$1 = this;

        return collection.__iterate(function(v, k, c) {
          return fn(mapper.call(context, v, k, c), k, this$1) !== false;
        }, reverse);
      };
      mappedSequence.__iteratorUncached = function(type, reverse) {
        var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);
        return new Iterator(function() {
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          var entry = step.value;
          var key = entry[0];
          return iteratorValue(
            type,
            key,
            mapper.call(context, entry[1], key, collection),
            step
          );
        });
      };
      return mappedSequence;
    }

    function reverseFactory(collection, useKeys) {
      var this$1 = this;

      var reversedSequence = makeSequence(collection);
      reversedSequence._iter = collection;
      reversedSequence.size = collection.size;
      reversedSequence.reverse = function() {
        return collection;
      };
      if (collection.flip) {
        reversedSequence.flip = function() {
          var flipSequence = flipFactory(collection);
          flipSequence.reverse = function() {
            return collection.flip();
          };
          return flipSequence;
        };
      }
      reversedSequence.get = function(key, notSetValue) {
        return collection.get(useKeys ? key : -1 - key, notSetValue);
      };
      reversedSequence.has = function(key) {
        return collection.has(useKeys ? key : -1 - key);
      };
      reversedSequence.includes = function(value) {
        return collection.includes(value);
      };
      reversedSequence.cacheResult = cacheResultThrough;
      reversedSequence.__iterate = function(fn, reverse) {
        var this$1 = this;

        var i = 0;
        reverse && ensureSize(collection);
        return collection.__iterate(function(v, k) {
          return fn(v, useKeys ? k : reverse ? this$1.size - ++i : i++, this$1);
        }, !reverse);
      };
      reversedSequence.__iterator = function(type, reverse) {
        var i = 0;
        reverse && ensureSize(collection);
        var iterator = collection.__iterator(ITERATE_ENTRIES, !reverse);
        return new Iterator(function() {
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          var entry = step.value;
          return iteratorValue(
            type,
            useKeys ? entry[0] : reverse ? this$1.size - ++i : i++,
            entry[1],
            step
          );
        });
      };
      return reversedSequence;
    }

    function filterFactory(collection, predicate, context, useKeys) {
      var filterSequence = makeSequence(collection);
      if (useKeys) {
        filterSequence.has = function(key) {
          var v = collection.get(key, NOT_SET);
          return v !== NOT_SET && !!predicate.call(context, v, key, collection);
        };
        filterSequence.get = function(key, notSetValue) {
          var v = collection.get(key, NOT_SET);
          return v !== NOT_SET && predicate.call(context, v, key, collection)
            ? v
            : notSetValue;
        };
      }
      filterSequence.__iterateUncached = function(fn, reverse) {
        var this$1 = this;

        var iterations = 0;
        collection.__iterate(function(v, k, c) {
          if (predicate.call(context, v, k, c)) {
            iterations++;
            return fn(v, useKeys ? k : iterations - 1, this$1);
          }
        }, reverse);
        return iterations;
      };
      filterSequence.__iteratorUncached = function(type, reverse) {
        var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);
        var iterations = 0;
        return new Iterator(function() {
          while (true) {
            var step = iterator.next();
            if (step.done) {
              return step;
            }
            var entry = step.value;
            var key = entry[0];
            var value = entry[1];
            if (predicate.call(context, value, key, collection)) {
              return iteratorValue(
                type,
                useKeys ? key : iterations++,
                value,
                step
              );
            }
          }
        });
      };
      return filterSequence;
    }

    function countByFactory(collection, grouper, context) {
      var groups = Map().asMutable();
      collection.__iterate(function(v, k) {
        groups.update(grouper.call(context, v, k, collection), 0, function(a) {
          return a + 1;
        });
      });
      return groups.asImmutable();
    }

    function groupByFactory(collection, grouper, context) {
      var isKeyedIter = isKeyed(collection);
      var groups = (isOrdered(collection) ? OrderedMap() : Map()).asMutable();
      collection.__iterate(function(v, k) {
        groups.update(grouper.call(context, v, k, collection), function(a) {
          return (a = a || []), a.push(isKeyedIter ? [k, v] : v), a;
        });
      });
      var coerce = collectionClass(collection);
      return groups
        .map(function(arr) {
          return reify(collection, coerce(arr));
        })
        .asImmutable();
    }

    function sliceFactory(collection, begin, end, useKeys) {
      var originalSize = collection.size;

      if (wholeSlice(begin, end, originalSize)) {
        return collection;
      }

      var resolvedBegin = resolveBegin(begin, originalSize);
      var resolvedEnd = resolveEnd(end, originalSize);

      // begin or end will be NaN if they were provided as negative numbers and
      // this collection's size is unknown. In that case, cache first so there is
      // a known size and these do not resolve to NaN.
      if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {
        return sliceFactory(
          collection.toSeq().cacheResult(),
          begin,
          end,
          useKeys
        );
      }

      // Note: resolvedEnd is undefined when the original sequence's length is
      // unknown and this slice did not supply an end and should contain all
      // elements after resolvedBegin.
      // In that case, resolvedSize will be NaN and sliceSize will remain undefined.
      var resolvedSize = resolvedEnd - resolvedBegin;
      var sliceSize;
      if (resolvedSize === resolvedSize) {
        sliceSize = resolvedSize < 0 ? 0 : resolvedSize;
      }

      var sliceSeq = makeSequence(collection);

      // If collection.size is undefined, the size of the realized sliceSeq is
      // unknown at this point unless the number of items to slice is 0
      sliceSeq.size =
        sliceSize === 0
          ? sliceSize
          : (collection.size && sliceSize) || undefined;

      if (!useKeys && isSeq(collection) && sliceSize >= 0) {
        sliceSeq.get = function(index, notSetValue) {
          index = wrapIndex(this, index);
          return index >= 0 && index < sliceSize
            ? collection.get(index + resolvedBegin, notSetValue)
            : notSetValue;
        };
      }

      sliceSeq.__iterateUncached = function(fn, reverse) {
        var this$1 = this;

        if (sliceSize === 0) {
          return 0;
        }
        if (reverse) {
          return this.cacheResult().__iterate(fn, reverse);
        }
        var skipped = 0;
        var isSkipping = true;
        var iterations = 0;
        collection.__iterate(function(v, k) {
          if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {
            iterations++;
            return (
              fn(v, useKeys ? k : iterations - 1, this$1) !== false &&
              iterations !== sliceSize
            );
          }
        });
        return iterations;
      };

      sliceSeq.__iteratorUncached = function(type, reverse) {
        if (sliceSize !== 0 && reverse) {
          return this.cacheResult().__iterator(type, reverse);
        }
        // Don't bother instantiating parent iterator if taking 0.
        if (sliceSize === 0) {
          return new Iterator(iteratorDone);
        }
        var iterator = collection.__iterator(type, reverse);
        var skipped = 0;
        var iterations = 0;
        return new Iterator(function() {
          while (skipped++ < resolvedBegin) {
            iterator.next();
          }
          if (++iterations > sliceSize) {
            return iteratorDone();
          }
          var step = iterator.next();
          if (useKeys || type === ITERATE_VALUES || step.done) {
            return step;
          }
          if (type === ITERATE_KEYS) {
            return iteratorValue(type, iterations - 1, undefined, step);
          }
          return iteratorValue(type, iterations - 1, step.value[1], step);
        });
      };

      return sliceSeq;
    }

    function takeWhileFactory(collection, predicate, context) {
      var takeSequence = makeSequence(collection);
      takeSequence.__iterateUncached = function(fn, reverse) {
        var this$1 = this;

        if (reverse) {
          return this.cacheResult().__iterate(fn, reverse);
        }
        var iterations = 0;
        collection.__iterate(function(v, k, c) {
          return (
            predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$1)
          );
        });
        return iterations;
      };
      takeSequence.__iteratorUncached = function(type, reverse) {
        var this$1 = this;

        if (reverse) {
          return this.cacheResult().__iterator(type, reverse);
        }
        var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);
        var iterating = true;
        return new Iterator(function() {
          if (!iterating) {
            return iteratorDone();
          }
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          var entry = step.value;
          var k = entry[0];
          var v = entry[1];
          if (!predicate.call(context, v, k, this$1)) {
            iterating = false;
            return iteratorDone();
          }
          return type === ITERATE_ENTRIES
            ? step
            : iteratorValue(type, k, v, step);
        });
      };
      return takeSequence;
    }

    function skipWhileFactory(collection, predicate, context, useKeys) {
      var skipSequence = makeSequence(collection);
      skipSequence.__iterateUncached = function(fn, reverse) {
        var this$1 = this;

        if (reverse) {
          return this.cacheResult().__iterate(fn, reverse);
        }
        var isSkipping = true;
        var iterations = 0;
        collection.__iterate(function(v, k, c) {
          if (
            !(isSkipping && (isSkipping = predicate.call(context, v, k, c)))
          ) {
            iterations++;
            return fn(v, useKeys ? k : iterations - 1, this$1);
          }
        });
        return iterations;
      };
      skipSequence.__iteratorUncached = function(type, reverse) {
        var this$1 = this;

        if (reverse) {
          return this.cacheResult().__iterator(type, reverse);
        }
        var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);
        var skipping = true;
        var iterations = 0;
        return new Iterator(function() {
          var step;
          var k;
          var v;
          do {
            step = iterator.next();
            if (step.done) {
              if (useKeys || type === ITERATE_VALUES) {
                return step;
              }
              if (type === ITERATE_KEYS) {
                return iteratorValue(type, iterations++, undefined, step);
              }
              return iteratorValue(type, iterations++, step.value[1], step);
            }
            var entry = step.value;
            k = entry[0];
            v = entry[1];
            skipping && (skipping = predicate.call(context, v, k, this$1));
          } while (skipping);
          return type === ITERATE_ENTRIES
            ? step
            : iteratorValue(type, k, v, step);
        });
      };
      return skipSequence;
    }

    function concatFactory(collection, values) {
      var isKeyedCollection = isKeyed(collection);
      var iters = [collection]
        .concat(values)
        .map(function(v) {
          if (!isCollection(v)) {
            v = isKeyedCollection
              ? keyedSeqFromValue(v)
              : indexedSeqFromValue(Array.isArray(v) ? v : [v]);
          } else if (isKeyedCollection) {
            v = KeyedCollection(v);
          }
          return v;
        })
        .filter(function(v) {
          return v.size !== 0;
        });

      if (iters.length === 0) {
        return collection;
      }

      if (iters.length === 1) {
        var singleton = iters[0];
        if (
          singleton === collection ||
          (isKeyedCollection && isKeyed(singleton)) ||
          (isIndexed(collection) && isIndexed(singleton))
        ) {
          return singleton;
        }
      }

      var concatSeq = new ArraySeq(iters);
      if (isKeyedCollection) {
        concatSeq = concatSeq.toKeyedSeq();
      } else if (!isIndexed(collection)) {
        concatSeq = concatSeq.toSetSeq();
      }
      concatSeq = concatSeq.flatten(true);
      concatSeq.size = iters.reduce(function(sum, seq) {
        if (sum !== undefined) {
          var size = seq.size;
          if (size !== undefined) {
            return sum + size;
          }
        }
      }, 0);
      return concatSeq;
    }

    function flattenFactory(collection, depth, useKeys) {
      var flatSequence = makeSequence(collection);
      flatSequence.__iterateUncached = function(fn, reverse) {
        if (reverse) {
          return this.cacheResult().__iterate(fn, reverse);
        }
        var iterations = 0;
        var stopped = false;
        function flatDeep(iter, currentDepth) {
          iter.__iterate(function(v, k) {
            if ((!depth || currentDepth < depth) && isCollection(v)) {
              flatDeep(v, currentDepth + 1);
            } else {
              iterations++;
              if (fn(v, useKeys ? k : iterations - 1, flatSequence) === false) {
                stopped = true;
              }
            }
            return !stopped;
          }, reverse);
        }
        flatDeep(collection, 0);
        return iterations;
      };
      flatSequence.__iteratorUncached = function(type, reverse) {
        if (reverse) {
          return this.cacheResult().__iterator(type, reverse);
        }
        var iterator = collection.__iterator(type, reverse);
        var stack = [];
        var iterations = 0;
        return new Iterator(function() {
          while (iterator) {
            var step = iterator.next();
            if (step.done !== false) {
              iterator = stack.pop();
              continue;
            }
            var v = step.value;
            if (type === ITERATE_ENTRIES) {
              v = v[1];
            }
            if ((!depth || stack.length < depth) && isCollection(v)) {
              stack.push(iterator);
              iterator = v.__iterator(type, reverse);
            } else {
              return useKeys
                ? step
                : iteratorValue(type, iterations++, v, step);
            }
          }
          return iteratorDone();
        });
      };
      return flatSequence;
    }

    function flatMapFactory(collection, mapper, context) {
      var coerce = collectionClass(collection);
      return collection
        .toSeq()
        .map(function(v, k) {
          return coerce(mapper.call(context, v, k, collection));
        })
        .flatten(true);
    }

    function interposeFactory(collection, separator) {
      var interposedSequence = makeSequence(collection);
      interposedSequence.size = collection.size && collection.size * 2 - 1;
      interposedSequence.__iterateUncached = function(fn, reverse) {
        var this$1 = this;

        var iterations = 0;
        collection.__iterate(function(v) {
          return (
            (!iterations || fn(separator, iterations++, this$1) !== false) &&
            fn(v, iterations++, this$1) !== false
          );
        }, reverse);
        return iterations;
      };
      interposedSequence.__iteratorUncached = function(type, reverse) {
        var iterator = collection.__iterator(ITERATE_VALUES, reverse);
        var iterations = 0;
        var step;
        return new Iterator(function() {
          if (!step || iterations % 2) {
            step = iterator.next();
            if (step.done) {
              return step;
            }
          }
          return iterations % 2
            ? iteratorValue(type, iterations++, separator)
            : iteratorValue(type, iterations++, step.value, step);
        });
      };
      return interposedSequence;
    }

    function sortFactory(collection, comparator, mapper) {
      if (!comparator) {
        comparator = defaultComparator;
      }
      var isKeyedCollection = isKeyed(collection);
      var index = 0;
      var entries = collection
        .toSeq()
        .map(function(v, k) {
          return [k, v, index++, mapper ? mapper(v, k, collection) : v];
        })
        .valueSeq()
        .toArray();
      entries
        .sort(function(a, b) {
          return comparator(a[3], b[3]) || a[2] - b[2];
        })
        .forEach(
          isKeyedCollection
            ? function(v, i) {
                entries[i].length = 2;
              }
            : function(v, i) {
                entries[i] = v[1];
              }
        );
      return isKeyedCollection
        ? KeyedSeq(entries)
        : isIndexed(collection)
        ? IndexedSeq(entries)
        : SetSeq(entries);
    }

    function maxFactory(collection, comparator, mapper) {
      if (!comparator) {
        comparator = defaultComparator;
      }
      if (mapper) {
        var entry = collection
          .toSeq()
          .map(function(v, k) {
            return [v, mapper(v, k, collection)];
          })
          .reduce(function(a, b) {
            return maxCompare(comparator, a[1], b[1]) ? b : a;
          });
        return entry && entry[0];
      }
      return collection.reduce(function(a, b) {
        return maxCompare(comparator, a, b) ? b : a;
      });
    }

    function maxCompare(comparator, a, b) {
      var comp = comparator(b, a);
      // b is considered the new max if the comparator declares them equal, but
      // they are not equal and b is in fact a nullish value.
      return (
        (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) ||
        comp > 0
      );
    }

    function zipWithFactory(keyIter, zipper, iters, zipAll) {
      var zipSequence = makeSequence(keyIter);
      var sizes = new ArraySeq(iters).map(function(i) {
        return i.size;
      });
      zipSequence.size = zipAll ? sizes.max() : sizes.min();
      // Note: this a generic base implementation of __iterate in terms of
      // __iterator which may be more generically useful in the future.
      zipSequence.__iterate = function(fn, reverse) {
        /* generic:
      var iterator = this.__iterator(ITERATE_ENTRIES, reverse);
      var step;
      var iterations = 0;
      while (!(step = iterator.next()).done) {
        iterations++;
        if (fn(step.value[1], step.value[0], this) === false) {
          break;
        }
      }
      return iterations;
      */
        // indexed:
        var iterator = this.__iterator(ITERATE_VALUES, reverse);
        var step;
        var iterations = 0;
        while (!(step = iterator.next()).done) {
          if (fn(step.value, iterations++, this) === false) {
            break;
          }
        }
        return iterations;
      };
      zipSequence.__iteratorUncached = function(type, reverse) {
        var iterators = iters.map(function(i) {
          return (i = Collection(i)), getIterator(reverse ? i.reverse() : i);
        });
        var iterations = 0;
        var isDone = false;
        return new Iterator(function() {
          var steps;
          if (!isDone) {
            steps = iterators.map(function(i) {
              return i.next();
            });
            isDone = zipAll
              ? steps.every(function(s) {
                  return s.done;
                })
              : steps.some(function(s) {
                  return s.done;
                });
          }
          if (isDone) {
            return iteratorDone();
          }
          return iteratorValue(
            type,
            iterations++,
            zipper.apply(
              null,
              steps.map(function(s) {
                return s.value;
              })
            )
          );
        });
      };
      return zipSequence;
    }

    // #pragma Helper Functions

    function reify(iter, seq) {
      return iter === seq ? iter : isSeq(iter) ? seq : iter.constructor(seq);
    }

    function validateEntry(entry) {
      if (entry !== Object(entry)) {
        throw new TypeError("Expected [K, V] tuple: " + entry);
      }
    }

    function collectionClass(collection) {
      return isKeyed(collection)
        ? KeyedCollection
        : isIndexed(collection)
        ? IndexedCollection
        : SetCollection;
    }

    function makeSequence(collection) {
      return Object.create(
        (isKeyed(collection)
          ? KeyedSeq
          : isIndexed(collection)
          ? IndexedSeq
          : SetSeq
        ).prototype
      );
    }

    function cacheResultThrough() {
      if (this._iter.cacheResult) {
        this._iter.cacheResult();
        this.size = this._iter.size;
        return this;
      }
      return Seq.prototype.cacheResult.call(this);
    }

    function defaultComparator(a, b) {
      if (a === undefined && b === undefined) {
        return 0;
      }

      if (a === undefined) {
        return 1;
      }

      if (b === undefined) {
        return -1;
      }

      return a > b ? 1 : a < b ? -1 : 0;
    }

    // http://jsperf.com/copy-array-inline
    function arrCopy(arr, offset) {
      offset = offset || 0;
      var len = Math.max(0, arr.length - offset);
      var newArr = new Array(len);
      for (var ii = 0; ii < len; ii++) {
        newArr[ii] = arr[ii + offset];
      }
      return newArr;
    }

    function invariant(condition, error) {
      if (!condition) {
        throw new Error(error);
      }
    }

    function assertNotInfinite(size) {
      invariant(
        size !== Infinity,
        "Cannot perform this action with an infinite size."
      );
    }

    function coerceKeyPath(keyPath) {
      if (isArrayLike(keyPath) && typeof keyPath !== "string") {
        return keyPath;
      }
      if (isOrdered(keyPath)) {
        return keyPath.toArray();
      }
      throw new TypeError(
        "Invalid keyPath: expected Ordered Collection or Array: " + keyPath
      );
    }

    function isPlainObj(value) {
      return (
        value &&
        (typeof value.constructor !== "function" ||
          value.constructor.name === "Object")
      );
    }

    /**
     * Returns true if the value is a potentially-persistent data structure, either
     * provided by Immutable.js or a plain Array or Object.
     */
    function isDataStructure(value) {
      return (
        typeof value === "object" &&
        (isImmutable(value) || Array.isArray(value) || isPlainObj(value))
      );
    }

    /**
     * Converts a value to a string, adding quotes if a string was provided.
     */
    function quoteString(value) {
      try {
        return typeof value === "string"
          ? JSON.stringify(value)
          : String(value);
      } catch (_ignoreError) {
        return JSON.stringify(value);
      }
    }

    function has(collection, key) {
      return isImmutable(collection)
        ? collection.has(key)
        : isDataStructure(collection) && hasOwnProperty.call(collection, key);
    }

    function get(collection, key, notSetValue) {
      return isImmutable(collection)
        ? collection.get(key, notSetValue)
        : !has(collection, key)
        ? notSetValue
        : typeof collection.get === "function"
        ? collection.get(key)
        : collection[key];
    }

    function shallowCopy(from) {
      if (Array.isArray(from)) {
        return arrCopy(from);
      }
      var to = {};
      for (var key in from) {
        if (hasOwnProperty.call(from, key)) {
          to[key] = from[key];
        }
      }
      return to;
    }

    function remove(collection, key) {
      if (!isDataStructure(collection)) {
        throw new TypeError(
          "Cannot update non-data-structure value: " + collection
        );
      }
      if (isImmutable(collection)) {
        if (!collection.remove) {
          throw new TypeError(
            "Cannot update immutable value without .remove() method: " +
              collection
          );
        }
        return collection.remove(key);
      }
      if (!hasOwnProperty.call(collection, key)) {
        return collection;
      }
      var collectionCopy = shallowCopy(collection);
      if (Array.isArray(collectionCopy)) {
        collectionCopy.splice(key, 1);
      } else {
        delete collectionCopy[key];
      }
      return collectionCopy;
    }

    function set(collection, key, value) {
      if (!isDataStructure(collection)) {
        throw new TypeError(
          "Cannot update non-data-structure value: " + collection
        );
      }
      if (isImmutable(collection)) {
        if (!collection.set) {
          throw new TypeError(
            "Cannot update immutable value without .set() method: " + collection
          );
        }
        return collection.set(key, value);
      }
      if (hasOwnProperty.call(collection, key) && value === collection[key]) {
        return collection;
      }
      var collectionCopy = shallowCopy(collection);
      collectionCopy[key] = value;
      return collectionCopy;
    }

    function updateIn(collection, keyPath, notSetValue, updater) {
      if (!updater) {
        updater = notSetValue;
        notSetValue = undefined;
      }
      var updatedValue = updateInDeeply(
        isImmutable(collection),
        collection,
        coerceKeyPath(keyPath),
        0,
        notSetValue,
        updater
      );
      return updatedValue === NOT_SET ? notSetValue : updatedValue;
    }

    function updateInDeeply(
      inImmutable,
      existing,
      keyPath,
      i,
      notSetValue,
      updater
    ) {
      var wasNotSet = existing === NOT_SET;
      if (i === keyPath.length) {
        var existingValue = wasNotSet ? notSetValue : existing;
        var newValue = updater(existingValue);
        return newValue === existingValue ? existing : newValue;
      }
      if (!wasNotSet && !isDataStructure(existing)) {
        throw new TypeError(
          "Cannot update within non-data-structure value in path [" +
            keyPath.slice(0, i).map(quoteString) +
            "]: " +
            existing
        );
      }
      var key = keyPath[i];
      var nextExisting = wasNotSet ? NOT_SET : get(existing, key, NOT_SET);
      var nextUpdated = updateInDeeply(
        nextExisting === NOT_SET ? inImmutable : isImmutable(nextExisting),
        nextExisting,
        keyPath,
        i + 1,
        notSetValue,
        updater
      );
      return nextUpdated === nextExisting
        ? existing
        : nextUpdated === NOT_SET
        ? remove(existing, key)
        : set(
            wasNotSet ? (inImmutable ? emptyMap() : {}) : existing,
            key,
            nextUpdated
          );
    }

    function setIn(collection, keyPath, value) {
      return updateIn(collection, keyPath, NOT_SET, function() {
        return value;
      });
    }

    function setIn$1(keyPath, v) {
      return setIn(this, keyPath, v);
    }

    function removeIn(collection, keyPath) {
      return updateIn(collection, keyPath, function() {
        return NOT_SET;
      });
    }

    function deleteIn(keyPath) {
      return removeIn(this, keyPath);
    }

    function update(collection, key, notSetValue, updater) {
      return updateIn(collection, [key], notSetValue, updater);
    }

    function update$1(key, notSetValue, updater) {
      return arguments.length === 1
        ? key(this)
        : update(this, key, notSetValue, updater);
    }

    function updateIn$1(keyPath, notSetValue, updater) {
      return updateIn(this, keyPath, notSetValue, updater);
    }

    function merge() {
      var iters = [],
        len = arguments.length;
      while (len--) iters[len] = arguments[len];

      return mergeIntoKeyedWith(this, iters);
    }

    function mergeWith(merger) {
      var iters = [],
        len = arguments.length - 1;
      while (len-- > 0) iters[len] = arguments[len + 1];

      if (typeof merger !== "function") {
        throw new TypeError("Invalid merger function: " + merger);
      }
      return mergeIntoKeyedWith(this, iters, merger);
    }

    function mergeIntoKeyedWith(collection, collections, merger) {
      var iters = [];
      for (var ii = 0; ii < collections.length; ii++) {
        var collection$1 = KeyedCollection(collections[ii]);
        if (collection$1.size !== 0) {
          iters.push(collection$1);
        }
      }
      if (iters.length === 0) {
        return collection;
      }
      if (
        collection.toSeq().size === 0 &&
        !collection.__ownerID &&
        iters.length === 1
      ) {
        return collection.constructor(iters[0]);
      }
      return collection.withMutations(function(collection) {
        var mergeIntoCollection = merger
          ? function(value, key) {
              update(collection, key, NOT_SET, function(oldVal) {
                return oldVal === NOT_SET ? value : merger(oldVal, value, key);
              });
            }
          : function(value, key) {
              collection.set(key, value);
            };
        for (var ii = 0; ii < iters.length; ii++) {
          iters[ii].forEach(mergeIntoCollection);
        }
      });
    }

    function merge$1(collection) {
      var sources = [],
        len = arguments.length - 1;
      while (len-- > 0) sources[len] = arguments[len + 1];

      return mergeWithSources(collection, sources);
    }

    function mergeWith$1(merger, collection) {
      var sources = [],
        len = arguments.length - 2;
      while (len-- > 0) sources[len] = arguments[len + 2];

      return mergeWithSources(collection, sources, merger);
    }

    function mergeDeep(collection) {
      var sources = [],
        len = arguments.length - 1;
      while (len-- > 0) sources[len] = arguments[len + 1];

      return mergeDeepWithSources(collection, sources);
    }

    function mergeDeepWith(merger, collection) {
      var sources = [],
        len = arguments.length - 2;
      while (len-- > 0) sources[len] = arguments[len + 2];

      return mergeDeepWithSources(collection, sources, merger);
    }

    function mergeDeepWithSources(collection, sources, merger) {
      return mergeWithSources(collection, sources, deepMergerWith(merger));
    }

    function mergeWithSources(collection, sources, merger) {
      if (!isDataStructure(collection)) {
        throw new TypeError(
          "Cannot merge into non-data-structure value: " + collection
        );
      }
      if (isImmutable(collection)) {
        return typeof merger === "function" && collection.mergeWith
          ? collection.mergeWith.apply(collection, [merger].concat(sources))
          : collection.merge
          ? collection.merge.apply(collection, sources)
          : collection.concat.apply(collection, sources);
      }
      var isArray = Array.isArray(collection);
      var merged = collection;
      var Collection$$1 = isArray ? IndexedCollection : KeyedCollection;
      var mergeItem = isArray
        ? function(value) {
            // Copy on write
            if (merged === collection) {
              merged = shallowCopy(merged);
            }
            merged.push(value);
          }
        : function(value, key) {
            var hasVal = hasOwnProperty.call(merged, key);
            var nextVal =
              hasVal && merger ? merger(merged[key], value, key) : value;
            if (!hasVal || nextVal !== merged[key]) {
              // Copy on write
              if (merged === collection) {
                merged = shallowCopy(merged);
              }
              merged[key] = nextVal;
            }
          };
      for (var i = 0; i < sources.length; i++) {
        Collection$$1(sources[i]).forEach(mergeItem);
      }
      return merged;
    }

    function deepMergerWith(merger) {
      function deepMerger(oldValue, newValue, key) {
        return isDataStructure(oldValue) && isDataStructure(newValue)
          ? mergeWithSources(oldValue, [newValue], deepMerger)
          : merger
          ? merger(oldValue, newValue, key)
          : newValue;
      }
      return deepMerger;
    }

    function mergeDeep$1() {
      var iters = [],
        len = arguments.length;
      while (len--) iters[len] = arguments[len];

      return mergeDeepWithSources(this, iters);
    }

    function mergeDeepWith$1(merger) {
      var iters = [],
        len = arguments.length - 1;
      while (len-- > 0) iters[len] = arguments[len + 1];

      return mergeDeepWithSources(this, iters, merger);
    }

    function mergeIn(keyPath) {
      var iters = [],
        len = arguments.length - 1;
      while (len-- > 0) iters[len] = arguments[len + 1];

      return updateIn(this, keyPath, emptyMap(), function(m) {
        return mergeWithSources(m, iters);
      });
    }

    function mergeDeepIn(keyPath) {
      var iters = [],
        len = arguments.length - 1;
      while (len-- > 0) iters[len] = arguments[len + 1];

      return updateIn(this, keyPath, emptyMap(), function(m) {
        return mergeDeepWithSources(m, iters);
      });
    }

    function withMutations(fn) {
      var mutable = this.asMutable();
      fn(mutable);
      return mutable.wasAltered()
        ? mutable.__ensureOwner(this.__ownerID)
        : this;
    }

    function asMutable() {
      return this.__ownerID ? this : this.__ensureOwner(new OwnerID());
    }

    function asImmutable() {
      return this.__ensureOwner();
    }

    function wasAltered() {
      return this.__altered;
    }

    var Map = /*@__PURE__*/ (function(KeyedCollection$$1) {
      function Map(value) {
        return value === null || value === undefined
          ? emptyMap()
          : isMap(value) && !isOrdered(value)
          ? value
          : emptyMap().withMutations(function(map) {
              var iter = KeyedCollection$$1(value);
              assertNotInfinite(iter.size);
              iter.forEach(function(v, k) {
                return map.set(k, v);
              });
            });
      }

      if (KeyedCollection$$1) Map.__proto__ = KeyedCollection$$1;
      Map.prototype = Object.create(
        KeyedCollection$$1 && KeyedCollection$$1.prototype
      );
      Map.prototype.constructor = Map;

      Map.of = function of() {
        var keyValues = [],
          len = arguments.length;
        while (len--) keyValues[len] = arguments[len];

        return emptyMap().withMutations(function(map) {
          for (var i = 0; i < keyValues.length; i += 2) {
            if (i + 1 >= keyValues.length) {
              throw new Error("Missing value for key: " + keyValues[i]);
            }
            map.set(keyValues[i], keyValues[i + 1]);
          }
        });
      };

      Map.prototype.toString = function toString() {
        return this.__toString("Map {", "}");
      };

      // @pragma Access

      Map.prototype.get = function get(k, notSetValue) {
        return this._root
          ? this._root.get(0, undefined, k, notSetValue)
          : notSetValue;
      };

      // @pragma Modification

      Map.prototype.set = function set(k, v) {
        return updateMap(this, k, v);
      };

      Map.prototype.remove = function remove(k) {
        return updateMap(this, k, NOT_SET);
      };

      Map.prototype.deleteAll = function deleteAll(keys) {
        var collection = Collection(keys);

        if (collection.size === 0) {
          return this;
        }

        return this.withMutations(function(map) {
          collection.forEach(function(key) {
            return map.remove(key);
          });
        });
      };

      Map.prototype.clear = function clear() {
        if (this.size === 0) {
          return this;
        }
        if (this.__ownerID) {
          this.size = 0;
          this._root = null;
          this.__hash = undefined;
          this.__altered = true;
          return this;
        }
        return emptyMap();
      };

      // @pragma Composition

      Map.prototype.sort = function sort(comparator) {
        // Late binding
        return OrderedMap(sortFactory(this, comparator));
      };

      Map.prototype.sortBy = function sortBy(mapper, comparator) {
        // Late binding
        return OrderedMap(sortFactory(this, comparator, mapper));
      };

      Map.prototype.map = function map(mapper, context) {
        return this.withMutations(function(map) {
          map.forEach(function(value, key) {
            map.set(key, mapper.call(context, value, key, map));
          });
        });
      };

      // @pragma Mutability

      Map.prototype.__iterator = function __iterator(type, reverse) {
        return new MapIterator(this, type, reverse);
      };

      Map.prototype.__iterate = function __iterate(fn, reverse) {
        var this$1 = this;

        var iterations = 0;
        this._root &&
          this._root.iterate(function(entry) {
            iterations++;
            return fn(entry[1], entry[0], this$1);
          }, reverse);
        return iterations;
      };

      Map.prototype.__ensureOwner = function __ensureOwner(ownerID) {
        if (ownerID === this.__ownerID) {
          return this;
        }
        if (!ownerID) {
          if (this.size === 0) {
            return emptyMap();
          }
          this.__ownerID = ownerID;
          this.__altered = false;
          return this;
        }
        return makeMap(this.size, this._root, ownerID, this.__hash);
      };

      return Map;
    })(KeyedCollection);

    Map.isMap = isMap;

    var MapPrototype = Map.prototype;
    MapPrototype[IS_MAP_SYMBOL] = true;
    MapPrototype[DELETE] = MapPrototype.remove;
    MapPrototype.removeAll = MapPrototype.deleteAll;
    MapPrototype.setIn = setIn$1;
    MapPrototype.removeIn = MapPrototype.deleteIn = deleteIn;
    MapPrototype.update = update$1;
    MapPrototype.updateIn = updateIn$1;
    MapPrototype.merge = MapPrototype.concat = merge;
    MapPrototype.mergeWith = mergeWith;
    MapPrototype.mergeDeep = mergeDeep$1;
    MapPrototype.mergeDeepWith = mergeDeepWith$1;
    MapPrototype.mergeIn = mergeIn;
    MapPrototype.mergeDeepIn = mergeDeepIn;
    MapPrototype.withMutations = withMutations;
    MapPrototype.wasAltered = wasAltered;
    MapPrototype.asImmutable = asImmutable;
    MapPrototype["@@transducer/init"] = MapPrototype.asMutable = asMutable;
    MapPrototype["@@transducer/step"] = function(result, arr) {
      return result.set(arr[0], arr[1]);
    };
    MapPrototype["@@transducer/result"] = function(obj) {
      return obj.asImmutable();
    };

    // #pragma Trie Nodes

    var ArrayMapNode = function ArrayMapNode(ownerID, entries) {
      this.ownerID = ownerID;
      this.entries = entries;
    };

    ArrayMapNode.prototype.get = function get(
      shift,
      keyHash,
      key,
      notSetValue
    ) {
      var entries = this.entries;
      for (var ii = 0, len = entries.length; ii < len; ii++) {
        if (is(key, entries[ii][0])) {
          return entries[ii][1];
        }
      }
      return notSetValue;
    };

    ArrayMapNode.prototype.update = function update(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      var removed = value === NOT_SET;

      var entries = this.entries;
      var idx = 0;
      var len = entries.length;
      for (; idx < len; idx++) {
        if (is(key, entries[idx][0])) {
          break;
        }
      }
      var exists = idx < len;

      if (exists ? entries[idx][1] === value : removed) {
        return this;
      }

      SetRef(didAlter);
      (removed || !exists) && SetRef(didChangeSize);

      if (removed && entries.length === 1) {
        return; // undefined
      }

      if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {
        return createNodes(ownerID, entries, key, value);
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newEntries = isEditable ? entries : arrCopy(entries);

      if (exists) {
        if (removed) {
          idx === len - 1
            ? newEntries.pop()
            : (newEntries[idx] = newEntries.pop());
        } else {
          newEntries[idx] = [key, value];
        }
      } else {
        newEntries.push([key, value]);
      }

      if (isEditable) {
        this.entries = newEntries;
        return this;
      }

      return new ArrayMapNode(ownerID, newEntries);
    };

    var BitmapIndexedNode = function BitmapIndexedNode(ownerID, bitmap, nodes) {
      this.ownerID = ownerID;
      this.bitmap = bitmap;
      this.nodes = nodes;
    };

    BitmapIndexedNode.prototype.get = function get(
      shift,
      keyHash,
      key,
      notSetValue
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var bit = 1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK);
      var bitmap = this.bitmap;
      return (bitmap & bit) === 0
        ? notSetValue
        : this.nodes[popCount(bitmap & (bit - 1))].get(
            shift + SHIFT,
            keyHash,
            key,
            notSetValue
          );
    };

    BitmapIndexedNode.prototype.update = function update(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
      var bit = 1 << keyHashFrag;
      var bitmap = this.bitmap;
      var exists = (bitmap & bit) !== 0;

      if (!exists && value === NOT_SET) {
        return this;
      }

      var idx = popCount(bitmap & (bit - 1));
      var nodes = this.nodes;
      var node = exists ? nodes[idx] : undefined;
      var newNode = updateNode(
        node,
        ownerID,
        shift + SHIFT,
        keyHash,
        key,
        value,
        didChangeSize,
        didAlter
      );

      if (newNode === node) {
        return this;
      }

      if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {
        return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);
      }

      if (
        exists &&
        !newNode &&
        nodes.length === 2 &&
        isLeafNode(nodes[idx ^ 1])
      ) {
        return nodes[idx ^ 1];
      }

      if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {
        return newNode;
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newBitmap = exists ? (newNode ? bitmap : bitmap ^ bit) : bitmap | bit;
      var newNodes = exists
        ? newNode
          ? setAt(nodes, idx, newNode, isEditable)
          : spliceOut(nodes, idx, isEditable)
        : spliceIn(nodes, idx, newNode, isEditable);

      if (isEditable) {
        this.bitmap = newBitmap;
        this.nodes = newNodes;
        return this;
      }

      return new BitmapIndexedNode(ownerID, newBitmap, newNodes);
    };

    var HashArrayMapNode = function HashArrayMapNode(ownerID, count, nodes) {
      this.ownerID = ownerID;
      this.count = count;
      this.nodes = nodes;
    };

    HashArrayMapNode.prototype.get = function get(
      shift,
      keyHash,
      key,
      notSetValue
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
      var node = this.nodes[idx];
      return node
        ? node.get(shift + SHIFT, keyHash, key, notSetValue)
        : notSetValue;
    };

    HashArrayMapNode.prototype.update = function update(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
      var removed = value === NOT_SET;
      var nodes = this.nodes;
      var node = nodes[idx];

      if (removed && !node) {
        return this;
      }

      var newNode = updateNode(
        node,
        ownerID,
        shift + SHIFT,
        keyHash,
        key,
        value,
        didChangeSize,
        didAlter
      );
      if (newNode === node) {
        return this;
      }

      var newCount = this.count;
      if (!node) {
        newCount++;
      } else if (!newNode) {
        newCount--;
        if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {
          return packNodes(ownerID, nodes, newCount, idx);
        }
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newNodes = setAt(nodes, idx, newNode, isEditable);

      if (isEditable) {
        this.count = newCount;
        this.nodes = newNodes;
        return this;
      }

      return new HashArrayMapNode(ownerID, newCount, newNodes);
    };

    var HashCollisionNode = function HashCollisionNode(
      ownerID,
      keyHash,
      entries
    ) {
      this.ownerID = ownerID;
      this.keyHash = keyHash;
      this.entries = entries;
    };

    HashCollisionNode.prototype.get = function get(
      shift,
      keyHash,
      key,
      notSetValue
    ) {
      var entries = this.entries;
      for (var ii = 0, len = entries.length; ii < len; ii++) {
        if (is(key, entries[ii][0])) {
          return entries[ii][1];
        }
      }
      return notSetValue;
    };

    HashCollisionNode.prototype.update = function update(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }

      var removed = value === NOT_SET;

      if (keyHash !== this.keyHash) {
        if (removed) {
          return this;
        }
        SetRef(didAlter);
        SetRef(didChangeSize);
        return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);
      }

      var entries = this.entries;
      var idx = 0;
      var len = entries.length;
      for (; idx < len; idx++) {
        if (is(key, entries[idx][0])) {
          break;
        }
      }
      var exists = idx < len;

      if (exists ? entries[idx][1] === value : removed) {
        return this;
      }

      SetRef(didAlter);
      (removed || !exists) && SetRef(didChangeSize);

      if (removed && len === 2) {
        return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);
      }

      var isEditable = ownerID && ownerID === this.ownerID;
      var newEntries = isEditable ? entries : arrCopy(entries);

      if (exists) {
        if (removed) {
          idx === len - 1
            ? newEntries.pop()
            : (newEntries[idx] = newEntries.pop());
        } else {
          newEntries[idx] = [key, value];
        }
      } else {
        newEntries.push([key, value]);
      }

      if (isEditable) {
        this.entries = newEntries;
        return this;
      }

      return new HashCollisionNode(ownerID, this.keyHash, newEntries);
    };

    var ValueNode = function ValueNode(ownerID, keyHash, entry) {
      this.ownerID = ownerID;
      this.keyHash = keyHash;
      this.entry = entry;
    };

    ValueNode.prototype.get = function get(shift, keyHash, key, notSetValue) {
      return is(key, this.entry[0]) ? this.entry[1] : notSetValue;
    };

    ValueNode.prototype.update = function update(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      var removed = value === NOT_SET;
      var keyMatch = is(key, this.entry[0]);
      if (keyMatch ? value === this.entry[1] : removed) {
        return this;
      }

      SetRef(didAlter);

      if (removed) {
        SetRef(didChangeSize);
        return; // undefined
      }

      if (keyMatch) {
        if (ownerID && ownerID === this.ownerID) {
          this.entry[1] = value;
          return this;
        }
        return new ValueNode(ownerID, this.keyHash, [key, value]);
      }

      SetRef(didChangeSize);
      return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);
    };

    // #pragma Iterators

    ArrayMapNode.prototype.iterate = HashCollisionNode.prototype.iterate = function(
      fn,
      reverse
    ) {
      var entries = this.entries;
      for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {
        if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {
          return false;
        }
      }
    };

    BitmapIndexedNode.prototype.iterate = HashArrayMapNode.prototype.iterate = function(
      fn,
      reverse
    ) {
      var nodes = this.nodes;
      for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {
        var node = nodes[reverse ? maxIndex - ii : ii];
        if (node && node.iterate(fn, reverse) === false) {
          return false;
        }
      }
    };

    // eslint-disable-next-line no-unused-vars
    ValueNode.prototype.iterate = function(fn, reverse) {
      return fn(this.entry);
    };

    var MapIterator = /*@__PURE__*/ (function(Iterator$$1) {
      function MapIterator(map, type, reverse) {
        this._type = type;
        this._reverse = reverse;
        this._stack = map._root && mapIteratorFrame(map._root);
      }

      if (Iterator$$1) MapIterator.__proto__ = Iterator$$1;
      MapIterator.prototype = Object.create(
        Iterator$$1 && Iterator$$1.prototype
      );
      MapIterator.prototype.constructor = MapIterator;

      MapIterator.prototype.next = function next() {
        var type = this._type;
        var stack = this._stack;
        while (stack) {
          var node = stack.node;
          var index = stack.index++;
          var maxIndex = void 0;
          if (node.entry) {
            if (index === 0) {
              return mapIteratorValue(type, node.entry);
            }
          } else if (node.entries) {
            maxIndex = node.entries.length - 1;
            if (index <= maxIndex) {
              return mapIteratorValue(
                type,
                node.entries[this._reverse ? maxIndex - index : index]
              );
            }
          } else {
            maxIndex = node.nodes.length - 1;
            if (index <= maxIndex) {
              var subNode =
                node.nodes[this._reverse ? maxIndex - index : index];
              if (subNode) {
                if (subNode.entry) {
                  return mapIteratorValue(type, subNode.entry);
                }
                stack = this._stack = mapIteratorFrame(subNode, stack);
              }
              continue;
            }
          }
          stack = this._stack = this._stack.__prev;
        }
        return iteratorDone();
      };

      return MapIterator;
    })(Iterator);

    function mapIteratorValue(type, entry) {
      return iteratorValue(type, entry[0], entry[1]);
    }

    function mapIteratorFrame(node, prev) {
      return {
        node: node,
        index: 0,
        __prev: prev
      };
    }

    function makeMap(size, root, ownerID, hash$$1) {
      var map = Object.create(MapPrototype);
      map.size = size;
      map._root = root;
      map.__ownerID = ownerID;
      map.__hash = hash$$1;
      map.__altered = false;
      return map;
    }

    var EMPTY_MAP;
    function emptyMap() {
      return EMPTY_MAP || (EMPTY_MAP = makeMap(0));
    }

    function updateMap(map, k, v) {
      var newRoot;
      var newSize;
      if (!map._root) {
        if (v === NOT_SET) {
          return map;
        }
        newSize = 1;
        newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);
      } else {
        var didChangeSize = MakeRef();
        var didAlter = MakeRef();
        newRoot = updateNode(
          map._root,
          map.__ownerID,
          0,
          undefined,
          k,
          v,
          didChangeSize,
          didAlter
        );
        if (!didAlter.value) {
          return map;
        }
        newSize =
          map.size + (didChangeSize.value ? (v === NOT_SET ? -1 : 1) : 0);
      }
      if (map.__ownerID) {
        map.size = newSize;
        map._root = newRoot;
        map.__hash = undefined;
        map.__altered = true;
        return map;
      }
      return newRoot ? makeMap(newSize, newRoot) : emptyMap();
    }

    function updateNode(
      node,
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    ) {
      if (!node) {
        if (value === NOT_SET) {
          return node;
        }
        SetRef(didAlter);
        SetRef(didChangeSize);
        return new ValueNode(ownerID, keyHash, [key, value]);
      }
      return node.update(
        ownerID,
        shift,
        keyHash,
        key,
        value,
        didChangeSize,
        didAlter
      );
    }

    function isLeafNode(node) {
      return (
        node.constructor === ValueNode || node.constructor === HashCollisionNode
      );
    }

    function mergeIntoNode(node, ownerID, shift, keyHash, entry) {
      if (node.keyHash === keyHash) {
        return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);
      }

      var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;
      var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;

      var newNode;
      var nodes =
        idx1 === idx2
          ? [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)]
          : ((newNode = new ValueNode(ownerID, keyHash, entry)),
            idx1 < idx2 ? [node, newNode] : [newNode, node]);

      return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);
    }

    function createNodes(ownerID, entries, key, value) {
      if (!ownerID) {
        ownerID = new OwnerID();
      }
      var node = new ValueNode(ownerID, hash(key), [key, value]);
      for (var ii = 0; ii < entries.length; ii++) {
        var entry = entries[ii];
        node = node.update(ownerID, 0, undefined, entry[0], entry[1]);
      }
      return node;
    }

    function packNodes(ownerID, nodes, count, excluding) {
      var bitmap = 0;
      var packedII = 0;
      var packedNodes = new Array(count);
      for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {
        var node = nodes[ii];
        if (node !== undefined && ii !== excluding) {
          bitmap |= bit;
          packedNodes[packedII++] = node;
        }
      }
      return new BitmapIndexedNode(ownerID, bitmap, packedNodes);
    }

    function expandNodes(ownerID, nodes, bitmap, including, node) {
      var count = 0;
      var expandedNodes = new Array(SIZE);
      for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {
        expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;
      }
      expandedNodes[including] = node;
      return new HashArrayMapNode(ownerID, count + 1, expandedNodes);
    }

    function popCount(x) {
      x -= (x >> 1) & 0x55555555;
      x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
      x = (x + (x >> 4)) & 0x0f0f0f0f;
      x += x >> 8;
      x += x >> 16;
      return x & 0x7f;
    }

    function setAt(array, idx, val, canEdit) {
      var newArray = canEdit ? array : arrCopy(array);
      newArray[idx] = val;
      return newArray;
    }

    function spliceIn(array, idx, val, canEdit) {
      var newLen = array.length + 1;
      if (canEdit && idx + 1 === newLen) {
        array[idx] = val;
        return array;
      }
      var newArray = new Array(newLen);
      var after = 0;
      for (var ii = 0; ii < newLen; ii++) {
        if (ii === idx) {
          newArray[ii] = val;
          after = -1;
        } else {
          newArray[ii] = array[ii + after];
        }
      }
      return newArray;
    }

    function spliceOut(array, idx, canEdit) {
      var newLen = array.length - 1;
      if (canEdit && idx === newLen) {
        array.pop();
        return array;
      }
      var newArray = new Array(newLen);
      var after = 0;
      for (var ii = 0; ii < newLen; ii++) {
        if (ii === idx) {
          after = 1;
        }
        newArray[ii] = array[ii + after];
      }
      return newArray;
    }

    var MAX_ARRAY_MAP_SIZE = SIZE / 4;
    var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;
    var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;

    var IS_LIST_SYMBOL = "@@__IMMUTABLE_LIST__@@";

    function isList(maybeList) {
      return Boolean(maybeList && maybeList[IS_LIST_SYMBOL]);
    }

    var List = /*@__PURE__*/ (function(IndexedCollection$$1) {
      function List(value) {
        var empty = emptyList();
        if (value === null || value === undefined) {
          return empty;
        }
        if (isList(value)) {
          return value;
        }
        var iter = IndexedCollection$$1(value);
        var size = iter.size;
        if (size === 0) {
          return empty;
        }
        assertNotInfinite(size);
        if (size > 0 && size < SIZE) {
          return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));
        }
        return empty.withMutations(function(list) {
          list.setSize(size);
          iter.forEach(function(v, i) {
            return list.set(i, v);
          });
        });
      }

      if (IndexedCollection$$1) List.__proto__ = IndexedCollection$$1;
      List.prototype = Object.create(
        IndexedCollection$$1 && IndexedCollection$$1.prototype
      );
      List.prototype.constructor = List;

      List.of = function of(/*...values*/) {
        return this(arguments);
      };

      List.prototype.toString = function toString() {
        return this.__toString("List [", "]");
      };

      // @pragma Access

      List.prototype.get = function get(index, notSetValue) {
        index = wrapIndex(this, index);
        if (index >= 0 && index < this.size) {
          index += this._origin;
          var node = listNodeFor(this, index);
          return node && node.array[index & MASK];
        }
        return notSetValue;
      };

      // @pragma Modification

      List.prototype.set = function set(index, value) {
        return updateList(this, index, value);
      };

      List.prototype.remove = function remove(index) {
        return !this.has(index)
          ? this
          : index === 0
          ? this.shift()
          : index === this.size - 1
          ? this.pop()
          : this.splice(index, 1);
      };

      List.prototype.insert = function insert(index, value) {
        return this.splice(index, 0, value);
      };

      List.prototype.clear = function clear() {
        if (this.size === 0) {
          return this;
        }
        if (this.__ownerID) {
          this.size = this._origin = this._capacity = 0;
          this._level = SHIFT;
          this._root = this._tail = null;
          this.__hash = undefined;
          this.__altered = true;
          return this;
        }
        return emptyList();
      };

      List.prototype.push = function push(/*...values*/) {
        var values = arguments;
        var oldSize = this.size;
        return this.withMutations(function(list) {
          setListBounds(list, 0, oldSize + values.length);
          for (var ii = 0; ii < values.length; ii++) {
            list.set(oldSize + ii, values[ii]);
          }
        });
      };

      List.prototype.pop = function pop() {
        return setListBounds(this, 0, -1);
      };

      List.prototype.unshift = function unshift(/*...values*/) {
        var values = arguments;
        return this.withMutations(function(list) {
          setListBounds(list, -values.length);
          for (var ii = 0; ii < values.length; ii++) {
            list.set(ii, values[ii]);
          }
        });
      };

      List.prototype.shift = function shift() {
        return setListBounds(this, 1);
      };

      // @pragma Composition

      List.prototype.concat = function concat(/*...collections*/) {
        var arguments$1 = arguments;

        var seqs = [];
        for (var i = 0; i < arguments.length; i++) {
          var argument = arguments$1[i];
          var seq = IndexedCollection$$1(
            typeof argument !== "string" && hasIterator(argument)
              ? argument
              : [argument]
          );
          if (seq.size !== 0) {
            seqs.push(seq);
          }
        }
        if (seqs.length === 0) {
          return this;
        }
        if (this.size === 0 && !this.__ownerID && seqs.length === 1) {
          return this.constructor(seqs[0]);
        }
        return this.withMutations(function(list) {
          seqs.forEach(function(seq) {
            return seq.forEach(function(value) {
              return list.push(value);
            });
          });
        });
      };

      List.prototype.setSize = function setSize(size) {
        return setListBounds(this, 0, size);
      };

      List.prototype.map = function map(mapper, context) {
        var this$1 = this;

        return this.withMutations(function(list) {
          for (var i = 0; i < this$1.size; i++) {
            list.set(i, mapper.call(context, list.get(i), i, list));
          }
        });
      };

      // @pragma Iteration

      List.prototype.slice = function slice(begin, end) {
        var size = this.size;
        if (wholeSlice(begin, end, size)) {
          return this;
        }
        return setListBounds(
          this,
          resolveBegin(begin, size),
          resolveEnd(end, size)
        );
      };

      List.prototype.__iterator = function __iterator(type, reverse) {
        var index = reverse ? this.size : 0;
        var values = iterateList(this, reverse);
        return new Iterator(function() {
          var value = values();
          return value === DONE
            ? iteratorDone()
            : iteratorValue(type, reverse ? --index : index++, value);
        });
      };

      List.prototype.__iterate = function __iterate(fn, reverse) {
        var index = reverse ? this.size : 0;
        var values = iterateList(this, reverse);
        var value;
        while ((value = values()) !== DONE) {
          if (fn(value, reverse ? --index : index++, this) === false) {
            break;
          }
        }
        return index;
      };

      List.prototype.__ensureOwner = function __ensureOwner(ownerID) {
        if (ownerID === this.__ownerID) {
          return this;
        }
        if (!ownerID) {
          if (this.size === 0) {
            return emptyList();
          }
          this.__ownerID = ownerID;
          this.__altered = false;
          return this;
        }
        return makeList(
          this._origin,
          this._capacity,
          this._level,
          this._root,
          this._tail,
          ownerID,
          this.__hash
        );
      };

      return List;
    })(IndexedCollection);

    List.isList = isList;

    var ListPrototype = List.prototype;
    ListPrototype[IS_LIST_SYMBOL] = true;
    ListPrototype[DELETE] = ListPrototype.remove;
    ListPrototype.merge = ListPrototype.concat;
    ListPrototype.setIn = setIn$1;
    ListPrototype.deleteIn = ListPrototype.removeIn = deleteIn;
    ListPrototype.update = update$1;
    ListPrototype.updateIn = updateIn$1;
    ListPrototype.mergeIn = mergeIn;
    ListPrototype.mergeDeepIn = mergeDeepIn;
    ListPrototype.withMutations = withMutations;
    ListPrototype.wasAltered = wasAltered;
    ListPrototype.asImmutable = asImmutable;
    ListPrototype["@@transducer/init"] = ListPrototype.asMutable = asMutable;
    ListPrototype["@@transducer/step"] = function(result, arr) {
      return result.push(arr);
    };
    ListPrototype["@@transducer/result"] = function(obj) {
      return obj.asImmutable();
    };

    var VNode = function VNode(array, ownerID) {
      this.array = array;
      this.ownerID = ownerID;
    };

    // TODO: seems like these methods are very similar

    VNode.prototype.removeBefore = function removeBefore(
      ownerID,
      level,
      index
    ) {
      if (index === level ? 1 << level : this.array.length === 0) {
        return this;
      }
      var originIndex = (index >>> level) & MASK;
      if (originIndex >= this.array.length) {
        return new VNode([], ownerID);
      }
      var removingFirst = originIndex === 0;
      var newChild;
      if (level > 0) {
        var oldChild = this.array[originIndex];
        newChild =
          oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);
        if (newChild === oldChild && removingFirst) {
          return this;
        }
      }
      if (removingFirst && !newChild) {
        return this;
      }
      var editable = editableVNode(this, ownerID);
      if (!removingFirst) {
        for (var ii = 0; ii < originIndex; ii++) {
          editable.array[ii] = undefined;
        }
      }
      if (newChild) {
        editable.array[originIndex] = newChild;
      }
      return editable;
    };

    VNode.prototype.removeAfter = function removeAfter(ownerID, level, index) {
      if (index === (level ? 1 << level : 0) || this.array.length === 0) {
        return this;
      }
      var sizeIndex = ((index - 1) >>> level) & MASK;
      if (sizeIndex >= this.array.length) {
        return this;
      }

      var newChild;
      if (level > 0) {
        var oldChild = this.array[sizeIndex];
        newChild =
          oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);
        if (newChild === oldChild && sizeIndex === this.array.length - 1) {
          return this;
        }
      }

      var editable = editableVNode(this, ownerID);
      editable.array.splice(sizeIndex + 1);
      if (newChild) {
        editable.array[sizeIndex] = newChild;
      }
      return editable;
    };

    var DONE = {};

    function iterateList(list, reverse) {
      var left = list._origin;
      var right = list._capacity;
      var tailPos = getTailOffset(right);
      var tail = list._tail;

      return iterateNodeOrLeaf(list._root, list._level, 0);

      function iterateNodeOrLeaf(node, level, offset) {
        return level === 0
          ? iterateLeaf(node, offset)
          : iterateNode(node, level, offset);
      }

      function iterateLeaf(node, offset) {
        var array =
          offset === tailPos ? tail && tail.array : node && node.array;
        var from = offset > left ? 0 : left - offset;
        var to = right - offset;
        if (to > SIZE) {
          to = SIZE;
        }
        return function() {
          if (from === to) {
            return DONE;
          }
          var idx = reverse ? --to : from++;
          return array && array[idx];
        };
      }

      function iterateNode(node, level, offset) {
        var values;
        var array = node && node.array;
        var from = offset > left ? 0 : (left - offset) >> level;
        var to = ((right - offset) >> level) + 1;
        if (to > SIZE) {
          to = SIZE;
        }
        return function() {
          while (true) {
            if (values) {
              var value = values();
              if (value !== DONE) {
                return value;
              }
              values = null;
            }
            if (from === to) {
              return DONE;
            }
            var idx = reverse ? --to : from++;
            values = iterateNodeOrLeaf(
              array && array[idx],
              level - SHIFT,
              offset + (idx << level)
            );
          }
        };
      }
    }

    function makeList(origin, capacity, level, root, tail, ownerID, hash) {
      var list = Object.create(ListPrototype);
      list.size = capacity - origin;
      list._origin = origin;
      list._capacity = capacity;
      list._level = level;
      list._root = root;
      list._tail = tail;
      list.__ownerID = ownerID;
      list.__hash = hash;
      list.__altered = false;
      return list;
    }

    var EMPTY_LIST;
    function emptyList() {
      return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));
    }

    function updateList(list, index, value) {
      index = wrapIndex(list, index);

      if (index !== index) {
        return list;
      }

      if (index >= list.size || index < 0) {
        return list.withMutations(function(list) {
          index < 0
            ? setListBounds(list, index).set(0, value)
            : setListBounds(list, 0, index + 1).set(index, value);
        });
      }

      index += list._origin;

      var newTail = list._tail;
      var newRoot = list._root;
      var didAlter = MakeRef();
      if (index >= getTailOffset(list._capacity)) {
        newTail = updateVNode(
          newTail,
          list.__ownerID,
          0,
          index,
          value,
          didAlter
        );
      } else {
        newRoot = updateVNode(
          newRoot,
          list.__ownerID,
          list._level,
          index,
          value,
          didAlter
        );
      }

      if (!didAlter.value) {
        return list;
      }

      if (list.__ownerID) {
        list._root = newRoot;
        list._tail = newTail;
        list.__hash = undefined;
        list.__altered = true;
        return list;
      }
      return makeList(
        list._origin,
        list._capacity,
        list._level,
        newRoot,
        newTail
      );
    }

    function updateVNode(node, ownerID, level, index, value, didAlter) {
      var idx = (index >>> level) & MASK;
      var nodeHas = node && idx < node.array.length;
      if (!nodeHas && value === undefined) {
        return node;
      }

      var newNode;

      if (level > 0) {
        var lowerNode = node && node.array[idx];
        var newLowerNode = updateVNode(
          lowerNode,
          ownerID,
          level - SHIFT,
          index,
          value,
          didAlter
        );
        if (newLowerNode === lowerNode) {
          return node;
        }
        newNode = editableVNode(node, ownerID);
        newNode.array[idx] = newLowerNode;
        return newNode;
      }

      if (nodeHas && node.array[idx] === value) {
        return node;
      }

      if (didAlter) {
        SetRef(didAlter);
      }

      newNode = editableVNode(node, ownerID);
      if (value === undefined && idx === newNode.array.length - 1) {
        newNode.array.pop();
      } else {
        newNode.array[idx] = value;
      }
      return newNode;
    }

    function editableVNode(node, ownerID) {
      if (ownerID && node && ownerID === node.ownerID) {
        return node;
      }
      return new VNode(node ? node.array.slice() : [], ownerID);
    }

    function listNodeFor(list, rawIndex) {
      if (rawIndex >= getTailOffset(list._capacity)) {
        return list._tail;
      }
      if (rawIndex < 1 << (list._level + SHIFT)) {
        var node = list._root;
        var level = list._level;
        while (node && level > 0) {
          node = node.array[(rawIndex >>> level) & MASK];
          level -= SHIFT;
        }
        return node;
      }
    }

    function setListBounds(list, begin, end) {
      // Sanitize begin & end using this shorthand for ToInt32(argument)
      // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
      if (begin !== undefined) {
        begin |= 0;
      }
      if (end !== undefined) {
        end |= 0;
      }
      var owner = list.__ownerID || new OwnerID();
      var oldOrigin = list._origin;
      var oldCapacity = list._capacity;
      var newOrigin = oldOrigin + begin;
      var newCapacity =
        end === undefined
          ? oldCapacity
          : end < 0
          ? oldCapacity + end
          : oldOrigin + end;
      if (newOrigin === oldOrigin && newCapacity === oldCapacity) {
        return list;
      }

      // If it's going to end after it starts, it's empty.
      if (newOrigin >= newCapacity) {
        return list.clear();
      }

      var newLevel = list._level;
      var newRoot = list._root;

      // New origin might need creating a higher root.
      var offsetShift = 0;
      while (newOrigin + offsetShift < 0) {
        newRoot = new VNode(
          newRoot && newRoot.array.length ? [undefined, newRoot] : [],
          owner
        );
        newLevel += SHIFT;
        offsetShift += 1 << newLevel;
      }
      if (offsetShift) {
        newOrigin += offsetShift;
        oldOrigin += offsetShift;
        newCapacity += offsetShift;
        oldCapacity += offsetShift;
      }

      var oldTailOffset = getTailOffset(oldCapacity);
      var newTailOffset = getTailOffset(newCapacity);

      // New size might need creating a higher root.
      while (newTailOffset >= 1 << (newLevel + SHIFT)) {
        newRoot = new VNode(
          newRoot && newRoot.array.length ? [newRoot] : [],
          owner
        );
        newLevel += SHIFT;
      }

      // Locate or create the new tail.
      var oldTail = list._tail;
      var newTail =
        newTailOffset < oldTailOffset
          ? listNodeFor(list, newCapacity - 1)
          : newTailOffset > oldTailOffset
          ? new VNode([], owner)
          : oldTail;

      // Merge Tail into tree.
      if (
        oldTail &&
        newTailOffset > oldTailOffset &&
        newOrigin < oldCapacity &&
        oldTail.array.length
      ) {
        newRoot = editableVNode(newRoot, owner);
        var node = newRoot;
        for (var level = newLevel; level > SHIFT; level -= SHIFT) {
          var idx = (oldTailOffset >>> level) & MASK;
          node = node.array[idx] = editableVNode(node.array[idx], owner);
        }
        node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;
      }

      // If the size has been reduced, there's a chance the tail needs to be trimmed.
      if (newCapacity < oldCapacity) {
        newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);
      }

      // If the new origin is within the tail, then we do not need a root.
      if (newOrigin >= newTailOffset) {
        newOrigin -= newTailOffset;
        newCapacity -= newTailOffset;
        newLevel = SHIFT;
        newRoot = null;
        newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);

        // Otherwise, if the root has been trimmed, garbage collect.
      } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {
        offsetShift = 0;

        // Identify the new top root node of the subtree of the old root.
        while (newRoot) {
          var beginIndex = (newOrigin >>> newLevel) & MASK;
          if ((beginIndex !== newTailOffset >>> newLevel) & MASK) {
            break;
          }
          if (beginIndex) {
            offsetShift += (1 << newLevel) * beginIndex;
          }
          newLevel -= SHIFT;
          newRoot = newRoot.array[beginIndex];
        }

        // Trim the new sides of the new root.
        if (newRoot && newOrigin > oldOrigin) {
          newRoot = newRoot.removeBefore(
            owner,
            newLevel,
            newOrigin - offsetShift
          );
        }
        if (newRoot && newTailOffset < oldTailOffset) {
          newRoot = newRoot.removeAfter(
            owner,
            newLevel,
            newTailOffset - offsetShift
          );
        }
        if (offsetShift) {
          newOrigin -= offsetShift;
          newCapacity -= offsetShift;
        }
      }

      if (list.__ownerID) {
        list.size = newCapacity - newOrigin;
        list._origin = newOrigin;
        list._capacity = newCapacity;
        list._level = newLevel;
        list._root = newRoot;
        list._tail = newTail;
        list.__hash = undefined;
        list.__altered = true;
        return list;
      }
      return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);
    }

    function getTailOffset(size) {
      return size < SIZE ? 0 : ((size - 1) >>> SHIFT) << SHIFT;
    }

    var OrderedMap = /*@__PURE__*/ (function(Map$$1) {
      function OrderedMap(value) {
        return value === null || value === undefined
          ? emptyOrderedMap()
          : isOrderedMap(value)
          ? value
          : emptyOrderedMap().withMutations(function(map) {
              var iter = KeyedCollection(value);
              assertNotInfinite(iter.size);
              iter.forEach(function(v, k) {
                return map.set(k, v);
              });
            });
      }

      if (Map$$1) OrderedMap.__proto__ = Map$$1;
      OrderedMap.prototype = Object.create(Map$$1 && Map$$1.prototype);
      OrderedMap.prototype.constructor = OrderedMap;

      OrderedMap.of = function of(/*...values*/) {
        return this(arguments);
      };

      OrderedMap.prototype.toString = function toString() {
        return this.__toString("OrderedMap {", "}");
      };

      // @pragma Access

      OrderedMap.prototype.get = function get(k, notSetValue) {
        var index = this._map.get(k);
        return index !== undefined ? this._list.get(index)[1] : notSetValue;
      };

      // @pragma Modification

      OrderedMap.prototype.clear = function clear() {
        if (this.size === 0) {
          return this;
        }
        if (this.__ownerID) {
          this.size = 0;
          this._map.clear();
          this._list.clear();
          return this;
        }
        return emptyOrderedMap();
      };

      OrderedMap.prototype.set = function set(k, v) {
        return updateOrderedMap(this, k, v);
      };

      OrderedMap.prototype.remove = function remove(k) {
        return updateOrderedMap(this, k, NOT_SET);
      };

      OrderedMap.prototype.wasAltered = function wasAltered() {
        return this._map.wasAltered() || this._list.wasAltered();
      };

      OrderedMap.prototype.__iterate = function __iterate(fn, reverse) {
        var this$1 = this;

        return this._list.__iterate(function(entry) {
          return entry && fn(entry[1], entry[0], this$1);
        }, reverse);
      };

      OrderedMap.prototype.__iterator = function __iterator(type, reverse) {
        return this._list.fromEntrySeq().__iterator(type, reverse);
      };

      OrderedMap.prototype.__ensureOwner = function __ensureOwner(ownerID) {
        if (ownerID === this.__ownerID) {
          return this;
        }
        var newMap = this._map.__ensureOwner(ownerID);
        var newList = this._list.__ensureOwner(ownerID);
        if (!ownerID) {
          if (this.size === 0) {
            return emptyOrderedMap();
          }
          this.__ownerID = ownerID;
          this._map = newMap;
          this._list = newList;
          return this;
        }
        return makeOrderedMap(newMap, newList, ownerID, this.__hash);
      };

      return OrderedMap;
    })(Map);

    OrderedMap.isOrderedMap = isOrderedMap;

    OrderedMap.prototype[IS_ORDERED_SYMBOL] = true;
    OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;

    function makeOrderedMap(map, list, ownerID, hash) {
      var omap = Object.create(OrderedMap.prototype);
      omap.size = map ? map.size : 0;
      omap._map = map;
      omap._list = list;
      omap.__ownerID = ownerID;
      omap.__hash = hash;
      return omap;
    }

    var EMPTY_ORDERED_MAP;
    function emptyOrderedMap() {
      return (
        EMPTY_ORDERED_MAP ||
        (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()))
      );
    }

    function updateOrderedMap(omap, k, v) {
      var map = omap._map;
      var list = omap._list;
      var i = map.get(k);
      var has = i !== undefined;
      var newMap;
      var newList;
      if (v === NOT_SET) {
        // removed
        if (!has) {
          return omap;
        }
        if (list.size >= SIZE && list.size >= map.size * 2) {
          newList = list.filter(function(entry, idx) {
            return entry !== undefined && i !== idx;
          });
          newMap = newList
            .toKeyedSeq()
            .map(function(entry) {
              return entry[0];
            })
            .flip()
            .toMap();
          if (omap.__ownerID) {
            newMap.__ownerID = newList.__ownerID = omap.__ownerID;
          }
        } else {
          newMap = map.remove(k);
          newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);
        }
      } else if (has) {
        if (v === list.get(i)[1]) {
          return omap;
        }
        newMap = map;
        newList = list.set(i, [k, v]);
      } else {
        newMap = map.set(k, list.size);
        newList = list.set(list.size, [k, v]);
      }
      if (omap.__ownerID) {
        omap.size = newMap.size;
        omap._map = newMap;
        omap._list = newList;
        omap.__hash = undefined;
        return omap;
      }
      return makeOrderedMap(newMap, newList);
    }

    var IS_STACK_SYMBOL = "@@__IMMUTABLE_STACK__@@";

    function isStack(maybeStack) {
      return Boolean(maybeStack && maybeStack[IS_STACK_SYMBOL]);
    }

    var Stack = /*@__PURE__*/ (function(IndexedCollection$$1) {
      function Stack(value) {
        return value === null || value === undefined
          ? emptyStack()
          : isStack(value)
          ? value
          : emptyStack().pushAll(value);
      }

      if (IndexedCollection$$1) Stack.__proto__ = IndexedCollection$$1;
      Stack.prototype = Object.create(
        IndexedCollection$$1 && IndexedCollection$$1.prototype
      );
      Stack.prototype.constructor = Stack;

      Stack.of = function of(/*...values*/) {
        return this(arguments);
      };

      Stack.prototype.toString = function toString() {
        return this.__toString("Stack [", "]");
      };

      // @pragma Access

      Stack.prototype.get = function get(index, notSetValue) {
        var head = this._head;
        index = wrapIndex(this, index);
        while (head && index--) {
          head = head.next;
        }
        return head ? head.value : notSetValue;
      };

      Stack.prototype.peek = function peek() {
        return this._head && this._head.value;
      };

      // @pragma Modification

      Stack.prototype.push = function push(/*...values*/) {
        var arguments$1 = arguments;

        if (arguments.length === 0) {
          return this;
        }
        var newSize = this.size + arguments.length;
        var head = this._head;
        for (var ii = arguments.length - 1; ii >= 0; ii--) {
          head = {
            value: arguments$1[ii],
            next: head
          };
        }
        if (this.__ownerID) {
          this.size = newSize;
          this._head = head;
          this.__hash = undefined;
          this.__altered = true;
          return this;
        }
        return makeStack(newSize, head);
      };

      Stack.prototype.pushAll = function pushAll(iter) {
        iter = IndexedCollection$$1(iter);
        if (iter.size === 0) {
          return this;
        }
        if (this.size === 0 && isStack(iter)) {
          return iter;
        }
        assertNotInfinite(iter.size);
        var newSize = this.size;
        var head = this._head;
        iter.__iterate(function(value) {
          newSize++;
          head = {
            value: value,
            next: head
          };
        }, /* reverse */ true);
        if (this.__ownerID) {
          this.size = newSize;
          this._head = head;
          this.__hash = undefined;
          this.__altered = true;
          return this;
        }
        return makeStack(newSize, head);
      };

      Stack.prototype.pop = function pop() {
        return this.slice(1);
      };

      Stack.prototype.clear = function clear() {
        if (this.size === 0) {
          return this;
        }
        if (this.__ownerID) {
          this.size = 0;
          this._head = undefined;
          this.__hash = undefined;
          this.__altered = true;
          return this;
        }
        return emptyStack();
      };

      Stack.prototype.slice = function slice(begin, end) {
        if (wholeSlice(begin, end, this.size)) {
          return this;
        }
        var resolvedBegin = resolveBegin(begin, this.size);
        var resolvedEnd = resolveEnd(end, this.size);
        if (resolvedEnd !== this.size) {
          // super.slice(begin, end);
          return IndexedCollection$$1.prototype.slice.call(this, begin, end);
        }
        var newSize = this.size - resolvedBegin;
        var head = this._head;
        while (resolvedBegin--) {
          head = head.next;
        }
        if (this.__ownerID) {
          this.size = newSize;
          this._head = head;
          this.__hash = undefined;
          this.__altered = true;
          return this;
        }
        return makeStack(newSize, head);
      };

      // @pragma Mutability

      Stack.prototype.__ensureOwner = function __ensureOwner(ownerID) {
        if (ownerID === this.__ownerID) {
          return this;
        }
        if (!ownerID) {
          if (this.size === 0) {
            return emptyStack();
          }
          this.__ownerID = ownerID;
          this.__altered = false;
          return this;
        }
        return makeStack(this.size, this._head, ownerID, this.__hash);
      };

      // @pragma Iteration

      Stack.prototype.__iterate = function __iterate(fn, reverse) {
        var this$1 = this;

        if (reverse) {
          return new ArraySeq(this.toArray()).__iterate(function(v, k) {
            return fn(v, k, this$1);
          }, reverse);
        }
        var iterations = 0;
        var node = this._head;
        while (node) {
          if (fn(node.value, iterations++, this) === false) {
            break;
          }
          node = node.next;
        }
        return iterations;
      };

      Stack.prototype.__iterator = function __iterator(type, reverse) {
        if (reverse) {
          return new ArraySeq(this.toArray()).__iterator(type, reverse);
        }
        var iterations = 0;
        var node = this._head;
        return new Iterator(function() {
          if (node) {
            var value = node.value;
            node = node.next;
            return iteratorValue(type, iterations++, value);
          }
          return iteratorDone();
        });
      };

      return Stack;
    })(IndexedCollection);

    Stack.isStack = isStack;

    var StackPrototype = Stack.prototype;
    StackPrototype[IS_STACK_SYMBOL] = true;
    StackPrototype.shift = StackPrototype.pop;
    StackPrototype.unshift = StackPrototype.push;
    StackPrototype.unshiftAll = StackPrototype.pushAll;
    StackPrototype.withMutations = withMutations;
    StackPrototype.wasAltered = wasAltered;
    StackPrototype.asImmutable = asImmutable;
    StackPrototype["@@transducer/init"] = StackPrototype.asMutable = asMutable;
    StackPrototype["@@transducer/step"] = function(result, arr) {
      return result.unshift(arr);
    };
    StackPrototype["@@transducer/result"] = function(obj) {
      return obj.asImmutable();
    };

    function makeStack(size, head, ownerID, hash) {
      var map = Object.create(StackPrototype);
      map.size = size;
      map._head = head;
      map.__ownerID = ownerID;
      map.__hash = hash;
      map.__altered = false;
      return map;
    }

    var EMPTY_STACK;
    function emptyStack() {
      return EMPTY_STACK || (EMPTY_STACK = makeStack(0));
    }

    var IS_SET_SYMBOL = "@@__IMMUTABLE_SET__@@";

    function isSet(maybeSet) {
      return Boolean(maybeSet && maybeSet[IS_SET_SYMBOL]);
    }

    function isOrderedSet(maybeOrderedSet) {
      return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);
    }

    function deepEqual(a, b) {
      if (a === b) {
        return true;
      }

      if (
        !isCollection(b) ||
        (a.size !== undefined && b.size !== undefined && a.size !== b.size) ||
        (a.__hash !== undefined &&
          b.__hash !== undefined &&
          a.__hash !== b.__hash) ||
        isKeyed(a) !== isKeyed(b) ||
        isIndexed(a) !== isIndexed(b) ||
        isOrdered(a) !== isOrdered(b)
      ) {
        return false;
      }

      if (a.size === 0 && b.size === 0) {
        return true;
      }

      var notAssociative = !isAssociative(a);

      if (isOrdered(a)) {
        var entries = a.entries();
        return (
          b.every(function(v, k) {
            var entry = entries.next().value;
            return (
              entry && is(entry[1], v) && (notAssociative || is(entry[0], k))
            );
          }) && entries.next().done
        );
      }

      var flipped = false;

      if (a.size === undefined) {
        if (b.size === undefined) {
          if (typeof a.cacheResult === "function") {
            a.cacheResult();
          }
        } else {
          flipped = true;
          var _ = a;
          a = b;
          b = _;
        }
      }

      var allEqual = true;
      var bSize = b.__iterate(function(v, k) {
        if (
          notAssociative
            ? !a.has(v)
            : flipped
            ? !is(v, a.get(k, NOT_SET))
            : !is(a.get(k, NOT_SET), v)
        ) {
          allEqual = false;
          return false;
        }
      });

      return allEqual && a.size === bSize;
    }

    /**
     * Contributes additional methods to a constructor
     */
    function mixin(ctor, methods) {
      var keyCopier = function(key) {
        ctor.prototype[key] = methods[key];
      };
      Object.keys(methods).forEach(keyCopier);
      Object.getOwnPropertySymbols &&
        Object.getOwnPropertySymbols(methods).forEach(keyCopier);
      return ctor;
    }

    function toJS(value) {
      if (!value || typeof value !== "object") {
        return value;
      }
      if (!isCollection(value)) {
        if (!isDataStructure(value)) {
          return value;
        }
        value = Seq(value);
      }
      if (isKeyed(value)) {
        var result$1 = {};
        value.__iterate(function(v, k) {
          result$1[k] = toJS(v);
        });
        return result$1;
      }
      var result = [];
      value.__iterate(function(v) {
        result.push(toJS(v));
      });
      return result;
    }

    var Set = /*@__PURE__*/ (function(SetCollection$$1) {
      function Set(value) {
        return value === null || value === undefined
          ? emptySet()
          : isSet(value) && !isOrdered(value)
          ? value
          : emptySet().withMutations(function(set) {
              var iter = SetCollection$$1(value);
              assertNotInfinite(iter.size);
              iter.forEach(function(v) {
                return set.add(v);
              });
            });
      }

      if (SetCollection$$1) Set.__proto__ = SetCollection$$1;
      Set.prototype = Object.create(
        SetCollection$$1 && SetCollection$$1.prototype
      );
      Set.prototype.constructor = Set;

      Set.of = function of(/*...values*/) {
        return this(arguments);
      };

      Set.fromKeys = function fromKeys(value) {
        return this(KeyedCollection(value).keySeq());
      };

      Set.intersect = function intersect(sets) {
        sets = Collection(sets).toArray();
        return sets.length
          ? SetPrototype.intersect.apply(Set(sets.pop()), sets)
          : emptySet();
      };

      Set.union = function union(sets) {
        sets = Collection(sets).toArray();
        return sets.length
          ? SetPrototype.union.apply(Set(sets.pop()), sets)
          : emptySet();
      };

      Set.prototype.toString = function toString() {
        return this.__toString("Set {", "}");
      };

      // @pragma Access

      Set.prototype.has = function has(value) {
        return this._map.has(value);
      };

      // @pragma Modification

      Set.prototype.add = function add(value) {
        return updateSet(this, this._map.set(value, value));
      };

      Set.prototype.remove = function remove(value) {
        return updateSet(this, this._map.remove(value));
      };

      Set.prototype.clear = function clear() {
        return updateSet(this, this._map.clear());
      };

      // @pragma Composition

      Set.prototype.map = function map(mapper, context) {
        var this$1 = this;

        var removes = [];
        var adds = [];
        this.forEach(function(value) {
          var mapped = mapper.call(context, value, value, this$1);
          if (mapped !== value) {
            removes.push(value);
            adds.push(mapped);
          }
        });
        return this.withMutations(function(set) {
          removes.forEach(function(value) {
            return set.remove(value);
          });
          adds.forEach(function(value) {
            return set.add(value);
          });
        });
      };

      Set.prototype.union = function union() {
        var iters = [],
          len = arguments.length;
        while (len--) iters[len] = arguments[len];

        iters = iters.filter(function(x) {
          return x.size !== 0;
        });
        if (iters.length === 0) {
          return this;
        }
        if (this.size === 0 && !this.__ownerID && iters.length === 1) {
          return this.constructor(iters[0]);
        }
        return this.withMutations(function(set) {
          for (var ii = 0; ii < iters.length; ii++) {
            SetCollection$$1(iters[ii]).forEach(function(value) {
              return set.add(value);
            });
          }
        });
      };

      Set.prototype.intersect = function intersect() {
        var iters = [],
          len = arguments.length;
        while (len--) iters[len] = arguments[len];

        if (iters.length === 0) {
          return this;
        }
        iters = iters.map(function(iter) {
          return SetCollection$$1(iter);
        });
        var toRemove = [];
        this.forEach(function(value) {
          if (
            !iters.every(function(iter) {
              return iter.includes(value);
            })
          ) {
            toRemove.push(value);
          }
        });
        return this.withMutations(function(set) {
          toRemove.forEach(function(value) {
            set.remove(value);
          });
        });
      };

      Set.prototype.subtract = function subtract() {
        var iters = [],
          len = arguments.length;
        while (len--) iters[len] = arguments[len];

        if (iters.length === 0) {
          return this;
        }
        iters = iters.map(function(iter) {
          return SetCollection$$1(iter);
        });
        var toRemove = [];
        this.forEach(function(value) {
          if (
            iters.some(function(iter) {
              return iter.includes(value);
            })
          ) {
            toRemove.push(value);
          }
        });
        return this.withMutations(function(set) {
          toRemove.forEach(function(value) {
            set.remove(value);
          });
        });
      };

      Set.prototype.sort = function sort(comparator) {
        // Late binding
        return OrderedSet(sortFactory(this, comparator));
      };

      Set.prototype.sortBy = function sortBy(mapper, comparator) {
        // Late binding
        return OrderedSet(sortFactory(this, comparator, mapper));
      };

      Set.prototype.wasAltered = function wasAltered() {
        return this._map.wasAltered();
      };

      Set.prototype.__iterate = function __iterate(fn, reverse) {
        var this$1 = this;

        return this._map.__iterate(function(k) {
          return fn(k, k, this$1);
        }, reverse);
      };

      Set.prototype.__iterator = function __iterator(type, reverse) {
        return this._map.__iterator(type, reverse);
      };

      Set.prototype.__ensureOwner = function __ensureOwner(ownerID) {
        if (ownerID === this.__ownerID) {
          return this;
        }
        var newMap = this._map.__ensureOwner(ownerID);
        if (!ownerID) {
          if (this.size === 0) {
            return this.__empty();
          }
          this.__ownerID = ownerID;
          this._map = newMap;
          return this;
        }
        return this.__make(newMap, ownerID);
      };

      return Set;
    })(SetCollection);

    Set.isSet = isSet;

    var SetPrototype = Set.prototype;
    SetPrototype[IS_SET_SYMBOL] = true;
    SetPrototype[DELETE] = SetPrototype.remove;
    SetPrototype.merge = SetPrototype.concat = SetPrototype.union;
    SetPrototype.withMutations = withMutations;
    SetPrototype.asImmutable = asImmutable;
    SetPrototype["@@transducer/init"] = SetPrototype.asMutable = asMutable;
    SetPrototype["@@transducer/step"] = function(result, arr) {
      return result.add(arr);
    };
    SetPrototype["@@transducer/result"] = function(obj) {
      return obj.asImmutable();
    };

    SetPrototype.__empty = emptySet;
    SetPrototype.__make = makeSet;

    function updateSet(set, newMap) {
      if (set.__ownerID) {
        set.size = newMap.size;
        set._map = newMap;
        return set;
      }
      return newMap === set._map
        ? set
        : newMap.size === 0
        ? set.__empty()
        : set.__make(newMap);
    }

    function makeSet(map, ownerID) {
      var set = Object.create(SetPrototype);
      set.size = map ? map.size : 0;
      set._map = map;
      set.__ownerID = ownerID;
      return set;
    }

    var EMPTY_SET;
    function emptySet() {
      return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));
    }

    /**
     * Returns a lazy seq of nums from start (inclusive) to end
     * (exclusive), by step, where start defaults to 0, step to 1, and end to
     * infinity. When start is equal to end, returns empty list.
     */
    var Range = /*@__PURE__*/ (function(IndexedSeq$$1) {
      function Range(start, end, step) {
        if (!(this instanceof Range)) {
          return new Range(start, end, step);
        }
        invariant(step !== 0, "Cannot step a Range by 0");
        start = start || 0;
        if (end === undefined) {
          end = Infinity;
        }
        step = step === undefined ? 1 : Math.abs(step);
        if (end < start) {
          step = -step;
        }
        this._start = start;
        this._end = end;
        this._step = step;
        this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);
        if (this.size === 0) {
          if (EMPTY_RANGE) {
            return EMPTY_RANGE;
          }
          EMPTY_RANGE = this;
        }
      }

      if (IndexedSeq$$1) Range.__proto__ = IndexedSeq$$1;
      Range.prototype = Object.create(IndexedSeq$$1 && IndexedSeq$$1.prototype);
      Range.prototype.constructor = Range;

      Range.prototype.toString = function toString() {
        if (this.size === 0) {
          return "Range []";
        }
        return (
          "Range [ " +
          this._start +
          "..." +
          this._end +
          (this._step !== 1 ? " by " + this._step : "") +
          " ]"
        );
      };

      Range.prototype.get = function get(index, notSetValue) {
        return this.has(index)
          ? this._start + wrapIndex(this, index) * this._step
          : notSetValue;
      };

      Range.prototype.includes = function includes(searchValue) {
        var possibleIndex = (searchValue - this._start) / this._step;
        return (
          possibleIndex >= 0 &&
          possibleIndex < this.size &&
          possibleIndex === Math.floor(possibleIndex)
        );
      };

      Range.prototype.slice = function slice(begin, end) {
        if (wholeSlice(begin, end, this.size)) {
          return this;
        }
        begin = resolveBegin(begin, this.size);
        end = resolveEnd(end, this.size);
        if (end <= begin) {
          return new Range(0, 0);
        }
        return new Range(
          this.get(begin, this._end),
          this.get(end, this._end),
          this._step
        );
      };

      Range.prototype.indexOf = function indexOf(searchValue) {
        var offsetValue = searchValue - this._start;
        if (offsetValue % this._step === 0) {
          var index = offsetValue / this._step;
          if (index >= 0 && index < this.size) {
            return index;
          }
        }
        return -1;
      };

      Range.prototype.lastIndexOf = function lastIndexOf(searchValue) {
        return this.indexOf(searchValue);
      };

      Range.prototype.__iterate = function __iterate(fn, reverse) {
        var size = this.size;
        var step = this._step;
        var value = reverse ? this._start + (size - 1) * step : this._start;
        var i = 0;
        while (i !== size) {
          if (fn(value, reverse ? size - ++i : i++, this) === false) {
            break;
          }
          value += reverse ? -step : step;
        }
        return i;
      };

      Range.prototype.__iterator = function __iterator(type, reverse) {
        var size = this.size;
        var step = this._step;
        var value = reverse ? this._start + (size - 1) * step : this._start;
        var i = 0;
        return new Iterator(function() {
          if (i === size) {
            return iteratorDone();
          }
          var v = value;
          value += reverse ? -step : step;
          return iteratorValue(type, reverse ? size - ++i : i++, v);
        });
      };

      Range.prototype.equals = function equals(other) {
        return other instanceof Range
          ? this._start === other._start &&
              this._end === other._end &&
              this._step === other._step
          : deepEqual(this, other);
      };

      return Range;
    })(IndexedSeq);

    var EMPTY_RANGE;

    function getIn(collection, searchKeyPath, notSetValue) {
      var keyPath = coerceKeyPath(searchKeyPath);
      var i = 0;
      while (i !== keyPath.length) {
        collection = get(collection, keyPath[i++], NOT_SET);
        if (collection === NOT_SET) {
          return notSetValue;
        }
      }
      return collection;
    }

    function getIn$1(searchKeyPath, notSetValue) {
      return getIn(this, searchKeyPath, notSetValue);
    }

    function hasIn(collection, keyPath) {
      return getIn(collection, keyPath, NOT_SET) !== NOT_SET;
    }

    function hasIn$1(searchKeyPath) {
      return hasIn(this, searchKeyPath);
    }

    function toObject() {
      assertNotInfinite(this.size);
      var object = {};
      this.__iterate(function(v, k) {
        object[k] = v;
      });
      return object;
    }

    // Note: all of these methods are deprecated.
    Collection.isIterable = isCollection;
    Collection.isKeyed = isKeyed;
    Collection.isIndexed = isIndexed;
    Collection.isAssociative = isAssociative;
    Collection.isOrdered = isOrdered;

    Collection.Iterator = Iterator;

    mixin(Collection, {
      // ### Conversion to other types

      toArray: function toArray() {
        assertNotInfinite(this.size);
        var array = new Array(this.size || 0);
        var useTuples = isKeyed(this);
        var i = 0;
        this.__iterate(function(v, k) {
          // Keyed collections produce an array of tuples.
          array[i++] = useTuples ? [k, v] : v;
        });
        return array;
      },

      toIndexedSeq: function toIndexedSeq() {
        return new ToIndexedSequence(this);
      },

      toJS: function toJS$1() {
        return toJS(this);
      },

      toKeyedSeq: function toKeyedSeq() {
        return new ToKeyedSequence(this, true);
      },

      toMap: function toMap() {
        // Use Late Binding here to solve the circular dependency.
        return Map(this.toKeyedSeq());
      },

      toObject: toObject,

      toOrderedMap: function toOrderedMap() {
        // Use Late Binding here to solve the circular dependency.
        return OrderedMap(this.toKeyedSeq());
      },

      toOrderedSet: function toOrderedSet() {
        // Use Late Binding here to solve the circular dependency.
        return OrderedSet(isKeyed(this) ? this.valueSeq() : this);
      },

      toSet: function toSet() {
        // Use Late Binding here to solve the circular dependency.
        return Set(isKeyed(this) ? this.valueSeq() : this);
      },

      toSetSeq: function toSetSeq() {
        return new ToSetSequence(this);
      },

      toSeq: function toSeq() {
        return isIndexed(this)
          ? this.toIndexedSeq()
          : isKeyed(this)
          ? this.toKeyedSeq()
          : this.toSetSeq();
      },

      toStack: function toStack() {
        // Use Late Binding here to solve the circular dependency.
        return Stack(isKeyed(this) ? this.valueSeq() : this);
      },

      toList: function toList() {
        // Use Late Binding here to solve the circular dependency.
        return List(isKeyed(this) ? this.valueSeq() : this);
      },

      // ### Common JavaScript methods and properties

      toString: function toString() {
        return "[Collection]";
      },

      __toString: function __toString(head, tail) {
        if (this.size === 0) {
          return head + tail;
        }
        return (
          head +
          " " +
          this.toSeq()
            .map(this.__toStringMapper)
            .join(", ") +
          " " +
          tail
        );
      },

      // ### ES6 Collection methods (ES6 Array and Map)

      concat: function concat() {
        var values = [],
          len = arguments.length;
        while (len--) values[len] = arguments[len];

        return reify(this, concatFactory(this, values));
      },

      includes: function includes(searchValue) {
        return this.some(function(value) {
          return is(value, searchValue);
        });
      },

      entries: function entries() {
        return this.__iterator(ITERATE_ENTRIES);
      },

      every: function every(predicate, context) {
        assertNotInfinite(this.size);
        var returnValue = true;
        this.__iterate(function(v, k, c) {
          if (!predicate.call(context, v, k, c)) {
            returnValue = false;
            return false;
          }
        });
        return returnValue;
      },

      filter: function filter(predicate, context) {
        return reify(this, filterFactory(this, predicate, context, true));
      },

      find: function find(predicate, context, notSetValue) {
        var entry = this.findEntry(predicate, context);
        return entry ? entry[1] : notSetValue;
      },

      forEach: function forEach(sideEffect, context) {
        assertNotInfinite(this.size);
        return this.__iterate(context ? sideEffect.bind(context) : sideEffect);
      },

      join: function join(separator) {
        assertNotInfinite(this.size);
        separator = separator !== undefined ? "" + separator : ",";
        var joined = "";
        var isFirst = true;
        this.__iterate(function(v) {
          isFirst ? (isFirst = false) : (joined += separator);
          joined += v !== null && v !== undefined ? v.toString() : "";
        });
        return joined;
      },

      keys: function keys() {
        return this.__iterator(ITERATE_KEYS);
      },

      map: function map(mapper, context) {
        return reify(this, mapFactory(this, mapper, context));
      },

      reduce: function reduce$1(reducer, initialReduction, context) {
        return reduce(
          this,
          reducer,
          initialReduction,
          context,
          arguments.length < 2,
          false
        );
      },

      reduceRight: function reduceRight(reducer, initialReduction, context) {
        return reduce(
          this,
          reducer,
          initialReduction,
          context,
          arguments.length < 2,
          true
        );
      },

      reverse: function reverse() {
        return reify(this, reverseFactory(this, true));
      },

      slice: function slice(begin, end) {
        return reify(this, sliceFactory(this, begin, end, true));
      },

      some: function some(predicate, context) {
        return !this.every(not(predicate), context);
      },

      sort: function sort(comparator) {
        return reify(this, sortFactory(this, comparator));
      },

      values: function values() {
        return this.__iterator(ITERATE_VALUES);
      },

      // ### More sequential methods

      butLast: function butLast() {
        return this.slice(0, -1);
      },

      isEmpty: function isEmpty() {
        return this.size !== undefined
          ? this.size === 0
          : !this.some(function() {
              return true;
            });
      },

      count: function count(predicate, context) {
        return ensureSize(
          predicate ? this.toSeq().filter(predicate, context) : this
        );
      },

      countBy: function countBy(grouper, context) {
        return countByFactory(this, grouper, context);
      },

      equals: function equals(other) {
        return deepEqual(this, other);
      },

      entrySeq: function entrySeq() {
        var collection = this;
        if (collection._cache) {
          // We cache as an entries array, so we can just return the cache!
          return new ArraySeq(collection._cache);
        }
        var entriesSequence = collection
          .toSeq()
          .map(entryMapper)
          .toIndexedSeq();
        entriesSequence.fromEntrySeq = function() {
          return collection.toSeq();
        };
        return entriesSequence;
      },

      filterNot: function filterNot(predicate, context) {
        return this.filter(not(predicate), context);
      },

      findEntry: function findEntry(predicate, context, notSetValue) {
        var found = notSetValue;
        this.__iterate(function(v, k, c) {
          if (predicate.call(context, v, k, c)) {
            found = [k, v];
            return false;
          }
        });
        return found;
      },

      findKey: function findKey(predicate, context) {
        var entry = this.findEntry(predicate, context);
        return entry && entry[0];
      },

      findLast: function findLast(predicate, context, notSetValue) {
        return this.toKeyedSeq()
          .reverse()
          .find(predicate, context, notSetValue);
      },

      findLastEntry: function findLastEntry(predicate, context, notSetValue) {
        return this.toKeyedSeq()
          .reverse()
          .findEntry(predicate, context, notSetValue);
      },

      findLastKey: function findLastKey(predicate, context) {
        return this.toKeyedSeq()
          .reverse()
          .findKey(predicate, context);
      },

      first: function first(notSetValue) {
        return this.find(returnTrue, null, notSetValue);
      },

      flatMap: function flatMap(mapper, context) {
        return reify(this, flatMapFactory(this, mapper, context));
      },

      flatten: function flatten(depth) {
        return reify(this, flattenFactory(this, depth, true));
      },

      fromEntrySeq: function fromEntrySeq() {
        return new FromEntriesSequence(this);
      },

      get: function get(searchKey, notSetValue) {
        return this.find(
          function(_, key) {
            return is(key, searchKey);
          },
          undefined,
          notSetValue
        );
      },

      getIn: getIn$1,

      groupBy: function groupBy(grouper, context) {
        return groupByFactory(this, grouper, context);
      },

      has: function has(searchKey) {
        return this.get(searchKey, NOT_SET) !== NOT_SET;
      },

      hasIn: hasIn$1,

      isSubset: function isSubset(iter) {
        iter = typeof iter.includes === "function" ? iter : Collection(iter);
        return this.every(function(value) {
          return iter.includes(value);
        });
      },

      isSuperset: function isSuperset(iter) {
        iter = typeof iter.isSubset === "function" ? iter : Collection(iter);
        return iter.isSubset(this);
      },

      keyOf: function keyOf(searchValue) {
        return this.findKey(function(value) {
          return is(value, searchValue);
        });
      },

      keySeq: function keySeq() {
        return this.toSeq()
          .map(keyMapper)
          .toIndexedSeq();
      },

      last: function last(notSetValue) {
        return this.toSeq()
          .reverse()
          .first(notSetValue);
      },

      lastKeyOf: function lastKeyOf(searchValue) {
        return this.toKeyedSeq()
          .reverse()
          .keyOf(searchValue);
      },

      max: function max(comparator) {
        return maxFactory(this, comparator);
      },

      maxBy: function maxBy(mapper, comparator) {
        return maxFactory(this, comparator, mapper);
      },

      min: function min(comparator) {
        return maxFactory(
          this,
          comparator ? neg(comparator) : defaultNegComparator
        );
      },

      minBy: function minBy(mapper, comparator) {
        return maxFactory(
          this,
          comparator ? neg(comparator) : defaultNegComparator,
          mapper
        );
      },

      rest: function rest() {
        return this.slice(1);
      },

      skip: function skip(amount) {
        return amount === 0 ? this : this.slice(Math.max(0, amount));
      },

      skipLast: function skipLast(amount) {
        return amount === 0 ? this : this.slice(0, -Math.max(0, amount));
      },

      skipWhile: function skipWhile(predicate, context) {
        return reify(this, skipWhileFactory(this, predicate, context, true));
      },

      skipUntil: function skipUntil(predicate, context) {
        return this.skipWhile(not(predicate), context);
      },

      sortBy: function sortBy(mapper, comparator) {
        return reify(this, sortFactory(this, comparator, mapper));
      },

      take: function take(amount) {
        return this.slice(0, Math.max(0, amount));
      },

      takeLast: function takeLast(amount) {
        return this.slice(-Math.max(0, amount));
      },

      takeWhile: function takeWhile(predicate, context) {
        return reify(this, takeWhileFactory(this, predicate, context));
      },

      takeUntil: function takeUntil(predicate, context) {
        return this.takeWhile(not(predicate), context);
      },

      update: function update(fn) {
        return fn(this);
      },

      valueSeq: function valueSeq() {
        return this.toIndexedSeq();
      },

      // ### Hashable Object

      hashCode: function hashCode() {
        return this.__hash || (this.__hash = hashCollection(this));
      }

      // ### Internal

      // abstract __iterate(fn, reverse)

      // abstract __iterator(type, reverse)
    });

    var CollectionPrototype = Collection.prototype;
    CollectionPrototype[IS_COLLECTION_SYMBOL] = true;
    CollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.values;
    CollectionPrototype.toJSON = CollectionPrototype.toArray;
    CollectionPrototype.__toStringMapper = quoteString;
    CollectionPrototype.inspect = CollectionPrototype.toSource = function() {
      return this.toString();
    };
    CollectionPrototype.chain = CollectionPrototype.flatMap;
    CollectionPrototype.contains = CollectionPrototype.includes;

    mixin(KeyedCollection, {
      // ### More sequential methods

      flip: function flip() {
        return reify(this, flipFactory(this));
      },

      mapEntries: function mapEntries(mapper, context) {
        var this$1 = this;

        var iterations = 0;
        return reify(
          this,
          this.toSeq()
            .map(function(v, k) {
              return mapper.call(context, [k, v], iterations++, this$1);
            })
            .fromEntrySeq()
        );
      },

      mapKeys: function mapKeys(mapper, context) {
        var this$1 = this;

        return reify(
          this,
          this.toSeq()
            .flip()
            .map(function(k, v) {
              return mapper.call(context, k, v, this$1);
            })
            .flip()
        );
      }
    });

    var KeyedCollectionPrototype = KeyedCollection.prototype;
    KeyedCollectionPrototype[IS_KEYED_SYMBOL] = true;
    KeyedCollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.entries;
    KeyedCollectionPrototype.toJSON = toObject;
    KeyedCollectionPrototype.__toStringMapper = function(v, k) {
      return quoteString(k) + ": " + quoteString(v);
    };

    mixin(IndexedCollection, {
      // ### Conversion to other types

      toKeyedSeq: function toKeyedSeq() {
        return new ToKeyedSequence(this, false);
      },

      // ### ES6 Collection methods (ES6 Array and Map)

      filter: function filter(predicate, context) {
        return reify(this, filterFactory(this, predicate, context, false));
      },

      findIndex: function findIndex(predicate, context) {
        var entry = this.findEntry(predicate, context);
        return entry ? entry[0] : -1;
      },

      indexOf: function indexOf(searchValue) {
        var key = this.keyOf(searchValue);
        return key === undefined ? -1 : key;
      },

      lastIndexOf: function lastIndexOf(searchValue) {
        var key = this.lastKeyOf(searchValue);
        return key === undefined ? -1 : key;
      },

      reverse: function reverse() {
        return reify(this, reverseFactory(this, false));
      },

      slice: function slice(begin, end) {
        return reify(this, sliceFactory(this, begin, end, false));
      },

      splice: function splice(index, removeNum /*, ...values*/) {
        var numArgs = arguments.length;
        removeNum = Math.max(removeNum || 0, 0);
        if (numArgs === 0 || (numArgs === 2 && !removeNum)) {
          return this;
        }
        // If index is negative, it should resolve relative to the size of the
        // collection. However size may be expensive to compute if not cached, so
        // only call count() if the number is in fact negative.
        index = resolveBegin(index, index < 0 ? this.count() : this.size);
        var spliced = this.slice(0, index);
        return reify(
          this,
          numArgs === 1
            ? spliced
            : spliced.concat(
                arrCopy(arguments, 2),
                this.slice(index + removeNum)
              )
        );
      },

      // ### More collection methods

      findLastIndex: function findLastIndex(predicate, context) {
        var entry = this.findLastEntry(predicate, context);
        return entry ? entry[0] : -1;
      },

      first: function first(notSetValue) {
        return this.get(0, notSetValue);
      },

      flatten: function flatten(depth) {
        return reify(this, flattenFactory(this, depth, false));
      },

      get: function get(index, notSetValue) {
        index = wrapIndex(this, index);
        return index < 0 ||
          this.size === Infinity ||
            (this.size !== undefined && index > this.size)
          ? notSetValue
          : this.find(
              function(_, key) {
                return key === index;
              },
              undefined,
              notSetValue
            );
      },

      has: function has(index) {
        index = wrapIndex(this, index);
        return (
          index >= 0 &&
          (this.size !== undefined
            ? this.size === Infinity || index < this.size
            : this.indexOf(index) !== -1)
        );
      },

      interpose: function interpose(separator) {
        return reify(this, interposeFactory(this, separator));
      },

      interleave: function interleave(/*...collections*/) {
        var collections = [this].concat(arrCopy(arguments));
        var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, collections);
        var interleaved = zipped.flatten(true);
        if (zipped.size) {
          interleaved.size = zipped.size * collections.length;
        }
        return reify(this, interleaved);
      },

      keySeq: function keySeq() {
        return Range(0, this.size);
      },

      last: function last(notSetValue) {
        return this.get(-1, notSetValue);
      },

      skipWhile: function skipWhile(predicate, context) {
        return reify(this, skipWhileFactory(this, predicate, context, false));
      },

      zip: function zip(/*, ...collections */) {
        var collections = [this].concat(arrCopy(arguments));
        return reify(this, zipWithFactory(this, defaultZipper, collections));
      },

      zipAll: function zipAll(/*, ...collections */) {
        var collections = [this].concat(arrCopy(arguments));
        return reify(
          this,
          zipWithFactory(this, defaultZipper, collections, true)
        );
      },

      zipWith: function zipWith(zipper /*, ...collections */) {
        var collections = arrCopy(arguments);
        collections[0] = this;
        return reify(this, zipWithFactory(this, zipper, collections));
      }
    });

    var IndexedCollectionPrototype = IndexedCollection.prototype;
    IndexedCollectionPrototype[IS_INDEXED_SYMBOL] = true;
    IndexedCollectionPrototype[IS_ORDERED_SYMBOL] = true;

    mixin(SetCollection, {
      // ### ES6 Collection methods (ES6 Array and Map)

      get: function get(value, notSetValue) {
        return this.has(value) ? value : notSetValue;
      },

      includes: function includes(value) {
        return this.has(value);
      },

      // ### More sequential methods

      keySeq: function keySeq() {
        return this.valueSeq();
      }
    });

    SetCollection.prototype.has = CollectionPrototype.includes;
    SetCollection.prototype.contains = SetCollection.prototype.includes;

    // Mixin subclasses

    mixin(KeyedSeq, KeyedCollection.prototype);
    mixin(IndexedSeq, IndexedCollection.prototype);
    mixin(SetSeq, SetCollection.prototype);

    // #pragma Helper functions

    function reduce(
      collection,
      reducer,
      reduction,
      context,
      useFirst,
      reverse
    ) {
      assertNotInfinite(collection.size);
      collection.__iterate(function(v, k, c) {
        if (useFirst) {
          useFirst = false;
          reduction = v;
        } else {
          reduction = reducer.call(context, reduction, v, k, c);
        }
      }, reverse);
      return reduction;
    }

    function keyMapper(v, k) {
      return k;
    }

    function entryMapper(v, k) {
      return [k, v];
    }

    function not(predicate) {
      return function() {
        return !predicate.apply(this, arguments);
      };
    }

    function neg(predicate) {
      return function() {
        return -predicate.apply(this, arguments);
      };
    }

    function defaultZipper() {
      return arrCopy(arguments);
    }

    function defaultNegComparator(a, b) {
      return a < b ? 1 : a > b ? -1 : 0;
    }

    function hashCollection(collection) {
      if (collection.size === Infinity) {
        return 0;
      }
      var ordered = isOrdered(collection);
      var keyed = isKeyed(collection);
      var h = ordered ? 1 : 0;
      var size = collection.__iterate(
        keyed
          ? ordered
            ? function(v, k) {
                h = (31 * h + hashMerge(hash(v), hash(k))) | 0;
              }
            : function(v, k) {
                h = (h + hashMerge(hash(v), hash(k))) | 0;
              }
          : ordered
          ? function(v) {
              h = (31 * h + hash(v)) | 0;
            }
          : function(v) {
              h = (h + hash(v)) | 0;
            }
      );
      return murmurHashOfSize(size, h);
    }

    function murmurHashOfSize(size, h) {
      h = imul(h, 0xcc9e2d51);
      h = imul((h << 15) | (h >>> -15), 0x1b873593);
      h = imul((h << 13) | (h >>> -13), 5);
      h = ((h + 0xe6546b64) | 0) ^ size;
      h = imul(h ^ (h >>> 16), 0x85ebca6b);
      h = imul(h ^ (h >>> 13), 0xc2b2ae35);
      h = smi(h ^ (h >>> 16));
      return h;
    }

    function hashMerge(a, b) {
      return (a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2))) | 0; // int
    }

    var OrderedSet = /*@__PURE__*/ (function(Set$$1) {
      function OrderedSet(value) {
        return value === null || value === undefined
          ? emptyOrderedSet()
          : isOrderedSet(value)
          ? value
          : emptyOrderedSet().withMutations(function(set) {
              var iter = SetCollection(value);
              assertNotInfinite(iter.size);
              iter.forEach(function(v) {
                return set.add(v);
              });
            });
      }

      if (Set$$1) OrderedSet.__proto__ = Set$$1;
      OrderedSet.prototype = Object.create(Set$$1 && Set$$1.prototype);
      OrderedSet.prototype.constructor = OrderedSet;

      OrderedSet.of = function of(/*...values*/) {
        return this(arguments);
      };

      OrderedSet.fromKeys = function fromKeys(value) {
        return this(KeyedCollection(value).keySeq());
      };

      OrderedSet.prototype.toString = function toString() {
        return this.__toString("OrderedSet {", "}");
      };

      return OrderedSet;
    })(Set);

    OrderedSet.isOrderedSet = isOrderedSet;

    var OrderedSetPrototype = OrderedSet.prototype;
    OrderedSetPrototype[IS_ORDERED_SYMBOL] = true;
    OrderedSetPrototype.zip = IndexedCollectionPrototype.zip;
    OrderedSetPrototype.zipWith = IndexedCollectionPrototype.zipWith;

    OrderedSetPrototype.__empty = emptyOrderedSet;
    OrderedSetPrototype.__make = makeOrderedSet;

    function makeOrderedSet(map, ownerID) {
      var set = Object.create(OrderedSetPrototype);
      set.size = map ? map.size : 0;
      set._map = map;
      set.__ownerID = ownerID;
      return set;
    }

    var EMPTY_ORDERED_SET;
    function emptyOrderedSet() {
      return (
        EMPTY_ORDERED_SET ||
        (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()))
      );
    }

    var Record = function Record(defaultValues, name) {
      var hasInitialized;

      var RecordType = function Record(values) {
        var this$1 = this;

        if (values instanceof RecordType) {
          return values;
        }
        if (!(this instanceof RecordType)) {
          return new RecordType(values);
        }
        if (!hasInitialized) {
          hasInitialized = true;
          var keys = Object.keys(defaultValues);
          var indices = (RecordTypePrototype._indices = {});
          // Deprecated: left to attempt not to break any external code which
          // relies on a ._name property existing on record instances.
          // Use Record.getDescriptiveName() instead
          RecordTypePrototype._name = name;
          RecordTypePrototype._keys = keys;
          RecordTypePrototype._defaultValues = defaultValues;
          for (var i = 0; i < keys.length; i++) {
            var propName = keys[i];
            indices[propName] = i;
            if (RecordTypePrototype[propName]) {
              /* eslint-disable no-console */
              typeof console === "object" &&
                console.warn &&
                console.warn(
                  "Cannot define " +
                    recordName(this) +
                    ' with property "' +
                    propName +
                    '" since that property name is part of the Record API.'
                );
              /* eslint-enable no-console */
            } else {
              setProp(RecordTypePrototype, propName);
            }
          }
        }
        this.__ownerID = undefined;
        this._values = List().withMutations(function(l) {
          l.setSize(this$1._keys.length);
          KeyedCollection(values).forEach(function(v, k) {
            l.set(
              this$1._indices[k],
              v === this$1._defaultValues[k] ? undefined : v
            );
          });
        });
      };

      var RecordTypePrototype = (RecordType.prototype = Object.create(
        RecordPrototype
      ));
      RecordTypePrototype.constructor = RecordType;

      if (name) {
        RecordType.displayName = name;
      }

      return RecordType;
    };

    Record.prototype.toString = function toString() {
      var str = recordName(this) + " { ";
      var keys = this._keys;
      var k;
      for (var i = 0, l = keys.length; i !== l; i++) {
        k = keys[i];
        str += (i ? ", " : "") + k + ": " + quoteString(this.get(k));
      }
      return str + " }";
    };

    Record.prototype.equals = function equals(other) {
      return (
        this === other ||
        (other &&
          this._keys === other._keys &&
          recordSeq(this).equals(recordSeq(other)))
      );
    };

    Record.prototype.hashCode = function hashCode() {
      return recordSeq(this).hashCode();
    };

    // @pragma Access

    Record.prototype.has = function has(k) {
      return this._indices.hasOwnProperty(k);
    };

    Record.prototype.get = function get(k, notSetValue) {
      if (!this.has(k)) {
        return notSetValue;
      }
      var index = this._indices[k];
      var value = this._values.get(index);
      return value === undefined ? this._defaultValues[k] : value;
    };

    // @pragma Modification

    Record.prototype.set = function set(k, v) {
      if (this.has(k)) {
        var newValues = this._values.set(
          this._indices[k],
          v === this._defaultValues[k] ? undefined : v
        );
        if (newValues !== this._values && !this.__ownerID) {
          return makeRecord(this, newValues);
        }
      }
      return this;
    };

    Record.prototype.remove = function remove(k) {
      return this.set(k);
    };

    Record.prototype.clear = function clear() {
      var newValues = this._values.clear().setSize(this._keys.length);
      return this.__ownerID ? this : makeRecord(this, newValues);
    };

    Record.prototype.wasAltered = function wasAltered() {
      return this._values.wasAltered();
    };

    Record.prototype.toSeq = function toSeq() {
      return recordSeq(this);
    };

    Record.prototype.toJS = function toJS$1() {
      return toJS(this);
    };

    Record.prototype.entries = function entries() {
      return this.__iterator(ITERATE_ENTRIES);
    };

    Record.prototype.__iterator = function __iterator(type, reverse) {
      return recordSeq(this).__iterator(type, reverse);
    };

    Record.prototype.__iterate = function __iterate(fn, reverse) {
      return recordSeq(this).__iterate(fn, reverse);
    };

    Record.prototype.__ensureOwner = function __ensureOwner(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      var newValues = this._values.__ensureOwner(ownerID);
      if (!ownerID) {
        this.__ownerID = ownerID;
        this._values = newValues;
        return this;
      }
      return makeRecord(this, newValues, ownerID);
    };

    Record.isRecord = isRecord;
    Record.getDescriptiveName = recordName;
    var RecordPrototype = Record.prototype;
    RecordPrototype[IS_RECORD_SYMBOL] = true;
    RecordPrototype[DELETE] = RecordPrototype.remove;
    RecordPrototype.deleteIn = RecordPrototype.removeIn = deleteIn;
    RecordPrototype.getIn = getIn$1;
    RecordPrototype.hasIn = CollectionPrototype.hasIn;
    RecordPrototype.merge = merge;
    RecordPrototype.mergeWith = mergeWith;
    RecordPrototype.mergeIn = mergeIn;
    RecordPrototype.mergeDeep = mergeDeep$1;
    RecordPrototype.mergeDeepWith = mergeDeepWith$1;
    RecordPrototype.mergeDeepIn = mergeDeepIn;
    RecordPrototype.setIn = setIn$1;
    RecordPrototype.update = update$1;
    RecordPrototype.updateIn = updateIn$1;
    RecordPrototype.withMutations = withMutations;
    RecordPrototype.asMutable = asMutable;
    RecordPrototype.asImmutable = asImmutable;
    RecordPrototype[ITERATOR_SYMBOL] = RecordPrototype.entries;
    RecordPrototype.toJSON = RecordPrototype.toObject =
      CollectionPrototype.toObject;
    RecordPrototype.inspect = RecordPrototype.toSource = function() {
      return this.toString();
    };

    function makeRecord(likeRecord, values, ownerID) {
      var record = Object.create(Object.getPrototypeOf(likeRecord));
      record._values = values;
      record.__ownerID = ownerID;
      return record;
    }

    function recordName(record) {
      return (
        record.constructor.displayName || record.constructor.name || "Record"
      );
    }

    function recordSeq(record) {
      return keyedSeqFromValue(
        record._keys.map(function(k) {
          return [k, record.get(k)];
        })
      );
    }

    function setProp(prototype, name) {
      try {
        Object.defineProperty(prototype, name, {
          get: function() {
            return this.get(name);
          },
          set: function(value) {
            invariant(this.__ownerID, "Cannot set on an immutable record.");
            this.set(name, value);
          }
        });
      } catch (error) {
        // Object.defineProperty failed. Probably IE8.
      }
    }

    /**
     * Returns a lazy Seq of `value` repeated `times` times. When `times` is
     * undefined, returns an infinite sequence of `value`.
     */
    var Repeat = /*@__PURE__*/ (function(IndexedSeq$$1) {
      function Repeat(value, times) {
        if (!(this instanceof Repeat)) {
          return new Repeat(value, times);
        }
        this._value = value;
        this.size = times === undefined ? Infinity : Math.max(0, times);
        if (this.size === 0) {
          if (EMPTY_REPEAT) {
            return EMPTY_REPEAT;
          }
          EMPTY_REPEAT = this;
        }
      }

      if (IndexedSeq$$1) Repeat.__proto__ = IndexedSeq$$1;
      Repeat.prototype = Object.create(
        IndexedSeq$$1 && IndexedSeq$$1.prototype
      );
      Repeat.prototype.constructor = Repeat;

      Repeat.prototype.toString = function toString() {
        if (this.size === 0) {
          return "Repeat []";
        }
        return "Repeat [ " + this._value + " " + this.size + " times ]";
      };

      Repeat.prototype.get = function get(index, notSetValue) {
        return this.has(index) ? this._value : notSetValue;
      };

      Repeat.prototype.includes = function includes(searchValue) {
        return is(this._value, searchValue);
      };

      Repeat.prototype.slice = function slice(begin, end) {
        var size = this.size;
        return wholeSlice(begin, end, size)
          ? this
          : new Repeat(
              this._value,
              resolveEnd(end, size) - resolveBegin(begin, size)
            );
      };

      Repeat.prototype.reverse = function reverse() {
        return this;
      };

      Repeat.prototype.indexOf = function indexOf(searchValue) {
        if (is(this._value, searchValue)) {
          return 0;
        }
        return -1;
      };

      Repeat.prototype.lastIndexOf = function lastIndexOf(searchValue) {
        if (is(this._value, searchValue)) {
          return this.size;
        }
        return -1;
      };

      Repeat.prototype.__iterate = function __iterate(fn, reverse) {
        var size = this.size;
        var i = 0;
        while (i !== size) {
          if (fn(this._value, reverse ? size - ++i : i++, this) === false) {
            break;
          }
        }
        return i;
      };

      Repeat.prototype.__iterator = function __iterator(type, reverse) {
        var this$1 = this;

        var size = this.size;
        var i = 0;
        return new Iterator(function() {
          return i === size
            ? iteratorDone()
            : iteratorValue(type, reverse ? size - ++i : i++, this$1._value);
        });
      };

      Repeat.prototype.equals = function equals(other) {
        return other instanceof Repeat
          ? is(this._value, other._value)
          : deepEqual(other);
      };

      return Repeat;
    })(IndexedSeq);

    var EMPTY_REPEAT;

    function fromJS(value, converter) {
      return fromJSWith(
        [],
        converter || defaultConverter,
        value,
        "",
        converter && converter.length > 2 ? [] : undefined,
        { "": value }
      );
    }

    function fromJSWith(stack, converter, value, key, keyPath, parentValue) {
      var toSeq = Array.isArray(value)
        ? IndexedSeq
        : isPlainObj(value)
        ? KeyedSeq
        : null;
      if (toSeq) {
        if (~stack.indexOf(value)) {
          throw new TypeError("Cannot convert circular structure to Immutable");
        }
        stack.push(value);
        keyPath && key !== "" && keyPath.push(key);
        var converted = converter.call(
          parentValue,
          key,
          toSeq(value).map(function(v, k) {
            return fromJSWith(stack, converter, v, k, keyPath, value);
          }),
          keyPath && keyPath.slice()
        );
        stack.pop();
        keyPath && keyPath.pop();
        return converted;
      }
      return value;
    }

    function defaultConverter(k, v) {
      return isKeyed(v) ? v.toMap() : v.toList();
    }

    var version = "4.0.0-rc.11";

    var Immutable = {
      version: version,

      Collection: Collection,
      // Note: Iterable is deprecated
      Iterable: Collection,

      Seq: Seq,
      Map: Map,
      OrderedMap: OrderedMap,
      List: List,
      Stack: Stack,
      Set: Set,
      OrderedSet: OrderedSet,

      Record: Record,
      Range: Range,
      Repeat: Repeat,

      is: is,
      fromJS: fromJS,
      hash: hash,

      isImmutable: isImmutable,
      isCollection: isCollection,
      isKeyed: isKeyed,
      isIndexed: isIndexed,
      isAssociative: isAssociative,
      isOrdered: isOrdered,
      isValueObject: isValueObject,
      isSeq: isSeq,
      isList: isList,
      isMap: isMap,
      isOrderedMap: isOrderedMap,
      isStack: isStack,
      isSet: isSet,
      isOrderedSet: isOrderedSet,
      isRecord: isRecord,

      get: get,
      getIn: getIn,
      has: has,
      hasIn: hasIn,
      merge: merge$1,
      mergeDeep: mergeDeep,
      mergeWith: mergeWith$1,
      mergeDeepWith: mergeDeepWith,
      remove: remove,
      removeIn: removeIn,
      set: set,
      setIn: setIn,
      update: update,
      updateIn: updateIn
    };

    // Note: Iterable is deprecated
    var Iterable = Collection;

    exports.default = Immutable;
    exports.version = version;
    exports.Collection = Collection;
    exports.Iterable = Iterable;
    exports.Seq = Seq;
    exports.Map = Map;
    exports.OrderedMap = OrderedMap;
    exports.List = List;
    exports.Stack = Stack;
    exports.Set = Set;
    exports.OrderedSet = OrderedSet;
    exports.Record = Record;
    exports.Range = Range;
    exports.Repeat = Repeat;
    exports.is = is;
    exports.fromJS = fromJS;
    exports.hash = hash;
    exports.isImmutable = isImmutable;
    exports.isCollection = isCollection;
    exports.isKeyed = isKeyed;
    exports.isIndexed = isIndexed;
    exports.isAssociative = isAssociative;
    exports.isOrdered = isOrdered;
    exports.isValueObject = isValueObject;
    exports.get = get;
    exports.getIn = getIn;
    exports.has = has;
    exports.hasIn = hasIn;
    exports.merge = merge$1;
    exports.mergeDeep = mergeDeep;
    exports.mergeWith = mergeWith$1;
    exports.mergeDeepWith = mergeDeepWith;
    exports.remove = remove;
    exports.removeIn = removeIn;
    exports.set = set;
    exports.setIn = setIn;
    exports.update = update;
    exports.updateIn = updateIn;

    Object.defineProperty(exports, "__esModule", { value: true });
  });
});

_commonjsHelpers.unwrapExports(immutable$3);

var draftjsUtils$1 = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  !(function(t, e) {
    module.exports = e(Draft, immutable$3);
  })(window, function(n, r) {
    return (
      (u = {}),
      (o.m = i = [
        function(t, e) {
          t.exports = n;
        },
        function(t, e) {
          t.exports = r;
        },
        function(t, e, n) {
          t.exports = n(3);
        },
        function(t, e, n) {
          n.r(e);
          var C = n(0),
            i = n(1);
          function m(t) {
            var e = t.getSelection(),
              n = t.getCurrentContent(),
              r = e.getStartKey(),
              o = e.getEndKey(),
              i = n.getBlockMap();
            return i
              .toSeq()
              .skipUntil(function(t, e) {
                return e === r;
              })
              .takeUntil(function(t, e) {
                return e === o;
              })
              .concat([[o, i.get(o)]]);
          }
          function a(t) {
            return m(t).toList();
          }
          function f(t) {
            if (t) return a(t).get(0);
          }
          function r(t) {
            if (t) {
              var n = f(t),
                e = t
                  .getCurrentContent()
                  .getBlockMap()
                  .toSeq()
                  .toList(),
                r = 0;
              if (
                (e.forEach(function(t, e) {
                  t.get("key") === n.get("key") && (r = e - 1);
                }),
                -1 < r)
              )
                return e.get(r);
            }
          }
          function o(t) {
            return t
              ? t
                  .getCurrentContent()
                  .getBlockMap()
                  .toList()
              : new i.List();
          }
          function u(t) {
            var e = a(t);
            if (
              !e.some(function(t) {
                return t.type !== e.get(0).type;
              })
            )
              return e.get(0).type;
          }
          function c(t) {
            var e = C.RichUtils.tryToRemoveBlockStyle(t);
            return e ? C.EditorState.push(t, e, "change-block-type") : t;
          }
          function l(t) {
            var e = "",
              n = t.getSelection(),
              r = n.getAnchorOffset(),
              o = n.getFocusOffset(),
              i = a(t);
            if (0 < i.size) {
              if (n.getIsBackward()) {
                var u = r;
                (r = o), (o = u);
              }
              for (var c = 0; c < i.size; c += 1) {
                var f = 0 === c ? r : 0,
                  l = c === i.size - 1 ? o : i.get(c).getText().length;
                e += i
                  .get(c)
                  .getText()
                  .slice(f, l);
              }
            }
            return e;
          }
          function s(t) {
            var e = t.getCurrentContent(),
              n = t.getSelection(),
              r = C.Modifier.removeRange(e, n, "forward"),
              o = r.getSelectionAfter(),
              i = r.getBlockForKey(o.getStartKey());
            return (
              (r = C.Modifier.insertText(
                r,
                o,
                "\n",
                i.getInlineStyleAt(o.getStartOffset()),
                null
              )),
              C.EditorState.push(t, r, "insert-fragment")
            );
          }
          function g(t) {
            var e = C.Modifier.splitBlock(
              t.getCurrentContent(),
              t.getSelection()
            );
            return c(C.EditorState.push(t, e, "split-block"));
          }
          function d(t) {
            var e = t
                .getCurrentContent()
                .getBlockMap()
                .toList(),
              n = t
                .getSelection()
                .merge({
                  anchorKey: e.first().get("key"),
                  anchorOffset: 0,
                  focusKey: e.last().get("key"),
                  focusOffset: e.last().getLength()
                }),
              r = C.Modifier.removeRange(t.getCurrentContent(), n, "forward");
            return C.EditorState.push(t, r, "remove-range");
          }
          function S(t, e) {
            var n = C.Modifier.setBlockData(
              t.getCurrentContent(),
              t.getSelection(),
              e
            );
            return C.EditorState.push(t, n, "change-block-data");
          }
          function p(t) {
            var r = new i.Map({}),
              e = a(t);
            if (e && 0 < e.size)
              for (
                var n = function(t) {
                    var n = e.get(t).getData();
                    if (!n || 0 === n.size) return (r = r.clear()), "break";
                    if (0 === t) r = n;
                    else if (
                      (r.forEach(function(t, e) {
                        (n.get(e) && n.get(e) === t) || (r = r.delete(e));
                      }),
                      0 === r.size)
                    )
                      return (r = r.clear()), "break";
                  },
                  o = 0;
                o < e.size;
                o += 1
              ) {
                if ("break" === n(o)) break;
              }
            return r;
          }
          var y = Object(i.Map)({ code: { element: "pre" } }),
            v = C.DefaultDraftBlockRenderMap.merge(y);
          function b(t) {
            if (t) {
              var e = t.getType();
              return "unordered-list-item" === e || "ordered-list-item" === e;
            }
            return !1;
          }
          function h(t, e, n) {
            var r,
              o = t.getSelection();
            r = o.getIsBackward() ? o.getFocusKey() : o.getAnchorKey();
            var i = t.getCurrentContent(),
              u = i.getBlockForKey(r),
              c = u.getType();
            if ("unordered-list-item" !== c && "ordered-list-item" !== c)
              return t;
            var f = i.getBlockBefore(r);
            if (!f) return t;
            if (f.getType() !== c) return t;
            var l = u.getDepth();
            if (1 === e && l === n) return t;
            var a,
              s,
              g,
              d,
              S,
              p,
              y,
              v = Math.min(f.getDepth() + 1, n),
              b =
                ((s = e),
                (g = v),
                (d = (a = t).getSelection()),
                (S = a.getCurrentContent()),
                (p = S.getBlockMap()),
                (y = m(a).map(function(t) {
                  var e = t.getDepth() + s;
                  return (e = Math.max(0, Math.min(e, g))), t.set("depth", e);
                })),
                (p = p.merge(y)),
                S.merge({
                  blockMap: p,
                  selectionBefore: d,
                  selectionAfter: d
                }));
            return C.EditorState.push(t, b, "adjust-depth");
          }
          function O(t, e) {
            var n;
            return 13 === (n = e).which &&
              (n.getModifierState("Shift") ||
                n.getModifierState("Alt") ||
                n.getModifierState("Control"))
              ? t.getSelection().isCollapsed()
                ? C.RichUtils.insertSoftNewline(t)
                : s(t)
              : (function(t) {
                  var e = t.getSelection();
                  if (e.isCollapsed()) {
                    var n = t.getCurrentContent(),
                      r = e.getStartKey(),
                      o = n.getBlockForKey(r);
                    if (
                      !b(o) &&
                      "unstyled" !== o.getType() &&
                      o.getLength() === e.getStartOffset()
                    )
                      return g(t);
                    if (b(o) && 0 === o.getLength()) {
                      var i = o.getDepth();
                      if (0 === i) return c(t);
                      if (0 < i) return h(t, -1, i);
                    }
                  }
                })(t);
          }
          function k(e, t) {
            var n = Object.keys(e);
            if (Object.getOwnPropertySymbols) {
              var r = Object.getOwnPropertySymbols(e);
              t &&
                (r = r.filter(function(t) {
                  return Object.getOwnPropertyDescriptor(e, t).enumerable;
                })),
                n.push.apply(n, r);
            }
            return n;
          }
          function E(t, e, n) {
            return (
              e in t
                ? Object.defineProperty(t, e, {
                    value: n,
                    enumerable: !0,
                    configurable: !0,
                    writable: !0
                  })
                : (t[e] = n),
              t
            );
          }
          function I(t) {
            return (I =
              "function" == typeof Symbol && "symbol" == typeof Symbol.iterator
                ? function(t) {
                    return typeof t;
                  }
                : function(t) {
                    return t &&
                      "function" == typeof Symbol &&
                      t.constructor === Symbol &&
                      t !== Symbol.prototype
                      ? "symbol"
                      : typeof t;
                  })(t);
          }
          function R(t) {
            var e = t.getSelection();
            if (e.isCollapsed()) {
              var n = {},
                r = t
                  .getCurrentInlineStyle()
                  .toList()
                  .toJS();
              if (r)
                return (
                  [
                    "BOLD",
                    "ITALIC",
                    "UNDERLINE",
                    "STRIKETHROUGH",
                    "CODE",
                    "SUPERSCRIPT",
                    "SUBSCRIPT"
                  ].forEach(function(t) {
                    n[t] = 0 <= r.indexOf(t);
                  }),
                  n
                );
            }
            var u = e.getStartOffset(),
              c = e.getEndOffset(),
              f = a(t);
            if (0 < f.size) {
              var o = (function() {
                for (
                  var n = {
                      BOLD: !0,
                      ITALIC: !0,
                      UNDERLINE: !0,
                      STRIKETHROUGH: !0,
                      CODE: !0,
                      SUPERSCRIPT: !0,
                      SUBSCRIPT: !0
                    },
                    r = 0;
                  r < f.size;
                  r += 1
                ) {
                  var t = 0 === r ? u : 0,
                    e = r === f.size - 1 ? c : f.get(r).getText().length;
                  t === e && 0 === t ? ((t = 1), (e = 2)) : t === e && --t;
                  for (
                    var o = function(t) {
                        var e = f.get(r).getInlineStyleAt(t);
                        [
                          "BOLD",
                          "ITALIC",
                          "UNDERLINE",
                          "STRIKETHROUGH",
                          "CODE",
                          "SUPERSCRIPT",
                          "SUBSCRIPT"
                        ].forEach(function(t) {
                          n[t] = n[t] && e.get(t) === t;
                        });
                      },
                      i = t;
                    i < e;
                    i += 1
                  )
                    o(i);
                }
                return { v: n };
              })();
              if ("object" === I(o)) return o.v;
            }
            return {};
          }
          function B(t) {
            var e,
              n = t.getSelection(),
              r = n.getStartOffset(),
              o = n.getEndOffset();
            r === o && 0 === r ? (o = 1) : r === o && --r;
            for (var i = f(t), u = r; u < o; u += 1) {
              var c = i.getEntityAt(u);
              if (!c) {
                e = void 0;
                break;
              }
              if (u === r) e = c;
              else if (e !== c) {
                e = void 0;
                break;
              }
            }
            return e;
          }
          function T(t, e) {
            var n,
              r = f(t);
            return (
              r.findEntityRanges(
                function(t) {
                  return t.get("entity") === e;
                },
                function(t, e) {
                  n = { start: t, end: e, text: r.get("text").slice(t, e) };
                }
              ),
              n
            );
          }
          function P(t, e, n) {
            x[t]["".concat(t.toLowerCase(), "-").concat(n)] = E(
              {},
              "".concat(e),
              n
            );
          }
          function j() {
            return (function(e) {
              for (var t = 1; t < arguments.length; t++) {
                var n = null != arguments[t] ? arguments[t] : {};
                t % 2
                  ? k(Object(n), !0).forEach(function(t) {
                      E(e, t, n[t]);
                    })
                  : Object.getOwnPropertyDescriptors
                  ? Object.defineProperties(
                      e,
                      Object.getOwnPropertyDescriptors(n)
                    )
                  : k(Object(n)).forEach(function(t) {
                      Object.defineProperty(
                        e,
                        t,
                        Object.getOwnPropertyDescriptor(n, t)
                      );
                    });
              }
              return e;
            })({}, x.color, {}, x.bgcolor, {}, x.fontSize, {}, x.fontFamily, {
              CODE: x.CODE,
              SUPERSCRIPT: x.SUPERSCRIPT,
              SUBSCRIPT: x.SUBSCRIPT
            });
          }
          var x = {
            color: {},
            bgcolor: {},
            fontSize: {},
            fontFamily: {},
            CODE: {
              fontFamily: "monospace",
              wordWrap: "break-word",
              background: "#f1f1f1",
              borderRadius: 3,
              padding: "1px 3px"
            },
            SUPERSCRIPT: {
              fontSize: 11,
              position: "relative",
              top: -8,
              display: "inline-flex"
            },
            SUBSCRIPT: {
              fontSize: 11,
              position: "relative",
              bottom: -8,
              display: "inline-flex"
            }
          };
          function M(t, e, n) {
            var r = t.getSelection(),
              o = Object.keys(x[e]).reduce(function(t, e) {
                return C.Modifier.removeInlineStyle(t, r, e);
              }, t.getCurrentContent()),
              i = C.EditorState.push(t, o, "changeinline-style"),
              u = t.getCurrentInlineStyle();
            if (
              (r.isCollapsed() &&
                (i = u.reduce(function(t, e) {
                  return C.RichUtils.toggleInlineStyle(t, e);
                }, i)),
              "SUPERSCRIPT" === e || "SUBSCRIPT" == e)
            )
              u.has(n) || (i = C.RichUtils.toggleInlineStyle(i, n));
            else {
              var c = "bgcolor" === e ? "backgroundColor" : e;
              u.has("".concat(c, "-").concat(n)) ||
                ((i = C.RichUtils.toggleInlineStyle(
                  i,
                  "".concat(e.toLowerCase(), "-").concat(n)
                )),
                P(e, c, n));
            }
            return i;
          }
          function L(t) {
            t &&
              t
                .getCurrentContent()
                .getBlockMap()
                .map(function(t) {
                  return t.get("characterList");
                })
                .toList()
                .flatten()
                .forEach(function(t) {
                  t && 0 === t.indexOf("color-")
                    ? P("color", "color", t.substr(6))
                    : t && 0 === t.indexOf("bgcolor-")
                    ? P("bgcolor", "backgroundColor", t.substr(8))
                    : t && 0 === t.indexOf("fontsize-")
                    ? P("fontSize", "fontSize", +t.substr(9))
                    : t &&
                      0 === t.indexOf("fontfamily-") &&
                      P("fontFamily", "fontFamily", t.substr(11));
                });
          }
          function U(t, e, n) {
            var r = t
              .getInlineStyleAt(n)
              .toList()
              .filter(function(t) {
                return t.startsWith(e.toLowerCase());
              });
            if (r && 0 < r.size) return r.get(0);
          }
          function w(r, l) {
            if (r && l && 0 < l.length) {
              var t = (function() {
                var t = r.getSelection(),
                  i = {};
                if (t.isCollapsed())
                  return (
                    l.forEach(function(t) {
                      i[t] = (function(t, e) {
                        var n = t
                          .getCurrentInlineStyle()
                          .toList()
                          .filter(function(t) {
                            return t.startsWith(e.toLowerCase());
                          });
                        if (n && 0 < n.size) return n.get(0);
                      })(r, t);
                    }),
                    { v: i }
                  );
                var u = t.getStartOffset(),
                  c = t.getEndOffset(),
                  f = a(r);
                if (0 < f.size) {
                  for (
                    var e = function(n) {
                        var t = 0 === n ? u : 0,
                          e = n === f.size - 1 ? c : f.get(n).getText().length;
                        t === e && 0 === t
                          ? ((t = 1), (e = 2))
                          : t === e && --t;
                        for (
                          var r = function(e) {
                              e === t
                                ? l.forEach(function(t) {
                                    i[t] = U(f.get(n), t, e);
                                  })
                                : l.forEach(function(t) {
                                    i[t] &&
                                      i[t] !== U(f.get(n), t, e) &&
                                      (i[t] = void 0);
                                  });
                            },
                            o = t;
                          o < e;
                          o += 1
                        )
                          r(o);
                      },
                      n = 0;
                    n < f.size;
                    n += 1
                  )
                    e(n);
                  return { v: i };
                }
              })();
              if ("object" === I(t)) return t.v;
            }
            return {};
          }
          function D(e) {
            var t = e.getCurrentInlineStyle(),
              n = e.getCurrentContent();
            return (
              t.forEach(function(t) {
                n = C.Modifier.removeInlineStyle(n, e.getSelection(), t);
              }),
              C.EditorState.push(e, n, "change-inline-style")
            );
          }
          n.d(e, "isListBlock", function() {
            return b;
          }),
            n.d(e, "changeDepth", function() {
              return h;
            }),
            n.d(e, "handleNewLine", function() {
              return O;
            }),
            n.d(e, "getEntityRange", function() {
              return T;
            }),
            n.d(e, "getCustomStyleMap", function() {
              return j;
            }),
            n.d(e, "toggleCustomInlineStyle", function() {
              return M;
            }),
            n.d(e, "getSelectionEntity", function() {
              return B;
            }),
            n.d(e, "extractInlineStyle", function() {
              return L;
            }),
            n.d(e, "removeAllInlineStyles", function() {
              return D;
            }),
            n.d(e, "getSelectionInlineStyle", function() {
              return R;
            }),
            n.d(e, "getSelectionCustomInlineStyle", function() {
              return w;
            }),
            n.d(e, "getSelectedBlocksMap", function() {
              return m;
            }),
            n.d(e, "getSelectedBlocksList", function() {
              return a;
            }),
            n.d(e, "getSelectedBlock", function() {
              return f;
            }),
            n.d(e, "getBlockBeforeSelectedBlock", function() {
              return r;
            }),
            n.d(e, "getAllBlocks", function() {
              return o;
            }),
            n.d(e, "getSelectedBlocksType", function() {
              return u;
            }),
            n.d(e, "removeSelectedBlocksStyle", function() {
              return c;
            }),
            n.d(e, "getSelectionText", function() {
              return l;
            }),
            n.d(e, "addLineBreakRemovingSelection", function() {
              return s;
            }),
            n.d(e, "insertNewUnstyledBlock", function() {
              return g;
            }),
            n.d(e, "clearEditorContent", function() {
              return d;
            }),
            n.d(e, "setBlockData", function() {
              return S;
            }),
            n.d(e, "getSelectedBlocksMetadata", function() {
              return p;
            }),
            n.d(e, "blockRenderMap", function() {
              return v;
            });
        }
      ]),
      (o.c = u),
      (o.d = function(t, e, n) {
        o.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: n });
      }),
      (o.r = function(t) {
        "undefined" != typeof Symbol &&
          Symbol.toStringTag &&
          Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
          Object.defineProperty(t, "__esModule", { value: !0 });
      }),
      (o.t = function(e, t) {
        if ((1 & t && (e = o(e)), 8 & t)) return e;
        if (4 & t && "object" == typeof e && e && e.__esModule) return e;
        var n = Object.create(null);
        if (
          (o.r(n),
          Object.defineProperty(n, "default", { enumerable: !0, value: e }),
          2 & t && "string" != typeof e)
        )
          for (var r in e)
            o.d(
              n,
              r,
              function(t) {
                return e[t];
              }.bind(null, r)
            );
        return n;
      }),
      (o.n = function(t) {
        var e =
          t && t.__esModule
            ? function() {
                return t.default;
              }
            : function() {
                return t;
              };
        return o.d(e, "a", e), e;
      }),
      (o.o = function(t, e) {
        return Object.prototype.hasOwnProperty.call(t, e);
      }),
      (o.p = ""),
      o((o.s = 2))
    );
    function o(t) {
      if (u[t]) return u[t].exports;
      var e = (u[t] = { i: t, l: !1, exports: {} });
      return i[t].call(e.exports, e, e.exports, o), (e.l = !0), e.exports;
    }
    var i, u;
  });
});

_commonjsHelpers.unwrapExports(draftjsUtils$1);
var draftjsUtils_1$1 = draftjsUtils$1.draftjsUtils;

var content$1 = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.redo = exports.undo = exports.handleKeyCommand = exports.clear = exports.setMediaPosition = exports.removeMedia = exports.setMediaData = exports.insertMedias = exports.insertHorizontalLine = exports.insertAtomicBlock = exports.insertHTML = exports.insertText = exports.toggleSelectionLetterSpacing = exports.toggleSelectionFontFamily = exports.toggleSelectionLineHeight = exports.toggleSelectionFontSize = exports.toggleSelectionBackgroundColor = exports.toggleSelectionColor = exports.decreaseSelectionIndent = exports.increaseSelectionIndent = exports.toggleSelectionIndent = exports.toggleSelectionAlignment = exports.removeSelectionInlineStyles = exports.toggleSelectionInlineStyle = exports.selectionHasInlineStyle = exports.getSelectionInlineStyle = exports.toggleSelectionLink = exports.toggleSelectionEntity = exports.getSelectionEntityData = exports.getSelectionEntityType = exports.toggleSelectionBlockType = exports.getSelectionText = exports.getSelectionBlockType = exports.getSelectionBlockData = exports.setSelectionBlockData = exports.getSelectedBlocks = exports.updateEachCharacterOfSelection = exports.getSelectionBlock = exports.removeBlock = exports.selectNextBlock = exports.selectBlock = exports.selectionContainsStrictBlock = exports.selectionContainsBlockType = exports.isSelectionCollapsed = exports.createEditorState = exports.createEmptyEditorState = exports.isEditorState = exports.registerStrictBlockType = undefined;

  var _immutable2 = _interopRequireDefault(immutable$3);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : { default: obj };
  }

  var strictBlockTypes = ["atomic"];

  var registerStrictBlockType = (exports.registerStrictBlockType = function registerStrictBlockType(
    blockType
  ) {
    strictBlockTypes.indexOf(blockType) === -1 &&
      strictBlockTypes.push(blockType);
  });

  var isEditorState = (exports.isEditorState = function isEditorState(
    editorState
  ) {
    return editorState instanceof Draft.EditorState;
  });

  var createEmptyEditorState = (exports.createEmptyEditorState = function createEmptyEditorState(
    editorDecorators
  ) {
    return Draft.EditorState.createEmpty(editorDecorators);
  });

  var createEditorState = (exports.createEditorState = function createEditorState(
    contentState,
    editorDecorators
  ) {
    return Draft.EditorState.createWithContent(contentState, editorDecorators);
  });

  var isSelectionCollapsed = (exports.isSelectionCollapsed = function isSelectionCollapsed(
    editorState
  ) {
    return editorState.getSelection().isCollapsed();
  });

  var selectionContainsBlockType = (exports.selectionContainsBlockType = function selectionContainsBlockType(
    editorState,
    blockType
  ) {
    return getSelectedBlocks(editorState).find(function(block) {
      return block.getType() === blockType;
    });
  });

  var selectionContainsStrictBlock = (exports.selectionContainsStrictBlock = function selectionContainsStrictBlock(
    editorState
  ) {
    return getSelectedBlocks(editorState).find(function(block) {
      return ~strictBlockTypes.indexOf(block.getType());
    });
  });

  var selectBlock = (exports.selectBlock = function selectBlock(
    editorState,
    block
  ) {
    var blockKey = block.getKey();

    return Draft.EditorState.forceSelection(
      editorState,
      new Draft.SelectionState({
        anchorKey: blockKey,
        anchorOffset: 0,
        focusKey: blockKey,
        focusOffset: block.getLength()
      })
    );
  });

  var selectNextBlock = (exports.selectNextBlock = function selectNextBlock(
    editorState,
    block
  ) {
    var nextBlock = editorState
      .getCurrentContent()
      .getBlockAfter(block.getKey());
    return nextBlock ? selectBlock(editorState, nextBlock) : editorState;
  });

  var removeBlock = (exports.removeBlock = function removeBlock(
    editorState,
    block
  ) {
    var lastSelection =
      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;

    var nextContentState = void 0,
      nextEditorState = void 0;
    var blockKey = block.getKey();

    nextContentState = Draft.Modifier.removeRange(
      editorState.getCurrentContent(),
      new Draft.SelectionState({
        anchorKey: blockKey,
        anchorOffset: 0,
        focusKey: blockKey,
        focusOffset: block.getLength()
      }),
      "backward"
    );

    nextContentState = Draft.Modifier.setBlockType(
      nextContentState,
      nextContentState.getSelectionAfter(),
      "unstyled"
    );
    nextEditorState = Draft.EditorState.push(
      editorState,
      nextContentState,
      "remove-range"
    );
    return Draft.EditorState.forceSelection(
      nextEditorState,
      lastSelection || nextContentState.getSelectionAfter()
    );
  });

  var getSelectionBlock = (exports.getSelectionBlock = function getSelectionBlock(
    editorState
  ) {
    return editorState
      .getCurrentContent()
      .getBlockForKey(editorState.getSelection().getAnchorKey());
  });

  var updateEachCharacterOfSelection = (exports.updateEachCharacterOfSelection = function updateEachCharacterOfSelection(
    editorState,
    callback
  ) {
    var selectionState = editorState.getSelection();
    var contentState = editorState.getCurrentContent();
    var contentBlocks = contentState.getBlockMap();
    var selectedBlocks = getSelectedBlocks(editorState);

    if (selectedBlocks.length === 0) {
      return editorState;
    }

    var startKey = selectionState.getStartKey();
    var startOffset = selectionState.getStartOffset();
    var endKey = selectionState.getEndKey();
    var endOffset = selectionState.getEndOffset();

    var nextContentBlocks = contentBlocks.map(function(block) {
      if (selectedBlocks.indexOf(block) === -1) {
        return block;
      }

      var blockKey = block.getKey();
      var charactersList = block.getCharacterList();
      var nextCharactersList = null;

      if (blockKey === startKey && blockKey === endKey) {
        nextCharactersList = charactersList.map(function(character, index) {
          if (index >= startOffset && index < endOffset) {
            return callback(character);
          }
          return character;
        });
      } else if (blockKey === startKey) {
        nextCharactersList = charactersList.map(function(character, index) {
          if (index >= startOffset) {
            return callback(character);
          }
          return character;
        });
      } else if (blockKey === endKey) {
        nextCharactersList = charactersList.map(function(character, index) {
          if (index < endOffset) {
            return callback(character);
          }
          return character;
        });
      } else {
        nextCharactersList = charactersList.map(function(character) {
          return callback(character);
        });
      }

      return block.merge({
        characterList: nextCharactersList
      });
    });

    return Draft.EditorState.push(
      editorState,
      contentState.merge({
        blockMap: nextContentBlocks,
        selectionBefore: selectionState,
        selectionAfter: selectionState
      }),
      "update-selection-character-list"
    );
  });

  var getSelectedBlocks = (exports.getSelectedBlocks = function getSelectedBlocks(
    editorState
  ) {
    var selectionState = editorState.getSelection();
    var contentState = editorState.getCurrentContent();

    var startKey = selectionState.getStartKey();
    var endKey = selectionState.getEndKey();
    var isSameBlock = startKey === endKey;
    var startingBlock = contentState.getBlockForKey(startKey);
    var selectedBlocks = [startingBlock];

    if (!isSameBlock) {
      var blockKey = startKey;

      while (blockKey !== endKey) {
        var nextBlock = contentState.getBlockAfter(blockKey);
        selectedBlocks.push(nextBlock);
        blockKey = nextBlock.getKey();
      }
    }

    return selectedBlocks;
  });

  var setSelectionBlockData = (exports.setSelectionBlockData = function setSelectionBlockData(
    editorState,
    blockData,
    override
  ) {
    var newBlockData = override
      ? blockData
      : Object.assign({}, getSelectionBlockData(editorState).toJS(), blockData);

    Object.keys(newBlockData).forEach(function(key) {
      if (newBlockData.hasOwnProperty(key) && newBlockData[key] === undefined) {
        delete newBlockData[key];
      }
    });

    return (0, draftjsUtils$1.setBlockData)(editorState, newBlockData);
  });

  var getSelectionBlockData = (exports.getSelectionBlockData = function getSelectionBlockData(
    editorState,
    name
  ) {
    var blockData = getSelectionBlock(editorState).getData();
    return name ? blockData.get(name) : blockData;
  });

  var getSelectionBlockType = (exports.getSelectionBlockType = function getSelectionBlockType(
    editorState
  ) {
    return getSelectionBlock(editorState).getType();
  });

  var getSelectionText = (exports.getSelectionText = function getSelectionText(
    editorState
  ) {
    var selectionState = editorState.getSelection();
    var contentState = editorState.getCurrentContent();

    if (
      selectionState.isCollapsed() ||
      getSelectionBlockType(editorState) === "atomic"
    ) {
      return "";
    }

    var anchorKey = selectionState.getAnchorKey();
    var currentContentBlock = contentState.getBlockForKey(anchorKey);
    var start = selectionState.getStartOffset();
    var end = selectionState.getEndOffset();

    return currentContentBlock.getText().slice(start, end);
  });

  var toggleSelectionBlockType = (exports.toggleSelectionBlockType = function toggleSelectionBlockType(
    editorState,
    blockType
  ) {
    if (selectionContainsStrictBlock(editorState)) {
      return editorState;
    }

    return Draft.RichUtils.toggleBlockType(editorState, blockType);
  });

  var getSelectionEntityType = (exports.getSelectionEntityType = function getSelectionEntityType(
    editorState
  ) {
    var entityKey = (0, draftjsUtils$1.getSelectionEntity)(editorState);

    if (entityKey) {
      var entity = editorState.getCurrentContent().getEntity(entityKey);
      return entity ? entity.get("type") : null;
    }

    return null;
  });

  var getSelectionEntityData = (exports.getSelectionEntityData = function getSelectionEntityData(
    editorState,
    type
  ) {
    var entityKey = (0, draftjsUtils$1.getSelectionEntity)(editorState);

    if (entityKey) {
      var entity = editorState.getCurrentContent().getEntity(entityKey);
      if (entity && entity.get("type") === type) {
        return entity.getData();
      } else {
        return {};
      }
    } else {
      return {};
    }
  });

  var toggleSelectionEntity = (exports.toggleSelectionEntity = function toggleSelectionEntity(
    editorState,
    entity
  ) {
    var contentState = editorState.getCurrentContent();
    var selectionState = editorState.getSelection();

    if (
      selectionState.isCollapsed() ||
      getSelectionBlockType(editorState) === "atomic"
    ) {
      return editorState;
    }

    if (
      !entity ||
      !entity.type ||
      getSelectionEntityType(editorState) === entity.type
    ) {
      return Draft.EditorState.push(
        editorState,
        Draft.Modifier.applyEntity(contentState, selectionState, null),
        "apply-entity"
      );
    }

    try {
      var nextContentState = contentState.createEntity(
        entity.type,
        entity.mutability,
        entity.data
      );
      var entityKey = nextContentState.getLastCreatedEntityKey();

      var nextEditorState = Draft.EditorState.set(editorState, {
        currentContent: nextContentState
      });

      return Draft.EditorState.push(
        nextEditorState,
        Draft.Modifier.applyEntity(nextContentState, selectionState, entityKey),
        "apply-entity"
      );
    } catch (error) {
      console.warn(error);
      return editorState;
    }
  });

  var toggleSelectionLink = (exports.toggleSelectionLink = function toggleSelectionLink(
    editorState,
    href,
    target
  ) {
    var contentState = editorState.getCurrentContent();
    var selectionState = editorState.getSelection();

    var entityData = { href: href, target: target };

    if (
      selectionState.isCollapsed() ||
      getSelectionBlockType(editorState) === "atomic"
    ) {
      return editorState;
    }

    if (href === false) {
      return Draft.RichUtils.toggleLink(editorState, selectionState, null);
    }

    if (href === null) {
      delete entityData.href;
    }

    try {
      var nextContentState = contentState.createEntity(
        "LINK",
        "MUTABLE",
        entityData
      );
      var entityKey = nextContentState.getLastCreatedEntityKey();

      var nextEditorState = Draft.EditorState.set(editorState, {
        currentContent: nextContentState
      });

      nextEditorState = Draft.RichUtils.toggleLink(
        nextEditorState,
        selectionState,
        entityKey
      );
      nextEditorState = Draft.EditorState.forceSelection(
        nextEditorState,
        selectionState.merge({
          anchorOffset: selectionState.getEndOffset(),
          focusOffset: selectionState.getEndOffset()
        })
      );

      nextEditorState = Draft.EditorState.push(
        nextEditorState,
        Draft.Modifier.insertText(
          nextEditorState.getCurrentContent(),
          nextEditorState.getSelection(),
          ""
        ),
        "insert-text"
      );

      return nextEditorState;
    } catch (error) {
      console.warn(error);
      return editorState;
    }
  });

  var getSelectionInlineStyle = (exports.getSelectionInlineStyle = function getSelectionInlineStyle(
    editorState
  ) {
    return editorState.getCurrentInlineStyle();
  });

  var selectionHasInlineStyle = (exports.selectionHasInlineStyle = function selectionHasInlineStyle(
    editorState,
    style
  ) {
    return getSelectionInlineStyle(editorState).has(style.toUpperCase());
  });

  var toggleSelectionInlineStyle = (exports.toggleSelectionInlineStyle = function toggleSelectionInlineStyle(
    editorState,
    style
  ) {
    var prefix =
      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "";

    var nextEditorState = editorState;
    style = prefix + style.toUpperCase();

    if (prefix) {
      nextEditorState = updateEachCharacterOfSelection(
        nextEditorState,
        function(characterMetadata) {
          return characterMetadata
            .toJS()
            .style.reduce(function(characterMetadata, characterStyle) {
              if (
                characterStyle.indexOf(prefix) === 0 &&
                style !== characterStyle
              ) {
                return Draft.CharacterMetadata.removeStyle(
                  characterMetadata,
                  characterStyle
                );
              } else {
                return characterMetadata;
              }
            }, characterMetadata);
        }
      );
    }

    return Draft.RichUtils.toggleInlineStyle(nextEditorState, style);
  });

  var removeSelectionInlineStyles = (exports.removeSelectionInlineStyles = function removeSelectionInlineStyles(
    editorState
  ) {
    return updateEachCharacterOfSelection(editorState, function(
      characterMetadata
    ) {
      return characterMetadata.merge({
        style: _immutable2.default.OrderedSet([])
      });
    });
  });

  var toggleSelectionAlignment = (exports.toggleSelectionAlignment = function toggleSelectionAlignment(
    editorState,
    alignment
  ) {
    return setSelectionBlockData(editorState, {
      textAlign:
        getSelectionBlockData(editorState, "textAlign") !== alignment
          ? alignment
          : undefined
    });
  });

  var toggleSelectionIndent = (exports.toggleSelectionIndent = function toggleSelectionIndent(
    editorState,
    textIndent
  ) {
    var maxIndent =
      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 6;

    return textIndent < 0 || textIndent > maxIndent || isNaN(textIndent)
      ? editorState
      : setSelectionBlockData(editorState, {
          textIndent: textIndent || undefined
        });
  });

  var increaseSelectionIndent = (exports.increaseSelectionIndent = function increaseSelectionIndent(
    editorState
  ) {
    var maxIndent =
      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 6;

    var currentIndent = getSelectionBlockData(editorState, "textIndent") || 0;
    return toggleSelectionIndent(editorState, currentIndent + 1, maxIndent);
  });

  var decreaseSelectionIndent = (exports.decreaseSelectionIndent = function decreaseSelectionIndent(
    editorState
  ) {
    var currentIndent = getSelectionBlockData(editorState, "textIndent") || 0;
    return toggleSelectionIndent(editorState, currentIndent - 1);
  });

  var toggleSelectionColor = (exports.toggleSelectionColor = function toggleSelectionColor(
    editorState,
    color
  ) {
    return toggleSelectionInlineStyle(
      editorState,
      color.replace("#", ""),
      "COLOR-"
    );
  });

  var toggleSelectionBackgroundColor = (exports.toggleSelectionBackgroundColor = function toggleSelectionBackgroundColor(
    editorState,
    color
  ) {
    return toggleSelectionInlineStyle(
      editorState,
      color.replace("#", ""),
      "BGCOLOR-"
    );
  });

  var toggleSelectionFontSize = (exports.toggleSelectionFontSize = function toggleSelectionFontSize(
    editorState,
    fontSize
  ) {
    return toggleSelectionInlineStyle(editorState, fontSize, "FONTSIZE-");
  });

  var toggleSelectionLineHeight = (exports.toggleSelectionLineHeight = function toggleSelectionLineHeight(
    editorState,
    lineHeight
  ) {
    return toggleSelectionInlineStyle(editorState, lineHeight, "LINEHEIGHT-");
  });

  var toggleSelectionFontFamily = (exports.toggleSelectionFontFamily = function toggleSelectionFontFamily(
    editorState,
    fontFamily
  ) {
    return toggleSelectionInlineStyle(editorState, fontFamily, "FONTFAMILY-");
  });

  var toggleSelectionLetterSpacing = (exports.toggleSelectionLetterSpacing = function toggleSelectionLetterSpacing(
    editorState,
    letterSpacing
  ) {
    return toggleSelectionInlineStyle(
      editorState,
      letterSpacing,
      "LETTERSPACING-"
    );
  });

  var insertText = (exports.insertText = function insertText(
    editorState,
    text,
    inlineStyle,
    entity
  ) {
    var selectionState = editorState.getSelection();
    var currentSelectedBlockType = getSelectionBlockType(editorState);

    if (currentSelectedBlockType === "atomic") {
      return editorState;
    }

    var entityKey = void 0;
    var contentState = editorState.getCurrentContent();

    if (entity && entity.type) {
      contentState = contentState.createEntity(
        entity.type,
        entity.mutability || "MUTABLE",
        entity.data || entityData
      );
      entityKey = contentState.getLastCreatedEntityKey();
    }

    if (!selectionState.isCollapsed()) {
      return Draft.EditorState.push(
        editorState,
        Draft.Modifier.replaceText(
          contentState,
          selectionState,
          text,
          inlineStyle,
          entityKey
        ),
        "replace-text"
      );
    } else {
      return Draft.EditorState.push(
        editorState,
        Draft.Modifier.insertText(
          contentState,
          selectionState,
          text,
          inlineStyle,
          entityKey
        ),
        "insert-text"
      );
    }
  });

  var insertHTML = (exports.insertHTML = function insertHTML(
    editorState,
    htmlString,
    source
  ) {
    if (!htmlString) {
      return editorState;
    }

    var selectionState = editorState.getSelection();
    var contentState = editorState.getCurrentContent();
    var options = editorState.convertOptions || {};

    try {
      var _convertFromRaw = (0, Draft.convertFromRaw)(
          (0, dist.convertHTMLToRaw)(htmlString, options, source)
        ),
        blockMap = _convertFromRaw.blockMap;

      return Draft.EditorState.push(
        editorState,
        Draft.Modifier.replaceWithFragment(
          contentState,
          selectionState,
          blockMap
        ),
        "insert-fragment"
      );
    } catch (error) {
      console.warn(error);
      return editorState;
    }
  });

  var insertAtomicBlock = (exports.insertAtomicBlock = function insertAtomicBlock(
    editorState,
    type
  ) {
    var immutable =
      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
    var data =
      arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};

    if (selectionContainsStrictBlock(editorState)) {
      return insertAtomicBlock(
        selectNextBlock(editorState, getSelectionBlock(editorState)),
        type,
        immutable,
        data
      );
    }

    var selectionState = editorState.getSelection();
    var contentState = editorState.getCurrentContent();

    if (
      !selectionState.isCollapsed() ||
      getSelectionBlockType(editorState) === "atomic"
    ) {
      return editorState;
    }

    var contentStateWithEntity = contentState.createEntity(
      type,
      immutable ? "IMMUTABLE" : "MUTABLE",
      data
    );
    var entityKey = contentStateWithEntity.getLastCreatedEntityKey();
    var newEditorState = Draft.AtomicBlockUtils.insertAtomicBlock(
      editorState,
      entityKey,
      " "
    );

    return newEditorState;
  });

  var insertHorizontalLine = (exports.insertHorizontalLine = function insertHorizontalLine(
    editorState
  ) {
    return insertAtomicBlock(editorState, "HR");
  });

  var insertMedias = (exports.insertMedias = function insertMedias(
    editorState
  ) {
    var medias =
      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];

    if (!medias.length) {
      return editorState;
    }

    return medias.reduce(function(editorState, media) {
      var url = media.url,
        link = media.link,
        link_target = media.link_target,
        name = media.name,
        type = media.type,
        width = media.width,
        height = media.height,
        meta = media.meta;

      return insertAtomicBlock(editorState, type, true, {
        url: url,
        link: link,
        link_target: link_target,
        name: name,
        type: type,
        width: width,
        height: height,
        meta: meta
      });
    }, editorState);
  });

  var setMediaData = (exports.setMediaData = function setMediaData(
    editorState,
    entityKey,
    data
  ) {
    return Draft.EditorState.push(
      editorState,
      editorState.getCurrentContent().mergeEntityData(entityKey, data),
      "change-block-data"
    );
  });

  var removeMedia = (exports.removeMedia = function removeMedia(
    editorState,
    mediaBlock
  ) {
    return removeBlock(editorState, mediaBlock);
  });

  var setMediaPosition = (exports.setMediaPosition = function setMediaPosition(
    editorState,
    mediaBlock,
    position
  ) {
    var newPosition = {};
    var float = position.float,
      alignment = position.alignment;

    if (typeof float !== "undefined") {
      newPosition.float =
        mediaBlock.getData().get("float") === float ? null : float;
    }

    if (typeof alignment !== "undefined") {
      newPosition.alignment =
        mediaBlock.getData().get("alignment") === alignment ? null : alignment;
    }

    return setSelectionBlockData(
      selectBlock(editorState, mediaBlock),
      newPosition
    );
  });

  var clear = (exports.clear = function clear(editorState) {
    var contentState = editorState.getCurrentContent();

    var firstBlock = contentState.getFirstBlock();
    var lastBlock = contentState.getLastBlock();

    var allSelected = new Draft.SelectionState({
      anchorKey: firstBlock.getKey(),
      anchorOffset: 0,
      focusKey: lastBlock.getKey(),
      focusOffset: lastBlock.getLength(),
      hasFocus: true
    });

    return Draft.RichUtils.toggleBlockType(
      Draft.EditorState.push(
        editorState,
        Draft.Modifier.removeRange(contentState, allSelected, "backward"),
        "remove-range"
      ),
      "unstyled"
    );
  });

  var handleKeyCommand = (exports.handleKeyCommand = function handleKeyCommand(
    editorState,
    command
  ) {
    return Draft.RichUtils.handleKeyCommand(editorState, command);
  });

  var undo = (exports.undo = function undo(editorState) {
    return Draft.EditorState.undo(editorState);
  });

  var redo = (exports.redo = function redo(editorState) {
    return Draft.EditorState.redo(editorState);
  });
});

_commonjsHelpers.unwrapExports(content$1);
var content_1$1 = content$1.redo;
var content_2$1 = content$1.undo;
var content_3$1 = content$1.handleKeyCommand;
var content_4$1 = content$1.clear;
var content_5$1 = content$1.setMediaPosition;
var content_6$1 = content$1.removeMedia;
var content_7$1 = content$1.setMediaData;
var content_8$1 = content$1.insertMedias;
var content_9$1 = content$1.insertHorizontalLine;
var content_10$1 = content$1.insertAtomicBlock;
var content_11$1 = content$1.insertHTML;
var content_12$1 = content$1.insertText;
var content_13$1 = content$1.toggleSelectionLetterSpacing;
var content_14$1 = content$1.toggleSelectionFontFamily;
var content_15$1 = content$1.toggleSelectionLineHeight;
var content_16$1 = content$1.toggleSelectionFontSize;
var content_17$1 = content$1.toggleSelectionBackgroundColor;
var content_18$1 = content$1.toggleSelectionColor;
var content_19$1 = content$1.decreaseSelectionIndent;
var content_20$1 = content$1.increaseSelectionIndent;
var content_21$1 = content$1.toggleSelectionIndent;
var content_22$1 = content$1.toggleSelectionAlignment;
var content_23$1 = content$1.removeSelectionInlineStyles;
var content_24$1 = content$1.toggleSelectionInlineStyle;
var content_25$1 = content$1.selectionHasInlineStyle;
var content_26$1 = content$1.getSelectionInlineStyle;
var content_27$1 = content$1.toggleSelectionLink;
var content_28$1 = content$1.toggleSelectionEntity;
var content_29$1 = content$1.getSelectionEntityData;
var content_30$1 = content$1.getSelectionEntityType;
var content_31$1 = content$1.toggleSelectionBlockType;
var content_32$1 = content$1.getSelectionText;
var content_33$1 = content$1.getSelectionBlockType;
var content_34$1 = content$1.getSelectionBlockData;
var content_35$1 = content$1.setSelectionBlockData;
var content_36$1 = content$1.getSelectedBlocks;
var content_37$1 = content$1.updateEachCharacterOfSelection;
var content_38$1 = content$1.getSelectionBlock;
var content_39$1 = content$1.removeBlock;
var content_40$1 = content$1.selectNextBlock;
var content_41$1 = content$1.selectBlock;
var content_42$1 = content$1.selectionContainsStrictBlock;
var content_43$1 = content$1.selectionContainsBlockType;
var content_44$1 = content$1.isSelectionCollapsed;
var content_45$1 = content$1.createEditorState;
var content_46$1 = content$1.createEmptyEditorState;
var content_47$1 = content$1.isEditorState;
var content_48$1 = content$1.registerStrictBlockType;

var base$1 = _commonjsHelpers.createCommonjsModule(function(module, exports) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  var braftUniqueIndex = 0;

  var UniqueIndex = (exports.UniqueIndex = function UniqueIndex() {
    return (braftUniqueIndex += 1);
  });
});

_commonjsHelpers.unwrapExports(base$1);
var base_1$1 = base$1.UniqueIndex;

var color$1 = _commonjsHelpers.createCommonjsModule(function(module, exports) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  var _namedColors = {
    aliceblue: "#f0f8ff",
    antiquewhite: "#faebd7",
    aqua: "#00ffff",
    aquamarine: "#7fffd4",
    azure: "#f0ffff",
    beige: "#f5f5dc",
    bisque: "#ffe4c4",
    black: "#000000",
    blanchedalmond: "#ffebcd",
    blue: "#0000ff",
    blueviolet: "#8a2be2",
    brown: "#a52a2a",
    burlywood: "#deb887",
    cadetblue: "#5f9ea0",
    chartreuse: "#7fff00",
    chocolate: "#d2691e",
    coral: "#ff7f50",
    cornflowerblue: "#6495ed",
    cornsilk: "#fff8dc",
    crimson: "#dc143c",
    cyan: "#00ffff",
    darkblue: "#00008b",
    darkcyan: "#008b8b",
    darkgoldenrod: "#b8860b",
    darkgray: "#a9a9a9",
    darkgreen: "#006400",
    darkkhaki: "#bdb76b",
    darkmagenta: "#8b008b",
    darkolivegreen: "#556b2f",
    darkorange: "#ff8c00",
    darkorchid: "#9932cc",
    darkred: "#8b0000",
    darksalmon: "#e9967a",
    darkseagreen: "#8fbc8f",
    darkslateblue: "#483d8b",
    darkslategray: "#2f4f4f",
    darkturquoise: "#00ced1",
    darkviolet: "#9400d3",
    deeppink: "#ff1493",
    deepskyblue: "#00bfff",
    dimgray: "#696969",
    dodgerblue: "#1e90ff",
    firebrick: "#b22222",
    floralwhite: "#fffaf0",
    forestgreen: "#228b22",
    fuchsia: "#ff00ff",
    gainsboro: "#dcdcdc",
    ghostwhite: "#f8f8ff",
    gold: "#ffd700",
    goldenrod: "#daa520",
    gray: "#808080",
    green: "#008000",
    greenyellow: "#adff2f",
    honeydew: "#f0fff0",
    hotpink: "#ff69b4",
    "indianred ": "#cd5c5c",
    indigo: "#4b0082",
    ivory: "#fffff0",
    khaki: "#f0e68c",
    lavender: "#e6e6fa",
    lavenderblush: "#fff0f5",
    lawngreen: "#7cfc00",
    lemonchiffon: "#fffacd",
    lightblue: "#add8e6",
    lightcoral: "#f08080",
    lightcyan: "#e0ffff",
    lightgoldenrodyellow: "#fafad2",
    lightgrey: "#d3d3d3",
    lightgreen: "#90ee90",
    lightpink: "#ffb6c1",
    lightsalmon: "#ffa07a",
    lightseagreen: "#20b2aa",
    lightskyblue: "#87cefa",
    lightslategray: "#778899",
    lightsteelblue: "#b0c4de",
    lightyellow: "#ffffe0",
    lime: "#00ff00",
    limegreen: "#32cd32",
    linen: "#faf0e6",
    magenta: "#ff00ff",
    maroon: "#800000",
    mediumaquamarine: "#66cdaa",
    mediumblue: "#0000cd",
    mediumorchid: "#ba55d3",
    mediumpurple: "#9370d8",
    mediumseagreen: "#3cb371",
    mediumslateblue: "#7b68ee",
    mediumspringgreen: "#00fa9a",
    mediumturquoise: "#48d1cc",
    mediumvioletred: "#c71585",
    midnightblue: "#191970",
    mintcream: "#f5fffa",
    mistyrose: "#ffe4e1",
    moccasin: "#ffe4b5",
    navajowhite: "#ffdead",
    navy: "#000080",
    oldlace: "#fdf5e6",
    olive: "#808000",
    olivedrab: "#6b8e23",
    orange: "#ffa500",
    orangered: "#ff4500",
    orchid: "#da70d6",
    palegoldenrod: "#eee8aa",
    palegreen: "#98fb98",
    paleturquoise: "#afeeee",
    palevioletred: "#d87093",
    papayawhip: "#ffefd5",
    peachpuff: "#ffdab9",
    peru: "#cd853f",
    pink: "#ffc0cb",
    plum: "#dda0dd",
    powderblue: "#b0e0e6",
    purple: "#800080",
    rebeccapurple: "#663399",
    red: "#ff0000",
    rosybrown: "#bc8f8f",
    royalblue: "#4169e1",
    saddlebrown: "#8b4513",
    salmon: "#fa8072",
    sandybrown: "#f4a460",
    seagreen: "#2e8b57",
    seashell: "#fff5ee",
    sienna: "#a0522d",
    silver: "#c0c0c0",
    skyblue: "#87ceeb",
    slateblue: "#6a5acd",
    slategray: "#708090",
    snow: "#fffafa",
    springgreen: "#00ff7f",
    steelblue: "#4682b4",
    tan: "#d2b48c",
    teal: "#008080",
    thistle: "#d8bfd8",
    tomato: "#ff6347",
    turquoise: "#40e0d0",
    violet: "#ee82ee",
    wheat: "#f5deb3",
    white: "#ffffff",
    whitesmoke: "#f5f5f5",
    yellow: "#ffff00",
    yellowgreen: "#9acd32"
  };

  var _getHexColor = function _getHexColor(color) {
    color = color
      .replace("color:", "")
      .replace(";", "")
      .replace(" ", "");

    if (/^#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})$/.test(color)) {
      return color;
    } else if (namedColors[color]) {
      return namedColors[color];
    } else if (color.indexOf("rgb") === 0) {
      var rgbArray = color.split(",");
      var convertedColor =
        rgbArray.length < 3
          ? null
          : "#" +
            [rgbArray[0], rgbArray[1], rgbArray[2]]
              .map(function(x) {
                var hex = parseInt(x.replace(/\D/g, ""), 10).toString(16);
                return hex.length === 1 ? "0" + hex : hex;
              })
              .join("");

      return /^#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})$/.test(convertedColor)
        ? convertedColor
        : null;
    } else {
      return null;
    }
  };

  var namedColors = (exports.namedColors = _namedColors);
  var getHexColor = (exports.getHexColor = _getHexColor);

  var detectColorsFromHTMLString = (exports.detectColorsFromHTMLString = function detectColorsFromHTMLString(
    html
  ) {
    return typeof html !== "string"
      ? []
      : (html.match(/color:[^;]{3,24};/g) || [])
          .map(getHexColor)
          .filter(function(color) {
            return color;
          });
  });

  var detectColorsFromDraftState = (exports.detectColorsFromDraftState = function detectColorsFromDraftState(
    draftState
  ) {
    var result = [];

    if (!draftState || !draftState.blocks || !draftState.blocks.length) {
      return result;
    }

    draftState.blocks.forEach(function(block) {
      if (block && block.inlineStyleRanges && block.inlineStyleRanges.length) {
        block.inlineStyleRanges.forEach(function(inlineStyle) {
          if (inlineStyle.style && inlineStyle.style.indexOf("COLOR-") >= 0) {
            result.push("#" + inlineStyle.style.split("COLOR-")[1]);
          }
        });
      }
    });

    return result.filter(function(color) {
      return color;
    });
  });
});

_commonjsHelpers.unwrapExports(color$1);
var color_1$1 = color$1.namedColors;
var color_2$1 = color$1.getHexColor;
var color_3$1 = color$1.detectColorsFromHTMLString;
var color_4$1 = color$1.detectColorsFromDraftState;

var dist$4 = _commonjsHelpers.createCommonjsModule(function(module, exports) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.ColorUtils = exports.BaseUtils = exports.ContentUtils = undefined;

  var _ContentUtils = _interopRequireWildcard(content$1);

  var _BaseUtils = _interopRequireWildcard(base$1);

  var _ColorUtils = _interopRequireWildcard(color$1);

  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;
    }
  }

  var ContentUtils = (exports.ContentUtils = _ContentUtils);
  var BaseUtils = (exports.BaseUtils = _BaseUtils);
  var ColorUtils = (exports.ColorUtils = _ColorUtils);
});

_commonjsHelpers.unwrapExports(dist$4);
var dist_1$2 = dist$4.ColorUtils;
var dist_2$2 = dist$4.BaseUtils;
var dist_3$2 = dist$4.ContentUtils;

var emoticon = _commonjsHelpers.createCommonjsModule(function(module, exports) {
  (function webpackUniversalModuleDefinition(root, factory) {
    module.exports = factory(React__default, dist$4);
  })(window, function(
    __WEBPACK_EXTERNAL_MODULE__1__,
    __WEBPACK_EXTERNAL_MODULE__6__
  ) {
    return /******/ (function(modules) {
      // webpackBootstrap
      /******/ // The module cache
      /******/ var installedModules = {}; // The require function
      /******/
      /******/ /******/ function __webpack_require__(moduleId) {
        /******/
        /******/ // Check if module is in cache
        /******/ if (installedModules[moduleId]) {
          /******/ return installedModules[moduleId].exports;
          /******/
        } // Create a new module (and put it into the cache)
        /******/ /******/ var module = (installedModules[moduleId] = {
          /******/ i: moduleId,
          /******/ l: false,
          /******/ exports: {}
          /******/
        }); // Execute the module function
        /******/
        /******/ /******/ modules[moduleId].call(
          module.exports,
          module,
          module.exports,
          __webpack_require__
        ); // Flag the module as loaded
        /******/
        /******/ /******/ module.l = true; // Return the exports of the module
        /******/
        /******/ /******/ return module.exports;
        /******/
      } // expose the modules object (__webpack_modules__)
      /******/
      /******/
      /******/ /******/ __webpack_require__.m = modules; // expose the module cache
      /******/
      /******/ /******/ __webpack_require__.c = installedModules; // define getter function for harmony exports
      /******/
      /******/ /******/ __webpack_require__.d = function(
        exports,
        name,
        getter
      ) {
        /******/ if (!__webpack_require__.o(exports, name)) {
          /******/ Object.defineProperty(exports, name, {
            enumerable: true,
            get: getter
          });
          /******/
        }
        /******/
      }; // define __esModule on exports
      /******/
      /******/ /******/ __webpack_require__.r = function(exports) {
        /******/ if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
          /******/ Object.defineProperty(exports, Symbol.toStringTag, {
            value: "Module"
          });
          /******/
        }
        /******/ Object.defineProperty(exports, "__esModule", { value: true });
        /******/
      }; // create a fake namespace object // mode & 1: value is a module id, require it // mode & 2: merge all properties of value into the ns // mode & 4: return value when already ns object // mode & 8|1: behave like require
      /******/
      /******/ /******/ /******/ /******/ /******/ /******/ __webpack_require__.t = function(
        value,
        mode
      ) {
        /******/ if (mode & 1) value = __webpack_require__(value);
        /******/ if (mode & 8) return value;
        /******/ if (
          mode & 4 &&
          typeof value === "object" &&
          value &&
          value.__esModule
        )
          return value;
        /******/ var ns = Object.create(null);
        /******/ __webpack_require__.r(ns);
        /******/ Object.defineProperty(ns, "default", {
          enumerable: true,
          value: value
        });
        /******/ if (mode & 2 && typeof value != "string")
          for (var key in value)
            __webpack_require__.d(
              ns,
              key,
              function(key) {
                return value[key];
              }.bind(null, key)
            );
        /******/ return ns;
        /******/
      }; // getDefaultExport function for compatibility with non-harmony modules
      /******/
      /******/ /******/ __webpack_require__.n = function(module) {
        /******/ var getter =
          module && module.__esModule
            ? /******/ function getDefault() {
                return module["default"];
              }
            : /******/ function getModuleExports() {
                return module;
              };
        /******/ __webpack_require__.d(getter, "a", getter);
        /******/ return getter;
        /******/
      }; // Object.prototype.hasOwnProperty.call
      /******/
      /******/ /******/ __webpack_require__.o = function(object, property) {
        return Object.prototype.hasOwnProperty.call(object, property);
      }; // __webpack_public_path__
      /******/
      /******/ /******/ __webpack_require__.p = "/"; // Load entry module and return exports
      /******/
      /******/
      /******/ /******/ return __webpack_require__(
        (__webpack_require__.s = 33)
      );
      /******/
    })(
      /************************************************************************/
      /******/ {
        /***/ 1: /***/ function(module, exports) {
          module.exports = __WEBPACK_EXTERNAL_MODULE__1__;

          /***/
        },

        /***/ 2: /***/ function(module, exports) {
          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;
          }

          module.exports = _defineProperty;

          /***/
        },

        /***/ 33: /***/ function(
          module,
          __webpack_exports__,
          __webpack_require__
        ) {
          __webpack_require__.r(__webpack_exports__);
          /* harmony export (binding) */ __webpack_require__.d(
            __webpack_exports__,
            "defaultEmoticons",
            function() {
              return defaultEmoticons;
            }
          );
          /* harmony import */ var _babel_runtime_helpers_objectSpread__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
            5
          );
          /* harmony import */ var _babel_runtime_helpers_objectSpread__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/ __webpack_require__.n(
            _babel_runtime_helpers_objectSpread__WEBPACK_IMPORTED_MODULE_0__
          );
          /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(
            1
          );
          /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/ __webpack_require__.n(
            react__WEBPACK_IMPORTED_MODULE_1__
          );
          /* harmony import */ var braft_utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(
            6
          );
          /* harmony import */ var _styles_scss__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(
            48
          );

          // https://www.iconfinder.com/iconsets/emoji-18

          var defaultEmoticons = [
            1,
            2,
            3,
            4,
            5,
            6,
            7,
            8,
            9,
            10,
            11,
            12,
            13,
            14,
            15,
            16,
            17,
            18,
            19,
            20,
            21,
            22,
            23,
            24,
            25
          ].map(function(item) {
            return "".concat(item, ".png");
          });

          var insertEmoticon = function insertEmoticon(
            editor,
            editorState,
            src
          ) {
            editor.setValue(
              braft_utils__WEBPACK_IMPORTED_MODULE_2__[
                "ContentUtils"
              ].insertText(editorState, " ", null, {
                type: "EMOTICON",
                mutability: "IMMUTABLE",
                data: {
                  src: src
                }
              })
            );
          };

          var controlRef = null;

          var bindControlRef = function bindControlRef(ref) {
            return (controlRef = ref);
          };

          /* harmony default export */ __webpack_exports__[
            "default"
          ] = function(options) {
            options = _babel_runtime_helpers_objectSpread__WEBPACK_IMPORTED_MODULE_0___default()(
              {
                emoticons: [],
                closeOnSelect: false,
                closeOnBlur: false
              },
              options
            );
            var _options = options,
              emoticons = _options.emoticons,
              closeOnSelect = _options.closeOnSelect,
              closeOnBlur = _options.closeOnBlur,
              includeEditors = _options.includeEditors,
              excludeEditors = _options.excludeEditors;
            return {
              type: "entity",
              includeEditors: includeEditors,
              excludeEditors: excludeEditors,
              name: "EMOTICON",
              control: function control(props) {
                return {
                  key: "EMOTICON",
                  replace: "emoji",
                  type: "dropdown",
                  text: react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement(
                    "i",
                    {
                      className: "bfi-emoji"
                    }
                  ),
                  showArrow: false,
                  ref: bindControlRef,
                  autoHide: closeOnBlur,
                  component: react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement(
                    "div",
                    {
                      className: "braft-emoticon-picker"
                    },
                    react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement(
                      "div",
                      {
                        className: "braft-emoticons-list"
                      },
                      emoticons.map(function(item, index) {
                        return react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement(
                          "img",
                          {
                            onClick: function onClick() {
                              insertEmoticon(
                                props.editor,
                                props.editorState,
                                item
                              );
                              closeOnSelect && controlRef && controlRef.hide();
                            },
                            key: index,
                            src: item
                          }
                        );
                      })
                    )
                  )
                };
              },
              mutability: "IMMUTABLE",
              component: function component(props) {
                var entity = props.contentState.getEntity(props.entityKey);

                var _entity$getData = entity.getData(),
                  src = _entity$getData.src;

                return react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement(
                  "span",
                  {
                    className: "braft-emoticon-in-editor"
                  },
                  react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement(
                    "img",
                    {
                      src: src
                    }
                  ),
                  props.children
                );
              },
              importer: function importer(nodeName, node) {
                if (
                  nodeName.toLowerCase() === "span" &&
                  node.classList &&
                  node.classList.contains("braft-emoticon-wrap")
                ) {
                  var imgNode = node.querySelector("img");
                  var src = imgNode.getAttribute("src"); // 移除img节点以避免生成atomic block

                  node.removeChild(imgNode);
                  return {
                    mutability: "IMMUTABLE",
                    data: {
                      src: src
                    }
                  };
                }
              },
              exporter: function exporter(entityObject, initialText) {
                var src = entityObject.data.src;
                return react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement(
                  "span",
                  {
                    className: "braft-emoticon-wrap"
                  },
                  react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement(
                    "img",
                    {
                      src: src
                    }
                  ),
                  initialText
                );
              }
            };
          };

          /***/
        },

        /***/ 48: /***/ function(module, exports) {
          // removed by extract-text-webpack-plugin
          /***/
        },

        /***/ 5: /***/ function(module, exports, __webpack_require__) {
          var defineProperty = __webpack_require__(2);

          function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
              var source = arguments[i] != null ? arguments[i] : {};
              var ownKeys = Object.keys(source);

              if (typeof Object.getOwnPropertySymbols === "function") {
                ownKeys = ownKeys.concat(
                  Object.getOwnPropertySymbols(source).filter(function(sym) {
                    return Object.getOwnPropertyDescriptor(
                      source,
                      sym
                    ).enumerable;
                  })
                );
              }

              ownKeys.forEach(function(key) {
                defineProperty(target, key, source[key]);
              });
            }

            return target;
          }

          module.exports = _objectSpread;

          /***/
        },

        /***/ 6: /***/ function(module, exports) {
          module.exports = __WEBPACK_EXTERNAL_MODULE__6__;

          /***/
        }

        /******/
      }
    );
  });
});

var Emoticon = _commonjsHelpers.unwrapExports(emoticon);
var emoticon_1 = emoticon.defaultEmoticons;

var maxLength = _commonjsHelpers.createCommonjsModule(function(
  module,
  exports
) {
  (function webpackUniversalModuleDefinition(root, factory) {
    module.exports = factory();
  })(window, function() {
    return /******/ (function(modules) {
      // webpackBootstrap
      /******/ // The module cache
      /******/ var installedModules = {}; // The require function
      /******/
      /******/ /******/ function __webpack_require__(moduleId) {
        /******/
        /******/ // Check if module is in cache
        /******/ if (installedModules[moduleId]) {
          /******/ return installedModules[moduleId].exports;
          /******/
        } // Create a new module (and put it into the cache)
        /******/ /******/ var module = (installedModules[moduleId] = {
          /******/ i: moduleId,
          /******/ l: false,
          /******/ exports: {}
          /******/
        }); // Execute the module function
        /******/
        /******/ /******/ modules[moduleId].call(
          module.exports,
          module,
          module.exports,
          __webpack_require__
        ); // Flag the module as loaded
        /******/
        /******/ /******/ module.l = true; // Return the exports of the module
        /******/
        /******/ /******/ return module.exports;
        /******/
      } // expose the modules object (__webpack_modules__)
      /******/
      /******/
      /******/ /******/ __webpack_require__.m = modules; // expose the module cache
      /******/
      /******/ /******/ __webpack_require__.c = installedModules; // define getter function for harmony exports
      /******/
      /******/ /******/ __webpack_require__.d = function(
        exports,
        name,
        getter
      ) {
        /******/ if (!__webpack_require__.o(exports, name)) {
          /******/ Object.defineProperty(exports, name, {
            enumerable: true,
            get: getter
          });
          /******/
        }
        /******/
      }; // define __esModule on exports
      /******/
      /******/ /******/ __webpack_require__.r = function(exports) {
        /******/ if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
          /******/ Object.defineProperty(exports, Symbol.toStringTag, {
            value: "Module"
          });
          /******/
        }
        /******/ Object.defineProperty(exports, "__esModule", { value: true });
        /******/
      }; // create a fake namespace object // mode & 1: value is a module id, require it // mode & 2: merge all properties of value into the ns // mode & 4: return value when already ns object // mode & 8|1: behave like require
      /******/
      /******/ /******/ /******/ /******/ /******/ /******/ __webpack_require__.t = function(
        value,
        mode
      ) {
        /******/ if (mode & 1) value = __webpack_require__(value);
        /******/ if (mode & 8) return value;
        /******/ if (
          mode & 4 &&
          typeof value === "object" &&
          value &&
          value.__esModule
        )
          return value;
        /******/ var ns = Object.create(null);
        /******/ __webpack_require__.r(ns);
        /******/ Object.defineProperty(ns, "default", {
          enumerable: true,
          value: value
        });
        /******/ if (mode & 2 && typeof value != "string")
          for (var key in value)
            __webpack_require__.d(
              ns,
              key,
              function(key) {
                return value[key];
              }.bind(null, key)
            );
        /******/ return ns;
        /******/
      }; // getDefaultExport function for compatibility with non-harmony modules
      /******/
      /******/ /******/ __webpack_require__.n = function(module) {
        /******/ var getter =
          module && module.__esModule
            ? /******/ function getDefault() {
                return module["default"];
              }
            : /******/ function getModuleExports() {
                return module;
              };
        /******/ __webpack_require__.d(getter, "a", getter);
        /******/ return getter;
        /******/
      }; // Object.prototype.hasOwnProperty.call
      /******/
      /******/ /******/ __webpack_require__.o = function(object, property) {
        return Object.prototype.hasOwnProperty.call(object, property);
      }; // __webpack_public_path__
      /******/
      /******/ /******/ __webpack_require__.p = "/"; // Load entry module and return exports
      /******/
      /******/
      /******/ /******/ return __webpack_require__(
        (__webpack_require__.s = 34)
      );
      /******/
    })(
      /************************************************************************/
      /******/ {
        /***/ 2: /***/ function(module, exports) {
          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;
          }

          module.exports = _defineProperty;

          /***/
        },

        /***/ 34: /***/ function(
          module,
          __webpack_exports__,
          __webpack_require__
        ) {
          __webpack_require__.r(__webpack_exports__);
          /* harmony import */ var _babel_runtime_helpers_objectSpread__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
            5
          );
          /* harmony import */ var _babel_runtime_helpers_objectSpread__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/ __webpack_require__.n(
            _babel_runtime_helpers_objectSpread__WEBPACK_IMPORTED_MODULE_0__
          );

          var getSelectedTextLength = function getSelectedTextLength(
            editorState
          ) {
            var currentSelection = editorState.getSelection();
            var isCollapsed = currentSelection.isCollapsed();
            var length = 0;

            if (!isCollapsed) {
              var currentContent = editorState.getCurrentContent();
              var startKey = currentSelection.getStartKey();
              var endKey = currentSelection.getEndKey();
              var startBlock = currentContent.getBlockForKey(startKey);
              var isStartAndEndBlockAreTheSame = startKey === endKey;
              var startBlockTextLength = startBlock.getLength();
              var startSelectedTextLength =
                startBlockTextLength - currentSelection.getStartOffset();
              var endSelectedTextLength = currentSelection.getEndOffset();
              var keyAfterEnd = currentContent.getKeyAfter(endKey);

              if (isStartAndEndBlockAreTheSame) {
                length +=
                  currentSelection.getEndOffset() -
                  currentSelection.getStartOffset();
              } else {
                var currentKey = startKey;

                while (currentKey && currentKey !== keyAfterEnd) {
                  if (currentKey === startKey) {
                    length += startSelectedTextLength + 1;
                  } else if (currentKey === endKey) {
                    length += endSelectedTextLength;
                  } else {
                    length +=
                      currentContent.getBlockForKey(currentKey).getLength() + 1;
                  }

                  currentKey = currentContent.getKeyAfter(currentKey);
                }
              }
            }

            return length;
          };

          /* harmony default export */ __webpack_exports__[
            "default"
          ] = function(options) {
            options = _babel_runtime_helpers_objectSpread__WEBPACK_IMPORTED_MODULE_0___default()(
              {
                defaultValue: Infinity
              },
              options
            );
            var _options = options,
              includeEditors = _options.includeEditors,
              excludeEditors = _options.excludeEditors,
              defaultValue = _options.defaultValue;
            return {
              type: "prop-interception",
              includeEditors: includeEditors,
              excludeEditors: excludeEditors,
              interceptor: function interceptor(editorProps) {
                var maxLength = editorProps.maxLength || defaultValue;

                editorProps.handleBeforeInput = function(_, editorState) {
                  if (maxLength === Infinity) {
                    return "not-handled";
                  }

                  var currentContentLength = editorState.toText().length;
                  var selectedTextLength = getSelectedTextLength(editorState);

                  if (
                    currentContentLength - selectedTextLength >
                    maxLength - 1
                  ) {
                    editorProps.onReachMaxLength &&
                      editorProps.onReachMaxLength(maxLength);
                    return "handled";
                  }
                };

                editorProps.handlePastedText = function(
                  pastedText,
                  _,
                  editorState
                ) {
                  if (maxLength === Infinity) {
                    return "not-handled";
                  }

                  var currentContentLength = editorState.toText().length;
                  var selectedTextLength = getSelectedTextLength(editorState);

                  if (
                    currentContentLength +
                      pastedText.length -
                      selectedTextLength >
                    maxLength
                  ) {
                    editorProps.onReachMaxLength &&
                      editorProps.onReachMaxLength(maxLength);
                    return "handled";
                  }
                };

                return editorProps;
              }
            };
          };

          /***/
        },

        /***/ 5: /***/ function(module, exports, __webpack_require__) {
          var defineProperty = __webpack_require__(2);

          function _objectSpread(target) {
            for (var i = 1; i < arguments.length; i++) {
              var source = arguments[i] != null ? arguments[i] : {};
              var ownKeys = Object.keys(source);

              if (typeof Object.getOwnPropertySymbols === "function") {
                ownKeys = ownKeys.concat(
                  Object.getOwnPropertySymbols(source).filter(function(sym) {
                    return Object.getOwnPropertyDescriptor(
                      source,
                      sym
                    ).enumerable;
                  })
                );
              }

              ownKeys.forEach(function(key) {
                defineProperty(target, key, source[key]);
              });
            }

            return target;
          }

          module.exports = _objectSpread;

          /***/
        }

        /******/
      }
    );
  });
});

var MaxLength = _commonjsHelpers.unwrapExports(maxLength);

var lengthOptions = {
  defaultValue: 100
};
BraftEditor.use(MaxLength(lengthOptions));
var emoticons = emoticon_1.map(function(item) {
  return require("braft-extensions/dist/assets/".concat(item));
});
var emotionOptions = {
  emoticons: emoticons,
  closeOnBlur: true,
  closeOnSelect: false
};
BraftEditor.use(Emoticon(emotionOptions));
var BarftEditorPage = function BarftEditorPage(_ref) {
  var value = _ref.value;
  var controls = [
    "bold",
    "italic",
    "underline",
    "separator",
    "link",
    "emoji",
    "separator",
    "media"
  ];

  var _useState = React.useState(
      BraftEditor.createEditorState(value || "<p>Hello <b>World!</b></p>")
    ),
    _useState2 = slicedToArray._slicedToArray(_useState, 2),
    editorState = _useState2[0],
    setEditorState = _useState2[1];

  return React__default.createElement(
    "div",
    {
      className: "editor-wrapper"
    },
    React__default.createElement(BraftEditor, {
      value: editorState,
      onChange: setEditorState,
      controls: controls,
      contentStyle: {
        boxShadow: "inset 0 1px 3px rgba(0,0,0,.1)"
      }
    })
  );
};

exports.BarftEditorPage = BarftEditorPage;
exports.default = BarftEditorPage;
//# sourceMappingURL=index.js.map