sir-trevor.js

/*!
 * Sir Trevor JS v0.5.0-beta3
 *
 * Released under the MIT license
 * www.opensource.org/licenses/MIT
 *
 * 2015-03-13
 */

var $ = jQuery;


!function (e) {
  if ("object" == typeof exports && "undefined" != typeof module)module.exports = e(); else if ("function" == typeof define && define.amd)define([], e); else {
    var f;
    "undefined" != typeof window ? f = window : "undefined" != typeof global ? f = global : "undefined" != typeof self && (f = self), f.SirTrevor = e()
  }
}(function () {
  var define, module, exports;
  return (function e(t, n, r) {
    function s(o, u) {
      if (!n[o]) {
        if (!t[o]) {
          var a = typeof require == "function" && require;
          if (!u && a)return a(o, !0);
          if (i)return i(o, !0);
          var f = new Error("Cannot find module '" + o + "'");
          throw f.code = "MODULE_NOT_FOUND", f
        }
        var l = n[o] = {exports: {}};
        t[o][0].call(l.exports, function (e) {
          var n = t[o][1][e];
          return s(n ? n : e)
        }, l, l.exports, e, t, n, r)
      }
      return n[o].exports
    }

    var i = typeof require == "function" && require;
    for (var o = 0; o < r.length; o++)s(r[o]);
    return s
  })({
    1: [function (require, module, exports) {
      module.exports = require('./src/');

    }, {"./src/": 176}],
    2: [function (require, module, exports) {
// Array.prototype.find - MIT License (c) 2013 Paul Miller <http://paulmillr.com>
// For all details and docs: https://github.com/paulmillr/array.prototype.find
// Fixes and tests supplied by Duncan Hall <http://duncanhall.net>
      (function (globals) {
        if (Array.prototype.find) return;

        var find = function (predicate) {
          var list = Object(this);
          var length = list.length < 0 ? 0 : list.length >>> 0; // ES.ToUint32;
          if (length === 0) return undefined;
          if (typeof predicate !== 'function' || Object.prototype.toString.call(predicate) !== '[object Function]') {
            throw new TypeError('Array#find: predicate must be a function');
          }
          var thisArg = arguments[1];
          for (var i = 0, value; i < length; i++) {
            value = list[i];
            if (predicate.call(thisArg, value, i, list)) return value;
          }
          return undefined;
        };

        if (Object.defineProperty) {
          try {
            Object.defineProperty(Array.prototype, 'find', {
              value: find, configurable: true, enumerable: false, writable: true
            });
          } catch (e) {
          }
        }

        if (!Array.prototype.find) {
          Array.prototype.find = find;
        }
      })(this);

    }, {}],
    3: [function (require, module, exports) {
      (function (root, factory) {
        if (typeof define === 'function' && define.amd) {
          // AMD. Register as a module.
          define('eventable', function () {
            return (root.Eventable = factory());
          });
        } else if (typeof exports !== 'undefined') {
          // Node. Does not work with strict CommonJS, but only CommonJS-like
          // enviroments that support module.exports, like Node.
          module.exports = factory();
        } else {
          // Browser globals
          root.Eventable = factory();
        }
      }(this, function () {

        // Copy and pasted straight out of Backbone 1.0.0
        // We'll try and keep this updated to the latest

        var array = [];
        var slice = array.slice;

        function once(func) {
          var memo, times = 2;

          return function () {
            if (--times > 0) {
              memo = func.apply(this, arguments);
            } else {
              func = null;
            }
            return memo;
          };
        }

        // Backbone.Events
        // ---------------

        // A module that can be mixed in to *any object* in order to provide it with
        // custom events. You may bind with `on` or remove with `off` callback
        // functions to an event; `trigger`-ing an event fires all callbacks in
        // succession.
        //
        //     var object = {};
        //     extend(object, Backbone.Events);
        //     object.on('expand', function(){ alert('expanded'); });
        //     object.trigger('expand');
        //
        var Eventable = {

          // Bind an event to a `callback` function. Passing `"all"` will bind
          // the callback to all events fired.
          on: function (name, callback, context) {
            if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;
            this._events || (this._events = {});
            var events = this._events[name] || (this._events[name] = []);
            events.push({callback: callback, context: context, ctx: context || this});
            return this;
          },

          // Bind an event to only be triggered a single time. After the first time
          // the callback is invoked, it will be removed.
          once: function (name, callback, context) {
            if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;
            var self = this;
            var func = once(function () {
              self.off(name, func);
              callback.apply(this, arguments);
            });
            func._callback = callback;
            return this.on(name, func, context);
          },

          // Remove one or many callbacks. If `context` is null, removes all
          // callbacks with that function. If `callback` is null, removes all
          // callbacks for the event. If `name` is null, removes all bound
          // callbacks for all events.
          off: function (name, callback, context) {
            var retain, ev, events, names, i, l, j, k;
            if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
            if (!name && !callback && !context) {
              this._events = {};
              return this;
            }

            names = name ? [name] : Object.keys(this._events);
            for (i = 0, l = names.length; i < l; i++) {
              name = names[i];
              if (events = this._events[name]) {
                this._events[name] = retain = [];
                if (callback || context) {
                  for (j = 0, k = events.length; j < k; j++) {
                    ev = events[j];
                    if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||
                      (context && context !== ev.context)) {
                      retain.push(ev);
                    }
                  }
                }
                if (!retain.length) delete this._events[name];
              }
            }

            return this;
          },

          // Trigger one or many events, firing all bound callbacks. Callbacks are
          // passed the same arguments as `trigger` is, apart from the event name
          // (unless you're listening on `"all"`, which will cause your callback to
          // receive the true name of the event as the first argument).
          trigger: function (name) {
            if (!this._events) return this;
            var args = slice.call(arguments, 1);
            if (!eventsApi(this, 'trigger', name, args)) return this;
            var events = this._events[name];
            var allEvents = this._events.all;
            if (events) triggerEvents(events, args);
            if (allEvents) triggerEvents(allEvents, arguments);
            return this;
          },

          // Tell this object to stop listening to either specific events ... or
          // to every object it's currently listening to.
          stopListening: function (obj, name, callback) {
            var listeners = this._listeners;
            if (!listeners) return this;
            var deleteListener = !name && !callback;
            if (typeof name === 'object') callback = this;
            if (obj) (listeners = {})[obj._listenerId] = obj;
            for (var id in listeners) {
              listeners[id].off(name, callback, this);
              if (deleteListener) delete this._listeners[id];
            }
            return this;
          }

        };

        // Regular expression used to split event strings.
        var eventSplitter = /\s+/;

        // Implement fancy features of the Events API such as multiple event
        // names `"change blur"` and jQuery-style event maps `{change: action}`
        // in terms of the existing API.
        var eventsApi = function (obj, action, name, rest) {
          if (!name) return true;

          // Handle event maps.
          if (typeof name === 'object') {
            for (var key in name) {
              obj[action].apply(obj, [key, name[key]].concat(rest));
            }
            return false;
          }

          // Handle space separated event names.
          if (eventSplitter.test(name)) {
            var names = name.split(eventSplitter);
            for (var i = 0, l = names.length; i < l; i++) {
              obj[action].apply(obj, [names[i]].concat(rest));
            }
            return false;
          }

          return true;
        };

        // A difficult-to-believe, but optimized internal dispatch function for
        // triggering events. Tries to keep the usual cases speedy (most internal
        // Backbone events have 3 arguments).
        var triggerEvents = function (events, args) {
          var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];
          switch (args.length) {
            case 0:
              while (++i < l) (ev = events[i]).callback.call(ev.ctx);
              return;
            case 1:
              while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1);
              return;
            case 2:
              while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2);
              return;
            case 3:
              while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3);
              return;
            default:
              while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
          }
        };

        var listenMethods = {listenTo: 'on', listenToOnce: 'once'};

        // Inversion-of-control versions of `on` and `once`. Tell *this* object to
        // listen to an event in another object ... keeping track of what it's
        // listening to.
        function addListenMethod(method, implementation) {
          Eventable[method] = function (obj, name, callback) {
            var listeners = this._listeners || (this._listeners = {});
            var id = obj._listenerId || (obj._listenerId = (new Date()).getTime());
            listeners[id] = obj;
            if (typeof name === 'object') callback = this;
            obj[implementation](name, callback, this);
            return this;
          };
        }

        addListenMethod('listenTo', 'on');
        addListenMethod('listenToOnce', 'once');

        // Aliases for backwards compatibility.
        Eventable.bind = Eventable.on;
        Eventable.unbind = Eventable.off;

        return Eventable;

      }));

    }, {}],
    4: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var forOwn = require('lodash.forown'),
        isFunction = require('lodash.isfunction');

      /** `Object#toString` result shortcuts */
      var argsClass = '[object Arguments]',
        arrayClass = '[object Array]',
        objectClass = '[object Object]',
        stringClass = '[object String]';

      /** Used for native method references */
      var objectProto = Object.prototype;

      /** Used to resolve the internal [[Class]] of values */
      var toString = objectProto.toString;

      /**
       * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
       * length of `0` and objects with no own enumerable properties are considered
       * "empty".
       *
       * @static
       * @memberOf _
       * @category Objects
       * @param {Array|Object|string} value The value to inspect.
       * @returns {boolean} Returns `true` if the `value` is empty, else `false`.
       * @example
       *
       * _.isEmpty([1, 2, 3]);
       * // => false
       *
       * _.isEmpty({});
       * // => true
       *
       * _.isEmpty('');
       * // => true
       */
      function isEmpty(value) {
        var result = true;
        if (!value) {
          return result;
        }
        var className = toString.call(value),
          length = value.length;

        if ((className == arrayClass || className == stringClass || className == argsClass ) ||
          (className == objectClass && typeof length == 'number' && isFunction(value.splice))) {
          return !length;
        }
        forOwn(value, function () {
          return (result = false);
        });
        return result;
      }

      module.exports = isEmpty;

    }, {"lodash.forown": 5, "lodash.isfunction": 28}],
    5: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var baseCreateCallback = require('lodash._basecreatecallback'),
        keys = require('lodash.keys'),
        objectTypes = require('lodash._objecttypes');

      /**
       * Iterates over own enumerable properties of an object, executing the callback
       * for each property. The callback is bound to `thisArg` and invoked with three
       * arguments; (value, key, object). Callbacks may exit iteration early by
       * explicitly returning `false`.
       *
       * @static
       * @memberOf _
       * @type Function
       * @category Objects
       * @param {Object} object The object to iterate over.
       * @param {Function} [callback=identity] The function called per iteration.
       * @param {*} [thisArg] The `this` binding of `callback`.
       * @returns {Object} Returns `object`.
       * @example
       *
       * _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
 *   console.log(key);
 * });
       * // => logs '0', '1', and 'length' (property order is not guaranteed across environments)
       */
      var forOwn = function (collection, callback, thisArg) {
        var index, iterable = collection, result = iterable;
        if (!iterable) return result;
        if (!objectTypes[typeof iterable]) return result;
        callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
        var ownIndex = -1,
          ownProps = objectTypes[typeof iterable] && keys(iterable),
          length = ownProps ? ownProps.length : 0;

        while (++ownIndex < length) {
          index = ownProps[ownIndex];
          if (callback(iterable[index], index, collection) === false) return result;
        }
        return result
      };

      module.exports = forOwn;

    }, {"lodash._basecreatecallback": 6, "lodash._objecttypes": 24, "lodash.keys": 25}],
    6: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var bind = require('lodash.bind'),
        identity = require('lodash.identity'),
        setBindData = require('lodash._setbinddata'),
        support = require('lodash.support');

      /** Used to detected named functions */
      var reFuncName = /^\s*function[ \n\r\t]+\w/;

      /** Used to detect functions containing a `this` reference */
      var reThis = /\bthis\b/;

      /** Native method shortcuts */
      var fnToString = Function.prototype.toString;

      /**
       * The base implementation of `_.createCallback` without support for creating
       * "_.pluck" or "_.where" style callbacks.
       *
       * @private
       * @param {*} [func=identity] The value to convert to a callback.
       * @param {*} [thisArg] The `this` binding of the created callback.
       * @param {number} [argCount] The number of arguments the callback accepts.
       * @returns {Function} Returns a callback function.
       */
      function baseCreateCallback(func, thisArg, argCount) {
        if (typeof func != 'function') {
          return identity;
        }
        // exit early for no `thisArg` or already bound by `Function#bind`
        if (typeof thisArg == 'undefined' || !('prototype' in func)) {
          return func;
        }
        var bindData = func.__bindData__;
        if (typeof bindData == 'undefined') {
          if (support.funcNames) {
            bindData = !func.name;
          }
          bindData = bindData || !support.funcDecomp;
          if (!bindData) {
            var source = fnToString.call(func);
            if (!support.funcNames) {
              bindData = !reFuncName.test(source);
            }
            if (!bindData) {
              // checks if `func` references the `this` keyword and stores the result
              bindData = reThis.test(source);
              setBindData(func, bindData);
            }
          }
        }
        // exit early if there are no `this` references or `func` is bound
        if (bindData === false || (bindData !== true && bindData[1] & 1)) {
          return func;
        }
        switch (argCount) {
          case 1:
            return function (value) {
              return func.call(thisArg, value);
            };
          case 2:
            return function (a, b) {
              return func.call(thisArg, a, b);
            };
          case 3:
            return function (value, index, collection) {
              return func.call(thisArg, value, index, collection);
            };
          case 4:
            return function (accumulator, value, index, collection) {
              return func.call(thisArg, accumulator, value, index, collection);
            };
        }
        return bind(func, thisArg);
      }

      module.exports = baseCreateCallback;

    }, {"lodash._setbinddata": 7, "lodash.bind": 10, "lodash.identity": 21, "lodash.support": 22}],
    7: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var isNative = require('lodash._isnative'),
        noop = require('lodash.noop');

      /** Used as the property descriptor for `__bindData__` */
      var descriptor = {
        'configurable': false,
        'enumerable': false,
        'value': null,
        'writable': false
      };

      /** Used to set meta data on functions */
      var defineProperty = (function () {
        // IE 8 only accepts DOM elements
        try {
          var o = {},
            func = isNative(func = Object.defineProperty) && func,
            result = func(o, o, o) && func;
        } catch (e) {
        }
        return result;
      }());

      /**
       * Sets `this` binding data on a given function.
       *
       * @private
       * @param {Function} func The function to set data on.
       * @param {Array} value The data array to set.
       */
      var setBindData = !defineProperty ? noop : function (func, value) {
        descriptor.value = value;
        defineProperty(func, '__bindData__', descriptor);
      };

      module.exports = setBindData;

    }, {"lodash._isnative": 8, "lodash.noop": 9}],
    8: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */

      /** Used for native method references */
      var objectProto = Object.prototype;

      /** Used to resolve the internal [[Class]] of values */
      var toString = objectProto.toString;

      /** Used to detect if a method is native */
      var reNative = RegExp('^' +
        String(toString)
          .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
          .replace(/toString| for [^\]]+/g, '.*?') + '$'
      );

      /**
       * Checks if `value` is a native function.
       *
       * @private
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if the `value` is a native function, else `false`.
       */
      function isNative(value) {
        return typeof value == 'function' && reNative.test(value);
      }

      module.exports = isNative;

    }, {}],
    9: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */

      /**
       * A no-operation function.
       *
       * @static
       * @memberOf _
       * @category Utilities
       * @example
       *
       * var object = { 'name': 'fred' };
       * _.noop(object) === undefined;
       * // => true
       */
      function noop() {
        // no operation performed
      }

      module.exports = noop;

    }, {}],
    10: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var createWrapper = require('lodash._createwrapper'),
        slice = require('lodash._slice');

      /**
       * Creates a function that, when called, invokes `func` with the `this`
       * binding of `thisArg` and prepends any additional `bind` arguments to those
       * provided to the bound function.
       *
       * @static
       * @memberOf _
       * @category Functions
       * @param {Function} func The function to bind.
       * @param {*} [thisArg] The `this` binding of `func`.
       * @param {...*} [arg] Arguments to be partially applied.
       * @returns {Function} Returns the new bound function.
       * @example
       *
       * var func = function(greeting) {
 *   return greeting + ' ' + this.name;
 * };
       *
       * func = _.bind(func, { 'name': 'fred' }, 'hi');
       * func();
       * // => 'hi fred'
       */
      function bind(func, thisArg) {
        return arguments.length > 2
          ? createWrapper(func, 17, slice(arguments, 2), null, thisArg)
          : createWrapper(func, 1, null, null, thisArg);
      }

      module.exports = bind;

    }, {"lodash._createwrapper": 11, "lodash._slice": 20}],
    11: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var baseBind = require('lodash._basebind'),
        baseCreateWrapper = require('lodash._basecreatewrapper'),
        isFunction = require('lodash.isfunction'),
        slice = require('lodash._slice');

      /**
       * Used for `Array` method references.
       *
       * Normally `Array.prototype` would suffice, however, using an array literal
       * avoids issues in Narwhal.
       */
      var arrayRef = [];

      /** Native method shortcuts */
      var push = arrayRef.push,
        unshift = arrayRef.unshift;

      /**
       * Creates a function that, when called, either curries or invokes `func`
       * with an optional `this` binding and partially applied arguments.
       *
       * @private
       * @param {Function|string} func The function or method name to reference.
       * @param {number} bitmask The bitmask of method flags to compose.
       *  The bitmask may be composed of the following flags:
       *  1 - `_.bind`
       *  2 - `_.bindKey`
       *  4 - `_.curry`
       *  8 - `_.curry` (bound)
       *  16 - `_.partial`
       *  32 - `_.partialRight`
       * @param {Array} [partialArgs] An array of arguments to prepend to those
       *  provided to the new function.
       * @param {Array} [partialRightArgs] An array of arguments to append to those
       *  provided to the new function.
       * @param {*} [thisArg] The `this` binding of `func`.
       * @param {number} [arity] The arity of `func`.
       * @returns {Function} Returns the new function.
       */
      function createWrapper(func, bitmask, partialArgs, partialRightArgs, thisArg, arity) {
        var isBind = bitmask & 1,
          isBindKey = bitmask & 2,
          isCurry = bitmask & 4,
          isCurryBound = bitmask & 8,
          isPartial = bitmask & 16,
          isPartialRight = bitmask & 32;

        if (!isBindKey && !isFunction(func)) {
          throw new TypeError;
        }
        if (isPartial && !partialArgs.length) {
          bitmask &= ~16;
          isPartial = partialArgs = false;
        }
        if (isPartialRight && !partialRightArgs.length) {
          bitmask &= ~32;
          isPartialRight = partialRightArgs = false;
        }
        var bindData = func && func.__bindData__;
        if (bindData && bindData !== true) {
          // clone `bindData`
          bindData = slice(bindData);
          if (bindData[2]) {
            bindData[2] = slice(bindData[2]);
          }
          if (bindData[3]) {
            bindData[3] = slice(bindData[3]);
          }
          // set `thisBinding` is not previously bound
          if (isBind && !(bindData[1] & 1)) {
            bindData[4] = thisArg;
          }
          // set if previously bound but not currently (subsequent curried functions)
          if (!isBind && bindData[1] & 1) {
            bitmask |= 8;
          }
          // set curried arity if not yet set
          if (isCurry && !(bindData[1] & 4)) {
            bindData[5] = arity;
          }
          // append partial left arguments
          if (isPartial) {
            push.apply(bindData[2] || (bindData[2] = []), partialArgs);
          }
          // append partial right arguments
          if (isPartialRight) {
            unshift.apply(bindData[3] || (bindData[3] = []), partialRightArgs);
          }
          // merge flags
          bindData[1] |= bitmask;
          return createWrapper.apply(null, bindData);
        }
        // fast path for `_.bind`
        var creater = (bitmask == 1 || bitmask === 17) ? baseBind : baseCreateWrapper;
        return creater([func, bitmask, partialArgs, partialRightArgs, thisArg, arity]);
      }

      module.exports = createWrapper;

    }, {"lodash._basebind": 12, "lodash._basecreatewrapper": 16, "lodash._slice": 20, "lodash.isfunction": 28}],
    12: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var baseCreate = require('lodash._basecreate'),
        isObject = require('lodash.isobject'),
        setBindData = require('lodash._setbinddata'),
        slice = require('lodash._slice');

      /**
       * Used for `Array` method references.
       *
       * Normally `Array.prototype` would suffice, however, using an array literal
       * avoids issues in Narwhal.
       */
      var arrayRef = [];

      /** Native method shortcuts */
      var push = arrayRef.push;

      /**
       * The base implementation of `_.bind` that creates the bound function and
       * sets its meta data.
       *
       * @private
       * @param {Array} bindData The bind data array.
       * @returns {Function} Returns the new bound function.
       */
      function baseBind(bindData) {
        var func = bindData[0],
          partialArgs = bindData[2],
          thisArg = bindData[4];

        function bound() {
          // `Function#bind` spec
          // http://es5.github.io/#x15.3.4.5
          if (partialArgs) {
            // avoid `arguments` object deoptimizations by using `slice` instead
            // of `Array.prototype.slice.call` and not assigning `arguments` to a
            // variable as a ternary expression
            var args = slice(partialArgs);
            push.apply(args, arguments);
          }
          // mimic the constructor's `return` behavior
          // http://es5.github.io/#x13.2.2
          if (this instanceof bound) {
            // ensure `new bound` is an instance of `func`
            var thisBinding = baseCreate(func.prototype),
              result = func.apply(thisBinding, args || arguments);
            return isObject(result) ? result : thisBinding;
          }
          return func.apply(thisArg, args || arguments);
        }

        setBindData(bound, bindData);
        return bound;
      }

      module.exports = baseBind;

    }, {"lodash._basecreate": 13, "lodash._setbinddata": 7, "lodash._slice": 20, "lodash.isobject": 29}],
    13: [function (require, module, exports) {
      (function (global) {
        /**
         * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
         * Build: `lodash modularize modern exports="npm" -o ./npm/`
         * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
         * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
         * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
         * Available under MIT license <http://lodash.com/license>
         */
        var isNative = require('lodash._isnative'),
          isObject = require('lodash.isobject'),
          noop = require('lodash.noop');

        /* Native method shortcuts for methods with the same name as other `lodash` methods */
        var nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate;

        /**
         * The base implementation of `_.create` without support for assigning
         * properties to the created object.
         *
         * @private
         * @param {Object} prototype The object to inherit from.
         * @returns {Object} Returns the new object.
         */
        function baseCreate(prototype, properties) {
          return isObject(prototype) ? nativeCreate(prototype) : {};
        }

// fallback for browsers without `Object.create`
        if (!nativeCreate) {
          baseCreate = (function () {
            function Object() {
            }

            return function (prototype) {
              if (isObject(prototype)) {
                Object.prototype = prototype;
                var result = new Object;
                Object.prototype = null;
              }
              return result || global.Object();
            };
          }());
        }

        module.exports = baseCreate;

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"lodash._isnative": 14, "lodash.isobject": 29, "lodash.noop": 15}],
    14: [function (require, module, exports) {
      arguments[4][8][0].apply(exports, arguments)
    }, {"dup": 8}],
    15: [function (require, module, exports) {
      arguments[4][9][0].apply(exports, arguments)
    }, {"dup": 9}],
    16: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var baseCreate = require('lodash._basecreate'),
        isObject = require('lodash.isobject'),
        setBindData = require('lodash._setbinddata'),
        slice = require('lodash._slice');

      /**
       * Used for `Array` method references.
       *
       * Normally `Array.prototype` would suffice, however, using an array literal
       * avoids issues in Narwhal.
       */
      var arrayRef = [];

      /** Native method shortcuts */
      var push = arrayRef.push;

      /**
       * The base implementation of `createWrapper` that creates the wrapper and
       * sets its meta data.
       *
       * @private
       * @param {Array} bindData The bind data array.
       * @returns {Function} Returns the new function.
       */
      function baseCreateWrapper(bindData) {
        var func = bindData[0],
          bitmask = bindData[1],
          partialArgs = bindData[2],
          partialRightArgs = bindData[3],
          thisArg = bindData[4],
          arity = bindData[5];

        var isBind = bitmask & 1,
          isBindKey = bitmask & 2,
          isCurry = bitmask & 4,
          isCurryBound = bitmask & 8,
          key = func;

        function bound() {
          var thisBinding = isBind ? thisArg : this;
          if (partialArgs) {
            var args = slice(partialArgs);
            push.apply(args, arguments);
          }
          if (partialRightArgs || isCurry) {
            args || (args = slice(arguments));
            if (partialRightArgs) {
              push.apply(args, partialRightArgs);
            }
            if (isCurry && args.length < arity) {
              bitmask |= 16 & ~32;
              return baseCreateWrapper([func, (isCurryBound ? bitmask : bitmask & ~3), args, null, thisArg, arity]);
            }
          }
          args || (args = arguments);
          if (isBindKey) {
            func = thisBinding[key];
          }
          if (this instanceof bound) {
            thisBinding = baseCreate(func.prototype);
            var result = func.apply(thisBinding, args);
            return isObject(result) ? result : thisBinding;
          }
          return func.apply(thisBinding, args);
        }

        setBindData(bound, bindData);
        return bound;
      }

      module.exports = baseCreateWrapper;

    }, {"lodash._basecreate": 17, "lodash._setbinddata": 7, "lodash._slice": 20, "lodash.isobject": 29}],
    17: [function (require, module, exports) {
      arguments[4][13][0].apply(exports, arguments)
    }, {"dup": 13, "lodash._isnative": 18, "lodash.isobject": 29, "lodash.noop": 19}],
    18: [function (require, module, exports) {
      arguments[4][8][0].apply(exports, arguments)
    }, {"dup": 8}],
    19: [function (require, module, exports) {
      arguments[4][9][0].apply(exports, arguments)
    }, {"dup": 9}],
    20: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */

      /**
       * Slices the `collection` from the `start` index up to, but not including,
       * the `end` index.
       *
       * Note: This function is used instead of `Array#slice` to support node lists
       * in IE < 9 and to ensure dense arrays are returned.
       *
       * @private
       * @param {Array|Object|string} collection The collection to slice.
       * @param {number} start The start index.
       * @param {number} end The end index.
       * @returns {Array} Returns the new array.
       */
      function slice(array, start, end) {
        start || (start = 0);
        if (typeof end == 'undefined') {
          end = array ? array.length : 0;
        }
        var index = -1,
          length = end - start || 0,
          result = Array(length < 0 ? 0 : length);

        while (++index < length) {
          result[index] = array[start + index];
        }
        return result;
      }

      module.exports = slice;

    }, {}],
    21: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */

      /**
       * This method returns the first argument provided to it.
       *
       * @static
       * @memberOf _
       * @category Utilities
       * @param {*} value Any value.
       * @returns {*} Returns `value`.
       * @example
       *
       * var object = { 'name': 'fred' };
       * _.identity(object) === object;
       * // => true
       */
      function identity(value) {
        return value;
      }

      module.exports = identity;

    }, {}],
    22: [function (require, module, exports) {
      (function (global) {
        /**
         * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
         * Build: `lodash modularize modern exports="npm" -o ./npm/`
         * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
         * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
         * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
         * Available under MIT license <http://lodash.com/license>
         */
        var isNative = require('lodash._isnative');

        /** Used to detect functions containing a `this` reference */
        var reThis = /\bthis\b/;

        /**
         * An object used to flag environments features.
         *
         * @static
         * @memberOf _
         * @type Object
         */
        var support = {};

        /**
         * Detect if functions can be decompiled by `Function#toString`
         * (all but PS3 and older Opera mobile browsers & avoided in Windows 8 apps).
         *
         * @memberOf _.support
         * @type boolean
         */
        support.funcDecomp = !isNative(global.WinRTError) && reThis.test(function () {
            return this;
          });

        /**
         * Detect if `Function#name` is supported (all but IE).
         *
         * @memberOf _.support
         * @type boolean
         */
        support.funcNames = typeof Function.name == 'string';

        module.exports = support;

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"lodash._isnative": 23}],
    23: [function (require, module, exports) {
      arguments[4][8][0].apply(exports, arguments)
    }, {"dup": 8}],
    24: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */

      /** Used to determine if values are of the language type Object */
      var objectTypes = {
        'boolean': false,
        'function': true,
        'object': true,
        'number': false,
        'string': false,
        'undefined': false
      };

      module.exports = objectTypes;

    }, {}],
    25: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var isNative = require('lodash._isnative'),
        isObject = require('lodash.isobject'),
        shimKeys = require('lodash._shimkeys');

      /* Native method shortcuts for methods with the same name as other `lodash` methods */
      var nativeKeys = isNative(nativeKeys = Object.keys) && nativeKeys;

      /**
       * Creates an array composed of the own enumerable property names of an object.
       *
       * @static
       * @memberOf _
       * @category Objects
       * @param {Object} object The object to inspect.
       * @returns {Array} Returns an array of property names.
       * @example
       *
       * _.keys({ 'one': 1, 'two': 2, 'three': 3 });
       * // => ['one', 'two', 'three'] (property order is not guaranteed across environments)
       */
      var keys = !nativeKeys ? shimKeys : function (object) {
        if (!isObject(object)) {
          return [];
        }
        return nativeKeys(object);
      };

      module.exports = keys;

    }, {"lodash._isnative": 26, "lodash._shimkeys": 27, "lodash.isobject": 29}],
    26: [function (require, module, exports) {
      arguments[4][8][0].apply(exports, arguments)
    }, {"dup": 8}],
    27: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var objectTypes = require('lodash._objecttypes');

      /** Used for native method references */
      var objectProto = Object.prototype;

      /** Native method shortcuts */
      var hasOwnProperty = objectProto.hasOwnProperty;

      /**
       * A fallback implementation of `Object.keys` which produces an array of the
       * given object's own enumerable property names.
       *
       * @private
       * @type Function
       * @param {Object} object The object to inspect.
       * @returns {Array} Returns an array of property names.
       */
      var shimKeys = function (object) {
        var index, iterable = object, result = [];
        if (!iterable) return result;
        if (!(objectTypes[typeof object])) return result;
        for (index in iterable) {
          if (hasOwnProperty.call(iterable, index)) {
            result.push(index);
          }
        }
        return result
      };

      module.exports = shimKeys;

    }, {"lodash._objecttypes": 24}],
    28: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */

      /**
       * Checks if `value` is a function.
       *
       * @static
       * @memberOf _
       * @category Objects
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if the `value` is a function, else `false`.
       * @example
       *
       * _.isFunction(_);
       * // => true
       */
      function isFunction(value) {
        return typeof value == 'function';
      }

      module.exports = isFunction;

    }, {}],
    29: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var objectTypes = require('lodash._objecttypes');

      /**
       * Checks if `value` is the language type of Object.
       * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
       *
       * @static
       * @memberOf _
       * @category Objects
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if the `value` is an object, else `false`.
       * @example
       *
       * _.isObject({});
       * // => true
       *
       * _.isObject([1, 2, 3]);
       * // => true
       *
       * _.isObject(1);
       * // => false
       */
      function isObject(value) {
        // check if the value is the ECMAScript language type of Object
        // http://es5.github.io/#x8
        // and avoid a V8 bug
        // http://code.google.com/p/v8/issues/detail?id=2291
        return !!(value && objectTypes[typeof value]);
      }

      module.exports = isObject;

    }, {"lodash._objecttypes": 30}],
    30: [function (require, module, exports) {
      arguments[4][24][0].apply(exports, arguments)
    }, {"dup": 24}],
    31: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */

      /** `Object#toString` result shortcuts */
      var stringClass = '[object String]';

      /** Used for native method references */
      var objectProto = Object.prototype;

      /** Used to resolve the internal [[Class]] of values */
      var toString = objectProto.toString;

      /**
       * Checks if `value` is a string.
       *
       * @static
       * @memberOf _
       * @category Objects
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if the `value` is a string, else `false`.
       * @example
       *
       * _.isString('fred');
       * // => true
       */
      function isString(value) {
        return typeof value == 'string' ||
          value && typeof value == 'object' && toString.call(value) == stringClass || false;
      }

      module.exports = isString;

    }, {}],
    32: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */

      /**
       * Checks if `value` is `undefined`.
       *
       * @static
       * @memberOf _
       * @category Objects
       * @param {*} value The value to check.
       * @returns {boolean} Returns `true` if the `value` is `undefined`, else `false`.
       * @example
       *
       * _.isUndefined(void 0);
       * // => true
       */
      function isUndefined(value) {
        return typeof value == 'undefined';
      }

      module.exports = isUndefined;

    }, {}],
    33: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var isFunction = require('lodash.isfunction');

      /**
       * Resolves the value of property `key` on `object`. If `key` is a function
       * it will be invoked with the `this` binding of `object` and its result returned,
       * else the property value is returned. If `object` is falsey then `undefined`
       * is returned.
       *
       * @static
       * @memberOf _
       * @category Utilities
       * @param {Object} object The object to inspect.
       * @param {string} key The name of the property to resolve.
       * @returns {*} Returns the resolved value.
       * @example
       *
       * var object = {
 *   'cheese': 'crumpets',
 *   'stuff': function() {
 *     return 'nonsense';
 *   }
 * };
       *
       * _.result(object, 'cheese');
       * // => 'crumpets'
       *
       * _.result(object, 'stuff');
       * // => 'nonsense'
       */
      function result(object, key) {
        if (object) {
          var value = object[key];
          return isFunction(value) ? object[key]() : value;
        }
      }

      module.exports = result;

    }, {"lodash.isfunction": 28}],
    34: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var defaults = require('lodash.defaults'),
        escape = require('lodash.escape'),
        escapeStringChar = require('lodash._escapestringchar'),
        keys = require('lodash.keys'),
        reInterpolate = require('lodash._reinterpolate'),
        templateSettings = require('lodash.templatesettings'),
        values = require('lodash.values');

      /** Used to match empty string literals in compiled template source */
      var reEmptyStringLeading = /\b__p \+= '';/g,
        reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
        reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;

      /**
       * Used to match ES6 template delimiters
       * http://people.mozilla.org/~jorendorff/es6-draft.html#sec-literals-string-literals
       */
      var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;

      /** Used to ensure capturing order of template delimiters */
      var reNoMatch = /($^)/;

      /** Used to match unescaped characters in compiled string literals */
      var reUnescapedString = /['\n\r\t\u2028\u2029\\]/g;

      /**
       * A micro-templating method that handles arbitrary delimiters, preserves
       * whitespace, and correctly escapes quotes within interpolated code.
       *
       * Note: In the development build, `_.template` utilizes sourceURLs for easier
       * debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
       *
       * For more information on precompiling templates see:
       * http://lodash.com/custom-builds
       *
       * For more information on Chrome extension sandboxes see:
       * http://developer.chrome.com/stable/extensions/sandboxingEval.html
       *
       * @static
       * @memberOf _
       * @category Utilities
       * @param {string} text The template text.
       * @param {Object} data The data object used to populate the text.
       * @param {Object} [options] The options object.
       * @param {RegExp} [options.escape] The "escape" delimiter.
       * @param {RegExp} [options.evaluate] The "evaluate" delimiter.
       * @param {Object} [options.imports] An object to import into the template as local variables.
       * @param {RegExp} [options.interpolate] The "interpolate" delimiter.
       * @param {string} [sourceURL] The sourceURL of the template's compiled source.
       * @param {string} [variable] The data object variable name.
       * @returns {Function|string} Returns a compiled function when no `data` object
       *  is given, else it returns the interpolated text.
       * @example
       *
       * // using the "interpolate" delimiter to create a compiled template
       * var compiled = _.template('hello <%= name %>');
       * compiled({ 'name': 'fred' });
       * // => 'hello fred'
       *
       * // using the "escape" delimiter to escape HTML in data property values
       * _.template('<b><%- value %></b>', { 'value': '<script>' });
       * // => '<b>&lt;script&gt;</b>'
       *
       * // using the "evaluate" delimiter to generate HTML
       * var list = '<% _.forEach(people, function(name) { %><li><%- name %></li><% }); %>';
       * _.template(list, { 'people': ['fred', 'barney'] });
       * // => '<li>fred</li><li>barney</li>'
       *
       * // using the ES6 delimiter as an alternative to the default "interpolate" delimiter
       * _.template('hello ${ name }', { 'name': 'pebbles' });
       * // => 'hello pebbles'
       *
       * // using the internal `print` function in "evaluate" delimiters
       * _.template('<% print("hello " + name); %>!', { 'name': 'barney' });
       * // => 'hello barney!'
       *
       * // using a custom template delimiters
       * _.templateSettings = {
 *   'interpolate': /{{([\s\S]+?)}}/g
 * };
       *
       * _.template('hello {{ name }}!', { 'name': 'mustache' });
       * // => 'hello mustache!'
       *
       * // using the `imports` option to import jQuery
       * var list = '<% jq.each(people, function(name) { %><li><%- name %></li><% }); %>';
       * _.template(list, { 'people': ['fred', 'barney'] }, { 'imports': { 'jq': jQuery } });
       * // => '<li>fred</li><li>barney</li>'
       *
       * // using the `sourceURL` option to specify a custom sourceURL for the template
       * var compiled = _.template('hello <%= name %>', null, { 'sourceURL': '/basic/greeting.jst' });
       * compiled(data);
       * // => find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector
       *
       * // using the `variable` option to ensure a with-statement isn't used in the compiled template
       * var compiled = _.template('hi <%= data.name %>!', null, { 'variable': 'data' });
       * compiled.source;
       * // => function(data) {
 *   var __t, __p = '', __e = _.escape;
 *   __p += 'hi ' + ((__t = ( data.name )) == null ? '' : __t) + '!';
 *   return __p;
 * }
       *
       * // using the `source` property to inline compiled templates for meaningful
       * // line numbers in error messages and a stack trace
       * fs.writeFileSync(path.join(cwd, 'jst.js'), '\
       *   var JST = {\
 *     "main": ' + _.template(mainText).source + '\
 *   };\
       * ');
       */
      function template(text, data, options) {
        // based on John Resig's `tmpl` implementation
        // http://ejohn.org/blog/javascript-micro-templating/
        // and Laura Doktorova's doT.js
        // https://github.com/olado/doT
        var settings = templateSettings.imports._.templateSettings || templateSettings;
        text = String(text || '');

        // avoid missing dependencies when `iteratorTemplate` is not defined
        options = defaults({}, options, settings);

        var imports = defaults({}, options.imports, settings.imports),
          importsKeys = keys(imports),
          importsValues = values(imports);

        var isEvaluating,
          index = 0,
          interpolate = options.interpolate || reNoMatch,
          source = "__p += '";

        // compile the regexp to match each delimiter
        var reDelimiters = RegExp(
          (options.escape || reNoMatch).source + '|' +
          interpolate.source + '|' +
          (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +
          (options.evaluate || reNoMatch).source + '|$'
          , 'g');

        text.replace(reDelimiters, function (match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
          interpolateValue || (interpolateValue = esTemplateValue);

          // escape characters that cannot be included in string literals
          source += text.slice(index, offset).replace(reUnescapedString, escapeStringChar);

          // replace delimiters with snippets
          if (escapeValue) {
            source += "' +\n__e(" + escapeValue + ") +\n'";
          }
          if (evaluateValue) {
            isEvaluating = true;
            source += "';\n" + evaluateValue + ";\n__p += '";
          }
          if (interpolateValue) {
            source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
          }
          index = offset + match.length;

          // the JS engine embedded in Adobe products requires returning the `match`
          // string in order to produce the correct `offset` value
          return match;
        });

        source += "';\n";

        // if `variable` is not specified, wrap a with-statement around the generated
        // code to add the data object to the top of the scope chain
        var variable = options.variable,
          hasVariable = variable;

        if (!hasVariable) {
          variable = 'obj';
          source = 'with (' + variable + ') {\n' + source + '\n}\n';
        }
        // cleanup code by stripping empty strings
        source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
          .replace(reEmptyStringMiddle, '$1')
          .replace(reEmptyStringTrailing, '$1;');

        // frame code as the function body
        source = 'function(' + variable + ') {\n' +
          (hasVariable ? '' : variable + ' || (' + variable + ' = {});\n') +
          "var __t, __p = '', __e = _.escape" +
          (isEvaluating
              ? ', __j = Array.prototype.join;\n' +
            "function print() { __p += __j.call(arguments, '') }\n"
              : ';\n'
          ) +
          source +
          'return __p\n}';

        try {
          var result = Function(importsKeys, 'return ' + source).apply(undefined, importsValues);
        } catch (e) {
          e.source = source;
          throw e;
        }
        if (data) {
          return result(data);
        }
        // provide the compiled function's source by its `toString` method, in
        // supported environments, or the `source` property as a convenience for
        // inlining compiled templates during the build process
        result.source = source;
        return result;
      }

      module.exports = template;

    }, {
      "lodash._escapestringchar": 35,
      "lodash._reinterpolate": 36,
      "lodash.defaults": 37,
      "lodash.escape": 39,
      "lodash.keys": 44,
      "lodash.templatesettings": 48,
      "lodash.values": 49
    }],
    35: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */

      /** Used to escape characters for inclusion in compiled string literals */
      var stringEscapes = {
        '\\': '\\',
        "'": "'",
        '\n': 'n',
        '\r': 'r',
        '\t': 't',
        '\u2028': 'u2028',
        '\u2029': 'u2029'
      };

      /**
       * Used by `template` to escape characters for inclusion in compiled
       * string literals.
       *
       * @private
       * @param {string} match The matched character to escape.
       * @returns {string} Returns the escaped character.
       */
      function escapeStringChar(match) {
        return '\\' + stringEscapes[match];
      }

      module.exports = escapeStringChar;

    }, {}],
    36: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */

      /** Used to match "interpolate" template delimiters */
      var reInterpolate = /<%=([\s\S]+?)%>/g;

      module.exports = reInterpolate;

    }, {}],
    37: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var keys = require('lodash.keys'),
        objectTypes = require('lodash._objecttypes');

      /**
       * Assigns own enumerable properties of source object(s) to the destination
       * object for all destination properties that resolve to `undefined`. Once a
       * property is set, additional defaults of the same property will be ignored.
       *
       * @static
       * @memberOf _
       * @type Function
       * @category Objects
       * @param {Object} object The destination object.
       * @param {...Object} [source] The source objects.
       * @param- {Object} [guard] Allows working with `_.reduce` without using its
       *  `key` and `object` arguments as sources.
       * @returns {Object} Returns the destination object.
       * @example
       *
       * var object = { 'name': 'barney' };
       * _.defaults(object, { 'name': 'fred', 'employer': 'slate' });
       * // => { 'name': 'barney', 'employer': 'slate' }
       */
      var defaults = function (object, source, guard) {
        var index, iterable = object, result = iterable;
        if (!iterable) return result;
        var args = arguments,
          argsIndex = 0,
          argsLength = typeof guard == 'number' ? 2 : args.length;
        while (++argsIndex < argsLength) {
          iterable = args[argsIndex];
          if (iterable && objectTypes[typeof iterable]) {
            var ownIndex = -1,
              ownProps = objectTypes[typeof iterable] && keys(iterable),
              length = ownProps ? ownProps.length : 0;

            while (++ownIndex < length) {
              index = ownProps[ownIndex];
              if (typeof result[index] == 'undefined') result[index] = iterable[index];
            }
          }
        }
        return result
      };

      module.exports = defaults;

    }, {"lodash._objecttypes": 38, "lodash.keys": 44}],
    38: [function (require, module, exports) {
      arguments[4][24][0].apply(exports, arguments)
    }, {"dup": 24}],
    39: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var escapeHtmlChar = require('lodash._escapehtmlchar'),
        keys = require('lodash.keys'),
        reUnescapedHtml = require('lodash._reunescapedhtml');

      /**
       * Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their
       * corresponding HTML entities.
       *
       * @static
       * @memberOf _
       * @category Utilities
       * @param {string} string The string to escape.
       * @returns {string} Returns the escaped string.
       * @example
       *
       * _.escape('Fred, Wilma, & Pebbles');
       * // => 'Fred, Wilma, &amp; Pebbles'
       */
      function escape(string) {
        return string == null ? '' : String(string).replace(reUnescapedHtml, escapeHtmlChar);
      }

      module.exports = escape;

    }, {"lodash._escapehtmlchar": 40, "lodash._reunescapedhtml": 42, "lodash.keys": 44}],
    40: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var htmlEscapes = require('lodash._htmlescapes');

      /**
       * Used by `escape` to convert characters to HTML entities.
       *
       * @private
       * @param {string} match The matched character to escape.
       * @returns {string} Returns the escaped character.
       */
      function escapeHtmlChar(match) {
        return htmlEscapes[match];
      }

      module.exports = escapeHtmlChar;

    }, {"lodash._htmlescapes": 41}],
    41: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */

      /**
       * Used to convert characters to HTML entities:
       *
       * Though the `>` character is escaped for symmetry, characters like `>` and `/`
       * don't require escaping in HTML and have no special meaning unless they're part
       * of a tag or an unquoted attribute value.
       * http://mathiasbynens.be/notes/ambiguous-ampersands (under "semi-related fun fact")
       */
      var htmlEscapes = {
        '&': '&amp;',
        '<': '&lt;',
        '>': '&gt;',
        '"': '&quot;',
        "'": '&#39;'
      };

      module.exports = htmlEscapes;

    }, {}],
    42: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var htmlEscapes = require('lodash._htmlescapes'),
        keys = require('lodash.keys');

      /** Used to match HTML entities and HTML characters */
      var reUnescapedHtml = RegExp('[' + keys(htmlEscapes).join('') + ']', 'g');

      module.exports = reUnescapedHtml;

    }, {"lodash._htmlescapes": 43, "lodash.keys": 44}],
    43: [function (require, module, exports) {
      arguments[4][41][0].apply(exports, arguments)
    }, {"dup": 41}],
    44: [function (require, module, exports) {
      arguments[4][25][0].apply(exports, arguments)
    }, {"dup": 25, "lodash._isnative": 45, "lodash._shimkeys": 46, "lodash.isobject": 29}],
    45: [function (require, module, exports) {
      arguments[4][8][0].apply(exports, arguments)
    }, {"dup": 8}],
    46: [function (require, module, exports) {
      arguments[4][27][0].apply(exports, arguments)
    }, {"dup": 27, "lodash._objecttypes": 47}],
    47: [function (require, module, exports) {
      arguments[4][24][0].apply(exports, arguments)
    }, {"dup": 24}],
    48: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var escape = require('lodash.escape'),
        reInterpolate = require('lodash._reinterpolate');

      /**
       * By default, the template delimiters used by Lo-Dash are similar to those in
       * embedded Ruby (ERB). Change the following template settings to use alternative
       * delimiters.
       *
       * @static
       * @memberOf _
       * @type Object
       */
      var templateSettings = {

        /**
         * Used to detect `data` property values to be HTML-escaped.
         *
         * @memberOf _.templateSettings
         * @type RegExp
         */
        'escape': /<%-([\s\S]+?)%>/g,

        /**
         * Used to detect code to be evaluated.
         *
         * @memberOf _.templateSettings
         * @type RegExp
         */
        'evaluate': /<%([\s\S]+?)%>/g,

        /**
         * Used to detect `data` property values to inject.
         *
         * @memberOf _.templateSettings
         * @type RegExp
         */
        'interpolate': reInterpolate,

        /**
         * Used to reference the data object in the template text.
         *
         * @memberOf _.templateSettings
         * @type string
         */
        'variable': '',

        /**
         * Used to import variables into the compiled template.
         *
         * @memberOf _.templateSettings
         * @type Object
         */
        'imports': {

          /**
           * A reference to the `lodash` function.
           *
           * @memberOf _.templateSettings.imports
           * @type Function
           */
          '_': {'escape': escape}
        }
      };

      module.exports = templateSettings;

    }, {"lodash._reinterpolate": 36, "lodash.escape": 39}],
    49: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */
      var keys = require('lodash.keys');

      /**
       * Creates an array composed of the own enumerable property values of `object`.
       *
       * @static
       * @memberOf _
       * @category Objects
       * @param {Object} object The object to inspect.
       * @returns {Array} Returns an array of property values.
       * @example
       *
       * _.values({ 'one': 1, 'two': 2, 'three': 3 });
       * // => [1, 2, 3] (property order is not guaranteed across environments)
       */
      function values(object) {
        var index = -1,
          props = keys(object),
          length = props.length,
          result = Array(length);

        while (++index < length) {
          result[index] = object[props[index]];
        }
        return result;
      }

      module.exports = values;

    }, {"lodash.keys": 44}],
    50: [function (require, module, exports) {
      /**
       * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
       * Build: `lodash modularize modern exports="npm" -o ./npm/`
       * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
       * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
       * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
       * Available under MIT license <http://lodash.com/license>
       */

      /** Used to generate unique IDs */
      var idCounter = 0;

      /**
       * Generates a unique ID. If `prefix` is provided the ID will be appended to it.
       *
       * @static
       * @memberOf _
       * @category Utilities
       * @param {string} [prefix] The value to prefix the ID with.
       * @returns {string} Returns the unique ID.
       * @example
       *
       * _.uniqueId('contact_');
       * // => 'contact_104'
       *
       * _.uniqueId();
       * // => '105'
       */
      function uniqueId(prefix) {
        var id = ++idCounter;
        return String(prefix == null ? '' : prefix) + id;
      }

      module.exports = uniqueId;

    }, {}],
    51: [function (require, module, exports) {
      'use strict';

// modified from https://github.com/es-shims/es6-shim
      var keys = require('object-keys');
      var canBeObject = function (obj) {
        return typeof obj !== 'undefined' && obj !== null;
      };

      var assignShim = function assign(target, source1) {
        if (!canBeObject(target)) {
          throw new TypeError('target must be an object');
        }
        var objTarget = Object(target);
        var s, source, i, props;
        for (s = 1; s < arguments.length; ++s) {
          source = Object(arguments[s]);
          props = keys(source);
          for (i = 0; i < props.length; ++i) {
            objTarget[props[i]] = source[props[i]];
          }
        }
        return objTarget;
      };

      assignShim.shim = function shimObjectAssign() {
        if (!Object.assign) {
          Object.assign = assignShim;
        }
        return Object.assign || assignShim;
      };

      module.exports = assignShim;


    }, {"object-keys": 52}],
    52: [function (require, module, exports) {
      'use strict';

// modified from https://github.com/es-shims/es5-shim
      var has = Object.prototype.hasOwnProperty;
      var toStr = Object.prototype.toString;
      var isArgs = require('./isArguments');
      var hasDontEnumBug = !({'toString': null}).propertyIsEnumerable('toString');
      var hasProtoEnumBug = function () {
      }.propertyIsEnumerable('prototype');
      var dontEnums = [
        'toString',
        'toLocaleString',
        'valueOf',
        'hasOwnProperty',
        'isPrototypeOf',
        'propertyIsEnumerable',
        'constructor'
      ];

      var keysShim = function keys(object) {
        var isObject = object !== null && typeof object === 'object';
        var isFunction = toStr.call(object) === '[object Function]';
        var isArguments = isArgs(object);
        var isString = isObject && toStr.call(object) === '[object String]';
        var theKeys = [];

        if (!isObject && !isFunction && !isArguments) {
          throw new TypeError('Object.keys called on a non-object');
        }

        var skipProto = hasProtoEnumBug && isFunction;
        if (isString && object.length > 0 && !has.call(object, 0)) {
          for (var i = 0; i < object.length; ++i) {
            theKeys.push(String(i));
          }
        }

        if (isArguments && object.length > 0) {
          for (var j = 0; j < object.length; ++j) {
            theKeys.push(String(j));
          }
        } else {
          for (var name in object) {
            if (!(skipProto && name === 'prototype') && has.call(object, name)) {
              theKeys.push(String(name));
            }
          }
        }

        if (hasDontEnumBug) {
          var ctor = object.constructor;
          var skipConstructor = ctor && ctor.prototype === object;

          for (var k = 0; k < dontEnums.length; ++k) {
            if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
              theKeys.push(dontEnums[k]);
            }
          }
        }
        return theKeys;
      };

      keysShim.shim = function shimObjectKeys() {
        if (!Object.keys) {
          Object.keys = keysShim;
        }
        return Object.keys || keysShim;
      };

      module.exports = keysShim;

    }, {"./isArguments": 53}],
    53: [function (require, module, exports) {
      'use strict';

      var toStr = Object.prototype.toString;

      module.exports = function isArguments(value) {
        var str = toStr.call(value);
        var isArgs = str === '[object Arguments]';
        if (!isArgs) {
          isArgs = str !== '[object Array]'
            && value !== null
            && typeof value === 'object'
            && typeof value.length === 'number'
            && value.length >= 0
            && toStr.call(value.callee) === '[object Function]';
        }
        return isArgs;
      };

    }, {}],
    54: [function (require, module, exports) {
      /**
       *  Copyright (c) 2014, 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) {
        typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
          typeof define === 'function' && define.amd ? define(factory) :
            global.Immutable = factory()
      }(this, function () {
        'use strict';
        var SLICE$0 = Array.prototype.slice;

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

        // 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) {
          return index >= 0 ? (+index) : ensureSize(iter) + (+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);
        }

        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__@@';

        /* 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.of = function (/*...values*/) {
          return KeyedSeq(arguments);
        };

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

        KeyedSeq.prototype.toSeq = 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;


        // #pragma Root Sequences

        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);
        }

        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;

        /**
         * 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();
          }
          return typeof valueA.equals === 'function' &&
          typeof valueB.equals === 'function' ?
            valueA.equals(valueB) :
          valueA === valueB || (valueA !== valueA && valueB !== valueB);
        }

        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;
        }

        var Math__imul =
          typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2 ?
            Math.imul :
            function Math__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();
          }
          return hashJSObj(o);
        }

        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 = weakMap && weakMap.get(obj);
          if (hash) return hash;

          hash = obj[UID_HASH_KEY];
          if (hash) return hash;

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

            hash = getIENodeHash(obj);
            if (hash) return hash;
          }

          if (Object.isExtensible && !Object.isExtensible(obj)) {
            throw new Error('Non-extensible objects are not allowed as keys.');
          }

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

          if (weakMap) {
            weakMap.set(obj, hash);
          } else if (canDefineProperty) {
            Object.defineProperty(obj, UID_HASH_KEY, {
              'enumerable': false,
              'configurable': false,
              'writable': false,
              'value': hash
            });
          } else if (obj.propertyIsEnumerable &&
            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) {
            // 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;
        }

        // True if Object.defineProperty works as expected. IE8 fails this test.
        var canDefineProperty = (function () {
          try {
            Object.defineProperty({}, 'x', {});
            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 weakMap = typeof WeakMap === 'function' && 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 invariant(condition, error) {
          if (!condition) throw new Error(error);
        }

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

        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.contains = function (value) {
          return this._iter.contains(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.contains(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);
              return fn(entry[1], 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);
                return type === ITERATE_ENTRIES ? step :
                  iteratorValue(type, entry[0], 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.contains(key)
          };
          flipSequence.contains = 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.contains = function (value) {
            return iterable.contains(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;

          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.
          if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {
            return sliceFactory(iterable.toSeq().cacheResult(), begin, end, useKeys);
          }

          var sliceSize = resolvedEnd - resolvedBegin;
          if (sliceSize < 0) {
            sliceSize = 0;
          }

          var sliceSeq = makeSequence(iterable);

          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 && reverse) {
              return this.cacheResult().__iterator(type, reverse);
            }
            // Don't bother instantiating parent iterator if taking 0.
            var iterator = sliceSize && 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(Map, KeyedCollection);

        // @pragma Construction

        function Map(value) {
          return value === null || value === undefined ? emptyMap() :
            isMap(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 m.merge.apply(m, iters)
          });
        };

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

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

        Map.prototype.mergeDeepIn = function (keyPath) {
          var iters = SLICE$0.call(arguments, 1);
          return this.updateIn(keyPath, emptyMap(), function (m) {
            return m.mergeDeep.apply(m, iters)
          });
        };

        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(merger) {
          return function (existing, value) {
            return existing && existing.mergeDeepWith && isIterable(value) ?
              existing.mergeDeepWith(merger, value) :
              merger ? merger(existing, value) : value
          };
        }

        function mergeIntoCollectionWith(collection, merger, iters) {
          iters = iters.filter(function (x) {
            return x.size !== 0
          });
          if (iters.length === 0) {
            return collection;
          }
          if (collection.size === 0 && 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)
                  }
                );
              } :
              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) {
            return notSetValue;
          }
          index += this._origin;
          var node = listNodeFor(this, index);
          return node && node.array[index & MASK];
        };

        // @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.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(undefined), arguments);
        };

        List.prototype.mergeDeepWith = function (merger) {
          var iters = SLICE$0.call(arguments, 1);
          return mergeIntoListWith(this, deepMerger(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 : 0 || 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 removingLast = sizeIndex === this.array.length - 1;
          var newChild;
          if (level > 0) {
            var oldChild = this.array[sizeIndex];
            newChild = oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);
            if (newChild === oldChild && removingLast) {
              return this;
            }
          }
          if (removingLast && !newChild) {
            return this;
          }
          var editable = editableVNode(this, ownerID);
          if (!removingLast) {
            editable.array.pop();
          }
          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 >= 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) {
          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 require 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 require 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(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;
          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.toSeq().cacheResult.__iterate(fn, 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 (type, reverse) {
          if (reverse) {
            return this.toSeq().cacheResult().__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();
          });
        };


        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));
        }

        createClass(Set, SetCollection);

        // @pragma Construction

        function Set(value) {
          return value === null || value === undefined ? emptySet() :
            isSet(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 && 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.contains(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.contains(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(Record, KeyedCollection);

        function Record(defaultValues, name) {
          var RecordType = function Record(values) {
            if (!(this instanceof RecordType)) {
              return new RecordType(values);
            }
            this._map = Map(values);
          };

          var keys = Object.keys(defaultValues);

          var RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype);
          RecordTypePrototype.constructor = RecordType;
          name && (RecordTypePrototype._name = name);
          RecordTypePrototype._defaultValues = defaultValues;
          RecordTypePrototype._keys = keys;
          RecordTypePrototype.size = keys.length;

          try {
            keys.forEach(function (key) {
              Object.defineProperty(RecordType.prototype, key, {
                get: function () {
                  return this.get(key);
                },
                set: function (value) {
                  invariant(this.__ownerID, 'Cannot set on an immutable record.');
                  this.set(key, value);
                }
              });
            });
          } catch (error) {
            // Object.defineProperty failed. Probably IE8.
          }

          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 SuperRecord = Object.getPrototypeOf(this).constructor;
          return SuperRecord._empty || (SuperRecord._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;
        }

        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) {
              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(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.contains = 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(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.contains = 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;

        /**
         * 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));
          },

          contains: 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 : '';
            });
            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.contains === 'function' ? iter : Iterable(iter);
            return this.every(function (value) {
              return iter.contains(value)
            });
          },

          isSuperset: function (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;

        // 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 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) {
            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;
            }
            index = resolveBegin(index, 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;
          },

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


          // ### More sequential methods

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

        });

        SetIterable.prototype.has = IterablePrototype.contains;


        // 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 = Math__imul(h, 0xCC9E2D51);
          h = Math__imul(h << 15 | h >>> -15, 0x1B873593);
          h = Math__imul(h << 13 | h >>> -13, 5);
          h = (h + 0xE6546B64 | 0) ^ size;
          h = Math__imul(h ^ h >>> 16, 0x85EBCA6B);
          h = Math__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;

      }));
    }, {}],
    55: [function (require, module, exports) {
      var baseFlatten = require('../internals/baseFlatten'), map = require('../collections/map');

      function flatten(array, isShallow, callback, thisArg) {
        if (typeof isShallow != 'boolean' && isShallow != null) {
          thisArg = callback;
          callback = typeof isShallow != 'function' && thisArg && thisArg[isShallow] === array ? null : isShallow;
          isShallow = false;
        }
        if (callback != null) {
          array = map(array, callback, thisArg);
        }
        return baseFlatten(array, isShallow);
      }

      module.exports = flatten;
    }, {"../collections/map": 59, "../internals/baseFlatten": 68}],
    56: [function (require, module, exports) {
      var createCallback = require('../functions/createCallback'), slice = require('../internals/slice');
      var undefined;
      var nativeMax = Math.max;

      function last(array, callback, thisArg) {
        var n = 0, length = array ? array.length : 0;
        if (typeof callback != 'number' && callback != null) {
          var index = length;
          callback = createCallback(callback, thisArg, 3);
          while (index-- && callback(array[index], index, array)) {
            n++;
          }
        } else {
          n = callback;
          if (n == null || thisArg) {
            return array ? array[length - 1] : undefined;
          }
        }
        return slice(array, nativeMax(0, length - n));
      }

      module.exports = last;
    }, {"../functions/createCallback": 62, "../internals/slice": 82}],
    57: [function (require, module, exports) {
      var arrayRef = [];
      var splice = arrayRef.splice;

      function pull(array) {
        var args = arguments, argsIndex = 0, argsLength = args.length, length = array ? array.length : 0;
        while (++argsIndex < argsLength) {
          var index = -1, value = args[argsIndex];
          while (++index < length) {
            if (array[index] === value) {
              splice.call(array, index--, 1);
              length--;
            }
          }
        }
        return array;
      }

      module.exports = pull;
    }, {}],
    58: [function (require, module, exports) {
      var baseIndexOf = require('../internals/baseIndexOf'), forOwn = require('../objects/forOwn'), isArray = require('../objects/isArray'), isString = require('../objects/isString');
      var nativeMax = Math.max;

      function contains(collection, target, fromIndex) {
        var index = -1, indexOf = baseIndexOf, length = collection ? collection.length : 0, result = false;
        fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex) || 0;
        if (isArray(collection)) {
          result = indexOf(collection, target, fromIndex) > -1;
        } else if (typeof length == 'number') {
          result = (isString(collection) ? collection.indexOf(target, fromIndex) : indexOf(collection, target, fromIndex)) > -1;
        } else {
          forOwn(collection, function (value) {
            if (++index >= fromIndex) {
              return !(result = value === target);
            }
          });
        }
        return result;
      }

      module.exports = contains;
    }, {"../internals/baseIndexOf": 69, "../objects/forOwn": 86, "../objects/isArray": 88, "../objects/isString": 91}],
    59: [function (require, module, exports) {
      var createCallback = require('../functions/createCallback'), forOwn = require('../objects/forOwn');

      function map(collection, callback, thisArg) {
        var index = -1, length = collection ? collection.length : 0;
        callback = createCallback(callback, thisArg, 3);
        if (typeof length == 'number') {
          var result = Array(length);
          while (++index < length) {
            result[index] = callback(collection[index], index, collection);
          }
        } else {
          result = [];
          forOwn(collection, function (value, key, collection) {
            result[++index] = callback(value, key, collection);
          });
        }
        return result;
      }

      module.exports = map;
    }, {"../functions/createCallback": 62, "../objects/forOwn": 86}],
    60: [function (require, module, exports) {
      var isString = require('../objects/isString'), slice = require('../internals/slice'), values = require('../objects/values');

      function toArray(collection) {
        if (collection && typeof collection.length == 'number') {
          return slice(collection);
        }
        return values(collection);
      }

      module.exports = toArray;
    }, {"../internals/slice": 82, "../objects/isString": 91, "../objects/values": 93}],
    61: [function (require, module, exports) {
      var createWrapper = require('../internals/createWrapper'), slice = require('../internals/slice');

      function bind(func, thisArg) {
        return arguments.length > 2 ? createWrapper(func, 17, slice(arguments, 2), null, thisArg) : createWrapper(func, 1, null, null, thisArg);
      }

      module.exports = bind;
    }, {"../internals/createWrapper": 71, "../internals/slice": 82}],
    62: [function (require, module, exports) {
      var baseCreateCallback = require('../internals/baseCreateCallback'), baseIsEqual = require('../internals/baseIsEqual'), isObject = require('../objects/isObject'), keys = require('../objects/keys'), property = require('../utilities/property');

      function createCallback(func, thisArg, argCount) {
        var type = typeof func;
        if (func == null || type == 'function') {
          return baseCreateCallback(func, thisArg, argCount);
        }
        if (type != 'object') {
          return property(func);
        }
        var props = keys(func), key = props[0], a = func[key];
        if (props.length == 1 && a === a && !isObject(a)) {
          return function (object) {
            var b = object[key];
            return a === b && (a !== 0 || 1 / a == 1 / b);
          };
        }
        return function (object) {
          var length = props.length, result = false;
          while (length--) {
            if (!(result = baseIsEqual(object[props[length]], func[props[length]], null, true))) {
              break;
            }
          }
          return result;
        };
      }

      module.exports = createCallback;
    }, {
      "../internals/baseCreateCallback": 66,
      "../internals/baseIsEqual": 70,
      "../objects/isObject": 90,
      "../objects/keys": 92,
      "../utilities/property": 98
    }],
    63: [function (require, module, exports) {
      var arrayPool = [];
      module.exports = arrayPool;
    }, {}],
    64: [function (require, module, exports) {
      var baseCreate = require('./baseCreate'), isObject = require('../objects/isObject'), setBindData = require('./setBindData'), slice = require('./slice');
      var arrayRef = [];
      var push = arrayRef.push;

      function baseBind(bindData) {
        var func = bindData[0], partialArgs = bindData[2], thisArg = bindData[4];

        function bound() {
          if (partialArgs) {
            var args = slice(partialArgs);
            push.apply(args, arguments);
          }
          if (this instanceof bound) {
            var thisBinding = baseCreate(func.prototype), result = func.apply(thisBinding, args || arguments);
            return isObject(result) ? result : thisBinding;
          }
          return func.apply(thisArg, args || arguments);
        }

        setBindData(bound, bindData);
        return bound;
      }

      module.exports = baseBind;
    }, {"../objects/isObject": 90, "./baseCreate": 65, "./setBindData": 80, "./slice": 82}],
    65: [function (require, module, exports) {
      var isNative = require('./isNative'), isObject = require('../objects/isObject'), noop = require('../utilities/noop');
      var nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate;

      function baseCreate(prototype, properties) {
        return isObject(prototype) ? nativeCreate(prototype) : {};
      }

      if (!nativeCreate) {
        baseCreate = function () {
          function Object() {
          }

          return function (prototype) {
            if (isObject(prototype)) {
              Object.prototype = prototype;
              var result = new Object();
              Object.prototype = null;
            }
            return result || window.Object();
          };
        }();
      }
      module.exports = baseCreate;
    }, {"../objects/isObject": 90, "../utilities/noop": 97, "./isNative": 75}],
    66: [function (require, module, exports) {
      var bind = require('../functions/bind'), identity = require('../utilities/identity'), setBindData = require('./setBindData'), support = require('../support');
      var reFuncName = /^\s*function[ \n\r\t]+\w/;
      var reThis = /\bthis\b/;
      var fnToString = Function.prototype.toString;

      function baseCreateCallback(func, thisArg, argCount) {
        if (typeof func != 'function') {
          return identity;
        }
        if (typeof thisArg == 'undefined' || !('prototype' in func)) {
          return func;
        }
        var bindData = func.__bindData__;
        if (typeof bindData == 'undefined') {
          if (support.funcNames) {
            bindData = !func.name;
          }
          bindData = bindData || !support.funcDecomp;
          if (!bindData) {
            var source = fnToString.call(func);
            if (!support.funcNames) {
              bindData = !reFuncName.test(source);
            }
            if (!bindData) {
              bindData = reThis.test(source);
              setBindData(func, bindData);
            }
          }
        }
        if (bindData === false || bindData !== true && bindData[1] & 1) {
          return func;
        }
        switch (argCount) {
          case 1:
            return function (value) {
              return func.call(thisArg, value);
            };
          case 2:
            return function (a, b) {
              return func.call(thisArg, a, b);
            };
          case 3:
            return function (value, index, collection) {
              return func.call(thisArg, value, index, collection);
            };
          case 4:
            return function (accumulator, value, index, collection) {
              return func.call(thisArg, accumulator, value, index, collection);
            };
        }
        return bind(func, thisArg);
      }

      module.exports = baseCreateCallback;
    }, {"../functions/bind": 61, "../support": 94, "../utilities/identity": 96, "./setBindData": 80}],
    67: [function (require, module, exports) {
      var baseCreate = require('./baseCreate'), isObject = require('../objects/isObject'), setBindData = require('./setBindData'), slice = require('./slice');
      var arrayRef = [];
      var push = arrayRef.push;

      function baseCreateWrapper(bindData) {
        var func = bindData[0], bitmask = bindData[1], partialArgs = bindData[2], partialRightArgs = bindData[3], thisArg = bindData[4], arity = bindData[5];
        var isBind = bitmask & 1, isBindKey = bitmask & 2, isCurry = bitmask & 4, isCurryBound = bitmask & 8, key = func;

        function bound() {
          var thisBinding = isBind ? thisArg : this;
          if (partialArgs) {
            var args = slice(partialArgs);
            push.apply(args, arguments);
          }
          if (partialRightArgs || isCurry) {
            args || (args = slice(arguments));
            if (partialRightArgs) {
              push.apply(args, partialRightArgs);
            }
            if (isCurry && args.length < arity) {
              bitmask |= 16 & ~32;
              return baseCreateWrapper([
                func,
                isCurryBound ? bitmask : bitmask & ~3,
                args,
                null,
                thisArg,
                arity
              ]);
            }
          }
          args || (args = arguments);
          if (isBindKey) {
            func = thisBinding[key];
          }
          if (this instanceof bound) {
            thisBinding = baseCreate(func.prototype);
            var result = func.apply(thisBinding, args);
            return isObject(result) ? result : thisBinding;
          }
          return func.apply(thisBinding, args);
        }

        setBindData(bound, bindData);
        return bound;
      }

      module.exports = baseCreateWrapper;
    }, {"../objects/isObject": 90, "./baseCreate": 65, "./setBindData": 80, "./slice": 82}],
    68: [function (require, module, exports) {
      var isArguments = require('../objects/isArguments'), isArray = require('../objects/isArray');

      function baseFlatten(array, isShallow, isStrict, fromIndex) {
        var index = (fromIndex || 0) - 1, length = array ? array.length : 0, result = [];
        while (++index < length) {
          var value = array[index];
          if (value && typeof value == 'object' && typeof value.length == 'number' && (isArray(value) || isArguments(value))) {
            if (!isShallow) {
              value = baseFlatten(value, isShallow, isStrict);
            }
            var valIndex = -1, valLength = value.length, resIndex = result.length;
            result.length += valLength;
            while (++valIndex < valLength) {
              result[resIndex++] = value[valIndex];
            }
          } else if (!isStrict) {
            result.push(value);
          }
        }
        return result;
      }

      module.exports = baseFlatten;
    }, {"../objects/isArguments": 87, "../objects/isArray": 88}],
    69: [function (require, module, exports) {
      function baseIndexOf(array, value, fromIndex) {
        var index = (fromIndex || 0) - 1, length = array ? array.length : 0;
        while (++index < length) {
          if (array[index] === value) {
            return index;
          }
        }
        return -1;
      }

      module.exports = baseIndexOf;
    }, {}],
    70: [function (require, module, exports) {
      var forIn = require('../objects/forIn'), getArray = require('./getArray'), isFunction = require('../objects/isFunction'), objectTypes = require('./objectTypes'), releaseArray = require('./releaseArray');
      var argsClass = '[object Arguments]', arrayClass = '[object Array]', boolClass = '[object Boolean]', dateClass = '[object Date]', numberClass = '[object Number]', objectClass = '[object Object]', regexpClass = '[object RegExp]', stringClass = '[object String]';
      var objectProto = Object.prototype;
      var toString = objectProto.toString;
      var hasOwnProperty = objectProto.hasOwnProperty;

      function baseIsEqual(a, b, callback, isWhere, stackA, stackB) {
        if (callback) {
          var result = callback(a, b);
          if (typeof result != 'undefined') {
            return !!result;
          }
        }
        if (a === b) {
          return a !== 0 || 1 / a == 1 / b;
        }
        var type = typeof a, otherType = typeof b;
        if (a === a && !(a && objectTypes[type]) && !(b && objectTypes[otherType])) {
          return false;
        }
        if (a == null || b == null) {
          return a === b;
        }
        var className = toString.call(a), otherClass = toString.call(b);
        if (className == argsClass) {
          className = objectClass;
        }
        if (otherClass == argsClass) {
          otherClass = objectClass;
        }
        if (className != otherClass) {
          return false;
        }
        switch (className) {
          case boolClass:
          case dateClass:
            return +a == +b;
          case numberClass:
            return a != +a ? b != +b : a == 0 ? 1 / a == 1 / b : a == +b;
          case regexpClass:
          case stringClass:
            return a == String(b);
        }
        var isArr = className == arrayClass;
        if (!isArr) {
          var aWrapped = hasOwnProperty.call(a, '__wrapped__'), bWrapped = hasOwnProperty.call(b, '__wrapped__');
          if (aWrapped || bWrapped) {
            return baseIsEqual(aWrapped ? a.__wrapped__ : a, bWrapped ? b.__wrapped__ : b, callback, isWhere, stackA, stackB);
          }
          if (className != objectClass) {
            return false;
          }
          var ctorA = a.constructor, ctorB = b.constructor;
          if (ctorA != ctorB && !(isFunction(ctorA) && ctorA instanceof ctorA && isFunction(ctorB) && ctorB instanceof ctorB) && ('constructor' in a && 'constructor' in b)) {
            return false;
          }
        }
        var initedStack = !stackA;
        stackA || (stackA = getArray());
        stackB || (stackB = getArray());
        var length = stackA.length;
        while (length--) {
          if (stackA[length] == a) {
            return stackB[length] == b;
          }
        }
        var size = 0;
        result = true;
        stackA.push(a);
        stackB.push(b);
        if (isArr) {
          length = a.length;
          size = b.length;
          result = size == length;
          if (result || isWhere) {
            while (size--) {
              var index = length, value = b[size];
              if (isWhere) {
                while (index--) {
                  if (result = baseIsEqual(a[index], value, callback, isWhere, stackA, stackB)) {
                    break;
                  }
                }
              } else if (!(result = baseIsEqual(a[size], value, callback, isWhere, stackA, stackB))) {
                break;
              }
            }
          }
        } else {
          forIn(b, function (value, key, b) {
            if (hasOwnProperty.call(b, key)) {
              size++;
              return result = hasOwnProperty.call(a, key) && baseIsEqual(a[key], value, callback, isWhere, stackA, stackB);
            }
          });
          if (result && !isWhere) {
            forIn(a, function (value, key, a) {
              if (hasOwnProperty.call(a, key)) {
                return result = --size > -1;
              }
            });
          }
        }
        stackA.pop();
        stackB.pop();
        if (initedStack) {
          releaseArray(stackA);
          releaseArray(stackB);
        }
        return result;
      }

      module.exports = baseIsEqual;
    }, {
      "../objects/forIn": 85,
      "../objects/isFunction": 89,
      "./getArray": 73,
      "./objectTypes": 77,
      "./releaseArray": 79
    }],
    71: [function (require, module, exports) {
      var baseBind = require('./baseBind'), baseCreateWrapper = require('./baseCreateWrapper'), isFunction = require('../objects/isFunction'), slice = require('./slice');
      var arrayRef = [];
      var push = arrayRef.push, unshift = arrayRef.unshift;

      function createWrapper(func, bitmask, partialArgs, partialRightArgs, thisArg, arity) {
        var isBind = bitmask & 1, isBindKey = bitmask & 2, isCurry = bitmask & 4, isCurryBound = bitmask & 8, isPartial = bitmask & 16, isPartialRight = bitmask & 32;
        if (!isBindKey && !isFunction(func)) {
          throw new TypeError();
        }
        if (isPartial && !partialArgs.length) {
          bitmask &= ~16;
          isPartial = partialArgs = false;
        }
        if (isPartialRight && !partialRightArgs.length) {
          bitmask &= ~32;
          isPartialRight = partialRightArgs = false;
        }
        var bindData = func && func.__bindData__;
        if (bindData && bindData !== true) {
          bindData = slice(bindData);
          if (bindData[2]) {
            bindData[2] = slice(bindData[2]);
          }
          if (bindData[3]) {
            bindData[3] = slice(bindData[3]);
          }
          if (isBind && !(bindData[1] & 1)) {
            bindData[4] = thisArg;
          }
          if (!isBind && bindData[1] & 1) {
            bitmask |= 8;
          }
          if (isCurry && !(bindData[1] & 4)) {
            bindData[5] = arity;
          }
          if (isPartial) {
            push.apply(bindData[2] || (bindData[2] = []), partialArgs);
          }
          if (isPartialRight) {
            unshift.apply(bindData[3] || (bindData[3] = []), partialRightArgs);
          }
          bindData[1] |= bitmask;
          return createWrapper.apply(null, bindData);
        }
        var creater = bitmask == 1 || bitmask === 17 ? baseBind : baseCreateWrapper;
        return creater([
          func,
          bitmask,
          partialArgs,
          partialRightArgs,
          thisArg,
          arity
        ]);
      }

      module.exports = createWrapper;
    }, {"../objects/isFunction": 89, "./baseBind": 64, "./baseCreateWrapper": 67, "./slice": 82}],
    72: [function (require, module, exports) {
      var htmlEscapes = require('./htmlEscapes');

      function escapeHtmlChar(match) {
        return htmlEscapes[match];
      }

      module.exports = escapeHtmlChar;
    }, {"./htmlEscapes": 74}],
    73: [function (require, module, exports) {
      var arrayPool = require('./arrayPool');

      function getArray() {
        return arrayPool.pop() || [];
      }

      module.exports = getArray;
    }, {"./arrayPool": 63}],
    74: [function (require, module, exports) {
      var htmlEscapes = {
        '&': '&amp;',
        '<': '&lt;',
        '>': '&gt;',
        '"': '&quot;',
        '\'': '&#39;'
      };
      module.exports = htmlEscapes;
    }, {}],
    75: [function (require, module, exports) {
      var objectProto = Object.prototype;
      var toString = objectProto.toString;
      var reNative = RegExp('^' + String(toString).replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/toString| for [^\]]+/g, '.*?') + '$');

      function isNative(value) {
        return typeof value == 'function' && reNative.test(value);
      }

      module.exports = isNative;
    }, {}],
    76: [function (require, module, exports) {
      var maxPoolSize = 40;
      module.exports = maxPoolSize;
    }, {}],
    77: [function (require, module, exports) {
      var objectTypes = {
        'boolean': false,
        'function': true,
        'object': true,
        'number': false,
        'string': false,
        'undefined': false
      };
      module.exports = objectTypes;
    }, {}],
    78: [function (require, module, exports) {
      var htmlEscapes = require('./htmlEscapes'), keys = require('../objects/keys');
      var reUnescapedHtml = RegExp('[' + keys(htmlEscapes).join('') + ']', 'g');
      module.exports = reUnescapedHtml;
    }, {"../objects/keys": 92, "./htmlEscapes": 74}],
    79: [function (require, module, exports) {
      var arrayPool = require('./arrayPool'), maxPoolSize = require('./maxPoolSize');

      function releaseArray(array) {
        array.length = 0;
        if (arrayPool.length < maxPoolSize) {
          arrayPool.push(array);
        }
      }

      module.exports = releaseArray;
    }, {"./arrayPool": 63, "./maxPoolSize": 76}],
    80: [function (require, module, exports) {
      var isNative = require('./isNative'), noop = require('../utilities/noop');
      var descriptor = {
        'configurable': false,
        'enumerable': false,
        'value': null,
        'writable': false
      };
      var defineProperty = function () {
        try {
          var o = {}, func = isNative(func = Object.defineProperty) && func, result = func(o, o, o) && func;
        } catch (e) {
        }
        return result;
      }();
      var setBindData = !defineProperty ? noop : function (func, value) {
        descriptor.value = value;
        defineProperty(func, '__bindData__', descriptor);
      };
      module.exports = setBindData;
    }, {"../utilities/noop": 97, "./isNative": 75}],
    81: [function (require, module, exports) {
      var objectTypes = require('./objectTypes');
      var objectProto = Object.prototype;
      var hasOwnProperty = objectProto.hasOwnProperty;
      var shimKeys = function (object) {
        var index, iterable = object, result = [];
        if (!iterable)
          return result;
        if (!objectTypes[typeof object])
          return result;
        for (index in iterable) {
          if (hasOwnProperty.call(iterable, index)) {
            result.push(index);
          }
        }
        return result;
      };
      module.exports = shimKeys;
    }, {"./objectTypes": 77}],
    82: [function (require, module, exports) {
      function slice(array, start, end) {
        start || (start = 0);
        if (typeof end == 'undefined') {
          end = array ? array.length : 0;
        }
        var index = -1, length = end - start || 0, result = Array(length < 0 ? 0 : length);
        while (++index < length) {
          result[index] = array[start + index];
        }
        return result;
      }

      module.exports = slice;
    }, {}],
    83: [function (require, module, exports) {
      var baseCreateCallback = require('../internals/baseCreateCallback'), keys = require('./keys'), objectTypes = require('../internals/objectTypes');
      var assign = function (object, source, guard) {
        var index, iterable = object, result = iterable;
        if (!iterable)
          return result;
        var args = arguments, argsIndex = 0, argsLength = typeof guard == 'number' ? 2 : args.length;
        if (argsLength > 3 && typeof args[argsLength - 2] == 'function') {
          var callback = baseCreateCallback(args[--argsLength - 1], args[argsLength--], 2);
        } else if (argsLength > 2 && typeof args[argsLength - 1] == 'function') {
          callback = args[--argsLength];
        }
        while (++argsIndex < argsLength) {
          iterable = args[argsIndex];
          if (iterable && objectTypes[typeof iterable]) {
            var ownIndex = -1, ownProps = objectTypes[typeof iterable] && keys(iterable), length = ownProps ? ownProps.length : 0;
            while (++ownIndex < length) {
              index = ownProps[ownIndex];
              result[index] = callback ? callback(result[index], iterable[index]) : iterable[index];
            }
          }
        }
        return result;
      };
      module.exports = assign;
    }, {"../internals/baseCreateCallback": 66, "../internals/objectTypes": 77, "./keys": 92}],
    84: [function (require, module, exports) {
      var keys = require('./keys'), objectTypes = require('../internals/objectTypes');
      var defaults = function (object, source, guard) {
        var index, iterable = object, result = iterable;
        if (!iterable)
          return result;
        var args = arguments, argsIndex = 0, argsLength = typeof guard == 'number' ? 2 : args.length;
        while (++argsIndex < argsLength) {
          iterable = args[argsIndex];
          if (iterable && objectTypes[typeof iterable]) {
            var ownIndex = -1, ownProps = objectTypes[typeof iterable] && keys(iterable), length = ownProps ? ownProps.length : 0;
            while (++ownIndex < length) {
              index = ownProps[ownIndex];
              if (typeof result[index] == 'undefined')
                result[index] = iterable[index];
            }
          }
        }
        return result;
      };
      module.exports = defaults;
    }, {"../internals/objectTypes": 77, "./keys": 92}],
    85: [function (require, module, exports) {
      var baseCreateCallback = require('../internals/baseCreateCallback'), objectTypes = require('../internals/objectTypes');
      var forIn = function (collection, callback, thisArg) {
        var index, iterable = collection, result = iterable;
        if (!iterable)
          return result;
        if (!objectTypes[typeof iterable])
          return result;
        callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
        for (index in iterable) {
          if (callback(iterable[index], index, collection) === false)
            return result;
        }
        return result;
      };
      module.exports = forIn;
    }, {"../internals/baseCreateCallback": 66, "../internals/objectTypes": 77}],
    86: [function (require, module, exports) {
      var baseCreateCallback = require('../internals/baseCreateCallback'), keys = require('./keys'), objectTypes = require('../internals/objectTypes');
      var forOwn = function (collection, callback, thisArg) {
        var index, iterable = collection, result = iterable;
        if (!iterable)
          return result;
        if (!objectTypes[typeof iterable])
          return result;
        callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
        var ownIndex = -1, ownProps = objectTypes[typeof iterable] && keys(iterable), length = ownProps ? ownProps.length : 0;
        while (++ownIndex < length) {
          index = ownProps[ownIndex];
          if (callback(iterable[index], index, collection) === false)
            return result;
        }
        return result;
      };
      module.exports = forOwn;
    }, {"../internals/baseCreateCallback": 66, "../internals/objectTypes": 77, "./keys": 92}],
    87: [function (require, module, exports) {
      var argsClass = '[object Arguments]';
      var objectProto = Object.prototype;
      var toString = objectProto.toString;

      function isArguments(value) {
        return value && typeof value == 'object' && typeof value.length == 'number' && toString.call(value) == argsClass || false;
      }

      module.exports = isArguments;
    }, {}],
    88: [function (require, module, exports) {
      var isNative = require('../internals/isNative');
      var arrayClass = '[object Array]';
      var objectProto = Object.prototype;
      var toString = objectProto.toString;
      var nativeIsArray = isNative(nativeIsArray = Array.isArray) && nativeIsArray;
      var isArray = nativeIsArray || function (value) {
          return value && typeof value == 'object' && typeof value.length == 'number' && toString.call(value) == arrayClass || false;
        };
      module.exports = isArray;
    }, {"../internals/isNative": 75}],
    89: [function (require, module, exports) {
      function isFunction(value) {
        return typeof value == 'function';
      }

      module.exports = isFunction;
    }, {}],
    90: [function (require, module, exports) {
      var objectTypes = require('../internals/objectTypes');

      function isObject(value) {
        return !!(value && objectTypes[typeof value]);
      }

      module.exports = isObject;
    }, {"../internals/objectTypes": 77}],
    91: [function (require, module, exports) {
      var stringClass = '[object String]';
      var objectProto = Object.prototype;
      var toString = objectProto.toString;

      function isString(value) {
        return typeof value == 'string' || value && typeof value == 'object' && toString.call(value) == stringClass || false;
      }

      module.exports = isString;
    }, {}],
    92: [function (require, module, exports) {
      var isNative = require('../internals/isNative'), isObject = require('./isObject'), shimKeys = require('../internals/shimKeys');
      var nativeKeys = isNative(nativeKeys = Object.keys) && nativeKeys;
      var keys = !nativeKeys ? shimKeys : function (object) {
        if (!isObject(object)) {
          return [];
        }
        return nativeKeys(object);
      };
      module.exports = keys;
    }, {"../internals/isNative": 75, "../internals/shimKeys": 81, "./isObject": 90}],
    93: [function (require, module, exports) {
      var keys = require('./keys');

      function values(object) {
        var index = -1, props = keys(object), length = props.length, result = Array(length);
        while (++index < length) {
          result[index] = object[props[index]];
        }
        return result;
      }

      module.exports = values;
    }, {"./keys": 92}],
    94: [function (require, module, exports) {
      var isNative = require('./internals/isNative');
      var reThis = /\bthis\b/;
      var support = {};
      support.funcDecomp = !isNative(window.WinRTError) && reThis.test(function () {
          return this;
        });
      support.funcNames = typeof Function.name == 'string';
      module.exports = support;
    }, {"./internals/isNative": 75}],
    95: [function (require, module, exports) {
      var escapeHtmlChar = require('../internals/escapeHtmlChar'), keys = require('../objects/keys'), reUnescapedHtml = require('../internals/reUnescapedHtml');

      function escape(string) {
        return string == null ? '' : String(string).replace(reUnescapedHtml, escapeHtmlChar);
      }

      module.exports = escape;
    }, {"../internals/escapeHtmlChar": 72, "../internals/reUnescapedHtml": 78, "../objects/keys": 92}],
    96: [function (require, module, exports) {
      function identity(value) {
        return value;
      }

      module.exports = identity;
    }, {}],
    97: [function (require, module, exports) {
      function noop() {
      }

      module.exports = noop;
    }, {}],
    98: [function (require, module, exports) {
      function property(key) {
        return function (object) {
          return object[key];
        };
      }

      module.exports = property;
    }, {}],
    99: [function (require, module, exports) {
      var buildCommandPatch = require('./api/command-patch'), buildCommand = require('./api/command'), Node = require('./api/node'), buildSelection = require('./api/selection'), buildSimpleCommand = require('./api/simple-command');
      'use strict';
      module.exports = function Api(scribe) {
        this.CommandPatch = buildCommandPatch(scribe);
        this.Command = buildCommand(scribe);
        this.Node = Node;
        this.Selection = buildSelection(scribe);
        this.SimpleCommand = buildSimpleCommand(this, scribe);
      };
    }, {
      "./api/command": 101,
      "./api/command-patch": 100,
      "./api/node": 102,
      "./api/selection": 103,
      "./api/simple-command": 104
    }],
    100: [function (require, module, exports) {
      'use strict';
      module.exports = function (scribe) {
        function CommandPatch(commandName) {
          this.commandName = commandName;
        }

        CommandPatch.prototype.execute = function (value) {
          scribe.transactionManager.run(function () {
            document.execCommand(this.commandName, false, value || null);
          }.bind(this));
        };
        CommandPatch.prototype.queryState = function () {
          return document.queryCommandState(this.commandName);
        };
        CommandPatch.prototype.queryEnabled = function () {
          return document.queryCommandEnabled(this.commandName);
        };
        return CommandPatch;
      };
    }, {}],
    101: [function (require, module, exports) {
      'use strict';
      module.exports = function (scribe) {
        function Command(commandName) {
          this.commandName = commandName;
          this.patch = scribe.commandPatches[this.commandName];
        }

        Command.prototype.execute = function (value) {
          if (this.patch) {
            this.patch.execute(value);
          } else {
            scribe.transactionManager.run(function () {
              document.execCommand(this.commandName, false, value || null);
            }.bind(this));
          }
        };
        Command.prototype.queryState = function () {
          if (this.patch) {
            return this.patch.queryState();
          } else {
            return document.queryCommandState(this.commandName);
          }
        };
        Command.prototype.queryEnabled = function () {
          if (this.patch) {
            return this.patch.queryEnabled();
          } else {
            return document.queryCommandEnabled(this.commandName);
          }
        };
        return Command;
      };
    }, {}],
    102: [function (require, module, exports) {
      'use strict';
      function Node(node) {
        this.node = node;
      }

      Node.prototype.getAncestor = function (rootElement, nodeFilter) {
        var isTopContainerElement = function (element) {
          return rootElement === element;
        };
        if (isTopContainerElement(this.node)) {
          return;
        }
        var currentNode = this.node.parentNode;
        while (currentNode && !isTopContainerElement(currentNode)) {
          if (nodeFilter(currentNode)) {
            return currentNode;
          }
          currentNode = currentNode.parentNode;
        }
      };
      Node.prototype.nextAll = function () {
        var all = [];
        var el = this.node.nextSibling;
        while (el) {
          all.push(el);
          el = el.nextSibling;
        }
        return all;
      };
      module.exports = Node;
    }, {}],
    103: [function (require, module, exports) {
      var elementHelper = require('../element');
      'use strict';
      module.exports = function (scribe) {
        function Selection() {
          var rootDoc = document;
          var currentElement = scribe.el.parentNode;
          while (currentElement && currentElement.nodeType !== Node.DOCUMENT_FRAGMENT_NODE && currentElement.nodeType !== Node.DOCUMENT_NODE) {
            currentElement = currentElement.parentNode;
          }
          if (currentElement && currentElement.nodeType === Node.DOCUMENT_FRAGMENT_NODE && currentElement.getSelection) {
            rootDoc = currentElement;
          }
          this.selection = rootDoc.getSelection();
          if (this.selection.rangeCount) {
            this.range = document.createRange();
            this.range.setStart(this.selection.anchorNode, this.selection.anchorOffset);
            this.range.setEnd(this.selection.focusNode, this.selection.focusOffset);
          }
        }

        Selection.prototype.getContaining = function (nodeFilter) {
          var range = this.range;
          if (!range) {
            return;
          }
          var node = new scribe.api.Node(this.range.commonAncestorContainer);
          var isTopContainerElement = node.node && scribe.el === node.node;
          return !isTopContainerElement && nodeFilter(node.node) ? node.node : node.getAncestor(scribe.el, nodeFilter);
        };
        Selection.prototype.placeMarkers = function () {
          var range = this.range;
          if (!range) {
            return;
          }
          if (!scribe.el.offsetParent) {
            return;
          }
          var scribeNodeRange = document.createRange();
          scribeNodeRange.selectNodeContents(scribe.el);
          var selectionStartWithinScribeElementStart = this.range.compareBoundaryPoints(Range.START_TO_START, scribeNodeRange) >= 0;
          var selectionEndWithinScribeElementEnd = this.range.compareBoundaryPoints(Range.END_TO_END, scribeNodeRange) <= 0;
          if (selectionStartWithinScribeElementStart && selectionEndWithinScribeElementEnd) {
            var startMarker = document.createElement('em');
            startMarker.classList.add('scribe-marker');
            var endMarker = document.createElement('em');
            endMarker.classList.add('scribe-marker');
            var rangeEnd = this.range.cloneRange();
            rangeEnd.collapse(false);
            rangeEnd.insertNode(endMarker);
            if (endMarker.nextSibling && endMarker.nextSibling.nodeType === Node.TEXT_NODE && endMarker.nextSibling.data === '') {
              endMarker.parentNode.removeChild(endMarker.nextSibling);
            }
            if (endMarker.previousSibling && endMarker.previousSibling.nodeType === Node.TEXT_NODE && endMarker.previousSibling.data === '') {
              endMarker.parentNode.removeChild(endMarker.previousSibling);
            }
            if (!this.range.collapsed) {
              var rangeStart = this.range.cloneRange();
              rangeStart.collapse(true);
              rangeStart.insertNode(startMarker);
              if (startMarker.nextSibling && startMarker.nextSibling.nodeType === Node.TEXT_NODE && startMarker.nextSibling.data === '') {
                startMarker.parentNode.removeChild(startMarker.nextSibling);
              }
              if (startMarker.previousSibling && startMarker.previousSibling.nodeType === Node.TEXT_NODE && startMarker.previousSibling.data === '') {
                startMarker.parentNode.removeChild(startMarker.previousSibling);
              }
            }
            this.selection.removeAllRanges();
            this.selection.addRange(this.range);
          }
        };
        Selection.prototype.getMarkers = function () {
          return scribe.el.querySelectorAll('em.scribe-marker');
        };
        Selection.prototype.removeMarkers = function () {
          var markers = this.getMarkers();
          Array.prototype.forEach.call(markers, function (marker) {
            marker.parentNode.removeChild(marker);
          });
        };
        Selection.prototype.selectMarkers = function (keepMarkers) {
          var markers = this.getMarkers();
          if (!markers.length) {
            return;
          }
          var newRange = document.createRange();
          newRange.setStartBefore(markers[0]);
          if (markers.length >= 2) {
            newRange.setEndAfter(markers[1]);
          } else {
            newRange.setEndAfter(markers[0]);
          }
          if (!keepMarkers) {
            this.removeMarkers();
          }
          this.selection.removeAllRanges();
          this.selection.addRange(newRange);
        };
        Selection.prototype.isCaretOnNewLine = function () {
          function isEmptyInlineElement(node) {
            var treeWalker = document.createTreeWalker(node, NodeFilter.SHOW_ELEMENT, null, false);
            var currentNode = treeWalker.root;
            while (currentNode) {
              var numberOfChildren = currentNode.childNodes.length;
              if (numberOfChildren > 1 || numberOfChildren === 1 && currentNode.textContent.trim() !== '')
                return false;
              if (numberOfChildren === 0) {
                return currentNode.textContent.trim() === '';
              }
              currentNode = treeWalker.nextNode();
            }
            ;
          }
          ;
          var containerPElement = this.getContaining(function (node) {
            return node.nodeName === 'P';
          });
          if (containerPElement) {
            return isEmptyInlineElement(containerPElement);
          } else {
            return false;
          }
        };
        return Selection;
      };
    }, {"../element": 106}],
    104: [function (require, module, exports) {
      'use strict';
      module.exports = function (api, scribe) {
        function SimpleCommand(commandName, nodeName) {
          scribe.api.Command.call(this, commandName);
          this._nodeName = nodeName;
        }

        SimpleCommand.prototype = Object.create(api.Command.prototype);
        SimpleCommand.prototype.constructor = SimpleCommand;
        SimpleCommand.prototype.queryState = function () {
          var selection = new scribe.api.Selection();
          return scribe.api.Command.prototype.queryState.call(this) && !!selection.getContaining(function (node) {
              return node.nodeName === this._nodeName;
            }.bind(this));
        };
        return SimpleCommand;
      };
    }, {}],
    105: [function (require, module, exports) {
      var flatten = require('lodash-amd/modern/arrays/flatten'), toArray = require('lodash-amd/modern/collections/toArray'), elementHelpers = require('./element'), nodeHelpers = require('./node');

      function observeDomChanges(el, callback) {
        function includeRealMutations(mutations) {
          var allChangedNodes = flatten(mutations.map(function (mutation) {
            var added = toArray(mutation.addedNodes);
            var removed = toArray(mutation.removedNodes);
            return added.concat(removed);
          }));
          var realChangedNodes = allChangedNodes.filter(function (n) {
            return !nodeHelpers.isEmptyTextNode(n);
          }).filter(function (n) {
            return !elementHelpers.isSelectionMarkerNode(n);
          });
          return realChangedNodes.length > 0;
        }

        var MutationObserver = window.MutationObserver || window.WebKitMutationObserver || window.MozMutationObserver;
        var runningPostMutation = false;
        var observer = new MutationObserver(function (mutations) {
          if (!runningPostMutation && includeRealMutations(mutations)) {
            runningPostMutation = true;
            try {
              callback();
            } catch (e) {
              throw e;
            } finally {
              setTimeout(function () {
                runningPostMutation = false;
              }, 0);
            }
          }
        });
        observer.observe(el, {
          attributes: true,
          childList: true,
          subtree: true
        });
        return observer;
      }

      module.exports = observeDomChanges;
    }, {
      "./element": 106,
      "./node": 108,
      "lodash-amd/modern/arrays/flatten": 55,
      "lodash-amd/modern/collections/toArray": 60
    }],
    106: [function (require, module, exports) {
      var contains = require('lodash-amd/modern/collections/contains');
      'use strict';
      var blockElementNames = [
        'ADDRESS',
        'ARTICLE',
        'ASIDE',
        'AUDIO',
        'BLOCKQUOTE',
        'CANVAS',
        'DD',
        'DIV',
        'FIELDSET',
        'FIGCAPTION',
        'FIGURE',
        'FOOTER',
        'FORM',
        'H1',
        'H2',
        'H3',
        'H4',
        'H5',
        'H6',
        'HEADER',
        'HGROUP',
        'HR',
        'LI',
        'NOSCRIPT',
        'OL',
        'OUTPUT',
        'P',
        'PRE',
        'SECTION',
        'TABLE',
        'TD',
        'TH',
        'TFOOT',
        'UL',
        'VIDEO'
      ];

      function isBlockElement(node) {
        return contains(blockElementNames, node.nodeName);
      }

      function isSelectionMarkerNode(node) {
        return node.nodeType === Node.ELEMENT_NODE && node.className === 'scribe-marker';
      }

      function isCaretPositionNode(node) {
        return node.nodeType === Node.ELEMENT_NODE && node.className === 'caret-position';
      }

      function unwrap(node, childNode) {
        while (childNode.childNodes.length > 0) {
          node.insertBefore(childNode.childNodes[0], childNode);
        }
        node.removeChild(childNode);
      }

      module.exports = {
        isBlockElement: isBlockElement,
        isSelectionMarkerNode: isSelectionMarkerNode,
        isCaretPositionNode: isCaretPositionNode,
        unwrap: unwrap
      };
    }, {"lodash-amd/modern/collections/contains": 58}],
    107: [function (require, module, exports) {
      var pull = require('lodash-amd/modern/arrays/pull'), Immutable = require('immutable/dist/immutable');
      'use strict';
      function EventEmitter() {
        this._listeners = {};
      }

      EventEmitter.prototype.on = function (eventName, fn) {
        var listeners = this._listeners[eventName] || Immutable.Set();
        this._listeners[eventName] = listeners.add(fn);
      };
      EventEmitter.prototype.off = function (eventName, fn) {
        var listeners = this._listeners[eventName] || Immutable.Set();
        if (fn) {
          listeners = listeners.delete(fn);
        } else {
          listeners = listeners.clear();
        }
      };
      EventEmitter.prototype.trigger = function (eventName, args) {
        var events = eventName.split(':');
        while (!!events.length) {
          var currentEvent = events.join(':');
          var listeners = this._listeners[currentEvent] || Immutable.Set();
          listeners.forEach(function (listener) {
            listener.apply(null, args);
          });
          events.splice(events.length - 1, 1);
        }
      };
      module.exports = EventEmitter;
    }, {"immutable/dist/immutable": 54, "lodash-amd/modern/arrays/pull": 57}],
    108: [function (require, module, exports) {
      'use strict';
      function isEmptyTextNode(node) {
        return node.nodeType === Node.TEXT_NODE && node.textContent === '';
      }

      function insertAfter(newNode, referenceNode) {
        return referenceNode.parentNode.insertBefore(newNode, referenceNode.nextSibling);
      }

      function removeNode(node) {
        return node.parentNode.removeChild(node);
      }

      module.exports = {
        isEmptyTextNode: isEmptyTextNode,
        insertAfter: insertAfter,
        removeNode: removeNode
      };
    }, {}],
    109: [function (require, module, exports) {
      var indent = require('./commands/indent'), insertList = require('./commands/insert-list'), outdent = require('./commands/outdent'), redo = require('./commands/redo'), subscript = require('./commands/subscript'), superscript = require('./commands/superscript'), undo = require('./commands/undo');
      'use strict';
      module.exports = {
        indent: indent,
        insertList: insertList,
        outdent: outdent,
        redo: redo,
        subscript: subscript,
        superscript: superscript,
        undo: undo
      };
    }, {
      "./commands/indent": 110,
      "./commands/insert-list": 111,
      "./commands/outdent": 112,
      "./commands/redo": 113,
      "./commands/subscript": 114,
      "./commands/superscript": 115,
      "./commands/undo": 116
    }],
    110: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var indentCommand = new scribe.api.Command('indent');
          indentCommand.queryEnabled = function () {
            var selection = new scribe.api.Selection();
            var listElement = selection.getContaining(function (element) {
              return element.nodeName === 'UL' || element.nodeName === 'OL';
            });
            return scribe.api.Command.prototype.queryEnabled.call(this) && scribe.allowsBlockElements() && !listElement;
          };
          scribe.commands.indent = indentCommand;
        };
      };
    }, {}],
    111: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var InsertListCommand = function (commandName) {
            scribe.api.Command.call(this, commandName);
          };
          InsertListCommand.prototype = Object.create(scribe.api.Command.prototype);
          InsertListCommand.prototype.constructor = InsertListCommand;
          InsertListCommand.prototype.execute = function (value) {
            function splitList(listItemElements) {
              if (listItemElements.length > 0) {
                var newListNode = document.createElement(listNode.nodeName);
                listItemElements.forEach(function (listItemElement) {
                  newListNode.appendChild(listItemElement);
                });
                listNode.parentNode.insertBefore(newListNode, listNode.nextElementSibling);
              }
            }

            if (this.queryState()) {
              var selection = new scribe.api.Selection();
              var range = selection.range;
              var listNode = selection.getContaining(function (node) {
                return node.nodeName === 'OL' || node.nodeName === 'UL';
              });
              var listItemElement = selection.getContaining(function (node) {
                return node.nodeName === 'LI';
              });
              scribe.transactionManager.run(function () {
                if (listItemElement) {
                  var nextListItemElements = new scribe.api.Node(listItemElement).nextAll();
                  splitList(nextListItemElements);
                  selection.placeMarkers();
                  var pNode = document.createElement('p');
                  pNode.innerHTML = listItemElement.innerHTML;
                  listNode.parentNode.insertBefore(pNode, listNode.nextElementSibling);
                  listItemElement.parentNode.removeChild(listItemElement);
                } else {
                  var selectedListItemElements = Array.prototype.map.call(listNode.querySelectorAll('li'), function (listItemElement) {
                    return range.intersectsNode(listItemElement) && listItemElement;
                  }).filter(function (listItemElement) {
                    return listItemElement;
                  });
                  var lastSelectedListItemElement = selectedListItemElements.slice(-1)[0];
                  var listItemElementsAfterSelection = new scribe.api.Node(lastSelectedListItemElement).nextAll();
                  splitList(listItemElementsAfterSelection);
                  selection.placeMarkers();
                  var documentFragment = document.createDocumentFragment();
                  selectedListItemElements.forEach(function (listItemElement) {
                    var pElement = document.createElement('p');
                    pElement.innerHTML = listItemElement.innerHTML;
                    documentFragment.appendChild(pElement);
                  });
                  listNode.parentNode.insertBefore(documentFragment, listNode.nextElementSibling);
                  selectedListItemElements.forEach(function (listItemElement) {
                    listItemElement.parentNode.removeChild(listItemElement);
                  });
                }
                if (listNode.childNodes.length === 0) {
                  listNode.parentNode.removeChild(listNode);
                }
                selection.selectMarkers();
              }.bind(this));
            } else {
              scribe.api.Command.prototype.execute.call(this, value);
            }
          };
          InsertListCommand.prototype.queryEnabled = function () {
            return scribe.api.Command.prototype.queryEnabled.call(this) && scribe.allowsBlockElements();
          };
          scribe.commands.insertOrderedList = new InsertListCommand('insertOrderedList');
          scribe.commands.insertUnorderedList = new InsertListCommand('insertUnorderedList');
        };
      };
    }, {}],
    112: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var outdentCommand = new scribe.api.Command('outdent');
          outdentCommand.queryEnabled = function () {
            var selection = new scribe.api.Selection();
            var listElement = selection.getContaining(function (element) {
              return element.nodeName === 'UL' || element.nodeName === 'OL';
            });
            return scribe.api.Command.prototype.queryEnabled.call(this) && scribe.allowsBlockElements() && !listElement;
          };
          scribe.commands.outdent = outdentCommand;
        };
      };
    }, {}],
    113: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var redoCommand = new scribe.api.Command('redo');
          redoCommand.execute = function () {
            var historyItem = scribe.undoManager.redo();
            if (typeof historyItem !== 'undefined') {
              scribe.restoreFromHistory(historyItem);
            }
          };
          redoCommand.queryEnabled = function () {
            return scribe.undoManager.position < scribe.undoManager.stack.length - 1;
          };
          scribe.commands.redo = redoCommand;
          scribe.el.addEventListener('keydown', function (event) {
            if (event.shiftKey && (event.metaKey || event.ctrlKey) && event.keyCode === 90) {
              event.preventDefault();
              redoCommand.execute();
            }
          });
        };
      };
    }, {}],
    114: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var subscriptCommand = new scribe.api.Command('subscript');
          scribe.commands.subscript = subscriptCommand;
        };
      };
    }, {}],
    115: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var superscriptCommand = new scribe.api.Command('superscript');
          scribe.commands.superscript = superscriptCommand;
        };
      };
    }, {}],
    116: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var undoCommand = new scribe.api.Command('undo');
          undoCommand.execute = function () {
            var historyItem = scribe.undoManager.undo();
            if (typeof historyItem !== 'undefined') {
              scribe.restoreFromHistory(historyItem);
            }
          };
          undoCommand.queryEnabled = function () {
            return scribe.undoManager.position > 1;
          };
          scribe.commands.undo = undoCommand;
          scribe.el.addEventListener('keydown', function (event) {
            if (!event.shiftKey && (event.metaKey || event.ctrlKey) && event.keyCode === 90) {
              event.preventDefault();
              undoCommand.execute();
            }
          });
        };
      };
    }, {}],
    117: [function (require, module, exports) {
      var contains = require('lodash-amd/modern/collections/contains'), observeDomChanges = require('../../dom-observer');
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var pushHistoryOnFocus = function () {
            setTimeout(function () {
              scribe.pushHistory();
            }.bind(scribe), 0);
            scribe.el.removeEventListener('focus', pushHistoryOnFocus);
          }.bind(scribe);
          scribe.el.addEventListener('focus', pushHistoryOnFocus);
          scribe.el.addEventListener('focus', function placeCaretOnFocus() {
            var selection = new scribe.api.Selection();
            if (selection.range) {
              var isFirefoxBug = scribe.allowsBlockElements() && selection.range.startContainer === scribe.el;
              if (isFirefoxBug) {
                var focusElement = getFirstDeepestChild(scribe.el.firstChild);
                var range = selection.range;
                range.setStart(focusElement, 0);
                range.setEnd(focusElement, 0);
                selection.selection.removeAllRanges();
                selection.selection.addRange(range);
              }
            }
            function getFirstDeepestChild(node) {
              var treeWalker = document.createTreeWalker(node, NodeFilter.SHOW_ALL, null, false);
              var previousNode = treeWalker.currentNode;
              if (treeWalker.firstChild()) {
                if (treeWalker.currentNode.nodeName === 'BR') {
                  return previousNode;
                } else {
                  return getFirstDeepestChild(treeWalker.currentNode);
                }
              } else {
                return treeWalker.currentNode;
              }
            }
          }.bind(scribe));
          var applyFormatters = function () {
            if (!scribe._skipFormatters) {
              var selection = new scribe.api.Selection();
              var isEditorActive = selection.range;
              var runFormatters = function () {
                if (isEditorActive) {
                  selection.placeMarkers();
                }
                scribe.setHTML(scribe._htmlFormatterFactory.format(scribe.getHTML()));
                selection.selectMarkers();
              }.bind(scribe);
              if (isEditorActive) {
                scribe.undoManager.undo();
                scribe.transactionManager.run(runFormatters);
              } else {
                runFormatters();
              }
            }
            delete scribe._skipFormatters;
          }.bind(scribe);
          observeDomChanges(scribe.el, applyFormatters);
          if (scribe.allowsBlockElements()) {
            scribe.el.addEventListener('keydown', function (event) {
              if (event.keyCode === 13) {
                var selection = new scribe.api.Selection();
                var range = selection.range;
                var headingNode = selection.getContaining(function (node) {
                  return /^(H[1-6])$/.test(node.nodeName);
                });
                if (headingNode && range.collapsed) {
                  var contentToEndRange = range.cloneRange();
                  contentToEndRange.setEndAfter(headingNode, 0);
                  var contentToEndFragment = contentToEndRange.cloneContents();
                  if (contentToEndFragment.firstChild.textContent === '') {
                    event.preventDefault();
                    scribe.transactionManager.run(function () {
                      var pNode = document.createElement('p');
                      var brNode = document.createElement('br');
                      pNode.appendChild(brNode);
                      headingNode.parentNode.insertBefore(pNode, headingNode.nextElementSibling);
                      range.setStart(pNode, 0);
                      range.setEnd(pNode, 0);
                      selection.selection.removeAllRanges();
                      selection.selection.addRange(range);
                    });
                  }
                }
              }
            });
          }
          if (scribe.allowsBlockElements()) {
            scribe.el.addEventListener('keydown', function (event) {
              if (event.keyCode === 13 || event.keyCode === 8) {
                var selection = new scribe.api.Selection();
                var range = selection.range;
                if (range.collapsed) {
                  var containerLIElement = selection.getContaining(function (node) {
                    return node.nodeName === 'LI';
                  });
                  if (containerLIElement && containerLIElement.textContent.trim() === '') {
                    event.preventDefault();
                    var listNode = selection.getContaining(function (node) {
                      return node.nodeName === 'UL' || node.nodeName === 'OL';
                    });
                    var command = scribe.getCommand(listNode.nodeName === 'OL' ? 'insertOrderedList' : 'insertUnorderedList');
                    command.execute();
                  }
                }
              }
            });
          }
          scribe.el.addEventListener('paste', function handlePaste(event) {
            if (event.clipboardData) {
              event.preventDefault();
              if (contains(event.clipboardData.types, 'text/html')) {
                scribe.insertHTML(event.clipboardData.getData('text/html'));
              } else {
                scribe.insertPlainText(event.clipboardData.getData('text/plain'));
              }
            } else {
              var selection = new scribe.api.Selection();
              selection.placeMarkers();
              var bin = document.createElement('div');
              document.body.appendChild(bin);
              bin.setAttribute('contenteditable', true);
              bin.focus();
              setTimeout(function () {
                var data = bin.innerHTML;
                bin.parentNode.removeChild(bin);
                selection.selectMarkers();
                scribe.el.focus();
                scribe.insertHTML(data);
              }, 1);
            }
          });
        };
      };
    }, {"../../dom-observer": 105, "lodash-amd/modern/collections/contains": 58}],
    118: [function (require, module, exports) {
      var last = require('lodash-amd/modern/arrays/last');
      'use strict';
      function wrapChildNodes(scribe, parentNode) {
        var groups = Array.prototype.reduce.call(parentNode.childNodes, function (accumulator, binChildNode) {
          var group = last(accumulator);
          if (!group) {
            startNewGroup();
          } else {
            var isBlockGroup = scribe.element.isBlockElement(group[0]);
            if (isBlockGroup === scribe.element.isBlockElement(binChildNode)) {
              group.push(binChildNode);
            } else {
              startNewGroup();
            }
          }
          return accumulator;
          function startNewGroup() {
            var newGroup = [binChildNode];
            accumulator.push(newGroup);
          }
        }, []);
        var consecutiveInlineElementsAndTextNodes = groups.filter(function (group) {
          var isBlockGroup = scribe.element.isBlockElement(group[0]);
          return !isBlockGroup;
        });
        consecutiveInlineElementsAndTextNodes.forEach(function (nodes) {
          var pElement = document.createElement('p');
          nodes[0].parentNode.insertBefore(pElement, nodes[0]);
          nodes.forEach(function (node) {
            pElement.appendChild(node);
          });
        });
        parentNode._isWrapped = true;
      }

      function traverse(scribe, parentNode) {
        var treeWalker = document.createTreeWalker(parentNode, NodeFilter.SHOW_ELEMENT, null, false);
        var node = treeWalker.firstChild();
        while (node) {
          if (node.nodeName === 'BLOCKQUOTE' && !node._isWrapped) {
            wrapChildNodes(scribe, node);
            traverse(scribe, parentNode);
            break;
          }
          node = treeWalker.nextSibling();
        }
      }

      module.exports = function () {
        return function (scribe) {
          scribe.registerHTMLFormatter('normalize', function (html) {
            var bin = document.createElement('div');
            bin.innerHTML = html;
            wrapChildNodes(scribe, bin);
            traverse(scribe, bin);
            return bin.innerHTML;
          });
        };
      };
    }, {"lodash-amd/modern/arrays/last": 56}],
    119: [function (require, module, exports) {
      var element = require('../../../../element'), contains = require('lodash-amd/modern/collections/contains');
      'use strict';
      var html5VoidElements = [
        'AREA',
        'BASE',
        'BR',
        'COL',
        'COMMAND',
        'EMBED',
        'HR',
        'IMG',
        'INPUT',
        'KEYGEN',
        'LINK',
        'META',
        'PARAM',
        'SOURCE',
        'TRACK',
        'WBR'
      ];

      function parentHasNoTextContent(element, node) {
        if (element.isCaretPositionNode(node)) {
          return true;
        } else {
          return node.parentNode.textContent.trim() === '';
        }
      }

      function traverse(element, parentNode) {
        var node = parentNode.firstElementChild;

        function isEmpty(node) {
          if (node.children.length === 0 && element.isBlockElement(node) || node.children.length === 1 && element.isSelectionMarkerNode(node.children[0])) {
            return true;
          }
          if (!element.isBlockElement(node) && node.children.length === 0) {
            return parentHasNoTextContent(element, node);
          }
          return false;
        }

        while (node) {
          if (!element.isSelectionMarkerNode(node)) {
            if (isEmpty(node) && node.textContent.trim() === '' && !contains(html5VoidElements, node.nodeName)) {
              node.appendChild(document.createElement('br'));
            } else if (node.children.length > 0) {
              traverse(element, node);
            }
          }
          node = node.nextElementSibling;
        }
      }

      module.exports = function () {
        return function (scribe) {
          scribe.registerHTMLFormatter('normalize', function (html) {
            var bin = document.createElement('div');
            bin.innerHTML = html;
            traverse(scribe.element, bin);
            return bin.innerHTML;
          });
        };
      };
    }, {"../../../../element": 106, "lodash-amd/modern/collections/contains": 58}],
    120: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var nbspCharRegExp = /(\s|&nbsp;)+/g;
          scribe.registerHTMLFormatter('export', function (html) {
            return html.replace(nbspCharRegExp, ' ');
          });
        };
      };
    }, {}],
    121: [function (require, module, exports) {
      var escape = require('lodash-amd/modern/utilities/escape');
      'use strict';
      module.exports = function () {
        return function (scribe) {
          scribe.registerPlainTextFormatter(escape);
        };
      };
    }, {"lodash-amd/modern/utilities/escape": 95}],
    122: [function (require, module, exports) {
      'use strict';
      function hasContent(rootNode) {
        var treeWalker = document.createTreeWalker(rootNode, NodeFilter.SHOW_ALL, null, false);
        while (treeWalker.nextNode()) {
          if (treeWalker.currentNode) {
            if (~['br'].indexOf(treeWalker.currentNode.nodeName.toLowerCase()) || treeWalker.currentNode.length > 0) {
              return true;
            }
          }
        }
        return false;
      }

      module.exports = function () {
        return function (scribe) {
          scribe.el.addEventListener('keydown', function (event) {
            if (event.keyCode === 13) {
              var selection = new scribe.api.Selection();
              var range = selection.range;
              var blockNode = selection.getContaining(function (node) {
                return node.nodeName === 'LI' || /^(H[1-6])$/.test(node.nodeName);
              });
              if (!blockNode) {
                event.preventDefault();
                scribe.transactionManager.run(function () {
                  if (scribe.el.lastChild.nodeName === 'BR') {
                    scribe.el.removeChild(scribe.el.lastChild);
                  }
                  var brNode = document.createElement('br');
                  range.insertNode(brNode);
                  range.collapse(false);
                  var contentToEndRange = range.cloneRange();
                  contentToEndRange.setEndAfter(scribe.el.lastChild, 0);
                  var contentToEndFragment = contentToEndRange.cloneContents();
                  if (!hasContent(contentToEndFragment)) {
                    var bogusBrNode = document.createElement('br');
                    range.insertNode(bogusBrNode);
                  }
                  var newRange = range.cloneRange();
                  newRange.setStartAfter(brNode, 0);
                  newRange.setEndAfter(brNode, 0);
                  selection.selection.removeAllRanges();
                  selection.selection.addRange(newRange);
                });
              }
            }
          }.bind(this));
          if (scribe.getHTML().trim() === '') {
            scribe.setContent('');
          }
        };
      };
    }, {}],
    123: [function (require, module, exports) {
      var boldCommand = require('./patches/commands/bold'), indentCommand = require('./patches/commands/indent'), insertHTMLCommand = require('./patches/commands/insert-html'), insertListCommands = require('./patches/commands/insert-list'), outdentCommand = require('./patches/commands/outdent'), createLinkCommand = require('./patches/commands/create-link'), events = require('./patches/events');
      'use strict';
      module.exports = {
        commands: {
          bold: boldCommand,
          indent: indentCommand,
          insertHTML: insertHTMLCommand,
          insertList: insertListCommands,
          outdent: outdentCommand,
          createLink: createLinkCommand
        },
        events: events
      };
    }, {
      "./patches/commands/bold": 124,
      "./patches/commands/create-link": 125,
      "./patches/commands/indent": 126,
      "./patches/commands/insert-html": 127,
      "./patches/commands/insert-list": 128,
      "./patches/commands/outdent": 129,
      "./patches/events": 130
    }],
    124: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var boldCommand = new scribe.api.CommandPatch('bold');
          boldCommand.queryEnabled = function () {
            var selection = new scribe.api.Selection();
            var headingNode = selection.getContaining(function (node) {
              return /^(H[1-6])$/.test(node.nodeName);
            });
            return scribe.api.CommandPatch.prototype.queryEnabled.apply(this, arguments) && !headingNode;
          };
          scribe.commandPatches.bold = boldCommand;
        };
      };
    }, {}],
    125: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var createLinkCommand = new scribe.api.CommandPatch('createLink');
          scribe.commandPatches.createLink = createLinkCommand;
          createLinkCommand.execute = function (value) {
            var selection = new scribe.api.Selection();
            if (selection.range.collapsed) {
              var aElement = document.createElement('a');
              aElement.setAttribute('href', value);
              aElement.textContent = value;
              selection.range.insertNode(aElement);
              var newRange = document.createRange();
              newRange.setStartBefore(aElement);
              newRange.setEndAfter(aElement);
              selection.selection.removeAllRanges();
              selection.selection.addRange(newRange);
            } else {
              scribe.api.CommandPatch.prototype.execute.call(this, value);
            }
          };
        };
      };
    }, {}],
    126: [function (require, module, exports) {
      'use strict';
      var INVISIBLE_CHAR = '\ufeff';
      module.exports = function () {
        return function (scribe) {
          var indentCommand = new scribe.api.CommandPatch('indent');
          indentCommand.execute = function (value) {
            scribe.transactionManager.run(function () {
              var selection = new scribe.api.Selection();
              var range = selection.range;
              var isCaretOnNewLine = range.commonAncestorContainer.nodeName === 'P' && range.commonAncestorContainer.innerHTML === '<br>';
              if (isCaretOnNewLine) {
                var textNode = document.createTextNode(INVISIBLE_CHAR);
                range.insertNode(textNode);
                range.setStart(textNode, 0);
                range.setEnd(textNode, 0);
                selection.selection.removeAllRanges();
                selection.selection.addRange(range);
              }
              scribe.api.CommandPatch.prototype.execute.call(this, value);
              selection = new scribe.api.Selection();
              var blockquoteNode = selection.getContaining(function (node) {
                return node.nodeName === 'BLOCKQUOTE';
              });
              if (blockquoteNode) {
                blockquoteNode.removeAttribute('style');
              }
            }.bind(this));
          };
          scribe.commandPatches.indent = indentCommand;
        };
      };
    }, {}],
    127: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var insertHTMLCommandPatch = new scribe.api.CommandPatch('insertHTML');
          var element = scribe.element;
          insertHTMLCommandPatch.execute = function (value) {
            scribe.transactionManager.run(function () {
              scribe.api.CommandPatch.prototype.execute.call(this, value);
              sanitize(scribe.el);
              function sanitize(parentNode) {
                var treeWalker = document.createTreeWalker(parentNode, NodeFilter.SHOW_ELEMENT, null, false);
                var node = treeWalker.firstChild();
                if (!node) {
                  return;
                }
                do {
                  if (node.nodeName === 'SPAN') {
                    element.unwrap(parentNode, node);
                  } else {
                    node.style.lineHeight = null;
                    if (node.getAttribute('style') === '') {
                      node.removeAttribute('style');
                    }
                  }
                  sanitize(node);
                } while (node = treeWalker.nextSibling());
              }
            }.bind(this));
          };
          scribe.commandPatches.insertHTML = insertHTMLCommandPatch;
        };
      };
    }, {}],
    128: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var element = scribe.element;
          var nodeHelpers = scribe.node;
          var InsertListCommandPatch = function (commandName) {
            scribe.api.CommandPatch.call(this, commandName);
          };
          InsertListCommandPatch.prototype = Object.create(scribe.api.CommandPatch.prototype);
          InsertListCommandPatch.prototype.constructor = InsertListCommandPatch;
          InsertListCommandPatch.prototype.execute = function (value) {
            scribe.transactionManager.run(function () {
              scribe.api.CommandPatch.prototype.execute.call(this, value);
              if (this.queryState()) {
                var selection = new scribe.api.Selection();
                var listElement = selection.getContaining(function (node) {
                  return node.nodeName === 'OL' || node.nodeName === 'UL';
                });
                if (listElement.nextElementSibling && listElement.nextElementSibling.childNodes.length === 0) {
                  nodeHelpers.removeNode(listElement.nextElementSibling);
                }
                if (listElement) {
                  var listParentNode = listElement.parentNode;
                  if (listParentNode && /^(H[1-6]|P)$/.test(listParentNode.nodeName)) {
                    selection.placeMarkers();
                    nodeHelpers.insertAfter(listElement, listParentNode);
                    selection.selectMarkers();
                    if (listParentNode.childNodes.length === 2 && nodeHelpers.isEmptyTextNode(listParentNode.firstChild)) {
                      nodeHelpers.removeNode(listParentNode);
                    }
                    if (listParentNode.childNodes.length === 0) {
                      nodeHelpers.removeNode(listParentNode);
                    }
                  }
                }
                var listItemElements = Array.prototype.slice.call(listElement.childNodes);
                listItemElements.forEach(function (listItemElement) {
                  var listItemElementChildNodes = Array.prototype.slice.call(listItemElement.childNodes);
                  listItemElementChildNodes.forEach(function (listElementChildNode) {
                    if (listElementChildNode.nodeName === 'SPAN') {
                      var spanElement = listElementChildNode;
                      element.unwrap(listItemElement, spanElement);
                    } else if (listElementChildNode.nodeType === Node.ELEMENT_NODE) {
                      listElementChildNode.style.lineHeight = null;
                      if (listElementChildNode.getAttribute('style') === '') {
                        listElementChildNode.removeAttribute('style');
                      }
                    }
                  });
                });
              }
            }.bind(this));
          };
          scribe.commandPatches.insertOrderedList = new InsertListCommandPatch('insertOrderedList');
          scribe.commandPatches.insertUnorderedList = new InsertListCommandPatch('insertUnorderedList');
        };
      };
    }, {}],
    129: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var outdentCommand = new scribe.api.CommandPatch('outdent');
          outdentCommand.execute = function () {
            scribe.transactionManager.run(function () {
              var selection = new scribe.api.Selection();
              var range = selection.range;
              var blockquoteNode = selection.getContaining(function (node) {
                return node.nodeName === 'BLOCKQUOTE';
              });
              if (range.commonAncestorContainer.nodeName === 'BLOCKQUOTE') {
                selection.placeMarkers();
                selection.selectMarkers(true);
                var selectedNodes = range.cloneContents();
                blockquoteNode.parentNode.insertBefore(selectedNodes, blockquoteNode);
                range.deleteContents();
                selection.selectMarkers();
                if (blockquoteNode.textContent === '') {
                  blockquoteNode.parentNode.removeChild(blockquoteNode);
                }
              } else {
                var pNode = selection.getContaining(function (node) {
                  return node.nodeName === 'P';
                });
                if (pNode) {
                  var nextSiblingNodes = new scribe.api.Node(pNode).nextAll();
                  if (nextSiblingNodes.length) {
                    var newContainerNode = document.createElement(blockquoteNode.nodeName);
                    nextSiblingNodes.forEach(function (siblingNode) {
                      newContainerNode.appendChild(siblingNode);
                    });
                    blockquoteNode.parentNode.insertBefore(newContainerNode, blockquoteNode.nextElementSibling);
                  }
                  selection.placeMarkers();
                  blockquoteNode.parentNode.insertBefore(pNode, blockquoteNode.nextElementSibling);
                  selection.selectMarkers();
                  if (blockquoteNode.innerHTML === '') {
                    blockquoteNode.parentNode.removeChild(blockquoteNode);
                  }
                } else {
                  scribe.api.CommandPatch.prototype.execute.call(this);
                }
              }
            }.bind(this));
          };
          scribe.commandPatches.outdent = outdentCommand;
        };
      };
    }, {}],
    130: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var element = scribe.element;
          if (scribe.allowsBlockElements()) {
            scribe.el.addEventListener('keyup', function (event) {
              if (event.keyCode === 8 || event.keyCode === 46) {
                var selection = new scribe.api.Selection();
                var containerPElement = selection.getContaining(function (node) {
                  return node.nodeName === 'P';
                });
                if (containerPElement) {
                  scribe.undoManager.undo();
                  scribe.transactionManager.run(function () {
                    selection.placeMarkers();
                    var pElementChildNodes = Array.prototype.slice.call(containerPElement.childNodes);
                    pElementChildNodes.forEach(function (pElementChildNode) {
                      if (pElementChildNode.nodeName === 'SPAN') {
                        var spanElement = pElementChildNode;
                        element.unwrap(containerPElement, spanElement);
                      } else if (pElementChildNode.nodeType === Node.ELEMENT_NODE) {
                        pElementChildNode.style.lineHeight = null;
                        if (pElementChildNode.getAttribute('style') === '') {
                          pElementChildNode.removeAttribute('style');
                        }
                      }
                    });
                    selection.selectMarkers();
                  });
                }
              }
            });
          }
        };
      };
    }, {}],
    131: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          if (scribe.getHTML().trim() === '') {
            scribe.setContent('<p><br></p>');
          }
        };
      };
    }, {}],
    132: [function (require, module, exports) {
      var defaults = require('lodash-amd/modern/objects/defaults'), commands = require('./plugins/core/commands'), events = require('./plugins/core/events'), replaceNbspCharsFormatter = require('./plugins/core/formatters/html/replace-nbsp-chars'), enforcePElements = require('./plugins/core/formatters/html/enforce-p-elements'), ensureSelectableContainers = require('./plugins/core/formatters/html/ensure-selectable-containers'), escapeHtmlCharactersFormatter = require('./plugins/core/formatters/plain-text/escape-html-characters'), inlineElementsMode = require('./plugins/core/inline-elements-mode'), patches = require('./plugins/core/patches'), setRootPElement = require('./plugins/core/set-root-p-element'), Api = require('./api'), buildTransactionManager = require('./transaction-manager'), buildUndoManager = require('./undo-manager'), EventEmitter = require('./event-emitter'), elementHelpers = require('./element'), nodeHelpers = require('./node'), Immutable = require('immutable/dist/immutable');
      'use strict';
      function Scribe(el, options) {
        EventEmitter.call(this);
        this.el = el;
        this.commands = {};
        this.options = defaults(options || {}, {
          allowBlockElements: true,
          debug: false,
          defaultCommandPatches: [
            'bold',
            'indent',
            'insertHTML',
            'insertList',
            'outdent',
            'createLink'
          ]
        });
        this.commandPatches = {};
        this._plainTextFormatterFactory = new FormatterFactory();
        this._htmlFormatterFactory = new HTMLFormatterFactory();
        this.api = new Api(this);
        this.node = nodeHelpers;
        this.element = elementHelpers;
        this.Immutable = Immutable;
        var TransactionManager = buildTransactionManager(this);
        this.transactionManager = new TransactionManager();
        var UndoManager = buildUndoManager(this);
        this.undoManager = new UndoManager();
        this.el.setAttribute('contenteditable', true);
        this.el.addEventListener('input', function () {
          this.transactionManager.run();
        }.bind(this), false);
        if (this.allowsBlockElements()) {
          this.use(setRootPElement());
          this.use(enforcePElements());
          this.use(ensureSelectableContainers());
        } else {
          this.use(inlineElementsMode());
        }
        var defaultFormatters = Immutable.List.of(escapeHtmlCharactersFormatter, replaceNbspCharsFormatter);
        var defaultPatches = Immutable.List.of(patches.events);
        var defaultCommandPatches = Immutable.List(this.options.defaultCommandPatches).map(function (patch) {
          return patches.commands[patch];
        });
        var defaultCommands = Immutable.List.of('indent', 'insertList', 'outdent', 'redo', 'subscript', 'superscript', 'undo').map(function (command) {
          return commands[command];
        });
        var allPlugins = Immutable.List().concat(defaultFormatters, defaultPatches, defaultCommandPatches, defaultCommands);
        allPlugins.forEach(function (plugin) {
          this.use(plugin());
        }.bind(this));
        this.use(events());
      }

      Scribe.prototype = Object.create(EventEmitter.prototype);
      Scribe.prototype.use = function (configurePlugin) {
        configurePlugin(this);
        return this;
      };
      Scribe.prototype.setHTML = function (html, skipFormatters) {
        if (skipFormatters) {
          this._skipFormatters = true;
        }
        if (this.el.innerHTML !== html) {
          this.el.innerHTML = html;
        }
      };
      Scribe.prototype.getHTML = function () {
        return this.el.innerHTML;
      };
      Scribe.prototype.getContent = function () {
        return this._htmlFormatterFactory.formatForExport(this.getHTML().replace(/<br>$/, ''));
      };
      Scribe.prototype.getTextContent = function () {
        return this.el.textContent;
      };
      Scribe.prototype.pushHistory = function () {
        var previousUndoItem = this.undoManager.stack[this.undoManager.position];
        var previousContent = previousUndoItem && previousUndoItem.replace(/<em class="scribe-marker">/g, '').replace(/<\/em>/g, '');
        if (!previousUndoItem || previousUndoItem && this.getHTML() !== previousContent) {
          var selection = new this.api.Selection();
          selection.placeMarkers();
          var html = this.getHTML();
          selection.removeMarkers();
          this.undoManager.push(html);
          return true;
        } else {
          return false;
        }
      };
      Scribe.prototype.getCommand = function (commandName) {
        return this.commands[commandName] || this.commandPatches[commandName] || new this.api.Command(commandName);
      };
      Scribe.prototype.restoreFromHistory = function (historyItem) {
        this.setHTML(historyItem, true);
        var selection = new this.api.Selection();
        selection.selectMarkers();
        this.trigger('content-changed');
      };
      Scribe.prototype.allowsBlockElements = function () {
        return this.options.allowBlockElements;
      };
      Scribe.prototype.setContent = function (content) {
        if (!this.allowsBlockElements()) {
          content = content + '<br>';
        }
        this.setHTML(content);
        this.trigger('content-changed');
      };
      Scribe.prototype.insertPlainText = function (plainText) {
        this.insertHTML('<p>' + this._plainTextFormatterFactory.format(plainText) + '</p>');
      };
      Scribe.prototype.insertHTML = function (html) {
        this.getCommand('insertHTML').execute(this._htmlFormatterFactory.format(html));
      };
      Scribe.prototype.isDebugModeEnabled = function () {
        return this.options.debug;
      };
      Scribe.prototype.registerHTMLFormatter = function (phase, fn) {
        this._htmlFormatterFactory.formatters[phase] = this._htmlFormatterFactory.formatters[phase].push(fn);
      };
      Scribe.prototype.registerPlainTextFormatter = function (fn) {
        this._plainTextFormatterFactory.formatters = this._plainTextFormatterFactory.formatters.push(fn);
      };
      function FormatterFactory() {
        this.formatters = Immutable.List();
      }

      FormatterFactory.prototype.format = function (html) {
        var formatted = this.formatters.reduce(function (formattedData, formatter) {
          return formatter(formattedData);
        }, html);
        return formatted;
      };
      function HTMLFormatterFactory() {
        this.formatters = {
          sanitize: Immutable.List(),
          normalize: Immutable.List(),
          'export': Immutable.List()
        };
      }

      HTMLFormatterFactory.prototype = Object.create(FormatterFactory.prototype);
      HTMLFormatterFactory.prototype.constructor = HTMLFormatterFactory;
      HTMLFormatterFactory.prototype.format = function (html) {
        var formatters = this.formatters.sanitize.concat(this.formatters.normalize);
        var formatted = formatters.reduce(function (formattedData, formatter) {
          return formatter(formattedData);
        }, html);
        return formatted;
      };
      HTMLFormatterFactory.prototype.formatForExport = function (html) {
        return this.formatters['export'].reduce(function (formattedData, formatter) {
          return formatter(formattedData);
        }, html);
      };
      module.exports = Scribe;
    }, {
      "./api": 99,
      "./element": 106,
      "./event-emitter": 107,
      "./node": 108,
      "./plugins/core/commands": 109,
      "./plugins/core/events": 117,
      "./plugins/core/formatters/html/enforce-p-elements": 118,
      "./plugins/core/formatters/html/ensure-selectable-containers": 119,
      "./plugins/core/formatters/html/replace-nbsp-chars": 120,
      "./plugins/core/formatters/plain-text/escape-html-characters": 121,
      "./plugins/core/inline-elements-mode": 122,
      "./plugins/core/patches": 123,
      "./plugins/core/set-root-p-element": 131,
      "./transaction-manager": 133,
      "./undo-manager": 134,
      "immutable/dist/immutable": 54,
      "lodash-amd/modern/objects/defaults": 84
    }],
    133: [function (require, module, exports) {
      var assign = require('lodash-amd/modern/objects/assign');
      'use strict';
      module.exports = function (scribe) {
        function TransactionManager() {
          this.history = [];
        }

        assign(TransactionManager.prototype, {
          start: function () {
            this.history.push(1);
          },
          end: function () {
            this.history.pop();
            if (this.history.length === 0) {
              scribe.pushHistory();
              scribe.trigger('content-changed');
            }
          },
          run: function (transaction) {
            this.start();
            try {
              if (transaction) {
                transaction();
              }
            } finally {
              this.end();
            }
          }
        });
        return TransactionManager;
      };
    }, {"lodash-amd/modern/objects/assign": 83}],
    134: [function (require, module, exports) {
      'use strict';
      module.exports = function (scribe) {
        function UndoManager() {
          this.position = -1;
          this.stack = [];
          this.debug = scribe.isDebugModeEnabled();
        }

        UndoManager.prototype.maxStackSize = 100;
        UndoManager.prototype.push = function (item) {
          if (this.debug) {
            console.log('UndoManager.push: %s', item);
          }
          this.stack.length = ++this.position;
          this.stack.push(item);
          while (this.stack.length > this.maxStackSize) {
            this.stack.shift();
            --this.position;
          }
        };
        UndoManager.prototype.undo = function () {
          if (this.position > 0) {
            return this.stack[--this.position];
          }
        };
        UndoManager.prototype.redo = function () {
          if (this.position < this.stack.length - 1) {
            return this.stack[++this.position];
          }
        };
        return UndoManager;
      };
    }, {}],
    135: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          scribe.registerPlainTextFormatter(function (html) {
            return html.replace(/\n([ \t]*\n)+/g, '</p><p>').replace(/\n/g, '<br>');
          });
        };
      };
    }, {}],
    136: [function (require, module, exports) {
      'use strict';
      module.exports = function () {
        return function (scribe) {
          var linkPromptCommand = new scribe.api.Command('createLink');
          linkPromptCommand.nodeName = 'A';
          linkPromptCommand.execute = function () {
            var selection = new scribe.api.Selection();
            var range = selection.range;
            var anchorNode = selection.getContaining(function (node) {
              return node.nodeName === this.nodeName;
            }.bind(this));
            var initialLink = anchorNode ? anchorNode.href : '';
            var link = window.prompt('Enter a link.', initialLink);
            if (anchorNode) {
              range.selectNode(anchorNode);
              selection.selection.removeAllRanges();
              selection.selection.addRange(range);
            }
            if (link) {
              var urlProtocolRegExp = /^https?\:\/\//;
              var mailtoProtocolRegExp = /^mailto\:/;
              if (!urlProtocolRegExp.test(link) && !mailtoProtocolRegExp.test(link)) {
                if (/@/.test(link)) {
                  var shouldPrefixEmail = window.confirm('The URL you entered appears to be an email address. ' + 'Do you want to add the required \u201cmailto:\u201d prefix?');
                  if (shouldPrefixEmail) {
                    link = 'mailto:' + link;
                  }
                } else {
                  var shouldPrefixLink = window.confirm('The URL you entered appears to be a link. ' + 'Do you want to add the required \u201chttp://\u201d prefix?');
                  if (shouldPrefixLink) {
                    link = 'http://' + link;
                  }
                }
              }
              scribe.api.SimpleCommand.prototype.execute.call(this, link);
            }
          };
          linkPromptCommand.queryState = function () {
            var selection = new scribe.api.Selection();
            return !!selection.getContaining(function (node) {
              return node.nodeName === this.nodeName;
            }.bind(this));
          };
          scribe.commands.linkPrompt = linkPromptCommand;
        };
      };
    }, {}],
    137: [function (require, module, exports) {
      /**
       * Copyright (c) 2011-2014 Felix Gnass
       * Licensed under the MIT license
       */
      (function (root, factory) {

        /* CommonJS */
        if (typeof exports == 'object')  module.exports = factory()

        /* AMD module */
        else if (typeof define == 'function' && define.amd) define(factory)

        /* Browser global */
        else root.Spinner = factory()
      }
      (this, function () {
        "use strict";

        var prefixes = ['webkit', 'Moz', 'ms', 'O'] /* Vendor prefixes */
          , animations = {} /* Animation rules keyed by their name */
          , useCssAnimations
        /* Whether to use CSS animations or setTimeout */

        /**
         * Utility function to create elements. If no tag name is given,
         * a DIV is created. Optionally properties can be passed.
         */
        function createEl(tag, prop) {
          var el = document.createElement(tag || 'div')
            , n

          for (n in prop) el[n] = prop[n]
          return el
        }

        /**
         * Appends children and returns the parent.
         */
        function ins(parent /* child1, child2, ...*/) {
          for (var i = 1, n = arguments.length; i < n; i++)
            parent.appendChild(arguments[i])

          return parent
        }

        /**
         * Insert a new stylesheet to hold the @keyframe or VML rules.
         */
        var sheet = (function () {
          var el = createEl('style', {type: 'text/css'})
          ins(document.getElementsByTagName('head')[0], el)
          return el.sheet || el.styleSheet
        }())

        /**
         * Creates an opacity keyframe animation rule and returns its name.
         * Since most mobile Webkits have timing issues with animation-delay,
         * we create separate rules for each line/segment.
         */
        function addAnimation(alpha, trail, i, lines) {
          var name = ['opacity', trail, ~~(alpha * 100), i, lines].join('-')
            , start = 0.01 + i / lines * 100
            , z = Math.max(1 - (1 - alpha) / trail * (100 - start), alpha)
            , prefix = useCssAnimations.substring(0, useCssAnimations.indexOf('Animation')).toLowerCase()
            , pre = prefix && '-' + prefix + '-' || ''

          if (!animations[name]) {
            sheet.insertRule(
              '@' + pre + 'keyframes ' + name + '{' +
              '0%{opacity:' + z + '}' +
              start + '%{opacity:' + alpha + '}' +
              (start + 0.01) + '%{opacity:1}' +
              (start + trail) % 100 + '%{opacity:' + alpha + '}' +
              '100%{opacity:' + z + '}' +
              '}', sheet.cssRules.length)

            animations[name] = 1
          }

          return name
        }

        /**
         * Tries various vendor prefixes and returns the first supported property.
         */
        function vendor(el, prop) {
          var s = el.style
            , pp
            , i

          prop = prop.charAt(0).toUpperCase() + prop.slice(1)
          for (i = 0; i < prefixes.length; i++) {
            pp = prefixes[i] + prop
            if (s[pp] !== undefined) return pp
          }
          if (s[prop] !== undefined) return prop
        }

        /**
         * Sets multiple style properties at once.
         */
        function css(el, prop) {
          for (var n in prop)
            el.style[vendor(el, n) || n] = prop[n]

          return el
        }

        /**
         * Fills in default values.
         */
        function merge(obj) {
          for (var i = 1; i < arguments.length; i++) {
            var def = arguments[i]
            for (var n in def)
              if (obj[n] === undefined) obj[n] = def[n]
          }
          return obj
        }

        /**
         * Returns the line color from the given string or array.
         */
        function getColor(color, idx) {
          return typeof color == 'string' ? color : color[idx % color.length]
        }

        // Built-in defaults

        var defaults = {
          lines: 12,            // The number of lines to draw
          length: 7,            // The length of each line
          width: 5,             // The line thickness
          radius: 10,           // The radius of the inner circle
          rotate: 0,            // Rotation offset
          corners: 1,           // Roundness (0..1)
          color: '#000',        // #rgb or #rrggbb
          direction: 1,         // 1: clockwise, -1: counterclockwise
          speed: 1,             // Rounds per second
          trail: 100,           // Afterglow percentage
          opacity: 1 / 4,         // Opacity of the lines
          fps: 20,              // Frames per second when using setTimeout()
          zIndex: 2e9,          // Use a high z-index by default
          className: 'spinner', // CSS class to assign to the element
          top: '50%',           // center vertically
          left: '50%',          // center horizontally
          position: 'absolute'  // element position
        }

        /** The constructor */
        function Spinner(o) {
          this.opts = merge(o || {}, Spinner.defaults, defaults)
        }

        // Global defaults that override the built-ins:
        Spinner.defaults = {}

        merge(Spinner.prototype, {

          /**
           * Adds the spinner to the given target element. If this instance is already
           * spinning, it is automatically removed from its previous target b calling
           * stop() internally.
           */
          spin: function (target) {
            this.stop()

            var self = this
              , o = self.opts
              , el = self.el = css(createEl(0, {className: o.className}), {
                position: o.position,
                width: 0,
                zIndex: o.zIndex
              })

            css(el, {
              left: o.left,
              top: o.top
            })

            if (target) {
              target.insertBefore(el, target.firstChild || null)
            }

            el.setAttribute('role', 'progressbar')
            self.lines(el, self.opts)

            if (!useCssAnimations) {
              // No CSS animation support, use setTimeout() instead
              var i = 0
                , start = (o.lines - 1) * (1 - o.direction) / 2
                , alpha
                , fps = o.fps
                , f = fps / o.speed
                , ostep = (1 - o.opacity) / (f * o.trail / 100)
                , astep = f / o.lines

                ;
              (function anim() {
                i++;
                for (var j = 0; j < o.lines; j++) {
                  alpha = Math.max(1 - (i + (o.lines - j) * astep) % f * ostep, o.opacity)

                  self.opacity(el, j * o.direction + start, alpha, o)
                }
                self.timeout = self.el && setTimeout(anim, ~~(1000 / fps))
              })()
            }
            return self
          },

          /**
           * Stops and removes the Spinner.
           */
          stop: function () {
            var el = this.el
            if (el) {
              clearTimeout(this.timeout)
              if (el.parentNode) el.parentNode.removeChild(el)
              this.el = undefined
            }
            return this
          },

          /**
           * Internal method that draws the individual lines. Will be overwritten
           * in VML fallback mode below.
           */
          lines: function (el, o) {
            var i = 0
              , start = (o.lines - 1) * (1 - o.direction) / 2
              , seg

            function fill(color, shadow) {
              return css(createEl(), {
                position: 'absolute',
                width: (o.length + o.width) + 'px',
                height: o.width + 'px',
                background: color,
                boxShadow: shadow,
                transformOrigin: 'left',
                transform: 'rotate(' + ~~(360 / o.lines * i + o.rotate) + 'deg) translate(' + o.radius + 'px' + ',0)',
                borderRadius: (o.corners * o.width >> 1) + 'px'
              })
            }

            for (; i < o.lines; i++) {
              seg = css(createEl(), {
                position: 'absolute',
                top: 1 + ~(o.width / 2) + 'px',
                transform: o.hwaccel ? 'translate3d(0,0,0)' : '',
                opacity: o.opacity,
                animation: useCssAnimations && addAnimation(o.opacity, o.trail, start + i * o.direction, o.lines) + ' ' + 1 / o.speed + 's linear infinite'
              })

              if (o.shadow) ins(seg, css(fill('#000', '0 0 4px ' + '#000'), {top: 2 + 'px'}))
              ins(el, ins(seg, fill(getColor(o.color, i), '0 0 1px rgba(0,0,0,.1)')))
            }
            return el
          },

          /**
           * Internal method that adjusts the opacity of a single line.
           * Will be overwritten in VML fallback mode below.
           */
          opacity: function (el, i, val) {
            if (i < el.childNodes.length) el.childNodes[i].style.opacity = val
          }

        })


        function initVML() {

          /* Utility function to create a VML tag */
          function vml(tag, attr) {
            return createEl('<' + tag + ' xmlns="urn:schemas-microsoft.com:vml" class="spin-vml">', attr)
          }

          // No CSS transforms but VML support, add a CSS rule for VML elements:
          sheet.addRule('.spin-vml', 'behavior:url(#default#VML)')

          Spinner.prototype.lines = function (el, o) {
            var r = o.length + o.width
              , s = 2 * r

            function grp() {
              return css(
                vml('group', {
                  coordsize: s + ' ' + s,
                  coordorigin: -r + ' ' + -r
                }),
                {width: s, height: s}
              )
            }

            var margin = -(o.width + o.length) * 2 + 'px'
              , g = css(grp(), {position: 'absolute', top: margin, left: margin})
              , i

            function seg(i, dx, filter) {
              ins(g,
                ins(css(grp(), {rotation: 360 / o.lines * i + 'deg', left: ~~dx}),
                  ins(css(vml('roundrect', {arcsize: o.corners}), {
                      width: r,
                      height: o.width,
                      left: o.radius,
                      top: -o.width >> 1,
                      filter: filter
                    }),
                    vml('fill', {color: getColor(o.color, i), opacity: o.opacity}),
                    vml('stroke', {opacity: 0}) // transparent stroke to fix color bleeding upon opacity change
                  )
                )
              )
            }

            if (o.shadow)
              for (i = 1; i <= o.lines; i++)
                seg(i, -2, 'progid:DXImageTransform.Microsoft.Blur(pixelradius=2,makeshadow=1,shadowopacity=.3)')

            for (i = 1; i <= o.lines; i++) seg(i)
            return ins(el, g)
          }

          Spinner.prototype.opacity = function (el, i, val, o) {
            var c = el.firstChild
            o = o.shadow && o.lines || 0
            if (c && i + o < c.childNodes.length) {
              c = c.childNodes[i + o];
              c = c && c.firstChild;
              c = c && c.firstChild
              if (c) c.opacity = val
            }
          }
        }

        var probe = css(createEl('group'), {behavior: 'url(#default#VML)'})

        if (!vendor(probe, 'transform') && probe.adj) initVML()
        else useCssAnimations = vendor(probe, 'animation')

        return Spinner

      }));

    }, {}],
    138: [function (require, module, exports) {
      "use strict";

      var _ = require('./lodash');
      var Blocks = require('./blocks');

      var BlockControl = function (type) {
        this.type = type;
        this.block_type = Blocks[this.type].prototype;
        this.can_be_rendered = this.block_type.toolbarEnabled;

        this._ensureElement();
      };

      Object.assign(BlockControl.prototype, require('./function-bind'), require('./renderable'), require('./events'), {

        tagName: 'a',
        className: "st-block-control",

        attributes: function () {
          return {
            'data-type': this.block_type.type
          };
        },

        render: function () {
          this.$el.html('<span class="st-icon">' + _.result(this.block_type, 'icon_name') + '</span>' + _.result(this.block_type, 'title'));
          return this;
        }
      });

      module.exports = BlockControl;

    }, {"./blocks": 156, "./events": 166, "./function-bind": 173, "./lodash": 178, "./renderable": 180}],
    139: [function (require, module, exports) {
      (function (global) {
        "use strict";

        /*
         * SirTrevor Block Controls
         * --
         * Gives an interface for adding new Sir Trevor blocks.
         */

        var _ = require('./lodash');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);

        var Blocks = require('./blocks');
        var BlockControl = require('./block-control');
        var EventBus = require('./event-bus');

        var BlockControls = function (available_types, mediator) {
          this.available_types = available_types || [];
          this.mediator = mediator;

          this._ensureElement();
          this._bindFunctions();
          this._bindMediatedEvents();

          this.initialize();
        };

        Object.assign(BlockControls.prototype, require('./function-bind'), require('./mediated-events'), require('./renderable'), require('./events'), {

          bound: ['handleControlButtonClick'],
          block_controls: null,

          className: "st-block-controls",
          eventNamespace: 'block-controls',

          mediatedEvents: {
            'render': 'renderInContainer',
            'show': 'show',
            'hide': 'hide'
          },

          initialize: function () {
            for (var block_type in this.available_types) {
              if (Blocks.hasOwnProperty(block_type)) {
                var block_control = new BlockControl(block_type);
                if (block_control.can_be_rendered) {
                  this.$el.append(block_control.render().$el);
                }
              }
            }

            this.$el.delegate('.st-block-control', 'click', this.handleControlButtonClick);
            this.mediator.on('block-controls:show', this.renderInContainer);
          },

          show: function () {
            this.$el.addClass('st-block-controls--active');

            EventBus.trigger('block:controls:shown');
          },

          hide: function () {
            this.removeCurrentContainer();
            this.$el.removeClass('st-block-controls--active');

            EventBus.trigger('block:controls:hidden');
          },

          handleControlButtonClick: function (e) {
            e.stopPropagation();

            this.mediator.trigger('block:create', $(e.currentTarget).attr('data-type'), null, this.current_container);
          },

          renderInContainer: function (container) {
            this.removeCurrentContainer();

            container.append(this.$el.detach());
            container.addClass('with-st-controls');

            this.currentContainer = container;
            this.show();
          },

          removeCurrentContainer: function () {
            if (!_.isUndefined(this.currentContainer)) {
              this.currentContainer.removeClass("with-st-controls");
              this.currentContainer = undefined;
            }
          }
        });

        module.exports = BlockControls;

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {
      "./block-control": 138,
      "./blocks": 156,
      "./event-bus": 165,
      "./events": 166,
      "./function-bind": 173,
      "./lodash": 178,
      "./mediated-events": 179,
      "./renderable": 180
    }],
    140: [function (require, module, exports) {
      "use strict";

      var BlockDeletion = function () {
        this._ensureElement();
        this._bindFunctions();
      };

      Object.assign(BlockDeletion.prototype, require('./function-bind'), require('./renderable'), {

        tagName: 'a',
        className: 'st-block-ui-btn st-block-ui-btn--delete st-icon',

        attributes: {
          html: 'delete',
          'data-icon': 'bin'
        }

      });

      module.exports = BlockDeletion;

    }, {"./function-bind": 173, "./renderable": 180}],
    141: [function (require, module, exports) {
      (function (global) {
        "use strict";

        var _ = require('./lodash');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);
        var utils = require('./utils');
        var config = require('./config');

        var EventBus = require('./event-bus');
        var Blocks = require('./blocks');

        var BLOCK_OPTION_KEYS = ['convertToMarkdown', 'convertFromMarkdown',
          'formatBar'];

        var BlockManager = function (options, editorInstance, mediator) {
          this.options = options;
          this.blockOptions = BLOCK_OPTION_KEYS.reduce(function (acc, key) {
            acc[key] = options[key];
            return acc;
          }, {});
          this.instance_scope = editorInstance; // It's Sir Trevor editor instance now. ID is useless. Passing Sir Trevor instance gives more flexibility.
          this.mediator = mediator;

          this.blocks = [];
          this.blockCounts = {};
          this.blockTypes = {};

          this._setBlocksTypes();
          this._setRequired();
          this._bindMediatedEvents();

          this.initialize();
        };

        Object.assign(BlockManager.prototype, require('./function-bind'), require('./mediated-events'), require('./events'), {

          eventNamespace: 'block',

          mediatedEvents: {
            'create': 'createBlock',
            'remove': 'removeBlock',
            'rerender': 'rerenderBlock'
          },

          initialize: function () {
          },

          createBlock: function (type, data, render_at) {
            type = utils.classify(type);

            // Run validations
            if (!this.canCreateBlock(type)) {
              return;
            }

            var block = new Blocks[type](data, this.instance_scope, this.mediator,
              this.blockOptions);
            this.blocks.push(block);

            this._incrementBlockTypeCount(type);
            this.mediator.trigger('block:render', block, render_at);

            this.triggerBlockCountUpdate();
            this.mediator.trigger('block:limitReached', this.blockLimitReached());

            EventBus.trigger(data ? "block:create:existing" : "block:create:new", block);
            utils.log("Block created of type " + type);

            return block;
          },

          removeBlock: function (blockID) {
            var block = this.findBlockById(blockID),
              type = utils.classify(block.type);

            // assume there can be nested blocks. if none - it's ok.
            if (!_.isUndefined(block.$el)) {
              var nested_blocks = block.$el.find('.st-block');
              if (nested_blocks.length > 0) {
                var list = nested_blocks.map(function () {
                  return {depth: $(this).parents().length, id: this.getAttribute('id')};
                }).get();
                list.sort(function (a, b) {
                  return a.depth - b.depth;
                });
                // remove nested blocks in a proper order (deepest first)
                for (var i = 0; i < list.length; i++) {
                  this.removeBlock(list[i].id);
                }
              }
            }

            this.mediator.trigger('block-controls:reset');
            this.blocks = this.blocks.filter(function (item) {
              return (item.blockID !== block.blockID);
            });

            this._decrementBlockTypeCount(type);
            this.triggerBlockCountUpdate();
            this.mediator.trigger('block:limitReached', this.blockLimitReached());

            EventBus.trigger("block:remove");
          },

          rerenderBlock: function (blockID) {
            var block = this.findBlockById(blockID);
            if (!_.isUndefined(block) && !block.isEmpty() &&
              block.drop_options.re_render_on_reorder) {
              block.beforeLoadingData();
            }
          },

          triggerBlockCountUpdate: function () {
            this.mediator.trigger('block:countUpdate', this.blocks.length);
          },

          canCreateBlock: function (type) {
            if (this.blockLimitReached()) {
              utils.log("Cannot add any more blocks. Limit reached.");
              return false;
            }

            if (!this.isBlockTypeAvailable(type)) {
              utils.log("Block type not available " + type);
              return false;
            }

            // Can we have another one of these blocks?
            if (!this.canAddBlockType(type)) {
              utils.log("Block Limit reached for type " + type);
              return false;
            }

            return true;
          },

          validateBlockTypesExist: function (shouldValidate) {
            if (config.skipValidation || !shouldValidate) {
              return false;
            }

            (this.required || []).forEach(function (type, index) {
              if (!this.isBlockTypeAvailable(type)) {
                return;
              }

              if (this._getBlockTypeCount(type) === 0) {
                utils.log("Failed validation on required block type " + type);
                this.mediator.trigger('errors:add',
                  {text: i18n.t("errors:type_missing", {type: type})});

              } else {
                var blocks = this.getBlocksByType(type).filter(function (b) {
                  return !b.isEmpty();
                });

                if (blocks.length > 0) {
                  return false;
                }

                this.mediator.trigger('errors:add', {
                  text: i18n.t("errors:required_type_empty", {type: type})
                });

                utils.log("A required block type " + type + " is empty");
              }
            }, this);
          },

          findBlockById: function (blockID) {
            return this.blocks.find(function (b) {
              return b.blockID === blockID;
            });
          },

          getBlocksByType: function (type) {
            return this.blocks.filter(function (b) {
              return utils.classify(b.type) === type;
            });
          },

          getBlocksByIDs: function (block_ids) {
            return this.blocks.filter(function (b) {
              return block_ids.includes(b.blockID);
            });
          },

          blockLimitReached: function () {
            return (this.options.blockLimit !== 0 && this.blocks.length >= this.options.blockLimit);
          },

          isBlockTypeAvailable: function (t) {
            return !_.isUndefined(this.blockTypes[t]);
          },

          canAddBlockType: function (type) {
            var block_type_limit = this._getBlockTypeLimit(type);
            return !(block_type_limit !== 0 && this._getBlockTypeCount(type) >= block_type_limit);
          },

          _setBlocksTypes: function () {
            this.blockTypes = utils.flatten(
              _.isUndefined(this.options.blockTypes) ?
                Blocks : this.options.blockTypes);
          },

          _setRequired: function () {
            this.required = false;

            if (Array.isArray(this.options.required) && !_.isEmpty(this.options.required)) {
              this.required = this.options.required;
            }
          },

          _incrementBlockTypeCount: function (type) {
            this.blockCounts[type] = (_.isUndefined(this.blockCounts[type])) ? 1 : this.blockCounts[type] + 1;
          },

          _decrementBlockTypeCount: function (type) {
            this.blockCounts[type] = (_.isUndefined(this.blockCounts[type])) ? 1 : this.blockCounts[type] - 1;
          },

          _getBlockTypeCount: function (type) {
            return (_.isUndefined(this.blockCounts[type])) ? 0 : this.blockCounts[type];
          },

          _blockLimitReached: function () {
            return (this.options.blockLimit !== 0 && this.blocks.length >= this.options.blockLimit);
          },

          _getBlockTypeLimit: function (t) {
            if (!this.isBlockTypeAvailable(t)) {
              return 0;
            }
            return parseInt((_.isUndefined(this.options.blockTypeLimits[t])) ? 0 : this.options.blockTypeLimits[t], 10);
          }

        });

        module.exports = BlockManager;


      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {
      "./blocks": 156,
      "./config": 162,
      "./event-bus": 165,
      "./events": 166,
      "./function-bind": 173,
      "./lodash": 178,
      "./mediated-events": 179,
      "./utils": 184
    }],
    142: [function (require, module, exports) {
      "use strict";

      var template = [
        "<div class='st-block-positioner__inner'>",
        "<span class='st-block-positioner__selected-value'></span>",
        "<select class='st-block-positioner__select'></select>",
        "</div>"
      ].join("\n");

      var BlockPositioner = function (block_element, mediator) {
        this.mediator = mediator;
        this.$block = block_element;

        this._ensureElement();
        this._bindFunctions();

        this.initialize();
      };

      Object.assign(BlockPositioner.prototype, require('./function-bind'), require('./renderable'), {

        total_blocks: 0,

        bound: ['onBlockCountChange', 'onSelectChange', 'toggle', 'show', 'hide'],

        className: 'st-block-positioner',
        visibleClass: 'st-block-positioner--is-visible',

        initialize: function () {
          this.$el.append(template);
          this.$select = this.$('.st-block-positioner__select');

          this.$select.on('change', this.onSelectChange);

          this.mediator.on("block:countUpdate", this.onBlockCountChange);
        },

        onBlockCountChange: function (new_count) {
          // count only siblings blocks
          new_count = this.$block.siblings('.st-block').length + 1;
          if (new_count !== this.total_blocks) {
            this.total_blocks = new_count;
            this.renderPositionList();
          }
        },

        onSelectChange: function () {
          var val = this.$select.val();
          if (val !== 0) {
            this.mediator.trigger(
              "block:changePosition", this.$block, val,
              (val === 1 ? 'before' : 'after'));
            this.toggle();
          }
        },

        renderPositionList: function () {
          var inner = "<option value='0'>" + i18n.t("general:position") + "</option>";
          for (var i = 1; i <= this.total_blocks; i++) {
            inner += "<option value=" + i + ">" + i + "</option>";
          }
          this.$select.html(inner);
        },

        toggle: function () {
          this.$select.val(0);
          this.$el.toggleClass(this.visibleClass);
        },

        show: function () {
          this.$el.addClass(this.visibleClass);
        },

        hide: function () {
          this.$el.removeClass(this.visibleClass);
        }

      });

      module.exports = BlockPositioner;

    }, {"./function-bind": 173, "./renderable": 180}],
    143: [function (require, module, exports) {
      (function (global) {
        "use strict";

        var _ = require('./lodash');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);

        var EventBus = require('./event-bus');

        var BlockReorder = function (block_element, mediator) {
          this.$block = block_element;
          this.blockID = this.$block.attr('id');
          this.mediator = mediator;

          this._ensureElement();
          this._bindFunctions();

          this.initialize();
        };

        Object.assign(BlockReorder.prototype, require('./function-bind'), require('./renderable'), {

          bound: ['onMouseDown', 'onDragStart', 'onDragEnd', 'onDrop'],

          className: 'st-block-ui-btn st-block-ui-btn--reorder st-icon',
          tagName: 'a',

          attributes: function () {
            return {
              'html': 'reorder',
              'draggable': 'true',
              'data-icon': 'move'
            };
          },

          initialize: function () {
            this.$el.bind('mousedown touchstart', this.onMouseDown)
              .bind('dragstart', this.onDragStart)
              .bind('dragend touchend', this.onDragEnd);

            this.$block.dropArea()
              .bind('drop', this.onDrop);
          },

          blockId: function () {
            return this.$block.attr('id');
          },

          onMouseDown: function () {
            this.mediator.trigger("block-controls:hide");
            EventBus.trigger("block:reorder:down");
          },

          onDrop: function (ev) {
            ev.preventDefault();
            ev.stopPropagation(); // to prevent event handling on outer blocks

            var dropped_on = this.$block,
              item_id = ev.originalEvent.dataTransfer.getData("text/plain"),
              block = $('#' + item_id);

            if (!_.isUndefined(item_id) && !_.isEmpty(block) &&
              dropped_on.attr('id') !== item_id &&
              dropped_on.attr('data-instance') === block.attr('data-instance') && !$.contains(block[0], dropped_on[0]) // additional check for nested blocks: disallow dropping block inside the block itself
            ) {
              dropped_on.after(block);
            }
            this.mediator.trigger("block:rerender", item_id);
            EventBus.trigger("block:reorder:dropped", item_id);
          },

          onDragStart: function (ev) {
            var btn = $(ev.currentTarget).parent();

            ev.originalEvent.dataTransfer.setDragImage(this.$block[0], btn.position().left, btn.position().top);
            ev.originalEvent.dataTransfer.setData('Text', this.blockId());

            EventBus.trigger("block:reorder:dragstart");
            this.$block.addClass('st-block--dragging');
          },

          onDragEnd: function (ev) {
            EventBus.trigger("block:reorder:dragend");
            this.$block.removeClass('st-block--dragging');
          },

          render: function () {
            return this;
          }

        });

        module.exports = BlockReorder;

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"./event-bus": 165, "./function-bind": 173, "./lodash": 178, "./renderable": 180}],
    144: [function (require, module, exports) {
      "use strict";

      var _ = require('./lodash');
      var utils = require('./utils');

      var EventBus = require('./event-bus');

      module.exports = {

        /**
         * Internal storage object for the block
         */
        blockStorage: {},

        /**
         * Initialize the store, including the block type
         */
        createStore: function (blockData) {
          this.blockStorage = {
            type: utils.underscored(this.type),
            data: blockData || {}
          };
        },

        /**
         * Serialize the block and save the data into the store
         */
        save: function () {
          var data = this._serializeData();

          if (!_.isEmpty(data)) {
            this.setData(data);
          }
        },

        getData: function () {
          this.save();
          return this.blockStorage;
        },

        getBlockData: function () {
          this.save();
          return this.blockStorage.data;
        },

        _getData: function () {
          return this.blockStorage.data;
        },

        /**
         * Set the block data.
         * This is used by the save() method.
         */
        setData: function (blockData) {
          utils.log("Setting data for block " + this.blockID);
          Object.assign(this.blockStorage.data, blockData || {});
        },

        setAndLoadData: function (blockData) {
          this.setData(blockData);
          this.beforeLoadingData();
        },

        _serializeData: function () {
        },
        loadData: function () {
        },

        beforeLoadingData: function () {
          utils.log("loadData for " + this.blockID);
          EventBus.trigger("editor/block/loadData");
          this.loadData(this._getData());
        },

        _loadData: function () {
          utils.log("_loadData is deprecated and will be removed in the future. Please use beforeLoadingData instead.");
          this.beforeLoadingData();
        },

        checkAndLoadData: function () {
          if (!_.isEmpty(this._getData())) {
            this.beforeLoadingData();
          }
        }

      };

    }, {"./event-bus": 165, "./lodash": 178, "./utils": 184}],
    145: [function (require, module, exports) {
      (function (global) {
        "use strict";

        var _ = require('./lodash');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);
        var utils = require('./utils');

        var bestNameFromField = function (field) {
          var msg = field.attr("data-st-name") || field.attr("name");

          if (!msg) {
            msg = 'Field';
          }

          return utils.capitalize(msg);
        };

        module.exports = {

          errors: [],

          valid: function () {
            this.performValidations();
            return this.errors.length === 0;
          },

          // This method actually does the leg work
          // of running our validators and custom validators
          performValidations: function () {
            this.resetErrors();

            var required_fields = this.$('.st-required');
            required_fields.each(function (i, f) {
              this.validateField(f);
            }.bind(this));
            this.validations.forEach(this.runValidator, this);

            this.$el.toggleClass('st-block--with-errors', this.errors.length > 0);
          },

          // Everything in here should be a function that returns true or false
          validations: [],

          validateField: function (field) {
            field = $(field);

            var content = field.attr('contenteditable') ? field.text() : field.val();

            if (content.length === 0) {
              this.setError(field, i18n.t("errors:block_empty",
                {name: bestNameFromField(field)}));
            }
          },

          runValidator: function (validator) {
            if (!_.isUndefined(this[validator])) {
              this[validator].call(this);
            }
          },

          setError: function (field, reason) {
            var $msg = this.addMessage(reason, "st-msg--error");
            field.addClass('st-error');

            this.errors.push({field: field, reason: reason, msg: $msg});
          },

          resetErrors: function () {
            this.errors.forEach(function (error) {
              error.field.removeClass('st-error');
              error.msg.remove();
            });

            this.$messages.removeClass("st-block__messages--is-visible");
            this.errors = [];
          }

        };

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"./lodash": 178, "./utils": 184}],
    146: [function (require, module, exports) {
      (function (global) {
        "use strict";

        var _ = require('./lodash');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);

        var Scribe = require('scribe-editor');
        var scribePluginFormatterPlainTextConvertNewLinesToHTML = require('scribe-plugin-formatter-plain-text-convert-new-lines-to-html');
        var scribePluginLinkPromptCommand = require('scribe-plugin-link-prompt-command');

        var config = require('./config');
        var utils = require('./utils');
        var BlockMixins = require('./block_mixins');

        var SimpleBlock = require('./simple-block');
        var BlockReorder = require('./block-reorder');
        var BlockDeletion = require('./block-deletion');
        var BlockPositioner = require('./block-positioner');
        var EventBus = require('./event-bus');

        var Spinner = require('spin.js');

        var Block = function (data, instance_id, mediator, options) {
          SimpleBlock.apply(this, arguments);
        };

        Block.prototype = Object.create(SimpleBlock.prototype);
        Block.prototype.constructor = Block;

        var delete_template = [
          "<div class='st-block__ui-delete-controls'>",
          "<label class='st-block__delete-label'>",
          "<%= i18n.t('general:delete') %>",
          "</label>",
          "<a class='st-block-ui-btn st-block-ui-btn--confirm-delete st-icon' data-icon='tick'></a>",
          "<a class='st-block-ui-btn st-block-ui-btn--deny-delete st-icon' data-icon='close'></a>",
          "</div>"
        ].join("\n");

        Object.assign(Block.prototype, SimpleBlock.fn, require('./block-validations'), {

          bound: [
            "_handleContentPaste", "_onFocus", "_onBlur", "onDrop", "onDeleteClick",
            "clearInsertedStyles", "getSelectionForFormatter", "onBlockRender",
          ],

          className: 'st-block st-icon--add',

          attributes: function () {
            return Object.assign(SimpleBlock.fn.attributes.call(this), {
              'data-icon-after': "add"
            });
          },

          icon_name: 'default',

          validationFailMsg: function () {
            return i18n.t('errors:validation_fail', {type: this.title()});
          },

          editorHTML: '<div class="st-block__editor"></div>',

          toolbarEnabled: true,

          availableMixins: ['droppable', 'pastable', 'uploadable', 'fetchable',
            'ajaxable', 'controllable'],

          droppable: false,
          pastable: false,
          uploadable: false,
          fetchable: false,
          ajaxable: false,

          drop_options: {},
          paste_options: {},
          upload_options: {},

          formattable: true,

          _previousSelection: '',

          initialize: function () {
          },

          toMarkdown: function (markdown) {
            return markdown;
          },
          toHTML: function (html) {
            return html;
          },

          withMixin: function (mixin) {
            if (!_.isObject(mixin)) {
              return;
            }

            var initializeMethod = "initialize" + mixin.mixinName;

            if (_.isUndefined(this[initializeMethod])) {
              Object.assign(this, mixin);
              this[initializeMethod]();
            }
          },

          render: function () {
            this.beforeBlockRender();
            this._setBlockInner();

            this.$editor = this.$inner.children().first();

            this.mixinsRequireInputs = false;
            this.availableMixins.forEach(function (mixin) {
              if (this[mixin]) {
                var blockMixin = BlockMixins[utils.classify(mixin)];
                if (!_.isUndefined(blockMixin.requireInputs) && blockMixin.requireInputs) {
                  this.mixinsRequireInputs = true;
                }
              }
            }, this);

            if (this.mixinsRequireInputs) {
              var input_html = $("<div>", {'class': 'st-block__inputs'});
              this.$inner.append(input_html);
              this.$inputs = input_html;
            }

            if (this.hasTextBlock()) {
              this._initTextBlocks();
            }

            this.availableMixins.forEach(function (mixin) {
              if (this[mixin]) {
                this.withMixin(BlockMixins[utils.classify(mixin)]);
              }
            }, this);

            if (this.formattable) {
              this._initFormatting();
            }

            this._blockPrepare();

            return this;
          },

          remove: function () {
            if (this.ajaxable) {
              this.resolveAllInQueue();
            }

            this.$el.remove();
          },

          loading: function () {
            if (!_.isUndefined(this.spinner)) {
              this.ready();
            }

            this.spinner = new Spinner(config.defaults.spinner);
            this.spinner.spin(this.$el[0]);

            this.$el.addClass('st--is-loading');
          },

          ready: function () {
            this.$el.removeClass('st--is-loading');
            if (!_.isUndefined(this.spinner)) {
              this.spinner.stop();
              delete this.spinner;
            }
          },

          /* Generic _serializeData implementation to serialize the block into a plain object.
           * Can be overwritten, although hopefully this will cover most situations.
           * If you want to get the data of your block use block.getBlockData()
           */
          _serializeData: function () {
            utils.log("toData for " + this.blockID);

            var data = {};

            /* Simple to start. Add conditions later */
            if (this.hasTextBlock()) {
              data.text = this.getTextBlockHTML();
              data.isHtml = true;
            }

            // Add any inputs to the data attr
            if (this.$(':input').not('.st-paste-block').length > 0) {
              this.$(':input').each(function (index, input) {
                if (input.getAttribute('name')) {
                  data[input.getAttribute('name')] = input.value;
                }
              });
            }

            return data;
          },

          /* Generic implementation to tell us when the block is active */
          focus: function () {
            this.getTextBlock().focus();
          },

          blur: function () {
            this.getTextBlock().blur();
          },

          onFocus: function () {
            this.getTextBlock().bind('focus', this._onFocus);
          },

          onBlur: function () {
            this.getTextBlock().bind('blur', this._onBlur);
          },

          /*
           * Event handlers
           */

          _onFocus: function () {
            this.trigger('blockFocus', this.$el);
          },

          _onBlur: function () {
          },

          onBlockRender: function () {
            this.focus();
          },

          onDrop: function (dataTransferObj) {
          },

          onDeleteClick: function (ev) {
            ev.preventDefault();

            var onDeleteConfirm = function (e) {
              e.preventDefault();
              this.mediator.trigger('block:remove', this.blockID);
              this.remove();
            };

            var onDeleteDeny = function (e) {
              e.preventDefault();
              this.$el.removeClass('st-block--delete-active');
              $delete_el.remove();
            };

            if (this.isEmpty()) {
              onDeleteConfirm.call(this, new Event('click'));
              return;
            }

            this.$inner.append(_.template(delete_template));
            this.$el.addClass('st-block--delete-active');

            var $delete_el = this.$inner.find('.st-block__ui-delete-controls');

            this.$inner.on('click', '.st-block-ui-btn--confirm-delete',
              onDeleteConfirm.bind(this))
              .on('click', '.st-block-ui-btn--deny-delete',
              onDeleteDeny.bind(this));
          },

          beforeLoadingData: function () {
            this.loading();

            if (this.mixinsRequireInputs) {
              this.$editor.show();
              this.$inputs.hide();
            }

            SimpleBlock.fn.beforeLoadingData.call(this);

            this.ready();
          },

          execTextBlockCommand: function (cmdName) {
            if (_.isUndefined(this._scribe)) {
              throw "No Scribe instance found to send a command to";
            }
            var cmd = this._scribe.getCommand(cmdName);
            this._scribe.el.focus();
            cmd.execute();
          },

          queryTextBlockCommandState: function (cmdName) {
            if (_.isUndefined(this._scribe)) {
              throw "No Scribe instance found to query command";
            }
            var cmd = this._scribe.getCommand(cmdName),
              sel = new this._scribe.api.Selection();
            return sel.range && cmd.queryState();
          },

          _handleContentPaste: function (ev) {
            setTimeout(this.onContentPasted.bind(this, ev, $(ev.currentTarget)), 0);
          },

          _getBlockClass: function () {
            return 'st-block--' + this.className;
          },

          /*
           * Init functions for adding functionality
           */

          _initUIComponents: function () {

            var positioner = new BlockPositioner(this.$el, this.mediator);

            this._withUIComponent(positioner, '.st-block-ui-btn--reorder',
              positioner.toggle);

            this._withUIComponent(new BlockReorder(this.$el, this.mediator));

            this._withUIComponent(new BlockDeletion(), '.st-block-ui-btn--delete',
              this.onDeleteClick);

            this.onFocus();
            this.onBlur();
          },

          _initFormatting: function () {

            // Enable formatting keyboard input
            var block = this;

            if (!this.options.formatBar) {
              return;
            }

            this.options.formatBar.commands.forEach(function (cmd) {
              if (_.isUndefined(cmd.keyCode)) {
                return;
              }

              var ctrlDown = false;

              block.$el
                .on('keyup', '.st-text-block', function (ev) {
                  if (ev.which === 17 || ev.which === 224 || ev.which === 91) {
                    ctrlDown = false;
                  }
                })
                .on('keydown', '.st-text-block', {formatter: cmd}, function (ev) {
                  if (ev.which === 17 || ev.which === 224 || ev.which === 91) {
                    ctrlDown = true;
                  }

                  if (ev.which === ev.data.formatter.keyCode && ctrlDown) {
                    ev.preventDefault();
                    block.execTextBlockCommand(ev.data.formatter.cmd);
                  }
                });
            });
          },

          _initTextBlocks: function () {
            this.getTextBlock()
              .bind('keyup', this.getSelectionForFormatter)
              .bind('mouseup', this.getSelectionForFormatter)
              .bind('DOMNodeInserted', this.clearInsertedStyles);

            var textBlock = this.getTextBlock().get(0);
            if (!_.isUndefined(textBlock) && _.isUndefined(this._scribe)) {

              var scribeConfig = {debug: config.scribeDebug};
              if (_.isObject(this.scribeOptions)) {
                scribeConfig = Object.assign(scribeConfig, this.scribeOptions);
              }

              this._scribe = new Scribe(textBlock, scribeConfig);

              this._scribe.use(scribePluginFormatterPlainTextConvertNewLinesToHTML());
              this._scribe.use(scribePluginLinkPromptCommand());

              if (_.isFunction(this.configureScribe)) {
                this.configureScribe.call(this, this._scribe);
              }
            }
          },

          getSelectionForFormatter: function () {
            var block = this;
            setTimeout(function () {
              var selection = window.getSelection(),
                selectionStr = selection.toString().trim(),
                en = 'formatter:' + ((selectionStr === '') ? 'hide' : 'position');

              block.mediator.trigger(en, block);
              EventBus.trigger(en, block);
            }, 1);
          },

          clearInsertedStyles: function (e) {
            var target = e.target;
            target.removeAttribute('style'); // Hacky fix for Chrome.
          },

          hasTextBlock: function () {
            return this.getTextBlock().length > 0;
          },

          getTextBlock: function () {
            if (_.isUndefined(this.text_block)) {
              this.text_block = this.$('.st-text-block');
            }

            return this.text_block;
          },

          getTextBlockHTML: function () {
            return this._scribe.getHTML();
          },

          setTextBlockHTML: function (html) {
            return this._scribe.setContent(html);
          },

          isEmpty: function () {
            return _.isEmpty(this.getBlockData());
          }

        });

        Block.extend = require('./helpers/extend'); // Allow our Block to be extended.

        module.exports = Block;

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {
      "./block-deletion": 140,
      "./block-positioner": 142,
      "./block-reorder": 143,
      "./block-validations": 145,
      "./block_mixins": 151,
      "./config": 162,
      "./event-bus": 165,
      "./helpers/extend": 175,
      "./lodash": 178,
      "./simple-block": 181,
      "./utils": 184,
      "scribe-editor": 132,
      "scribe-plugin-formatter-plain-text-convert-new-lines-to-html": 135,
      "scribe-plugin-link-prompt-command": 136,
      "spin.js": 137
    }],
    147: [function (require, module, exports) {
      "use strict";

      var utils = require('../utils');

      module.exports = {

        mixinName: "Ajaxable",

        ajaxable: true,

        initializeAjaxable: function () {
          this._queued = [];
        },

        addQueuedItem: function (name, deferred) {
          utils.log("Adding queued item for " + this.blockID + " called " + name);

          this._queued.push({name: name, deferred: deferred});
        },

        removeQueuedItem: function (name) {
          utils.log("Removing queued item for " + this.blockID + " called " + name);

          this._queued = this._queued.filter(function (queued) {
            return queued.name !== name;
          });
        },

        hasItemsInQueue: function () {
          return this._queued.length > 0;
        },

        resolveAllInQueue: function () {
          this._queued.forEach(function (item) {
            utils.log("Aborting queued request: " + item.name);
            item.deferred.abort();
          }, this);
        }

      };

    }, {"../utils": 184}],
    148: [function (require, module, exports) {
      (function (global) {
        "use strict";

        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);

        var utils = require('../utils');

        module.exports = {

          mixinName: "Controllable",

          initializeControllable: function () {
            utils.log("Adding controllable to block " + this.blockID);
            this.$control_ui = $('<div>', {'class': 'st-block__control-ui'});
            Object.keys(this.controls).forEach(
              function (cmd) {
                // Bind configured handler to current block context
                this.addUiControl(cmd, this.controls[cmd].bind(this));
              },
              this
            );
            this.$inner.append(this.$control_ui);
          },

          getControlTemplate: function (cmd) {
            return $("<a>",
              {
                'data-icon': cmd,
                'class': 'st-icon st-block-control-ui-btn st-block-control-ui-btn--' + cmd
              });
          },

          addUiControl: function (cmd, handler) {
            this.$control_ui.append(this.getControlTemplate(cmd));
            this.$control_ui.on('click', '.st-block-control-ui-btn--' + cmd, handler);
          }
        };

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"../utils": 184}],
    149: [function (require, module, exports) {
      (function (global) {
        "use strict";

        /* Adds drop functionaltiy to this block */

        var _ = require('../lodash');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);
        var config = require('../config');
        var utils = require('../utils');

        var EventBus = require('../event-bus');

        module.exports = {

          mixinName: "Droppable",
          valid_drop_file_types: ['File', 'Files', 'text/plain', 'text/uri-list'],
          requireInputs: true,

          initializeDroppable: function () {
            utils.log("Adding droppable to block " + this.blockID);

            this.drop_options = Object.assign({}, config.defaults.Block.drop_options, this.drop_options);

            var drop_html = $(_.template(this.drop_options.html,
              {block: this, _: _}));

            this.$editor.hide();
            this.$inputs.append(drop_html);
            this.$dropzone = drop_html;

            // Bind our drop event
            this.$dropzone.dropArea()
              .bind('drop', this._handleDrop.bind(this));

            this.$inner.addClass('st-block__inner--droppable');
          },

          _handleDrop: function (e) {
            e.preventDefault();

            e = e.originalEvent;

            var el = $(e.target),
              types = e.dataTransfer.types;

            el.removeClass('st-dropzone--dragover');

            /*
             Check the type we just received,
             delegate it away to our blockTypes to process
             */

            if (types &&
              types.some(function (type) {
                return this.valid_drop_file_types.includes(type);
              }, this)) {
              this.onDrop(e.dataTransfer);
            }

            EventBus.trigger('block:content:dropped', this.blockID);
          }

        };

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"../config": 162, "../event-bus": 165, "../lodash": 178, "../utils": 184}],
    150: [function (require, module, exports) {
      (function (global) {
        "use strict";

        var _ = require('../lodash');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);

        module.exports = {

          mixinName: "Fetchable",

          initializeFetchable: function () {
            this.withMixin(require('./ajaxable'));
          },

          fetch: function (options, success, failure) {
            var uid = _.uniqueId(this.blockID + "_fetch"),
              xhr = $.ajax(options);

            this.resetMessages();
            this.addQueuedItem(uid, xhr);

            if (!_.isUndefined(success)) {
              xhr.done(success.bind(this));
            }

            if (!_.isUndefined(failure)) {
              xhr.fail(failure.bind(this));
            }

            xhr.always(this.removeQueuedItem.bind(this, uid));

            return xhr;
          }

        };

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"../lodash": 178, "./ajaxable": 147}],
    151: [function (require, module, exports) {
      "use strict";

      module.exports = {
        Ajaxable: require('./ajaxable.js'),
        Controllable: require('./controllable.js'),
        Droppable: require('./droppable.js'),
        Fetchable: require('./fetchable.js'),
        Pastable: require('./pastable.js'),
        Uploadable: require('./uploadable.js'),
      };

    }, {
      "./ajaxable.js": 147,
      "./controllable.js": 148,
      "./droppable.js": 149,
      "./fetchable.js": 150,
      "./pastable.js": 152,
      "./uploadable.js": 153
    }],
    152: [function (require, module, exports) {
      (function (global) {
        "use strict";

        var _ = require('../lodash');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);
        var config = require('../config');
        var utils = require('../utils');

        module.exports = {

          mixinName: "Pastable",
          requireInputs: true,

          initializePastable: function () {
            utils.log("Adding pastable to block " + this.blockID);

            this.paste_options = Object.assign(
              {}, config.defaults.Block.paste_options, this.paste_options);
            this.$inputs.append(_.template(this.paste_options.html, this));

            this.$('.st-paste-block')
              .bind('click', function () {
                $(this).select();
              })
              .bind('paste', this._handleContentPaste)
              .bind('submit', this._handleContentPaste);
          }

        };

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"../config": 162, "../lodash": 178, "../utils": 184}],
    153: [function (require, module, exports) {
      "use strict";

      var _ = require('../lodash');
      var config = require('../config');
      var utils = require('../utils');


      var fileUploader = function (block, file, success, error) {
        var uid = [block.blockID, (new Date()).getTime(), 'raw'].join('-');
        var data = new FormData();
        data.append('async-upload', file);
        data.append('html-upload', 'Upload');

        block.resetMessages();

        $.get(ajaxurl, {action: 'stwp_nonce'}, function (nonce, status, xhr) {
          data.append('_wpnonce', nonce);

          var callbackSuccess = function (data) {

            $.get('/wp-admin/upload.php?mode=list', function (data, status, xhr) {
              var imgid = $(data).find('#the-list').children(":first").attr('id');
              imgid = imgid.substr(imgid.indexOf('-') + 1, 10);

              // Get Image URL
              $.get(ajaxurl, {action: 'stwp_imgurl', id: imgid}, function (url, status, xhr) {

                var data = {file: {url: url.disp, full: url.full}};

                SirTrevor.log('アップロードに成功しました');
                if (!_.isUndefined(success) && _.isFunction(success)) {
                  success.bind(block)(data);
                }

              }, 'json');

            });
          };

          var callbackError = function (jqXHR, status, errorThrown) {
            SirTrevor.log('アップロードに失敗しました。');

            if (!_.isUndefined(error) && _.isFunction(error)) {
              error.bind(block)(status);
            }
          };


          var xhr = $.ajax({
            url: SirTrevor.config.defaults.uploadUrl,
            data: data,
            cache: false,
            contentType: false,
            processData: false,
            type: 'POST'
          });

          block.addQueuedItem(uid, xhr);


          xhr.done(callbackSuccess)
            .fail(callbackError)
            .always(block.removeQueuedItem.bind(block, uid));
          return xhr;
        });
      };

      module.exports = {

        mixinName: "Uploadable",

        uploadsCount: 0,
        requireInputs: true,

        initializeUploadable: function () {
          utils.log("Adding uploadable to block " + this.blockID);
          this.withMixin(require('./ajaxable'));

          this.upload_options = Object.assign({}, config.defaults.Block.upload_options, this.upload_options);
          this.$inputs.append(_.template(this.upload_options.html, this));
        },

        uploader: function (file, success, failure) {
          return fileUploader(this, file, success, failure);
        }

      };

    }, {"../config": 162, "../extensions/file-uploader": 168, "../lodash": 178, "../utils": 184, "./ajaxable": 147}],
    154: [function (require, module, exports) {
      "use strict";

      /*
       Heading Block
       */

      var Block = require('../block');
      var stToHTML = require('../to-html');

      module.exports = Block.extend({

        type: 'Heading',

        title: function () {
          return i18n.t('blocks:heading:title');
        },

        editorHTML: '<div class="st-required st-text-block st-text-block--heading" contenteditable="true"></div>',

        scribeOptions: {allowBlockElements: false},

        icon_name: 'heading',

        loadData: function (data) {
          if (this.options.convertFromMarkdown && !data.isHtml) {
            this.setTextBlockHTML(stToHTML(data.text, this.type));
          } else {
            this.setTextBlockHTML(data.text);
          }
        }
      });

    }, {"../block": 146, "../to-html": 182}],
    155: [function (require, module, exports) {
      (function (global) {
        "use strict";

        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);
        var Block = require('../block');

        module.exports = Block.extend({

          type: "image",
          title: function () {
            return i18n.t('blocks:image:title');
          },

          droppable: true,
          uploadable: true,

          icon_name: 'image',

          loadData: function (data) {
            // Create our image tag
            this.$editor.html($('<img>', {src: data.file.url}));
          },

          onBlockRender: function () {
            /* Setup the upload button */
            this.$inputs.find('button').bind('click', function (ev) {
              ev.preventDefault();
            });
            this.$inputs.find('input').on('change', (function (ev) {
              this.onDrop(ev.currentTarget);
            }).bind(this));
          },

          onDrop: function (transferData) {
            var file = transferData.files[0],
              urlAPI = (typeof URL !== "undefined") ? URL : (typeof webkitURL !== "undefined") ? webkitURL : null;

            // Handle one upload at a time
            if (/image/.test(file.type)) {
              this.loading();
              // Show this image on here
              this.$inputs.hide();
              this.$editor.html($('<img>', {src: urlAPI.createObjectURL(file)})).show();

              this.uploader(
                file,
                function (data) {
                  this.setData(data);
                  this.ready();
                },
                function (error) {
                  this.addMessage(i18n.t('blocks:image:upload_error'));
                  this.ready();
                }
              );
            }
          }
        });

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"../block": 146}],
    156: [function (require, module, exports) {
      "use strict";

      module.exports = {
        Text: require('./text'),
        Quote: require('./quote'),
        Image: require('./image'),
        Heading: require('./heading'),
        List: require('./list'),
        Tweet: require('./tweet'),
        Video: require('./video'),
      };

    }, {
      "./heading": 154,
      "./image": 155,
      "./list": 157,
      "./quote": 158,
      "./text": 159,
      "./tweet": 160,
      "./video": 161
    }],
    157: [function (require, module, exports) {
      "use strict";

      var _ = require('../lodash');

      var Block = require('../block');
      var stToHTML = require('../to-html');

      var template = '<div class="st-text-block st-required" contenteditable="true"><ul><li></li></ul></div>';

      module.exports = Block.extend({

        type: 'list',

        title: function () {
          return i18n.t('blocks:list:title');
        },

        icon_name: 'list',

        editorHTML: function () {
          return _.template(template, this);
        },

        loadData: function (data) {
          if (this.options.convertFromMarkdown && !data.isHtml) {
            this.setTextBlockHTML("<ul>" + stToHTML(data.text, this.type) + "</ul>");
          } else {
            this.setTextBlockHTML(data.text);
          }
        },

        onBlockRender: function () {
          this.checkForList = this.checkForList.bind(this);
          this.getTextBlock().on('click keyup', this.checkForList);
          this.focus();
        },

        checkForList: function () {
          if (this.$('ul').length === 0) {
            document.execCommand("insertUnorderedList", false, false);
          }
        },

        toHTML: function (html) {
          html = html.replace(/^ - (.+)$/mg, "<li>$1</li>")
            .replace(/\n/mg, "");

          return html;
        },

        onContentPasted: function (event, target) {
          this.$('ul').html(
            this.pastedMarkdownToHTML(target[0].innerHTML));
          this.getTextBlock().caretToEnd();
        },

        isEmpty: function () {
          return _.isEmpty(this.getBlockData().text);
        }

      });

    }, {"../block": 146, "../lodash": 178, "../to-html": 182}],
    158: [function (require, module, exports) {
      "use strict";

      /*
       Block Quote
       */

      var _ = require('../lodash');

      var Block = require('../block');
      var stToHTML = require('../to-html');

      var template = _.template([
        '<blockquote class="st-required st-text-block" contenteditable="true"></blockquote>',
        '<label class="st-input-label"> <%= i18n.t("blocks:quote:credit_field") %></label>',
        '<input maxlength="140" name="cite" placeholder="<%= i18n.t("blocks:quote:credit_field") %>"',
        ' class="st-input-string st-required js-cite-input" type="text" />'
      ].join("\n"));

      module.exports = Block.extend({

        type: "quote",

        title: function () {
          return i18n.t('blocks:quote:title');
        },

        icon_name: 'quote',

        editorHTML: function () {
          return template(this);
        },

        loadData: function (data) {
          if (this.options.convertFromMarkdown && !data.isHtml) {
            this.setTextBlockHTML(stToHTML(data.text, this.type));
          } else {
            this.setTextBlockHTML(data.text);
          }

          this.$('.js-cite-input').val(data.cite);
        }
      });

    }, {"../block": 146, "../lodash": 178, "../to-html": 182}],
    159: [function (require, module, exports) {
      "use strict";

      /*
       Text Block
       */

      var Block = require('../block');
      var stToHTML = require('../to-html');

      module.exports = Block.extend({

        type: "text",

        title: function () {
          return i18n.t('blocks:text:title');
        },

        editorHTML: '<div class="st-required st-text-block" contenteditable="true"></div>',

        icon_name: 'text',

        loadData: function (data) {
          if (this.options.convertFromMarkdown && !data.isHtml) {
            this.setTextBlockHTML(stToHTML(data.text, this.type));
          } else {
            this.setTextBlockHTML(data.text);
          }
        },
      });

    }, {"../block": 146, "../to-html": 182}],
    160: [function (require, module, exports) {
      (function (global) {
        "use strict";

        var _ = require('../lodash');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);
        var utils = require('../utils');

        var Block = require('../block');

        var tweet_template = _.template([
          "<blockquote class='twitter-tweet' align='center'>",
          "<p><%= text %></p>",
          "&mdash; <%= user.name %> (@<%= user.screen_name %>)",
          "<a href='<%= status_url %>' data-datetime='<%= created_at %>'><%= created_at %></a>",
          "</blockquote>",
          '<script src="//platform.twitter.com/widgets.js" charset="utf-8"></script>'
        ].join("\n"));

        module.exports = Block.extend({

          type: "tweet",
          droppable: true,
          pastable: true,
          fetchable: true,

          drop_options: {
            re_render_on_reorder: true
          },

          title: function () {
            return i18n.t('blocks:tweet:title');
          },

          fetchUrl: function (tweetID) {
            return "/tweets/?tweet_id=" + tweetID;
          },

          icon_name: 'twitter',

          loadData: function (data) {
            if (_.isUndefined(data.status_url)) {
              data.status_url = '';
            }
            this.$inner.find('iframe').remove();
            this.$inner.prepend(tweet_template(data));
          },

          onContentPasted: function (event) {
            // Content pasted. Delegate to the drop parse method
            var input = $(event.target),
              val = input.val();

            // Pass this to the same handler as onDrop
            this.handleTwitterDropPaste(val);
          },

          handleTwitterDropPaste: function (url) {
            if (!this.validTweetUrl(url)) {
              utils.log("Invalid Tweet URL");
              return;
            }

            // Twitter status
            var tweetID = url.match(/[^\/]+$/);
            if (!_.isEmpty(tweetID)) {
              this.loading();
              tweetID = tweetID[0];

              var ajaxOptions = {
                url: this.fetchUrl(tweetID),
                dataType: "json"
              };

              this.fetch(ajaxOptions, this.onTweetSuccess, this.onTweetFail);
            }
          },

          validTweetUrl: function (url) {
            return (utils.isURI(url) &&
            url.indexOf("twitter") !== -1 &&
            url.indexOf("status") !== -1);
          },

          onTweetSuccess: function (data) {
            // Parse the twitter object into something a bit slimmer..
            var obj = {
              user: {
                profile_image_url: data.user.profile_image_url,
                profile_image_url_https: data.user.profile_image_url_https,
                screen_name: data.user.screen_name,
                name: data.user.name
              },
              id: data.id_str,
              text: data.text,
              created_at: data.created_at,
              entities: data.entities,
              status_url: "https://twitter.com/" + data.user.screen_name + "/status/" + data.id_str
            };

            this.setAndLoadData(obj);
            this.ready();
          },

          onTweetFail: function () {
            this.addMessage(i18n.t("blocks:tweet:fetch_error"));
            this.ready();
          },

          onDrop: function (transferData) {
            var url = transferData.getData('text/plain');
            this.handleTwitterDropPaste(url);
          }
        });

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"../block": 146, "../lodash": 178, "../utils": 184}],
    161: [function (require, module, exports) {
      "use strict";

      var _ = require('../lodash');
      var utils = require('../utils');
      var Block = require('../block');

      module.exports = Block.extend({

        // more providers at https://gist.github.com/jeffling/a9629ae28e076785a14f
        providers: {
          vimeo: {
            regex: /(?:http[s]?:\/\/)?(?:www.)?vimeo.com\/(.+)/,
            html: "<iframe src=\"<%= protocol %>//player.vimeo.com/video/<%= remote_id %>?title=0&byline=0\" width=\"580\" height=\"320\" frameborder=\"0\"></iframe>"
          },
          youtube: {
            regex: /^.*(?:youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=|\&v=)([^#\&\?]*).*/,
            html: "<iframe src=\"<%= protocol %>//www.youtube.com/embed/<%= remote_id %>\" width=\"580\" height=\"320\" frameborder=\"0\" allowfullscreen></iframe>"
          }
        },

        type: 'video',
        title: function () {
          return i18n.t('blocks:video:title');
        },

        droppable: true,
        pastable: true,

        icon_name: 'video',

        loadData: function (data) {
          if (!this.providers.hasOwnProperty(data.source)) {
            return;
          }

          var source = this.providers[data.source];

          var protocol = window.location.protocol === "file:" ?
            "http:" : window.location.protocol;

          var aspectRatioClass = source.square ?
            'with-square-media' : 'with-sixteen-by-nine-media';

          this.$editor
            .addClass('st-block__editor--' + aspectRatioClass)
            .html(_.template(source.html, {
              protocol: protocol,
              remote_id: data.remote_id,
              width: this.$editor.width() // for videos like vine
            }));
        },

        onContentPasted: function (event) {
          this.handleDropPaste(event.target.value);
        },

        matchVideoProvider: function (provider, index, url) {
          var match = provider.regex.exec(url);
          if (match == null || _.isUndefined(match[1])) {
            return {};
          }

          return {
            source: index,
            remote_id: match[1]
          };
        },

        handleDropPaste: function (url) {
          if (!utils.isURI(url)) {
            return;
          }

          for (var key in this.providers) {
            if (!this.providers.hasOwnProperty(key)) {
              continue;
            }
            this.setAndLoadData(
              this.matchVideoProvider(this.providers[key], key, url)
            );
          }
        },

        onDrop: function (transferData) {
          var url = transferData.getData('text/plain');
          this.handleDropPaste(url);
        }
      });


    }, {"../block": 146, "../lodash": 178, "../utils": 184}],
    162: [function (require, module, exports) {
      "use strict";

      var drop_options = {
        html: ['<div class="st-block__dropzone">',
          '<span class="st-icon"><%= _.result(block, "icon_name") %></span>',
          '<p><%= i18n.t("general:drop", { block: "<span>" + _.result(block, "title") + "</span>" }) %>',
          '</p></div>'].join('\n'),
        re_render_on_reorder: false
      };

      var paste_options = {
        html: ['<input type="text" placeholder="<%= i18n.t("general:paste") %>"',
          ' class="st-block__paste-input st-paste-block">'].join('')
      };

      var upload_options = {
        html: [
          '<div class="st-block__upload-container">',
          '<input type="file" type="st-file-upload">',
          '<button class="st-upload-btn"><%= i18n.t("general:upload") %></button>',
          '</div>'
        ].join('\n')
      };

      module.exports = {
        debug: false,
        scribeDebug: false,
        skipValidation: false,
        version: "0.4.0",
        language: "en",

        instances: [],

        defaults: {
          defaultType: false,
          spinner: {
            className: 'st-spinner',
            lines: 9,
            length: 8,
            width: 3,
            radius: 6,
            color: '#000',
            speed: 1.4,
            trail: 57,
            shadow: false,
            left: '50%',
            top: '50%'
          },
          Block: {
            drop_options: drop_options,
            paste_options: paste_options,
            upload_options: upload_options,
          },
          blockLimit: 0,
          blockTypeLimits: {},
          required: [],
          uploadUrl: '/attachments',
          baseImageUrl: '/sir-trevor-uploads/',
          errorsContainer: undefined,
          convertFromMarkdown: true,
          formatBarContainer: document.body,
          formatBar: {
            commands: [
              {
                name: "Bold",
                title: "bold",
                cmd: "bold",
                keyCode: 66,
                text: "B"
              },
              {
                name: "Italic",
                title: "italic",
                cmd: "italic",
                keyCode: 73,
                text: "i"
              },
              {
                name: "Link",
                title: "link",
                iconName: "link",
                cmd: "linkPrompt",
                text: "link",
              },
              {
                name: "Unlink",
                title: "unlink",
                iconName: "link",
                cmd: "unlink",
                text: "link",
              },
            ],
          },
        }
      };

    }, {}],
    163: [function (require, module, exports) {
      (function (global) {
        "use strict";

        /*
         * Sir Trevor Editor
         * --
         * Represents one Sir Trevor editor instance (with multiple blocks)
         * Each block references this instance.
         * BlockTypes are global however.
         */

        var _ = require('./lodash');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);
        var config = require('./config');
        var utils = require('./utils');

        var Events = require('./events');
        var EventBus = require('./event-bus');
        var FormEvents = require('./form-events');
        var BlockControls = require('./block-controls');
        var BlockManager = require('./block-manager');
        var FloatingBlockControls = require('./floating-block-controls');
        var FormatBar = require('./format-bar');
        var EditorStore = require('./extensions/editor-store');
        var ErrorHandler = require('./error-handler');

        var Editor = function (options) {
          this.initialize(options);
        };

        Object.assign(Editor.prototype, require('./function-bind'), require('./events'), {

          bound: ['onFormSubmit', 'hideAllTheThings', 'changeBlockPosition',
            'removeBlockDragOver', 'renderBlock', 'resetBlockControls',
            'blockLimitReached'],

          events: {
            'block:reorder:dragend': 'removeBlockDragOver',
            'block:reorder:dropped': 'removeBlockDragOver',
            'block:content:dropped': 'removeBlockDragOver'
          },

          initialize: function (options) {
            utils.log("Init SirTrevor.Editor");

            this.options = Object.assign({}, config.defaults, options || {});
            this.ID = _.uniqueId('st-editor-');

            if (!this._ensureAndSetElements()) {
              return false;
            }

            if (!_.isUndefined(this.options.onEditorRender) &&
              _.isFunction(this.options.onEditorRender)) {
              this.onEditorRender = this.options.onEditorRender;
            }

            // Mediated events for *this* Editor instance
            this.mediator = Object.assign({}, Events);

            this._bindFunctions();

            config.instances.push(this);

            this.build();

            FormEvents.bindFormSubmit(this.$form);
          },

          /*
           * Build the Editor instance.
           * Check to see if we've been passed JSON already, and if not try and
           * create a default block.
           * If we have JSON then we need to build all of our blocks from this.
           */
          build: function () {
            this.$el.hide();

            this.errorHandler = new ErrorHandler(this.$outer, this.mediator, this.options.errorsContainer);
            this.store = new EditorStore(this.$el.val(), this.mediator);
            this.block_manager = new BlockManager(this.options, this, this.mediator); // passing SirTrevor instance gives more flexibility
            this.block_controls = new BlockControls(this.block_manager.blockTypes, this.mediator);
            this.fl_block_controls = new FloatingBlockControls(this.$wrapper, this.ID, this.mediator);
            this.formatBar = new FormatBar(this.options.formatBar, this.mediator);

            this.mediator.on('block:changePosition', this.changeBlockPosition);
            this.mediator.on('block-controls:reset', this.resetBlockControls);
            this.mediator.on('block:limitReached', this.blockLimitReached);
            this.mediator.on('block:render', this.renderBlock);

            this.dataStore = "Please use store.retrieve();";

            this._setEvents();

            this.$wrapper.prepend(this.fl_block_controls.render().$el);
            $(this.options.formatBarContainer).append(this.formatBar.render().$el);
            this.$outer.append(this.block_controls.render().$el);

            $(window).bind('click', this.hideAllTheThings);

            this.createBlocks();
            this.$wrapper.addClass('st-ready');

            if (!_.isUndefined(this.onEditorRender)) {
              this.onEditorRender();
            }
          },

          createBlocks: function () {
            var store = this.store.retrieve();

            if (store.data.length > 0) {
              store.data.forEach(function (block) {
                this.mediator.trigger('block:create', block.type, block.data);
              }, this);
            } else if (this.options.defaultType !== false) {
              this.mediator.trigger('block:create', this.options.defaultType, {});
            }
          },

          destroy: function () {
            // Destroy the rendered sub views
            this.formatBar.destroy();
            this.fl_block_controls.destroy();
            this.block_controls.destroy();

            // Destroy all blocks
            this.block_manager.blocks.forEach(function (block) {
              this.mediator.trigger('block:remove', block.blockID);
            }, this);

            // Stop listening to events
            this.mediator.stopListening();
            this.stopListening();

            // Remove instance
            config.instances = config.instances.filter(function (instance) {
              return instance.ID !== this.ID;
            }, this);

            // Clear the store
            this.store.reset();
            this.$outer.replaceWith(this.$el.detach());
          },

          reinitialize: function (options) {
            this.destroy();
            this.initialize(options || this.options);
          },

          resetBlockControls: function () {
            this.block_controls.renderInContainer(this.$wrapper);
            this.block_controls.hide();
          },

          blockLimitReached: function (toggle) {
            this.$wrapper.toggleClass('st--block-limit-reached', toggle);
          },

          _setEvents: function () {
            Object.keys(this.events).forEach(function (type) {
              EventBus.on(type, this[this.events[type]], this);
            }, this);
          },

          hideAllTheThings: function (e) {
            this.block_controls.hide();
            this.formatBar.hide();
          },

          store: function (method, options) {
            utils.log("The store method has been removed, please call store[methodName]");
            return this.store[method].call(this, options || {});
          },

          renderBlock: function (block, render_at) {
            this._renderInPosition(block.render().$el, render_at);
            this.hideAllTheThings();

            block.trigger("onRender");
          },

          removeBlockDragOver: function () {
            this.$outer.find('.st-drag-over').removeClass('st-drag-over');
          },

          changeBlockPosition: function ($block, selectedPosition) {
            selectedPosition = selectedPosition - 1;

            var blockPosition = this.getBlockPosition($block),
              $blockBy = $block.parent().children('.st-block').eq(selectedPosition);

            var where = (blockPosition > selectedPosition) ? "Before" : "After";

            if ($blockBy && $blockBy.attr('id') !== $block.attr('id')) {
              this.hideAllTheThings();
              $block["insert" + where]($blockBy);
            }
          },

          _renderInPosition: function (block, render_at) {
            if (render_at) {
              $(render_at).after(block);
            } else if (this.block_controls.currentContainer) {
              this.block_controls.currentContainer.after(block);
            } else {
              this.$wrapper.append(block);
            }
          },

          validateAndSaveBlock: function (block, shouldValidate) {
            if ((!config.skipValidation || shouldValidate) && !block.valid()) {
              this.mediator.trigger('errors:add', {text: _.result(block, 'validationFailMsg')});
              utils.log("Block " + block.blockID + " failed validation");
              return;
            }

            var blockData = block.getData();
            utils.log("Adding data for block " + block.blockID + " to block store:",
              blockData);
            this.store.addData(blockData);
          },

          /*
           * Handle a form submission of this Editor instance.
           * Validate all of our blocks, and serialise all data onto the JSON objects
           */
          onFormSubmit: function (shouldValidate) {
            // if undefined or null or anything other than false - treat as true
            shouldValidate = (shouldValidate === false) ? false : true;

            utils.log("Handling form submission for Editor " + this.ID);

            this.mediator.trigger('errors:reset');
            this.store.reset();

            this.validateBlocks(shouldValidate);
            this.block_manager.validateBlockTypesExist(shouldValidate);

            this.mediator.trigger('errors:render');
            this.$el.val(this.store.toString());

            return this.errorHandler.errors.length;
          },

          validateBlocks: function (shouldValidate) {
            var self = this;
            // save only top-level blocks (nested data is handled by container blocks themselves)
            this.$wrapper.children('.st-block').each(function (idx, block) {
              var _block = self.block_manager.findBlockById($(block).attr('id'));
              if (!_.isUndefined(_block)) {
                self.validateAndSaveBlock(_block, shouldValidate);
              }
            });
          },

          findBlockById: function (block_id) {
            return this.block_manager.findBlockById(block_id);
          },

          getBlocksByType: function (block_type) {
            return this.block_manager.getBlocksByType(block_type);
          },

          getBlocksByIDs: function (block_ids) {
            return this.block_manager.getBlocksByIDs(block_ids);
          },

          getBlockPosition: function ($block) {
            return $block.parent().children('.st-block').index($block);
          },

          _ensureAndSetElements: function () {
            if (_.isUndefined(this.options.el) || _.isEmpty(this.options.el)) {
              utils.log("You must provide an el");
              return false;
            }

            this.$el = this.options.el;
            this.el = this.options.el[0];
            this.$form = this.$el.parents('form');

            var $outer = $("<div>").attr({'id': this.ID, 'class': 'st-outer', 'dropzone': 'copy link move'});
            var $wrapper = $("<div>").attr({'class': 'st-blocks'});

            // Wrap our element in lots of containers *eww*
            this.$el.wrap($outer).wrap($wrapper);

            this.$outer = this.$form.find('#' + this.ID);
            this.$wrapper = this.$outer.find('.st-blocks');

            return true;
          }

        });

        module.exports = Editor;


      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {
      "./block-controls": 139,
      "./block-manager": 141,
      "./config": 162,
      "./error-handler": 164,
      "./event-bus": 165,
      "./events": 166,
      "./extensions/editor-store": 167,
      "./floating-block-controls": 170,
      "./form-events": 171,
      "./format-bar": 172,
      "./function-bind": 173,
      "./lodash": 178,
      "./utils": 184
    }],
    164: [function (require, module, exports) {
      (function (global) {
        "use strict";

        var _ = require('./lodash');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);

        var ErrorHandler = function ($wrapper, mediator, container) {
          this.$wrapper = $wrapper;
          this.mediator = mediator;
          this.$el = container;

          if (_.isUndefined(this.$el)) {
            this._ensureElement();
            this.$wrapper.prepend(this.$el);
          }

          this.$el.hide();
          this._bindFunctions();
          this._bindMediatedEvents();

          this.initialize();
        };

        Object.assign(ErrorHandler.prototype, require('./function-bind'), require('./mediated-events'), require('./renderable'), {

          errors: [],
          className: "st-errors",
          eventNamespace: 'errors',

          mediatedEvents: {
            'reset': 'reset',
            'add': 'addMessage',
            'render': 'render'
          },

          initialize: function () {
            var $list = $("<ul>");
            this.$el.append("<p>" + i18n.t("errors:title") + "</p>")
              .append($list);
            this.$list = $list;
          },

          render: function () {
            if (this.errors.length === 0) {
              return false;
            }
            this.errors.forEach(this.createErrorItem, this);
            this.$el.show();
          },

          createErrorItem: function (error) {
            var $error = $("<li>", {class: "st-errors__msg", html: error.text});
            this.$list.append($error);
          },

          addMessage: function (error) {
            this.errors.push(error);
          },

          reset: function () {
            if (this.errors.length === 0) {
              return false;
            }
            this.errors = [];
            this.$list.html('');
            this.$el.hide();
          }

        });

        module.exports = ErrorHandler;


      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"./function-bind": 173, "./lodash": 178, "./mediated-events": 179, "./renderable": 180}],
    165: [function (require, module, exports) {
      "use strict";

      module.exports = Object.assign({}, require('./events'));

    }, {"./events": 166}],
    166: [function (require, module, exports) {
      "use strict";

      module.exports = require('eventablejs');

    }, {"eventablejs": 3}],
    167: [function (require, module, exports) {
      "use strict";

      /*
       * Sir Trevor Editor Store
       * By default we store the complete data on the instances $el
       * We can easily extend this and store it on some server or something
       */

      var _ = require('../lodash');
      var utils = require('../utils');


      var EditorStore = function (data, mediator) {
        this.mediator = mediator;
        this.initialize(data ? data.trim() : '');
      };

      Object.assign(EditorStore.prototype, {

        initialize: function (data) {
          this.store = this._parseData(data) || {data: []};
        },

        retrieve: function () {
          return this.store;
        },

        toString: function (space) {
          return JSON.stringify(this.store, undefined, space);
        },

        reset: function () {
          utils.log("Resetting the EditorStore");
          this.store = {data: []};
        },

        addData: function (data) {
          this.store.data.push(data);
          return this.store;
        },

        _parseData: function (data) {
          var result;

          if (data.length === 0) {
            return result;
          }

          try {
            // Ensure the JSON string has a data element that's an array
            var jsonStr = JSON.parse(data);
            if (!_.isUndefined(jsonStr.data)) {
              result = jsonStr;
            }
          } catch (e) {
            this.mediator.trigger(
              'errors:add',
              {text: i18n.t("errors:load_fail")});

            this.mediator.trigger('errors:render');

            console.log('Sorry there has been a problem with parsing the JSON');
            console.log(e);
          }

          return result;
        }

      });

      module.exports = EditorStore;

    }, {"../lodash": 178, "../utils": 184}],
    168: [function (require, module, exports) {
      (function (global) {
        "use strict";

        /*
         *   Sir Trevor Uploader
         *   Generic Upload implementation that can be extended for blocks
         */

        var _ = require('../lodash');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);
        var config = require('../config');
        var utils = require('../utils');

        var EventBus = require('../event-bus');

        module.exports = function (block, file, success, error) {

          EventBus.trigger('onUploadStart');

          var uid = [block.blockID, (new Date()).getTime(), 'raw'].join('-');
          var data = new FormData();

          data.append('attachment[name]', file.name);
          data.append('attachment[file]', file);
          data.append('attachment[uid]', uid);

          block.resetMessages();

          var callbackSuccess = function (data) {
            utils.log('Upload callback called');
            EventBus.trigger('onUploadStop');

            if (!_.isUndefined(success) && _.isFunction(success)) {
              success.apply(block, arguments);
            }
          };

          var callbackError = function (jqXHR, status, errorThrown) {
            utils.log('Upload callback error called');
            EventBus.trigger('onUploadStop');

            if (!_.isUndefined(error) && _.isFunction(error)) {
              error.call(block, status);
            }
          };

          var xhr = $.ajax({
            url: config.defaults.uploadUrl,
            data: data,
            cache: false,
            contentType: false,
            processData: false,
            dataType: 'json',
            type: 'POST'
          });

          block.addQueuedItem(uid, xhr);

          xhr.done(callbackSuccess)
            .fail(callbackError)
            .always(block.removeQueuedItem.bind(block, uid));

          return xhr;
        };

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"../config": 162, "../event-bus": 165, "../lodash": 178, "../utils": 184}],
    169: [function (require, module, exports) {
      (function (global) {
        "use strict";

        /*
         * SirTrevor.Submittable
         * --
         * We need a global way of setting if the editor can and can't be submitted,
         * and a way to disable the submit button and add messages (when appropriate)
         * We also need this to be highly extensible so it can be overridden.
         * This will be triggered *by anything* so it needs to subscribe to events.
         */

        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);
        var utils = require('../utils');

        var EventBus = require('../event-bus');

        var Submittable = function ($form) {
          this.$form = $form;
          this.initialize();
        };

        Object.assign(Submittable.prototype, {

          initialize: function () {
            this.submitBtn = this.$form.find("input[type='submit']");

            var btnTitles = [];

            this.submitBtn.each(function (i, btn) {
              btnTitles.push($(btn).attr('value'));
            });

            this.submitBtnTitles = btnTitles;
            this.canSubmit = true;
            this.globalUploadCount = 0;
            this._bindEvents();
          },

          setSubmitButton: function (e, message) {
            this.submitBtn.attr('value', message);
          },

          resetSubmitButton: function () {
            var titles = this.submitBtnTitles;
            this.submitBtn.each(function (index, item) {
              $(item).attr('value', titles[index]);
            });
          },

          onUploadStart: function (e) {
            this.globalUploadCount++;
            utils.log('onUploadStart called ' + this.globalUploadCount);

            if (this.globalUploadCount === 1) {
              this._disableSubmitButton();
            }
          },

          onUploadStop: function (e) {
            this.globalUploadCount = (this.globalUploadCount <= 0) ? 0 : this.globalUploadCount - 1;

            utils.log('onUploadStop called ' + this.globalUploadCount);

            if (this.globalUploadCount === 0) {
              this._enableSubmitButton();
            }
          },

          onError: function (e) {
            utils.log('onError called');
            this.canSubmit = false;
          },

          _disableSubmitButton: function (message) {
            this.setSubmitButton(null, message || i18n.t("general:wait"));
            this.submitBtn
              .attr('disabled', 'disabled')
              .addClass('disabled');
          },

          _enableSubmitButton: function () {
            this.resetSubmitButton();
            this.submitBtn
              .removeAttr('disabled')
              .removeClass('disabled');
          },

          _events: {
            "disableSubmitButton": "_disableSubmitButton",
            "enableSubmitButton": "_enableSubmitButton",
            "setSubmitButton": "setSubmitButton",
            "resetSubmitButton": "resetSubmitButton",
            "onError": "onError",
            "onUploadStart": "onUploadStart",
            "onUploadStop": "onUploadStop"
          },

          _bindEvents: function () {
            Object.keys(this._events).forEach(function (type) {
              EventBus.on(type, this[this._events[type]], this);
            }, this);
          }

        });

        module.exports = Submittable;


      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"../event-bus": 165, "../utils": 184}],
    170: [function (require, module, exports) {
      (function (global) {
        "use strict";

        /*
         SirTrevor Floating Block Controls
         --
         Draws the 'plus' between blocks
         */

        var _ = require('./lodash');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);

        var EventBus = require('./event-bus');

        var FloatingBlockControls = function (wrapper, instance_id, mediator) {
          this.$wrapper = wrapper;
          this.instance_id = instance_id;
          this.mediator = mediator;

          this._ensureElement();
          this._bindFunctions();

          this.initialize();
        };

        Object.assign(FloatingBlockControls.prototype, require('./function-bind'), require('./renderable'), require('./events'), {

          className: "st-block-controls__top",

          attributes: function () {
            return {
              'data-icon': 'add'
            };
          },

          bound: ['handleBlockMouseOut', 'handleBlockMouseOver', 'handleBlockClick', 'onDrop'],

          initialize: function () {
            this.$el.on('click', this.handleBlockClick)
              .dropArea()
              .bind('drop', this.onDrop);

            this.$wrapper.on('mouseover', '.st-block', this.handleBlockMouseOver)
              .on('mouseout', '.st-block', this.handleBlockMouseOut)
              .on('click', '.st-block--with-plus', this.handleBlockClick);
          },

          onDrop: function (ev) {
            ev.preventDefault();
            ev.stopPropagation(); // to prevent event handling on outer blocks

            var dropped_on = this.$el,
              item_id = ev.originalEvent.dataTransfer.getData("text/plain"),
              block = $('#' + item_id);

            if (!_.isUndefined(item_id) && !_.isEmpty(block) &&
              dropped_on.attr('id') !== item_id &&
              this.instance_id === block.attr('data-instance')
            ) {
              dropped_on.after(block);
            }

            EventBus.trigger("block:reorder:dropped", item_id);
          },

          handleBlockMouseOver: function (e) {
            var block = $(e.currentTarget);

            if (!block.hasClass('st-block--with-plus')) {
              block.addClass('st-block--with-plus');
            }
          },

          handleBlockMouseOut: function (e) {
            var block = $(e.currentTarget);

            if (block.hasClass('st-block--with-plus')) {
              block.removeClass('st-block--with-plus');
            }
          },

          handleBlockClick: function (e) {
            e.stopPropagation();
            this.mediator.trigger('block-controls:render', $(e.currentTarget));
          }

        });

        module.exports = FloatingBlockControls;

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"./event-bus": 165, "./events": 166, "./function-bind": 173, "./lodash": 178, "./renderable": 180}],
    171: [function (require, module, exports) {
      "use strict";

      var config = require('./config');
      var utils = require('./utils');

      var EventBus = require('./event-bus');
      var Submittable = require('./extensions/submittable');

      var formBound = false; // Flag to tell us once we've bound our submit event

      var FormEvents = {
        bindFormSubmit: function (form) {
          if (!formBound) {
            // XXX: should we have a formBound and submittable per-editor?
            // telling JSHint to ignore as it'll complain we shouldn't be creating
            // a new object, but otherwise `this` won't be set in the Submittable
            // initialiser. Bit weird.
            new Submittable(form); // jshint ignore:line
            form.bind('submit', this.onFormSubmit);
            formBound = true;
          }
        },

        onBeforeSubmit: function (shouldValidate) {
          // Loop through all of our instances and do our form submits on them
          var errors = 0;
          config.instances.forEach(function (inst, i) {
            errors += inst.onFormSubmit(shouldValidate);
          });
          utils.log("Total errors: " + errors);

          return errors;
        },

        onFormSubmit: function (ev) {
          var errors = FormEvents.onBeforeSubmit();

          if (errors > 0) {
            EventBus.trigger("onError");
            ev.preventDefault();
          }
        },
      };

      module.exports = FormEvents;

    }, {"./config": 162, "./event-bus": 165, "./extensions/submittable": 169, "./utils": 184}],
    172: [function (require, module, exports) {
      (function (global) {
        "use strict";

        /**
         * Format Bar
         * --
         * Displayed on focus on a text area.
         * Renders with all available options for the editor instance
         */

        var _ = require('./lodash');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);

        var config = require('./config');
        var utils = require('./utils');

        var FormatBar = function (options, mediator) {
          this.options = Object.assign({}, config.defaults.formatBar, options || {});
          this.commands = this.options.commands;
          this.mediator = mediator;

          this._ensureElement();
          this._bindFunctions();
          this._bindMediatedEvents();

          this.initialize.apply(this, arguments);
        };

        Object.assign(FormatBar.prototype, require('./function-bind'), require('./mediated-events'), require('./events'), require('./renderable'), {

          className: 'st-format-bar',

          bound: ["onFormatButtonClick", "renderBySelection", "hide"],

          eventNamespace: 'formatter',

          mediatedEvents: {
            'position': 'renderBySelection',
            'show': 'show',
            'hide': 'hide'
          },

          initialize: function () {
            this.$btns = [];

            this.commands.forEach(function (format) {
              var btn = $("<button>", {
                'class': 'st-format-btn st-format-btn--' + format.name + ' ' +
                (format.iconName ? 'st-icon' : ''),
                'text': format.text,
                'data-cmd': format.cmd
              });

              this.$btns.push(btn);
              btn.appendTo(this.$el);
            }, this);

            this.$b = $(document);
            this.$el.bind('click', '.st-format-btn', this.onFormatButtonClick);
          },

          hide: function () {
            this.$el.removeClass('st-format-bar--is-ready');
          },

          show: function () {
            this.$el.addClass('st-format-bar--is-ready');
          },

          remove: function () {
            this.$el.remove();
          },

          renderBySelection: function () {
            var selection = window.getSelection(),
              range = selection.getRangeAt(0),
              boundary = range.getBoundingClientRect(),
              coords = {},
              scrollTop = this.el.parentNode.scrollTop,
            // in case the format bar is inside a scrollable container
              leftOffset = this.el.parentNode.offsetLeft,
              topOffset = this.el.parentNode.offsetTop;

            coords.top = boundary.top + 20 + scrollTop - this.$el.height() - topOffset + 'px';
            coords.left = ((boundary.left + boundary.right) / 2) - (this.$el.width() / 2) - leftOffset + 'px';

            this.highlightSelectedButtons();
            this.show();

            this.$el.css(coords);
          },

          highlightSelectedButtons: function () {
            var block = utils.getBlockBySelection();
            this.$btns.forEach(function (btn) {
              var cmd = $(btn).data('cmd');
              btn.toggleClass("st-format-btn--is-active",
                block.queryTextBlockCommandState(cmd));
            }, this);
          },

          onFormatButtonClick: function (ev) {
            ev.stopPropagation();

            var block = utils.getBlockBySelection();
            if (_.isUndefined(block)) {
              throw "Associated block not found";
            }

            var btn = $(ev.target),
              cmd = btn.data('cmd');

            if (_.isUndefined(cmd)) {
              return false;
            }

            block.execTextBlockCommand(cmd);

            this.highlightSelectedButtons();

            return false;
          }

        });

        module.exports = FormatBar;

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {
      "./config": 162,
      "./events": 166,
      "./function-bind": 173,
      "./lodash": 178,
      "./mediated-events": 179,
      "./renderable": 180,
      "./utils": 184
    }],
    173: [function (require, module, exports) {
      "use strict";

      /* Generic function binding utility, used by lots of our classes */

      module.exports = {
        bound: [],
        _bindFunctions: function () {
          this.bound.forEach(function (f) {
            this[f] = this[f].bind(this);
          }, this);
        }
      };


    }, {}],
    174: [function (require, module, exports) {
      (function (global) {
        "use strict";

        /*
         * Drop Area Plugin from @maccman
         * http://blog.alexmaccaw.com/svbtle-image-uploading
         * --
         * Tweaked so we use the parent class of dropzone
         */

        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);

        function dragEnter(e) {
          e.preventDefault();
        }

        function dragOver(e) {
          e.originalEvent.dataTransfer.dropEffect = "copy";
          $(e.currentTarget).addClass('st-drag-over');
          e.preventDefault();
        }

        function dragLeave(e) {
          $(e.currentTarget).removeClass('st-drag-over');
          e.preventDefault();
        }

        $.fn.dropArea = function () {
          this.bind("dragenter", dragEnter).
            bind("dragover", dragOver).
            bind("dragleave", dragLeave);
          return this;
        };

        $.fn.noDropArea = function () {
          this.unbind("dragenter").
            unbind("dragover").
            unbind("dragleave");
          return this;
        };

        $.fn.caretToEnd = function () {
          var range, selection;

          range = document.createRange();
          range.selectNodeContents(this[0]);
          range.collapse(false);

          selection = window.getSelection();
          selection.removeAllRanges();
          selection.addRange(range);

          return this;
        };


      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {}],
    175: [function (require, module, exports) {
      "use strict";

      /*
       Backbone Inheritence
       --
       From: https://github.com/documentcloud/backbone/blob/master/backbone.js
       Backbone.js 0.9.2
       (c) 2010-2012 Jeremy Ashkenas, DocumentCloud Inc.
       */

      module.exports = function (protoProps, staticProps) {
        var parent = this;
        var child;

        // The constructor function for the new subclass is either defined by you
        // (the "constructor" property in your `extend` definition), or defaulted
        // by us to simply call the parent's constructor.
        if (protoProps && protoProps.hasOwnProperty('constructor')) {
          child = protoProps.constructor;
        } else {
          child = function () {
            return parent.apply(this, arguments);
          };
        }

        // Add static properties to the constructor function, if supplied.
        Object.assign(child, parent, staticProps);

        // Set the prototype chain to inherit from `parent`, without calling
        // `parent`'s constructor function.
        var Surrogate = function () {
          this.constructor = child;
        };
        Surrogate.prototype = parent.prototype;
        child.prototype = new Surrogate; // jshint ignore:line

        // Add prototype properties (instance properties) to the subclass,
        // if supplied.
        if (protoProps) {
          Object.assign(child.prototype, protoProps);
        }

        // Set a convenience property in case the parent's prototype is needed
        // later.
        child.__super__ = parent.prototype;

        return child;
      };

    }, {}],
    176: [function (require, module, exports) {
      "use strict";

      var _ = require('./lodash');

// ES6 shims
      require('object.assign').shim();
      require('array.prototype.find');
      require('./vendor/array-includes'); // shims ES7 Array.prototype.includes

      require('./helpers/event'); // extends jQuery itself

      var utils = require('./utils');

      var SirTrevor = {

        config: require('./config'),

        log: utils.log,
        Locales: require('./locales'),

        Events: require('./events'),
        EventBus: require('./event-bus'),

        EditorStore: require('./extensions/editor-store'),
        Submittable: require('./extensions/submittable'),
        FileUploader: require('./extensions/file-uploader'),

        BlockMixins: require('./block_mixins'),
        BlockPositioner: require('./block-positioner'),
        BlockReorder: require('./block-reorder'),
        BlockDeletion: require('./block-deletion'),
        BlockValidations: require('./block-validations'),
        BlockStore: require('./block-store'),
        BlockManager: require('./block-manager'),

        SimpleBlock: require('./simple-block'),
        Block: require('./block'),

        Blocks: require('./blocks'),

        BlockControl: require('./block-control'),
        BlockControls: require('./block-controls'),
        FloatingBlockControls: require('./floating-block-controls'),

        FormatBar: require('./format-bar'),
        Editor: require('./editor'),

        toMarkdown: require('./to-markdown'),
        toHTML: require('./to-html'),

        setDefaults: function (options) {
          Object.assign(SirTrevor.config.defaults, options || {});
        },

        getInstance: utils.getInstance,

        setBlockOptions: function (type, options) {
          var block = SirTrevor.Blocks[type];

          if (_.isUndefined(block)) {
            return;
          }

          Object.assign(block.prototype, options || {});
        },

        runOnAllInstances: function (method) {
          if (SirTrevor.Editor.prototype.hasOwnProperty(method)) {
            var methodArgs = Array.prototype.slice.call(arguments, 1);
            Array.prototype.forEach.call(SirTrevor.config.instances, function (i) {
              i[method].apply(null, methodArgs);
            });
          } else {
            SirTrevor.log("method doesn't exist");
          }
        },

      };

      Object.assign(SirTrevor, require('./form-events'));


      module.exports = SirTrevor;

    }, {
      "./block": 146,
      "./block-control": 138,
      "./block-controls": 139,
      "./block-deletion": 140,
      "./block-manager": 141,
      "./block-positioner": 142,
      "./block-reorder": 143,
      "./block-store": 144,
      "./block-validations": 145,
      "./block_mixins": 151,
      "./blocks": 156,
      "./config": 162,
      "./editor": 163,
      "./event-bus": 165,
      "./events": 166,
      "./extensions/editor-store": 167,
      "./extensions/file-uploader": 168,
      "./extensions/submittable": 169,
      "./floating-block-controls": 170,
      "./form-events": 171,
      "./format-bar": 172,
      "./helpers/event": 174,
      "./locales": 177,
      "./lodash": 178,
      "./simple-block": 181,
      "./to-html": 182,
      "./to-markdown": 183,
      "./utils": 184,
      "./vendor/array-includes": 185,
      "array.prototype.find": 2,
      "object.assign": 51
    }],
    177: [function (require, module, exports) {
      "use strict";

      var _ = require('./lodash');
      var config = require('./config');
      var utils = require('./utils');

      var Locales = {
        en: {
          general: {
            'delete': 'Delete?',
            'drop': 'Drag __block__ here',
            'paste': 'Or paste URL here',
            'upload': '...or choose a file',
            'close': 'close',
            'position': 'Position',
            'wait': 'Please wait...',
            'link': 'Enter a link'
          },
          errors: {
            'title': "You have the following errors:",
            'validation_fail': "__type__ block is invalid",
            'block_empty': "__name__ must not be empty",
            'type_missing': "You must have a block of type __type__",
            'required_type_empty': "A required block type __type__ is empty",
            'load_fail': "There was a problem loading the contents of the document"
          },
          blocks: {
            text: {
              'title': "Text"
            },
            list: {
              'title': "List"
            },
            quote: {
              'title': "Quote",
              'credit_field': "Credit"
            },
            image: {
              'title': "Image",
              'upload_error': "There was a problem with your upload"
            },
            video: {
              'title': "Video"
            },
            tweet: {
              'title': "Tweet",
              'fetch_error': "There was a problem fetching your tweet"
            },
            embedly: {
              'title': "Embedly",
              'fetch_error': "There was a problem fetching your embed",
              'key_missing': "An Embedly API key must be present"
            },
            heading: {
              'title': "Heading"
            }
          }
        }
      };

      if (window.i18n === undefined) {
        // Minimal i18n stub that only reads the English strings
        utils.log("Using i18n stub");
        window.i18n = {
          t: function (key, options) {
            var parts = key.split(':'), str, obj, part, i;

            obj = Locales[config.language];

            for (i = 0; i < parts.length; i++) {
              part = parts[i];

              if (!_.isUndefined(obj[part])) {
                obj = obj[part];
              }
            }

            str = obj;

            if (!_.isString(str)) {
              return "";
            }

            if (str.indexOf('__') >= 0) {
              Object.keys(options).forEach(function (opt) {
                str = str.replace('__' + opt + '__', options[opt]);
              });
            }

            return str;
          }
        };
      } else {
        utils.log("Using i18next");
        // Only use i18next when the library has been loaded by the user, keeps
        // dependencies slim
        i18n.init({
          resStore: Locales, fallbackLng: config.language,
          ns: {namespaces: ['general', 'blocks'], defaultNs: 'general'}
        });
      }

      module.exports = Locales;

    }, {"./config": 162, "./lodash": 178, "./utils": 184}],
    178: [function (require, module, exports) {
      "use strict";

      exports.isEmpty = require('lodash.isempty');
      exports.isFunction = require('lodash.isfunction');
      exports.isObject = require('lodash.isobject');
      exports.isString = require('lodash.isstring');
      exports.isUndefined = require('lodash.isundefined');
      exports.result = require('lodash.result');
      exports.template = require('lodash.template');
      exports.uniqueId = require('lodash.uniqueid');

    }, {
      "lodash.isempty": 4,
      "lodash.isfunction": 28,
      "lodash.isobject": 29,
      "lodash.isstring": 31,
      "lodash.isundefined": 32,
      "lodash.result": 33,
      "lodash.template": 34,
      "lodash.uniqueid": 50
    }],
    179: [function (require, module, exports) {
      "use strict";

      module.exports = {
        mediatedEvents: {},
        eventNamespace: null,
        _bindMediatedEvents: function () {
          Object.keys(this.mediatedEvents).forEach(function (eventName) {
            var cb = this.mediatedEvents[eventName];
            eventName = this.eventNamespace ?
            this.eventNamespace + ':' + eventName :
              eventName;
            this.mediator.on(eventName, this[cb].bind(this));
          }, this);
        }
      };

    }, {}],
    180: [function (require, module, exports) {
      (function (global) {
        "use strict";

        var _ = require('./lodash');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);

        module.exports = {
          tagName: 'div',
          className: 'sir-trevor__view',
          attributes: {},

          $: function (selector) {
            return this.$el.find(selector);
          },

          render: function () {
            return this;
          },

          destroy: function () {
            if (!_.isUndefined(this.stopListening)) {
              this.stopListening();
            }
            this.$el.remove();
          },

          _ensureElement: function () {
            if (!this.el) {
              var attrs = Object.assign({}, _.result(this, 'attributes')),
                html;
              if (this.id) {
                attrs.id = this.id;
              }
              if (this.className) {
                attrs['class'] = this.className;
              }

              if (attrs.html) {
                html = attrs.html;
                delete attrs.html;
              }
              var $el = $('<' + this.tagName + '>').attr(attrs);
              if (html) {
                $el.html(html);
              }
              this._setElement($el);
            } else {
              this._setElement(this.el);
            }
          },

          _setElement: function (element) {
            this.$el = $(element);
            this.el = this.$el[0];
            return this;
          }
        };


      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"./lodash": 178}],
    181: [function (require, module, exports) {
      (function (global) {
        "use strict";

        var _ = require('./lodash');
        var utils = require('./utils');
        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);

        var BlockReorder = require('./block-reorder');

        var SimpleBlock = function (data, editorInstance, mediator, options) {
          this.createStore(data);
          this.blockID = _.uniqueId('st-block-');
          this.editorInstance = editorInstance; // save instance itself
          this.instanceID = editorInstance.ID; // save instance ID for backward compatibility
          this.mediator = mediator;
          this.options = options || {};

          this._ensureElement();
          this._bindFunctions();

          this.initialize.apply(this, arguments);
        };

        Object.assign(SimpleBlock.prototype, require('./function-bind'), require('./events'), require('./renderable'), require('./block-store'), {

          focus: function () {
          },

          valid: function () {
            return true;
          },

          className: 'st-block',

          block_template: _.template(
            "<div class='st-block__inner'><%= editor_html %></div>"
          ),

          attributes: function () {
            return {
              'id': this.blockID,
              'data-type': this.type,
              'data-instance': this.instanceID
            };
          },

          title: function () {
            return utils.titleize(this.type.replace(/[\W_]/g, ' '));
          },

          blockCSSClass: function () {
            this.blockCSSClass = utils.toSlug(this.type);
            return this.blockCSSClass;
          },

          type: '',

          class: function () {
            return utils.classify(this.type);
          },

          editorHTML: '',

          initialize: function () {
          },

          onBlockRender: function () {
          },
          beforeBlockRender: function () {
          },

          _setBlockInner: function () {
            var editor_html = _.result(this, 'editorHTML');

            this.$el.append(
              this.block_template({editor_html: editor_html})
            );

            this.$inner = this.$el.find('.st-block__inner');
            this.$inner.bind('click mouseover', function (e) {
              e.stopPropagation();
            });
          },

          render: function () {
            this.beforeBlockRender();

            this._setBlockInner();
            this._blockPrepare();

            return this;
          },

          _blockPrepare: function () {
            this._initUI();
            this._initMessages();

            this.checkAndLoadData();

            this.$el.addClass('st-item-ready');
            this.on("onRender", this.onBlockRender);
            this.save();
          },

          _withUIComponent: function (component, className, callback) {
            this.$ui.append(component.render().$el);
            if (className && callback) {
              this.$ui.on('click', className, callback);
            }
          },

          _initUI: function () {
            var ui_element = $("<div>", {'class': 'st-block__ui'});
            this.$inner.append(ui_element);
            this.$ui = ui_element;
            this._initUIComponents();
          },

          _initMessages: function () {
            var msgs_element = $("<div>", {'class': 'st-block__messages'});
            this.$inner.prepend(msgs_element);
            this.$messages = msgs_element;
          },

          addMessage: function (msg, additionalClass) {
            var $msg = $("<span>", {html: msg, class: "st-msg " + additionalClass});
            this.$messages.append($msg)
              .addClass('st-block__messages--is-visible');
            return $msg;
          },

          resetMessages: function () {
            this.$messages.html('')
              .removeClass('st-block__messages--is-visible');
          },

          _initUIComponents: function () {
            this._withUIComponent(new BlockReorder(this.$el));
          }

        });

        SimpleBlock.fn = SimpleBlock.prototype;

// Allow our Block to be extended.
        SimpleBlock.extend = require('./helpers/extend');

        module.exports = SimpleBlock;

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {
      "./block-reorder": 143,
      "./block-store": 144,
      "./events": 166,
      "./function-bind": 173,
      "./helpers/extend": 175,
      "./lodash": 178,
      "./renderable": 180,
      "./utils": 184
    }],
    182: [function (require, module, exports) {
      "use strict";

      var _ = require('./lodash');
      var utils = require('./utils');

      module.exports = function (markdown, type) {

        // Deferring requiring these to sidestep a circular dependency:
        // Block -> this -> Blocks -> Block
        var Blocks = require('./blocks');

        // MD -> HTML
        type = utils.classify(type);

        var html = markdown,
          shouldWrap = type === "Text";

        if (_.isUndefined(shouldWrap)) {
          shouldWrap = false;
        }

        if (shouldWrap) {
          html = "<p>" + html;
        }

        html = html.replace(/\[([^\]]+)\]\(([^\)]+)\)/gm, function (match, p1, p2) {
          return "<a href='" + p2 + "'>" + p1.replace(/\n/g, '') + "</a>";
        });

        // This may seem crazy, but because JS doesn't have a look behind,
        // we reverse the string to regex out the italic items (and bold)
        // and look for something that doesn't start (or end in the reversed strings case)
        // with a slash.
        html = utils.reverse(
          utils.reverse(html)
            .replace(/_(?!\\)((_\\|[^_])*)_(?=$|[^\\])/gm, function (match, p1) {
              return ">i/<" + p1.replace(/\n/g, '').replace(/[\s]+$/, '') + ">i<";
            })
            .replace(/\*\*(?!\\)((\*\*\\|[^\*\*])*)\*\*(?=$|[^\\])/gm, function (match, p1) {
              return ">b/<" + p1.replace(/\n/g, '').replace(/[\s]+$/, '') + ">b<";
            })
        );

        html = html.replace(/^\> (.+)$/mg, "$1");

        // Use custom block toHTML functions (if any exist)
        var block;
        if (Blocks.hasOwnProperty(type)) {
          block = Blocks[type];
          // Do we have a toHTML function?
          if (!_.isUndefined(block.prototype.toHTML) && _.isFunction(block.prototype.toHTML)) {
            html = block.prototype.toHTML(html);
          }
        }

        if (shouldWrap) {
          html = html.replace(/\n\s*\n/gm, "</p><p>");
          html = html.replace(/\n/gm, "<br>");
        }

        html = html.replace(/\t/g, "&nbsp;&nbsp;&nbsp;&nbsp;")
          .replace(/\n/g, "<br>")
          .replace(/\*\*/, "")
          .replace(/__/, "");  // Cleanup any markdown characters left

        // Replace escaped
        html = html.replace(/\\\*/g, "*")
          .replace(/\\\[/g, "[")
          .replace(/\\\]/g, "]")
          .replace(/\\\_/g, "_")
          .replace(/\\\(/g, "(")
          .replace(/\\\)/g, ")")
          .replace(/\\\-/g, "-");

        if (shouldWrap) {
          html += "</p>";
        }

        return html;
      };

    }, {"./blocks": 156, "./lodash": 178, "./utils": 184}],
    183: [function (require, module, exports) {
      "use strict";

      var _ = require('./lodash');
      var utils = require('./utils');

      module.exports = function (content, type) {

        // Deferring requiring these to sidestep a circular dependency:
        // Block -> this -> Blocks -> Block
        var Blocks = require('./blocks');

        type = utils.classify(type);

        var markdown = content;

        //Normalise whitespace
        markdown = markdown.replace(/&nbsp;/g, " ");

        // First of all, strip any additional formatting
        // MSWord, I'm looking at you, punk.
        markdown = markdown.replace(/( class=(")?Mso[a-zA-Z]+(")?)/g, '')
          .replace(/<!--(.*?)-->/g, '')
          .replace(/\/\*(.*?)\*\//g, '')
          .replace(/<(\/)*(meta|link|span|\\?xml:|st1:|o:|font)(.*?)>/gi, '');

        var badTags = ['style', 'script', 'applet', 'embed', 'noframes', 'noscript'],
          tagStripper, i;

        for (i = 0; i < badTags.length; i++) {
          tagStripper = new RegExp('<' + badTags[i] + '.*?' + badTags[i] + '(.*?)>', 'gi');
          markdown = markdown.replace(tagStripper, '');
        }

        // Escape anything in here that *could* be considered as MD
        // Markdown chars we care about: * [] _ () -
        markdown = markdown.replace(/\*/g, "\\*")
          .replace(/\[/g, "\\[")
          .replace(/\]/g, "\\]")
          .replace(/\_/g, "\\_")
          .replace(/\(/g, "\\(")
          .replace(/\)/g, "\\)")
          .replace(/\-/g, "\\-");

        var inlineTags = ["em", "i", "strong", "b"];

        for (i = 0; i < inlineTags.length; i++) {
          tagStripper = new RegExp('<' + inlineTags[i] + '><br></' + inlineTags[i] + '>', 'gi');
          markdown = markdown.replace(tagStripper, '<br>');
        }

        function replaceBolds(match, p1, p2) {
          if (_.isUndefined(p2)) {
            p2 = '';
          }
          return "**" + p1.replace(/<(.)?br(.)?>/g, '') + "**" + p2;
        }

        function replaceItalics(match, p1, p2) {
          if (_.isUndefined(p2)) {
            p2 = '';
          }
          return "_" + p1.replace(/<(.)?br(.)?>/g, '') + "_" + p2;
        }

        markdown = markdown.replace(/<(\w+)(?:\s+\w+="[^"]+(?:"\$[^"]+"[^"]+)?")*>\s*<\/\1>/gim, '') //Empty elements
          .replace(/\n/mg, "")
          .replace(/<a.*?href=[""'](.*?)[""'].*?>(.*?)<\/a>/gim, function (match, p1, p2) {
            return "[" + p2.trim().replace(/<(.)?br(.)?>/g, '') + "](" + p1 + ")";
          }) // Hyperlinks
          .replace(/<strong>(?:\s*)(.*?)(\s)*?<\/strong>/gim, replaceBolds)
          .replace(/<b>(?:\s*)(.*?)(\s*)?<\/b>/gim, replaceBolds)
          .replace(/<em>(?:\s*)(.*?)(\s*)?<\/em>/gim, replaceItalics)
          .replace(/<i>(?:\s*)(.*?)(\s*)?<\/i>/gim, replaceItalics);


        // Do our generic stripping out
        markdown = markdown.replace(/([^<>]+)(<div>)/g, "$1\n$2")                                 // Divitis style line breaks (handle the first line)
          .replace(/<div><div>/g, '\n<div>')                                         // ^ (double opening divs with one close from Chrome)
          .replace(/(?:<div>)([^<>]+)(?:<div>)/g, "$1\n")                            // ^ (handle nested divs that start with content)
          .replace(/(?:<div>)(?:<br>)?([^<>]+)(?:<br>)?(?:<\/div>)/g, "$1\n")        // ^ (handle content inside divs)
          .replace(/<\/p>/g, "\n\n")                                               // P tags as line breaks
          .replace(/<(.)?br(.)?>/g, "\n")                                            // Convert normal line breaks
          .replace(/&lt;/g, "<").replace(/&gt;/g, ">");                                 // Encoding

        // Use custom block toMarkdown functions (if any exist)
        var block;
        if (Blocks.hasOwnProperty(type)) {
          block = Blocks[type];
          // Do we have a toMarkdown function?
          if (!_.isUndefined(block.prototype.toMarkdown) && _.isFunction(block.prototype.toMarkdown)) {
            markdown = block.prototype.toMarkdown(markdown);
          }
        }

        // Strip remaining HTML
        markdown = markdown.replace(/<\/?[^>]+(>|$)/g, "");

        return markdown;
      };

    }, {"./blocks": 156, "./lodash": 178, "./utils": 184}],
    184: [function (require, module, exports) {
      (function (global) {
        "use strict";

        var $ = (typeof window !== "undefined" ? window.$ : typeof global !== "undefined" ? global.$ : null);
        var _ = require('./lodash');
        var config = require('./config');

        var urlRegex = /^(?:([A-Za-z]+):)?(\/{0,3})([0-9.\-A-Za-z]+)(?::(\d+))?(?:\/([^?#]*))?(?:\?([^#]*))?(?:#(.*))?$/;

        var utils = {

          getInstance: function (identifier) {
            if (_.isUndefined(identifier)) {
              return config.instances[0];
            }

            if (_.isString(identifier)) {
              return config.instances.find(function (editor) {
                return editor.ID === identifier;
              });
            }

            return config.instances[identifier];
          },

          getInstanceBySelection: function () {
            return utils.getInstance(
              $(window.getSelection().anchorNode).
                parents('.st-block').data('instance'));
          },

          getBlockBySelection: function () {
            return utils.getInstanceBySelection().findBlockById(
              $(window.getSelection().anchorNode).parents('.st-block').get(0).id
            );
          },

          log: function () {
            if (!_.isUndefined(console) && config.debug) {
              console.log.apply(console, arguments);
            }
          },

          isURI: function (string) {
            return (urlRegex.test(string));
          },

          titleize: function (str) {
            if (str === null) {
              return '';
            }
            str = String(str).toLowerCase();
            return str.replace(/(?:^|\s|-)\S/g, function (c) {
              return c.toUpperCase();
            });
          },

          classify: function (str) {
            return utils.titleize(String(str).replace(/[\W_]/g, ' ')).replace(/\s/g, '');
          },

          capitalize: function (string) {
            return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();
          },

          flatten: function (obj) {
            var x = {};
            (Array.isArray(obj) ? obj : Object.keys(obj)).forEach(function (i) {
              x[i] = true;
            });
            return x;
          },

          underscored: function (str) {
            return str.trim().replace(/([a-z\d])([A-Z]+)/g, '$1_$2')
              .replace(/[-\s]+/g, '_').toLowerCase();
          },

          reverse: function (str) {
            return str.split("").reverse().join("");
          },

          toSlug: function (str) {
            return str
              .toLowerCase()
              .replace(/[^\w ]+/g, '')
              .replace(/ +/g, '-');
          }

        };

        module.exports = utils;

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"./config": 162, "./lodash": 178}],
    185: [function (require, module, exports) {
      "use strict";

// jshint freeze: false

      if (![].includes) {
        Array.prototype.includes = function (searchElement /*, fromIndex*/) {
          if (this === undefined || this === null) {
            throw new TypeError('Cannot convert this value to object');
          }
          var O = Object(this);
          var len = parseInt(O.length) || 0;
          if (len === 0) {
            return false;
          }
          var n = parseInt(arguments[1]) || 0;
          var k;
          if (n >= 0) {
            k = n;
          } else {
            k = len + n;
            if (k < 0) {
              k = 0;
            }
          }
          while (k < len) {
            var currentElement = O[k];
            if (searchElement === currentElement ||
              (searchElement !== searchElement && currentElement !== currentElement)) {
              return true;
            }
            k++;
          }
          return false;
        };
      }

    }, {}]
  }, {}, [1])(1)
});