slate-devtools
Version:
`slate-devtools` as name suggests it is devtool for [slatejs](https://github.com/ianstormtaylor/slate) which will assist you in debugging the code
1,633 lines (1,607 loc) • 420 kB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
var __commonJS = (callback, module) => () => {
if (!module) {
module = {exports: {}};
callback(module.exports, module);
}
return module.exports;
};
var __exportStar = (target, module, desc) => {
if (module && typeof module === "object" || typeof module === "function") {
for (let key of __getOwnPropNames(module))
if (!__hasOwnProp.call(target, key) && key !== "default")
__defProp(target, key, {get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable});
}
return target;
};
var __toModule = (module) => {
return __exportStar(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? {get: () => module.default, enumerable: true} : {value: module, enumerable: true})), module);
};
// slate-devtools/node_modules/esrever/esrever.js
var require_esrever = __commonJS((exports, module) => {
/*! https://mths.be/esrever v0.2.0 by @mathias */
(function(root) {
var freeExports = typeof exports == "object" && exports;
var freeModule = typeof module == "object" && module && module.exports == freeExports && module;
var freeGlobal = typeof global == "object" && global;
if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
root = freeGlobal;
}
var regexSymbolWithCombiningMarks = /([\0-\u02FF\u0370-\u1AAF\u1B00-\u1DBF\u1E00-\u20CF\u2100-\uD7FF\uE000-\uFE1F\uFE30-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])([\u0300-\u036F\u1AB0-\u1AFF\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]+)/g;
var regexSurrogatePair = /([\uD800-\uDBFF])([\uDC00-\uDFFF])/g;
var reverse2 = function(string) {
string = string.replace(regexSymbolWithCombiningMarks, function($0, $1, $2) {
return reverse2($2) + $1;
}).replace(regexSurrogatePair, "$2$1");
var result = "";
var index = string.length;
while (index--) {
result += string.charAt(index);
}
return result;
};
var esrever = {
version: "0.2.0",
reverse: reverse2
};
if (typeof define == "function" && typeof define.amd == "object" && define.amd) {
define(function() {
return esrever;
});
} else if (freeExports && !freeExports.nodeType) {
if (freeModule) {
freeModule.exports = esrever;
} else {
for (var key in esrever) {
esrever.hasOwnProperty(key) && (freeExports[key] = esrever[key]);
}
}
} else {
root.esrever = esrever;
}
})(exports);
});
// slate-devtools/node_modules/lodash/isObject.js
var require_isObject = __commonJS((exports, module) => {
function isObject2(value) {
var type = typeof value;
return value != null && (type == "object" || type == "function");
}
module.exports = isObject2;
});
// slate-devtools/node_modules/lodash/_freeGlobal.js
var require_freeGlobal = __commonJS((exports, module) => {
var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
module.exports = freeGlobal;
});
// slate-devtools/node_modules/lodash/_root.js
var require_root = __commonJS((exports, module) => {
var freeGlobal = require_freeGlobal();
var freeSelf = typeof self == "object" && self && self.Object === Object && self;
var root = freeGlobal || freeSelf || Function("return this")();
module.exports = root;
});
// slate-devtools/node_modules/lodash/now.js
var require_now = __commonJS((exports, module) => {
var root = require_root();
var now = function() {
return root.Date.now();
};
module.exports = now;
});
// slate-devtools/node_modules/lodash/_trimmedEndIndex.js
var require_trimmedEndIndex = __commonJS((exports, module) => {
var reWhitespace = /\s/;
function trimmedEndIndex(string) {
var index = string.length;
while (index-- && reWhitespace.test(string.charAt(index))) {
}
return index;
}
module.exports = trimmedEndIndex;
});
// slate-devtools/node_modules/lodash/_baseTrim.js
var require_baseTrim = __commonJS((exports, module) => {
var trimmedEndIndex = require_trimmedEndIndex();
var reTrimStart = /^\s+/;
function baseTrim(string) {
return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
}
module.exports = baseTrim;
});
// slate-devtools/node_modules/lodash/_Symbol.js
var require_Symbol = __commonJS((exports, module) => {
var root = require_root();
var Symbol2 = root.Symbol;
module.exports = Symbol2;
});
// slate-devtools/node_modules/lodash/_getRawTag.js
var require_getRawTag = __commonJS((exports, module) => {
var Symbol2 = require_Symbol();
var objectProto = Object.prototype;
var hasOwnProperty = objectProto.hasOwnProperty;
var nativeObjectToString = objectProto.toString;
var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
function getRawTag(value) {
var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
try {
value[symToStringTag] = void 0;
var unmasked = true;
} catch (e3) {
}
var result = nativeObjectToString.call(value);
if (unmasked) {
if (isOwn) {
value[symToStringTag] = tag;
} else {
delete value[symToStringTag];
}
}
return result;
}
module.exports = getRawTag;
});
// slate-devtools/node_modules/lodash/_objectToString.js
var require_objectToString = __commonJS((exports, module) => {
var objectProto = Object.prototype;
var nativeObjectToString = objectProto.toString;
function objectToString(value) {
return nativeObjectToString.call(value);
}
module.exports = objectToString;
});
// slate-devtools/node_modules/lodash/_baseGetTag.js
var require_baseGetTag = __commonJS((exports, module) => {
var Symbol2 = require_Symbol();
var getRawTag = require_getRawTag();
var objectToString = require_objectToString();
var nullTag = "[object Null]";
var undefinedTag = "[object Undefined]";
var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
function baseGetTag(value) {
if (value == null) {
return value === void 0 ? undefinedTag : nullTag;
}
return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
}
module.exports = baseGetTag;
});
// slate-devtools/node_modules/lodash/isObjectLike.js
var require_isObjectLike = __commonJS((exports, module) => {
function isObjectLike(value) {
return value != null && typeof value == "object";
}
module.exports = isObjectLike;
});
// slate-devtools/node_modules/lodash/isSymbol.js
var require_isSymbol = __commonJS((exports, module) => {
var baseGetTag = require_baseGetTag();
var isObjectLike = require_isObjectLike();
var symbolTag = "[object Symbol]";
function isSymbol(value) {
return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
}
module.exports = isSymbol;
});
// slate-devtools/node_modules/lodash/toNumber.js
var require_toNumber = __commonJS((exports, module) => {
var baseTrim = require_baseTrim();
var isObject2 = require_isObject();
var isSymbol = require_isSymbol();
var NAN = 0 / 0;
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
var reIsBinary = /^0b[01]+$/i;
var reIsOctal = /^0o[0-7]+$/i;
var freeParseInt = parseInt;
function toNumber(value) {
if (typeof value == "number") {
return value;
}
if (isSymbol(value)) {
return NAN;
}
if (isObject2(value)) {
var other = typeof value.valueOf == "function" ? value.valueOf() : value;
value = isObject2(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;
}
module.exports = toNumber;
});
// slate-devtools/node_modules/lodash/debounce.js
var require_debounce = __commonJS((exports, module) => {
var isObject2 = require_isObject();
var now = require_now();
var toNumber = require_toNumber();
var FUNC_ERROR_TEXT = "Expected a function";
var nativeMax = Math.max;
var nativeMin = Math.min;
function debounce2(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);
}
wait = toNumber(wait) || 0;
if (isObject2(options)) {
leading = !!options.leading;
maxing = "maxWait" in options;
maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
trailing = "trailing" in options ? !!options.trailing : trailing;
}
function invokeFunc(time) {
var args = lastArgs, thisArg = lastThis;
lastArgs = lastThis = void 0;
lastInvokeTime = time;
result = func.apply(thisArg, args);
return result;
}
function leadingEdge(time) {
lastInvokeTime = time;
timerId = setTimeout(timerExpired, wait);
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;
return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
}
function timerExpired() {
var time = now();
if (shouldInvoke(time)) {
return trailingEdge(time);
}
timerId = setTimeout(timerExpired, remainingWait(time));
}
function trailingEdge(time) {
timerId = void 0;
if (trailing && lastArgs) {
return invokeFunc(time);
}
lastArgs = lastThis = void 0;
return result;
}
function cancel() {
if (timerId !== void 0) {
clearTimeout(timerId);
}
lastInvokeTime = 0;
lastArgs = lastCallTime = lastThis = timerId = void 0;
}
function flush() {
return timerId === void 0 ? result : trailingEdge(now());
}
function debounced() {
var time = now(), isInvoking = shouldInvoke(time);
lastArgs = arguments;
lastThis = this;
lastCallTime = time;
if (isInvoking) {
if (timerId === void 0) {
return leadingEdge(lastCallTime);
}
if (maxing) {
clearTimeout(timerId);
timerId = setTimeout(timerExpired, wait);
return invokeFunc(lastCallTime);
}
}
if (timerId === void 0) {
timerId = setTimeout(timerExpired, wait);
}
return result;
}
debounced.cancel = cancel;
debounced.flush = flush;
return debounced;
}
module.exports = debounce2;
});
// slate-devtools/node_modules/lodash/throttle.js
var require_throttle = __commonJS((exports, module) => {
var debounce2 = require_debounce();
var isObject2 = require_isObject();
var FUNC_ERROR_TEXT = "Expected a function";
function throttle2(func, wait, options) {
var leading = true, trailing = true;
if (typeof func != "function") {
throw new TypeError(FUNC_ERROR_TEXT);
}
if (isObject2(options)) {
leading = "leading" in options ? !!options.leading : leading;
trailing = "trailing" in options ? !!options.trailing : trailing;
}
return debounce2(func, wait, {
leading,
maxWait: wait,
trailing
});
}
module.exports = throttle2;
});
// slate-devtools/node_modules/direction/index.js
var require_direction = __commonJS((exports, module) => {
"use strict";
module.exports = direction;
var RTL = "\u0591-\u07FF\uFB1D-\uFDFD\uFE70-\uFEFC";
var LTR = "A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\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";
}
});
// slate-devtools/node_modules/is-hotkey/lib/index.js
var require_lib = __commonJS((exports) => {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
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 f2 = 1; f2 < 20; f2++) {
CODES["f" + f2] = 111 + f2;
}
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 check2(e3) {
return array.some(function(object) {
return compareHotkey(object, e3);
});
};
var ret = event == null ? check : check(event);
return ret;
}
function isCodeHotkey(hotkey, event) {
return isHotkey(hotkey, event);
}
function isKeyHotkey2(hotkey, event) {
return isHotkey(hotkey, {byKey: true}, event);
}
function parseHotkey(hotkey, options) {
var byKey = options && options.byKey;
var ret = {};
hotkey = hotkey.replace("++", "+add");
var values = hotkey.split("+");
var length = values.length;
for (var k2 in MODIFIERS) {
ret[MODIFIERS[k2]] = false;
}
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = void 0;
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 (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;
}
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;
}
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;
}
exports.default = isHotkey;
exports.isHotkey = isHotkey;
exports.isCodeHotkey = isCodeHotkey;
exports.isKeyHotkey = isKeyHotkey2;
exports.parseHotkey = parseHotkey;
exports.compareHotkey = compareHotkey;
exports.toKeyCode = toKeyCode;
exports.toKeyName = toKeyName;
});
// slate-devtools/node_modules/react-fast-compare/index.js
var require_react_fast_compare = __commonJS((exports, module) => {
var hasElementType = typeof Element !== "undefined";
var hasMap2 = typeof Map === "function";
var hasSet2 = typeof Set === "function";
var hasArrayBuffer = typeof ArrayBuffer === "function" && !!ArrayBuffer.isView;
function equal(a2, b2) {
if (a2 === b2)
return true;
if (a2 && b2 && typeof a2 == "object" && typeof b2 == "object") {
if (a2.constructor !== b2.constructor)
return false;
var length, i2, keys;
if (Array.isArray(a2)) {
length = a2.length;
if (length != b2.length)
return false;
for (i2 = length; i2-- !== 0; )
if (!equal(a2[i2], b2[i2]))
return false;
return true;
}
var it;
if (hasMap2 && a2 instanceof Map && b2 instanceof Map) {
if (a2.size !== b2.size)
return false;
it = a2.entries();
while (!(i2 = it.next()).done)
if (!b2.has(i2.value[0]))
return false;
it = a2.entries();
while (!(i2 = it.next()).done)
if (!equal(i2.value[1], b2.get(i2.value[0])))
return false;
return true;
}
if (hasSet2 && a2 instanceof Set && b2 instanceof Set) {
if (a2.size !== b2.size)
return false;
it = a2.entries();
while (!(i2 = it.next()).done)
if (!b2.has(i2.value[0]))
return false;
return true;
}
if (hasArrayBuffer && ArrayBuffer.isView(a2) && ArrayBuffer.isView(b2)) {
length = a2.length;
if (length != b2.length)
return false;
for (i2 = length; i2-- !== 0; )
if (a2[i2] !== b2[i2])
return false;
return true;
}
if (a2.constructor === RegExp)
return a2.source === b2.source && a2.flags === b2.flags;
if (a2.valueOf !== Object.prototype.valueOf)
return a2.valueOf() === b2.valueOf();
if (a2.toString !== Object.prototype.toString)
return a2.toString() === b2.toString();
keys = Object.keys(a2);
length = keys.length;
if (length !== Object.keys(b2).length)
return false;
for (i2 = length; i2-- !== 0; )
if (!Object.prototype.hasOwnProperty.call(b2, keys[i2]))
return false;
if (hasElementType && a2 instanceof Element)
return false;
for (i2 = length; i2-- !== 0; ) {
if ((keys[i2] === "_owner" || keys[i2] === "__v" || keys[i2] === "__o") && a2.$$typeof) {
continue;
}
if (!equal(a2[keys[i2]], b2[keys[i2]]))
return false;
}
return true;
}
return a2 !== a2 && b2 !== b2;
}
module.exports = function isEqual2(a2, b2) {
try {
return equal(a2, b2);
} catch (error) {
if ((error.message || "").match(/stack|recursion/i)) {
console.warn("react-fast-compare cannot handle circular refs");
return false;
}
throw error;
}
};
});
// slate-devtools/node_modules/fast-memoize/src/index.js
var require_src = __commonJS((exports, module) => {
function memoize2(fn2, options) {
var cache = options && options.cache ? options.cache : cacheDefault;
var serializer = options && options.serializer ? options.serializer : serializerDefault;
var strategy = options && options.strategy ? options.strategy : strategyDefault;
return strategy(fn2, {
cache,
serializer
});
}
function isPrimitive(value) {
return value == null || typeof value === "number" || typeof value === "boolean";
}
function monadic(fn2, cache, serializer, arg) {
var cacheKey = isPrimitive(arg) ? arg : serializer(arg);
var computedValue = cache.get(cacheKey);
if (typeof computedValue === "undefined") {
computedValue = fn2.call(this, arg);
cache.set(cacheKey, computedValue);
}
return computedValue;
}
function variadic(fn2, cache, serializer) {
var args = Array.prototype.slice.call(arguments, 3);
var cacheKey = serializer(args);
var computedValue = cache.get(cacheKey);
if (typeof computedValue === "undefined") {
computedValue = fn2.apply(this, args);
cache.set(cacheKey, computedValue);
}
return computedValue;
}
function assemble(fn2, context, strategy, cache, serialize) {
return strategy.bind(context, fn2, cache, serialize);
}
function strategyDefault(fn2, options) {
var strategy = fn2.length === 1 ? monadic : variadic;
return assemble(fn2, this, strategy, options.cache.create(), options.serializer);
}
function strategyVariadic(fn2, options) {
var strategy = variadic;
return assemble(fn2, this, strategy, options.cache.create(), options.serializer);
}
function strategyMonadic(fn2, options) {
var strategy = monadic;
return assemble(fn2, this, strategy, options.cache.create(), options.serializer);
}
function serializerDefault() {
return JSON.stringify(arguments);
}
function ObjectWithoutPrototypeCache() {
this.cache = Object.create(null);
}
ObjectWithoutPrototypeCache.prototype.has = function(key) {
return key in this.cache;
};
ObjectWithoutPrototypeCache.prototype.get = function(key) {
return this.cache[key];
};
ObjectWithoutPrototypeCache.prototype.set = function(key, value) {
this.cache[key] = value;
};
var cacheDefault = {
create: function create2() {
return new ObjectWithoutPrototypeCache();
}
};
module.exports = memoize2;
module.exports.strategies = {
variadic: strategyVariadic,
monadic: strategyMonadic
};
});
// slate-devtools/node_modules/clone/clone.js
var require_clone = __commonJS((exports, module) => {
var clone2 = function() {
"use strict";
function _instanceof(obj, type) {
return type != null && obj instanceof type;
}
var nativeMap;
try {
nativeMap = Map;
} catch (_) {
nativeMap = function() {
};
}
var nativeSet;
try {
nativeSet = Set;
} catch (_) {
nativeSet = function() {
};
}
var nativePromise;
try {
nativePromise = Promise;
} catch (_) {
nativePromise = function() {
};
}
function clone3(parent, circular, depth, prototype, includeNonEnumerable) {
if (typeof circular === "object") {
depth = circular.depth;
prototype = circular.prototype;
includeNonEnumerable = circular.includeNonEnumerable;
circular = circular.circular;
}
var allParents = [];
var allChildren = [];
var useBuffer = typeof Buffer != "undefined";
if (typeof circular == "undefined")
circular = true;
if (typeof depth == "undefined")
depth = Infinity;
function _clone(parent2, depth2) {
if (parent2 === null)
return null;
if (depth2 === 0)
return parent2;
var child;
var proto;
if (typeof parent2 != "object") {
return parent2;
}
if (_instanceof(parent2, nativeMap)) {
child = new nativeMap();
} else if (_instanceof(parent2, nativeSet)) {
child = new nativeSet();
} else if (_instanceof(parent2, nativePromise)) {
child = new nativePromise(function(resolve, reject) {
parent2.then(function(value) {
resolve(_clone(value, depth2 - 1));
}, function(err) {
reject(_clone(err, depth2 - 1));
});
});
} else if (clone3.__isArray(parent2)) {
child = [];
} else if (clone3.__isRegExp(parent2)) {
child = new RegExp(parent2.source, __getRegExpFlags(parent2));
if (parent2.lastIndex)
child.lastIndex = parent2.lastIndex;
} else if (clone3.__isDate(parent2)) {
child = new Date(parent2.getTime());
} else if (useBuffer && Buffer.isBuffer(parent2)) {
if (Buffer.allocUnsafe) {
child = Buffer.allocUnsafe(parent2.length);
} else {
child = new Buffer(parent2.length);
}
parent2.copy(child);
return child;
} else if (_instanceof(parent2, Error)) {
child = Object.create(parent2);
} else {
if (typeof prototype == "undefined") {
proto = Object.getPrototypeOf(parent2);
child = Object.create(proto);
} else {
child = Object.create(prototype);
proto = prototype;
}
}
if (circular) {
var index = allParents.indexOf(parent2);
if (index != -1) {
return allChildren[index];
}
allParents.push(parent2);
allChildren.push(child);
}
if (_instanceof(parent2, nativeMap)) {
parent2.forEach(function(value, key) {
var keyChild = _clone(key, depth2 - 1);
var valueChild = _clone(value, depth2 - 1);
child.set(keyChild, valueChild);
});
}
if (_instanceof(parent2, nativeSet)) {
parent2.forEach(function(value) {
var entryChild = _clone(value, depth2 - 1);
child.add(entryChild);
});
}
for (var i2 in parent2) {
var attrs;
if (proto) {
attrs = Object.getOwnPropertyDescriptor(proto, i2);
}
if (attrs && attrs.set == null) {
continue;
}
child[i2] = _clone(parent2[i2], depth2 - 1);
}
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(parent2);
for (var i2 = 0; i2 < symbols.length; i2++) {
var symbol = symbols[i2];
var descriptor = Object.getOwnPropertyDescriptor(parent2, symbol);
if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {
continue;
}
child[symbol] = _clone(parent2[symbol], depth2 - 1);
if (!descriptor.enumerable) {
Object.defineProperty(child, symbol, {
enumerable: false
});
}
}
}
if (includeNonEnumerable) {
var allPropertyNames = Object.getOwnPropertyNames(parent2);
for (var i2 = 0; i2 < allPropertyNames.length; i2++) {
var propertyName = allPropertyNames[i2];
var descriptor = Object.getOwnPropertyDescriptor(parent2, propertyName);
if (descriptor && descriptor.enumerable) {
continue;
}
child[propertyName] = _clone(parent2[propertyName], depth2 - 1);
Object.defineProperty(child, propertyName, {
enumerable: false
});
}
}
return child;
}
return _clone(parent, depth);
}
clone3.clonePrototype = function clonePrototype(parent) {
if (parent === null)
return null;
var c2 = function() {
};
c2.prototype = parent;
return new c2();
};
function __objToStr(o2) {
return Object.prototype.toString.call(o2);
}
clone3.__objToStr = __objToStr;
function __isDate(o2) {
return typeof o2 === "object" && __objToStr(o2) === "[object Date]";
}
clone3.__isDate = __isDate;
function __isArray(o2) {
return typeof o2 === "object" && __objToStr(o2) === "[object Array]";
}
clone3.__isArray = __isArray;
function __isRegExp(o2) {
return typeof o2 === "object" && __objToStr(o2) === "[object RegExp]";
}
clone3.__isRegExp = __isRegExp;
function __getRegExpFlags(re) {
var flags = "";
if (re.global)
flags += "g";
if (re.ignoreCase)
flags += "i";
if (re.multiline)
flags += "m";
return flags;
}
clone3.__getRegExpFlags = __getRegExpFlags;
return clone3;
}();
if (typeof module === "object" && module.exports) {
module.exports = clone2;
}
});
// slate-devtools/src/devtools/devtools.tsx
import React30, {Fragment as Fragment2, useState as useState8} from "react";
// slate-devtools/src/devtools/devSlate.tsx
import React8, {useCallback as useCallback4, useEffect as useEffect4} from "react";
// slate-devtools/node_modules/is-plain-object/index.es.js
/*!
* isobject <https://github.com/jonschlinkert/isobject>
*
* Copyright (c) 2014-2017, Jon Schlinkert.
* Released under the MIT License.
*/
function isObject(val) {
return val != null && typeof val === "object" && Array.isArray(val) === false;
}
/*!
* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
*
* Copyright (c) 2014-2017, Jon Schlinkert.
* Released under the MIT License.
*/
function isObjectObject(o2) {
return isObject(o2) === true && Object.prototype.toString.call(o2) === "[object Object]";
}
function isPlainObject(o2) {
var ctor, prot;
if (isObjectObject(o2) === false)
return false;
ctor = o2.constructor;
if (typeof ctor !== "function")
return false;
prot = ctor.prototype;
if (isObjectObject(prot) === false)
return false;
if (prot.hasOwnProperty("isPrototypeOf") === false) {
return false;
}
return true;
}
var index_es_default = isPlainObject;
// slate-devtools/node_modules/slate/dist/index.es.js
var import_esrever = __toModule(require_esrever());
// slate-devtools/node_modules/immer/dist/immer.module.js
var _a;
var hasSymbol = typeof Symbol !== "undefined";
var hasMap = typeof Map !== "undefined";
var hasSet = typeof Set !== "undefined";
var NOTHING = hasSymbol ? Symbol("immer-nothing") : (_a = {}, _a["immer-nothing"] = true, _a);
var DRAFTABLE = hasSymbol ? Symbol("immer-draftable") : "__$immer_draftable";
var DRAFT_STATE = hasSymbol ? Symbol("immer-state") : "__$immer_state";
var iteratorSymbol = hasSymbol ? Symbol.iterator : "@@iterator";
var extendStatics = function(d2, b2) {
extendStatics = Object.setPrototypeOf || {
__proto__: []
} instanceof Array && function(d3, b3) {
d3.__proto__ = b3;
} || function(d3, b3) {
for (var p2 in b3) {
if (b3.hasOwnProperty(p2)) {
d3[p2] = b3[p2];
}
}
};
return extendStatics(d2, b2);
};
function __extends(d2, b2) {
extendStatics(d2, b2);
function __() {
this.constructor = d2;
}
d2.prototype = (__.prototype = b2.prototype, new __());
}
var Archtype;
(function(Archtype2) {
Archtype2[Archtype2["Object"] = 0] = "Object";
Archtype2[Archtype2["Array"] = 1] = "Array";
Archtype2[Archtype2["Map"] = 2] = "Map";
Archtype2[Archtype2["Set"] = 3] = "Set";
})(Archtype || (Archtype = {}));
var ProxyType;
(function(ProxyType2) {
ProxyType2[ProxyType2["ProxyObject"] = 0] = "ProxyObject";
ProxyType2[ProxyType2["ProxyArray"] = 1] = "ProxyArray";
ProxyType2[ProxyType2["ES5Object"] = 2] = "ES5Object";
ProxyType2[ProxyType2["ES5Array"] = 3] = "ES5Array";
ProxyType2[ProxyType2["Map"] = 4] = "Map";
ProxyType2[ProxyType2["Set"] = 5] = "Set";
})(ProxyType || (ProxyType = {}));
function isDraft(value) {
return !!value && !!value[DRAFT_STATE];
}
function isDraftable(value) {
if (!value) {
return false;
}
return isPlainObject2(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor[DRAFTABLE] || isMap(value) || isSet(value);
}
function isPlainObject2(value) {
if (!value || typeof value !== "object") {
return false;
}
var proto = Object.getPrototypeOf(value);
return !proto || proto === Object.prototype;
}
var ownKeys = typeof Reflect !== "undefined" && Reflect.ownKeys ? Reflect.ownKeys : typeof Object.getOwnPropertySymbols !== "undefined" ? function(obj) {
return Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj));
} : Object.getOwnPropertyNames;
function each(obj, iter) {
if (getArchtype(obj) === Archtype.Object) {
ownKeys(obj).forEach(function(key) {
return iter(key, obj[key], obj);
});
} else {
obj.forEach(function(entry, index) {
return iter(index, entry, obj);
});
}
}
function isEnumerable(base, prop) {
var desc = Object.getOwnPropertyDescriptor(base, prop);
return desc && desc.enumerable ? true : false;
}
function getArchtype(thing) {
if (!thing) {
die();
}
if (thing[DRAFT_STATE]) {
switch (thing[DRAFT_STATE].type) {
case ProxyType.ES5Object:
case ProxyType.ProxyObject:
return Archtype.Object;
case ProxyType.ES5Array:
case ProxyType.ProxyArray:
return Archtype.Array;
case ProxyType.Map:
return Archtype.Map;
case ProxyType.Set:
return Archtype.Set;
}
}
return Array.isArray(thing) ? Archtype.Array : isMap(thing) ? Archtype.Map : isSet(thing) ? Archtype.Set : Archtype.Object;
}
function has(thing, prop) {
return getArchtype(thing) === Archtype.Map ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
}
function get(thing, prop) {
return getArchtype(thing) === Archtype.Map ? thing.get(prop) : thing[prop];
}
function set(thing, propOrOldValue, value) {
switch (getArchtype(thing)) {
case Archtype.Map:
thing.set(propOrOldValue, value);
break;
case Archtype.Set:
thing.delete(propOrOldValue);
thing.add(value);
break;
default:
thing[propOrOldValue] = value;
}
}
function is(x2, y2) {
if (x2 === y2) {
return x2 !== 0 || 1 / x2 === 1 / y2;
} else {
return x2 !== x2 && y2 !== y2;
}
}
function isMap(target) {
return hasMap && target instanceof Map;
}
function isSet(target) {
return hasSet && target instanceof Set;
}
function latest(state) {
return state.copy || state.base;
}
function shallowCopy(base, invokeGetters) {
if (invokeGetters === void 0) {
invokeGetters = false;
}
if (Array.isArray(base)) {
return base.slice();
}
var clone2 = Object.create(Object.getPrototypeOf(base));
ownKeys(base).forEach(function(key) {
if (key === DRAFT_STATE) {
return;
}
var desc = Object.getOwnPropertyDescriptor(base, key);
var value = desc.value;
if (desc.get) {
if (!invokeGetters) {
throw new Error("Immer drafts cannot have computed properties");
}
value = desc.get.call(base);
}
if (desc.enumerable) {
clone2[key] = value;
} else {
Object.defineProperty(clone2, key, {
value,
writable: true,
configurable: true
});
}
});
return clone2;
}
function freeze(obj, deep) {
if (!isDraftable(obj) || isDraft(obj) || Object.isFrozen(obj)) {
return;
}
var type = getArchtype(obj);
if (type === Archtype.Set) {
obj.add = obj.clear = obj.delete = dontMutateFrozenCollections;
} else if (type === Archtype.Map) {
obj.set = obj.clear = obj.delete = dontMutateFrozenCollections;
}
Object.freeze(obj);
if (deep) {
each(obj, function(_, value) {
return freeze(value, true);
});
}
}
function dontMutateFrozenCollections() {
throw new Error("This object has been frozen and should not be mutated");
}
function createHiddenProperty(target, prop, value) {
Object.defineProperty(target, prop, {
value,
enumerable: false,
writable: true
});
}
function die() {
throw new Error("Illegal state, please file a bug");
}
var ImmerScope = function() {
function ImmerScope2(parent, immer2) {
this.drafts = [];
this.parent = parent;
this.immer = immer2;
this.canAutoFreeze = true;
}
ImmerScope2.prototype.usePatches = function(patchListener) {
if (patchListener) {
this.patches = [];
this.inversePatches = [];
this.patchListener = patchListener;
}
};
ImmerScope2.prototype.revoke = function() {
this.leave();
this.drafts.forEach(revoke);
this.drafts = null;
};
ImmerScope2.prototype.leave = function() {
if (this === ImmerScope2.current) {
ImmerScope2.current = this.parent;
}
};
ImmerScope2.enter = function(immer2) {
var scope = new ImmerScope2(ImmerScope2.current, immer2);
ImmerScope2.current = scope;
return scope;
};
return ImmerScope2;
}();
function revoke(draft) {
var state = draft[DRAFT_STATE];
if (state.type === ProxyType.ProxyObject || state.type === ProxyType.ProxyArray) {
state.revoke();
} else {
state.revoked = true;
}
}
function processResult(immer2, result, scope) {
var baseDraft = scope.drafts[0];
var isReplaced = result !== void 0 && result !== baseDraft;
immer2.willFinalize(scope, result, isReplaced);
if (isReplaced) {
if (baseDraft[DRAFT_STATE].modified) {
scope.revoke();
throw new Error("An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.");
}
if (isDraftable(result)) {
result = finalize(immer2, result, scope);
if (!scope.parent) {
maybeFreeze(immer2, result);
}
}
if (scope.patches) {
scope.patches.push({
op: "replace",
path: [],
value: result
});
scope.inversePatches.push({
op: "replace",
path: [],
value: baseDraft[DRAFT_STATE].base
});
}
} else {
result = finalize(immer2, baseDraft, scope, []);
}
scope.revoke();
if (scope.patches) {
scope.patchListener(scope.patches, scope.inversePatches);
}
return result !== NOTHING ? result : void 0;
}
function finalize(immer2, draft, scope, path) {
var state = draft[DRAFT_STATE];
if (!state) {
if (Object.isFrozen(draft)) {
return draft;
}
return finalizeTree(immer2, draft, scope);
}
if (state.scope !== scope) {
return draft;
}
if (!state.modified) {
maybeFreeze(immer2, state.base, true);
return state.base;
}
if (!state.finalized) {
state.finalized = true;
finalizeTree(immer2, state.draft, scope, path);
if (immer2.onDelete && state.type !== ProxyType.Set) {
if (immer2.useProxies) {
var assigned = state.assigned;
each(assigned, function(prop, exists) {
if (!exists) {
immer2.onDelete(state, prop);
}
});
} else {
var base = state.base, copy_1 = state.copy;
each(base, function(prop) {
if (!has(copy_1, prop)) {
immer2.onDelete(state, prop);
}
});
}
}
if (immer2.onCopy) {
immer2.onCopy(state);
}
if (immer2.autoFreeze && scope.canAutoFreeze) {
freeze(state.copy, false);
}
if (path && scope.patches) {
generatePatches(state, path, scope.patches, scope.inversePatches);
}
}
return state.copy;
}
function finalizeTree(immer2, root, scope, rootPath) {
var state = root[DRAFT_STATE];
if (state) {
if (state.type === ProxyType.ES5Object || state.type === ProxyType.ES5Array) {
state.copy = shallowCopy(state.draft, true);
}
root = state.copy;
}
each(root, function(key, value) {
return finalizeProperty(immer2, scope, root, state, root, key, value, rootPath);
});
return root;
}
function finalizeProperty(immer2, scope, root, rootState, parentValue, prop, childValue, rootPath) {
if (childValue === parentValue) {
throw Error("Immer forbids circular references");
}
var isDraftProp = !!rootState && parentValue === root;
var isSetMember = isSet(parentValue);
if (isDraft(childValue)) {
var path = rootPath && isDraftProp && !isSetMember && !has(rootState.assigned, prop) ? rootPath.concat(prop) : void 0;
childValue = finalize(immer2, childValue, scope, path);
set(parentValue, prop, childValue);
if (isDraft(childValue)) {
scope.canAutoFreeze = false;
}
} else if (isDraftProp && is(childValue, get(rootState.base, prop))) {
return;
} else if (isDraftable(childValue)) {
each(childValue, function(key, grandChild) {
return finalizeProperty(immer2, scope, root, rootState, childValue, key, grandChild, rootPath);
});
if (!scope.parent) {
maybeFreeze(immer2, childValue);
}
}
if (isDraftProp && immer2.onAssign && !isSetMember) {
immer2.onAssign(rootState, prop, childValue);
}
}
function maybeFreeze(immer2, value, deep) {
if (deep === void 0) {
deep = false;
}
if (immer2.autoFreeze && !isDraft(value)) {
freeze(value, deep);
}
}
function createProxy(base, parent) {
var isArray = Array.isArray(base);
var state = {
type: isArray ? ProxyType.ProxyArray : ProxyType.ProxyObject,
scope: parent ? parent.scope : ImmerScope.current,
modified: false,
finalized: false,
assigned: {},
parent,
base,
draft: null,
drafts: {},
copy: null,
revoke: null,
isManual: false
};
var target = state;
var traps = objectTraps;
if (isArray) {
target = [state];
traps = arrayTraps;
}
var _a2 = Proxy.revocable(target, traps), revoke2 = _a2.revoke, proxy = _a2.proxy;
state.draft = proxy;
state.revoke = revoke2;
return proxy;
}
var objectTraps = {
get: function(state, prop) {
if (prop === DRAFT_STATE) {
return state;
}
var drafts = state.drafts;
if (!state.modified && has(drafts, prop)) {
return drafts[prop];
}
var value = latest(state)[prop];
if (state.finalized || !isDraftable(value)) {
return value;
}
if (state.modified) {
if (value !== peek(state.base, prop)) {
return value;
}
drafts = state.copy;
}
return drafts[prop] = state.scope.immer.createProxy(value, state);
},
has: function(state, prop) {
return prop in latest(state);
},
ownKeys: function(state) {
return Reflect.ownKeys(latest(state));
},
set: function(state, prop, value) {
if (!state.modified) {
var baseValue = peek(state.base, prop);
var isUnchanged = value ? is(baseValue, value) || value === state.drafts[prop] : is(baseValue, value) && prop in state.base;
if (isUnchanged) {
return true;
}
prepareCopy(state);
markChanged(state);
}
state.assigned[prop] = true;
state.copy[prop] = value;
return true;
},
deleteProperty: function(state, prop) {
if (peek(state.base, prop) !== void 0 || prop in state.base) {
state.assigned[prop] = false;
prepareCopy(state);
markChanged(state);
} else if (state.assigned[prop]) {
delete state.assigned[prop];
}
if (state.copy) {
delete state.copy[prop];
}
return true;
},
getOwnPropertyDescriptor: function(state, prop) {
var owner = latest(state);
var desc = Reflect.getOwnPropertyDescriptor(owner, prop);
if (desc) {
desc.writable = true;
desc.configurable = state.type !== ProxyType.ProxyArray || prop !== "length";
}
return desc;
},
defineProperty: function() {
throw new Error("Object.defineProperty() cannot be used on an Immer draft");
},
getPrototypeOf: function(state) {
return Object.getPrototypeOf(state.base);
},
setPrototypeOf: function() {
throw new Error("Object.setPrototypeOf() cannot be used on an Immer draft");
}
};
var arrayTraps = {};
each(objectTraps, function(key, fn2) {
arrayTraps[key] = function() {
arguments[0] = arguments[0][0];
return fn2.apply(this, arguments);
};
});
arrayTraps.deleteProperty = function(state, prop) {
if (isNaN(parseInt(prop))) {
throw new Error("Immer only supports deleting array indices");
}
return objectTraps.deleteProperty.call(this, state[0], prop);
};
arrayTraps.set = function(state, prop, value) {
if (prop !== "length" && isNaN(parseInt(prop))) {
throw new Error("Immer only supports setting array indices and the 'length' property");
}
return objectTraps.set.call(this, state[0], prop, value, state[0]);
};
function peek(draft, prop) {
var state = draft[DRAFT_STATE];
var desc = Reflect.getOwnPropertyDescriptor(state ? latest(state) : draft, prop);
return desc && desc.value;
}
function markChanged(state) {
if (!state.modified) {
state.modified = true;
if (state.type === ProxyType.ProxyObject || state.type === ProxyType.ProxyArray) {
var copy_1 = state.copy = shallowCopy(state.base);
each(state.drafts, function(key, value) {
copy_1[key] = value;
});
state.drafts = void 0;
}
if (state.parent) {
markChanged(state.parent);
}
}
}
function prepareCopy(state) {
if (!state.copy) {
state.copy = shallowCopy(state.base);
}
}
function willFinalizeES5(scope, result, isReplaced) {
scope.drafts.forEach(function(draft) {
draft[DRAFT_STATE].finalizing = true;
});
if (!isReplaced) {
if (scope.patches) {
markChangesRecursively(scope.drafts[0]);
}
markChangesSweep(scope.drafts);
} else if (isDraft(result) && result[DRAFT_STATE].scope === scope) {
markChangesSweep(scope.drafts);
}
}
function createES5Proxy(base, parent) {
var isArray = Array.isArray(base);
var draft = clonePotentialDraft(base);
each(draft, function(prop) {
proxyProperty(draft, prop, isArray || isEnumerable(base, prop));
});
var state = {
type: isArray ? ProxyType.ES5Array : ProxyType.ES5Object,
scope: parent ? parent.scope : ImmerScope.current,
modified: false,
finalizing: false,
finalized: false,
assigned: {},
parent,
base,
draft,
copy: null,
revoked: false,
isManual: false
};
createHiddenProperty(draft, DRAFT_STATE, state);
return draft;
}
function peek$1(draft, prop) {
var state = draft[DRAFT_STATE];
if (state && !state.finalizing) {
state.finalizing = true;
var value = draft[prop];
state.finalizing = false;
return value;
}
return draft[prop];
}
function get$1(state, prop) {
assertUnrevoked(state);
var value = peek$1(latest(state), prop);
if (state.finalizing) {
return value;
}
if (value === peek$1(state.base, prop) && isDraftable(value)) {
prepareCopy$1(state);
return state.copy[prop] = state.scope.immer.createProxy(value, state);
}
return value;
}
function set$1(state, prop, value) {
assertUnrevoked(state);
state.assigned[prop] = true;
if (!state.modified) {
if (is(value, peek$1(latest(state), prop))) {
return;
}
markChangedES5(state);
prepareCopy$1(state);
}
state.copy[prop] = value;
}
function markChangedES5(state) {
if (!state.modified) {
state.modified = true;
if (state.parent) {
markChangedES5(state.parent);
}
}
}
function prepareCopy$1(state) {
if (!state.copy) {
state.copy = clonePotentialDraft(state.base);
}
}
function clonePotentialDraft(base) {
var state = base && base[DRAFT_STATE];
if (state) {
state.finalizing = true;
var draft = shallowCopy(state.draft, true);
state.finalizing = false;
return draft;
}
return shallowCopy(base);
}
var descriptors = {};
function proxyProperty(draft, prop, enumerable) {
var desc = descriptors[prop];
if (desc) {
desc.enumerable = enumerable;
} else {
descriptors[prop] = desc = {
configurable: true,
enumerable,
get: function() {
return get$1(this[DRAFT_STATE], prop);
},
set: function(value) {
set$1(this[DRAFT_STATE], prop, value);
}
};
}
Object.defineProperty(draft, prop, desc);
}
function assertUnrevoked(state) {
if (state.revoked === true) {
throw new Error("Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + JSON.stringify(latest(state)));
}
}
function markChangesSweep(drafts) {
for (var i2 = drafts.length - 1; i2 >= 0; i2--) {
var state = drafts[i2][DRAFT_STATE];
if (!state.modified) {
switch (state.type) {
case ProxyType.ES5Array:
if (hasArrayChanges(state)) {
markChangedES5(state);
}
break;
case ProxyType.ES5Object:
if (hasObjectChanges(state)) {
markChangedES5(state);
}
break;
}
}
}
}
function markChangesRecursively(object) {
if (!object || typeof object !== "object") {
return;
}
var state = object[DRAFT_STATE];
if (!state) {
return;
}
var base = state.base, draft = state.draft, assigned = state.assigned, type = state.type;
if (type === ProxyType.ES5Object) {
each(draft, function(key) {
if (key === DRAFT_STATE) {
re