slate-react/dist/slate-react.js

Tools for building completely customizable richtext editors with React.

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('slate')) :
	typeof define === 'function' && define.amd ? define(['exports', 'react', 'slate'], factory) :
	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SlateReact = {}, global.React, global.Slate));
})(this, (function (exports, React, slate) { 'use strict';

	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

	function unwrapExports (x) {
		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
	}

	function createCommonjsModule(fn, module) {
		return module = { exports: {} }, fn(module, module.exports), module.exports;
	}

	var arrayWithHoles = createCommonjsModule(function (module) {
	function _arrayWithHoles(arr) {
	  if (Array.isArray(arr)) return arr;
	}
	module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
	});

	unwrapExports(arrayWithHoles);

	var iterableToArrayLimit = createCommonjsModule(function (module) {
	function _iterableToArrayLimit(r, l) {
	  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	  if (null != t) {
	    var e,
	      n,
	      i,
	      u,
	      a = [],
	      f = !0,
	      o = !1;
	    try {
	      if (i = (t = t.call(r)).next, 0 === l) {
	        if (Object(t) !== t) return;
	        f = !1;
	      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
	    } catch (r) {
	      o = !0, n = r;
	    } finally {
	      try {
	        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
	      } finally {
	        if (o) throw n;
	      }
	    }
	    return a;
	  }
	}
	module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports;
	});

	unwrapExports(iterableToArrayLimit);

	var arrayLikeToArray = createCommonjsModule(function (module) {
	function _arrayLikeToArray(arr, len) {
	  if (len == null || len > arr.length) len = arr.length;
	  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
	  return arr2;
	}
	module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
	});

	unwrapExports(arrayLikeToArray);

	var unsupportedIterableToArray = createCommonjsModule(function (module) {
	function _unsupportedIterableToArray(o, minLen) {
	  if (!o) return;
	  if (typeof o === "string") return arrayLikeToArray(o, minLen);
	  var n = Object.prototype.toString.call(o).slice(8, -1);
	  if (n === "Object" && o.constructor) n = o.constructor.name;
	  if (n === "Map" || n === "Set") return Array.from(o);
	  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);
	}
	module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
	});

	unwrapExports(unsupportedIterableToArray);

	var nonIterableRest = createCommonjsModule(function (module) {
	function _nonIterableRest() {
	  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
	}
	module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports;
	});

	unwrapExports(nonIterableRest);

	var slicedToArray = createCommonjsModule(function (module) {
	function _slicedToArray(arr, i) {
	  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
	}
	module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
	});

	var _slicedToArray = unwrapExports(slicedToArray);

	var objectWithoutPropertiesLoose = createCommonjsModule(function (module) {
	function _objectWithoutPropertiesLoose(source, excluded) {
	  if (source == null) return {};
	  var target = {};
	  var sourceKeys = Object.keys(source);
	  var key, i;
	  for (i = 0; i < sourceKeys.length; i++) {
	    key = sourceKeys[i];
	    if (excluded.indexOf(key) >= 0) continue;
	    target[key] = source[key];
	  }
	  return target;
	}
	module.exports = _objectWithoutPropertiesLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;
	});

	unwrapExports(objectWithoutPropertiesLoose);

	var objectWithoutProperties = createCommonjsModule(function (module) {
	function _objectWithoutProperties(source, excluded) {
	  if (source == null) return {};
	  var target = objectWithoutPropertiesLoose(source, excluded);
	  var key, i;
	  if (Object.getOwnPropertySymbols) {
	    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
	    for (i = 0; i < sourceSymbolKeys.length; i++) {
	      key = sourceSymbolKeys[i];
	      if (excluded.indexOf(key) >= 0) continue;
	      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
	      target[key] = source[key];
	    }
	  }
	  return target;
	}
	module.exports = _objectWithoutProperties, module.exports.__esModule = true, module.exports["default"] = module.exports;
	});

	var _objectWithoutProperties$1 = unwrapExports(objectWithoutProperties);

	var _typeof_1 = createCommonjsModule(function (module) {
	function _typeof(o) {
	  "@babel/helpers - typeof";

	  return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
	    return typeof o;
	  } : function (o) {
	    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	  }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(o);
	}
	module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
	});

	unwrapExports(_typeof_1);

	var toPrimitive = createCommonjsModule(function (module) {
	var _typeof = _typeof_1["default"];
	function _toPrimitive(input, hint) {
	  if (_typeof(input) !== "object" || input === null) return input;
	  var prim = input[Symbol.toPrimitive];
	  if (prim !== undefined) {
	    var res = prim.call(input, hint || "default");
	    if (_typeof(res) !== "object") return res;
	    throw new TypeError("@@toPrimitive must return a primitive value.");
	  }
	  return (hint === "string" ? String : Number)(input);
	}
	module.exports = _toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports;
	});

	unwrapExports(toPrimitive);

	var toPropertyKey = createCommonjsModule(function (module) {
	var _typeof = _typeof_1["default"];

	function _toPropertyKey(arg) {
	  var key = toPrimitive(arg, "string");
	  return _typeof(key) === "symbol" ? key : String(key);
	}
	module.exports = _toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports;
	});

	unwrapExports(toPropertyKey);

	var defineProperty = createCommonjsModule(function (module) {
	function _defineProperty(obj, key, value) {
	  key = toPropertyKey(key);
	  if (key in obj) {
	    Object.defineProperty(obj, key, {
	      value: value,
	      enumerable: true,
	      configurable: true,
	      writable: true
	    });
	  } else {
	    obj[key] = value;
	  }
	  return obj;
	}
	module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
	});

	var _defineProperty$1 = unwrapExports(defineProperty);

	var direction_1 = direction;

	var RTL = '\u0591-\u07FF\uFB1D-\uFDFD\uFE70-\uFEFC';
	var LTR =
	  'A-Za-z\u00C0-\u00D6\u00D8-\u00F6' +
	  '\u00F8-\u02B8\u0300-\u0590\u0800-\u1FFF\u200E\u2C00-\uFB1C' +
	  '\uFE00-\uFE6F\uFEFD-\uFFFF';

	var rtl = new RegExp('^[^' + LTR + ']*[' + RTL + ']');
	var ltr = new RegExp('^[^' + RTL + ']*[' + LTR + ']');

	function direction(value) {
	  value = String(value || '');

	  if (rtl.test(value)) {
	    return 'rtl'
	  }

	  if (ltr.test(value)) {
	    return 'ltr'
	  }

	  return 'neutral'
	}

	/**
	 * Checks if `value` is the
	 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
	 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
	 *
	 * @static
	 * @memberOf _
	 * @since 0.1.0
	 * @category Lang
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
	 * @example
	 *
	 * _.isObject({});
	 * // => true
	 *
	 * _.isObject([1, 2, 3]);
	 * // => true
	 *
	 * _.isObject(_.noop);
	 * // => true
	 *
	 * _.isObject(null);
	 * // => false
	 */
	function isObject(value) {
	  var type = typeof value;
	  return value != null && (type == 'object' || type == 'function');
	}

	var isObject_1 = isObject;

	/** Detect free variable `global` from Node.js. */
	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;

	var _freeGlobal = freeGlobal;

	/** Detect free variable `self`. */
	var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

	/** Used as a reference to the global object. */
	var root = _freeGlobal || freeSelf || Function('return this')();

	var _root = root;

	/**
	 * Gets the timestamp of the number of milliseconds that have elapsed since
	 * the Unix epoch (1 January 1970 00:00:00 UTC).
	 *
	 * @static
	 * @memberOf _
	 * @since 2.4.0
	 * @category Date
	 * @returns {number} Returns the timestamp.
	 * @example
	 *
	 * _.defer(function(stamp) {
	 *   console.log(_.now() - stamp);
	 * }, _.now());
	 * // => Logs the number of milliseconds it took for the deferred invocation.
	 */
	var now = function() {
	  return _root.Date.now();
	};

	var now_1 = now;

	/** Used to match a single whitespace character. */
	var reWhitespace = /\s/;

	/**
	 * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
	 * character of `string`.
	 *
	 * @private
	 * @param {string} string The string to inspect.
	 * @returns {number} Returns the index of the last non-whitespace character.
	 */
	function trimmedEndIndex(string) {
	  var index = string.length;

	  while (index-- && reWhitespace.test(string.charAt(index))) {}
	  return index;
	}

	var _trimmedEndIndex = trimmedEndIndex;

	/** Used to match leading whitespace. */
	var reTrimStart = /^\s+/;

	/**
	 * The base implementation of `_.trim`.
	 *
	 * @private
	 * @param {string} string The string to trim.
	 * @returns {string} Returns the trimmed string.
	 */
	function baseTrim(string) {
	  return string
	    ? string.slice(0, _trimmedEndIndex(string) + 1).replace(reTrimStart, '')
	    : string;
	}

	var _baseTrim = baseTrim;

	/** Built-in value references. */
	var Symbol$1 = _root.Symbol;

	var _Symbol = Symbol$1;

	/** Used for built-in method references. */
	var objectProto$1 = Object.prototype;

	/** Used to check objects for own properties. */
	var hasOwnProperty = objectProto$1.hasOwnProperty;

	/**
	 * Used to resolve the
	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
	 * of values.
	 */
	var nativeObjectToString$1 = objectProto$1.toString;

	/** Built-in value references. */
	var symToStringTag$1 = _Symbol ? _Symbol.toStringTag : undefined;

	/**
	 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
	 *
	 * @private
	 * @param {*} value The value to query.
	 * @returns {string} Returns the raw `toStringTag`.
	 */
	function getRawTag(value) {
	  var isOwn = hasOwnProperty.call(value, symToStringTag$1),
	      tag = value[symToStringTag$1];

	  try {
	    value[symToStringTag$1] = undefined;
	    var unmasked = true;
	  } catch (e) {}

	  var result = nativeObjectToString$1.call(value);
	  if (unmasked) {
	    if (isOwn) {
	      value[symToStringTag$1] = tag;
	    } else {
	      delete value[symToStringTag$1];
	    }
	  }
	  return result;
	}

	var _getRawTag = getRawTag;

	/** Used for built-in method references. */
	var objectProto = Object.prototype;

	/**
	 * Used to resolve the
	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
	 * of values.
	 */
	var nativeObjectToString = objectProto.toString;

	/**
	 * Converts `value` to a string using `Object.prototype.toString`.
	 *
	 * @private
	 * @param {*} value The value to convert.
	 * @returns {string} Returns the converted string.
	 */
	function objectToString(value) {
	  return nativeObjectToString.call(value);
	}

	var _objectToString = objectToString;

	/** `Object#toString` result references. */
	var nullTag = '[object Null]',
	    undefinedTag = '[object Undefined]';

	/** Built-in value references. */
	var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;

	/**
	 * The base implementation of `getTag` without fallbacks for buggy environments.
	 *
	 * @private
	 * @param {*} value The value to query.
	 * @returns {string} Returns the `toStringTag`.
	 */
	function baseGetTag(value) {
	  if (value == null) {
	    return value === undefined ? undefinedTag : nullTag;
	  }
	  return (symToStringTag && symToStringTag in Object(value))
	    ? _getRawTag(value)
	    : _objectToString(value);
	}

	var _baseGetTag = baseGetTag;

	/**
	 * Checks if `value` is object-like. A value is object-like if it's not `null`
	 * and has a `typeof` result of "object".
	 *
	 * @static
	 * @memberOf _
	 * @since 4.0.0
	 * @category Lang
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
	 * @example
	 *
	 * _.isObjectLike({});
	 * // => true
	 *
	 * _.isObjectLike([1, 2, 3]);
	 * // => true
	 *
	 * _.isObjectLike(_.noop);
	 * // => false
	 *
	 * _.isObjectLike(null);
	 * // => false
	 */
	function isObjectLike(value) {
	  return value != null && typeof value == 'object';
	}

	var isObjectLike_1 = isObjectLike;

	/** `Object#toString` result references. */
	var symbolTag = '[object Symbol]';

	/**
	 * Checks if `value` is classified as a `Symbol` primitive or object.
	 *
	 * @static
	 * @memberOf _
	 * @since 4.0.0
	 * @category Lang
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
	 * @example
	 *
	 * _.isSymbol(Symbol.iterator);
	 * // => true
	 *
	 * _.isSymbol('abc');
	 * // => false
	 */
	function isSymbol(value) {
	  return typeof value == 'symbol' ||
	    (isObjectLike_1(value) && _baseGetTag(value) == symbolTag);
	}

	var isSymbol_1 = isSymbol;

	/** Used as references for various `Number` constants. */
	var NAN = 0 / 0;

	/** Used to detect bad signed hexadecimal string values. */
	var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;

	/** Used to detect binary string values. */
	var reIsBinary = /^0b[01]+$/i;

	/** Used to detect octal string values. */
	var reIsOctal = /^0o[0-7]+$/i;

	/** Built-in method references without a dependency on `root`. */
	var freeParseInt = parseInt;

	/**
	 * Converts `value` to a number.
	 *
	 * @static
	 * @memberOf _
	 * @since 4.0.0
	 * @category Lang
	 * @param {*} value The value to process.
	 * @returns {number} Returns the number.
	 * @example
	 *
	 * _.toNumber(3.2);
	 * // => 3.2
	 *
	 * _.toNumber(Number.MIN_VALUE);
	 * // => 5e-324
	 *
	 * _.toNumber(Infinity);
	 * // => Infinity
	 *
	 * _.toNumber('3.2');
	 * // => 3.2
	 */
	function toNumber(value) {
	  if (typeof value == 'number') {
	    return value;
	  }
	  if (isSymbol_1(value)) {
	    return NAN;
	  }
	  if (isObject_1(value)) {
	    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
	    value = isObject_1(other) ? (other + '') : other;
	  }
	  if (typeof value != 'string') {
	    return value === 0 ? value : +value;
	  }
	  value = _baseTrim(value);
	  var isBinary = reIsBinary.test(value);
	  return (isBinary || reIsOctal.test(value))
	    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
	    : (reIsBadHex.test(value) ? NAN : +value);
	}

	var toNumber_1 = toNumber;

	/** Error message constants. */
	var FUNC_ERROR_TEXT$1 = 'Expected a function';

	/* Built-in method references for those with the same name as other `lodash` methods. */
	var nativeMax = Math.max,
	    nativeMin = Math.min;

	/**
	 * Creates a debounced function that delays invoking `func` until after `wait`
	 * milliseconds have elapsed since the last time the debounced function was
	 * invoked. The debounced function comes with a `cancel` method to cancel
	 * delayed `func` invocations and a `flush` method to immediately invoke them.
	 * Provide `options` to indicate whether `func` should be invoked on the
	 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
	 * with the last arguments provided to the debounced function. Subsequent
	 * calls to the debounced function return the result of the last `func`
	 * invocation.
	 *
	 * **Note:** If `leading` and `trailing` options are `true`, `func` is
	 * invoked on the trailing edge of the timeout only if the debounced function
	 * is invoked more than once during the `wait` timeout.
	 *
	 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
	 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
	 *
	 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
	 * for details over the differences between `_.debounce` and `_.throttle`.
	 *
	 * @static
	 * @memberOf _
	 * @since 0.1.0
	 * @category Function
	 * @param {Function} func The function to debounce.
	 * @param {number} [wait=0] The number of milliseconds to delay.
	 * @param {Object} [options={}] The options object.
	 * @param {boolean} [options.leading=false]
	 *  Specify invoking on the leading edge of the timeout.
	 * @param {number} [options.maxWait]
	 *  The maximum time `func` is allowed to be delayed before it's invoked.
	 * @param {boolean} [options.trailing=true]
	 *  Specify invoking on the trailing edge of the timeout.
	 * @returns {Function} Returns the new debounced function.
	 * @example
	 *
	 * // Avoid costly calculations while the window size is in flux.
	 * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
	 *
	 * // Invoke `sendMail` when clicked, debouncing subsequent calls.
	 * jQuery(element).on('click', _.debounce(sendMail, 300, {
	 *   'leading': true,
	 *   'trailing': false
	 * }));
	 *
	 * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
	 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
	 * var source = new EventSource('/stream');
	 * jQuery(source).on('message', debounced);
	 *
	 * // Cancel the trailing debounced invocation.
	 * jQuery(window).on('popstate', debounced.cancel);
	 */
	function debounce(func, wait, options) {
	  var lastArgs,
	      lastThis,
	      maxWait,
	      result,
	      timerId,
	      lastCallTime,
	      lastInvokeTime = 0,
	      leading = false,
	      maxing = false,
	      trailing = true;

	  if (typeof func != 'function') {
	    throw new TypeError(FUNC_ERROR_TEXT$1);
	  }
	  wait = toNumber_1(wait) || 0;
	  if (isObject_1(options)) {
	    leading = !!options.leading;
	    maxing = 'maxWait' in options;
	    maxWait = maxing ? nativeMax(toNumber_1(options.maxWait) || 0, wait) : maxWait;
	    trailing = 'trailing' in options ? !!options.trailing : trailing;
	  }

	  function invokeFunc(time) {
	    var args = lastArgs,
	        thisArg = lastThis;

	    lastArgs = lastThis = undefined;
	    lastInvokeTime = time;
	    result = func.apply(thisArg, args);
	    return result;
	  }

	  function leadingEdge(time) {
	    // Reset any `maxWait` timer.
	    lastInvokeTime = time;
	    // Start the timer for the trailing edge.
	    timerId = setTimeout(timerExpired, wait);
	    // Invoke the leading edge.
	    return leading ? invokeFunc(time) : result;
	  }

	  function remainingWait(time) {
	    var timeSinceLastCall = time - lastCallTime,
	        timeSinceLastInvoke = time - lastInvokeTime,
	        timeWaiting = wait - timeSinceLastCall;

	    return maxing
	      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
	      : timeWaiting;
	  }

	  function shouldInvoke(time) {
	    var timeSinceLastCall = time - lastCallTime,
	        timeSinceLastInvoke = time - lastInvokeTime;

	    // Either this is the first call, activity has stopped and we're at the
	    // trailing edge, the system time has gone backwards and we're treating
	    // it as the trailing edge, or we've hit the `maxWait` limit.
	    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
	      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
	  }

	  function timerExpired() {
	    var time = now_1();
	    if (shouldInvoke(time)) {
	      return trailingEdge(time);
	    }
	    // Restart the timer.
	    timerId = setTimeout(timerExpired, remainingWait(time));
	  }

	  function trailingEdge(time) {
	    timerId = undefined;

	    // Only invoke if we have `lastArgs` which means `func` has been
	    // debounced at least once.
	    if (trailing && lastArgs) {
	      return invokeFunc(time);
	    }
	    lastArgs = lastThis = undefined;
	    return result;
	  }

	  function cancel() {
	    if (timerId !== undefined) {
	      clearTimeout(timerId);
	    }
	    lastInvokeTime = 0;
	    lastArgs = lastCallTime = lastThis = timerId = undefined;
	  }

	  function flush() {
	    return timerId === undefined ? result : trailingEdge(now_1());
	  }

	  function debounced() {
	    var time = now_1(),
	        isInvoking = shouldInvoke(time);

	    lastArgs = arguments;
	    lastThis = this;
	    lastCallTime = time;

	    if (isInvoking) {
	      if (timerId === undefined) {
	        return leadingEdge(lastCallTime);
	      }
	      if (maxing) {
	        // Handle invocations in a tight loop.
	        clearTimeout(timerId);
	        timerId = setTimeout(timerExpired, wait);
	        return invokeFunc(lastCallTime);
	      }
	    }
	    if (timerId === undefined) {
	      timerId = setTimeout(timerExpired, wait);
	    }
	    return result;
	  }
	  debounced.cancel = cancel;
	  debounced.flush = flush;
	  return debounced;
	}

	var debounce_1 = debounce;

	/** Error message constants. */
	var FUNC_ERROR_TEXT = 'Expected a function';

	/**
	 * Creates a throttled function that only invokes `func` at most once per
	 * every `wait` milliseconds. The throttled function comes with a `cancel`
	 * method to cancel delayed `func` invocations and a `flush` method to
	 * immediately invoke them. Provide `options` to indicate whether `func`
	 * should be invoked on the leading and/or trailing edge of the `wait`
	 * timeout. The `func` is invoked with the last arguments provided to the
	 * throttled function. Subsequent calls to the throttled function return the
	 * result of the last `func` invocation.
	 *
	 * **Note:** If `leading` and `trailing` options are `true`, `func` is
	 * invoked on the trailing edge of the timeout only if the throttled function
	 * is invoked more than once during the `wait` timeout.
	 *
	 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
	 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
	 *
	 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
	 * for details over the differences between `_.throttle` and `_.debounce`.
	 *
	 * @static
	 * @memberOf _
	 * @since 0.1.0
	 * @category Function
	 * @param {Function} func The function to throttle.
	 * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
	 * @param {Object} [options={}] The options object.
	 * @param {boolean} [options.leading=true]
	 *  Specify invoking on the leading edge of the timeout.
	 * @param {boolean} [options.trailing=true]
	 *  Specify invoking on the trailing edge of the timeout.
	 * @returns {Function} Returns the new throttled function.
	 * @example
	 *
	 * // Avoid excessively updating the position while scrolling.
	 * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
	 *
	 * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
	 * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
	 * jQuery(element).on('click', throttled);
	 *
	 * // Cancel the trailing throttled invocation.
	 * jQuery(window).on('popstate', throttled.cancel);
	 */
	function throttle(func, wait, options) {
	  var leading = true,
	      trailing = true;

	  if (typeof func != 'function') {
	    throw new TypeError(FUNC_ERROR_TEXT);
	  }
	  if (isObject_1(options)) {
	    leading = 'leading' in options ? !!options.leading : leading;
	    trailing = 'trailing' in options ? !!options.trailing : trailing;
	  }
	  return debounce_1(func, wait, {
	    'leading': leading,
	    'maxWait': wait,
	    'trailing': trailing
	  });
	}

	var throttle_1 = throttle;

	const t=t=>"object"==typeof t&&null!=t&&1===t.nodeType,e$1=(t,e)=>(!e||"hidden"!==t)&&("visible"!==t&&"clip"!==t),n$1=(t,n)=>{if(t.clientHeight<t.scrollHeight||t.clientWidth<t.scrollWidth){const o=getComputedStyle(t,null);return e$1(o.overflowY,n)||e$1(o.overflowX,n)||(t=>{const e=(t=>{if(!t.ownerDocument||!t.ownerDocument.defaultView)return null;try{return t.ownerDocument.defaultView.frameElement}catch(t){return null}})(t);return !!e&&(e.clientHeight<t.scrollHeight||e.clientWidth<t.scrollWidth)})(t)}return !1},o$1=(t,e,n,o,l,r,i,s)=>r<t&&i>e||r>t&&i<e?0:r<=t&&s<=n||i>=e&&s>=n?r-t-o:i>e&&s<n||r<t&&s>n?i-e+l:0,l=t=>{const e=t.parentElement;return null==e?t.getRootNode().host||null:e},r=(e,r)=>{var i,s,d,h;if("undefined"==typeof document)return [];const{scrollMode:c,block:f,inline:u,boundary:a,skipOverflowHiddenElements:g}=r,p="function"==typeof a?a:t=>t!==a;if(!t(e))throw new TypeError("Invalid target");const m=document.scrollingElement||document.documentElement,w=[];let W=e;for(;t(W)&&p(W);){if(W=l(W),W===m){w.push(W);break}null!=W&&W===document.body&&n$1(W)&&!n$1(document.documentElement)||null!=W&&n$1(W,g)&&w.push(W);}const b=null!=(s=null==(i=window.visualViewport)?void 0:i.width)?s:innerWidth,H=null!=(h=null==(d=window.visualViewport)?void 0:d.height)?h:innerHeight,{scrollX:y,scrollY:M}=window,{height:v,width:E,top:x,right:C,bottom:I,left:R}=e.getBoundingClientRect(),{top:T,right:B,bottom:F,left:V}=(t=>{const e=window.getComputedStyle(t);return {top:parseFloat(e.scrollMarginTop)||0,right:parseFloat(e.scrollMarginRight)||0,bottom:parseFloat(e.scrollMarginBottom)||0,left:parseFloat(e.scrollMarginLeft)||0}})(e);let k="start"===f||"nearest"===f?x-T:"end"===f?I+F:x+v/2-T+F,D="center"===u?R+E/2-V+B:"end"===u?C+B:R-V;const L=[];for(let t=0;t<w.length;t++){const e=w[t],{height:n,width:l,top:r,right:i,bottom:s,left:d}=e.getBoundingClientRect();if("if-needed"===c&&x>=0&&R>=0&&I<=H&&C<=b&&x>=r&&I<=s&&R>=d&&C<=i)return L;const h=getComputedStyle(e),a=parseInt(h.borderLeftWidth,10),g=parseInt(h.borderTopWidth,10),p=parseInt(h.borderRightWidth,10),W=parseInt(h.borderBottomWidth,10);let T=0,B=0;const F="offsetWidth"in e?e.offsetWidth-e.clientWidth-a-p:0,V="offsetHeight"in e?e.offsetHeight-e.clientHeight-g-W:0,S="offsetWidth"in e?0===e.offsetWidth?0:l/e.offsetWidth:0,X="offsetHeight"in e?0===e.offsetHeight?0:n/e.offsetHeight:0;if(m===e)T="start"===f?k:"end"===f?k-H:"nearest"===f?o$1(M,M+H,H,g,W,M+k,M+k+v,v):k-H/2,B="start"===u?D:"center"===u?D-b/2:"end"===u?D-b:o$1(y,y+b,b,a,p,y+D,y+D+E,E),T=Math.max(0,T+M),B=Math.max(0,B+y);else {T="start"===f?k-r-g:"end"===f?k-s+W+V:"nearest"===f?o$1(r,s,n,g,W+V,k,k+v,v):k-(r+n/2)+V/2,B="start"===u?D-d-a:"center"===u?D-(d+l/2)+F/2:"end"===u?D-i+p+F:o$1(d,i,l,a,p+F,D,D+E,E);const{scrollLeft:t,scrollTop:h}=e;T=0===X?0:Math.max(0,Math.min(h+T/X,e.scrollHeight-n/X+V)),B=0===S?0:Math.max(0,Math.min(t+B/S,e.scrollWidth-l/S+F)),k+=h-T,D+=t-B;}L.push({el:e,top:T,left:B});}return L};

	const o=t=>!1===t?{block:"end",inline:"nearest"}:(t=>t===Object(t)&&0!==Object.keys(t).length)(t)?t:{block:"start",inline:"nearest"};function e(e,r$1){if(!e.isConnected||!(t=>{let o=t;for(;o&&o.parentNode;){if(o.parentNode===document)return !0;o=o.parentNode instanceof ShadowRoot?o.parentNode.host:o.parentNode;}return !1})(e))return;const n=(t=>{const o=window.getComputedStyle(t);return {top:parseFloat(o.scrollMarginTop)||0,right:parseFloat(o.scrollMarginRight)||0,bottom:parseFloat(o.scrollMarginBottom)||0,left:parseFloat(o.scrollMarginLeft)||0}})(e);if((t=>"object"==typeof t&&"function"==typeof t.behavior)(r$1))return r$1.behavior(r(e,r$1));const l="boolean"==typeof r$1||null==r$1?void 0:r$1.behavior;for(const{el:a,top:i,left:s}of r(e,o(r$1))){const t=i-n.top+n.bottom,o=s-n.left+n.right;a.scroll({top:t,left:o,behavior:l});}}

	/**
	 * A React context for sharing the editor object.
	 */
	var EditorContext = /*#__PURE__*/React.createContext(null);
	/**
	 * Get the current editor object from the React context.
	 */
	var useSlateStatic = function useSlateStatic() {
	  var editor = React.useContext(EditorContext);
	  if (!editor) {
	    throw new Error("The `useSlateStatic` hook must be used inside the <Slate> component's context.");
	  }
	  return editor;
	};

	var lib = createCommonjsModule(function (module, exports) {

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

	/**
	 * Constants.
	 */

	var IS_MAC = typeof window != 'undefined' && /Mac|iPod|iPhone|iPad/.test(window.navigator.platform);

	var MODIFIERS = {
	  alt: 'altKey',
	  control: 'ctrlKey',
	  meta: 'metaKey',
	  shift: 'shiftKey'
	};

	var ALIASES = {
	  add: '+',
	  break: 'pause',
	  cmd: 'meta',
	  command: 'meta',
	  ctl: 'control',
	  ctrl: 'control',
	  del: 'delete',
	  down: 'arrowdown',
	  esc: 'escape',
	  ins: 'insert',
	  left: 'arrowleft',
	  mod: IS_MAC ? 'meta' : 'control',
	  opt: 'alt',
	  option: 'alt',
	  return: 'enter',
	  right: 'arrowright',
	  space: ' ',
	  spacebar: ' ',
	  up: 'arrowup',
	  win: 'meta',
	  windows: 'meta'
	};

	var CODES = {
	  backspace: 8,
	  tab: 9,
	  enter: 13,
	  shift: 16,
	  control: 17,
	  alt: 18,
	  pause: 19,
	  capslock: 20,
	  escape: 27,
	  ' ': 32,
	  pageup: 33,
	  pagedown: 34,
	  end: 35,
	  home: 36,
	  arrowleft: 37,
	  arrowup: 38,
	  arrowright: 39,
	  arrowdown: 40,
	  insert: 45,
	  delete: 46,
	  meta: 91,
	  numlock: 144,
	  scrolllock: 145,
	  ';': 186,
	  '=': 187,
	  ',': 188,
	  '-': 189,
	  '.': 190,
	  '/': 191,
	  '`': 192,
	  '[': 219,
	  '\\': 220,
	  ']': 221,
	  '\'': 222
	};

	for (var f = 1; f < 20; f++) {
	  CODES['f' + f] = 111 + f;
	}

	/**
	 * Is hotkey?
	 */

	function isHotkey(hotkey, options, event) {
	  if (options && !('byKey' in options)) {
	    event = options;
	    options = null;
	  }

	  if (!Array.isArray(hotkey)) {
	    hotkey = [hotkey];
	  }

	  var array = hotkey.map(function (string) {
	    return parseHotkey(string, options);
	  });
	  var check = function check(e) {
	    return array.some(function (object) {
	      return compareHotkey(object, e);
	    });
	  };
	  var ret = event == null ? check : check(event);
	  return ret;
	}

	function isCodeHotkey(hotkey, event) {
	  return isHotkey(hotkey, event);
	}

	function isKeyHotkey(hotkey, event) {
	  return isHotkey(hotkey, { byKey: true }, event);
	}

	/**
	 * Parse.
	 */

	function parseHotkey(hotkey, options) {
	  var byKey = options && options.byKey;
	  var ret = {};

	  // Special case to handle the `+` key since we use it as a separator.
	  hotkey = hotkey.replace('++', '+add');
	  var values = hotkey.split('+');
	  var length = values.length;

	  // Ensure that all the modifiers are set to false unless the hotkey has them.

	  for (var k in MODIFIERS) {
	    ret[MODIFIERS[k]] = false;
	  }

	  var _iteratorNormalCompletion = true;
	  var _didIteratorError = false;
	  var _iteratorError = undefined;

	  try {
	    for (var _iterator = values[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
	      var value = _step.value;

	      var optional = value.endsWith('?') && value.length > 1;

	      if (optional) {
	        value = value.slice(0, -1);
	      }

	      var name = toKeyName(value);
	      var modifier = MODIFIERS[name];

	      if (value.length > 1 && !modifier && !ALIASES[value] && !CODES[name]) {
	        throw new TypeError('Unknown modifier: "' + value + '"');
	      }

	      if (length === 1 || !modifier) {
	        if (byKey) {
	          ret.key = name;
	        } else {
	          ret.which = toKeyCode(value);
	        }
	      }

	      if (modifier) {
	        ret[modifier] = optional ? null : true;
	      }
	    }
	  } catch (err) {
	    _didIteratorError = true;
	    _iteratorError = err;
	  } finally {
	    try {
	      if (!_iteratorNormalCompletion && _iterator.return) {
	        _iterator.return();
	      }
	    } finally {
	      if (_didIteratorError) {
	        throw _iteratorError;
	      }
	    }
	  }

	  return ret;
	}

	/**
	 * Compare.
	 */

	function compareHotkey(object, event) {
	  for (var key in object) {
	    var expected = object[key];
	    var actual = void 0;

	    if (expected == null) {
	      continue;
	    }

	    if (key === 'key' && event.key != null) {
	      actual = event.key.toLowerCase();
	    } else if (key === 'which') {
	      actual = expected === 91 && event.which === 93 ? 91 : event.which;
	    } else {
	      actual = event[key];
	    }

	    if (actual == null && expected === false) {
	      continue;
	    }

	    if (actual !== expected) {
	      return false;
	    }
	  }

	  return true;
	}

	/**
	 * Utils.
	 */

	function toKeyCode(name) {
	  name = toKeyName(name);
	  var code = CODES[name] || name.toUpperCase().charCodeAt(0);
	  return code;
	}

	function toKeyName(name) {
	  name = name.toLowerCase();
	  name = ALIASES[name] || name;
	  return name;
	}

	/**
	 * Export.
	 */

	exports.default = isHotkey;
	exports.isHotkey = isHotkey;
	exports.isCodeHotkey = isCodeHotkey;
	exports.isKeyHotkey = isKeyHotkey;
	exports.parseHotkey = parseHotkey;
	exports.compareHotkey = compareHotkey;
	exports.toKeyCode = toKeyCode;
	exports.toKeyName = toKeyName;
	});

	unwrapExports(lib);
	var lib_1 = lib.isHotkey;
	lib.isCodeHotkey;
	lib.isKeyHotkey;
	lib.parseHotkey;
	lib.compareHotkey;
	lib.toKeyCode;
	lib.toKeyName;

	/**
	 * Types.
	 */
	// COMPAT: This is required to prevent TypeScript aliases from doing some very
	// weird things for Slate's types with the same name as globals. (2019/11/27)
	// https://github.com/microsoft/TypeScript/issues/35002
	var DOMNode = globalThis.Node;
	var DOMText = globalThis.Text;
	/**
	 * Returns the host window of a DOM node
	 */
	var getDefaultView = value => {
	  return value && value.ownerDocument && value.ownerDocument.defaultView || null;
	};
	/**
	 * Check if a DOM node is a comment node.
	 */
	var isDOMComment = value => {
	  return isDOMNode(value) && value.nodeType === 8;
	};
	/**
	 * Check if a DOM node is an element node.
	 */
	var isDOMElement = value => {
	  return isDOMNode(value) && value.nodeType === 1;
	};
	/**
	 * Check if a value is a DOM node.
	 */
	var isDOMNode = value => {
	  var window = getDefaultView(value);
	  return !!window && value instanceof window.Node;
	};
	/**
	 * Check if a value is a DOM selection.
	 */
	var isDOMSelection = value => {
	  var window = value && value.anchorNode && getDefaultView(value.anchorNode);
	  return !!window && value instanceof window.Selection;
	};
	/**
	 * Check if a DOM node is an element node.
	 */
	var isDOMText = value => {
	  return isDOMNode(value) && value.nodeType === 3;
	};
	/**
	 * Checks whether a paste event is a plaintext-only event.
	 */
	var isPlainTextOnlyPaste = event => {
	  return event.clipboardData && event.clipboardData.getData('text/plain') !== '' && event.clipboardData.types.length === 1;
	};
	/**
	 * Normalize a DOM point so that it always refers to a text node.
	 */
	var normalizeDOMPoint = domPoint => {
	  var [node, offset] = domPoint;
	  // If it's an element node, its offset refers to the index of its children
	  // including comment nodes, so try to find the right text child node.
	  if (isDOMElement(node) && node.childNodes.length) {
	    var isLast = offset === node.childNodes.length;
	    var index = isLast ? offset - 1 : offset;
	    [node, index] = getEditableChildAndIndex(node, index, isLast ? 'backward' : 'forward');
	    // If the editable child found is in front of input offset, we instead seek to its end
	    isLast = index < offset;
	    // If the node has children, traverse until we have a leaf node. Leaf nodes
	    // can be either text nodes, or other void DOM nodes.
	    while (isDOMElement(node) && node.childNodes.length) {
	      var i = isLast ? node.childNodes.length - 1 : 0;
	      node = getEditableChild(node, i, isLast ? 'backward' : 'forward');
	    }
	    // Determine the new offset inside the text node.
	    offset = isLast && node.textContent != null ? node.textContent.length : 0;
	  }
	  // Return the node and offset.
	  return [node, offset];
	};
	/**
	 * Determines whether the active element is nested within a shadowRoot
	 */
	var hasShadowRoot = node => {
	  var parent = node && node.parentNode;
	  while (parent) {
	    if (parent.toString() === '[object ShadowRoot]') {
	      return true;
	    }
	    parent = parent.parentNode;
	  }
	  return false;
	};
	/**
	 * Get the nearest editable child and index at `index` in a `parent`, preferring
	 * `direction`.
	 */
	var getEditableChildAndIndex = (parent, index, direction) => {
	  var {
	    childNodes
	  } = parent;
	  var child = childNodes[index];
	  var i = index;
	  var triedForward = false;
	  var triedBackward = false;
	  // While the child is a comment node, or an element node with no children,
	  // keep iterating to find a sibling non-void, non-comment node.
	  while (isDOMComment(child) || isDOMElement(child) && child.childNodes.length === 0 || isDOMElement(child) && child.getAttribute('contenteditable') === 'false') {
	    if (triedForward && triedBackward) {
	      break;
	    }
	    if (i >= childNodes.length) {
	      triedForward = true;
	      i = index - 1;
	      direction = 'backward';
	      continue;
	    }
	    if (i < 0) {
	      triedBackward = true;
	      i = index + 1;
	      direction = 'forward';
	      continue;
	    }
	    child = childNodes[i];
	    index = i;
	    i += direction === 'forward' ? 1 : -1;
	  }
	  return [child, index];
	};
	/**
	 * Get the nearest editable child at `index` in a `parent`, preferring
	 * `direction`.
	 */
	var getEditableChild = (parent, index, direction) => {
	  var [child] = getEditableChildAndIndex(parent, index, direction);
	  return child;
	};
	/**
	 * Get a plaintext representation of the content of a node, accounting for block
	 * elements which get a newline appended.
	 *
	 * The domNode must be attached to the DOM.
	 */
	var getPlainText = domNode => {
	  var text = '';
	  if (isDOMText(domNode) && domNode.nodeValue) {
	    return domNode.nodeValue;
	  }
	  if (isDOMElement(domNode)) {
	    for (var childNode of Array.from(domNode.childNodes)) {
	      text += getPlainText(childNode);
	    }
	    var display = getComputedStyle(domNode).getPropertyValue('display');
	    if (display === 'block' || display === 'list' || domNode.tagName === 'BR') {
	      text += '\n';
	    }
	  }
	  return text;
	};
	/**
	 * Get x-slate-fragment attribute from data-slate-fragment
	 */
	var catchSlateFragment = /data-slate-fragment="(.+?)"/m;
	var getSlateFragmentAttribute = dataTransfer => {
	  var htmlData = dataTransfer.getData('text/html');
	  var [, fragment] = htmlData.match(catchSlateFragment) || [];
	  return fragment;
	};
	/**
	 * Get the dom selection from Shadow Root if possible, otherwise from the document
	 */
	var getSelection = root => {
	  if (root.getSelection != null) {
	    return root.getSelection();
	  }
	  return document.getSelection();
	};
	/**
	 * Check whether a mutation originates from a editable element inside the editor.
	 */
	var isTrackedMutation = (editor, mutation, batch) => {
	  var {
	    target
	  } = mutation;
	  if (isDOMElement(target) && target.matches('[contentEditable="false"]')) {
	    return false;
	  }
	  var {
	    document
	  } = DOMEditor.getWindow(editor);
	  if (document.contains(target)) {
	    return DOMEditor.hasDOMNode(editor, target, {
	      editable: true
	    });
	  }
	  var parentMutation = batch.find(_ref => {
	    var {
	      addedNodes,
	      removedNodes
	    } = _ref;
	    for (var node of addedNodes) {
	      if (node === target || node.contains(target)) {
	        return true;
	      }
	    }
	    for (var _node of removedNodes) {
	      if (_node === target || _node.contains(target)) {
	        return true;
	      }
	    }
	  });
	  if (!parentMutation || parentMutation === mutation) {
	    return false;
	  }
	  // Target add/remove is tracked. Track the mutation if we track the parent mutation.
	  return isTrackedMutation(editor, parentMutation, batch);
	};
	/**
	 * Retrieves the deepest active element in the DOM, considering nested shadow DOMs.
	 */
	var getActiveElement = () => {
	  var activeElement = document.activeElement;
	  while ((_activeElement = activeElement) !== null && _activeElement !== void 0 && _activeElement.shadowRoot && (_activeElement$shadow = activeElement.shadowRoot) !== null && _activeElement$shadow !== void 0 && _activeElement$shadow.activeElement) {
	    var _activeElement, _activeElement$shadow, _activeElement2;
	    activeElement = (_activeElement2 = activeElement) === null || _activeElement2 === void 0 || (_activeElement2 = _activeElement2.shadowRoot) === null || _activeElement2 === void 0 ? void 0 : _activeElement2.activeElement;
	  }
	  return activeElement;
	};
	/**
	 * @returns `true` if `otherNode` is before `node` in the document; otherwise, `false`.
	 */
	var isBefore = (node, otherNode) => Boolean(node.compareDocumentPosition(otherNode) & DOMNode.DOCUMENT_POSITION_PRECEDING);
	/**
	 * @returns `true` if `otherNode` is after `node` in the document; otherwise, `false`.
	 */
	var isAfter = (node, otherNode) => Boolean(node.compareDocumentPosition(otherNode) & DOMNode.DOCUMENT_POSITION_FOLLOWING);

	var _navigator$userAgent$, _navigator$userAgent$2;
	var IS_IOS = typeof navigator !== 'undefined' && typeof window !== 'undefined' && /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
	var IS_APPLE = typeof navigator !== 'undefined' && /Mac OS X/.test(navigator.userAgent);
	var IS_ANDROID = typeof navigator !== 'undefined' && /Android/.test(navigator.userAgent);
	var IS_FIREFOX = typeof navigator !== 'undefined' && /^(?!.*Seamonkey)(?=.*Firefox).*/i.test(navigator.userAgent);
	var IS_WEBKIT = typeof navigator !== 'undefined' && /AppleWebKit(?!.*Chrome)/i.test(navigator.userAgent);
	// "modern" Edge was released at 79.x
	var IS_EDGE_LEGACY = typeof navigator !== 'undefined' && /Edge?\/(?:[0-6][0-9]|[0-7][0-8])(?:\.)/i.test(navigator.userAgent);
	var IS_CHROME = typeof navigator !== 'undefined' && /Chrome/i.test(navigator.userAgent);
	// Native `beforeInput` events don't work well with react on Chrome 75
	// and older, Chrome 76+ can use `beforeInput` though.
	var IS_CHROME_LEGACY = typeof navigator !== 'undefined' && /Chrome?\/(?:[0-7][0-5]|[0-6][0-9])(?:\.)/i.test(navigator.userAgent);
	var IS_ANDROID_CHROME_LEGACY = IS_ANDROID && typeof navigator !== 'undefined' && /Chrome?\/(?:[0-5]?\d)(?:\.)/i.test(navigator.userAgent);
	// Firefox did not support `beforeInput` until `v87`.
	var IS_FIREFOX_LEGACY = typeof navigator !== 'undefined' && /^(?!.*Seamonkey)(?=.*Firefox\/(?:[0-7][0-9]|[0-8][0-6])(?:\.)).*/i.test(navigator.userAgent);
	// UC mobile browser
	var IS_UC_MOBILE = typeof navigator !== 'undefined' && /.*UCBrowser/.test(navigator.userAgent);
	// Wechat browser (not including mac wechat)
	var IS_WECHATBROWSER = typeof navigator !== 'undefined' && /.*Wechat/.test(navigator.userAgent) && !/.*MacWechat/.test(navigator.userAgent); // avoid lookbehind (buggy in safari < 16.4)
	// Check if DOM is available as React does internally.
	// https://github.com/facebook/react/blob/master/packages/shared/ExecutionEnvironment.js
	var CAN_USE_DOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
	// Check if the browser is Safari and older than 17
	typeof navigator !== 'undefined' && /Safari/.test(navigator.userAgent) && /Version\/(\d+)/.test(navigator.userAgent) && ((_navigator$userAgent$ = navigator.userAgent.match(/Version\/(\d+)/)) !== null && _navigator$userAgent$ !== void 0 && _navigator$userAgent$[1] ? parseInt((_navigator$userAgent$2 = navigator.userAgent.match(/Version\/(\d+)/)) === null || _navigator$userAgent$2 === void 0 ? void 0 : _navigator$userAgent$2[1], 10) < 17 : false);
	// COMPAT: Firefox/Edge Legacy don't support the `beforeinput` event
	// Chrome Legacy doesn't support `beforeinput` correctly
	var HAS_BEFORE_INPUT_SUPPORT = (!IS_CHROME_LEGACY || !IS_ANDROID_CHROME_LEGACY) && !IS_EDGE_LEGACY &&
	// globalThis is undefined in older browsers
	typeof globalThis !== 'undefined' && globalThis.InputEvent &&
	// @ts-ignore The `getTargetRanges` property isn't recognized.
	typeof globalThis.InputEvent.prototype.getTargetRanges === 'function';

	function _typeof(o) {
	  "@babel/helpers - typeof";

	  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
	    return typeof o;
	  } : function (o) {
	    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	  }, _typeof(o);
	}

	function _toPrimitive(input, hint) {
	  if (_typeof(input) !== "object" || input === null) return input;
	  var prim = input[Symbol.toPrimitive];
	  if (prim !== undefined) {
	    var res = prim.call(input, hint || "default");
	    if (_typeof(res) !== "object") return res;
	    throw new TypeError("@@toPrimitive must return a primitive value.");
	  }
	  return (hint === "string" ? String : Number)(input);
	}

	function _toPropertyKey(arg) {
	  var key = _toPrimitive(arg, "string");
	  return _typeof(key) === "symbol" ? key : String(key);
	}

	function _defineProperty(obj, key, value) {
	  key = _toPropertyKey(key);
	  if (key in obj) {
	    Object.defineProperty(obj, key, {
	      value: value,
	      enumerable: true,
	      configurable: true,
	      writable: true
	    });
	  } else {
	    obj[key] = value;
	  }
	  return obj;
	}

	/**
	 * An auto-incrementing identifier for keys.
	 */
	var n = 0;
	/**
	 * A class that keeps track of a key string. We use a full class here because we
	 * want to be able to use them as keys in `WeakMap` objects.
	 */
	class Key {
	  constructor() {
	    _defineProperty(this, "id", void 0);
	    this.id = "".concat(n++);
	  }
	}

	/**
	 * Two weak maps that allow us rebuild a path given a node. They are populated
	 * at render time such that after a render occurs we can always backtrack.
	 */
	var IS_NODE_MAP_DIRTY = new WeakMap();
	var NODE_TO_INDEX = new WeakMap();
	var NODE_TO_PARENT = new WeakMap();
	/**
	 * Weak maps that allow us to go between Slate nodes and DOM nodes. These
	 * are used to resolve DOM event-related logic into Slate actions.
	 */
	var EDITOR_TO_WINDOW = new WeakMap();
	var EDITOR_TO_ELEMENT = new WeakMap();
	var EDITOR_TO_PLACEHOLDER_ELEMENT = new WeakMap();
	var ELEMENT_TO_NODE = new WeakMap();
	var NODE_TO_ELEMENT = new WeakMap();
	var NODE_TO_KEY = new WeakMap();
	var EDITOR_TO_KEY_TO_ELEMENT = new WeakMap();
	/**
	 * Weak maps for storing editor-related state.
	 */
	var IS_READ_ONLY = new WeakMap();
	var IS_FOCUSED = new WeakMap();
	var IS_COMPOSING = new WeakMap();
	var EDITOR_TO_USER_SELECTION = new WeakMap();
	/**
	 * Weak map for associating the context `onChange` context with the plugin.
	 */
	var EDITOR_TO_ON_CHANGE = new WeakMap();
	/**
	 * Weak maps for saving pending state on composition stage.
	 */
	var EDITOR_TO_SCHEDULE_FLUSH = new WeakMap();
	var EDITOR_TO_PENDING_INSERTION_MARKS = new WeakMap();
	var EDITOR_TO_USER_MARKS = new WeakMap();
	/**
	 * Android input handling specific weak-maps
	 */
	var EDITOR_TO_PENDING_DIFFS = new WeakMap();
	var EDITOR_TO_PENDING_ACTION = new WeakMap();
	var EDITOR_TO_PENDING_SELECTION = new WeakMap();
	var EDITOR_TO_FORCE_RENDER = new WeakMap();
	/**
	 * Symbols.
	 */
	var PLACEHOLDER_SYMBOL = Symbol('placeholder');
	var MARK_PLACEHOLDER_SYMBOL = Symbol('mark-placeholder');

	// eslint-disable-next-line no-redeclare
	var DOMEditor = {
	  androidPendingDiffs: editor => EDITOR_TO_PENDING_DIFFS.get(editor),
	  androidScheduleFlush: editor => {
	    var _EDITOR_TO_SCHEDULE_F;
	    (_EDITOR_TO_SCHEDULE_F = EDITOR_TO_SCHEDULE_FLUSH.get(editor)) === null || _EDITOR_TO_SCHEDULE_F === void 0 || _EDITOR_TO_SCHEDULE_F();
	  },
	  blur: editor => {
	    var el = DOMEditor.toDOMNode(editor, editor);
	    var root = DOMEditor.findDocumentOrShadowRoot(editor);
	    IS_FOCUSED.set(editor, false);
	    if (root.activeElement === el) {
	      el.blur();
	    }
	  },
	  deselect: editor => {
	    var {
	      selection
	    } = editor;
	    var root = DOMEditor.findDocumentOrShadowRoot(editor);
	    var domSelection = getSelection(root);
	    if (domSelection && domSelection.rangeCount > 0) {
	      domSelection.removeAllRanges();
	    }
	    if (selection) {
	      slate.Transforms.deselect(editor);
	    }
	  },
	  findDocumentOrShadowRoot: editor => {
	    var el = DOMEditor.toDOMNode(editor, editor);
	    var root = el.getRootNode();
	    if (root instanceof Document || root instanceof ShadowRoot) {
	      return root;
	    }
	    return el.ownerDocument;
	  },
	  findEventRange: (editor, event) => {
	    if ('nativeEvent' in event) {
	      event = event.nativeEvent;
	    }
	    var {
	      clientX: x,
	      clientY: y,
	      target
	    } = event;
	    if (x == null || y == null) {