diff --git a/App.vue b/App.vue index fd4eb54..5d3a189 100644 --- a/App.vue +++ b/App.vue @@ -10,18 +10,17 @@ export default { onLaunch: function() { console.log("App Launch"); - // #ifdef H5 + // #ifndef APP console.error( - `暂时不支持运行到 Web，如果需要移动端的 Web 项目，参考 [H5 demo](https://github.com/openimsdk/openim-h5-demo)` + `暂时不支持运行到 Web或小程序端，如果需要移动端的 Web 项目，参考 [H5 demo](https://github.com/openimsdk/openim-h5-demo)` ); return ; // #endif - // #ifdef MP-WEIXIN - console.error(`暂时不支持运行到小程序端`); - // #endif + // #ifdef APP this.checkUpdate(); this.setGlobalIMlistener(); this.tryLogin(); + // #endif }, onShow: function() { console.log("App Show"); @@ -80,7 +79,7 @@ uni.removeStorage({ key: "BusinessToken", }); - uni.$u.route("/pages/login/index"); + uni.$u.route("/pages/common/login/index"); }); }; IMSDK.subscribe(IMSDK.IMEvents.OnKickedOffline, (data) => { diff --git a/components/User.vue b/components/User.vue index 0a96b5a..af52013 100644 --- a/components/User.vue +++ b/components/User.vue @@ -15,7 +15,7 @@ const token = uni.getStorageSync('IMToken'); if (!token) { uni.redirectTo({ - url: "/pages/login/index" + url: "/pages/common/login/index" }) } }, diff --git a/index.html b/index.html index 31ff774..960e7d7 100644 --- a/index.html +++ b/index.html @@ -2,6 +2,8 @@ + + + \ No newline at end of file diff --git a/pages/login/index.vue b/pages/common/login/index.vue similarity index 99% rename from pages/login/index.vue rename to pages/common/login/index.vue index 16ac3e7..90f84d6 100644 --- a/pages/login/index.vue +++ b/pages/common/login/index.vue @@ -148,7 +148,7 @@ export default { this.eying = !this.eying; }, toRegisterOrForget(isRegister) { - uni.$u.route("/pages/login/registerOrForget/index", { + uni.$u.route("/pages/login/common/index", { isRegister, }); }, diff --git a/pages/common/map.vue b/pages/common/map.vue index 45d503a..e72f549 100644 --- a/pages/common/map.vue +++ b/pages/common/map.vue @@ -16,11 +16,11 @@ - - - - - + + + + + diff --git a/pages/login/registerOrForget/index.vue b/pages/common/registerOrForget/index.vue similarity index 97% rename from pages/login/registerOrForget/index.vue rename to pages/common/registerOrForget/index.vue index 8aff063..42b00b2 100644 --- a/pages/login/registerOrForget/index.vue +++ b/pages/common/registerOrForget/index.vue @@ -98,7 +98,7 @@ uni.$u.toast("验证码已发送！"); setTimeout( () => - uni.$u.route("/pages/login/verifyCode/index", { + uni.$u.route("/pages/common/verifyCode/index", { userInfo: JSON.stringify(this.userInfo), isRegister: this.isRegister, }), @@ -112,7 +112,7 @@ }); }, back() { - uni.$u.route("/pages/login/index"); + uni.$u.route("/pages/common/login/index"); }, showPicker() { this.$refs.AreaPicker.init(); diff --git a/pages/login/setPassword/index.vue b/pages/common/setPassword/index.vue similarity index 100% rename from pages/login/setPassword/index.vue rename to pages/common/setPassword/index.vue diff --git a/pages/login/setSelfInfo/index.vue b/pages/common/setSelfInfo/index.vue similarity index 98% rename from pages/login/setSelfInfo/index.vue rename to pages/common/setSelfInfo/index.vue index 6edd631..2c4b8e3 100644 --- a/pages/login/setSelfInfo/index.vue +++ b/pages/common/setSelfInfo/index.vue @@ -147,7 +147,7 @@ } catch (err) { console.log(err); if(err.msg=="验证码过期" || err.msg=="验证码错误"){ - uni.$u.route("/pages/login/verifyCode/index", { + uni.$u.route("/pages/common/verifyCode/index", { userInfo: JSON.stringify(this.userInfo), isRegister: true, resend: 1, diff --git a/pages/login/verifyCode/index.vue b/pages/common/verifyCode/index.vue similarity index 95% rename from pages/login/verifyCode/index.vue rename to pages/common/verifyCode/index.vue index ce0280b..5d2ee18 100644 --- a/pages/login/verifyCode/index.vue +++ b/pages/common/verifyCode/index.vue @@ -61,7 +61,7 @@ onReady() {}, methods: { back() { - uni.$u.route("/pages/login/registerOrForget/index", { + uni.$u.route("/pages/login/common/index", { isRegister: this.isRegister, }); }, @@ -77,13 +77,13 @@ businessVerifyCode(options) .then(() => { if (this.isRegister) { - uni.$u.route("/pages/login/setSelfInfo/index", { + uni.$u.route("/pages/common/setSelfInfo/index", { userInfo: JSON.stringify(this.userInfo), isRegister: this.isRegister, codeValue: this.codeValue, }); } else { - uni.$u.route("/pages/login/setPassword/index", { + uni.$u.route("/pages/common/setPassword/index", { userInfo: JSON.stringify(this.userInfo), isRegister: !this.isRegister, codeValue: this.codeValue, diff --git a/pages/conversation/chating/components/ChatingFooter/CustomEditor.vue b/pages/conversation/chating/components/ChatingFooter/CustomEditor.vue index 79725a1..d26f28f 100644 --- a/pages/conversation/chating/components/ChatingFooter/CustomEditor.vue +++ b/pages/conversation/chating/components/ChatingFooter/CustomEditor.vue @@ -1,193 +1,284 @@ + \ No newline at end of file diff --git a/pages/conversation/chating/components/ChatingFooter/Recoder.vue b/pages/conversation/chating/components/ChatingFooter/Recoder.vue index 28f6514..3eb1638 100644 --- a/pages/conversation/chating/components/ChatingFooter/Recoder.vue +++ b/pages/conversation/chating/components/ChatingFooter/Recoder.vue @@ -150,7 +150,7 @@ }; if (this.voiceCanSend) { //console.log("=====上传语音文件，并发送语音信息===="); - this.$emit('RecodeEvent',{type:"sendVoiceMessage",audio:voiceFile}) + this.$emit('RecodEvent',{type:"sendVoiceMessage",audio:voiceFile}) return; } else { console.log("=====已经取消发送语音信息====") diff --git a/pages/conversation/chating/components/ChatingFooter/SimpleEditor.vue b/pages/conversation/chating/components/ChatingFooter/SimpleEditor.vue index 2ca7f79..a7c3b65 100644 --- a/pages/conversation/chating/components/ChatingFooter/SimpleEditor.vue +++ b/pages/conversation/chating/components/ChatingFooter/SimpleEditor.vue @@ -59,21 +59,22 @@ this.textValue = e.detail.value; // 更新光标位置 this.cursorPos = e.detail.cursor || this.textValue.length; - this.$emit("input", { - detail: { - value: this.textValue, - text: this.textValue, - html: this.textValue // 简单编辑器，HTML 就是文本 - } + this.$emit("onUserEvent", { + "type":"input", + text: this.textValue, + html: this.textValue // 简单编辑器，HTML 就是文本 }); }, onFocus(e) { - this.$emit("focus", e); + this.$emit("onUserEvent",{ + type:"focus", + e + }); }, onBlur(e) { // 保存光标位置 this.cursorPos = e.detail.cursor || this.textValue.length; - this.$emit("blur", e); + this.$emit("onUserEvent",{type:"blur", e}); }, // 插入文本（表情或普通文本） insertText(text, successFn, errFn) { @@ -93,12 +94,10 @@ this.cursorPos = newCursorPos; // 触发 input 事件 - this.$emit("input", { - detail: { - value: newText, - text: newText, - html: newText - } + this.$emit("onUserEvent", { + type:"input", + html: newText, + text: newText, }); // 使用 $nextTick 确保 DOM 更新后再设置光标 @@ -139,12 +138,10 @@ clear() { this.textValue = ""; this.cursorPos = 0; - this.$emit("input", { - detail: { - value: "", - text: "", - html: "" - } + this.$emit("onUserEvent", { + type:"input", + text: "", + html: "" }); }, // 删除（退格） @@ -180,12 +177,10 @@ this.cursorPos = currentPos - deletedLength; // 触发 input 事件 - this.$emit("input", { - detail: { - value: this.textValue, - text: this.textValue, - html: this.textValue - } + this.$emit("onUserEvent", { + type:"input", + text: this.textValue, + html: this.textValue }); // 使用 $nextTick 确保 DOM 更新后再设置光标 @@ -220,12 +215,12 @@ .simple_editor_textarea { width: 100%; - min-height: 30px; + min-height: 60rpx; max-height: 120px; + line-height: 60rpx; background-color: #fff; - font-size: 14px; - line-height: 1.5; - padding: 4px; + font-size: 30rpx; + padding: 0 6rpx; word-break: break-all; box-sizing: border-box; } diff --git a/pages/conversation/chating/components/ChatingFooter/index.vue b/pages/conversation/chating/components/ChatingFooter/index.vue index 5eddf70..6d53b26 100644 --- a/pages/conversation/chating/components/ChatingFooter/index.vue +++ b/pages/conversation/chating/components/ChatingFooter/index.vue @@ -5,15 +5,13 @@ - + + @onUserEvent="onEditorEvent" + :value="inputHtml"/> @@ -53,6 +51,7 @@ import {offlinePushInfo} from "@/util/imCommon"; import {ChatingFooterActionTypes,UpdateMessageTypes,} from "@/constant"; import IMSDK, {IMMethods,MessageStatus,MessageType,} from "openim-uniapp-polyfill"; + import CustomEditor from "./CustomEditor"; import SimpleEditor from "./SimpleEditor"; import ChatingActionBar from "./ChatingActionBar"; import Recoder from "./Recoder"; @@ -74,7 +73,7 @@ export default { components: { - SimpleEditor, + CustomEditor,SimpleEditor, ChatingActionBar, Recoder, }, @@ -87,7 +86,7 @@ voiceIconText : "正在录音...", inputType:"keyboard", isEmoji:false, - inputHtml: '@cansnow@baidu@jingds', + inputHtml: '', actionBarVisible: false, isInputFocus: false, actionSheetMenu: [], @@ -102,6 +101,7 @@ "storeCurrentConversation", "storeCurrentGroup", "storeBlackList", + "storeCurrentUserID" ]), hasContent() { return html2Text(this.inputHtml) !== ""; @@ -212,17 +212,7 @@ this.isEmoji = false; } }, - editorFocus() { - this.isInputFocus = true; - this.$emit("scrollToBottom"); - }, - editorBlur() { - this.isInputFocus = false; - }, - editorInput(e) { - // SimpleEditor 返回的是纯文本，直接使用 - this.inputHtml = e.detail.value || e.detail.text || e.detail.html || ""; - }, + async sendLocationMessage(res){ console.log(res); const _this = this; @@ -318,8 +308,45 @@ disposeKeyboardListener() { uni.offKeyboardHeightChange(this.keyboardChangeHander); }, - - onRecodeEvent(e){ + onEditorEvent(e){ + const _this = this; + if(e.type=="atevent" && this.storeCurrentConversation.groupID){ + uni.navigateTo({ + url: `/pages/common/contactChoose/chooseGroupMember?groupID=${this.storeCurrentConversation.groupID}&checkedUserIDList=[]&hideUserIDList=[${this.storeCurrentUserID}]`, + events: { + onSelectedConfirm(userList) { + userList.forEach((user)=>{ + _this.$refs.customEditor.insertMention(user.remark || user.nickname || user.showName,user.userID); + _this.$refs.customEditor.focus(); + }) + } + } + }); + return ; + } + if(e.type=="ready"){ + return ; + } + if(e.type=="focus"){ + this.isInputFocus = true; + this.$emit("scrollToBottom"); + return ; + } + if(e.type=="blur"){ + this.isInputFocus = false; + return ; + } + if(e.type=="onChange"){ + return ; + } + if(e.type=="input"){ + // SimpleEditor 返回的是纯文本，直接使用 + this.inputHtml = e.html || e.text || ""; + return ; + } + console.log(e); + }, + onRecodEvent(e){ const _this = this; switch(e.type){ case "voiceIconTextChange": @@ -366,13 +393,13 @@ // 直接插入文本，不等待 nextTick，减少延迟 this.$refs.customEditor.insertText(e.emoji,() =>{ - console.log("插入文字成功"); + //console.log("插入文字成功"); // 延迟重置标志，确保其他事件不会隐藏表情栏 setTimeout(() => { this.isInsertingEmoji = false; }, 300); },(err) => { - console.log("插入文字失败", err); + //console.log("插入文字失败", err); this.isInsertingEmoji = false; }); break; @@ -450,11 +477,10 @@ \ No newline at end of file diff --git a/pages/user/vip/vip.vue b/pages/user/vip/vip.vue new file mode 100644 index 0000000..efa9905 --- /dev/null +++ b/pages/user/vip/vip.vue @@ -0,0 +1,197 @@ + + + + + \ No newline at end of file diff --git a/static/images/workbench/01.png b/static/images/find/01.png similarity index 100% rename from static/images/workbench/01.png rename to static/images/find/01.png diff --git a/static/images/workbench/02.png b/static/images/find/02.png similarity index 100% rename from static/images/workbench/02.png rename to static/images/find/02.png diff --git a/static/images/workbench/03.png b/static/images/find/03.png similarity index 100% rename from static/images/workbench/03.png rename to static/images/find/03.png diff --git a/static/images/workbench/04.png b/static/images/find/04.png similarity index 100% rename from static/images/workbench/04.png rename to static/images/find/04.png diff --git a/static/images/workbench/05.png b/static/images/find/05.png similarity index 100% rename from static/images/workbench/05.png rename to static/images/find/05.png diff --git a/static/images/workbench/06.png b/static/images/find/06.png similarity index 100% rename from static/images/workbench/06.png rename to static/images/find/06.png diff --git a/static/images/workbench/07.png b/static/images/find/07.png similarity index 100% rename from static/images/workbench/07.png rename to static/images/find/07.png diff --git a/static/images/workbench/08.png b/static/images/find/08.png similarity index 100% rename from static/images/workbench/08.png rename to static/images/find/08.png diff --git a/static/images/workbench/09.png b/static/images/find/09.png similarity index 100% rename from static/images/workbench/09.png rename to static/images/find/09.png diff --git a/static/images/workbench/10.png b/static/images/find/10.png similarity index 100% rename from static/images/workbench/10.png rename to static/images/find/10.png diff --git a/static/images/workbench/11.png b/static/images/find/11.png similarity index 100% rename from static/images/workbench/11.png rename to static/images/find/11.png diff --git a/static/images/workbench/friendCircleIcon.png b/static/images/find/friendCircleIcon.png similarity index 100% rename from static/images/workbench/friendCircleIcon.png rename to static/images/find/friendCircleIcon.png diff --git a/static/images/user/member_crown.png b/static/images/user/member_crown.png new file mode 100644 index 0000000..b95f015 Binary files /dev/null and b/static/images/user/member_crown.png differ diff --git a/static/wangeditor/index.js b/static/wangeditor/index.js new file mode 100644 index 0000000..9a5d788 --- /dev/null +++ b/static/wangeditor/index.js @@ -0,0 +1,24247 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : + typeof define === 'function' && define.amd ? define(['exports'], factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.wangEditor = {})); +})(this, (function (exports) { 'use strict'; + + /** + * @description browser polyfill + * @author wangfupeng + */ + var _a; + // @ts-nocheck + // 必须是浏览器环境 + if (typeof global === 'undefined') { + // 检查 IE 浏览器 + if ('ActiveXObject' in window) { + var info = '抱歉，wangEditor V5+ 版本开始，不在支持 IE 浏览器'; + info += '\n Sorry, wangEditor V5+ versions do not support IE browser.'; + console.error(info); + } + globalThisPolyfill(); + AggregateErrorPolyfill(); + } + else if (global && ((_a = global.navigator) === null || _a === void 0 ? void 0 : _a.userAgent.match('QQBrowser'))) { + // 兼容 QQ 浏览器 AggregateError 报错 + globalThisPolyfill(); + AggregateErrorPolyfill(); + } + function globalThisPolyfill() { + // 部分浏览器不支持 globalThis + if (typeof globalThis === 'undefined') { + // @ts-ignore + window.globalThis = window; + } + } + function AggregateErrorPolyfill() { + if (typeof AggregateError === 'undefined') { + window.AggregateError = function (errors, msg) { + var err = new Error(msg); + err.errors = errors; + return err; + }; + } + } + + /** + * @description node polyfill + * @author wangfupeng + */ + // @ts-nocheck + // 必须是 node 环境 + if (typeof global === 'object') { + // 用于 nodejs ，避免报错 + var globalProperty = Object.getOwnPropertyDescriptor(global, 'window'); + // global.window 为空则直接写入 + // 部分框架下已经定义了global.window且是不可写属性 + if (!global.window || globalProperty.set) { + global.window = global; + global.requestAnimationFrame = function () { }; + global.navigator = { + userAgent: '', + }; + global.location = { + hostname: '0.0.0.0', + port: 0, + protocol: 'http:', + }; + global.btoa = function () { }; + global.crypto = { + getRandomValues: function (buffer) { + return nodeCrypto.randomFillSync(buffer); + }, + }; + } + if (global.document != null) { + // SSR 环境下可能会报错 （issue 4409） + if (global.document.getElementsByTagName == null) { + global.document.getElementsByTagName = function () { return []; }; + } + } + } + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + function getDefaultExportFromCjs (x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x; + } + + function createCommonjsModule$1(fn) { + var module = { exports: {} }; + return fn(module, module.exports), module.exports; + } + + /*! + * is-plain-object + * + * Copyright (c) 2014-2017, Jon Schlinkert. + * Released under the MIT License. + */ + + function isObject$4(o) { + return Object.prototype.toString.call(o) === '[object Object]'; + } + + function isPlainObject$2(o) { + var ctor,prot; + + if (isObject$4(o) === false) return false; + + // If has modified constructor + ctor = o.constructor; + if (ctor === undefined) return true; + + // If has modified prototype + prot = ctor.prototype; + if (isObject$4(prot) === false) return false; + + // If constructor does not have an Object-specific method + if (prot.hasOwnProperty('isPrototypeOf') === false) { + return false; + } + + // Most likely a plain Object + return true; + } + + var isPlainObject_2 = isPlainObject$2; + + var isPlainObject_1 = /*#__PURE__*/Object.defineProperty({ + isPlainObject: isPlainObject_2 + }, '__esModule', {value: true}); + + var _ref; + + // Should be no imports here! + // Some things that should be evaluated before all else... + // We only want to know if non-polyfilled symbols are available + var hasSymbol = typeof Symbol !== "undefined" && typeof + /*#__PURE__*/ + Symbol("x") === "symbol"; + var hasMap = typeof Map !== "undefined"; + var hasSet = typeof Set !== "undefined"; + var hasProxies = typeof Proxy !== "undefined" && typeof Proxy.revocable !== "undefined" && typeof Reflect !== "undefined"; + /** + * The sentinel value returned by producers to replace the draft with undefined. + */ + + var NOTHING = hasSymbol ? + /*#__PURE__*/ + Symbol.for("immer-nothing") : (_ref = {}, _ref["immer-nothing"] = true, _ref); + /** + * To let Immer treat your class instances as plain immutable objects + * (albeit with a custom prototype), you must define either an instance property + * or a static property on each of your custom classes. + * + * Otherwise, your class instance will never be drafted, which means it won't be + * safe to mutate in a produce callback. + */ + + var DRAFTABLE = hasSymbol ? + /*#__PURE__*/ + Symbol.for("immer-draftable") : "__$immer_draftable"; + var DRAFT_STATE = hasSymbol ? + /*#__PURE__*/ + Symbol.for("immer-state") : "__$immer_state"; // Even a polyfilled Symbol might provide Symbol.iterator + + var iteratorSymbol$1 = typeof Symbol != "undefined" && Symbol.iterator || "@@iterator"; + + var errors = { + 0: "Illegal state", + 1: "Immer drafts cannot have computed properties", + 2: "This object has been frozen and should not be mutated", + 3: function _(data) { + return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data; + }, + 4: "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.", + 5: "Immer forbids circular references", + 6: "The first or second argument to `produce` must be a function", + 7: "The third argument to `produce` must be a function or undefined", + 8: "First argument to `createDraft` must be a plain object, an array, or an immerable object", + 9: "First argument to `finishDraft` must be a draft returned by `createDraft`", + 10: "The given draft is already finalized", + 11: "Object.defineProperty() cannot be used on an Immer draft", + 12: "Object.setPrototypeOf() cannot be used on an Immer draft", + 13: "Immer only supports deleting array indices", + 14: "Immer only supports setting array indices and the 'length' property", + 15: function _(path) { + return "Cannot apply patch, path doesn't resolve: " + path; + }, + 16: 'Sets cannot have "replace" patches.', + 17: function _(op) { + return "Unsupported patch operation: " + op; + }, + 18: function _(plugin) { + return "The plugin for '" + plugin + "' has not been loaded into Immer. To enable the plugin, import and call `enable" + plugin + "()` when initializing your application."; + }, + 20: "Cannot use proxies if Proxy, Proxy.revocable or Reflect are not available", + 21: function _(thing) { + return "produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '" + thing + "'"; + }, + 22: function _(thing) { + return "'current' expects a draft, got: " + thing; + }, + 23: function _(thing) { + return "'original' expects a draft, got: " + thing; + }, + 24: "Patching reserved attributes like __proto__, prototype and constructor is not allowed" + }; + function die(error) { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + { + var e = errors[error]; + var msg = !e ? "unknown error nr: " + error : typeof e === "function" ? e.apply(null, args) : e; + throw new Error("[Immer] " + msg); + } + } + + /** Returns true if the given value is an Immer draft */ + + + + function isDraft(value) { + return !!value && !!value[DRAFT_STATE]; + } + /** Returns true if the given value can be drafted by Immer */ + + + + function isDraftable(value) { + if (!value) return false; + return isPlainObject$1(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor[DRAFTABLE] || isMap(value) || isSet(value); + } + var objectCtorString = + /*#__PURE__*/ + Object.prototype.constructor.toString(); + + + function isPlainObject$1(value) { + if (!value || typeof value !== "object") return false; + var proto = Object.getPrototypeOf(value); + + if (proto === null) { + return true; + } + + var Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor; + if (Ctor === Object) return true; + return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString; + } + function original(value) { + if (!isDraft(value)) die(23, value); + return value[DRAFT_STATE].base_; + } + + + var ownKeys$a = typeof Reflect !== "undefined" && Reflect.ownKeys ? Reflect.ownKeys : typeof Object.getOwnPropertySymbols !== "undefined" ? function (obj) { + return Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj)); + } : + /* istanbul ignore next */ + Object.getOwnPropertyNames; + var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors(target) { + // Polyfill needed for Hermes and IE, see https://github.com/facebook/hermes/issues/274 + var res = {}; + ownKeys$a(target).forEach(function (key) { + res[key] = Object.getOwnPropertyDescriptor(target, key); + }); + return res; + }; + function each$1(obj, iter, enumerableOnly) { + if (enumerableOnly === void 0) { + enumerableOnly = false; + } + + if (getArchtype(obj) === 0 + /* Object */ + ) { + (enumerableOnly ? Object.keys : ownKeys$a)(obj).forEach(function (key) { + if (!enumerableOnly || typeof key !== "symbol") iter(key, obj[key], obj); + }); + } else { + obj.forEach(function (entry, index) { + return iter(index, entry, obj); + }); + } + } + + + function getArchtype(thing) { + /* istanbul ignore next */ + var state = thing[DRAFT_STATE]; + return state ? state.type_ > 3 ? state.type_ - 4 // cause Object and Array map back from 4 and 5 + : state.type_ // others are the same + : Array.isArray(thing) ? 1 + /* Array */ + : isMap(thing) ? 2 + /* Map */ + : isSet(thing) ? 3 + /* Set */ + : 0 + /* Object */ + ; + } + + + function has(thing, prop) { + return getArchtype(thing) === 2 + /* Map */ + ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop); + } + + + function get(thing, prop) { + // @ts-ignore + return getArchtype(thing) === 2 + /* Map */ + ? thing.get(prop) : thing[prop]; + } + + + function set(thing, propOrOldValue, value) { + var t = getArchtype(thing); + if (t === 2 + /* Map */ + ) thing.set(propOrOldValue, value);else if (t === 3 + /* Set */ + ) { + thing.delete(propOrOldValue); + thing.add(value); + } else thing[propOrOldValue] = value; + } + + + function is$1(x, y) { + // From: https://github.com/facebook/fbjs/blob/c69904a511b900266935168223063dd8772dfc40/packages/fbjs/src/core/shallowEqual.js + if (x === y) { + return x !== 0 || 1 / x === 1 / y; + } else { + return x !== x && y !== y; + } + } + + + 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) { + if (Array.isArray(base)) return Array.prototype.slice.call(base); + var descriptors = getOwnPropertyDescriptors(base); + delete descriptors[DRAFT_STATE]; + var keys = ownKeys$a(descriptors); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var desc = descriptors[key]; + + if (desc.writable === false) { + desc.writable = true; + desc.configurable = true; + } // like object.assign, we will read any _own_, get/set accessors. This helps in dealing + // with libraries that trap values, like mobx or vue + // unlike object.assign, non-enumerables will be copied as well + + + if (desc.get || desc.set) descriptors[key] = { + configurable: true, + writable: true, + enumerable: desc.enumerable, + value: base[key] + }; + } + + return Object.create(Object.getPrototypeOf(base), descriptors); + } + function freeze(obj, deep) { + if (deep === void 0) { + deep = false; + } + + if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj)) return obj; + + if (getArchtype(obj) > 1 + /* Map or Set */ + ) { + obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections; + } + + Object.freeze(obj); + if (deep) each$1(obj, function (key, value) { + return freeze(value, true); + }, true); + return obj; + } + + function dontMutateFrozenCollections() { + die(2); + } + + function isFrozen(obj) { + if (obj == null || typeof obj !== "object") return true; // See #600, IE dies on non-objects in Object.isFrozen + + return Object.isFrozen(obj); + } + + /** Plugin utilities */ + + var plugins = {}; + function getPlugin(pluginKey) { + var plugin = plugins[pluginKey]; + + if (!plugin) { + die(18, pluginKey); + } // @ts-ignore + + + return plugin; + } + function loadPlugin(pluginKey, implementation) { + if (!plugins[pluginKey]) plugins[pluginKey] = implementation; + } + + var currentScope; + function getCurrentScope() { + if ( !currentScope) die(0); + return currentScope; + } + + function createScope(parent_, immer_) { + return { + drafts_: [], + parent_: parent_, + immer_: immer_, + // Whenever the modified draft contains a draft from another scope, we + // need to prevent auto-freezing so the unowned draft can be finalized. + canAutoFreeze_: true, + unfinalizedDrafts_: 0 + }; + } + + function usePatchesInScope(scope, patchListener) { + if (patchListener) { + getPlugin("Patches"); // assert we have the plugin + + scope.patches_ = []; + scope.inversePatches_ = []; + scope.patchListener_ = patchListener; + } + } + function revokeScope(scope) { + leaveScope(scope); + scope.drafts_.forEach(revokeDraft); // @ts-ignore + + scope.drafts_ = null; + } + function leaveScope(scope) { + if (scope === currentScope) { + currentScope = scope.parent_; + } + } + function enterScope(immer) { + return currentScope = createScope(currentScope, immer); + } + + function revokeDraft(draft) { + var state = draft[DRAFT_STATE]; + if (state.type_ === 0 + /* ProxyObject */ + || state.type_ === 1 + /* ProxyArray */ + ) state.revoke_();else state.revoked_ = true; + } + + function processResult(result, scope) { + scope.unfinalizedDrafts_ = scope.drafts_.length; + var baseDraft = scope.drafts_[0]; + var isReplaced = result !== undefined && result !== baseDraft; + if (!scope.immer_.useProxies_) getPlugin("ES5").willFinalizeES5_(scope, result, isReplaced); + + if (isReplaced) { + if (baseDraft[DRAFT_STATE].modified_) { + revokeScope(scope); + die(4); + } + + if (isDraftable(result)) { + // Finalize the result in case it contains (or is) a subset of the draft. + result = finalize(scope, result); + if (!scope.parent_) maybeFreeze(scope, result); + } + + if (scope.patches_) { + getPlugin("Patches").generateReplacementPatches_(baseDraft[DRAFT_STATE], result, scope.patches_, scope.inversePatches_); + } + } else { + // Finalize the base draft. + result = finalize(scope, baseDraft, []); + } + + revokeScope(scope); + + if (scope.patches_) { + scope.patchListener_(scope.patches_, scope.inversePatches_); + } + + return result !== NOTHING ? result : undefined; + } + + function finalize(rootScope, value, path) { + // Don't recurse in tho recursive data structures + if (isFrozen(value)) return value; + var state = value[DRAFT_STATE]; // A plain object, might need freezing, might contain drafts + + if (!state) { + each$1(value, function (key, childValue) { + return finalizeProperty(rootScope, state, value, key, childValue, path); + }, true // See #590, don't recurse into non-enumerable of non drafted objects + ); + return value; + } // Never finalize drafts owned by another scope. + + + if (state.scope_ !== rootScope) return value; // Unmodified draft, return the (frozen) original + + if (!state.modified_) { + maybeFreeze(rootScope, state.base_, true); + return state.base_; + } // Not finalized yet, let's do that now + + + if (!state.finalized_) { + state.finalized_ = true; + state.scope_.unfinalizedDrafts_--; + var result = // For ES5, create a good copy from the draft first, with added keys and without deleted keys. + state.type_ === 4 + /* ES5Object */ + || state.type_ === 5 + /* ES5Array */ + ? state.copy_ = shallowCopy(state.draft_) : state.copy_; // Finalize all children of the copy + // For sets we clone before iterating, otherwise we can get in endless loop due to modifying during iteration, see #628 + // Although the original test case doesn't seem valid anyway, so if this in the way we can turn the next line + // back to each(result, ....) + + each$1(state.type_ === 3 + /* Set */ + ? new Set(result) : result, function (key, childValue) { + return finalizeProperty(rootScope, state, result, key, childValue, path); + }); // everything inside is frozen, we can freeze here + + maybeFreeze(rootScope, result, false); // first time finalizing, let's create those patches + + if (path && rootScope.patches_) { + getPlugin("Patches").generatePatches_(state, path, rootScope.patches_, rootScope.inversePatches_); + } + } + + return state.copy_; + } + + function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath) { + if ( childValue === targetObject) die(5); + + if (isDraft(childValue)) { + var path = rootPath && parentState && parentState.type_ !== 3 + /* Set */ + && // Set objects are atomic since they have no keys. + !has(parentState.assigned_, prop) // Skip deep patches for assigned keys. + ? rootPath.concat(prop) : undefined; // Drafts owned by `scope` are finalized here. + + var res = finalize(rootScope, childValue, path); + set(targetObject, prop, res); // Drafts from another scope must prevented to be frozen + // if we got a draft back from finalize, we're in a nested produce and shouldn't freeze + + if (isDraft(res)) { + rootScope.canAutoFreeze_ = false; + } else return; + } // Search new objects for unfinalized drafts. Frozen objects should never contain drafts. + + + if (isDraftable(childValue) && !isFrozen(childValue)) { + if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) { + // optimization: if an object is not a draft, and we don't have to + // deepfreeze everything, and we are sure that no drafts are left in the remaining object + // cause we saw and finalized all drafts already; we can stop visiting the rest of the tree. + // This benefits especially adding large data tree's without further processing. + // See add-data.js perf test + return; + } + + finalize(rootScope, childValue); // immer deep freezes plain objects, so if there is no parent state, we freeze as well + + if (!parentState || !parentState.scope_.parent_) maybeFreeze(rootScope, childValue); + } + } + + function maybeFreeze(scope, value, deep) { + if (deep === void 0) { + deep = false; + } + + if (scope.immer_.autoFreeze_ && scope.canAutoFreeze_) { + freeze(value, deep); + } + } + + /** + * Returns a new draft of the `base` object. + * + * The second argument is the parent draft-state (used internally). + */ + + function createProxyProxy(base, parent) { + var isArray = Array.isArray(base); + var state = { + type_: isArray ? 1 + /* ProxyArray */ + : 0 + /* ProxyObject */ + , + // Track which produce call this is associated with. + scope_: parent ? parent.scope_ : getCurrentScope(), + // True for both shallow and deep changes. + modified_: false, + // Used during finalization. + finalized_: false, + // Track which properties have been assigned (true) or deleted (false). + assigned_: {}, + // The parent draft state. + parent_: parent, + // The base state. + base_: base, + // The base proxy. + draft_: null, + // The base copy with any updated values. + copy_: null, + // Called by the `produce` function. + revoke_: null, + isManual_: false + }; // the traps must target something, a bit like the 'real' base. + // but also, we need to be able to determine from the target what the relevant state is + // (to avoid creating traps per instance to capture the state in closure, + // and to avoid creating weird hidden properties as well) + // So the trick is to use 'state' as the actual 'target'! (and make sure we intercept everything) + // Note that in the case of an array, we put the state in an array to have better Reflect defaults ootb + + var target = state; + var traps = objectTraps; + + if (isArray) { + target = [state]; + traps = arrayTraps; + } + + var _Proxy$revocable = Proxy.revocable(target, traps), + revoke = _Proxy$revocable.revoke, + proxy = _Proxy$revocable.proxy; + + state.draft_ = proxy; + state.revoke_ = revoke; + return proxy; + } + /** + * Object drafts + */ + + var objectTraps = { + get: function get(state, prop) { + if (prop === DRAFT_STATE) return state; + var source = latest(state); + + if (!has(source, prop)) { + // non-existing or non-own property... + return readPropFromProto(state, source, prop); + } + + var value = source[prop]; + + if (state.finalized_ || !isDraftable(value)) { + return value; + } // Check for existing draft in modified state. + // Assigned values are never drafted. This catches any drafts we created, too. + + + if (value === peek(state.base_, prop)) { + prepareCopy(state); + return state.copy_[prop] = createProxy(state.scope_.immer_, value, state); + } + + return value; + }, + has: function has(state, prop) { + return prop in latest(state); + }, + ownKeys: function ownKeys(state) { + return Reflect.ownKeys(latest(state)); + }, + set: function set(state, prop + /* strictly not, but helps TS */ + , value) { + var desc = getDescriptorFromProto(latest(state), prop); + + if (desc === null || desc === void 0 ? void 0 : desc.set) { + // special case: if this write is captured by a setter, we have + // to trigger it with the correct context + desc.set.call(state.draft_, value); + return true; + } + + if (!state.modified_) { + // the last check is because we need to be able to distinguish setting a non-existing to undefined (which is a change) + // from setting an existing property with value undefined to undefined (which is not a change) + var current = peek(latest(state), prop); // special case, if we assigning the original value to a draft, we can ignore the assignment + + var currentState = current === null || current === void 0 ? void 0 : current[DRAFT_STATE]; + + if (currentState && currentState.base_ === value) { + state.copy_[prop] = value; + state.assigned_[prop] = false; + return true; + } + + if (is$1(value, current) && (value !== undefined || has(state.base_, prop))) return true; + prepareCopy(state); + markChanged(state); + } + + if (state.copy_[prop] === value && // special case: NaN + typeof value !== "number" && ( // special case: handle new props with value 'undefined' + value !== undefined || prop in state.copy_)) return true; // @ts-ignore + + state.copy_[prop] = value; + state.assigned_[prop] = true; + return true; + }, + deleteProperty: function deleteProperty(state, prop) { + // The `undefined` check is a fast path for pre-existing keys. + if (peek(state.base_, prop) !== undefined || prop in state.base_) { + state.assigned_[prop] = false; + prepareCopy(state); + markChanged(state); + } else { + // if an originally not assigned property was deleted + delete state.assigned_[prop]; + } // @ts-ignore + + + if (state.copy_) delete state.copy_[prop]; + return true; + }, + // Note: We never coerce `desc.value` into an Immer draft, because we can't make + // the same guarantee in ES5 mode. + getOwnPropertyDescriptor: function getOwnPropertyDescriptor(state, prop) { + var owner = latest(state); + var desc = Reflect.getOwnPropertyDescriptor(owner, prop); + if (!desc) return desc; + return { + writable: true, + configurable: state.type_ !== 1 + /* ProxyArray */ + || prop !== "length", + enumerable: desc.enumerable, + value: owner[prop] + }; + }, + defineProperty: function defineProperty() { + die(11); + }, + getPrototypeOf: function getPrototypeOf(state) { + return Object.getPrototypeOf(state.base_); + }, + setPrototypeOf: function setPrototypeOf() { + die(12); + } + }; + /** + * Array drafts + */ + + var arrayTraps = {}; + each$1(objectTraps, function (key, fn) { + // @ts-ignore + arrayTraps[key] = function () { + arguments[0] = arguments[0][0]; + return fn.apply(this, arguments); + }; + }); + + arrayTraps.deleteProperty = function (state, prop) { + if ( isNaN(parseInt(prop))) die(13); + return objectTraps.deleteProperty.call(this, state[0], prop); + }; + + arrayTraps.set = function (state, prop, value) { + if ( prop !== "length" && isNaN(parseInt(prop))) die(14); + return objectTraps.set.call(this, state[0], prop, value, state[0]); + }; // Access a property without creating an Immer draft. + + + function peek(draft, prop) { + var state = draft[DRAFT_STATE]; + var source = state ? latest(state) : draft; + return source[prop]; + } + + function readPropFromProto(state, source, prop) { + var _desc$get; + + var desc = getDescriptorFromProto(source, prop); + return desc ? "value" in desc ? desc.value : // This is a very special case, if the prop is a getter defined by the + // prototype, we should invoke it with the draft as context! + (_desc$get = desc.get) === null || _desc$get === void 0 ? void 0 : _desc$get.call(state.draft_) : undefined; + } + + function getDescriptorFromProto(source, prop) { + // 'in' checks proto! + if (!(prop in source)) return undefined; + var proto = Object.getPrototypeOf(source); + + while (proto) { + var desc = Object.getOwnPropertyDescriptor(proto, prop); + if (desc) return desc; + proto = Object.getPrototypeOf(proto); + } + + return undefined; + } + + function markChanged(state) { + if (!state.modified_) { + state.modified_ = true; + + if (state.parent_) { + markChanged(state.parent_); + } + } + } + function prepareCopy(state) { + if (!state.copy_) { + state.copy_ = shallowCopy(state.base_); + } + } + + var Immer = + /*#__PURE__*/ + function () { + function Immer(config) { + var _this = this; + + this.useProxies_ = hasProxies; + this.autoFreeze_ = true; + /** + * The `produce` function takes a value and a "recipe function" (whose + * return value often depends on the base state). The recipe function is + * free to mutate its first argument however it wants. All mutations are + * only ever applied to a __copy__ of the base state. + * + * Pass only a function to create a "curried producer" which relieves you + * from passing the recipe function every time. + * + * Only plain objects and arrays are made mutable. All other objects are + * considered uncopyable. + * + * Note: This function is __bound__ to its `Immer` instance. + * + * @param {any} base - the initial state + * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified + * @param {Function} patchListener - optional function that will be called with all the patches produced here + * @returns {any} a new state, or the initial state if nothing was modified + */ + + this.produce = function (base, recipe, patchListener) { + // curried invocation + if (typeof base === "function" && typeof recipe !== "function") { + var defaultBase = recipe; + recipe = base; + var self = _this; + return function curriedProduce(base) { + var _this2 = this; + + if (base === void 0) { + base = defaultBase; + } + + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + return self.produce(base, function (draft) { + var _recipe; + + return (_recipe = recipe).call.apply(_recipe, [_this2, draft].concat(args)); + }); // prettier-ignore + }; + } + + if (typeof recipe !== "function") die(6); + if (patchListener !== undefined && typeof patchListener !== "function") die(7); + var result; // Only plain objects, arrays, and "immerable classes" are drafted. + + if (isDraftable(base)) { + var scope = enterScope(_this); + var proxy = createProxy(_this, base, undefined); + var hasError = true; + + try { + result = recipe(proxy); + hasError = false; + } finally { + // finally instead of catch + rethrow better preserves original stack + if (hasError) revokeScope(scope);else leaveScope(scope); + } + + if (typeof Promise !== "undefined" && result instanceof Promise) { + return result.then(function (result) { + usePatchesInScope(scope, patchListener); + return processResult(result, scope); + }, function (error) { + revokeScope(scope); + throw error; + }); + } + + usePatchesInScope(scope, patchListener); + return processResult(result, scope); + } else if (!base || typeof base !== "object") { + result = recipe(base); + if (result === NOTHING) return undefined; + if (result === undefined) result = base; + if (_this.autoFreeze_) freeze(result, true); + return result; + } else die(21, base); + }; + + this.produceWithPatches = function (arg1, arg2, arg3) { + if (typeof arg1 === "function") { + return function (state) { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + + return _this.produceWithPatches(state, function (draft) { + return arg1.apply(void 0, [draft].concat(args)); + }); + }; + } + + var patches, inversePatches; + + var nextState = _this.produce(arg1, arg2, function (p, ip) { + patches = p; + inversePatches = ip; + }); + + return [nextState, patches, inversePatches]; + }; + + if (typeof (config === null || config === void 0 ? void 0 : config.useProxies) === "boolean") this.setUseProxies(config.useProxies); + if (typeof (config === null || config === void 0 ? void 0 : config.autoFreeze) === "boolean") this.setAutoFreeze(config.autoFreeze); + } + + var _proto = Immer.prototype; + + _proto.createDraft = function createDraft(base) { + if (!isDraftable(base)) die(8); + if (isDraft(base)) base = current(base); + var scope = enterScope(this); + var proxy = createProxy(this, base, undefined); + proxy[DRAFT_STATE].isManual_ = true; + leaveScope(scope); + return proxy; + }; + + _proto.finishDraft = function finishDraft(draft, patchListener) { + var state = draft && draft[DRAFT_STATE]; + + { + if (!state || !state.isManual_) die(9); + if (state.finalized_) die(10); + } + + var scope = state.scope_; + usePatchesInScope(scope, patchListener); + return processResult(undefined, scope); + } + /** + * Pass true to automatically freeze all copies created by Immer. + * + * By default, auto-freezing is enabled. + */ + ; + + _proto.setAutoFreeze = function setAutoFreeze(value) { + this.autoFreeze_ = value; + } + /** + * Pass true to use the ES2015 `Proxy` class when creating drafts, which is + * always faster than using ES5 proxies. + * + * By default, feature detection is used, so calling this is rarely necessary. + */ + ; + + _proto.setUseProxies = function setUseProxies(value) { + if (value && !hasProxies) { + die(20); + } + + this.useProxies_ = value; + }; + + _proto.applyPatches = function applyPatches(base, patches) { + // If a patch replaces the entire state, take that replacement as base + // before applying patches + var i; + + for (i = patches.length - 1; i >= 0; i--) { + var patch = patches[i]; + + if (patch.path.length === 0 && patch.op === "replace") { + base = patch.value; + break; + } + } // If there was a patch that replaced the entire state, start from the + // patch after that. + + + if (i > -1) { + patches = patches.slice(i + 1); + } + + var applyPatchesImpl = getPlugin("Patches").applyPatches_; + + if (isDraft(base)) { + // N.B: never hits if some patch a replacement, patches are never drafts + return applyPatchesImpl(base, patches); + } // Otherwise, produce a copy of the base state. + + + return this.produce(base, function (draft) { + return applyPatchesImpl(draft, patches); + }); + }; + + return Immer; + }(); + function createProxy(immer, value, parent) { + // precondition: createProxy should be guarded by isDraftable, so we know we can safely draft + var draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : immer.useProxies_ ? createProxyProxy(value, parent) : getPlugin("ES5").createES5Proxy_(value, parent); + var scope = parent ? parent.scope_ : getCurrentScope(); + scope.drafts_.push(draft); + return draft; + } + + function current(value) { + if (!isDraft(value)) die(22, value); + return currentImpl(value); + } + + function currentImpl(value) { + if (!isDraftable(value)) return value; + var state = value[DRAFT_STATE]; + var copy; + var archType = getArchtype(value); + + if (state) { + if (!state.modified_ && (state.type_ < 4 || !getPlugin("ES5").hasChanges_(state))) return state.base_; // Optimization: avoid generating new drafts during copying + + state.finalized_ = true; + copy = copyHelper(value, archType); + state.finalized_ = false; + } else { + copy = copyHelper(value, archType); + } + + each$1(copy, function (key, childValue) { + if (state && get(state.base_, key) === childValue) return; // no need to copy or search in something that didn't change + + set(copy, key, currentImpl(childValue)); + }); // In the future, we might consider freezing here, based on the current settings + + return archType === 3 + /* Set */ + ? new Set(copy) : copy; + } + + function copyHelper(value, archType) { + // creates a shallow copy, even if it is a map or set + switch (archType) { + case 2 + /* Map */ + : + return new Map(value); + + case 3 + /* Set */ + : + // Set will be cloned as array temporarily, so that we can replace individual items + return Array.from(value); + } + + return shallowCopy(value); + } + + function enableES5() { + function willFinalizeES5_(scope, result, isReplaced) { + if (!isReplaced) { + if (scope.patches_) { + markChangesRecursively(scope.drafts_[0]); + } // This is faster when we don't care about which attributes changed. + + + markChangesSweep(scope.drafts_); + } // When a child draft is returned, look for changes. + else if (isDraft(result) && result[DRAFT_STATE].scope_ === scope) { + markChangesSweep(scope.drafts_); + } + } + + function createES5Draft(isArray, base) { + if (isArray) { + var draft = new Array(base.length); + + for (var i = 0; i < base.length; i++) { + Object.defineProperty(draft, "" + i, proxyProperty(i, true)); + } + + return draft; + } else { + var _descriptors = getOwnPropertyDescriptors(base); + + delete _descriptors[DRAFT_STATE]; + var keys = ownKeys$a(_descriptors); + + for (var _i = 0; _i < keys.length; _i++) { + var key = keys[_i]; + _descriptors[key] = proxyProperty(key, isArray || !!_descriptors[key].enumerable); + } + + return Object.create(Object.getPrototypeOf(base), _descriptors); + } + } + + function createES5Proxy_(base, parent) { + var isArray = Array.isArray(base); + var draft = createES5Draft(isArray, base); + var state = { + type_: isArray ? 5 + /* ES5Array */ + : 4 + /* ES5Object */ + , + scope_: parent ? parent.scope_ : getCurrentScope(), + modified_: false, + finalized_: false, + assigned_: {}, + parent_: parent, + // base is the object we are drafting + base_: base, + // draft is the draft object itself, that traps all reads and reads from either the base (if unmodified) or copy (if modified) + draft_: draft, + copy_: null, + revoked_: false, + isManual_: false + }; + Object.defineProperty(draft, DRAFT_STATE, { + value: state, + // enumerable: false <- the default + writable: true + }); + return draft; + } // property descriptors are recycled to make sure we don't create a get and set closure per property, + // but share them all instead + + + var descriptors = {}; + + function proxyProperty(prop, enumerable) { + var desc = descriptors[prop]; + + if (desc) { + desc.enumerable = enumerable; + } else { + descriptors[prop] = desc = { + configurable: true, + enumerable: enumerable, + get: function get() { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); // @ts-ignore + + return objectTraps.get(state, prop); + }, + set: function set(value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); // @ts-ignore + + objectTraps.set(state, prop, value); + } + }; + } + + return desc; + } // This looks expensive, but only proxies are visited, and only objects without known changes are scanned. + + + function markChangesSweep(drafts) { + // The natural order of drafts in the `scope` array is based on when they + // were accessed. By processing drafts in reverse natural order, we have a + // better chance of processing leaf nodes first. When a leaf node is known to + // have changed, we can avoid any traversal of its ancestor nodes. + for (var i = drafts.length - 1; i >= 0; i--) { + var state = drafts[i][DRAFT_STATE]; + + if (!state.modified_) { + switch (state.type_) { + case 5 + /* ES5Array */ + : + if (hasArrayChanges(state)) markChanged(state); + break; + + case 4 + /* ES5Object */ + : + if (hasObjectChanges(state)) markChanged(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_ === 4 + /* ES5Object */ + ) { + // Look for added keys. + // probably there is a faster way to detect changes, as sweep + recurse seems to do some + // unnecessary work. + // also: probably we can store the information we detect here, to speed up tree finalization! + each$1(draft_, function (key) { + if (key === DRAFT_STATE) return; // The `undefined` check is a fast path for pre-existing keys. + + if (base_[key] === undefined && !has(base_, key)) { + assigned_[key] = true; + markChanged(state); + } else if (!assigned_[key]) { + // Only untouched properties trigger recursion. + markChangesRecursively(draft_[key]); + } + }); // Look for removed keys. + + each$1(base_, function (key) { + // The `undefined` check is a fast path for pre-existing keys. + if (draft_[key] === undefined && !has(draft_, key)) { + assigned_[key] = false; + markChanged(state); + } + }); + } else if (type_ === 5 + /* ES5Array */ + ) { + if (hasArrayChanges(state)) { + markChanged(state); + assigned_.length = true; + } + + if (draft_.length < base_.length) { + for (var i = draft_.length; i < base_.length; i++) { + assigned_[i] = false; + } + } else { + for (var _i2 = base_.length; _i2 < draft_.length; _i2++) { + assigned_[_i2] = true; + } + } // Minimum count is enough, the other parts has been processed. + + + var min = Math.min(draft_.length, base_.length); + + for (var _i3 = 0; _i3 < min; _i3++) { + // Only untouched indices trigger recursion. + if (assigned_[_i3] === undefined) markChangesRecursively(draft_[_i3]); + } + } + } + + function hasObjectChanges(state) { + var base_ = state.base_, + draft_ = state.draft_; // Search for added keys and changed keys. Start at the back, because + // non-numeric keys are ordered by time of definition on the object. + + var keys = ownKeys$a(draft_); + + for (var i = keys.length - 1; i >= 0; i--) { + var key = keys[i]; + if (key === DRAFT_STATE) continue; + var baseValue = base_[key]; // The `undefined` check is a fast path for pre-existing keys. + + if (baseValue === undefined && !has(base_, key)) { + return true; + } // Once a base key is deleted, future changes go undetected, because its + // descriptor is erased. This branch detects any missed changes. + else { + var value = draft_[key]; + + var _state = value && value[DRAFT_STATE]; + + if (_state ? _state.base_ !== baseValue : !is$1(value, baseValue)) { + return true; + } + } + } // At this point, no keys were added or changed. + // Compare key count to determine if keys were deleted. + + + var baseIsDraft = !!base_[DRAFT_STATE]; + return keys.length !== ownKeys$a(base_).length + (baseIsDraft ? 0 : 1); // + 1 to correct for DRAFT_STATE + } + + function hasArrayChanges(state) { + var draft_ = state.draft_; + if (draft_.length !== state.base_.length) return true; // See #116 + // If we first shorten the length, our array interceptors will be removed. + // If after that new items are added, result in the same original length, + // those last items will have no intercepting property. + // So if there is no own descriptor on the last position, we know that items were removed and added + // N.B.: splice, unshift, etc only shift values around, but not prop descriptors, so we only have to check + // the last one + + var descriptor = Object.getOwnPropertyDescriptor(draft_, draft_.length - 1); // descriptor can be null, but only for newly created sparse arrays, eg. new Array(10) + + if (descriptor && !descriptor.get) return true; // For all other cases, we don't have to compare, as they would have been picked up by the index setters + + return false; + } + + function hasChanges_(state) { + return state.type_ === 4 + /* ES5Object */ + ? hasObjectChanges(state) : hasArrayChanges(state); + } + + function assertUnrevoked(state + /*ES5State | MapState | SetState*/ + ) { + if (state.revoked_) die(3, JSON.stringify(latest(state))); + } + + loadPlugin("ES5", { + createES5Proxy_: createES5Proxy_, + willFinalizeES5_: willFinalizeES5_, + hasChanges_: hasChanges_ + }); + } + + function enablePatches() { + var REPLACE = "replace"; + var ADD = "add"; + var REMOVE = "remove"; + + function generatePatches_(state, basePath, patches, inversePatches) { + switch (state.type_) { + case 0 + /* ProxyObject */ + : + case 4 + /* ES5Object */ + : + case 2 + /* Map */ + : + return generatePatchesFromAssigned(state, basePath, patches, inversePatches); + + case 5 + /* ES5Array */ + : + case 1 + /* ProxyArray */ + : + return generateArrayPatches(state, basePath, patches, inversePatches); + + case 3 + /* Set */ + : + return generateSetPatches(state, basePath, patches, inversePatches); + } + } + + function generateArrayPatches(state, basePath, patches, inversePatches) { + var base_ = state.base_, + assigned_ = state.assigned_; + var copy_ = state.copy_; // Reduce complexity by ensuring `base` is never longer. + + if (copy_.length < base_.length) { + var _ref = [copy_, base_]; + base_ = _ref[0]; + copy_ = _ref[1]; + var _ref2 = [inversePatches, patches]; + patches = _ref2[0]; + inversePatches = _ref2[1]; + } // Process replaced indices. + + + for (var i = 0; i < base_.length; i++) { + if (assigned_[i] && copy_[i] !== base_[i]) { + var path = basePath.concat([i]); + patches.push({ + op: REPLACE, + path: path, + // Need to maybe clone it, as it can in fact be the original value + // due to the base/copy inversion at the start of this function + value: clonePatchValueIfNeeded(copy_[i]) + }); + inversePatches.push({ + op: REPLACE, + path: path, + value: clonePatchValueIfNeeded(base_[i]) + }); + } + } // Process added indices. + + + for (var _i = base_.length; _i < copy_.length; _i++) { + var _path = basePath.concat([_i]); + + patches.push({ + op: ADD, + path: _path, + // Need to maybe clone it, as it can in fact be the original value + // due to the base/copy inversion at the start of this function + value: clonePatchValueIfNeeded(copy_[_i]) + }); + } + + if (base_.length < copy_.length) { + inversePatches.push({ + op: REPLACE, + path: basePath.concat(["length"]), + value: base_.length + }); + } + } // This is used for both Map objects and normal objects. + + + function generatePatchesFromAssigned(state, basePath, patches, inversePatches) { + var base_ = state.base_, + copy_ = state.copy_; + each$1(state.assigned_, function (key, assignedValue) { + var origValue = get(base_, key); + var value = get(copy_, key); + var op = !assignedValue ? REMOVE : has(base_, key) ? REPLACE : ADD; + if (origValue === value && op === REPLACE) return; + var path = basePath.concat(key); + patches.push(op === REMOVE ? { + op: op, + path: path + } : { + op: op, + path: path, + value: value + }); + inversePatches.push(op === ADD ? { + op: REMOVE, + path: path + } : op === REMOVE ? { + op: ADD, + path: path, + value: clonePatchValueIfNeeded(origValue) + } : { + op: REPLACE, + path: path, + value: clonePatchValueIfNeeded(origValue) + }); + }); + } + + function generateSetPatches(state, basePath, patches, inversePatches) { + var base_ = state.base_, + copy_ = state.copy_; + var i = 0; + base_.forEach(function (value) { + if (!copy_.has(value)) { + var path = basePath.concat([i]); + patches.push({ + op: REMOVE, + path: path, + value: value + }); + inversePatches.unshift({ + op: ADD, + path: path, + value: value + }); + } + + i++; + }); + i = 0; + copy_.forEach(function (value) { + if (!base_.has(value)) { + var path = basePath.concat([i]); + patches.push({ + op: ADD, + path: path, + value: value + }); + inversePatches.unshift({ + op: REMOVE, + path: path, + value: value + }); + } + + i++; + }); + } + + function generateReplacementPatches_(rootState, replacement, patches, inversePatches) { + patches.push({ + op: REPLACE, + path: [], + value: replacement === NOTHING ? undefined : replacement + }); + inversePatches.push({ + op: REPLACE, + path: [], + value: rootState.base_ + }); + } + + function applyPatches_(draft, patches) { + patches.forEach(function (patch) { + var path = patch.path, + op = patch.op; + var base = draft; + + for (var i = 0; i < path.length - 1; i++) { + var parentType = getArchtype(base); + var p = "" + path[i]; // See #738, avoid prototype pollution + + if ((parentType === 0 + /* Object */ + || parentType === 1 + /* Array */ + ) && (p === "__proto__" || p === "constructor")) die(24); + if (typeof base === "function" && p === "prototype") die(24); + base = get(base, p); + if (typeof base !== "object") die(15, path.join("/")); + } + + var type = getArchtype(base); + var value = deepClonePatchValue(patch.value); // used to clone patch to ensure original patch is not modified, see #411 + + var key = path[path.length - 1]; + + switch (op) { + case REPLACE: + switch (type) { + case 2 + /* Map */ + : + return base.set(key, value); + + /* istanbul ignore next */ + + case 3 + /* Set */ + : + die(16); + + default: + // if value is an object, then it's assigned by reference + // in the following add or remove ops, the value field inside the patch will also be modifyed + // so we use value from the cloned patch + // @ts-ignore + return base[key] = value; + } + + case ADD: + switch (type) { + case 1 + /* Array */ + : + return key === "-" ? base.push(value) : base.splice(key, 0, value); + + case 2 + /* Map */ + : + return base.set(key, value); + + case 3 + /* Set */ + : + return base.add(value); + + default: + return base[key] = value; + } + + case REMOVE: + switch (type) { + case 1 + /* Array */ + : + return base.splice(key, 1); + + case 2 + /* Map */ + : + return base.delete(key); + + case 3 + /* Set */ + : + return base.delete(patch.value); + + default: + return delete base[key]; + } + + default: + die(17, op); + } + }); + return draft; + } + + function deepClonePatchValue(obj) { + if (!isDraftable(obj)) return obj; + if (Array.isArray(obj)) return obj.map(deepClonePatchValue); + if (isMap(obj)) return new Map(Array.from(obj.entries()).map(function (_ref3) { + var k = _ref3[0], + v = _ref3[1]; + return [k, deepClonePatchValue(v)]; + })); + if (isSet(obj)) return new Set(Array.from(obj).map(deepClonePatchValue)); + var cloned = Object.create(Object.getPrototypeOf(obj)); + + for (var key in obj) { + cloned[key] = deepClonePatchValue(obj[key]); + } + + if (has(obj, DRAFTABLE)) cloned[DRAFTABLE] = obj[DRAFTABLE]; + return cloned; + } + + function clonePatchValueIfNeeded(obj) { + if (isDraft(obj)) { + return deepClonePatchValue(obj); + } else return obj; + } + + loadPlugin("Patches", { + applyPatches_: applyPatches_, + generatePatches_: generatePatches_, + generateReplacementPatches_: generateReplacementPatches_ + }); + } + + // types only! + function enableMapSet() { + /* istanbul ignore next */ + var _extendStatics = function extendStatics(d, b) { + _extendStatics = Object.setPrototypeOf || { + __proto__: [] + } instanceof Array && function (d, b) { + d.__proto__ = b; + } || function (d, b) { + for (var p in b) { + if (b.hasOwnProperty(p)) d[p] = b[p]; + } + }; + + return _extendStatics(d, b); + }; // Ugly hack to resolve #502 and inherit built in Map / Set + + + function __extends(d, b) { + _extendStatics(d, b); + + function __() { + this.constructor = d; + } + + d.prototype = ( // @ts-ignore + __.prototype = b.prototype, new __()); + } + + var DraftMap = function (_super) { + __extends(DraftMap, _super); // Create class manually, cause #502 + + + function DraftMap(target, parent) { + this[DRAFT_STATE] = { + type_: 2 + /* Map */ + , + parent_: parent, + scope_: parent ? parent.scope_ : getCurrentScope(), + modified_: false, + finalized_: false, + copy_: undefined, + assigned_: undefined, + base_: target, + draft_: this, + isManual_: false, + revoked_: false + }; + return this; + } + + var p = DraftMap.prototype; + Object.defineProperty(p, "size", { + get: function get() { + return latest(this[DRAFT_STATE]).size; + } // enumerable: false, + // configurable: true + + }); + + p.has = function (key) { + return latest(this[DRAFT_STATE]).has(key); + }; + + p.set = function (key, value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + + if (!latest(state).has(key) || latest(state).get(key) !== value) { + prepareMapCopy(state); + markChanged(state); + state.assigned_.set(key, true); + state.copy_.set(key, value); + state.assigned_.set(key, true); + } + + return this; + }; + + p.delete = function (key) { + if (!this.has(key)) { + return false; + } + + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareMapCopy(state); + markChanged(state); + state.assigned_.set(key, false); + state.copy_.delete(key); + return true; + }; + + p.clear = function () { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + + if (latest(state).size) { + prepareMapCopy(state); + markChanged(state); + state.assigned_ = new Map(); + each$1(state.base_, function (key) { + state.assigned_.set(key, false); + }); + state.copy_.clear(); + } + }; + + p.forEach = function (cb, thisArg) { + var _this = this; + + var state = this[DRAFT_STATE]; + latest(state).forEach(function (_value, key, _map) { + cb.call(thisArg, _this.get(key), key, _this); + }); + }; + + p.get = function (key) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + var value = latest(state).get(key); + + if (state.finalized_ || !isDraftable(value)) { + return value; + } + + if (value !== state.base_.get(key)) { + return value; // either already drafted or reassigned + } // despite what it looks, this creates a draft only once, see above condition + + + var draft = createProxy(state.scope_.immer_, value, state); + prepareMapCopy(state); + state.copy_.set(key, draft); + return draft; + }; + + p.keys = function () { + return latest(this[DRAFT_STATE]).keys(); + }; + + p.values = function () { + var _this2 = this, + _ref; + + var iterator = this.keys(); + return _ref = {}, _ref[iteratorSymbol$1] = function () { + return _this2.values(); + }, _ref.next = function next() { + var r = iterator.next(); + /* istanbul ignore next */ + + if (r.done) return r; + + var value = _this2.get(r.value); + + return { + done: false, + value: value + }; + }, _ref; + }; + + p.entries = function () { + var _this3 = this, + _ref2; + + var iterator = this.keys(); + return _ref2 = {}, _ref2[iteratorSymbol$1] = function () { + return _this3.entries(); + }, _ref2.next = function next() { + var r = iterator.next(); + /* istanbul ignore next */ + + if (r.done) return r; + + var value = _this3.get(r.value); + + return { + done: false, + value: [r.value, value] + }; + }, _ref2; + }; + + p[iteratorSymbol$1] = function () { + return this.entries(); + }; + + return DraftMap; + }(Map); + + function proxyMap_(target, parent) { + // @ts-ignore + return new DraftMap(target, parent); + } + + function prepareMapCopy(state) { + if (!state.copy_) { + state.assigned_ = new Map(); + state.copy_ = new Map(state.base_); + } + } + + var DraftSet = function (_super) { + __extends(DraftSet, _super); // Create class manually, cause #502 + + + function DraftSet(target, parent) { + this[DRAFT_STATE] = { + type_: 3 + /* Set */ + , + parent_: parent, + scope_: parent ? parent.scope_ : getCurrentScope(), + modified_: false, + finalized_: false, + copy_: undefined, + base_: target, + draft_: this, + drafts_: new Map(), + revoked_: false, + isManual_: false + }; + return this; + } + + var p = DraftSet.prototype; + Object.defineProperty(p, "size", { + get: function get() { + return latest(this[DRAFT_STATE]).size; + } // enumerable: true, + + }); + + p.has = function (value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); // bit of trickery here, to be able to recognize both the value, and the draft of its value + + if (!state.copy_) { + return state.base_.has(value); + } + + if (state.copy_.has(value)) return true; + if (state.drafts_.has(value) && state.copy_.has(state.drafts_.get(value))) return true; + return false; + }; + + p.add = function (value) { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + + if (!this.has(value)) { + prepareSetCopy(state); + markChanged(state); + state.copy_.add(value); + } + + return this; + }; + + p.delete = function (value) { + if (!this.has(value)) { + return false; + } + + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareSetCopy(state); + markChanged(state); + return state.copy_.delete(value) || (state.drafts_.has(value) ? state.copy_.delete(state.drafts_.get(value)) : + /* istanbul ignore next */ + false); + }; + + p.clear = function () { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + + if (latest(state).size) { + prepareSetCopy(state); + markChanged(state); + state.copy_.clear(); + } + }; + + p.values = function () { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareSetCopy(state); + return state.copy_.values(); + }; + + p.entries = function entries() { + var state = this[DRAFT_STATE]; + assertUnrevoked(state); + prepareSetCopy(state); + return state.copy_.entries(); + }; + + p.keys = function () { + return this.values(); + }; + + p[iteratorSymbol$1] = function () { + return this.values(); + }; + + p.forEach = function forEach(cb, thisArg) { + var iterator = this.values(); + var result = iterator.next(); + + while (!result.done) { + cb.call(thisArg, result.value, result.value, this); + result = iterator.next(); + } + }; + + return DraftSet; + }(Set); + + function proxySet_(target, parent) { + // @ts-ignore + return new DraftSet(target, parent); + } + + function prepareSetCopy(state) { + if (!state.copy_) { + // create drafts for all entries to preserve insertion order + state.copy_ = new Set(); + state.base_.forEach(function (value) { + if (isDraftable(value)) { + var draft = createProxy(state.scope_.immer_, value, state); + state.drafts_.set(value, draft); + state.copy_.add(draft); + } else { + state.copy_.add(value); + } + }); + } + } + + function assertUnrevoked(state + /*ES5State | MapState | SetState*/ + ) { + if (state.revoked_) die(3, JSON.stringify(latest(state))); + } + + loadPlugin("MapSet", { + proxyMap_: proxyMap_, + proxySet_: proxySet_ + }); + } + + function enableAllPlugins() { + enableES5(); + enableMapSet(); + enablePatches(); + } + + var immer$1 = + /*#__PURE__*/ + new Immer(); + /** + * The `produce` function takes a value and a "recipe function" (whose + * return value often depends on the base state). The recipe function is + * free to mutate its first argument however it wants. All mutations are + * only ever applied to a __copy__ of the base state. + * + * Pass only a function to create a "curried producer" which relieves you + * from passing the recipe function every time. + * + * Only plain objects and arrays are made mutable. All other objects are + * considered uncopyable. + * + * Note: This function is __bound__ to its `Immer` instance. + * + * @param {any} base - the initial state + * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified + * @param {Function} patchListener - optional function that will be called with all the patches produced here + * @returns {any} a new state, or the initial state if nothing was modified + */ + + var produce = immer$1.produce; + /** + * Like `produce`, but `produceWithPatches` always returns a tuple + * [nextState, patches, inversePatches] (instead of just the next state) + */ + + var produceWithPatches = + /*#__PURE__*/ + immer$1.produceWithPatches.bind(immer$1); + /** + * Pass true to automatically freeze all copies created by Immer. + * + * Always freeze by default, even in production mode + */ + + var setAutoFreeze = + /*#__PURE__*/ + immer$1.setAutoFreeze.bind(immer$1); + /** + * Pass true to use the ES2015 `Proxy` class when creating drafts, which is + * always faster than using ES5 proxies. + * + * By default, feature detection is used, so calling this is rarely necessary. + */ + + var setUseProxies = + /*#__PURE__*/ + immer$1.setUseProxies.bind(immer$1); + /** + * Apply an array of Immer patches to the first argument. + * + * This function is a producer, which means copy-on-write is in effect. + */ + + var applyPatches = + /*#__PURE__*/ + immer$1.applyPatches.bind(immer$1); + /** + * Create an Immer draft from the given base state, which may be a draft itself. + * The draft can be modified until you finalize it with the `finishDraft` function. + */ + + var createDraft = + /*#__PURE__*/ + immer$1.createDraft.bind(immer$1); + /** + * Finalize an Immer draft from a `createDraft` call, returning the base state + * (if no changes were made) or a modified copy. The draft must *not* be + * mutated afterwards. + * + * Pass a function as the 2nd argument to generate Immer patches based on the + * changes that were made. + */ + + var finishDraft = + /*#__PURE__*/ + immer$1.finishDraft.bind(immer$1); + /** + * This function is actually a no-op, but can be used to cast an immutable type + * to an draft type and make TypeScript happy + * + * @param value + */ + + function castDraft(value) { + return value; + } + /** + * This function is actually a no-op, but can be used to cast a mutable type + * to an immutable type and make TypeScript happy + * @param value + */ + + function castImmutable(value) { + return value; + } + + var Immer_1 = Immer; + var applyPatches_1 = applyPatches; + var castDraft_1 = castDraft; + var castImmutable_1 = castImmutable; + var createDraft_1 = createDraft; + var current_1 = current; + var _default$2 = produce; + var enableAllPlugins_1 = enableAllPlugins; + var enableES5_1 = enableES5; + var enableMapSet_1 = enableMapSet; + var enablePatches_1 = enablePatches; + var finishDraft_1 = finishDraft; + var freeze_1 = freeze; + var immerable = DRAFTABLE; + var isDraft_1 = isDraft; + var isDraftable_1 = isDraftable; + var nothing = NOTHING; + var original_1 = original; + var produce_1 = produce; + var produceWithPatches_1 = produceWithPatches; + var setAutoFreeze_1 = setAutoFreeze; + var setUseProxies_1 = setUseProxies; + + + var immer_cjs_development = /*#__PURE__*/Object.defineProperty({ + Immer: Immer_1, + applyPatches: applyPatches_1, + castDraft: castDraft_1, + castImmutable: castImmutable_1, + createDraft: createDraft_1, + current: current_1, + default: _default$2, + enableAllPlugins: enableAllPlugins_1, + enableES5: enableES5_1, + enableMapSet: enableMapSet_1, + enablePatches: enablePatches_1, + finishDraft: finishDraft_1, + freeze: freeze_1, + immerable: immerable, + isDraft: isDraft_1, + isDraftable: isDraftable_1, + nothing: nothing, + original: original_1, + produce: produce_1, + produceWithPatches: produceWithPatches_1, + setAutoFreeze: setAutoFreeze_1, + setUseProxies: setUseProxies_1 + }, '__esModule', {value: true}); + + var require$$1$1 = immer_cjs_development; + + var dist$8 = createCommonjsModule$1(function (module) { + + { + module.exports = require$$1$1; + } + }); + + var isPlainObject = isPlainObject_1; + + var immer = dist$8; + + 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 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["default"] = module.exports, module.exports.__esModule = true; + }); + + unwrapExports(arrayLikeToArray); + + var arrayWithoutHoles = createCommonjsModule(function (module) { + function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return arrayLikeToArray(arr); + } + + module.exports = _arrayWithoutHoles; + module.exports["default"] = module.exports, module.exports.__esModule = true; + }); + + unwrapExports(arrayWithoutHoles); + + var iterableToArray = createCommonjsModule(function (module) { + function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); + } + + module.exports = _iterableToArray; + module.exports["default"] = module.exports, module.exports.__esModule = true; + }); + + unwrapExports(iterableToArray); + + 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["default"] = module.exports, module.exports.__esModule = true; + }); + + unwrapExports(unsupportedIterableToArray); + + var nonIterableSpread = createCommonjsModule(function (module) { + function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + module.exports = _nonIterableSpread; + module.exports["default"] = module.exports, module.exports.__esModule = true; + }); + + unwrapExports(nonIterableSpread); + + var toConsumableArray = createCommonjsModule(function (module) { + function _toConsumableArray(arr) { + return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread(); + } + + module.exports = _toConsumableArray; + module.exports["default"] = module.exports, module.exports.__esModule = true; + }); + + var _toConsumableArray = unwrapExports(toConsumableArray); + + var arrayWithHoles = createCommonjsModule(function (module) { + function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; + } + + module.exports = _arrayWithHoles; + module.exports["default"] = module.exports, module.exports.__esModule = true; + }); + + unwrapExports(arrayWithHoles); + + var iterableToArrayLimit = createCommonjsModule(function (module) { + function _iterableToArrayLimit(arr, i) { + var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; + + if (_i == null) return; + var _arr = []; + var _n = true; + var _d = false; + + var _s, _e; + + try { + for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; + } + + module.exports = _iterableToArrayLimit; + module.exports["default"] = module.exports, module.exports.__esModule = true; + }); + + unwrapExports(iterableToArrayLimit); + + 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["default"] = module.exports, module.exports.__esModule = true; + }); + + 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["default"] = module.exports, module.exports.__esModule = true; + }); + + var _slicedToArray = unwrapExports(slicedToArray); + + var defineProperty = createCommonjsModule(function (module) { + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; + } + + module.exports = _defineProperty; + module.exports["default"] = module.exports, module.exports.__esModule = true; + }); + + var _defineProperty = unwrapExports(defineProperty); + + var DIRTY_PATHS = new WeakMap(); + var FLUSHING = new WeakMap(); + var NORMALIZING = new WeakMap(); + var PATH_REFS = new WeakMap(); + var POINT_REFS = new WeakMap(); + var RANGE_REFS = new WeakMap(); + + function ownKeys$9(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + + function _objectSpread$9(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$9(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$9(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + + function _createForOfIteratorHelper$7(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$7(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } + + function _unsupportedIterableToArray$7(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$7(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$7(o, minLen); } + + function _arrayLikeToArray$7(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; } + /** + * Create a new Slate `Editor` object. + */ + + var createEditor$1 = function createEditor() { + var editor = { + children: [], + operations: [], + selection: null, + marks: null, + isInline: function isInline() { + return false; + }, + isVoid: function isVoid() { + return false; + }, + onChange: function onChange() {}, + apply: function apply(op) { + var _iterator = _createForOfIteratorHelper$7(Editor.pathRefs(editor)), + _step; + + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var ref = _step.value; + PathRef.transform(ref, op); + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } + + var _iterator2 = _createForOfIteratorHelper$7(Editor.pointRefs(editor)), + _step2; + + try { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { + var _ref = _step2.value; + PointRef.transform(_ref, op); + } + } catch (err) { + _iterator2.e(err); + } finally { + _iterator2.f(); + } + + var _iterator3 = _createForOfIteratorHelper$7(Editor.rangeRefs(editor)), + _step3; + + try { + for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) { + var _ref2 = _step3.value; + RangeRef.transform(_ref2, op); + } + } catch (err) { + _iterator3.e(err); + } finally { + _iterator3.f(); + } + + var set = new Set(); + var dirtyPaths = []; + + var add = function add(path) { + if (path) { + var key = path.join(','); + + if (!set.has(key)) { + set.add(key); + dirtyPaths.push(path); + } + } + }; + + var oldDirtyPaths = DIRTY_PATHS.get(editor) || []; + var newDirtyPaths = getDirtyPaths(op); + + var _iterator4 = _createForOfIteratorHelper$7(oldDirtyPaths), + _step4; + + try { + for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) { + var path = _step4.value; + var newPath = Path.transform(path, op); + add(newPath); + } + } catch (err) { + _iterator4.e(err); + } finally { + _iterator4.f(); + } + + var _iterator5 = _createForOfIteratorHelper$7(newDirtyPaths), + _step5; + + try { + for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) { + var _path = _step5.value; + add(_path); + } + } catch (err) { + _iterator5.e(err); + } finally { + _iterator5.f(); + } + + DIRTY_PATHS.set(editor, dirtyPaths); + Transforms.transform(editor, op); + editor.operations.push(op); + Editor.normalize(editor); // Clear any formats applied to the cursor if the selection changes. + + if (op.type === 'set_selection') { + editor.marks = null; + } + + if (!FLUSHING.get(editor)) { + FLUSHING.set(editor, true); + Promise.resolve().then(function () { + FLUSHING.set(editor, false); + editor.onChange(); + editor.operations = []; + }); + } + }, + addMark: function addMark(key, value) { + var selection = editor.selection; + + if (selection) { + if (Range.isExpanded(selection)) { + Transforms.setNodes(editor, _defineProperty({}, key, value), { + match: Text.isText, + split: true + }); + } else { + var marks = _objectSpread$9(_objectSpread$9({}, Editor.marks(editor) || {}), {}, _defineProperty({}, key, value)); + + editor.marks = marks; + + if (!FLUSHING.get(editor)) { + editor.onChange(); + } + } + } + }, + deleteBackward: function deleteBackward(unit) { + var selection = editor.selection; + + if (selection && Range.isCollapsed(selection)) { + Transforms["delete"](editor, { + unit: unit, + reverse: true + }); + } + }, + deleteForward: function deleteForward(unit) { + var selection = editor.selection; + + if (selection && Range.isCollapsed(selection)) { + Transforms["delete"](editor, { + unit: unit + }); + } + }, + deleteFragment: function deleteFragment(direction) { + var selection = editor.selection; + + if (selection && Range.isExpanded(selection)) { + Transforms["delete"](editor, { + reverse: direction === 'backward' + }); + } + }, + getFragment: function getFragment() { + var selection = editor.selection; + + if (selection) { + return Node$1.fragment(editor, selection); + } + + return []; + }, + insertBreak: function insertBreak() { + Transforms.splitNodes(editor, { + always: true + }); + }, + insertFragment: function insertFragment(fragment) { + Transforms.insertFragment(editor, fragment); + }, + insertNode: function insertNode(node) { + Transforms.insertNodes(editor, node); + }, + insertText: function insertText(text) { + var selection = editor.selection, + marks = editor.marks; + + if (selection) { + if (marks) { + var node = _objectSpread$9({ + text: text + }, marks); + + Transforms.insertNodes(editor, node); + } else { + Transforms.insertText(editor, text); + } + + editor.marks = null; + } + }, + normalizeNode: function normalizeNode(entry) { + var _entry = _slicedToArray(entry, 2), + node = _entry[0], + path = _entry[1]; // There are no core normalizations for text nodes. + + + if (Text.isText(node)) { + return; + } // Ensure that block and inline nodes have at least one text child. + + + if (Element$1.isElement(node) && node.children.length === 0) { + var child = { + text: '' + }; + Transforms.insertNodes(editor, child, { + at: path.concat(0), + voids: true + }); + return; + } // Determine whether the node should have block or inline children. + + + var shouldHaveInlines = Editor.isEditor(node) ? false : Element$1.isElement(node) && (editor.isInline(node) || node.children.length === 0 || Text.isText(node.children[0]) || editor.isInline(node.children[0])); // Since we'll be applying operations while iterating, keep track of an + // index that accounts for any added/removed nodes. + + var n = 0; + + for (var i = 0; i < node.children.length; i++, n++) { + var currentNode = Node$1.get(editor, path); + if (Text.isText(currentNode)) continue; + var _child = node.children[i]; + var prev = currentNode.children[n - 1]; + var isLast = i === node.children.length - 1; + var isInlineOrText = Text.isText(_child) || Element$1.isElement(_child) && editor.isInline(_child); // Only allow block nodes in the top-level children and parent blocks + // that only contain block nodes. Similarly, only allow inline nodes in + // other inline nodes, or parent blocks that only contain inlines and + // text. + + if (isInlineOrText !== shouldHaveInlines) { + Transforms.removeNodes(editor, { + at: path.concat(n), + voids: true + }); + n--; + } else if (Element$1.isElement(_child)) { + // Ensure that inline nodes are surrounded by text nodes. + if (editor.isInline(_child)) { + if (prev == null || !Text.isText(prev)) { + var newChild = { + text: '' + }; + Transforms.insertNodes(editor, newChild, { + at: path.concat(n), + voids: true + }); + n++; + } else if (isLast) { + var _newChild = { + text: '' + }; + Transforms.insertNodes(editor, _newChild, { + at: path.concat(n + 1), + voids: true + }); + n++; + } + } + } else { + // Merge adjacent text nodes that are empty or match. + if (prev != null && Text.isText(prev)) { + if (Text.equals(_child, prev, { + loose: true + })) { + Transforms.mergeNodes(editor, { + at: path.concat(n), + voids: true + }); + n--; + } else if (prev.text === '') { + Transforms.removeNodes(editor, { + at: path.concat(n - 1), + voids: true + }); + n--; + } else if (_child.text === '') { + Transforms.removeNodes(editor, { + at: path.concat(n), + voids: true + }); + n--; + } + } + } + } + }, + removeMark: function removeMark(key) { + var selection = editor.selection; + + if (selection) { + if (Range.isExpanded(selection)) { + Transforms.unsetNodes(editor, key, { + match: Text.isText, + split: true + }); + } else { + var marks = _objectSpread$9({}, Editor.marks(editor) || {}); + + delete marks[key]; + editor.marks = marks; + + if (!FLUSHING.get(editor)) { + editor.onChange(); + } + } + } + } + }; + return editor; + }; + /** + * Get the "dirty" paths generated from an operation. + */ + + var getDirtyPaths = function getDirtyPaths(op) { + switch (op.type) { + case 'insert_text': + case 'remove_text': + case 'set_node': + { + var path = op.path; + return Path.levels(path); + } + + case 'insert_node': + { + var node = op.node, + _path2 = op.path; + var levels = Path.levels(_path2); + var descendants = Text.isText(node) ? [] : Array.from(Node$1.nodes(node), function (_ref3) { + var _ref4 = _slicedToArray(_ref3, 2), + p = _ref4[1]; + + return _path2.concat(p); + }); + return [].concat(_toConsumableArray(levels), _toConsumableArray(descendants)); + } + + case 'merge_node': + { + var _path3 = op.path; + var ancestors = Path.ancestors(_path3); + var previousPath = Path.previous(_path3); + return [].concat(_toConsumableArray(ancestors), [previousPath]); + } + + case 'move_node': + { + var _path4 = op.path, + newPath = op.newPath; + + if (Path.equals(_path4, newPath)) { + return []; + } + + var oldAncestors = []; + var newAncestors = []; + + var _iterator6 = _createForOfIteratorHelper$7(Path.ancestors(_path4)), + _step6; + + try { + for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) { + var ancestor = _step6.value; + var p = Path.transform(ancestor, op); + oldAncestors.push(p); + } + } catch (err) { + _iterator6.e(err); + } finally { + _iterator6.f(); + } + + var _iterator7 = _createForOfIteratorHelper$7(Path.ancestors(newPath)), + _step7; + + try { + for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) { + var _ancestor = _step7.value; + + var _p = Path.transform(_ancestor, op); + + newAncestors.push(_p); + } + } catch (err) { + _iterator7.e(err); + } finally { + _iterator7.f(); + } + + var newParent = newAncestors[newAncestors.length - 1]; + var newIndex = newPath[newPath.length - 1]; + var resultPath = newParent.concat(newIndex); + return [].concat(oldAncestors, newAncestors, [resultPath]); + } + + case 'remove_node': + { + var _path5 = op.path; + + var _ancestors = Path.ancestors(_path5); + + return _toConsumableArray(_ancestors); + } + + case 'split_node': + { + var _path6 = op.path; + + var _levels = Path.levels(_path6); + + var nextPath = Path.next(_path6); + return [].concat(_toConsumableArray(_levels), [nextPath]); + } + + default: + { + return []; + } + } + }; + + 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["default"] = module.exports, module.exports.__esModule = true; + }); + + 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["default"] = module.exports, module.exports.__esModule = true; + }); + + var _objectWithoutProperties = unwrapExports(objectWithoutProperties); + + function _createForOfIteratorHelper$6(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$6(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } + + function _unsupportedIterableToArray$6(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$6(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$6(o, minLen); } + + function _arrayLikeToArray$6(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; } + + // Character (grapheme cluster) boundaries are determined according to + // the default grapheme cluster boundary specification, extended grapheme clusters variant[1]. + // + // References: + // + // [1] https://www.unicode.org/reports/tr29/#Default_Grapheme_Cluster_Table + // [2] https://www.unicode.org/Public/UCD/latest/ucd/auxiliary/GraphemeBreakProperty.txt + // [3] https://www.unicode.org/Public/UCD/latest/ucd/auxiliary/GraphemeBreakTest.html + // [4] https://www.unicode.org/Public/UCD/latest/ucd/auxiliary/GraphemeBreakTest.txt + + /** + * Get the distance to the end of the first character in a string of text. + */ + var getCharacterDistance = function getCharacterDistance(str) { + var isRTL = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var isLTR = !isRTL; + var codepoints = isRTL ? codepointsIteratorRTL(str) : str; + var left = CodepointType.None; + var right = CodepointType.None; + var distance = 0; // Evaluation of these conditions are deferred. + + var gb11 = null; // Is GB11 applicable? + + var gb12Or13 = null; // Is GB12 or GB13 applicable? + + var _iterator = _createForOfIteratorHelper$6(codepoints), + _step; + + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var _char = _step.value; + + var code = _char.codePointAt(0); + + if (!code) break; + var type = getCodepointType(_char, code); + + var _ref = isLTR ? [right, type] : [type, left]; + + var _ref2 = _slicedToArray(_ref, 2); + + left = _ref2[0]; + right = _ref2[1]; + + if (intersects(left, CodepointType.ZWJ) && intersects(right, CodepointType.ExtPict)) { + if (isLTR) { + gb11 = endsWithEmojiZWJ(str.substring(0, distance)); + } else { + gb11 = endsWithEmojiZWJ(str.substring(0, str.length - distance)); + } + + if (!gb11) break; + } + + if (intersects(left, CodepointType.RI) && intersects(right, CodepointType.RI)) { + if (gb12Or13 !== null) { + gb12Or13 = !gb12Or13; + } else { + if (isLTR) { + gb12Or13 = true; + } else { + gb12Or13 = endsWithOddNumberOfRIs(str.substring(0, str.length - distance)); + } + } + + if (!gb12Or13) break; + } + + if (left !== CodepointType.None && right !== CodepointType.None && isBoundaryPair(left, right)) { + break; + } + + distance += _char.length; + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } + + return distance || 1; + }; + var SPACE = /\s/; + var PUNCTUATION = /[\u0021-\u0023\u0025-\u002A\u002C-\u002F\u003A\u003B\u003F\u0040\u005B-\u005D\u005F\u007B\u007D\u00A1\u00A7\u00AB\u00B6\u00B7\u00BB\u00BF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u0AF0\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166D\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E3B\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]/; + var CHAMELEON = /['\u2018\u2019]/; + /** + * Get the distance to the end of the first word in a string of text. + */ + + var getWordDistance = function getWordDistance(text) { + var isRTL = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var dist = 0; + var started = false; + + while (text.length > 0) { + var charDist = getCharacterDistance(text, isRTL); + + var _splitByCharacterDist = splitByCharacterDistance(text, charDist, isRTL), + _splitByCharacterDist2 = _slicedToArray(_splitByCharacterDist, 2), + _char2 = _splitByCharacterDist2[0], + remaining = _splitByCharacterDist2[1]; + + if (isWordCharacter(_char2, remaining, isRTL)) { + started = true; + dist += charDist; + } else if (!started) { + dist += charDist; + } else { + break; + } + + text = remaining; + } + + return dist; + }; + /** + * Split a string in two parts at a given distance starting from the end when + * `isRTL` is set to `true`. + */ + + var splitByCharacterDistance = function splitByCharacterDistance(str, dist, isRTL) { + if (isRTL) { + var at = str.length - dist; + return [str.slice(at, str.length), str.slice(0, at)]; + } + + return [str.slice(0, dist), str.slice(dist)]; + }; + /** + * Check if a character is a word character. The `remaining` argument is used + * because sometimes you must read subsequent characters to truly determine it. + */ + + var isWordCharacter = function isWordCharacter(_char3, remaining) { + var isRTL = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + + if (SPACE.test(_char3)) { + return false; + } // Chameleons count as word characters as long as they're in a word, so + // recurse to see if the next one is a word character or not. + + + if (CHAMELEON.test(_char3)) { + var charDist = getCharacterDistance(remaining, isRTL); + + var _splitByCharacterDist3 = splitByCharacterDistance(remaining, charDist, isRTL), + _splitByCharacterDist4 = _slicedToArray(_splitByCharacterDist3, 2), + nextChar = _splitByCharacterDist4[0], + nextRemaining = _splitByCharacterDist4[1]; + + if (isWordCharacter(nextChar, nextRemaining, isRTL)) { + return true; + } + } + + if (PUNCTUATION.test(_char3)) { + return false; + } + + return true; + }; + /** + * Iterate on codepoints from right to left. + */ + + + var codepointsIteratorRTL = function* codepointsIteratorRTL(str) { + var end = str.length - 1; + + for (var i = 0; i < str.length; i++) { + var char1 = str.charAt(end - i); + + if (isLowSurrogate(char1.charCodeAt(0))) { + var char2 = str.charAt(end - i - 1); + + if (isHighSurrogate(char2.charCodeAt(0))) { + yield char2 + char1; + i++; + continue; + } + } + + yield char1; + } + }; + /** + * Is `charCode` a high surrogate. + * + * https://en.wikipedia.org/wiki/Universal_Character_Set_characters#Surrogates + */ + + var isHighSurrogate = function isHighSurrogate(charCode) { + return charCode >= 0xd800 && charCode <= 0xdbff; + }; + /** + * Is `charCode` a low surrogate. + * + * https://en.wikipedia.org/wiki/Universal_Character_Set_characters#Surrogates + */ + + + var isLowSurrogate = function isLowSurrogate(charCode) { + return charCode >= 0xdc00 && charCode <= 0xdfff; + }; + + var CodepointType; + + (function (CodepointType) { + CodepointType[CodepointType["None"] = 0] = "None"; + CodepointType[CodepointType["Extend"] = 1] = "Extend"; + CodepointType[CodepointType["ZWJ"] = 2] = "ZWJ"; + CodepointType[CodepointType["RI"] = 4] = "RI"; + CodepointType[CodepointType["Prepend"] = 8] = "Prepend"; + CodepointType[CodepointType["SpacingMark"] = 16] = "SpacingMark"; + CodepointType[CodepointType["L"] = 32] = "L"; + CodepointType[CodepointType["V"] = 64] = "V"; + CodepointType[CodepointType["T"] = 128] = "T"; + CodepointType[CodepointType["LV"] = 256] = "LV"; + CodepointType[CodepointType["LVT"] = 512] = "LVT"; + CodepointType[CodepointType["ExtPict"] = 1024] = "ExtPict"; + CodepointType[CodepointType["Any"] = 2048] = "Any"; + })(CodepointType || (CodepointType = {})); + + var reExtend = /^(?:[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0902\u093A\u093C\u0941-\u0948\u094D\u0951-\u0957\u0962\u0963\u0981\u09BC\u09BE\u09C1-\u09C4\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01\u0A02\u0A3C\u0A41\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81\u0A82\u0ABC\u0AC1-\u0AC5\u0AC7\u0AC8\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01\u0B3C\u0B3E\u0B3F\u0B41-\u0B44\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B82\u0BBE\u0BC0\u0BCD\u0BD7\u0C00\u0C04\u0C3E-\u0C40\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81\u0CBC\u0CBF\u0CC2\u0CC6\u0CCC\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00\u0D01\u0D3B\u0D3C\u0D3E\u0D41-\u0D44\u0D4D\u0D57\u0D62\u0D63\u0D81\u0DCA\u0DCF\u0DD2-\u0DD4\u0DD6\u0DDF\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F71-\u0F7E\u0F80-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102D-\u1030\u1032-\u1037\u1039\u103A\u103D\u103E\u1058\u1059\u105E-\u1060\u1071-\u1074\u1082\u1085\u1086\u108D\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4\u17B5\u17B7-\u17BD\u17C6\u17C9-\u17D3\u17DD\u180B-\u180D\u1885\u1886\u18A9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193B\u1A17\u1A18\u1A1B\u1A56\u1A58-\u1A5E\u1A60\u1A62\u1A65-\u1A6C\u1A73-\u1A7C\u1A7F\u1AB0-\u1AC0\u1B00-\u1B03\u1B34-\u1B3A\u1B3C\u1B42\u1B6B-\u1B73\u1B80\u1B81\u1BA2-\u1BA5\u1BA8\u1BA9\u1BAB-\u1BAD\u1BE6\u1BE8\u1BE9\u1BED\u1BEF-\u1BF1\u1C2C-\u1C33\u1C36\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE0\u1CE2-\u1CE8\u1CED\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u200C\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA825\uA826\uA82C\uA8C4\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA951\uA980-\uA982\uA9B3\uA9B6-\uA9B9\uA9BC\uA9BD\uA9E5\uAA29-\uAA2E\uAA31\uAA32\uAA35\uAA36\uAA43\uAA4C\uAA7C\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEC\uAAED\uAAF6\uABE5\uABE8\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFF9E\uFF9F]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD803[\uDD24-\uDD27\uDEAB\uDEAC\uDF46-\uDF50]|\uD804[\uDC01\uDC38-\uDC46\uDC7F-\uDC81\uDCB3-\uDCB6\uDCB9\uDCBA\uDD00-\uDD02\uDD27-\uDD2B\uDD2D-\uDD34\uDD73\uDD80\uDD81\uDDB6-\uDDBE\uDDC9-\uDDCC\uDDCF\uDE2F-\uDE31\uDE34\uDE36\uDE37\uDE3E\uDEDF\uDEE3-\uDEEA\uDF00\uDF01\uDF3B\uDF3C\uDF3E\uDF40\uDF57\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC38-\uDC3F\uDC42-\uDC44\uDC46\uDC5E\uDCB0\uDCB3-\uDCB8\uDCBA\uDCBD\uDCBF\uDCC0\uDCC2\uDCC3\uDDAF\uDDB2-\uDDB5\uDDBC\uDDBD\uDDBF\uDDC0\uDDDC\uDDDD\uDE33-\uDE3A\uDE3D\uDE3F\uDE40\uDEAB\uDEAD\uDEB0-\uDEB5\uDEB7\uDF1D-\uDF1F\uDF22-\uDF25\uDF27-\uDF2B]|\uD806[\uDC2F-\uDC37\uDC39\uDC3A\uDD30\uDD3B\uDD3C\uDD3E\uDD43\uDDD4-\uDDD7\uDDDA\uDDDB\uDDE0\uDE01-\uDE0A\uDE33-\uDE38\uDE3B-\uDE3E\uDE47\uDE51-\uDE56\uDE59-\uDE5B\uDE8A-\uDE96\uDE98\uDE99]|\uD807[\uDC30-\uDC36\uDC38-\uDC3D\uDC3F\uDC92-\uDCA7\uDCAA-\uDCB0\uDCB2\uDCB3\uDCB5\uDCB6\uDD31-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD45\uDD47\uDD90\uDD91\uDD95\uDD97\uDEF3\uDEF4]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF4F\uDF8F-\uDF92\uDFE4]|\uD82F[\uDC9D\uDC9E]|\uD834[\uDD65\uDD67-\uDD69\uDD6E-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDD30-\uDD36\uDEEC-\uDEEF]|\uD83A[\uDCD0-\uDCD6\uDD44-\uDD4A]|\uD83C[\uDFFB-\uDFFF]|\uDB40[\uDC20-\uDC7F\uDD00-\uDDEF])$/; + var rePrepend = /^(?:[\u0600-\u0605\u06DD\u070F\u0890\u0891\u08E2\u0D4E]|\uD804[\uDCBD\uDCCD\uDDC2\uDDC3]|\uD806[\uDD3F\uDD41\uDE3A\uDE84-\uDE89]|\uD807\uDD46)$/; + var reSpacingMark = /^(?:[\u0903\u093B\u093E-\u0940\u0949-\u094C\u094E\u094F\u0982\u0983\u09BF\u09C0\u09C7\u09C8\u09CB\u09CC\u0A03\u0A3E-\u0A40\u0A83\u0ABE-\u0AC0\u0AC9\u0ACB\u0ACC\u0B02\u0B03\u0B40\u0B47\u0B48\u0B4B\u0B4C\u0BBF\u0BC1\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCC\u0C01-\u0C03\u0C41-\u0C44\u0C82\u0C83\u0CBE\u0CC0\u0CC1\u0CC3\u0CC4\u0CC7\u0CC8\u0CCA\u0CCB\u0D02\u0D03\u0D3F\u0D40\u0D46-\u0D48\u0D4A-\u0D4C\u0D82\u0D83\u0DD0\u0DD1\u0DD8-\u0DDE\u0DF2\u0DF3\u0E33\u0EB3\u0F3E\u0F3F\u0F7F\u1031\u103B\u103C\u1056\u1057\u1084\u1715\u1734\u17B6\u17BE-\u17C5\u17C7\u17C8\u1923-\u1926\u1929-\u192B\u1930\u1931\u1933-\u1938\u1A19\u1A1A\u1A55\u1A57\u1A6D-\u1A72\u1B04\u1B3B\u1B3D-\u1B41\u1B43\u1B44\u1B82\u1BA1\u1BA6\u1BA7\u1BAA\u1BE7\u1BEA-\u1BEC\u1BEE\u1BF2\u1BF3\u1C24-\u1C2B\u1C34\u1C35\u1CE1\u1CF7\uA823\uA824\uA827\uA880\uA881\uA8B4-\uA8C3\uA952\uA953\uA983\uA9B4\uA9B5\uA9BA\uA9BB\uA9BE-\uA9C0\uAA2F\uAA30\uAA33\uAA34\uAA4D\uAAEB\uAAEE\uAAEF\uAAF5\uABE3\uABE4\uABE6\uABE7\uABE9\uABEA\uABEC]|\uD804[\uDC00\uDC02\uDC82\uDCB0-\uDCB2\uDCB7\uDCB8\uDD2C\uDD45\uDD46\uDD82\uDDB3-\uDDB5\uDDBF\uDDC0\uDDCE\uDE2C-\uDE2E\uDE32\uDE33\uDE35\uDEE0-\uDEE2\uDF02\uDF03\uDF3F\uDF41-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF62\uDF63]|\uD805[\uDC35-\uDC37\uDC40\uDC41\uDC45\uDCB1\uDCB2\uDCB9\uDCBB\uDCBC\uDCBE\uDCC1\uDDB0\uDDB1\uDDB8-\uDDBB\uDDBE\uDE30-\uDE32\uDE3B\uDE3C\uDE3E\uDEAC\uDEAE\uDEAF\uDEB6\uDF26]|\uD806[\uDC2C-\uDC2E\uDC38\uDD31-\uDD35\uDD37\uDD38\uDD3D\uDD40\uDD42\uDDD1-\uDDD3\uDDDC-\uDDDF\uDDE4\uDE39\uDE57\uDE58\uDE97]|\uD807[\uDC2F\uDC3E\uDCA9\uDCB1\uDCB4\uDD8A-\uDD8E\uDD93\uDD94\uDD96\uDEF5\uDEF6]|\uD81B[\uDF51-\uDF87\uDFF0\uDFF1]|\uD834[\uDD66\uDD6D])$/; + var reL = /^[\u1100-\u115F\uA960-\uA97C]$/; + var reV = /^[\u1160-\u11A7\uD7B0-\uD7C6]$/; + var reT = /^[\u11A8-\u11FF\uD7CB-\uD7FB]$/; + var reLV = /^[\uAC00\uAC1C\uAC38\uAC54\uAC70\uAC8C\uACA8\uACC4\uACE0\uACFC\uAD18\uAD34\uAD50\uAD6C\uAD88\uADA4\uADC0\uADDC\uADF8\uAE14\uAE30\uAE4C\uAE68\uAE84\uAEA0\uAEBC\uAED8\uAEF4\uAF10\uAF2C\uAF48\uAF64\uAF80\uAF9C\uAFB8\uAFD4\uAFF0\uB00C\uB028\uB044\uB060\uB07C\uB098\uB0B4\uB0D0\uB0EC\uB108\uB124\uB140\uB15C\uB178\uB194\uB1B0\uB1CC\uB1E8\uB204\uB220\uB23C\uB258\uB274\uB290\uB2AC\uB2C8\uB2E4\uB300\uB31C\uB338\uB354\uB370\uB38C\uB3A8\uB3C4\uB3E0\uB3FC\uB418\uB434\uB450\uB46C\uB488\uB4A4\uB4C0\uB4DC\uB4F8\uB514\uB530\uB54C\uB568\uB584\uB5A0\uB5BC\uB5D8\uB5F4\uB610\uB62C\uB648\uB664\uB680\uB69C\uB6B8\uB6D4\uB6F0\uB70C\uB728\uB744\uB760\uB77C\uB798\uB7B4\uB7D0\uB7EC\uB808\uB824\uB840\uB85C\uB878\uB894\uB8B0\uB8CC\uB8E8\uB904\uB920\uB93C\uB958\uB974\uB990\uB9AC\uB9C8\uB9E4\uBA00\uBA1C\uBA38\uBA54\uBA70\uBA8C\uBAA8\uBAC4\uBAE0\uBAFC\uBB18\uBB34\uBB50\uBB6C\uBB88\uBBA4\uBBC0\uBBDC\uBBF8\uBC14\uBC30\uBC4C\uBC68\uBC84\uBCA0\uBCBC\uBCD8\uBCF4\uBD10\uBD2C\uBD48\uBD64\uBD80\uBD9C\uBDB8\uBDD4\uBDF0\uBE0C\uBE28\uBE44\uBE60\uBE7C\uBE98\uBEB4\uBED0\uBEEC\uBF08\uBF24\uBF40\uBF5C\uBF78\uBF94\uBFB0\uBFCC\uBFE8\uC004\uC020\uC03C\uC058\uC074\uC090\uC0AC\uC0C8\uC0E4\uC100\uC11C\uC138\uC154\uC170\uC18C\uC1A8\uC1C4\uC1E0\uC1FC\uC218\uC234\uC250\uC26C\uC288\uC2A4\uC2C0\uC2DC\uC2F8\uC314\uC330\uC34C\uC368\uC384\uC3A0\uC3BC\uC3D8\uC3F4\uC410\uC42C\uC448\uC464\uC480\uC49C\uC4B8\uC4D4\uC4F0\uC50C\uC528\uC544\uC560\uC57C\uC598\uC5B4\uC5D0\uC5EC\uC608\uC624\uC640\uC65C\uC678\uC694\uC6B0\uC6CC\uC6E8\uC704\uC720\uC73C\uC758\uC774\uC790\uC7AC\uC7C8\uC7E4\uC800\uC81C\uC838\uC854\uC870\uC88C\uC8A8\uC8C4\uC8E0\uC8FC\uC918\uC934\uC950\uC96C\uC988\uC9A4\uC9C0\uC9DC\uC9F8\uCA14\uCA30\uCA4C\uCA68\uCA84\uCAA0\uCABC\uCAD8\uCAF4\uCB10\uCB2C\uCB48\uCB64\uCB80\uCB9C\uCBB8\uCBD4\uCBF0\uCC0C\uCC28\uCC44\uCC60\uCC7C\uCC98\uCCB4\uCCD0\uCCEC\uCD08\uCD24\uCD40\uCD5C\uCD78\uCD94\uCDB0\uCDCC\uCDE8\uCE04\uCE20\uCE3C\uCE58\uCE74\uCE90\uCEAC\uCEC8\uCEE4\uCF00\uCF1C\uCF38\uCF54\uCF70\uCF8C\uCFA8\uCFC4\uCFE0\uCFFC\uD018\uD034\uD050\uD06C\uD088\uD0A4\uD0C0\uD0DC\uD0F8\uD114\uD130\uD14C\uD168\uD184\uD1A0\uD1BC\uD1D8\uD1F4\uD210\uD22C\uD248\uD264\uD280\uD29C\uD2B8\uD2D4\uD2F0\uD30C\uD328\uD344\uD360\uD37C\uD398\uD3B4\uD3D0\uD3EC\uD408\uD424\uD440\uD45C\uD478\uD494\uD4B0\uD4CC\uD4E8\uD504\uD520\uD53C\uD558\uD574\uD590\uD5AC\uD5C8\uD5E4\uD600\uD61C\uD638\uD654\uD670\uD68C\uD6A8\uD6C4\uD6E0\uD6FC\uD718\uD734\uD750\uD76C\uD788]$/; + var reLVT = /^[\uAC01-\uAC1B\uAC1D-\uAC37\uAC39-\uAC53\uAC55-\uAC6F\uAC71-\uAC8B\uAC8D-\uACA7\uACA9-\uACC3\uACC5-\uACDF\uACE1-\uACFB\uACFD-\uAD17\uAD19-\uAD33\uAD35-\uAD4F\uAD51-\uAD6B\uAD6D-\uAD87\uAD89-\uADA3\uADA5-\uADBF\uADC1-\uADDB\uADDD-\uADF7\uADF9-\uAE13\uAE15-\uAE2F\uAE31-\uAE4B\uAE4D-\uAE67\uAE69-\uAE83\uAE85-\uAE9F\uAEA1-\uAEBB\uAEBD-\uAED7\uAED9-\uAEF3\uAEF5-\uAF0F\uAF11-\uAF2B\uAF2D-\uAF47\uAF49-\uAF63\uAF65-\uAF7F\uAF81-\uAF9B\uAF9D-\uAFB7\uAFB9-\uAFD3\uAFD5-\uAFEF\uAFF1-\uB00B\uB00D-\uB027\uB029-\uB043\uB045-\uB05F\uB061-\uB07B\uB07D-\uB097\uB099-\uB0B3\uB0B5-\uB0CF\uB0D1-\uB0EB\uB0ED-\uB107\uB109-\uB123\uB125-\uB13F\uB141-\uB15B\uB15D-\uB177\uB179-\uB193\uB195-\uB1AF\uB1B1-\uB1CB\uB1CD-\uB1E7\uB1E9-\uB203\uB205-\uB21F\uB221-\uB23B\uB23D-\uB257\uB259-\uB273\uB275-\uB28F\uB291-\uB2AB\uB2AD-\uB2C7\uB2C9-\uB2E3\uB2E5-\uB2FF\uB301-\uB31B\uB31D-\uB337\uB339-\uB353\uB355-\uB36F\uB371-\uB38B\uB38D-\uB3A7\uB3A9-\uB3C3\uB3C5-\uB3DF\uB3E1-\uB3FB\uB3FD-\uB417\uB419-\uB433\uB435-\uB44F\uB451-\uB46B\uB46D-\uB487\uB489-\uB4A3\uB4A5-\uB4BF\uB4C1-\uB4DB\uB4DD-\uB4F7\uB4F9-\uB513\uB515-\uB52F\uB531-\uB54B\uB54D-\uB567\uB569-\uB583\uB585-\uB59F\uB5A1-\uB5BB\uB5BD-\uB5D7\uB5D9-\uB5F3\uB5F5-\uB60F\uB611-\uB62B\uB62D-\uB647\uB649-\uB663\uB665-\uB67F\uB681-\uB69B\uB69D-\uB6B7\uB6B9-\uB6D3\uB6D5-\uB6EF\uB6F1-\uB70B\uB70D-\uB727\uB729-\uB743\uB745-\uB75F\uB761-\uB77B\uB77D-\uB797\uB799-\uB7B3\uB7B5-\uB7CF\uB7D1-\uB7EB\uB7ED-\uB807\uB809-\uB823\uB825-\uB83F\uB841-\uB85B\uB85D-\uB877\uB879-\uB893\uB895-\uB8AF\uB8B1-\uB8CB\uB8CD-\uB8E7\uB8E9-\uB903\uB905-\uB91F\uB921-\uB93B\uB93D-\uB957\uB959-\uB973\uB975-\uB98F\uB991-\uB9AB\uB9AD-\uB9C7\uB9C9-\uB9E3\uB9E5-\uB9FF\uBA01-\uBA1B\uBA1D-\uBA37\uBA39-\uBA53\uBA55-\uBA6F\uBA71-\uBA8B\uBA8D-\uBAA7\uBAA9-\uBAC3\uBAC5-\uBADF\uBAE1-\uBAFB\uBAFD-\uBB17\uBB19-\uBB33\uBB35-\uBB4F\uBB51-\uBB6B\uBB6D-\uBB87\uBB89-\uBBA3\uBBA5-\uBBBF\uBBC1-\uBBDB\uBBDD-\uBBF7\uBBF9-\uBC13\uBC15-\uBC2F\uBC31-\uBC4B\uBC4D-\uBC67\uBC69-\uBC83\uBC85-\uBC9F\uBCA1-\uBCBB\uBCBD-\uBCD7\uBCD9-\uBCF3\uBCF5-\uBD0F\uBD11-\uBD2B\uBD2D-\uBD47\uBD49-\uBD63\uBD65-\uBD7F\uBD81-\uBD9B\uBD9D-\uBDB7\uBDB9-\uBDD3\uBDD5-\uBDEF\uBDF1-\uBE0B\uBE0D-\uBE27\uBE29-\uBE43\uBE45-\uBE5F\uBE61-\uBE7B\uBE7D-\uBE97\uBE99-\uBEB3\uBEB5-\uBECF\uBED1-\uBEEB\uBEED-\uBF07\uBF09-\uBF23\uBF25-\uBF3F\uBF41-\uBF5B\uBF5D-\uBF77\uBF79-\uBF93\uBF95-\uBFAF\uBFB1-\uBFCB\uBFCD-\uBFE7\uBFE9-\uC003\uC005-\uC01F\uC021-\uC03B\uC03D-\uC057\uC059-\uC073\uC075-\uC08F\uC091-\uC0AB\uC0AD-\uC0C7\uC0C9-\uC0E3\uC0E5-\uC0FF\uC101-\uC11B\uC11D-\uC137\uC139-\uC153\uC155-\uC16F\uC171-\uC18B\uC18D-\uC1A7\uC1A9-\uC1C3\uC1C5-\uC1DF\uC1E1-\uC1FB\uC1FD-\uC217\uC219-\uC233\uC235-\uC24F\uC251-\uC26B\uC26D-\uC287\uC289-\uC2A3\uC2A5-\uC2BF\uC2C1-\uC2DB\uC2DD-\uC2F7\uC2F9-\uC313\uC315-\uC32F\uC331-\uC34B\uC34D-\uC367\uC369-\uC383\uC385-\uC39F\uC3A1-\uC3BB\uC3BD-\uC3D7\uC3D9-\uC3F3\uC3F5-\uC40F\uC411-\uC42B\uC42D-\uC447\uC449-\uC463\uC465-\uC47F\uC481-\uC49B\uC49D-\uC4B7\uC4B9-\uC4D3\uC4D5-\uC4EF\uC4F1-\uC50B\uC50D-\uC527\uC529-\uC543\uC545-\uC55F\uC561-\uC57B\uC57D-\uC597\uC599-\uC5B3\uC5B5-\uC5CF\uC5D1-\uC5EB\uC5ED-\uC607\uC609-\uC623\uC625-\uC63F\uC641-\uC65B\uC65D-\uC677\uC679-\uC693\uC695-\uC6AF\uC6B1-\uC6CB\uC6CD-\uC6E7\uC6E9-\uC703\uC705-\uC71F\uC721-\uC73B\uC73D-\uC757\uC759-\uC773\uC775-\uC78F\uC791-\uC7AB\uC7AD-\uC7C7\uC7C9-\uC7E3\uC7E5-\uC7FF\uC801-\uC81B\uC81D-\uC837\uC839-\uC853\uC855-\uC86F\uC871-\uC88B\uC88D-\uC8A7\uC8A9-\uC8C3\uC8C5-\uC8DF\uC8E1-\uC8FB\uC8FD-\uC917\uC919-\uC933\uC935-\uC94F\uC951-\uC96B\uC96D-\uC987\uC989-\uC9A3\uC9A5-\uC9BF\uC9C1-\uC9DB\uC9DD-\uC9F7\uC9F9-\uCA13\uCA15-\uCA2F\uCA31-\uCA4B\uCA4D-\uCA67\uCA69-\uCA83\uCA85-\uCA9F\uCAA1-\uCABB\uCABD-\uCAD7\uCAD9-\uCAF3\uCAF5-\uCB0F\uCB11-\uCB2B\uCB2D-\uCB47\uCB49-\uCB63\uCB65-\uCB7F\uCB81-\uCB9B\uCB9D-\uCBB7\uCBB9-\uCBD3\uCBD5-\uCBEF\uCBF1-\uCC0B\uCC0D-\uCC27\uCC29-\uCC43\uCC45-\uCC5F\uCC61-\uCC7B\uCC7D-\uCC97\uCC99-\uCCB3\uCCB5-\uCCCF\uCCD1-\uCCEB\uCCED-\uCD07\uCD09-\uCD23\uCD25-\uCD3F\uCD41-\uCD5B\uCD5D-\uCD77\uCD79-\uCD93\uCD95-\uCDAF\uCDB1-\uCDCB\uCDCD-\uCDE7\uCDE9-\uCE03\uCE05-\uCE1F\uCE21-\uCE3B\uCE3D-\uCE57\uCE59-\uCE73\uCE75-\uCE8F\uCE91-\uCEAB\uCEAD-\uCEC7\uCEC9-\uCEE3\uCEE5-\uCEFF\uCF01-\uCF1B\uCF1D-\uCF37\uCF39-\uCF53\uCF55-\uCF6F\uCF71-\uCF8B\uCF8D-\uCFA7\uCFA9-\uCFC3\uCFC5-\uCFDF\uCFE1-\uCFFB\uCFFD-\uD017\uD019-\uD033\uD035-\uD04F\uD051-\uD06B\uD06D-\uD087\uD089-\uD0A3\uD0A5-\uD0BF\uD0C1-\uD0DB\uD0DD-\uD0F7\uD0F9-\uD113\uD115-\uD12F\uD131-\uD14B\uD14D-\uD167\uD169-\uD183\uD185-\uD19F\uD1A1-\uD1BB\uD1BD-\uD1D7\uD1D9-\uD1F3\uD1F5-\uD20F\uD211-\uD22B\uD22D-\uD247\uD249-\uD263\uD265-\uD27F\uD281-\uD29B\uD29D-\uD2B7\uD2B9-\uD2D3\uD2D5-\uD2EF\uD2F1-\uD30B\uD30D-\uD327\uD329-\uD343\uD345-\uD35F\uD361-\uD37B\uD37D-\uD397\uD399-\uD3B3\uD3B5-\uD3CF\uD3D1-\uD3EB\uD3ED-\uD407\uD409-\uD423\uD425-\uD43F\uD441-\uD45B\uD45D-\uD477\uD479-\uD493\uD495-\uD4AF\uD4B1-\uD4CB\uD4CD-\uD4E7\uD4E9-\uD503\uD505-\uD51F\uD521-\uD53B\uD53D-\uD557\uD559-\uD573\uD575-\uD58F\uD591-\uD5AB\uD5AD-\uD5C7\uD5C9-\uD5E3\uD5E5-\uD5FF\uD601-\uD61B\uD61D-\uD637\uD639-\uD653\uD655-\uD66F\uD671-\uD68B\uD68D-\uD6A7\uD6A9-\uD6C3\uD6C5-\uD6DF\uD6E1-\uD6FB\uD6FD-\uD717\uD719-\uD733\uD735-\uD74F\uD751-\uD76B\uD76D-\uD787\uD789-\uD7A3]$/; + var reExtPict = /^(?:[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u2388\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2605\u2607-\u2612\u2614-\u2685\u2690-\u2705\u2708-\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763-\u2767\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC00-\uDCFF\uDD0D-\uDD0F\uDD2F\uDD6C-\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDAD-\uDDE5\uDE01-\uDE0F\uDE1A\uDE2F\uDE32-\uDE3A\uDE3C-\uDE3F\uDE49-\uDFFA]|\uD83D[\uDC00-\uDD3D\uDD46-\uDE4F\uDE80-\uDEFF\uDF74-\uDF7F\uDFD5-\uDFFF]|\uD83E[\uDC0C-\uDC0F\uDC48-\uDC4F\uDC5A-\uDC5F\uDC88-\uDC8F\uDCAE-\uDCFF\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDEFF]|\uD83F[\uDC00-\uDFFD])$/; + + var getCodepointType = function getCodepointType(_char4, code) { + var type = CodepointType.Any; + + if (_char4.search(reExtend) !== -1) { + type |= CodepointType.Extend; + } + + if (code === 0x200d) { + type |= CodepointType.ZWJ; + } + + if (code >= 0x1f1e6 && code <= 0x1f1ff) { + type |= CodepointType.RI; + } + + if (_char4.search(rePrepend) !== -1) { + type |= CodepointType.Prepend; + } + + if (_char4.search(reSpacingMark) !== -1) { + type |= CodepointType.SpacingMark; + } + + if (_char4.search(reL) !== -1) { + type |= CodepointType.L; + } + + if (_char4.search(reV) !== -1) { + type |= CodepointType.V; + } + + if (_char4.search(reT) !== -1) { + type |= CodepointType.T; + } + + if (_char4.search(reLV) !== -1) { + type |= CodepointType.LV; + } + + if (_char4.search(reLVT) !== -1) { + type |= CodepointType.LVT; + } + + if (_char4.search(reExtPict) !== -1) { + type |= CodepointType.ExtPict; + } + + return type; + }; + + function intersects(x, y) { + return (x & y) !== 0; + } + + var NonBoundaryPairs = [// GB6 + [CodepointType.L, CodepointType.L | CodepointType.V | CodepointType.LV | CodepointType.LVT], // GB7 + [CodepointType.LV | CodepointType.V, CodepointType.V | CodepointType.T], // GB8 + [CodepointType.LVT | CodepointType.T, CodepointType.T], // GB9 + [CodepointType.Any, CodepointType.Extend | CodepointType.ZWJ], // GB9a + [CodepointType.Any, CodepointType.SpacingMark], // GB9b + [CodepointType.Prepend, CodepointType.Any], // GB11 + [CodepointType.ZWJ, CodepointType.ExtPict], // GB12 and GB13 + [CodepointType.RI, CodepointType.RI]]; + + function isBoundaryPair(left, right) { + return NonBoundaryPairs.findIndex(function (r) { + return intersects(left, r[0]) && intersects(right, r[1]); + }) === -1; + } + + var endingEmojiZWJ = /(?:[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u2388\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2605\u2607-\u2612\u2614-\u2685\u2690-\u2705\u2708-\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763-\u2767\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC00-\uDCFF\uDD0D-\uDD0F\uDD2F\uDD6C-\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDAD-\uDDE5\uDE01-\uDE0F\uDE1A\uDE2F\uDE32-\uDE3A\uDE3C-\uDE3F\uDE49-\uDFFA]|\uD83D[\uDC00-\uDD3D\uDD46-\uDE4F\uDE80-\uDEFF\uDF74-\uDF7F\uDFD5-\uDFFF]|\uD83E[\uDC0C-\uDC0F\uDC48-\uDC4F\uDC5A-\uDC5F\uDC88-\uDC8F\uDCAE-\uDCFF\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDEFF]|\uD83F[\uDC00-\uDFFD])(?:[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0902\u093A\u093C\u0941-\u0948\u094D\u0951-\u0957\u0962\u0963\u0981\u09BC\u09BE\u09C1-\u09C4\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01\u0A02\u0A3C\u0A41\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81\u0A82\u0ABC\u0AC1-\u0AC5\u0AC7\u0AC8\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01\u0B3C\u0B3E\u0B3F\u0B41-\u0B44\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B82\u0BBE\u0BC0\u0BCD\u0BD7\u0C00\u0C04\u0C3E-\u0C40\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81\u0CBC\u0CBF\u0CC2\u0CC6\u0CCC\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00\u0D01\u0D3B\u0D3C\u0D3E\u0D41-\u0D44\u0D4D\u0D57\u0D62\u0D63\u0D81\u0DCA\u0DCF\u0DD2-\u0DD4\u0DD6\u0DDF\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F71-\u0F7E\u0F80-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102D-\u1030\u1032-\u1037\u1039\u103A\u103D\u103E\u1058\u1059\u105E-\u1060\u1071-\u1074\u1082\u1085\u1086\u108D\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4\u17B5\u17B7-\u17BD\u17C6\u17C9-\u17D3\u17DD\u180B-\u180D\u1885\u1886\u18A9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193B\u1A17\u1A18\u1A1B\u1A56\u1A58-\u1A5E\u1A60\u1A62\u1A65-\u1A6C\u1A73-\u1A7C\u1A7F\u1AB0-\u1AC0\u1B00-\u1B03\u1B34-\u1B3A\u1B3C\u1B42\u1B6B-\u1B73\u1B80\u1B81\u1BA2-\u1BA5\u1BA8\u1BA9\u1BAB-\u1BAD\u1BE6\u1BE8\u1BE9\u1BED\u1BEF-\u1BF1\u1C2C-\u1C33\u1C36\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE0\u1CE2-\u1CE8\u1CED\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u200C\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA825\uA826\uA82C\uA8C4\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA951\uA980-\uA982\uA9B3\uA9B6-\uA9B9\uA9BC\uA9BD\uA9E5\uAA29-\uAA2E\uAA31\uAA32\uAA35\uAA36\uAA43\uAA4C\uAA7C\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEC\uAAED\uAAF6\uABE5\uABE8\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFF9E\uFF9F]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD803[\uDD24-\uDD27\uDEAB\uDEAC\uDF46-\uDF50]|\uD804[\uDC01\uDC38-\uDC46\uDC7F-\uDC81\uDCB3-\uDCB6\uDCB9\uDCBA\uDD00-\uDD02\uDD27-\uDD2B\uDD2D-\uDD34\uDD73\uDD80\uDD81\uDDB6-\uDDBE\uDDC9-\uDDCC\uDDCF\uDE2F-\uDE31\uDE34\uDE36\uDE37\uDE3E\uDEDF\uDEE3-\uDEEA\uDF00\uDF01\uDF3B\uDF3C\uDF3E\uDF40\uDF57\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC38-\uDC3F\uDC42-\uDC44\uDC46\uDC5E\uDCB0\uDCB3-\uDCB8\uDCBA\uDCBD\uDCBF\uDCC0\uDCC2\uDCC3\uDDAF\uDDB2-\uDDB5\uDDBC\uDDBD\uDDBF\uDDC0\uDDDC\uDDDD\uDE33-\uDE3A\uDE3D\uDE3F\uDE40\uDEAB\uDEAD\uDEB0-\uDEB5\uDEB7\uDF1D-\uDF1F\uDF22-\uDF25\uDF27-\uDF2B]|\uD806[\uDC2F-\uDC37\uDC39\uDC3A\uDD30\uDD3B\uDD3C\uDD3E\uDD43\uDDD4-\uDDD7\uDDDA\uDDDB\uDDE0\uDE01-\uDE0A\uDE33-\uDE38\uDE3B-\uDE3E\uDE47\uDE51-\uDE56\uDE59-\uDE5B\uDE8A-\uDE96\uDE98\uDE99]|\uD807[\uDC30-\uDC36\uDC38-\uDC3D\uDC3F\uDC92-\uDCA7\uDCAA-\uDCB0\uDCB2\uDCB3\uDCB5\uDCB6\uDD31-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD45\uDD47\uDD90\uDD91\uDD95\uDD97\uDEF3\uDEF4]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF4F\uDF8F-\uDF92\uDFE4]|\uD82F[\uDC9D\uDC9E]|\uD834[\uDD65\uDD67-\uDD69\uDD6E-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDD30-\uDD36\uDEEC-\uDEEF]|\uD83A[\uDCD0-\uDCD6\uDD44-\uDD4A]|\uD83C[\uDFFB-\uDFFF]|\uDB40[\uDC20-\uDC7F\uDD00-\uDDEF])*\u200D$/; + + var endsWithEmojiZWJ = function endsWithEmojiZWJ(str) { + return str.search(endingEmojiZWJ) !== -1; + }; + + var endingRIs = /(?:\uD83C[\uDDE6-\uDDFF])+$/g; + + var endsWithOddNumberOfRIs = function endsWithOddNumberOfRIs(str) { + var match = str.match(endingRIs); + + if (match === null) { + return false; + } else { + // A RI is represented by a surrogate pair. + var numRIs = match[0].length / 2; + return numRIs % 2 === 1; + } + }; + + /** + * Shared the function with isElementType utility + */ + + var isElement = function isElement(value) { + return isPlainObject.isPlainObject(value) && Node$1.isNodeList(value.children) && !Editor.isEditor(value); + }; + + var Element$1 = { + /** + * Check if a value implements the 'Ancestor' interface. + */ + isAncestor: function isAncestor(value) { + return isPlainObject.isPlainObject(value) && Node$1.isNodeList(value.children); + }, + + /** + * Check if a value implements the `Element` interface. + */ + isElement: isElement, + + /** + * Check if a value is an array of `Element` objects. + */ + isElementList: function isElementList(value) { + return Array.isArray(value) && value.every(function (val) { + return Element$1.isElement(val); + }); + }, + + /** + * Check if a set of props is a partial of Element. + */ + isElementProps: function isElementProps(props) { + return props.children !== undefined; + }, + + /** + * Check if a value implements the `Element` interface and has elementKey with selected value. + * Default it check to `type` key value + */ + isElementType: function isElementType(value, elementVal) { + var elementKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'type'; + return isElement(value) && value[elementKey] === elementVal; + }, + + /** + * Check if an element matches set of properties. + * + * Note: this checks custom properties, and it does not ensure that any + * children are equivalent. + */ + matches: function matches(element, props) { + for (var key in props) { + if (key === 'children') { + continue; + } + + if (element[key] !== props[key]) { + return false; + } + } + + return true; + } + }; + + var _excluded$4 = ["text"], + _excluded2$3 = ["text"]; + + function ownKeys$8(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + + function _objectSpread$8(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$8(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$8(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + + function _createForOfIteratorHelper$5(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$5(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } + + function _unsupportedIterableToArray$5(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$5(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$5(o, minLen); } + + function _arrayLikeToArray$5(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; } + var IS_EDITOR_CACHE = new WeakMap(); + var Editor = { + /** + * Get the ancestor above a location in the document. + */ + above: function above(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _options$voids = options.voids, + voids = _options$voids === void 0 ? false : _options$voids, + _options$mode = options.mode, + mode = _options$mode === void 0 ? 'lowest' : _options$mode, + _options$at = options.at, + at = _options$at === void 0 ? editor.selection : _options$at, + match = options.match; + + if (!at) { + return; + } + + var path = Editor.path(editor, at); + var reverse = mode === 'lowest'; + + var _iterator = _createForOfIteratorHelper$5(Editor.levels(editor, { + at: path, + voids: voids, + match: match, + reverse: reverse + })), + _step; + + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var _step$value = _slicedToArray(_step.value, 2), + n = _step$value[0], + p = _step$value[1]; + + if (!Text.isText(n) && !Path.equals(path, p)) { + return [n, p]; + } + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } + }, + + /** + * Add a custom property to the leaf text nodes in the current selection. + * + * If the selection is currently collapsed, the marks will be added to the + * `editor.marks` property instead, and applied when text is inserted next. + */ + addMark: function addMark(editor, key, value) { + editor.addMark(key, value); + }, + + /** + * Get the point after a location. + */ + after: function after(editor, at) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var anchor = Editor.point(editor, at, { + edge: 'end' + }); + var focus = Editor.end(editor, []); + var range = { + anchor: anchor, + focus: focus + }; + var _options$distance = options.distance, + distance = _options$distance === void 0 ? 1 : _options$distance; + var d = 0; + var target; + + var _iterator2 = _createForOfIteratorHelper$5(Editor.positions(editor, _objectSpread$8(_objectSpread$8({}, options), {}, { + at: range + }))), + _step2; + + try { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { + var p = _step2.value; + + if (d > distance) { + break; + } + + if (d !== 0) { + target = p; + } + + d++; + } + } catch (err) { + _iterator2.e(err); + } finally { + _iterator2.f(); + } + + return target; + }, + + /** + * Get the point before a location. + */ + before: function before(editor, at) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var anchor = Editor.start(editor, []); + var focus = Editor.point(editor, at, { + edge: 'start' + }); + var range = { + anchor: anchor, + focus: focus + }; + var _options$distance2 = options.distance, + distance = _options$distance2 === void 0 ? 1 : _options$distance2; + var d = 0; + var target; + + var _iterator3 = _createForOfIteratorHelper$5(Editor.positions(editor, _objectSpread$8(_objectSpread$8({}, options), {}, { + at: range, + reverse: true + }))), + _step3; + + try { + for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) { + var p = _step3.value; + + if (d > distance) { + break; + } + + if (d !== 0) { + target = p; + } + + d++; + } + } catch (err) { + _iterator3.e(err); + } finally { + _iterator3.f(); + } + + return target; + }, + + /** + * Delete content in the editor backward from the current selection. + */ + deleteBackward: function deleteBackward(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _options$unit = options.unit, + unit = _options$unit === void 0 ? 'character' : _options$unit; + editor.deleteBackward(unit); + }, + + /** + * Delete content in the editor forward from the current selection. + */ + deleteForward: function deleteForward(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _options$unit2 = options.unit, + unit = _options$unit2 === void 0 ? 'character' : _options$unit2; + editor.deleteForward(unit); + }, + + /** + * Delete the content in the current selection. + */ + deleteFragment: function deleteFragment(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _options$direction = options.direction, + direction = _options$direction === void 0 ? 'forward' : _options$direction; + editor.deleteFragment(direction); + }, + + /** + * Get the start and end points of a location. + */ + edges: function edges(editor, at) { + return [Editor.start(editor, at), Editor.end(editor, at)]; + }, + + /** + * Get the end point of a location. + */ + end: function end(editor, at) { + return Editor.point(editor, at, { + edge: 'end' + }); + }, + + /** + * Get the first node at a location. + */ + first: function first(editor, at) { + var path = Editor.path(editor, at, { + edge: 'start' + }); + return Editor.node(editor, path); + }, + + /** + * Get the fragment at a location. + */ + fragment: function fragment(editor, at) { + var range = Editor.range(editor, at); + var fragment = Node$1.fragment(editor, range); + return fragment; + }, + + /** + * Check if a node has block children. + */ + hasBlocks: function hasBlocks(editor, element) { + return element.children.some(function (n) { + return Editor.isBlock(editor, n); + }); + }, + + /** + * Check if a node has inline and text children. + */ + hasInlines: function hasInlines(editor, element) { + return element.children.some(function (n) { + return Text.isText(n) || Editor.isInline(editor, n); + }); + }, + + /** + * Check if a node has text children. + */ + hasTexts: function hasTexts(editor, element) { + return element.children.every(function (n) { + return Text.isText(n); + }); + }, + + /** + * Insert a block break at the current selection. + * + * If the selection is currently expanded, it will be deleted first. + */ + insertBreak: function insertBreak(editor) { + editor.insertBreak(); + }, + + /** + * Insert a fragment at the current selection. + * + * If the selection is currently expanded, it will be deleted first. + */ + insertFragment: function insertFragment(editor, fragment) { + editor.insertFragment(fragment); + }, + + /** + * Insert a node at the current selection. + * + * If the selection is currently expanded, it will be deleted first. + */ + insertNode: function insertNode(editor, node) { + editor.insertNode(node); + }, + + /** + * Insert text at the current selection. + * + * If the selection is currently expanded, it will be deleted first. + */ + insertText: function insertText(editor, text) { + editor.insertText(text); + }, + + /** + * Check if a value is a block `Element` object. + */ + isBlock: function isBlock(editor, value) { + return Element$1.isElement(value) && !editor.isInline(value); + }, + + /** + * Check if a value is an `Editor` object. + */ + isEditor: function isEditor(value) { + if (!isPlainObject.isPlainObject(value)) return false; + var cachedIsEditor = IS_EDITOR_CACHE.get(value); + + if (cachedIsEditor !== undefined) { + return cachedIsEditor; + } + + var isEditor = typeof value.addMark === 'function' && typeof value.apply === 'function' && typeof value.deleteBackward === 'function' && typeof value.deleteForward === 'function' && typeof value.deleteFragment === 'function' && typeof value.insertBreak === 'function' && typeof value.insertFragment === 'function' && typeof value.insertNode === 'function' && typeof value.insertText === 'function' && typeof value.isInline === 'function' && typeof value.isVoid === 'function' && typeof value.normalizeNode === 'function' && typeof value.onChange === 'function' && typeof value.removeMark === 'function' && (value.marks === null || isPlainObject.isPlainObject(value.marks)) && (value.selection === null || Range.isRange(value.selection)) && Node$1.isNodeList(value.children) && Operation.isOperationList(value.operations); + IS_EDITOR_CACHE.set(value, isEditor); + return isEditor; + }, + + /** + * Check if a point is the end point of a location. + */ + isEnd: function isEnd(editor, point, at) { + var end = Editor.end(editor, at); + return Point.equals(point, end); + }, + + /** + * Check if a point is an edge of a location. + */ + isEdge: function isEdge(editor, point, at) { + return Editor.isStart(editor, point, at) || Editor.isEnd(editor, point, at); + }, + + /** + * Check if an element is empty, accounting for void nodes. + */ + isEmpty: function isEmpty(editor, element) { + var children = element.children; + + var _children = _slicedToArray(children, 1), + first = _children[0]; + + return children.length === 0 || children.length === 1 && Text.isText(first) && first.text === '' && !editor.isVoid(element); + }, + + /** + * Check if a value is an inline `Element` object. + */ + isInline: function isInline(editor, value) { + return Element$1.isElement(value) && editor.isInline(value); + }, + + /** + * Check if the editor is currently normalizing after each operation. + */ + isNormalizing: function isNormalizing(editor) { + var isNormalizing = NORMALIZING.get(editor); + return isNormalizing === undefined ? true : isNormalizing; + }, + + /** + * Check if a point is the start point of a location. + */ + isStart: function isStart(editor, point, at) { + // PERF: If the offset isn't `0` we know it's not the start. + if (point.offset !== 0) { + return false; + } + + var start = Editor.start(editor, at); + return Point.equals(point, start); + }, + + /** + * Check if a value is a void `Element` object. + */ + isVoid: function isVoid(editor, value) { + return Element$1.isElement(value) && editor.isVoid(value); + }, + + /** + * Get the last node at a location. + */ + last: function last(editor, at) { + var path = Editor.path(editor, at, { + edge: 'end' + }); + return Editor.node(editor, path); + }, + + /** + * Get the leaf text node at a location. + */ + leaf: function leaf(editor, at) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var path = Editor.path(editor, at, options); + var node = Node$1.leaf(editor, path); + return [node, path]; + }, + + /** + * Iterate through all of the levels at a location. + */ + levels: function* levels(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _options$at2 = options.at, + at = _options$at2 === void 0 ? editor.selection : _options$at2, + _options$reverse = options.reverse, + reverse = _options$reverse === void 0 ? false : _options$reverse, + _options$voids2 = options.voids, + voids = _options$voids2 === void 0 ? false : _options$voids2; + var match = options.match; + + if (match == null) { + match = function match() { + return true; + }; + } + + if (!at) { + return; + } + + var levels = []; + var path = Editor.path(editor, at); + + var _iterator4 = _createForOfIteratorHelper$5(Node$1.levels(editor, path)), + _step4; + + try { + for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) { + var _step4$value = _slicedToArray(_step4.value, 2), + n = _step4$value[0], + p = _step4$value[1]; + + if (!match(n, p)) { + continue; + } + + levels.push([n, p]); + + if (!voids && Editor.isVoid(editor, n)) { + break; + } + } + } catch (err) { + _iterator4.e(err); + } finally { + _iterator4.f(); + } + + if (reverse) { + levels.reverse(); + } + + yield* levels; + }, + + /** + * Get the marks that would be added to text at the current selection. + */ + marks: function marks(editor) { + var marks = editor.marks, + selection = editor.selection; + + if (!selection) { + return null; + } + + if (marks) { + return marks; + } + + if (Range.isExpanded(selection)) { + var _Editor$nodes = Editor.nodes(editor, { + match: Text.isText + }), + _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1), + match = _Editor$nodes2[0]; + + if (match) { + var _match = _slicedToArray(match, 1), + _node = _match[0]; + + _node.text; + var _rest = _objectWithoutProperties(_node, _excluded$4); + + return _rest; + } else { + return {}; + } + } + + var anchor = selection.anchor; + var path = anchor.path; + + var _Editor$leaf = Editor.leaf(editor, path), + _Editor$leaf2 = _slicedToArray(_Editor$leaf, 1), + node = _Editor$leaf2[0]; + + if (anchor.offset === 0) { + var prev = Editor.previous(editor, { + at: path, + match: Text.isText + }); + var block = Editor.above(editor, { + match: function match(n) { + return Editor.isBlock(editor, n); + } + }); + + if (prev && block) { + var _prev = _slicedToArray(prev, 2), + prevNode = _prev[0], + prevPath = _prev[1]; + + var _block = _slicedToArray(block, 2), + blockPath = _block[1]; + + if (Path.isAncestor(blockPath, prevPath)) { + node = prevNode; + } + } + } + + var _node2 = node; + _node2.text; + var rest = _objectWithoutProperties(_node2, _excluded2$3); + + return rest; + }, + + /** + * Get the matching node in the branch of the document after a location. + */ + next: function next(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _options$mode2 = options.mode, + mode = _options$mode2 === void 0 ? 'lowest' : _options$mode2, + _options$voids3 = options.voids, + voids = _options$voids3 === void 0 ? false : _options$voids3; + var match = options.match, + _options$at3 = options.at, + at = _options$at3 === void 0 ? editor.selection : _options$at3; + + if (!at) { + return; + } + + var pointAfterLocation = Editor.after(editor, at, { + voids: voids + }); + if (!pointAfterLocation) return; + + var _Editor$last = Editor.last(editor, []), + _Editor$last2 = _slicedToArray(_Editor$last, 2), + to = _Editor$last2[1]; + + var span = [pointAfterLocation.path, to]; + + if (Path.isPath(at) && at.length === 0) { + throw new Error("Cannot get the next node from the root node!"); + } + + if (match == null) { + if (Path.isPath(at)) { + var _Editor$parent = Editor.parent(editor, at), + _Editor$parent2 = _slicedToArray(_Editor$parent, 1), + parent = _Editor$parent2[0]; + + match = function match(n) { + return parent.children.includes(n); + }; + } else { + match = function match() { + return true; + }; + } + } + + var _Editor$nodes3 = Editor.nodes(editor, { + at: span, + match: match, + mode: mode, + voids: voids + }), + _Editor$nodes4 = _slicedToArray(_Editor$nodes3, 1), + next = _Editor$nodes4[0]; + + return next; + }, + + /** + * Get the node at a location. + */ + node: function node(editor, at) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var path = Editor.path(editor, at, options); + var node = Node$1.get(editor, path); + return [node, path]; + }, + + /** + * Iterate through all of the nodes in the Editor. + */ + nodes: function* nodes(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _options$at4 = options.at, + at = _options$at4 === void 0 ? editor.selection : _options$at4, + _options$mode3 = options.mode, + mode = _options$mode3 === void 0 ? 'all' : _options$mode3, + _options$universal = options.universal, + universal = _options$universal === void 0 ? false : _options$universal, + _options$reverse2 = options.reverse, + reverse = _options$reverse2 === void 0 ? false : _options$reverse2, + _options$voids4 = options.voids, + voids = _options$voids4 === void 0 ? false : _options$voids4; + var match = options.match; + + if (!match) { + match = function match() { + return true; + }; + } + + if (!at) { + return; + } + + var from; + var to; + + if (Span.isSpan(at)) { + from = at[0]; + to = at[1]; + } else { + var first = Editor.path(editor, at, { + edge: 'start' + }); + var last = Editor.path(editor, at, { + edge: 'end' + }); + from = reverse ? last : first; + to = reverse ? first : last; + } + + var nodeEntries = Node$1.nodes(editor, { + reverse: reverse, + from: from, + to: to, + pass: function pass(_ref) { + var _ref2 = _slicedToArray(_ref, 1), + n = _ref2[0]; + + return voids ? false : Editor.isVoid(editor, n); + } + }); + var matches = []; + var hit; + + var _iterator5 = _createForOfIteratorHelper$5(nodeEntries), + _step5; + + try { + for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) { + var _step5$value = _slicedToArray(_step5.value, 2), + node = _step5$value[0], + path = _step5$value[1]; + + var isLower = hit && Path.compare(path, hit[1]) === 0; // In highest mode any node lower than the last hit is not a match. + + if (mode === 'highest' && isLower) { + continue; + } + + if (!match(node, path)) { + // If we've arrived at a leaf text node that is not lower than the last + // hit, then we've found a branch that doesn't include a match, which + // means the match is not universal. + if (universal && !isLower && Text.isText(node)) { + return; + } else { + continue; + } + } // If there's a match and it's lower than the last, update the hit. + + + if (mode === 'lowest' && isLower) { + hit = [node, path]; + continue; + } // In lowest mode we emit the last hit, once it's guaranteed lowest. + + + var emit = mode === 'lowest' ? hit : [node, path]; + + if (emit) { + if (universal) { + matches.push(emit); + } else { + yield emit; + } + } + + hit = [node, path]; + } // Since lowest is always emitting one behind, catch up at the end. + + } catch (err) { + _iterator5.e(err); + } finally { + _iterator5.f(); + } + + if (mode === 'lowest' && hit) { + if (universal) { + matches.push(hit); + } else { + yield hit; + } + } // Universal defers to ensure that the match occurs in every branch, so we + // yield all of the matches after iterating. + + + if (universal) { + yield* matches; + } + }, + + /** + * Normalize any dirty objects in the editor. + */ + normalize: function normalize(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _options$force = options.force, + force = _options$force === void 0 ? false : _options$force; + + var getDirtyPaths = function getDirtyPaths(editor) { + return DIRTY_PATHS.get(editor) || []; + }; + + if (!Editor.isNormalizing(editor)) { + return; + } + + if (force) { + var allPaths = Array.from(Node$1.nodes(editor), function (_ref3) { + var _ref4 = _slicedToArray(_ref3, 2), + p = _ref4[1]; + + return p; + }); + DIRTY_PATHS.set(editor, allPaths); + } + + if (getDirtyPaths(editor).length === 0) { + return; + } + + Editor.withoutNormalizing(editor, function () { + /* + Fix dirty elements with no children. + editor.normalizeNode() does fix this, but some normalization fixes also require it to work. + Running an initial pass avoids the catch-22 race condition. + */ + var _iterator6 = _createForOfIteratorHelper$5(getDirtyPaths(editor)), + _step6; + + try { + for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) { + var _dirtyPath = _step6.value; + + if (Node$1.has(editor, _dirtyPath)) { + var _entry = Editor.node(editor, _dirtyPath); + + var _entry2 = _slicedToArray(_entry, 2), + node = _entry2[0], + _ = _entry2[1]; + /* + The default normalizer inserts an empty text node in this scenario, but it can be customised. + So there is some risk here. + As long as the normalizer only inserts child nodes for this case it is safe to do in any order; + by definition adding children to an empty node can't cause other paths to change. + */ + + + if (Element$1.isElement(node) && node.children.length === 0) { + editor.normalizeNode(_entry); + } + } + } + } catch (err) { + _iterator6.e(err); + } finally { + _iterator6.f(); + } + + var max = getDirtyPaths(editor).length * 42; // HACK: better way? + + var m = 0; + + while (getDirtyPaths(editor).length !== 0) { + if (m > max) { + throw new Error("\n Could not completely normalize the editor after ".concat(max, " iterations! This is usually due to incorrect normalization logic that leaves a node in an invalid state.\n ")); + } + + var dirtyPath = getDirtyPaths(editor).pop(); // If the node doesn't exist in the tree, it does not need to be normalized. + + if (Node$1.has(editor, dirtyPath)) { + var entry = Editor.node(editor, dirtyPath); + editor.normalizeNode(entry); + } + + m++; + } + }); + }, + + /** + * Get the parent node of a location. + */ + parent: function parent(editor, at) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var path = Editor.path(editor, at, options); + var parentPath = Path.parent(path); + var entry = Editor.node(editor, parentPath); + return entry; + }, + + /** + * Get the path of a location. + */ + path: function path(editor, at) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var depth = options.depth, + edge = options.edge; + + if (Path.isPath(at)) { + if (edge === 'start') { + var _Node$first = Node$1.first(editor, at), + _Node$first2 = _slicedToArray(_Node$first, 2), + firstPath = _Node$first2[1]; + + at = firstPath; + } else if (edge === 'end') { + var _Node$last = Node$1.last(editor, at), + _Node$last2 = _slicedToArray(_Node$last, 2), + lastPath = _Node$last2[1]; + + at = lastPath; + } + } + + if (Range.isRange(at)) { + if (edge === 'start') { + at = Range.start(at); + } else if (edge === 'end') { + at = Range.end(at); + } else { + at = Path.common(at.anchor.path, at.focus.path); + } + } + + if (Point.isPoint(at)) { + at = at.path; + } + + if (depth != null) { + at = at.slice(0, depth); + } + + return at; + }, + hasPath: function hasPath(editor, path) { + return Node$1.has(editor, path); + }, + + /** + * Create a mutable ref for a `Path` object, which will stay in sync as new + * operations are applied to the editor. + */ + pathRef: function pathRef(editor, path) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var _options$affinity = options.affinity, + affinity = _options$affinity === void 0 ? 'forward' : _options$affinity; + var ref = { + current: path, + affinity: affinity, + unref: function unref() { + var current = ref.current; + var pathRefs = Editor.pathRefs(editor); + pathRefs["delete"](ref); + ref.current = null; + return current; + } + }; + var refs = Editor.pathRefs(editor); + refs.add(ref); + return ref; + }, + + /** + * Get the set of currently tracked path refs of the editor. + */ + pathRefs: function pathRefs(editor) { + var refs = PATH_REFS.get(editor); + + if (!refs) { + refs = new Set(); + PATH_REFS.set(editor, refs); + } + + return refs; + }, + + /** + * Get the start or end point of a location. + */ + point: function point(editor, at) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var _options$edge = options.edge, + edge = _options$edge === void 0 ? 'start' : _options$edge; + + if (Path.isPath(at)) { + var path; + + if (edge === 'end') { + var _Node$last3 = Node$1.last(editor, at), + _Node$last4 = _slicedToArray(_Node$last3, 2), + lastPath = _Node$last4[1]; + + path = lastPath; + } else { + var _Node$first3 = Node$1.first(editor, at), + _Node$first4 = _slicedToArray(_Node$first3, 2), + firstPath = _Node$first4[1]; + + path = firstPath; + } + + var node = Node$1.get(editor, path); + + if (!Text.isText(node)) { + throw new Error("Cannot get the ".concat(edge, " point in the node at path [").concat(at, "] because it has no ").concat(edge, " text node.")); + } + + return { + path: path, + offset: edge === 'end' ? node.text.length : 0 + }; + } + + if (Range.isRange(at)) { + var _Range$edges = Range.edges(at), + _Range$edges2 = _slicedToArray(_Range$edges, 2), + start = _Range$edges2[0], + end = _Range$edges2[1]; + + return edge === 'start' ? start : end; + } + + return at; + }, + + /** + * Create a mutable ref for a `Point` object, which will stay in sync as new + * operations are applied to the editor. + */ + pointRef: function pointRef(editor, point) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var _options$affinity2 = options.affinity, + affinity = _options$affinity2 === void 0 ? 'forward' : _options$affinity2; + var ref = { + current: point, + affinity: affinity, + unref: function unref() { + var current = ref.current; + var pointRefs = Editor.pointRefs(editor); + pointRefs["delete"](ref); + ref.current = null; + return current; + } + }; + var refs = Editor.pointRefs(editor); + refs.add(ref); + return ref; + }, + + /** + * Get the set of currently tracked point refs of the editor. + */ + pointRefs: function pointRefs(editor) { + var refs = POINT_REFS.get(editor); + + if (!refs) { + refs = new Set(); + POINT_REFS.set(editor, refs); + } + + return refs; + }, + + /** + * Return all the positions in `at` range where a `Point` can be placed. + * + * By default, moves forward by individual offsets at a time, but + * the `unit` option can be used to to move by character, word, line, or block. + * + * The `reverse` option can be used to change iteration direction. + * + * Note: By default void nodes are treated as a single point and iteration + * will not happen inside their content unless you pass in true for the + * `voids` option, then iteration will occur. + */ + positions: function* positions(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _options$at5 = options.at, + at = _options$at5 === void 0 ? editor.selection : _options$at5, + _options$unit3 = options.unit, + unit = _options$unit3 === void 0 ? 'offset' : _options$unit3, + _options$reverse3 = options.reverse, + reverse = _options$reverse3 === void 0 ? false : _options$reverse3, + _options$voids5 = options.voids, + voids = _options$voids5 === void 0 ? false : _options$voids5; + + if (!at) { + return; + } + /** + * Algorithm notes: + * + * Each step `distance` is dynamic depending on the underlying text + * and the `unit` specified. Each step, e.g., a line or word, may + * span multiple text nodes, so we iterate through the text both on + * two levels in step-sync: + * + * `leafText` stores the text on a text leaf level, and is advanced + * through using the counters `leafTextOffset` and `leafTextRemaining`. + * + * `blockText` stores the text on a block level, and is shortened + * by `distance` every time it is advanced. + * + * We only maintain a window of one blockText and one leafText because + * a block node always appears before all of its leaf nodes. + */ + + + var range = Editor.range(editor, at); + + var _Range$edges3 = Range.edges(range), + _Range$edges4 = _slicedToArray(_Range$edges3, 2), + start = _Range$edges4[0], + end = _Range$edges4[1]; + + var first = reverse ? end : start; + var isNewBlock = false; + var blockText = ''; + var distance = 0; // Distance for leafText to catch up to blockText. + + var leafTextRemaining = 0; + var leafTextOffset = 0; // Iterate through all nodes in range, grabbing entire textual content + // of block nodes in blockText, and text nodes in leafText. + // Exploits the fact that nodes are sequenced in such a way that we first + // encounter the block node, then all of its text nodes, so when iterating + // through the blockText and leafText we just need to remember a window of + // one block node and leaf node, respectively. + + var _iterator7 = _createForOfIteratorHelper$5(Editor.nodes(editor, { + at: at, + reverse: reverse, + voids: voids + })), + _step7; + + try { + for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) { + var _step7$value = _slicedToArray(_step7.value, 2), + node = _step7$value[0], + path = _step7$value[1]; + + /* + * ELEMENT NODE - Yield position(s) for voids, collect blockText for blocks + */ + if (Element$1.isElement(node)) { + // Void nodes are a special case, so by default we will always + // yield their first point. If the `voids` option is set to true, + // then we will iterate over their content. + if (!voids && editor.isVoid(node)) { + yield Editor.start(editor, path); + continue; + } // Inline element nodes are ignored as they don't themselves + // contribute to `blockText` or `leafText` - their parent and + // children do. + + + if (editor.isInline(node)) continue; // Block element node - set `blockText` to its text content. + + if (Editor.hasInlines(editor, node)) { + // We always exhaust block nodes before encountering a new one: + // console.assert(blockText === '', + // `blockText='${blockText}' - `+ + // `not exhausted before new block node`, path) + // Ensure range considered is capped to `range`, in the + // start/end edge cases where block extends beyond range. + // Equivalent to this, but presumably more performant: + // blockRange = Editor.range(editor, ...Editor.edges(editor, path)) + // blockRange = Range.intersection(range, blockRange) // intersect + // blockText = Editor.string(editor, blockRange, { voids }) + var e = Path.isAncestor(path, end.path) ? end : Editor.end(editor, path); + var s = Path.isAncestor(path, start.path) ? start : Editor.start(editor, path); + blockText = Editor.string(editor, { + anchor: s, + focus: e + }, { + voids: voids + }); + isNewBlock = true; + } + } + /* + * TEXT LEAF NODE - Iterate through text content, yielding + * positions every `distance` offset according to `unit`. + */ + + + if (Text.isText(node)) { + var isFirst = Path.equals(path, first.path); // Proof that we always exhaust text nodes before encountering a new one: + // console.assert(leafTextRemaining <= 0, + // `leafTextRemaining=${leafTextRemaining} - `+ + // `not exhausted before new leaf text node`, path) + // Reset `leafText` counters for new text node. + + if (isFirst) { + leafTextRemaining = reverse ? first.offset : node.text.length - first.offset; + leafTextOffset = first.offset; // Works for reverse too. + } else { + leafTextRemaining = node.text.length; + leafTextOffset = reverse ? leafTextRemaining : 0; + } // Yield position at the start of node (potentially). + + + if (isFirst || isNewBlock || unit === 'offset') { + yield { + path: path, + offset: leafTextOffset + }; + isNewBlock = false; + } // Yield positions every (dynamically calculated) `distance` offset. + + + while (true) { + // If `leafText` has caught up with `blockText` (distance=0), + // and if blockText is exhausted, break to get another block node, + // otherwise advance blockText forward by the new `distance`. + if (distance === 0) { + if (blockText === '') break; + distance = calcDistance(blockText, unit, reverse); // Split the string at the previously found distance and use the + // remaining string for the next iteration. + + blockText = splitByCharacterDistance(blockText, distance, reverse)[1]; + } // Advance `leafText` by the current `distance`. + + + leafTextOffset = reverse ? leafTextOffset - distance : leafTextOffset + distance; + leafTextRemaining = leafTextRemaining - distance; // If `leafText` is exhausted, break to get a new leaf node + // and set distance to the overflow amount, so we'll (maybe) + // catch up to blockText in the next leaf text node. + + if (leafTextRemaining < 0) { + distance = -leafTextRemaining; + break; + } // Successfully walked `distance` offsets through `leafText` + // to catch up with `blockText`, so we can reset `distance` + // and yield this position in this node. + + + distance = 0; + yield { + path: path, + offset: leafTextOffset + }; + } + } + } // Proof that upon completion, we've exahusted both leaf and block text: + // console.assert(leafTextRemaining <= 0, "leafText wasn't exhausted") + // console.assert(blockText === '', "blockText wasn't exhausted") + // Helper: + // Return the distance in offsets for a step of size `unit` on given string. + + } catch (err) { + _iterator7.e(err); + } finally { + _iterator7.f(); + } + + function calcDistance(text, unit, reverse) { + if (unit === 'character') { + return getCharacterDistance(text, reverse); + } else if (unit === 'word') { + return getWordDistance(text, reverse); + } else if (unit === 'line' || unit === 'block') { + return text.length; + } + + return 1; + } + }, + + /** + * Get the matching node in the branch of the document before a location. + */ + previous: function previous(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _options$mode4 = options.mode, + mode = _options$mode4 === void 0 ? 'lowest' : _options$mode4, + _options$voids6 = options.voids, + voids = _options$voids6 === void 0 ? false : _options$voids6; + var match = options.match, + _options$at6 = options.at, + at = _options$at6 === void 0 ? editor.selection : _options$at6; + + if (!at) { + return; + } + + var pointBeforeLocation = Editor.before(editor, at, { + voids: voids + }); + + if (!pointBeforeLocation) { + return; + } + + var _Editor$first = Editor.first(editor, []), + _Editor$first2 = _slicedToArray(_Editor$first, 2), + to = _Editor$first2[1]; // The search location is from the start of the document to the path of + // the point before the location passed in + + + var span = [pointBeforeLocation.path, to]; + + if (Path.isPath(at) && at.length === 0) { + throw new Error("Cannot get the previous node from the root node!"); + } + + if (match == null) { + if (Path.isPath(at)) { + var _Editor$parent3 = Editor.parent(editor, at), + _Editor$parent4 = _slicedToArray(_Editor$parent3, 1), + parent = _Editor$parent4[0]; + + match = function match(n) { + return parent.children.includes(n); + }; + } else { + match = function match() { + return true; + }; + } + } + + var _Editor$nodes5 = Editor.nodes(editor, { + reverse: true, + at: span, + match: match, + mode: mode, + voids: voids + }), + _Editor$nodes6 = _slicedToArray(_Editor$nodes5, 1), + previous = _Editor$nodes6[0]; + + return previous; + }, + + /** + * Get a range of a location. + */ + range: function range(editor, at, to) { + if (Range.isRange(at) && !to) { + return at; + } + + var start = Editor.start(editor, at); + var end = Editor.end(editor, to || at); + return { + anchor: start, + focus: end + }; + }, + + /** + * Create a mutable ref for a `Range` object, which will stay in sync as new + * operations are applied to the editor. + */ + rangeRef: function rangeRef(editor, range) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var _options$affinity3 = options.affinity, + affinity = _options$affinity3 === void 0 ? 'forward' : _options$affinity3; + var ref = { + current: range, + affinity: affinity, + unref: function unref() { + var current = ref.current; + var rangeRefs = Editor.rangeRefs(editor); + rangeRefs["delete"](ref); + ref.current = null; + return current; + } + }; + var refs = Editor.rangeRefs(editor); + refs.add(ref); + return ref; + }, + + /** + * Get the set of currently tracked range refs of the editor. + */ + rangeRefs: function rangeRefs(editor) { + var refs = RANGE_REFS.get(editor); + + if (!refs) { + refs = new Set(); + RANGE_REFS.set(editor, refs); + } + + return refs; + }, + + /** + * Remove a custom property from all of the leaf text nodes in the current + * selection. + * + * If the selection is currently collapsed, the removal will be stored on + * `editor.marks` and applied to the text inserted next. + */ + removeMark: function removeMark(editor, key) { + editor.removeMark(key); + }, + + /** + * Manually set if the editor should currently be normalizing. + * + * Note: Using this incorrectly can leave the editor in an invalid state. + * + */ + setNormalizing: function setNormalizing(editor, isNormalizing) { + NORMALIZING.set(editor, isNormalizing); + }, + + /** + * Get the start point of a location. + */ + start: function start(editor, at) { + return Editor.point(editor, at, { + edge: 'start' + }); + }, + + /** + * Get the text string content of a location. + * + * Note: by default the text of void nodes is considered to be an empty + * string, regardless of content, unless you pass in true for the voids option + */ + string: function string(editor, at) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var _options$voids7 = options.voids, + voids = _options$voids7 === void 0 ? false : _options$voids7; + var range = Editor.range(editor, at); + + var _Range$edges5 = Range.edges(range), + _Range$edges6 = _slicedToArray(_Range$edges5, 2), + start = _Range$edges6[0], + end = _Range$edges6[1]; + + var text = ''; + + var _iterator8 = _createForOfIteratorHelper$5(Editor.nodes(editor, { + at: range, + match: Text.isText, + voids: voids + })), + _step8; + + try { + for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) { + var _step8$value = _slicedToArray(_step8.value, 2), + node = _step8$value[0], + path = _step8$value[1]; + + var t = node.text; + + if (Path.equals(path, end.path)) { + t = t.slice(0, end.offset); + } + + if (Path.equals(path, start.path)) { + t = t.slice(start.offset); + } + + text += t; + } + } catch (err) { + _iterator8.e(err); + } finally { + _iterator8.f(); + } + + return text; + }, + + /** + * Convert a range into a non-hanging one. + */ + unhangRange: function unhangRange(editor, range) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var _options$voids8 = options.voids, + voids = _options$voids8 === void 0 ? false : _options$voids8; + + var _Range$edges7 = Range.edges(range), + _Range$edges8 = _slicedToArray(_Range$edges7, 2), + start = _Range$edges8[0], + end = _Range$edges8[1]; // PERF: exit early if we can guarantee that the range isn't hanging. + + + if (start.offset !== 0 || end.offset !== 0 || Range.isCollapsed(range)) { + return range; + } + + var endBlock = Editor.above(editor, { + at: end, + match: function match(n) { + return Editor.isBlock(editor, n); + } + }); + var blockPath = endBlock ? endBlock[1] : []; + var first = Editor.start(editor, []); + var before = { + anchor: first, + focus: end + }; + var skip = true; + + var _iterator9 = _createForOfIteratorHelper$5(Editor.nodes(editor, { + at: before, + match: Text.isText, + reverse: true, + voids: voids + })), + _step9; + + try { + for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) { + var _step9$value = _slicedToArray(_step9.value, 2), + node = _step9$value[0], + path = _step9$value[1]; + + if (skip) { + skip = false; + continue; + } + + if (node.text !== '' || Path.isBefore(path, blockPath)) { + end = { + path: path, + offset: node.text.length + }; + break; + } + } + } catch (err) { + _iterator9.e(err); + } finally { + _iterator9.f(); + } + + return { + anchor: start, + focus: end + }; + }, + + /** + * Match a void node in the current branch of the editor. + */ + "void": function _void(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + return Editor.above(editor, _objectSpread$8(_objectSpread$8({}, options), {}, { + match: function match(n) { + return Editor.isVoid(editor, n); + } + })); + }, + + /** + * Call a function, deferring normalization until after it completes. + */ + withoutNormalizing: function withoutNormalizing(editor, fn) { + var value = Editor.isNormalizing(editor); + Editor.setNormalizing(editor, false); + + try { + fn(); + } finally { + Editor.setNormalizing(editor, value); + } + + Editor.normalize(editor); + } + }; + + var Location = { + /** + * Check if a value implements the `Location` interface. + */ + isLocation: function isLocation(value) { + return Path.isPath(value) || Point.isPoint(value) || Range.isRange(value); + } + }; + var Span = { + /** + * Check if a value implements the `Span` interface. + */ + isSpan: function isSpan(value) { + return Array.isArray(value) && value.length === 2 && value.every(Path.isPath); + } + }; + + var _excluded$3 = ["children"], + _excluded2$2 = ["text"]; + + function _createForOfIteratorHelper$4(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$4(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } + + function _unsupportedIterableToArray$4(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$4(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$4(o, minLen); } + + function _arrayLikeToArray$4(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; } + var IS_NODE_LIST_CACHE = new WeakMap(); + var Node$1 = { + /** + * Get the node at a specific path, asserting that it's an ancestor node. + */ + ancestor: function ancestor(root, path) { + var node = Node$1.get(root, path); + + if (Text.isText(node)) { + throw new Error("Cannot get the ancestor node at path [".concat(path, "] because it refers to a text node instead: ").concat(node)); + } + + return node; + }, + + /** + * Return a generator of all the ancestor nodes above a specific path. + * + * By default the order is bottom-up, from lowest to highest ancestor in + * the tree, but you can pass the `reverse: true` option to go top-down. + */ + ancestors: function* ancestors(root, path) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + var _iterator = _createForOfIteratorHelper$4(Path.ancestors(path, options)), + _step; + + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var p = _step.value; + var n = Node$1.ancestor(root, p); + var entry = [n, p]; + yield entry; + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } + }, + + /** + * Get the child of a node at a specific index. + */ + child: function child(root, index) { + if (Text.isText(root)) { + throw new Error("Cannot get the child of a text node: ".concat(JSON.stringify(root))); + } + + var c = root.children[index]; + + if (c == null) { + throw new Error("Cannot get child at index `".concat(index, "` in node: ").concat(JSON.stringify(root))); + } + + return c; + }, + + /** + * Iterate over the children of a node at a specific path. + */ + children: function* children(root, path) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var _options$reverse = options.reverse, + reverse = _options$reverse === void 0 ? false : _options$reverse; + var ancestor = Node$1.ancestor(root, path); + var children = ancestor.children; + var index = reverse ? children.length - 1 : 0; + + while (reverse ? index >= 0 : index < children.length) { + var child = Node$1.child(ancestor, index); + var childPath = path.concat(index); + yield [child, childPath]; + index = reverse ? index - 1 : index + 1; + } + }, + + /** + * Get an entry for the common ancesetor node of two paths. + */ + common: function common(root, path, another) { + var p = Path.common(path, another); + var n = Node$1.get(root, p); + return [n, p]; + }, + + /** + * Get the node at a specific path, asserting that it's a descendant node. + */ + descendant: function descendant(root, path) { + var node = Node$1.get(root, path); + + if (Editor.isEditor(node)) { + throw new Error("Cannot get the descendant node at path [".concat(path, "] because it refers to the root editor node instead: ").concat(node)); + } + + return node; + }, + + /** + * Return a generator of all the descendant node entries inside a root node. + */ + descendants: function* descendants(root) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + var _iterator2 = _createForOfIteratorHelper$4(Node$1.nodes(root, options)), + _step2; + + try { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { + var _step2$value = _slicedToArray(_step2.value, 2), + node = _step2$value[0], + path = _step2$value[1]; + + if (path.length !== 0) { + // NOTE: we have to coerce here because checking the path's length does + // guarantee that `node` is not a `Editor`, but TypeScript doesn't know. + yield [node, path]; + } + } + } catch (err) { + _iterator2.e(err); + } finally { + _iterator2.f(); + } + }, + + /** + * Return a generator of all the element nodes inside a root node. Each iteration + * will return an `ElementEntry` tuple consisting of `[Element, Path]`. If the + * root node is an element it will be included in the iteration as well. + */ + elements: function* elements(root) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + var _iterator3 = _createForOfIteratorHelper$4(Node$1.nodes(root, options)), + _step3; + + try { + for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) { + var _step3$value = _slicedToArray(_step3.value, 2), + node = _step3$value[0], + path = _step3$value[1]; + + if (Element$1.isElement(node)) { + yield [node, path]; + } + } + } catch (err) { + _iterator3.e(err); + } finally { + _iterator3.f(); + } + }, + + /** + * Extract props from a Node. + */ + extractProps: function extractProps(node) { + if (Element$1.isAncestor(node)) { + node.children; + var properties = _objectWithoutProperties(node, _excluded$3); + + return properties; + } else { + node.text; + var _properties = _objectWithoutProperties(node, _excluded2$2); + + return _properties; + } + }, + + /** + * Get the first node entry in a root node from a path. + */ + first: function first(root, path) { + var p = path.slice(); + var n = Node$1.get(root, p); + + while (n) { + if (Text.isText(n) || n.children.length === 0) { + break; + } else { + n = n.children[0]; + p.push(0); + } + } + + return [n, p]; + }, + + /** + * Get the sliced fragment represented by a range inside a root node. + */ + fragment: function fragment(root, range) { + if (Text.isText(root)) { + throw new Error("Cannot get a fragment starting from a root text node: ".concat(JSON.stringify(root))); + } + + var newRoot = immer.produce({ + children: root.children + }, function (r) { + var _Range$edges = Range.edges(range), + _Range$edges2 = _slicedToArray(_Range$edges, 2), + start = _Range$edges2[0], + end = _Range$edges2[1]; + + var nodeEntries = Node$1.nodes(r, { + reverse: true, + pass: function pass(_ref) { + var _ref2 = _slicedToArray(_ref, 2), + path = _ref2[1]; + + return !Range.includes(range, path); + } + }); + + var _iterator4 = _createForOfIteratorHelper$4(nodeEntries), + _step4; + + try { + for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) { + var _step4$value = _slicedToArray(_step4.value, 2), + path = _step4$value[1]; + + if (!Range.includes(range, path)) { + var parent = Node$1.parent(r, path); + var index = path[path.length - 1]; + parent.children.splice(index, 1); + } + + if (Path.equals(path, end.path)) { + var leaf = Node$1.leaf(r, path); + leaf.text = leaf.text.slice(0, end.offset); + } + + if (Path.equals(path, start.path)) { + var _leaf = Node$1.leaf(r, path); + + _leaf.text = _leaf.text.slice(start.offset); + } + } + } catch (err) { + _iterator4.e(err); + } finally { + _iterator4.f(); + } + + if (Editor.isEditor(r)) { + r.selection = null; + } + }); + return newRoot.children; + }, + + /** + * Get the descendant node referred to by a specific path. If the path is an + * empty array, it refers to the root node itself. + */ + get: function get(root, path) { + var node = root; + + for (var i = 0; i < path.length; i++) { + var p = path[i]; + + if (Text.isText(node) || !node.children[p]) { + throw new Error("Cannot find a descendant at path [".concat(path, "] in node: ").concat(JSON.stringify(root))); + } + + node = node.children[p]; + } + + return node; + }, + + /** + * Check if a descendant node exists at a specific path. + */ + has: function has(root, path) { + var node = root; + + for (var i = 0; i < path.length; i++) { + var p = path[i]; + + if (Text.isText(node) || !node.children[p]) { + return false; + } + + node = node.children[p]; + } + + return true; + }, + + /** + * Check if a value implements the `Node` interface. + */ + isNode: function isNode(value) { + return Text.isText(value) || Element$1.isElement(value) || Editor.isEditor(value); + }, + + /** + * Check if a value is a list of `Node` objects. + */ + isNodeList: function isNodeList(value) { + if (!Array.isArray(value)) { + return false; + } + + var cachedResult = IS_NODE_LIST_CACHE.get(value); + + if (cachedResult !== undefined) { + return cachedResult; + } + + var isNodeList = value.every(function (val) { + return Node$1.isNode(val); + }); + IS_NODE_LIST_CACHE.set(value, isNodeList); + return isNodeList; + }, + + /** + * Get the last node entry in a root node from a path. + */ + last: function last(root, path) { + var p = path.slice(); + var n = Node$1.get(root, p); + + while (n) { + if (Text.isText(n) || n.children.length === 0) { + break; + } else { + var i = n.children.length - 1; + n = n.children[i]; + p.push(i); + } + } + + return [n, p]; + }, + + /** + * Get the node at a specific path, ensuring it's a leaf text node. + */ + leaf: function leaf(root, path) { + var node = Node$1.get(root, path); + + if (!Text.isText(node)) { + throw new Error("Cannot get the leaf node at path [".concat(path, "] because it refers to a non-leaf node: ").concat(node)); + } + + return node; + }, + + /** + * Return a generator of the in a branch of the tree, from a specific path. + * + * By default the order is top-down, from lowest to highest node in the tree, + * but you can pass the `reverse: true` option to go bottom-up. + */ + levels: function* levels(root, path) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + var _iterator5 = _createForOfIteratorHelper$4(Path.levels(path, options)), + _step5; + + try { + for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) { + var p = _step5.value; + var n = Node$1.get(root, p); + yield [n, p]; + } + } catch (err) { + _iterator5.e(err); + } finally { + _iterator5.f(); + } + }, + + /** + * Check if a node matches a set of props. + */ + matches: function matches(node, props) { + return Element$1.isElement(node) && Element$1.isElementProps(props) && Element$1.matches(node, props) || Text.isText(node) && Text.isTextProps(props) && Text.matches(node, props); + }, + + /** + * Return a generator of all the node entries of a root node. Each entry is + * returned as a `[Node, Path]` tuple, with the path referring to the node's + * position inside the root node. + */ + nodes: function* nodes(root) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var pass = options.pass, + _options$reverse2 = options.reverse, + reverse = _options$reverse2 === void 0 ? false : _options$reverse2; + var _options$from = options.from, + from = _options$from === void 0 ? [] : _options$from, + to = options.to; + var visited = new Set(); + var p = []; + var n = root; + + while (true) { + if (to && (reverse ? Path.isBefore(p, to) : Path.isAfter(p, to))) { + break; + } + + if (!visited.has(n)) { + yield [n, p]; + } // If we're allowed to go downward and we haven't descended yet, do. + + + if (!visited.has(n) && !Text.isText(n) && n.children.length !== 0 && (pass == null || pass([n, p]) === false)) { + visited.add(n); + var nextIndex = reverse ? n.children.length - 1 : 0; + + if (Path.isAncestor(p, from)) { + nextIndex = from[p.length]; + } + + p = p.concat(nextIndex); + n = Node$1.get(root, p); + continue; + } // If we're at the root and we can't go down, we're done. + + + if (p.length === 0) { + break; + } // If we're going forward... + + + if (!reverse) { + var newPath = Path.next(p); + + if (Node$1.has(root, newPath)) { + p = newPath; + n = Node$1.get(root, p); + continue; + } + } // If we're going backward... + + + if (reverse && p[p.length - 1] !== 0) { + var _newPath = Path.previous(p); + + p = _newPath; + n = Node$1.get(root, p); + continue; + } // Otherwise we're going upward... + + + p = Path.parent(p); + n = Node$1.get(root, p); + visited.add(n); + } + }, + + /** + * Get the parent of a node at a specific path. + */ + parent: function parent(root, path) { + var parentPath = Path.parent(path); + var p = Node$1.get(root, parentPath); + + if (Text.isText(p)) { + throw new Error("Cannot get the parent of path [".concat(path, "] because it does not exist in the root.")); + } + + return p; + }, + + /** + * Get the concatenated text string of a node's content. + * + * Note that this will not include spaces or line breaks between block nodes. + * It is not a user-facing string, but a string for performing offset-related + * computations for a node. + */ + string: function string(node) { + if (Text.isText(node)) { + return node.text; + } else { + return node.children.map(Node$1.string).join(''); + } + }, + + /** + * Return a generator of all leaf text nodes in a root node. + */ + texts: function* texts(root) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + var _iterator6 = _createForOfIteratorHelper$4(Node$1.nodes(root, options)), + _step6; + + try { + for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) { + var _step6$value = _slicedToArray(_step6.value, 2), + node = _step6$value[0], + path = _step6$value[1]; + + if (Text.isText(node)) { + yield [node, path]; + } + } + } catch (err) { + _iterator6.e(err); + } finally { + _iterator6.f(); + } + } + }; + + function ownKeys$7(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + + function _objectSpread$7(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$7(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$7(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + var Operation = { + /** + * Check of a value is a `NodeOperation` object. + */ + isNodeOperation: function isNodeOperation(value) { + return Operation.isOperation(value) && value.type.endsWith('_node'); + }, + + /** + * Check of a value is an `Operation` object. + */ + isOperation: function isOperation(value) { + if (!isPlainObject.isPlainObject(value)) { + return false; + } + + switch (value.type) { + case 'insert_node': + return Path.isPath(value.path) && Node$1.isNode(value.node); + + case 'insert_text': + return typeof value.offset === 'number' && typeof value.text === 'string' && Path.isPath(value.path); + + case 'merge_node': + return typeof value.position === 'number' && Path.isPath(value.path) && isPlainObject.isPlainObject(value.properties); + + case 'move_node': + return Path.isPath(value.path) && Path.isPath(value.newPath); + + case 'remove_node': + return Path.isPath(value.path) && Node$1.isNode(value.node); + + case 'remove_text': + return typeof value.offset === 'number' && typeof value.text === 'string' && Path.isPath(value.path); + + case 'set_node': + return Path.isPath(value.path) && isPlainObject.isPlainObject(value.properties) && isPlainObject.isPlainObject(value.newProperties); + + case 'set_selection': + return value.properties === null && Range.isRange(value.newProperties) || value.newProperties === null && Range.isRange(value.properties) || isPlainObject.isPlainObject(value.properties) && isPlainObject.isPlainObject(value.newProperties); + + case 'split_node': + return Path.isPath(value.path) && typeof value.position === 'number' && isPlainObject.isPlainObject(value.properties); + + default: + return false; + } + }, + + /** + * Check if a value is a list of `Operation` objects. + */ + isOperationList: function isOperationList(value) { + return Array.isArray(value) && value.every(function (val) { + return Operation.isOperation(val); + }); + }, + + /** + * Check of a value is a `SelectionOperation` object. + */ + isSelectionOperation: function isSelectionOperation(value) { + return Operation.isOperation(value) && value.type.endsWith('_selection'); + }, + + /** + * Check of a value is a `TextOperation` object. + */ + isTextOperation: function isTextOperation(value) { + return Operation.isOperation(value) && value.type.endsWith('_text'); + }, + + /** + * Invert an operation, returning a new operation that will exactly undo the + * original when applied. + */ + inverse: function inverse(op) { + switch (op.type) { + case 'insert_node': + { + return _objectSpread$7(_objectSpread$7({}, op), {}, { + type: 'remove_node' + }); + } + + case 'insert_text': + { + return _objectSpread$7(_objectSpread$7({}, op), {}, { + type: 'remove_text' + }); + } + + case 'merge_node': + { + return _objectSpread$7(_objectSpread$7({}, op), {}, { + type: 'split_node', + path: Path.previous(op.path) + }); + } + + case 'move_node': + { + var newPath = op.newPath, + path = op.path; // PERF: in this case the move operation is a no-op anyways. + + if (Path.equals(newPath, path)) { + return op; + } // If the move happens completely within a single parent the path and + // newPath are stable with respect to each other. + + + if (Path.isSibling(path, newPath)) { + return _objectSpread$7(_objectSpread$7({}, op), {}, { + path: newPath, + newPath: path + }); + } // If the move does not happen within a single parent it is possible + // for the move to impact the true path to the location where the node + // was removed from and where it was inserted. We have to adjust for this + // and find the original path. We can accomplish this (only in non-sibling) + // moves by looking at the impact of the move operation on the node + // after the original move path. + + + var inversePath = Path.transform(path, op); + var inverseNewPath = Path.transform(Path.next(path), op); + return _objectSpread$7(_objectSpread$7({}, op), {}, { + path: inversePath, + newPath: inverseNewPath + }); + } + + case 'remove_node': + { + return _objectSpread$7(_objectSpread$7({}, op), {}, { + type: 'insert_node' + }); + } + + case 'remove_text': + { + return _objectSpread$7(_objectSpread$7({}, op), {}, { + type: 'insert_text' + }); + } + + case 'set_node': + { + var properties = op.properties, + newProperties = op.newProperties; + return _objectSpread$7(_objectSpread$7({}, op), {}, { + properties: newProperties, + newProperties: properties + }); + } + + case 'set_selection': + { + var _properties = op.properties, + _newProperties = op.newProperties; + + if (_properties == null) { + return _objectSpread$7(_objectSpread$7({}, op), {}, { + properties: _newProperties, + newProperties: null + }); + } else if (_newProperties == null) { + return _objectSpread$7(_objectSpread$7({}, op), {}, { + properties: null, + newProperties: _properties + }); + } else { + return _objectSpread$7(_objectSpread$7({}, op), {}, { + properties: _newProperties, + newProperties: _properties + }); + } + } + + case 'split_node': + { + return _objectSpread$7(_objectSpread$7({}, op), {}, { + type: 'merge_node', + path: Path.next(op.path) + }); + } + } + } + }; + + var Path = { + /** + * Get a list of ancestor paths for a given path. + * + * The paths are sorted from deepest to shallowest ancestor. However, if the + * `reverse: true` option is passed, they are reversed. + */ + ancestors: function ancestors(path) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _options$reverse = options.reverse, + reverse = _options$reverse === void 0 ? false : _options$reverse; + var paths = Path.levels(path, options); + + if (reverse) { + paths = paths.slice(1); + } else { + paths = paths.slice(0, -1); + } + + return paths; + }, + + /** + * Get the common ancestor path of two paths. + */ + common: function common(path, another) { + var common = []; + + for (var i = 0; i < path.length && i < another.length; i++) { + var av = path[i]; + var bv = another[i]; + + if (av !== bv) { + break; + } + + common.push(av); + } + + return common; + }, + + /** + * Compare a path to another, returning an integer indicating whether the path + * was before, at, or after the other. + * + * Note: Two paths of unequal length can still receive a `0` result if one is + * directly above or below the other. If you want exact matching, use + * [[Path.equals]] instead. + */ + compare: function compare(path, another) { + var min = Math.min(path.length, another.length); + + for (var i = 0; i < min; i++) { + if (path[i] < another[i]) return -1; + if (path[i] > another[i]) return 1; + } + + return 0; + }, + + /** + * Check if a path ends after one of the indexes in another. + */ + endsAfter: function endsAfter(path, another) { + var i = path.length - 1; + var as = path.slice(0, i); + var bs = another.slice(0, i); + var av = path[i]; + var bv = another[i]; + return Path.equals(as, bs) && av > bv; + }, + + /** + * Check if a path ends at one of the indexes in another. + */ + endsAt: function endsAt(path, another) { + var i = path.length; + var as = path.slice(0, i); + var bs = another.slice(0, i); + return Path.equals(as, bs); + }, + + /** + * Check if a path ends before one of the indexes in another. + */ + endsBefore: function endsBefore(path, another) { + var i = path.length - 1; + var as = path.slice(0, i); + var bs = another.slice(0, i); + var av = path[i]; + var bv = another[i]; + return Path.equals(as, bs) && av < bv; + }, + + /** + * Check if a path is exactly equal to another. + */ + equals: function equals(path, another) { + return path.length === another.length && path.every(function (n, i) { + return n === another[i]; + }); + }, + + /** + * Check if the path of previous sibling node exists + */ + hasPrevious: function hasPrevious(path) { + return path[path.length - 1] > 0; + }, + + /** + * Check if a path is after another. + */ + isAfter: function isAfter(path, another) { + return Path.compare(path, another) === 1; + }, + + /** + * Check if a path is an ancestor of another. + */ + isAncestor: function isAncestor(path, another) { + return path.length < another.length && Path.compare(path, another) === 0; + }, + + /** + * Check if a path is before another. + */ + isBefore: function isBefore(path, another) { + return Path.compare(path, another) === -1; + }, + + /** + * Check if a path is a child of another. + */ + isChild: function isChild(path, another) { + return path.length === another.length + 1 && Path.compare(path, another) === 0; + }, + + /** + * Check if a path is equal to or an ancestor of another. + */ + isCommon: function isCommon(path, another) { + return path.length <= another.length && Path.compare(path, another) === 0; + }, + + /** + * Check if a path is a descendant of another. + */ + isDescendant: function isDescendant(path, another) { + return path.length > another.length && Path.compare(path, another) === 0; + }, + + /** + * Check if a path is the parent of another. + */ + isParent: function isParent(path, another) { + return path.length + 1 === another.length && Path.compare(path, another) === 0; + }, + + /** + * Check is a value implements the `Path` interface. + */ + isPath: function isPath(value) { + return Array.isArray(value) && (value.length === 0 || typeof value[0] === 'number'); + }, + + /** + * Check if a path is a sibling of another. + */ + isSibling: function isSibling(path, another) { + if (path.length !== another.length) { + return false; + } + + var as = path.slice(0, -1); + var bs = another.slice(0, -1); + var al = path[path.length - 1]; + var bl = another[another.length - 1]; + return al !== bl && Path.equals(as, bs); + }, + + /** + * Get a list of paths at every level down to a path. Note: this is the same + * as `Path.ancestors`, but including the path itself. + * + * The paths are sorted from shallowest to deepest. However, if the `reverse: + * true` option is passed, they are reversed. + */ + levels: function levels(path) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _options$reverse2 = options.reverse, + reverse = _options$reverse2 === void 0 ? false : _options$reverse2; + var list = []; + + for (var i = 0; i <= path.length; i++) { + list.push(path.slice(0, i)); + } + + if (reverse) { + list.reverse(); + } + + return list; + }, + + /** + * Given a path, get the path to the next sibling node. + */ + next: function next(path) { + if (path.length === 0) { + throw new Error("Cannot get the next path of a root path [".concat(path, "], because it has no next index.")); + } + + var last = path[path.length - 1]; + return path.slice(0, -1).concat(last + 1); + }, + + /** + * Given a path, return a new path referring to the parent node above it. + */ + parent: function parent(path) { + if (path.length === 0) { + throw new Error("Cannot get the parent path of the root path [".concat(path, "].")); + } + + return path.slice(0, -1); + }, + + /** + * Given a path, get the path to the previous sibling node. + */ + previous: function previous(path) { + if (path.length === 0) { + throw new Error("Cannot get the previous path of a root path [".concat(path, "], because it has no previous index.")); + } + + var last = path[path.length - 1]; + + if (last <= 0) { + throw new Error("Cannot get the previous path of a first child path [".concat(path, "] because it would result in a negative index.")); + } + + return path.slice(0, -1).concat(last - 1); + }, + + /** + * Get a path relative to an ancestor. + */ + relative: function relative(path, ancestor) { + if (!Path.isAncestor(ancestor, path) && !Path.equals(path, ancestor)) { + throw new Error("Cannot get the relative path of [".concat(path, "] inside ancestor [").concat(ancestor, "], because it is not above or equal to the path.")); + } + + return path.slice(ancestor.length); + }, + + /** + * Transform a path by an operation. + */ + transform: function transform(path, operation) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + return immer.produce(path, function (p) { + var _options$affinity = options.affinity, + affinity = _options$affinity === void 0 ? 'forward' : _options$affinity; // PERF: Exit early if the operation is guaranteed not to have an effect. + + if (!path || (path === null || path === void 0 ? void 0 : path.length) === 0) { + return; + } + + if (p === null) { + return null; + } + + switch (operation.type) { + case 'insert_node': + { + var op = operation.path; + + if (Path.equals(op, p) || Path.endsBefore(op, p) || Path.isAncestor(op, p)) { + p[op.length - 1] += 1; + } + + break; + } + + case 'remove_node': + { + var _op = operation.path; + + if (Path.equals(_op, p) || Path.isAncestor(_op, p)) { + return null; + } else if (Path.endsBefore(_op, p)) { + p[_op.length - 1] -= 1; + } + + break; + } + + case 'merge_node': + { + var _op2 = operation.path, + position = operation.position; + + if (Path.equals(_op2, p) || Path.endsBefore(_op2, p)) { + p[_op2.length - 1] -= 1; + } else if (Path.isAncestor(_op2, p)) { + p[_op2.length - 1] -= 1; + p[_op2.length] += position; + } + + break; + } + + case 'split_node': + { + var _op3 = operation.path, + _position = operation.position; + + if (Path.equals(_op3, p)) { + if (affinity === 'forward') { + p[p.length - 1] += 1; + } else if (affinity === 'backward') ; else { + return null; + } + } else if (Path.endsBefore(_op3, p)) { + p[_op3.length - 1] += 1; + } else if (Path.isAncestor(_op3, p) && path[_op3.length] >= _position) { + p[_op3.length - 1] += 1; + p[_op3.length] -= _position; + } + + break; + } + + case 'move_node': + { + var _op4 = operation.path, + onp = operation.newPath; // If the old and new path are the same, it's a no-op. + + if (Path.equals(_op4, onp)) { + return; + } + + if (Path.isAncestor(_op4, p) || Path.equals(_op4, p)) { + var copy = onp.slice(); + + if (Path.endsBefore(_op4, onp) && _op4.length < onp.length) { + copy[_op4.length - 1] -= 1; + } + + return copy.concat(p.slice(_op4.length)); + } else if (Path.isSibling(_op4, onp) && (Path.isAncestor(onp, p) || Path.equals(onp, p))) { + if (Path.endsBefore(_op4, p)) { + p[_op4.length - 1] -= 1; + } else { + p[_op4.length - 1] += 1; + } + } else if (Path.endsBefore(onp, p) || Path.equals(onp, p) || Path.isAncestor(onp, p)) { + if (Path.endsBefore(_op4, p)) { + p[_op4.length - 1] -= 1; + } + + p[onp.length - 1] += 1; + } else if (Path.endsBefore(_op4, p)) { + if (Path.equals(onp, p)) { + p[onp.length - 1] += 1; + } + + p[_op4.length - 1] -= 1; + } + + break; + } + } + }); + } + }; + + var PathRef = { + /** + * Transform the path ref's current value by an operation. + */ + transform: function transform(ref, op) { + var current = ref.current, + affinity = ref.affinity; + + if (current == null) { + return; + } + + var path = Path.transform(current, op, { + affinity: affinity + }); + ref.current = path; + + if (path == null) { + ref.unref(); + } + } + }; + + function ownKeys$6(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + + function _objectSpread$6(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$6(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$6(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + var Point = { + /** + * Compare a point to another, returning an integer indicating whether the + * point was before, at, or after the other. + */ + compare: function compare(point, another) { + var result = Path.compare(point.path, another.path); + + if (result === 0) { + if (point.offset < another.offset) return -1; + if (point.offset > another.offset) return 1; + return 0; + } + + return result; + }, + + /** + * Check if a point is after another. + */ + isAfter: function isAfter(point, another) { + return Point.compare(point, another) === 1; + }, + + /** + * Check if a point is before another. + */ + isBefore: function isBefore(point, another) { + return Point.compare(point, another) === -1; + }, + + /** + * Check if a point is exactly equal to another. + */ + equals: function equals(point, another) { + // PERF: ensure the offsets are equal first since they are cheaper to check. + return point.offset === another.offset && Path.equals(point.path, another.path); + }, + + /** + * Check if a value implements the `Point` interface. + */ + isPoint: function isPoint(value) { + return isPlainObject.isPlainObject(value) && typeof value.offset === 'number' && Path.isPath(value.path); + }, + + /** + * Transform a point by an operation. + */ + transform: function transform(point, op) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + return immer.produce(point, function (p) { + if (p === null) { + return null; + } + + var _options$affinity = options.affinity, + affinity = _options$affinity === void 0 ? 'forward' : _options$affinity; + var path = p.path, + offset = p.offset; + + switch (op.type) { + case 'insert_node': + case 'move_node': + { + p.path = Path.transform(path, op, options); + break; + } + + case 'insert_text': + { + if (Path.equals(op.path, path) && op.offset <= offset) { + p.offset += op.text.length; + } + + break; + } + + case 'merge_node': + { + if (Path.equals(op.path, path)) { + p.offset += op.position; + } + + p.path = Path.transform(path, op, options); + break; + } + + case 'remove_text': + { + if (Path.equals(op.path, path) && op.offset <= offset) { + p.offset -= Math.min(offset - op.offset, op.text.length); + } + + break; + } + + case 'remove_node': + { + if (Path.equals(op.path, path) || Path.isAncestor(op.path, path)) { + return null; + } + + p.path = Path.transform(path, op, options); + break; + } + + case 'split_node': + { + if (Path.equals(op.path, path)) { + if (op.position === offset && affinity == null) { + return null; + } else if (op.position < offset || op.position === offset && affinity === 'forward') { + p.offset -= op.position; + p.path = Path.transform(path, op, _objectSpread$6(_objectSpread$6({}, options), {}, { + affinity: 'forward' + })); + } + } else { + p.path = Path.transform(path, op, options); + } + + break; + } + } + }); + } + }; + + var PointRef = { + /** + * Transform the point ref's current value by an operation. + */ + transform: function transform(ref, op) { + var current = ref.current, + affinity = ref.affinity; + + if (current == null) { + return; + } + + var point = Point.transform(current, op, { + affinity: affinity + }); + ref.current = point; + + if (point == null) { + ref.unref(); + } + } + }; + + var _excluded$2 = ["anchor", "focus"]; + + function ownKeys$5(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + + function _objectSpread$5(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$5(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$5(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + var Range = { + /** + * Get the start and end points of a range, in the order in which they appear + * in the document. + */ + edges: function edges(range) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _options$reverse = options.reverse, + reverse = _options$reverse === void 0 ? false : _options$reverse; + var anchor = range.anchor, + focus = range.focus; + return Range.isBackward(range) === reverse ? [anchor, focus] : [focus, anchor]; + }, + + /** + * Get the end point of a range. + */ + end: function end(range) { + var _Range$edges = Range.edges(range), + _Range$edges2 = _slicedToArray(_Range$edges, 2), + end = _Range$edges2[1]; + + return end; + }, + + /** + * Check if a range is exactly equal to another. + */ + equals: function equals(range, another) { + return Point.equals(range.anchor, another.anchor) && Point.equals(range.focus, another.focus); + }, + + /** + * Check if a range includes a path, a point or part of another range. + */ + includes: function includes(range, target) { + if (Range.isRange(target)) { + if (Range.includes(range, target.anchor) || Range.includes(range, target.focus)) { + return true; + } + + var _Range$edges3 = Range.edges(range), + _Range$edges4 = _slicedToArray(_Range$edges3, 2), + rs = _Range$edges4[0], + re = _Range$edges4[1]; + + var _Range$edges5 = Range.edges(target), + _Range$edges6 = _slicedToArray(_Range$edges5, 2), + ts = _Range$edges6[0], + te = _Range$edges6[1]; + + return Point.isBefore(rs, ts) && Point.isAfter(re, te); + } + + var _Range$edges7 = Range.edges(range), + _Range$edges8 = _slicedToArray(_Range$edges7, 2), + start = _Range$edges8[0], + end = _Range$edges8[1]; + + var isAfterStart = false; + var isBeforeEnd = false; + + if (Point.isPoint(target)) { + isAfterStart = Point.compare(target, start) >= 0; + isBeforeEnd = Point.compare(target, end) <= 0; + } else { + isAfterStart = Path.compare(target, start.path) >= 0; + isBeforeEnd = Path.compare(target, end.path) <= 0; + } + + return isAfterStart && isBeforeEnd; + }, + + /** + * Get the intersection of a range with another. + */ + intersection: function intersection(range, another) { + range.anchor; + range.focus; + var rest = _objectWithoutProperties(range, _excluded$2); + + var _Range$edges9 = Range.edges(range), + _Range$edges10 = _slicedToArray(_Range$edges9, 2), + s1 = _Range$edges10[0], + e1 = _Range$edges10[1]; + + var _Range$edges11 = Range.edges(another), + _Range$edges12 = _slicedToArray(_Range$edges11, 2), + s2 = _Range$edges12[0], + e2 = _Range$edges12[1]; + + var start = Point.isBefore(s1, s2) ? s2 : s1; + var end = Point.isBefore(e1, e2) ? e1 : e2; + + if (Point.isBefore(end, start)) { + return null; + } else { + return _objectSpread$5({ + anchor: start, + focus: end + }, rest); + } + }, + + /** + * Check if a range is backward, meaning that its anchor point appears in the + * document _after_ its focus point. + */ + isBackward: function isBackward(range) { + var anchor = range.anchor, + focus = range.focus; + return Point.isAfter(anchor, focus); + }, + + /** + * Check if a range is collapsed, meaning that both its anchor and focus + * points refer to the exact same position in the document. + */ + isCollapsed: function isCollapsed(range) { + var anchor = range.anchor, + focus = range.focus; + return Point.equals(anchor, focus); + }, + + /** + * Check if a range is expanded. + * + * This is the opposite of [[Range.isCollapsed]] and is provided for legibility. + */ + isExpanded: function isExpanded(range) { + return !Range.isCollapsed(range); + }, + + /** + * Check if a range is forward. + * + * This is the opposite of [[Range.isBackward]] and is provided for legibility. + */ + isForward: function isForward(range) { + return !Range.isBackward(range); + }, + + /** + * Check if a value implements the [[Range]] interface. + */ + isRange: function isRange(value) { + return isPlainObject.isPlainObject(value) && Point.isPoint(value.anchor) && Point.isPoint(value.focus); + }, + + /** + * Iterate through all of the point entries in a range. + */ + points: function* points(range) { + yield [range.anchor, 'anchor']; + yield [range.focus, 'focus']; + }, + + /** + * Get the start point of a range. + */ + start: function start(range) { + var _Range$edges13 = Range.edges(range), + _Range$edges14 = _slicedToArray(_Range$edges13, 1), + start = _Range$edges14[0]; + + return start; + }, + + /** + * Transform a range by an operation. + */ + transform: function transform(range, op) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + return immer.produce(range, function (r) { + if (r === null) { + return null; + } + + var _options$affinity = options.affinity, + affinity = _options$affinity === void 0 ? 'inward' : _options$affinity; + var affinityAnchor; + var affinityFocus; + + if (affinity === 'inward') { + // If the range is collapsed, make sure to use the same affinity to + // avoid the two points passing each other and expanding in the opposite + // direction + var isCollapsed = Range.isCollapsed(r); + + if (Range.isForward(r)) { + affinityAnchor = 'forward'; + affinityFocus = isCollapsed ? affinityAnchor : 'backward'; + } else { + affinityAnchor = 'backward'; + affinityFocus = isCollapsed ? affinityAnchor : 'forward'; + } + } else if (affinity === 'outward') { + if (Range.isForward(r)) { + affinityAnchor = 'backward'; + affinityFocus = 'forward'; + } else { + affinityAnchor = 'forward'; + affinityFocus = 'backward'; + } + } else { + affinityAnchor = affinity; + affinityFocus = affinity; + } + + var anchor = Point.transform(r.anchor, op, { + affinity: affinityAnchor + }); + var focus = Point.transform(r.focus, op, { + affinity: affinityFocus + }); + + if (!anchor || !focus) { + return null; + } + + r.anchor = anchor; + r.focus = focus; + }); + } + }; + + var RangeRef = { + /** + * Transform the range ref's current value by an operation. + */ + transform: function transform(ref, op) { + var current = ref.current, + affinity = ref.affinity; + + if (current == null) { + return; + } + + var path = Range.transform(current, op, { + affinity: affinity + }); + ref.current = path; + + if (path == null) { + ref.unref(); + } + } + }; + + /* + Custom deep equal comparison for Slate nodes. + + We don't need general purpose deep equality; + Slate only supports plain values, Arrays, and nested objects. + Complex values nested inside Arrays are not supported. + + Slate objects are designed to be serialised, so + missing keys are deliberately normalised to undefined. + */ + + var isDeepEqual = function isDeepEqual(node, another) { + for (var key in node) { + var a = node[key]; + var b = another[key]; + + if (isPlainObject.isPlainObject(a) && isPlainObject.isPlainObject(b)) { + if (!isDeepEqual(a, b)) return false; + } else if (Array.isArray(a) && Array.isArray(b)) { + if (a.length !== b.length) return false; + + for (var i = 0; i < a.length; i++) { + if (a[i] !== b[i]) return false; + } + } else if (a !== b) { + return false; + } + } + /* + Deep object equality is only necessary in one direction; in the reverse direction + we are only looking for keys that are missing. + As above, undefined keys are normalised to missing. + */ + + + for (var _key in another) { + if (node[_key] === undefined && another[_key] !== undefined) { + return false; + } + } + + return true; + }; + + var _excluded$1 = ["text"], + _excluded2$1 = ["anchor", "focus"]; + + function _createForOfIteratorHelper$3(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$3(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } + + function _unsupportedIterableToArray$3(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$3(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$3(o, minLen); } + + function _arrayLikeToArray$3(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; } + + function ownKeys$4(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + + function _objectSpread$4(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$4(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$4(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + var Text = { + /** + * Check if two text nodes are equal. + * + * When loose is set, the text is not compared. This is + * used to check whether sibling text nodes can be merged. + */ + equals: function equals(text, another) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var _options$loose = options.loose, + loose = _options$loose === void 0 ? false : _options$loose; + + function omitText(obj) { + obj.text; + var rest = _objectWithoutProperties(obj, _excluded$1); + + return rest; + } + + return isDeepEqual(loose ? omitText(text) : text, loose ? omitText(another) : another); + }, + + /** + * Check if a value implements the `Text` interface. + */ + isText: function isText(value) { + return isPlainObject.isPlainObject(value) && typeof value.text === 'string'; + }, + + /** + * Check if a value is a list of `Text` objects. + */ + isTextList: function isTextList(value) { + return Array.isArray(value) && value.every(function (val) { + return Text.isText(val); + }); + }, + + /** + * Check if some props are a partial of Text. + */ + isTextProps: function isTextProps(props) { + return props.text !== undefined; + }, + + /** + * Check if an text matches set of properties. + * + * Note: this is for matching custom properties, and it does not ensure that + * the `text` property are two nodes equal. + */ + matches: function matches(text, props) { + for (var key in props) { + if (key === 'text') { + continue; + } + + if (!text.hasOwnProperty(key) || text[key] !== props[key]) { + return false; + } + } + + return true; + }, + + /** + * Get the leaves for a text node given decorations. + */ + decorations: function decorations(node, _decorations) { + var leaves = [_objectSpread$4({}, node)]; + + var _iterator = _createForOfIteratorHelper$3(_decorations), + _step; + + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var dec = _step.value; + + var anchor = dec.anchor, + focus = dec.focus, + rest = _objectWithoutProperties(dec, _excluded2$1); + + var _Range$edges = Range.edges(dec), + _Range$edges2 = _slicedToArray(_Range$edges, 2), + start = _Range$edges2[0], + end = _Range$edges2[1]; + + var next = []; + var o = 0; + + var _iterator2 = _createForOfIteratorHelper$3(leaves), + _step2; + + try { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { + var leaf = _step2.value; + var length = leaf.text.length; + var offset = o; + o += length; // If the range encompases the entire leaf, add the range. + + if (start.offset <= offset && end.offset >= o) { + Object.assign(leaf, rest); + next.push(leaf); + continue; + } // If the range expanded and match the leaf, or starts after, or ends before it, continue. + + + if (start.offset !== end.offset && (start.offset === o || end.offset === offset) || start.offset > o || end.offset < offset || end.offset === offset && offset !== 0) { + next.push(leaf); + continue; + } // Otherwise we need to split the leaf, at the start, end, or both, + // and add the range to the middle intersecting section. Do the end + // split first since we don't need to update the offset that way. + + + var middle = leaf; + var before = void 0; + var after = void 0; + + if (end.offset < o) { + var off = end.offset - offset; + after = _objectSpread$4(_objectSpread$4({}, middle), {}, { + text: middle.text.slice(off) + }); + middle = _objectSpread$4(_objectSpread$4({}, middle), {}, { + text: middle.text.slice(0, off) + }); + } + + if (start.offset > offset) { + var _off = start.offset - offset; + + before = _objectSpread$4(_objectSpread$4({}, middle), {}, { + text: middle.text.slice(0, _off) + }); + middle = _objectSpread$4(_objectSpread$4({}, middle), {}, { + text: middle.text.slice(_off) + }); + } + + Object.assign(middle, rest); + + if (before) { + next.push(before); + } + + next.push(middle); + + if (after) { + next.push(after); + } + } + } catch (err) { + _iterator2.e(err); + } finally { + _iterator2.f(); + } + + leaves = next; + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } + + return leaves; + } + }; + + function ownKeys$3(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + + function _objectSpread$3(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$3(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$3(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + + function _createForOfIteratorHelper$2(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$2(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } + + function _unsupportedIterableToArray$2(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$2(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$2(o, minLen); } + + function _arrayLikeToArray$2(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; } + + var applyToDraft = function applyToDraft(editor, selection, op) { + switch (op.type) { + case 'insert_node': + { + var path = op.path, + node = op.node; + var parent = Node$1.parent(editor, path); + var index = path[path.length - 1]; + + if (index > parent.children.length) { + throw new Error("Cannot apply an \"insert_node\" operation at path [".concat(path, "] because the destination is past the end of the node.")); + } + + parent.children.splice(index, 0, node); + + if (selection) { + var _iterator = _createForOfIteratorHelper$2(Range.points(selection)), + _step; + + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var _step$value = _slicedToArray(_step.value, 2), + point = _step$value[0], + key = _step$value[1]; + + selection[key] = Point.transform(point, op); + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } + } + + break; + } + + case 'insert_text': + { + var _path = op.path, + offset = op.offset, + text = op.text; + if (text.length === 0) break; + + var _node = Node$1.leaf(editor, _path); + + var before = _node.text.slice(0, offset); + + var after = _node.text.slice(offset); + + _node.text = before + text + after; + + if (selection) { + var _iterator2 = _createForOfIteratorHelper$2(Range.points(selection)), + _step2; + + try { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { + var _step2$value = _slicedToArray(_step2.value, 2), + _point = _step2$value[0], + _key = _step2$value[1]; + + selection[_key] = Point.transform(_point, op); + } + } catch (err) { + _iterator2.e(err); + } finally { + _iterator2.f(); + } + } + + break; + } + + case 'merge_node': + { + var _path2 = op.path; + + var _node2 = Node$1.get(editor, _path2); + + var prevPath = Path.previous(_path2); + var prev = Node$1.get(editor, prevPath); + + var _parent = Node$1.parent(editor, _path2); + + var _index = _path2[_path2.length - 1]; + + if (Text.isText(_node2) && Text.isText(prev)) { + prev.text += _node2.text; + } else if (!Text.isText(_node2) && !Text.isText(prev)) { + var _prev$children; + + (_prev$children = prev.children).push.apply(_prev$children, _toConsumableArray(_node2.children)); + } else { + throw new Error("Cannot apply a \"merge_node\" operation at path [".concat(_path2, "] to nodes of different interfaces: ").concat(_node2, " ").concat(prev)); + } + + _parent.children.splice(_index, 1); + + if (selection) { + var _iterator3 = _createForOfIteratorHelper$2(Range.points(selection)), + _step3; + + try { + for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) { + var _step3$value = _slicedToArray(_step3.value, 2), + _point2 = _step3$value[0], + _key2 = _step3$value[1]; + + selection[_key2] = Point.transform(_point2, op); + } + } catch (err) { + _iterator3.e(err); + } finally { + _iterator3.f(); + } + } + + break; + } + + case 'move_node': + { + var _path3 = op.path, + newPath = op.newPath; + + if (Path.isAncestor(_path3, newPath)) { + throw new Error("Cannot move a path [".concat(_path3, "] to new path [").concat(newPath, "] because the destination is inside itself.")); + } + + var _node3 = Node$1.get(editor, _path3); + + var _parent2 = Node$1.parent(editor, _path3); + + var _index2 = _path3[_path3.length - 1]; // This is tricky, but since the `path` and `newPath` both refer to + // the same snapshot in time, there's a mismatch. After either + // removing the original position, the second step's path can be out + // of date. So instead of using the `op.newPath` directly, we + // transform `op.path` to ascertain what the `newPath` would be after + // the operation was applied. + + _parent2.children.splice(_index2, 1); + + var truePath = Path.transform(_path3, op); + var newParent = Node$1.get(editor, Path.parent(truePath)); + var newIndex = truePath[truePath.length - 1]; + newParent.children.splice(newIndex, 0, _node3); + + if (selection) { + var _iterator4 = _createForOfIteratorHelper$2(Range.points(selection)), + _step4; + + try { + for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) { + var _step4$value = _slicedToArray(_step4.value, 2), + _point3 = _step4$value[0], + _key3 = _step4$value[1]; + + selection[_key3] = Point.transform(_point3, op); + } + } catch (err) { + _iterator4.e(err); + } finally { + _iterator4.f(); + } + } + + break; + } + + case 'remove_node': + { + var _path4 = op.path; + var _index3 = _path4[_path4.length - 1]; + + var _parent3 = Node$1.parent(editor, _path4); + + _parent3.children.splice(_index3, 1); // Transform all of the points in the value, but if the point was in the + // node that was removed we need to update the range or remove it. + + + if (selection) { + var _iterator5 = _createForOfIteratorHelper$2(Range.points(selection)), + _step5; + + try { + for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) { + var _step5$value = _slicedToArray(_step5.value, 2), + _point4 = _step5$value[0], + _key4 = _step5$value[1]; + + var result = Point.transform(_point4, op); + + if (selection != null && result != null) { + selection[_key4] = result; + } else { + var _prev = void 0; + + var next = void 0; + + var _iterator6 = _createForOfIteratorHelper$2(Node$1.texts(editor)), + _step6; + + try { + for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) { + var _step6$value = _slicedToArray(_step6.value, 2), + n = _step6$value[0], + p = _step6$value[1]; + + if (Path.compare(p, _path4) === -1) { + _prev = [n, p]; + } else { + next = [n, p]; + break; + } + } + } catch (err) { + _iterator6.e(err); + } finally { + _iterator6.f(); + } + + var preferNext = false; + + if (_prev && next) { + if (Path.equals(next[1], _path4)) { + preferNext = !Path.hasPrevious(next[1]); + } else { + preferNext = Path.common(_prev[1], _path4).length < Path.common(next[1], _path4).length; + } + } + + if (_prev && !preferNext) { + _point4.path = _prev[1]; + _point4.offset = _prev[0].text.length; + } else if (next) { + _point4.path = next[1]; + _point4.offset = 0; + } else { + selection = null; + } + } + } + } catch (err) { + _iterator5.e(err); + } finally { + _iterator5.f(); + } + } + + break; + } + + case 'remove_text': + { + var _path5 = op.path, + _offset = op.offset, + _text = op.text; + if (_text.length === 0) break; + + var _node4 = Node$1.leaf(editor, _path5); + + var _before = _node4.text.slice(0, _offset); + + var _after = _node4.text.slice(_offset + _text.length); + + _node4.text = _before + _after; + + if (selection) { + var _iterator7 = _createForOfIteratorHelper$2(Range.points(selection)), + _step7; + + try { + for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) { + var _step7$value = _slicedToArray(_step7.value, 2), + _point5 = _step7$value[0], + _key5 = _step7$value[1]; + + selection[_key5] = Point.transform(_point5, op); + } + } catch (err) { + _iterator7.e(err); + } finally { + _iterator7.f(); + } + } + + break; + } + + case 'set_node': + { + var _path6 = op.path, + properties = op.properties, + newProperties = op.newProperties; + + if (_path6.length === 0) { + throw new Error("Cannot set properties on the root node!"); + } + + var _node5 = Node$1.get(editor, _path6); + + for (var _key6 in newProperties) { + if (_key6 === 'children' || _key6 === 'text') { + throw new Error("Cannot set the \"".concat(_key6, "\" property of nodes!")); + } + + var value = newProperties[_key6]; + + if (value == null) { + delete _node5[_key6]; + } else { + _node5[_key6] = value; + } + } // properties that were previously defined, but are now missing, must be deleted + + + for (var _key7 in properties) { + if (!newProperties.hasOwnProperty(_key7)) { + delete _node5[_key7]; + } + } + + break; + } + + case 'set_selection': + { + var _newProperties = op.newProperties; + + if (_newProperties == null) { + selection = _newProperties; + } else { + if (selection == null) { + if (!Range.isRange(_newProperties)) { + throw new Error("Cannot apply an incomplete \"set_selection\" operation properties ".concat(JSON.stringify(_newProperties), " when there is no current selection.")); + } + + selection = _objectSpread$3({}, _newProperties); + } + + for (var _key8 in _newProperties) { + var _value = _newProperties[_key8]; + + if (_value == null) { + if (_key8 === 'anchor' || _key8 === 'focus') { + throw new Error("Cannot remove the \"".concat(_key8, "\" selection property")); + } + + delete selection[_key8]; + } else { + selection[_key8] = _value; + } + } + } + + break; + } + + case 'split_node': + { + var _path7 = op.path, + position = op.position, + _properties = op.properties; + + if (_path7.length === 0) { + throw new Error("Cannot apply a \"split_node\" operation at path [".concat(_path7, "] because the root node cannot be split.")); + } + + var _node6 = Node$1.get(editor, _path7); + + var _parent4 = Node$1.parent(editor, _path7); + + var _index4 = _path7[_path7.length - 1]; + var newNode; + + if (Text.isText(_node6)) { + var _before2 = _node6.text.slice(0, position); + + var _after2 = _node6.text.slice(position); + + _node6.text = _before2; + newNode = _objectSpread$3(_objectSpread$3({}, _properties), {}, { + text: _after2 + }); + } else { + var _before3 = _node6.children.slice(0, position); + + var _after3 = _node6.children.slice(position); + + _node6.children = _before3; + newNode = _objectSpread$3(_objectSpread$3({}, _properties), {}, { + children: _after3 + }); + } + + _parent4.children.splice(_index4 + 1, 0, newNode); + + if (selection) { + var _iterator8 = _createForOfIteratorHelper$2(Range.points(selection)), + _step8; + + try { + for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) { + var _step8$value = _slicedToArray(_step8.value, 2), + _point6 = _step8$value[0], + _key9 = _step8$value[1]; + + selection[_key9] = Point.transform(_point6, op); + } + } catch (err) { + _iterator8.e(err); + } finally { + _iterator8.f(); + } + } + + break; + } + } + + return selection; + }; + + var GeneralTransforms = { + /** + * Transform the editor by an operation. + */ + transform: function transform(editor, op) { + editor.children = immer.createDraft(editor.children); + var selection = editor.selection && immer.createDraft(editor.selection); + + try { + selection = applyToDraft(editor, selection, op); + } finally { + editor.children = immer.finishDraft(editor.children); + + if (selection) { + editor.selection = immer.isDraft(selection) ? immer.finishDraft(selection) : selection; + } else { + editor.selection = null; + } + } + } + }; + + var _excluded = ["text"], + _excluded2 = ["children"]; + + function ownKeys$2(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + + function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$2(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$2(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + + function _createForOfIteratorHelper$1(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } + + function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(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$1(o, minLen); } + + function _arrayLikeToArray$1(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; } + var NodeTransforms = { + /** + * Insert nodes at a specific location in the Editor. + */ + insertNodes: function insertNodes(editor, nodes) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + Editor.withoutNormalizing(editor, function () { + var _options$hanging = options.hanging, + hanging = _options$hanging === void 0 ? false : _options$hanging, + _options$voids = options.voids, + voids = _options$voids === void 0 ? false : _options$voids, + _options$mode = options.mode, + mode = _options$mode === void 0 ? 'lowest' : _options$mode; + var at = options.at, + match = options.match, + select = options.select; + + if (Node$1.isNode(nodes)) { + nodes = [nodes]; + } + + if (nodes.length === 0) { + return; + } + + var _nodes = nodes, + _nodes2 = _slicedToArray(_nodes, 1), + node = _nodes2[0]; // By default, use the selection as the target location. But if there is + // no selection, insert at the end of the document since that is such a + // common use case when inserting from a non-selected state. + + + if (!at) { + if (editor.selection) { + at = editor.selection; + } else if (editor.children.length > 0) { + at = Editor.end(editor, []); + } else { + at = [0]; + } + + select = true; + } + + if (select == null) { + select = false; + } + + if (Range.isRange(at)) { + if (!hanging) { + at = Editor.unhangRange(editor, at); + } + + if (Range.isCollapsed(at)) { + at = at.anchor; + } else { + var _Range$edges = Range.edges(at), + _Range$edges2 = _slicedToArray(_Range$edges, 2), + end = _Range$edges2[1]; + + var pointRef = Editor.pointRef(editor, end); + Transforms["delete"](editor, { + at: at + }); + at = pointRef.unref(); + } + } + + if (Point.isPoint(at)) { + if (match == null) { + if (Text.isText(node)) { + match = function match(n) { + return Text.isText(n); + }; + } else if (editor.isInline(node)) { + match = function match(n) { + return Text.isText(n) || Editor.isInline(editor, n); + }; + } else { + match = function match(n) { + return Editor.isBlock(editor, n); + }; + } + } + + var _Editor$nodes = Editor.nodes(editor, { + at: at.path, + match: match, + mode: mode, + voids: voids + }), + _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1), + entry = _Editor$nodes2[0]; + + if (entry) { + var _entry = _slicedToArray(entry, 2), + _matchPath = _entry[1]; + + var pathRef = Editor.pathRef(editor, _matchPath); + var isAtEnd = Editor.isEnd(editor, at, _matchPath); + Transforms.splitNodes(editor, { + at: at, + match: match, + mode: mode, + voids: voids + }); + var path = pathRef.unref(); + at = isAtEnd ? Path.next(path) : path; + } else { + return; + } + } + + var parentPath = Path.parent(at); + var index = at[at.length - 1]; + + if (!voids && Editor["void"](editor, { + at: parentPath + })) { + return; + } + + var _iterator = _createForOfIteratorHelper$1(nodes), + _step; + + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var _node = _step.value; + + var _path = parentPath.concat(index); + + index++; + editor.apply({ + type: 'insert_node', + path: _path, + node: _node + }); + at = Path.next(at); + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } + + at = Path.previous(at); + + if (select) { + var point = Editor.end(editor, at); + + if (point) { + Transforms.select(editor, point); + } + } + }); + }, + + /** + * Lift nodes at a specific location upwards in the document tree, splitting + * their parent in two if necessary. + */ + liftNodes: function liftNodes(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + Editor.withoutNormalizing(editor, function () { + var _options$at = options.at, + at = _options$at === void 0 ? editor.selection : _options$at, + _options$mode2 = options.mode, + mode = _options$mode2 === void 0 ? 'lowest' : _options$mode2, + _options$voids2 = options.voids, + voids = _options$voids2 === void 0 ? false : _options$voids2; + var match = options.match; + + if (match == null) { + match = Path.isPath(at) ? matchPath(editor, at) : function (n) { + return Editor.isBlock(editor, n); + }; + } + + if (!at) { + return; + } + + var matches = Editor.nodes(editor, { + at: at, + match: match, + mode: mode, + voids: voids + }); + var pathRefs = Array.from(matches, function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + p = _ref2[1]; + + return Editor.pathRef(editor, p); + }); + + for (var _i = 0, _pathRefs = pathRefs; _i < _pathRefs.length; _i++) { + var pathRef = _pathRefs[_i]; + var path = pathRef.unref(); + + if (path.length < 2) { + throw new Error("Cannot lift node at a path [".concat(path, "] because it has a depth of less than `2`.")); + } + + var parentNodeEntry = Editor.node(editor, Path.parent(path)); + + var _parentNodeEntry = _slicedToArray(parentNodeEntry, 2), + parent = _parentNodeEntry[0], + parentPath = _parentNodeEntry[1]; + + var index = path[path.length - 1]; + var length = parent.children.length; + + if (length === 1) { + var toPath = Path.next(parentPath); + Transforms.moveNodes(editor, { + at: path, + to: toPath, + voids: voids + }); + Transforms.removeNodes(editor, { + at: parentPath, + voids: voids + }); + } else if (index === 0) { + Transforms.moveNodes(editor, { + at: path, + to: parentPath, + voids: voids + }); + } else if (index === length - 1) { + var _toPath = Path.next(parentPath); + + Transforms.moveNodes(editor, { + at: path, + to: _toPath, + voids: voids + }); + } else { + var splitPath = Path.next(path); + + var _toPath2 = Path.next(parentPath); + + Transforms.splitNodes(editor, { + at: splitPath, + voids: voids + }); + Transforms.moveNodes(editor, { + at: path, + to: _toPath2, + voids: voids + }); + } + } + }); + }, + + /** + * Merge a node at a location with the previous node of the same depth, + * removing any empty containing nodes after the merge if necessary. + */ + mergeNodes: function mergeNodes(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + Editor.withoutNormalizing(editor, function () { + var match = options.match, + _options$at2 = options.at, + at = _options$at2 === void 0 ? editor.selection : _options$at2; + var _options$hanging2 = options.hanging, + hanging = _options$hanging2 === void 0 ? false : _options$hanging2, + _options$voids3 = options.voids, + voids = _options$voids3 === void 0 ? false : _options$voids3, + _options$mode3 = options.mode, + mode = _options$mode3 === void 0 ? 'lowest' : _options$mode3; + + if (!at) { + return; + } + + if (match == null) { + if (Path.isPath(at)) { + var _Editor$parent = Editor.parent(editor, at), + _Editor$parent2 = _slicedToArray(_Editor$parent, 1), + parent = _Editor$parent2[0]; + + match = function match(n) { + return parent.children.includes(n); + }; + } else { + match = function match(n) { + return Editor.isBlock(editor, n); + }; + } + } + + if (!hanging && Range.isRange(at)) { + at = Editor.unhangRange(editor, at); + } + + if (Range.isRange(at)) { + if (Range.isCollapsed(at)) { + at = at.anchor; + } else { + var _Range$edges3 = Range.edges(at), + _Range$edges4 = _slicedToArray(_Range$edges3, 2), + end = _Range$edges4[1]; + + var pointRef = Editor.pointRef(editor, end); + Transforms["delete"](editor, { + at: at + }); + at = pointRef.unref(); + + if (options.at == null) { + Transforms.select(editor, at); + } + } + } + + var _Editor$nodes3 = Editor.nodes(editor, { + at: at, + match: match, + voids: voids, + mode: mode + }), + _Editor$nodes4 = _slicedToArray(_Editor$nodes3, 1), + current = _Editor$nodes4[0]; + + var prev = Editor.previous(editor, { + at: at, + match: match, + voids: voids, + mode: mode + }); + + if (!current || !prev) { + return; + } + + var _current = _slicedToArray(current, 2), + node = _current[0], + path = _current[1]; + + var _prev = _slicedToArray(prev, 2), + prevNode = _prev[0], + prevPath = _prev[1]; + + if (path.length === 0 || prevPath.length === 0) { + return; + } + + var newPath = Path.next(prevPath); + var commonPath = Path.common(path, prevPath); + var isPreviousSibling = Path.isSibling(path, prevPath); + var levels = Array.from(Editor.levels(editor, { + at: path + }), function (_ref3) { + var _ref4 = _slicedToArray(_ref3, 1), + n = _ref4[0]; + + return n; + }).slice(commonPath.length).slice(0, -1); // Determine if the merge will leave an ancestor of the path empty as a + // result, in which case we'll want to remove it after merging. + + var emptyAncestor = Editor.above(editor, { + at: path, + mode: 'highest', + match: function match(n) { + return levels.includes(n) && hasSingleChildNest(editor, n); + } + }); + var emptyRef = emptyAncestor && Editor.pathRef(editor, emptyAncestor[1]); + var properties; + var position; // Ensure that the nodes are equivalent, and figure out what the position + // and extra properties of the merge will be. + + if (Text.isText(node) && Text.isText(prevNode)) { + node.text; + var rest = _objectWithoutProperties(node, _excluded); + + position = prevNode.text.length; + properties = rest; + } else if (Element$1.isElement(node) && Element$1.isElement(prevNode)) { + node.children; + var _rest = _objectWithoutProperties(node, _excluded2); + + position = prevNode.children.length; + properties = _rest; + } else { + throw new Error("Cannot merge the node at path [".concat(path, "] with the previous sibling because it is not the same kind: ").concat(JSON.stringify(node), " ").concat(JSON.stringify(prevNode))); + } // If the node isn't already the next sibling of the previous node, move + // it so that it is before merging. + + + if (!isPreviousSibling) { + Transforms.moveNodes(editor, { + at: path, + to: newPath, + voids: voids + }); + } // If there was going to be an empty ancestor of the node that was merged, + // we remove it from the tree. + + + if (emptyRef) { + Transforms.removeNodes(editor, { + at: emptyRef.current, + voids: voids + }); + } // If the target node that we're merging with is empty, remove it instead + // of merging the two. This is a common rich text editor behavior to + // prevent losing formatting when deleting entire nodes when you have a + // hanging selection. + // if prevNode is first child in parent,don't remove it. + + + if (Element$1.isElement(prevNode) && Editor.isEmpty(editor, prevNode) || Text.isText(prevNode) && prevNode.text === '' && prevPath[prevPath.length - 1] !== 0) { + Transforms.removeNodes(editor, { + at: prevPath, + voids: voids + }); + } else { + editor.apply({ + type: 'merge_node', + path: newPath, + position: position, + properties: properties + }); + } + + if (emptyRef) { + emptyRef.unref(); + } + }); + }, + + /** + * Move the nodes at a location to a new location. + */ + moveNodes: function moveNodes(editor, options) { + Editor.withoutNormalizing(editor, function () { + var to = options.to, + _options$at3 = options.at, + at = _options$at3 === void 0 ? editor.selection : _options$at3, + _options$mode4 = options.mode, + mode = _options$mode4 === void 0 ? 'lowest' : _options$mode4, + _options$voids4 = options.voids, + voids = _options$voids4 === void 0 ? false : _options$voids4; + var match = options.match; + + if (!at) { + return; + } + + if (match == null) { + match = Path.isPath(at) ? matchPath(editor, at) : function (n) { + return Editor.isBlock(editor, n); + }; + } + + var toRef = Editor.pathRef(editor, to); + var targets = Editor.nodes(editor, { + at: at, + match: match, + mode: mode, + voids: voids + }); + var pathRefs = Array.from(targets, function (_ref5) { + var _ref6 = _slicedToArray(_ref5, 2), + p = _ref6[1]; + + return Editor.pathRef(editor, p); + }); + + for (var _i2 = 0, _pathRefs2 = pathRefs; _i2 < _pathRefs2.length; _i2++) { + var pathRef = _pathRefs2[_i2]; + var path = pathRef.unref(); + var newPath = toRef.current; + + if (path.length !== 0) { + editor.apply({ + type: 'move_node', + path: path, + newPath: newPath + }); + } + + if (toRef.current && Path.isSibling(newPath, path) && Path.isAfter(newPath, path)) { + // When performing a sibling move to a later index, the path at the destination is shifted + // to before the insertion point instead of after. To ensure our group of nodes are inserted + // in the correct order we increment toRef to account for that + toRef.current = Path.next(toRef.current); + } + } + + toRef.unref(); + }); + }, + + /** + * Remove the nodes at a specific location in the document. + */ + removeNodes: function removeNodes(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + Editor.withoutNormalizing(editor, function () { + var _options$hanging3 = options.hanging, + hanging = _options$hanging3 === void 0 ? false : _options$hanging3, + _options$voids5 = options.voids, + voids = _options$voids5 === void 0 ? false : _options$voids5, + _options$mode5 = options.mode, + mode = _options$mode5 === void 0 ? 'lowest' : _options$mode5; + var _options$at4 = options.at, + at = _options$at4 === void 0 ? editor.selection : _options$at4, + match = options.match; + + if (!at) { + return; + } + + if (match == null) { + match = Path.isPath(at) ? matchPath(editor, at) : function (n) { + return Editor.isBlock(editor, n); + }; + } + + if (!hanging && Range.isRange(at)) { + at = Editor.unhangRange(editor, at); + } + + var depths = Editor.nodes(editor, { + at: at, + match: match, + mode: mode, + voids: voids + }); + var pathRefs = Array.from(depths, function (_ref7) { + var _ref8 = _slicedToArray(_ref7, 2), + p = _ref8[1]; + + return Editor.pathRef(editor, p); + }); + + for (var _i3 = 0, _pathRefs3 = pathRefs; _i3 < _pathRefs3.length; _i3++) { + var pathRef = _pathRefs3[_i3]; + var path = pathRef.unref(); + + if (path) { + var _Editor$node = Editor.node(editor, path), + _Editor$node2 = _slicedToArray(_Editor$node, 1), + node = _Editor$node2[0]; + + editor.apply({ + type: 'remove_node', + path: path, + node: node + }); + } + } + }); + }, + + /** + * Set new properties on the nodes at a location. + */ + setNodes: function setNodes(editor, props) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + Editor.withoutNormalizing(editor, function () { + var match = options.match, + _options$at5 = options.at, + at = _options$at5 === void 0 ? editor.selection : _options$at5; + var _options$hanging4 = options.hanging, + hanging = _options$hanging4 === void 0 ? false : _options$hanging4, + _options$mode6 = options.mode, + mode = _options$mode6 === void 0 ? 'lowest' : _options$mode6, + _options$split = options.split, + split = _options$split === void 0 ? false : _options$split, + _options$voids6 = options.voids, + voids = _options$voids6 === void 0 ? false : _options$voids6; + + if (!at) { + return; + } + + if (match == null) { + match = Path.isPath(at) ? matchPath(editor, at) : function (n) { + return Editor.isBlock(editor, n); + }; + } + + if (!hanging && Range.isRange(at)) { + at = Editor.unhangRange(editor, at); + } + + if (split && Range.isRange(at)) { + if (Range.isCollapsed(at) && Editor.leaf(editor, at.anchor)[0].text.length > 0) { + // If the range is collapsed in a non-empty node and 'split' is true, there's nothing to + // set that won't get normalized away + return; + } + + var rangeRef = Editor.rangeRef(editor, at, { + affinity: 'inward' + }); + + var _Range$edges5 = Range.edges(at), + _Range$edges6 = _slicedToArray(_Range$edges5, 2), + start = _Range$edges6[0], + end = _Range$edges6[1]; + + var splitMode = mode === 'lowest' ? 'lowest' : 'highest'; + var endAtEndOfNode = Editor.isEnd(editor, end, end.path); + Transforms.splitNodes(editor, { + at: end, + match: match, + mode: splitMode, + voids: voids, + always: !endAtEndOfNode + }); + var startAtStartOfNode = Editor.isStart(editor, start, start.path); + Transforms.splitNodes(editor, { + at: start, + match: match, + mode: splitMode, + voids: voids, + always: !startAtStartOfNode + }); + at = rangeRef.unref(); + + if (options.at == null) { + Transforms.select(editor, at); + } + } + + var _iterator2 = _createForOfIteratorHelper$1(Editor.nodes(editor, { + at: at, + match: match, + mode: mode, + voids: voids + })), + _step2; + + try { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { + var _step2$value = _slicedToArray(_step2.value, 2), + node = _step2$value[0], + path = _step2$value[1]; + + var properties = {}; + var newProperties = {}; // You can't set properties on the editor node. + + if (path.length === 0) { + continue; + } + + var hasChanges = false; + + for (var k in props) { + if (k === 'children' || k === 'text') { + continue; + } + + if (props[k] !== node[k]) { + hasChanges = true; // Omit new properties from the old properties list + + if (node.hasOwnProperty(k)) properties[k] = node[k]; // Omit properties that have been removed from the new properties list + + if (props[k] != null) newProperties[k] = props[k]; + } + } + + if (hasChanges) { + editor.apply({ + type: 'set_node', + path: path, + properties: properties, + newProperties: newProperties + }); + } + } + } catch (err) { + _iterator2.e(err); + } finally { + _iterator2.f(); + } + }); + }, + + /** + * Split the nodes at a specific location. + */ + splitNodes: function splitNodes(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + Editor.withoutNormalizing(editor, function () { + var _options$mode7 = options.mode, + mode = _options$mode7 === void 0 ? 'lowest' : _options$mode7, + _options$voids7 = options.voids, + voids = _options$voids7 === void 0 ? false : _options$voids7; + var match = options.match, + _options$at6 = options.at, + at = _options$at6 === void 0 ? editor.selection : _options$at6, + _options$height = options.height, + height = _options$height === void 0 ? 0 : _options$height, + _options$always = options.always, + always = _options$always === void 0 ? false : _options$always; + + if (match == null) { + match = function match(n) { + return Editor.isBlock(editor, n); + }; + } + + if (Range.isRange(at)) { + at = deleteRange(editor, at); + } // If the target is a path, the default height-skipping and position + // counters need to account for us potentially splitting at a non-leaf. + + + if (Path.isPath(at)) { + var path = at; + var point = Editor.point(editor, path); + + var _Editor$parent3 = Editor.parent(editor, path), + _Editor$parent4 = _slicedToArray(_Editor$parent3, 1), + parent = _Editor$parent4[0]; + + match = function match(n) { + return n === parent; + }; + + height = point.path.length - path.length + 1; + at = point; + always = true; + } + + if (!at) { + return; + } + + var beforeRef = Editor.pointRef(editor, at, { + affinity: 'backward' + }); + + var _Editor$nodes5 = Editor.nodes(editor, { + at: at, + match: match, + mode: mode, + voids: voids + }), + _Editor$nodes6 = _slicedToArray(_Editor$nodes5, 1), + highest = _Editor$nodes6[0]; + + if (!highest) { + return; + } + + var voidMatch = Editor["void"](editor, { + at: at, + mode: 'highest' + }); + var nudge = 0; + + if (!voids && voidMatch) { + var _voidMatch = _slicedToArray(voidMatch, 2), + voidNode = _voidMatch[0], + voidPath = _voidMatch[1]; + + if (Element$1.isElement(voidNode) && editor.isInline(voidNode)) { + var after = Editor.after(editor, voidPath); + + if (!after) { + var text = { + text: '' + }; + var afterPath = Path.next(voidPath); + Transforms.insertNodes(editor, text, { + at: afterPath, + voids: voids + }); + after = Editor.point(editor, afterPath); + } + + at = after; + always = true; + } + + var siblingHeight = at.path.length - voidPath.length; + height = siblingHeight + 1; + always = true; + } + + var afterRef = Editor.pointRef(editor, at); + var depth = at.path.length - height; + + var _highest = _slicedToArray(highest, 2), + highestPath = _highest[1]; + + var lowestPath = at.path.slice(0, depth); + var position = height === 0 ? at.offset : at.path[depth] + nudge; + + var _iterator3 = _createForOfIteratorHelper$1(Editor.levels(editor, { + at: lowestPath, + reverse: true, + voids: voids + })), + _step3; + + try { + for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) { + var _step3$value = _slicedToArray(_step3.value, 2), + node = _step3$value[0], + _path2 = _step3$value[1]; + + var split = false; + + if (_path2.length < highestPath.length || _path2.length === 0 || !voids && Editor.isVoid(editor, node)) { + break; + } + + var _point2 = beforeRef.current; + var isEnd = Editor.isEnd(editor, _point2, _path2); + + if (always || !beforeRef || !Editor.isEdge(editor, _point2, _path2)) { + split = true; + var properties = Node$1.extractProps(node); + editor.apply({ + type: 'split_node', + path: _path2, + position: position, + properties: properties + }); + } + + position = _path2[_path2.length - 1] + (split || isEnd ? 1 : 0); + } + } catch (err) { + _iterator3.e(err); + } finally { + _iterator3.f(); + } + + if (options.at == null) { + var _point = afterRef.current || Editor.end(editor, []); + + Transforms.select(editor, _point); + } + + beforeRef.unref(); + afterRef.unref(); + }); + }, + + /** + * Unset properties on the nodes at a location. + */ + unsetNodes: function unsetNodes(editor, props) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + if (!Array.isArray(props)) { + props = [props]; + } + + var obj = {}; + + var _iterator4 = _createForOfIteratorHelper$1(props), + _step4; + + try { + for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) { + var key = _step4.value; + obj[key] = null; + } + } catch (err) { + _iterator4.e(err); + } finally { + _iterator4.f(); + } + + Transforms.setNodes(editor, obj, options); + }, + + /** + * Unwrap the nodes at a location from a parent node, splitting the parent if + * necessary to ensure that only the content in the range is unwrapped. + */ + unwrapNodes: function unwrapNodes(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + Editor.withoutNormalizing(editor, function () { + var _options$mode8 = options.mode, + mode = _options$mode8 === void 0 ? 'lowest' : _options$mode8, + _options$split2 = options.split, + split = _options$split2 === void 0 ? false : _options$split2, + _options$voids8 = options.voids, + voids = _options$voids8 === void 0 ? false : _options$voids8; + var _options$at7 = options.at, + at = _options$at7 === void 0 ? editor.selection : _options$at7, + match = options.match; + + if (!at) { + return; + } + + if (match == null) { + match = Path.isPath(at) ? matchPath(editor, at) : function (n) { + return Editor.isBlock(editor, n); + }; + } + + if (Path.isPath(at)) { + at = Editor.range(editor, at); + } + + var rangeRef = Range.isRange(at) ? Editor.rangeRef(editor, at) : null; + var matches = Editor.nodes(editor, { + at: at, + match: match, + mode: mode, + voids: voids + }); + var pathRefs = Array.from(matches, function (_ref9) { + var _ref10 = _slicedToArray(_ref9, 2), + p = _ref10[1]; + + return Editor.pathRef(editor, p); + } // unwrapNode will call liftNode which does not support splitting the node when nested. + // If we do not reverse the order and call it from top to the bottom, it will remove all blocks + // that wrap target node. So we reverse the order. + ).reverse(); + + var _iterator5 = _createForOfIteratorHelper$1(pathRefs), + _step5; + + try { + var _loop = function _loop() { + var pathRef = _step5.value; + var path = pathRef.unref(); + + var _Editor$node3 = Editor.node(editor, path), + _Editor$node4 = _slicedToArray(_Editor$node3, 1), + node = _Editor$node4[0]; + + var range = Editor.range(editor, path); + + if (split && rangeRef) { + range = Range.intersection(rangeRef.current, range); + } + + Transforms.liftNodes(editor, { + at: range, + match: function match(n) { + return Element$1.isAncestor(node) && node.children.includes(n); + }, + voids: voids + }); + }; + + for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) { + _loop(); + } + } catch (err) { + _iterator5.e(err); + } finally { + _iterator5.f(); + } + + if (rangeRef) { + rangeRef.unref(); + } + }); + }, + + /** + * Wrap the nodes at a location in a new container node, splitting the edges + * of the range first to ensure that only the content in the range is wrapped. + */ + wrapNodes: function wrapNodes(editor, element) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + Editor.withoutNormalizing(editor, function () { + var _options$mode9 = options.mode, + mode = _options$mode9 === void 0 ? 'lowest' : _options$mode9, + _options$split3 = options.split, + split = _options$split3 === void 0 ? false : _options$split3, + _options$voids9 = options.voids, + voids = _options$voids9 === void 0 ? false : _options$voids9; + var match = options.match, + _options$at8 = options.at, + at = _options$at8 === void 0 ? editor.selection : _options$at8; + + if (!at) { + return; + } + + if (match == null) { + if (Path.isPath(at)) { + match = matchPath(editor, at); + } else if (editor.isInline(element)) { + match = function match(n) { + return Editor.isInline(editor, n) || Text.isText(n); + }; + } else { + match = function match(n) { + return Editor.isBlock(editor, n); + }; + } + } + + if (split && Range.isRange(at)) { + var _Range$edges7 = Range.edges(at), + _Range$edges8 = _slicedToArray(_Range$edges7, 2), + start = _Range$edges8[0], + end = _Range$edges8[1]; + + var rangeRef = Editor.rangeRef(editor, at, { + affinity: 'inward' + }); + Transforms.splitNodes(editor, { + at: end, + match: match, + voids: voids + }); + Transforms.splitNodes(editor, { + at: start, + match: match, + voids: voids + }); + at = rangeRef.unref(); + + if (options.at == null) { + Transforms.select(editor, at); + } + } + + var roots = Array.from(Editor.nodes(editor, { + at: at, + match: editor.isInline(element) ? function (n) { + return Editor.isBlock(editor, n); + } : function (n) { + return Editor.isEditor(n); + }, + mode: 'lowest', + voids: voids + })); + + for (var _i4 = 0, _roots = roots; _i4 < _roots.length; _i4++) { + var _roots$_i = _slicedToArray(_roots[_i4], 2), + rootPath = _roots$_i[1]; + + var a = Range.isRange(at) ? Range.intersection(at, Editor.range(editor, rootPath)) : at; + + if (!a) { + continue; + } + + var matches = Array.from(Editor.nodes(editor, { + at: a, + match: match, + mode: mode, + voids: voids + })); + + if (matches.length > 0) { + var _ret = function () { + var _matches = _slicedToArray(matches, 1), + first = _matches[0]; + + var last = matches[matches.length - 1]; + + var _first = _slicedToArray(first, 2), + firstPath = _first[1]; + + var _last = _slicedToArray(last, 2), + lastPath = _last[1]; + + if (firstPath.length === 0 && lastPath.length === 0) { + // if there's no matching parent - usually means the node is an editor - don't do anything + return "continue"; + } + + var commonPath = Path.equals(firstPath, lastPath) ? Path.parent(firstPath) : Path.common(firstPath, lastPath); + var range = Editor.range(editor, firstPath, lastPath); + var commonNodeEntry = Editor.node(editor, commonPath); + + var _commonNodeEntry = _slicedToArray(commonNodeEntry, 1), + commonNode = _commonNodeEntry[0]; + + var depth = commonPath.length + 1; + var wrapperPath = Path.next(lastPath.slice(0, depth)); + + var wrapper = _objectSpread$2(_objectSpread$2({}, element), {}, { + children: [] + }); + + Transforms.insertNodes(editor, wrapper, { + at: wrapperPath, + voids: voids + }); + Transforms.moveNodes(editor, { + at: range, + match: function match(n) { + return Element$1.isAncestor(commonNode) && commonNode.children.includes(n); + }, + to: wrapperPath.concat(0), + voids: voids + }); + }(); + + if (_ret === "continue") continue; + } + } + }); + } + }; + + var hasSingleChildNest = function hasSingleChildNest(editor, node) { + if (Element$1.isElement(node)) { + var element = node; + + if (Editor.isVoid(editor, node)) { + return true; + } else if (element.children.length === 1) { + return hasSingleChildNest(editor, element.children[0]); + } else { + return false; + } + } else if (Editor.isEditor(node)) { + return false; + } else { + return true; + } + }; + /** + * Convert a range into a point by deleting it's content. + */ + + + var deleteRange = function deleteRange(editor, range) { + if (Range.isCollapsed(range)) { + return range.anchor; + } else { + var _Range$edges9 = Range.edges(range), + _Range$edges10 = _slicedToArray(_Range$edges9, 2), + end = _Range$edges10[1]; + + var pointRef = Editor.pointRef(editor, end); + Transforms["delete"](editor, { + at: range + }); + return pointRef.unref(); + } + }; + + var matchPath = function matchPath(editor, path) { + var _Editor$node5 = Editor.node(editor, path), + _Editor$node6 = _slicedToArray(_Editor$node5, 1), + node = _Editor$node6[0]; + + return function (n) { + return n === node; + }; + }; + + function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + + function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + var SelectionTransforms = { + /** + * Collapse the selection. + */ + collapse: function collapse(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _options$edge = options.edge, + edge = _options$edge === void 0 ? 'anchor' : _options$edge; + var selection = editor.selection; + + if (!selection) { + return; + } else if (edge === 'anchor') { + Transforms.select(editor, selection.anchor); + } else if (edge === 'focus') { + Transforms.select(editor, selection.focus); + } else if (edge === 'start') { + var _Range$edges = Range.edges(selection), + _Range$edges2 = _slicedToArray(_Range$edges, 1), + start = _Range$edges2[0]; + + Transforms.select(editor, start); + } else if (edge === 'end') { + var _Range$edges3 = Range.edges(selection), + _Range$edges4 = _slicedToArray(_Range$edges3, 2), + end = _Range$edges4[1]; + + Transforms.select(editor, end); + } + }, + + /** + * Unset the selection. + */ + deselect: function deselect(editor) { + var selection = editor.selection; + + if (selection) { + editor.apply({ + type: 'set_selection', + properties: selection, + newProperties: null + }); + } + }, + + /** + * Move the selection's point forward or backward. + */ + move: function move(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var selection = editor.selection; + var _options$distance = options.distance, + distance = _options$distance === void 0 ? 1 : _options$distance, + _options$unit = options.unit, + unit = _options$unit === void 0 ? 'character' : _options$unit, + _options$reverse = options.reverse, + reverse = _options$reverse === void 0 ? false : _options$reverse; + var _options$edge2 = options.edge, + edge = _options$edge2 === void 0 ? null : _options$edge2; + + if (!selection) { + return; + } + + if (edge === 'start') { + edge = Range.isBackward(selection) ? 'focus' : 'anchor'; + } + + if (edge === 'end') { + edge = Range.isBackward(selection) ? 'anchor' : 'focus'; + } + + var anchor = selection.anchor, + focus = selection.focus; + var opts = { + distance: distance, + unit: unit + }; + var props = {}; + + if (edge == null || edge === 'anchor') { + var point = reverse ? Editor.before(editor, anchor, opts) : Editor.after(editor, anchor, opts); + + if (point) { + props.anchor = point; + } + } + + if (edge == null || edge === 'focus') { + var _point = reverse ? Editor.before(editor, focus, opts) : Editor.after(editor, focus, opts); + + if (_point) { + props.focus = _point; + } + } + + Transforms.setSelection(editor, props); + }, + + /** + * Set the selection to a new value. + */ + select: function select(editor, target) { + var selection = editor.selection; + target = Editor.range(editor, target); + + if (selection) { + Transforms.setSelection(editor, target); + return; + } + + if (!Range.isRange(target)) { + throw new Error("When setting the selection and the current selection is `null` you must provide at least an `anchor` and `focus`, but you passed: ".concat(JSON.stringify(target))); + } + + editor.apply({ + type: 'set_selection', + properties: selection, + newProperties: target + }); + }, + + /** + * Set new properties on one of the selection's points. + */ + setPoint: function setPoint(editor, props) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var selection = editor.selection; + var _options$edge3 = options.edge, + edge = _options$edge3 === void 0 ? 'both' : _options$edge3; + + if (!selection) { + return; + } + + if (edge === 'start') { + edge = Range.isBackward(selection) ? 'focus' : 'anchor'; + } + + if (edge === 'end') { + edge = Range.isBackward(selection) ? 'anchor' : 'focus'; + } + + var anchor = selection.anchor, + focus = selection.focus; + var point = edge === 'anchor' ? anchor : focus; + Transforms.setSelection(editor, _defineProperty({}, edge === 'anchor' ? 'anchor' : 'focus', _objectSpread$1(_objectSpread$1({}, point), props))); + }, + + /** + * Set new properties on the selection. + */ + setSelection: function setSelection(editor, props) { + var selection = editor.selection; + var oldProps = {}; + var newProps = {}; + + if (!selection) { + return; + } + + for (var k in props) { + if (k === 'anchor' && props.anchor != null && !Point.equals(props.anchor, selection.anchor) || k === 'focus' && props.focus != null && !Point.equals(props.focus, selection.focus) || k !== 'anchor' && k !== 'focus' && props[k] !== selection[k]) { + oldProps[k] = selection[k]; + newProps[k] = props[k]; + } + } + + if (Object.keys(oldProps).length > 0) { + editor.apply({ + type: 'set_selection', + properties: oldProps, + newProperties: newProps + }); + } + } + }; + + function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } + + 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); } + + 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; } + var TextTransforms = { + /** + * Delete content in the editor. + */ + "delete": function _delete(editor) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + Editor.withoutNormalizing(editor, function () { + var _options$reverse = options.reverse, + reverse = _options$reverse === void 0 ? false : _options$reverse, + _options$unit = options.unit, + unit = _options$unit === void 0 ? 'character' : _options$unit, + _options$distance = options.distance, + distance = _options$distance === void 0 ? 1 : _options$distance, + _options$voids = options.voids, + voids = _options$voids === void 0 ? false : _options$voids; + var _options$at = options.at, + at = _options$at === void 0 ? editor.selection : _options$at, + _options$hanging = options.hanging, + hanging = _options$hanging === void 0 ? false : _options$hanging; + + if (!at) { + return; + } + + if (Range.isRange(at) && Range.isCollapsed(at)) { + at = at.anchor; + } + + if (Point.isPoint(at)) { + var furthestVoid = Editor["void"](editor, { + at: at, + mode: 'highest' + }); + + if (!voids && furthestVoid) { + var _furthestVoid = _slicedToArray(furthestVoid, 2), + voidPath = _furthestVoid[1]; + + at = voidPath; + } else { + var opts = { + unit: unit, + distance: distance + }; + var target = reverse ? Editor.before(editor, at, opts) || Editor.start(editor, []) : Editor.after(editor, at, opts) || Editor.end(editor, []); + at = { + anchor: at, + focus: target + }; + hanging = true; + } + } + + if (Path.isPath(at)) { + Transforms.removeNodes(editor, { + at: at, + voids: voids + }); + return; + } + + if (Range.isCollapsed(at)) { + return; + } + + if (!hanging) { + var _Range$edges = Range.edges(at), + _Range$edges2 = _slicedToArray(_Range$edges, 2), + _end = _Range$edges2[1]; + + var endOfDoc = Editor.end(editor, []); + + if (!Point.equals(_end, endOfDoc)) { + at = Editor.unhangRange(editor, at, { + voids: voids + }); + } + } + + var _Range$edges3 = Range.edges(at), + _Range$edges4 = _slicedToArray(_Range$edges3, 2), + start = _Range$edges4[0], + end = _Range$edges4[1]; + + var startBlock = Editor.above(editor, { + match: function match(n) { + return Editor.isBlock(editor, n); + }, + at: start, + voids: voids + }); + var endBlock = Editor.above(editor, { + match: function match(n) { + return Editor.isBlock(editor, n); + }, + at: end, + voids: voids + }); + var isAcrossBlocks = startBlock && endBlock && !Path.equals(startBlock[1], endBlock[1]); + var isSingleText = Path.equals(start.path, end.path); + var startVoid = voids ? null : Editor["void"](editor, { + at: start, + mode: 'highest' + }); + var endVoid = voids ? null : Editor["void"](editor, { + at: end, + mode: 'highest' + }); // If the start or end points are inside an inline void, nudge them out. + + if (startVoid) { + var before = Editor.before(editor, start); + + if (before && startBlock && Path.isAncestor(startBlock[1], before.path)) { + start = before; + } + } + + if (endVoid) { + var after = Editor.after(editor, end); + + if (after && endBlock && Path.isAncestor(endBlock[1], after.path)) { + end = after; + } + } // Get the highest nodes that are completely inside the range, as well as + // the start and end nodes. + + + var matches = []; + var lastPath; + + var _iterator = _createForOfIteratorHelper(Editor.nodes(editor, { + at: at, + voids: voids + })), + _step; + + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var entry = _step.value; + + var _entry = _slicedToArray(entry, 2), + _node2 = _entry[0], + _path3 = _entry[1]; + + if (lastPath && Path.compare(_path3, lastPath) === 0) { + continue; + } + + if (!voids && Editor.isVoid(editor, _node2) || !Path.isCommon(_path3, start.path) && !Path.isCommon(_path3, end.path)) { + matches.push(entry); + lastPath = _path3; + } + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } + + var pathRefs = Array.from(matches, function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + p = _ref2[1]; + + return Editor.pathRef(editor, p); + }); + var startRef = Editor.pointRef(editor, start); + var endRef = Editor.pointRef(editor, end); + + if (!isSingleText && !startVoid) { + var _point = startRef.current; + + var _Editor$leaf = Editor.leaf(editor, _point), + _Editor$leaf2 = _slicedToArray(_Editor$leaf, 1), + node = _Editor$leaf2[0]; + + var path = _point.path; + var _start = start, + offset = _start.offset; + var text = node.text.slice(offset); + if (text.length > 0) editor.apply({ + type: 'remove_text', + path: path, + offset: offset, + text: text + }); + } + + for (var _i = 0, _pathRefs = pathRefs; _i < _pathRefs.length; _i++) { + var pathRef = _pathRefs[_i]; + + var _path = pathRef.unref(); + + Transforms.removeNodes(editor, { + at: _path, + voids: voids + }); + } + + if (!endVoid) { + var _point2 = endRef.current; + + var _Editor$leaf3 = Editor.leaf(editor, _point2), + _Editor$leaf4 = _slicedToArray(_Editor$leaf3, 1), + _node = _Editor$leaf4[0]; + + var _path2 = _point2.path; + + var _offset = isSingleText ? start.offset : 0; + + var _text = _node.text.slice(_offset, end.offset); + + if (_text.length > 0) editor.apply({ + type: 'remove_text', + path: _path2, + offset: _offset, + text: _text + }); + } + + if (!isSingleText && isAcrossBlocks && endRef.current && startRef.current) { + Transforms.mergeNodes(editor, { + at: endRef.current, + hanging: true, + voids: voids + }); + } + + var point = reverse ? startRef.unref() || endRef.unref() : endRef.unref() || startRef.unref(); + + if (options.at == null && point) { + Transforms.select(editor, point); + } + }); + }, + + /** + * Insert a fragment at a specific location in the editor. + */ + insertFragment: function insertFragment(editor, fragment) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + Editor.withoutNormalizing(editor, function () { + var _options$hanging2 = options.hanging, + hanging = _options$hanging2 === void 0 ? false : _options$hanging2, + _options$voids2 = options.voids, + voids = _options$voids2 === void 0 ? false : _options$voids2; + var _options$at2 = options.at, + at = _options$at2 === void 0 ? editor.selection : _options$at2; + + if (!fragment.length) { + return; + } + + if (!at) { + return; + } else if (Range.isRange(at)) { + if (!hanging) { + at = Editor.unhangRange(editor, at); + } + + if (Range.isCollapsed(at)) { + at = at.anchor; + } else { + var _Range$edges5 = Range.edges(at), + _Range$edges6 = _slicedToArray(_Range$edges5, 2), + end = _Range$edges6[1]; + + if (!voids && Editor["void"](editor, { + at: end + })) { + return; + } + + var pointRef = Editor.pointRef(editor, end); + Transforms["delete"](editor, { + at: at + }); + at = pointRef.unref(); + } + } else if (Path.isPath(at)) { + at = Editor.start(editor, at); + } + + if (!voids && Editor["void"](editor, { + at: at + })) { + return; + } // If the insert point is at the edge of an inline node, move it outside + // instead since it will need to be split otherwise. + + + var inlineElementMatch = Editor.above(editor, { + at: at, + match: function match(n) { + return Editor.isInline(editor, n); + }, + mode: 'highest', + voids: voids + }); + + if (inlineElementMatch) { + var _inlineElementMatch = _slicedToArray(inlineElementMatch, 2), + _inlinePath = _inlineElementMatch[1]; + + if (Editor.isEnd(editor, at, _inlinePath)) { + var after = Editor.after(editor, _inlinePath); + at = after; + } else if (Editor.isStart(editor, at, _inlinePath)) { + var before = Editor.before(editor, _inlinePath); + at = before; + } + } + + var blockMatch = Editor.above(editor, { + match: function match(n) { + return Editor.isBlock(editor, n); + }, + at: at, + voids: voids + }); + + var _blockMatch = _slicedToArray(blockMatch, 2), + blockPath = _blockMatch[1]; + + var isBlockStart = Editor.isStart(editor, at, blockPath); + var isBlockEnd = Editor.isEnd(editor, at, blockPath); + var isBlockEmpty = isBlockStart && isBlockEnd; + var mergeStart = !isBlockStart || isBlockStart && isBlockEnd; + var mergeEnd = !isBlockEnd; + + var _Node$first = Node$1.first({ + children: fragment + }, []), + _Node$first2 = _slicedToArray(_Node$first, 2), + firstPath = _Node$first2[1]; + + var _Node$last = Node$1.last({ + children: fragment + }, []), + _Node$last2 = _slicedToArray(_Node$last, 2), + lastPath = _Node$last2[1]; + + var matches = []; + + var matcher = function matcher(_ref3) { + var _ref4 = _slicedToArray(_ref3, 2), + n = _ref4[0], + p = _ref4[1]; + + var isRoot = p.length === 0; + + if (isRoot) { + return false; + } + + if (isBlockEmpty) { + return true; + } + + if (mergeStart && Path.isAncestor(p, firstPath) && Element$1.isElement(n) && !editor.isVoid(n) && !editor.isInline(n)) { + return false; + } + + if (mergeEnd && Path.isAncestor(p, lastPath) && Element$1.isElement(n) && !editor.isVoid(n) && !editor.isInline(n)) { + return false; + } + + return true; + }; + + var _iterator2 = _createForOfIteratorHelper(Node$1.nodes({ + children: fragment + }, { + pass: matcher + })), + _step2; + + try { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { + var entry = _step2.value; + + if (matcher(entry)) { + matches.push(entry); + } + } + } catch (err) { + _iterator2.e(err); + } finally { + _iterator2.f(); + } + + var starts = []; + var middles = []; + var ends = []; + var starting = true; + var hasBlocks = false; + + for (var _i2 = 0, _matches = matches; _i2 < _matches.length; _i2++) { + var _matches$_i = _slicedToArray(_matches[_i2], 1), + node = _matches$_i[0]; + + if (Element$1.isElement(node) && !editor.isInline(node)) { + starting = false; + hasBlocks = true; + middles.push(node); + } else if (starting) { + starts.push(node); + } else { + ends.push(node); + } + } + + var _Editor$nodes = Editor.nodes(editor, { + at: at, + match: function match(n) { + return Text.isText(n) || Editor.isInline(editor, n); + }, + mode: 'highest', + voids: voids + }), + _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1), + inlineMatch = _Editor$nodes2[0]; + + var _inlineMatch = _slicedToArray(inlineMatch, 2), + inlinePath = _inlineMatch[1]; + + var isInlineStart = Editor.isStart(editor, at, inlinePath); + var isInlineEnd = Editor.isEnd(editor, at, inlinePath); + var middleRef = Editor.pathRef(editor, isBlockEnd ? Path.next(blockPath) : blockPath); + var endRef = Editor.pathRef(editor, isInlineEnd ? Path.next(inlinePath) : inlinePath); + var blockPathRef = Editor.pathRef(editor, blockPath); + Transforms.splitNodes(editor, { + at: at, + match: function match(n) { + return hasBlocks ? Editor.isBlock(editor, n) : Text.isText(n) || Editor.isInline(editor, n); + }, + mode: hasBlocks ? 'lowest' : 'highest', + voids: voids + }); + var startRef = Editor.pathRef(editor, !isInlineStart || isInlineStart && isInlineEnd ? Path.next(inlinePath) : inlinePath); + Transforms.insertNodes(editor, starts, { + at: startRef.current, + match: function match(n) { + return Text.isText(n) || Editor.isInline(editor, n); + }, + mode: 'highest', + voids: voids + }); + + if (isBlockEmpty && middles.length) { + Transforms["delete"](editor, { + at: blockPathRef.unref(), + voids: voids + }); + } + + Transforms.insertNodes(editor, middles, { + at: middleRef.current, + match: function match(n) { + return Editor.isBlock(editor, n); + }, + mode: 'lowest', + voids: voids + }); + Transforms.insertNodes(editor, ends, { + at: endRef.current, + match: function match(n) { + return Text.isText(n) || Editor.isInline(editor, n); + }, + mode: 'highest', + voids: voids + }); + + if (!options.at) { + var path; + + if (ends.length > 0) { + path = Path.previous(endRef.current); + } else if (middles.length > 0) { + path = Path.previous(middleRef.current); + } else { + path = Path.previous(startRef.current); + } + + var _end2 = Editor.end(editor, path); + + Transforms.select(editor, _end2); + } + + startRef.unref(); + middleRef.unref(); + endRef.unref(); + }); + }, + + /** + * Insert a string of text in the Editor. + */ + insertText: function insertText(editor, text) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + Editor.withoutNormalizing(editor, function () { + var _options$voids3 = options.voids, + voids = _options$voids3 === void 0 ? false : _options$voids3; + var _options$at3 = options.at, + at = _options$at3 === void 0 ? editor.selection : _options$at3; + + if (!at) { + return; + } + + if (Path.isPath(at)) { + at = Editor.range(editor, at); + } + + if (Range.isRange(at)) { + if (Range.isCollapsed(at)) { + at = at.anchor; + } else { + var end = Range.end(at); + + if (!voids && Editor["void"](editor, { + at: end + })) { + return; + } + + var pointRef = Editor.pointRef(editor, end); + Transforms["delete"](editor, { + at: at, + voids: voids + }); + at = pointRef.unref(); + Transforms.setSelection(editor, { + anchor: at, + focus: at + }); + } + } + + if (!voids && Editor["void"](editor, { + at: at + })) { + return; + } + + var _at = at, + path = _at.path, + offset = _at.offset; + if (text.length > 0) editor.apply({ + type: 'insert_text', + path: path, + offset: offset, + text: text + }); + }); + } + }; + + function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + + function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + var Transforms = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, GeneralTransforms), NodeTransforms), SelectionTransforms), TextTransforms); + + var Editor_1 = Editor; + var Element_1 = Element$1; + var Location_1 = Location; + var Node_1 = Node$1; + var Operation_1 = Operation; + var Path_1 = Path; + var PathRef_1 = PathRef; + var Point_1 = Point; + var PointRef_1 = PointRef; + var Range_1 = Range; + var RangeRef_1 = RangeRef; + var Span_1 = Span; + var Text_1 = Text; + var Transforms_1 = Transforms; + var createEditor_1 = createEditor$1; + + + var dist$7 = /*#__PURE__*/Object.defineProperty({ + Editor: Editor_1, + Element: Element_1, + Location: Location_1, + Node: Node_1, + Operation: Operation_1, + Path: Path_1, + PathRef: PathRef_1, + Point: Point_1, + PointRef: PointRef_1, + Range: Range_1, + RangeRef: RangeRef_1, + Span: Span_1, + Text: Text_1, + Transforms: Transforms_1, + createEditor: createEditor_1 + }, '__esModule', {value: true}); + + /** + * lodash (Custom Build) + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + + /** Used as references for various `Number` constants. */ + var MAX_SAFE_INTEGER$1 = 9007199254740991; + + /** `Object#toString` result references. */ + var argsTag$1 = '[object Arguments]', + funcTag$1 = '[object Function]', + genTag$1 = '[object GeneratorFunction]', + mapTag = '[object Map]', + objectTag = '[object Object]', + promiseTag = '[object Promise]', + setTag = '[object Set]', + stringTag = '[object String]', + weakMapTag = '[object WeakMap]'; + + var dataViewTag = '[object DataView]'; + + /** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ + var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + + /** Used to detect host constructors (Safari). */ + var reIsHostCtor = /^\[object .+?Constructor\]$/; + + /** Used to detect unsigned integer values. */ + var reIsUint$1 = /^(?:0|[1-9]\d*)$/; + + /** Used to compose unicode character classes. */ + var rsAstralRange$1 = '\\ud800-\\udfff', + rsComboMarksRange$1 = '\\u0300-\\u036f\\ufe20-\\ufe23', + rsComboSymbolsRange$1 = '\\u20d0-\\u20f0', + rsVarRange$1 = '\\ufe0e\\ufe0f'; + + /** Used to compose unicode capture groups. */ + var rsAstral$1 = '[' + rsAstralRange$1 + ']', + rsCombo$1 = '[' + rsComboMarksRange$1 + rsComboSymbolsRange$1 + ']', + rsFitz$1 = '\\ud83c[\\udffb-\\udfff]', + rsModifier$1 = '(?:' + rsCombo$1 + '|' + rsFitz$1 + ')', + rsNonAstral$1 = '[^' + rsAstralRange$1 + ']', + rsRegional$1 = '(?:\\ud83c[\\udde6-\\uddff]){2}', + rsSurrPair$1 = '[\\ud800-\\udbff][\\udc00-\\udfff]', + rsZWJ$1 = '\\u200d'; + + /** Used to compose unicode regexes. */ + var reOptMod$1 = rsModifier$1 + '?', + rsOptVar$1 = '[' + rsVarRange$1 + ']?', + rsOptJoin$1 = '(?:' + rsZWJ$1 + '(?:' + [rsNonAstral$1, rsRegional$1, rsSurrPair$1].join('|') + ')' + rsOptVar$1 + reOptMod$1 + ')*', + rsSeq$1 = rsOptVar$1 + reOptMod$1 + rsOptJoin$1, + rsSymbol$1 = '(?:' + [rsNonAstral$1 + rsCombo$1 + '?', rsCombo$1, rsRegional$1, rsSurrPair$1, rsAstral$1].join('|') + ')'; + + /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ + var reUnicode$1 = RegExp(rsFitz$1 + '(?=' + rsFitz$1 + ')|' + rsSymbol$1 + rsSeq$1, 'g'); + + /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */ + var reHasUnicode$1 = RegExp('[' + rsZWJ$1 + rsAstralRange$1 + rsComboMarksRange$1 + rsComboSymbolsRange$1 + rsVarRange$1 + ']'); + + /** Detect free variable `global` from Node.js. */ + var freeGlobal$3 = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal; + + /** Detect free variable `self`. */ + var freeSelf$3 = typeof self == 'object' && self && self.Object === Object && self; + + /** Used as a reference to the global object. */ + var root$3 = freeGlobal$3 || freeSelf$3 || Function('return this')(); + + /** + * A specialized version of `_.map` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ + function arrayMap(array, iteratee) { + var index = -1, + length = array ? array.length : 0, + result = Array(length); + + while (++index < length) { + result[index] = iteratee(array[index], index, array); + } + return result; + } + + /** + * Converts an ASCII `string` to an array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. + */ + function asciiToArray$1(string) { + return string.split(''); + } + + /** + * The base implementation of `_.times` without support for iteratee shorthands + * or max array length checks. + * + * @private + * @param {number} n The number of times to invoke `iteratee`. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the array of results. + */ + function baseTimes$1(n, iteratee) { + var index = -1, + result = Array(n); + + while (++index < n) { + result[index] = iteratee(index); + } + return result; + } + + /** + * The base implementation of `_.values` and `_.valuesIn` which creates an + * array of `object` property values corresponding to the property names + * of `props`. + * + * @private + * @param {Object} object The object to query. + * @param {Array} props The property names to get values for. + * @returns {Object} Returns the array of property values. + */ + function baseValues(object, props) { + return arrayMap(props, function(key) { + return object[key]; + }); + } + + /** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ + function getValue(object, key) { + return object == null ? undefined : object[key]; + } + + /** + * Checks if `string` contains Unicode symbols. + * + * @private + * @param {string} string The string to inspect. + * @returns {boolean} Returns `true` if a symbol is found, else `false`. + */ + function hasUnicode$1(string) { + return reHasUnicode$1.test(string); + } + + /** + * Checks if `value` is a host object in IE < 9. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a host object, else `false`. + */ + function isHostObject(value) { + // Many host objects are `Object` objects that can coerce to strings + // despite having improperly defined `toString` methods. + var result = false; + if (value != null && typeof value.toString != 'function') { + try { + result = !!(value + ''); + } catch (e) {} + } + return result; + } + + /** + * Converts `iterator` to an array. + * + * @private + * @param {Object} iterator The iterator to convert. + * @returns {Array} Returns the converted array. + */ + function iteratorToArray(iterator) { + var data, + result = []; + + while (!(data = iterator.next()).done) { + result.push(data.value); + } + return result; + } + + /** + * Converts `map` to its key-value pairs. + * + * @private + * @param {Object} map The map to convert. + * @returns {Array} Returns the key-value pairs. + */ + function mapToArray(map) { + var index = -1, + result = Array(map.size); + + map.forEach(function(value, key) { + result[++index] = [key, value]; + }); + return result; + } + + /** + * Creates a unary function that invokes `func` with its argument transformed. + * + * @private + * @param {Function} func The function to wrap. + * @param {Function} transform The argument transform. + * @returns {Function} Returns the new function. + */ + function overArg$1(func, transform) { + return function(arg) { + return func(transform(arg)); + }; + } + + /** + * Converts `set` to an array of its values. + * + * @private + * @param {Object} set The set to convert. + * @returns {Array} Returns the values. + */ + function setToArray(set) { + var index = -1, + result = Array(set.size); + + set.forEach(function(value) { + result[++index] = value; + }); + return result; + } + + /** + * Converts `string` to an array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. + */ + function stringToArray$1(string) { + return hasUnicode$1(string) + ? unicodeToArray$1(string) + : asciiToArray$1(string); + } + + /** + * Converts a Unicode `string` to an array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. + */ + function unicodeToArray$1(string) { + return string.match(reUnicode$1) || []; + } + + /** Used for built-in method references. */ + var funcProto = Function.prototype, + objectProto$4 = Object.prototype; + + /** Used to detect overreaching core-js shims. */ + var coreJsData = root$3['__core-js_shared__']; + + /** Used to detect methods masquerading as native. */ + var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); + return uid ? ('Symbol(src)_1.' + uid) : ''; + }()); + + /** Used to resolve the decompiled source of functions. */ + var funcToString = funcProto.toString; + + /** Used to check objects for own properties. */ + var hasOwnProperty$2 = objectProto$4.hasOwnProperty; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ + var objectToString$4 = objectProto$4.toString; + + /** Used to detect if a method is native. */ + var reIsNative = RegExp('^' + + funcToString.call(hasOwnProperty$2).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' + ); + + /** Built-in value references. */ + var Symbol$2 = root$3.Symbol, + iteratorSymbol = Symbol$2 ? Symbol$2.iterator : undefined, + propertyIsEnumerable$1 = objectProto$4.propertyIsEnumerable; + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeKeys$1 = overArg$1(Object.keys, Object); + + /* Built-in method references that are verified to be native. */ + var DataView = getNative(root$3, 'DataView'), + Map$1 = getNative(root$3, 'Map'), + Promise$1 = getNative(root$3, 'Promise'), + Set$1 = getNative(root$3, 'Set'), + WeakMap$1 = getNative(root$3, 'WeakMap'); + + /** Used to detect maps, sets, and weakmaps. */ + var dataViewCtorString = toSource(DataView), + mapCtorString = toSource(Map$1), + promiseCtorString = toSource(Promise$1), + setCtorString = toSource(Set$1), + weakMapCtorString = toSource(WeakMap$1); + + /** + * Creates an array of the enumerable property names of the array-like `value`. + * + * @private + * @param {*} value The value to query. + * @param {boolean} inherited Specify returning inherited property names. + * @returns {Array} Returns the array of property names. + */ + function arrayLikeKeys$1(value, inherited) { + // Safari 8.1 makes `arguments.callee` enumerable in strict mode. + // Safari 9 makes `arguments.length` enumerable in strict mode. + var result = (isArray$1(value) || isArguments$1(value)) + ? baseTimes$1(value.length, String) + : []; + + var length = result.length, + skipIndexes = !!length; + + for (var key in value) { + if ((inherited || hasOwnProperty$2.call(value, key)) && + !(skipIndexes && (key == 'length' || isIndex$1(key, length)))) { + result.push(key); + } + } + return result; + } + + /** + * The base implementation of `getTag`. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ + function baseGetTag(value) { + return objectToString$4.call(value); + } + + /** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ + function baseIsNative(value) { + if (!isObject$3(value) || isMasked(value)) { + return false; + } + var pattern = (isFunction$1(value) || isHostObject(value)) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); + } + + /** + * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + function baseKeys$1(object) { + if (!isPrototype$1(object)) { + return nativeKeys$1(object); + } + var result = []; + for (var key in Object(object)) { + if (hasOwnProperty$2.call(object, key) && key != 'constructor') { + result.push(key); + } + } + return result; + } + + /** + * Copies the values of `source` to `array`. + * + * @private + * @param {Array} source The array to copy values from. + * @param {Array} [array=[]] The array to copy values to. + * @returns {Array} Returns `array`. + */ + function copyArray(source, array) { + var index = -1, + length = source.length; + + array || (array = Array(length)); + while (++index < length) { + array[index] = source[index]; + } + return array; + } + + /** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ + function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; + } + + /** + * Gets the `toStringTag` of `value`. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ + var getTag = baseGetTag; + + // Fallback for data views, maps, sets, and weak maps in IE 11, + // for data views in Edge < 14, and promises in Node.js. + if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || + (Map$1 && getTag(new Map$1) != mapTag) || + (Promise$1 && getTag(Promise$1.resolve()) != promiseTag) || + (Set$1 && getTag(new Set$1) != setTag) || + (WeakMap$1 && getTag(new WeakMap$1) != weakMapTag)) { + getTag = function(value) { + var result = objectToString$4.call(value), + Ctor = result == objectTag ? value.constructor : undefined, + ctorString = Ctor ? toSource(Ctor) : undefined; + + if (ctorString) { + switch (ctorString) { + case dataViewCtorString: return dataViewTag; + case mapCtorString: return mapTag; + case promiseCtorString: return promiseTag; + case setCtorString: return setTag; + case weakMapCtorString: return weakMapTag; + } + } + return result; + }; + } + + /** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ + function isIndex$1(value, length) { + length = length == null ? MAX_SAFE_INTEGER$1 : length; + return !!length && + (typeof value == 'number' || reIsUint$1.test(value)) && + (value > -1 && value % 1 == 0 && value < length); + } + + /** + * Checks if `func` has its source masked. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. + */ + function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); + } + + /** + * Checks if `value` is likely a prototype object. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. + */ + function isPrototype$1(value) { + var Ctor = value && value.constructor, + proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$4; + + return value === proto; + } + + /** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to process. + * @returns {string} Returns the source code. + */ + function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; + } + + /** + * Checks if `value` is likely an `arguments` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + * else `false`. + * @example + * + * _.isArguments(function() { return arguments; }()); + * // => true + * + * _.isArguments([1, 2, 3]); + * // => false + */ + function isArguments$1(value) { + // Safari 8.1 makes `arguments.callee` enumerable in strict mode. + return isArrayLikeObject$1(value) && hasOwnProperty$2.call(value, 'callee') && + (!propertyIsEnumerable$1.call(value, 'callee') || objectToString$4.call(value) == argsTag$1); + } + + /** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ + var isArray$1 = Array.isArray; + + /** + * Checks if `value` is array-like. A value is considered array-like if it's + * not a function and has a `value.length` that's an integer greater than or + * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + * @example + * + * _.isArrayLike([1, 2, 3]); + * // => true + * + * _.isArrayLike(document.body.children); + * // => true + * + * _.isArrayLike('abc'); + * // => true + * + * _.isArrayLike(_.noop); + * // => false + */ + function isArrayLike$1(value) { + return value != null && isLength$1(value.length) && !isFunction$1(value); + } + + /** + * This method is like `_.isArrayLike` except that it also checks if `value` + * is an object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array-like object, + * else `false`. + * @example + * + * _.isArrayLikeObject([1, 2, 3]); + * // => true + * + * _.isArrayLikeObject(document.body.children); + * // => true + * + * _.isArrayLikeObject('abc'); + * // => false + * + * _.isArrayLikeObject(_.noop); + * // => false + */ + function isArrayLikeObject$1(value) { + return isObjectLike$4(value) && isArrayLike$1(value); + } + + /** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ + function isFunction$1(value) { + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 8-9 which returns 'object' for typed array and other constructors. + var tag = isObject$3(value) ? objectToString$4.call(value) : ''; + return tag == funcTag$1 || tag == genTag$1; + } + + /** + * Checks if `value` is a valid array-like length. + * + * **Note:** This method is loosely based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * @example + * + * _.isLength(3); + * // => true + * + * _.isLength(Number.MIN_VALUE); + * // => false + * + * _.isLength(Infinity); + * // => false + * + * _.isLength('3'); + * // => false + */ + function isLength$1(value) { + return typeof value == 'number' && + value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER$1; + } + + /** + * 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$3(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); + } + + /** + * 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$4(value) { + return !!value && typeof value == 'object'; + } + + /** + * Checks if `value` is classified as a `String` primitive or object. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a string, else `false`. + * @example + * + * _.isString('abc'); + * // => true + * + * _.isString(1); + * // => false + */ + function isString(value) { + return typeof value == 'string' || + (!isArray$1(value) && isObjectLike$4(value) && objectToString$4.call(value) == stringTag); + } + + /** + * Converts `value` to an array. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to convert. + * @returns {Array} Returns the converted array. + * @example + * + * _.toArray({ 'a': 1, 'b': 2 }); + * // => [1, 2] + * + * _.toArray('abc'); + * // => ['a', 'b', 'c'] + * + * _.toArray(1); + * // => [] + * + * _.toArray(null); + * // => [] + */ + function toArray(value) { + if (!value) { + return []; + } + if (isArrayLike$1(value)) { + return isString(value) ? stringToArray$1(value) : copyArray(value); + } + if (iteratorSymbol && value[iteratorSymbol]) { + return iteratorToArray(value[iteratorSymbol]()); + } + var tag = getTag(value), + func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values); + + return func(value); + } + + /** + * Creates an array of the own enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * for more details. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] + */ + function keys$1(object) { + return isArrayLike$1(object) ? arrayLikeKeys$1(object) : baseKeys$1(object); + } + + /** + * Creates an array of the own enumerable string keyed property values of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property values. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.values(new Foo); + * // => [1, 2] (iteration order is not guaranteed) + * + * _.values('hi'); + * // => ['h', 'i'] + */ + function values(object) { + return object ? baseValues(object, keys$1(object)) : []; + } + + var lodash_toarray = toArray; + + /** + * SSR Window 3.0.0 + * Better handling for window object in SSR environment + * https://github.com/nolimits4web/ssr-window + * + * Copyright 2020, Vladimir Kharlampidi + * + * Licensed under MIT + * + * Released on: November 9, 2020 + */ + + var ssrWindow_umd = createCommonjsModule$1(function (module, exports) { + (function (global, factory) { + factory(exports) ; + }(commonjsGlobal, (function (exports) { + /* eslint-disable no-param-reassign */ + function isObject(obj) { + return (obj !== null && + typeof obj === 'object' && + 'constructor' in obj && + obj.constructor === Object); + } + function extend(target, src) { + if (target === void 0) { target = {}; } + if (src === void 0) { src = {}; } + Object.keys(src).forEach(function (key) { + if (typeof target[key] === 'undefined') + target[key] = src[key]; + else if (isObject(src[key]) && + isObject(target[key]) && + Object.keys(src[key]).length > 0) { + extend(target[key], src[key]); + } + }); + } + + var ssrDocument = { + body: {}, + addEventListener: function () { }, + removeEventListener: function () { }, + activeElement: { + blur: function () { }, + nodeName: '', + }, + querySelector: function () { + return null; + }, + querySelectorAll: function () { + return []; + }, + getElementById: function () { + return null; + }, + createEvent: function () { + return { + initEvent: function () { }, + }; + }, + createElement: function () { + return { + children: [], + childNodes: [], + style: {}, + setAttribute: function () { }, + getElementsByTagName: function () { + return []; + }, + }; + }, + createElementNS: function () { + return {}; + }, + importNode: function () { + return null; + }, + location: { + hash: '', + host: '', + hostname: '', + href: '', + origin: '', + pathname: '', + protocol: '', + search: '', + }, + }; + function getDocument() { + var doc = typeof document !== 'undefined' ? document : {}; + extend(doc, ssrDocument); + return doc; + } + + var ssrWindow = { + document: ssrDocument, + navigator: { + userAgent: '', + }, + location: { + hash: '', + host: '', + hostname: '', + href: '', + origin: '', + pathname: '', + protocol: '', + search: '', + }, + history: { + replaceState: function () { }, + pushState: function () { }, + go: function () { }, + back: function () { }, + }, + CustomEvent: function CustomEvent() { + return this; + }, + addEventListener: function () { }, + removeEventListener: function () { }, + getComputedStyle: function () { + return { + getPropertyValue: function () { + return ''; + }, + }; + }, + Image: function () { }, + Date: function () { }, + screen: {}, + setTimeout: function () { }, + clearTimeout: function () { }, + matchMedia: function () { + return {}; + }, + requestAnimationFrame: function (callback) { + if (typeof setTimeout === 'undefined') { + callback(); + return null; + } + return setTimeout(callback, 0); + }, + cancelAnimationFrame: function (id) { + if (typeof setTimeout === 'undefined') { + return; + } + clearTimeout(id); + }, + }; + function getWindow() { + var win = typeof window !== 'undefined' ? window : {}; + extend(win, ssrWindow); + return win; + } + + exports.extend = extend; + exports.getDocument = getDocument; + exports.getWindow = getWindow; + exports.ssrDocument = ssrDocument; + exports.ssrWindow = ssrWindow; + + Object.defineProperty(exports, '__esModule', { value: true }); + + }))); + + }); + + /** + * Dom7 3.0.0 + * Minimalistic JavaScript library for DOM manipulation, with a jQuery-compatible API + * https://framework7.io/docs/dom7.html + * + * Copyright 2020, Vladimir Kharlampidi + * + * Licensed under MIT + * + * Released on: November 9, 2020 + */ + + + + + + function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; + } + + function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); + } + + function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); + } + + function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } + } + + function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); + } + + function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; + } + + function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); + } + + function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; + } + + /* eslint-disable no-proto */ + function makeReactive(obj) { + var proto = obj.__proto__; + Object.defineProperty(obj, '__proto__', { + get: function get() { + return proto; + }, + set: function set(value) { + proto.__proto__ = value; + } + }); + } + + var Dom7 = /*#__PURE__*/function (_Array) { + _inheritsLoose(Dom7, _Array); + + function Dom7(items) { + var _this; + + _this = _Array.call.apply(_Array, [this].concat(items)) || this; + makeReactive(_assertThisInitialized(_this)); + return _this; + } + + return Dom7; + }( /*#__PURE__*/_wrapNativeSuper(Array)); + + function arrayFlat(arr) { + if (arr === void 0) { + arr = []; + } + + var res = []; + arr.forEach(function (el) { + if (Array.isArray(el)) { + res.push.apply(res, arrayFlat(el)); + } else { + res.push(el); + } + }); + return res; + } + function arrayFilter(arr, callback) { + return Array.prototype.filter.call(arr, callback); + } + function arrayUnique(arr) { + var uniqueArray = []; + + for (var i = 0; i < arr.length; i += 1) { + if (uniqueArray.indexOf(arr[i]) === -1) uniqueArray.push(arr[i]); + } + + return uniqueArray; + } + function toCamelCase(string) { + return string.toLowerCase().replace(/-(.)/g, function (match, group) { + return group.toUpperCase(); + }); + } + + function qsa(selector, context) { + if (typeof selector !== 'string') { + return [selector]; + } + + var a = []; + var res = context.querySelectorAll(selector); + + for (var i = 0; i < res.length; i += 1) { + a.push(res[i]); + } + + return a; + } + + function $(selector, context) { + var window = ssrWindow_umd.getWindow(); + var document = ssrWindow_umd.getDocument(); + var arr = []; + + if (!context && selector instanceof Dom7) { + return selector; + } + + if (!selector) { + return new Dom7(arr); + } + + if (typeof selector === 'string') { + var html = selector.trim(); + + if (html.indexOf('<') >= 0 && html.indexOf('>') >= 0) { + var toCreate = 'div'; + if (html.indexOf(' 0; + }).length > 0; + } + + function attr(attrs, value) { + if (arguments.length === 1 && typeof attrs === 'string') { + // Get attr + if (this[0]) return this[0].getAttribute(attrs); + return undefined; + } // Set attrs + + + for (var i = 0; i < this.length; i += 1) { + if (arguments.length === 2) { + // String + this[i].setAttribute(attrs, value); + } else { + // Object + for (var attrName in attrs) { + this[i][attrName] = attrs[attrName]; + this[i].setAttribute(attrName, attrs[attrName]); + } + } + } + + return this; + } + + function removeAttr(attr) { + for (var i = 0; i < this.length; i += 1) { + this[i].removeAttribute(attr); + } + + return this; + } + + function prop(props, value) { + if (arguments.length === 1 && typeof props === 'string') { + // Get prop + if (this[0]) return this[0][props]; + } else { + // Set props + for (var i = 0; i < this.length; i += 1) { + if (arguments.length === 2) { + // String + this[i][props] = value; + } else { + // Object + for (var propName in props) { + this[i][propName] = props[propName]; + } + } + } + + return this; + } + + return this; + } + + function data(key, value) { + var el; + + if (typeof value === 'undefined') { + el = this[0]; + if (!el) return undefined; // Get value + + if (el.dom7ElementDataStorage && key in el.dom7ElementDataStorage) { + return el.dom7ElementDataStorage[key]; + } + + var dataKey = el.getAttribute("data-" + key); + + if (dataKey) { + return dataKey; + } + + return undefined; + } // Set value + + + for (var i = 0; i < this.length; i += 1) { + el = this[i]; + if (!el.dom7ElementDataStorage) el.dom7ElementDataStorage = {}; + el.dom7ElementDataStorage[key] = value; + } + + return this; + } + + function removeData(key) { + for (var i = 0; i < this.length; i += 1) { + var el = this[i]; + + if (el.dom7ElementDataStorage && el.dom7ElementDataStorage[key]) { + el.dom7ElementDataStorage[key] = null; + delete el.dom7ElementDataStorage[key]; + } + } + } + + function dataset() { + var el = this[0]; + if (!el) return undefined; + var dataset = {}; // eslint-disable-line + + if (el.dataset) { + for (var dataKey in el.dataset) { + dataset[dataKey] = el.dataset[dataKey]; + } + } else { + for (var i = 0; i < el.attributes.length; i += 1) { + var _attr = el.attributes[i]; + + if (_attr.name.indexOf('data-') >= 0) { + dataset[toCamelCase(_attr.name.split('data-')[1])] = _attr.value; + } + } + } + + for (var key in dataset) { + if (dataset[key] === 'false') dataset[key] = false;else if (dataset[key] === 'true') dataset[key] = true;else if (parseFloat(dataset[key]) === dataset[key] * 1) dataset[key] *= 1; + } + + return dataset; + } + + function val(value) { + if (typeof value === 'undefined') { + // get value + var el = this[0]; + if (!el) return undefined; + + if (el.multiple && el.nodeName.toLowerCase() === 'select') { + var values = []; + + for (var i = 0; i < el.selectedOptions.length; i += 1) { + values.push(el.selectedOptions[i].value); + } + + return values; + } + + return el.value; + } // set value + + + for (var _i = 0; _i < this.length; _i += 1) { + var _el = this[_i]; + + if (Array.isArray(value) && _el.multiple && _el.nodeName.toLowerCase() === 'select') { + for (var j = 0; j < _el.options.length; j += 1) { + _el.options[j].selected = value.indexOf(_el.options[j].value) >= 0; + } + } else { + _el.value = value; + } + } + + return this; + } + + function value(value) { + return this.val(value); + } + + function transform(transform) { + for (var i = 0; i < this.length; i += 1) { + this[i].style.transform = transform; + } + + return this; + } + + function transition(duration) { + for (var i = 0; i < this.length; i += 1) { + this[i].style.transitionDuration = typeof duration !== 'string' ? duration + "ms" : duration; + } + + return this; + } + + function on() { + for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) { + args[_key5] = arguments[_key5]; + } + + var eventType = args[0], + targetSelector = args[1], + listener = args[2], + capture = args[3]; + + if (typeof args[1] === 'function') { + eventType = args[0]; + listener = args[1]; + capture = args[2]; + targetSelector = undefined; + } + + if (!capture) capture = false; + + function handleLiveEvent(e) { + var target = e.target; + if (!target) return; + var eventData = e.target.dom7EventData || []; + + if (eventData.indexOf(e) < 0) { + eventData.unshift(e); + } + + if ($(target).is(targetSelector)) listener.apply(target, eventData);else { + var _parents = $(target).parents(); // eslint-disable-line + + + for (var k = 0; k < _parents.length; k += 1) { + if ($(_parents[k]).is(targetSelector)) listener.apply(_parents[k], eventData); + } + } + } + + function handleEvent(e) { + var eventData = e && e.target ? e.target.dom7EventData || [] : []; + + if (eventData.indexOf(e) < 0) { + eventData.unshift(e); + } + + listener.apply(this, eventData); + } + + var events = eventType.split(' '); + var j; + + for (var i = 0; i < this.length; i += 1) { + var el = this[i]; + + if (!targetSelector) { + for (j = 0; j < events.length; j += 1) { + var event = events[j]; + if (!el.dom7Listeners) el.dom7Listeners = {}; + if (!el.dom7Listeners[event]) el.dom7Listeners[event] = []; + el.dom7Listeners[event].push({ + listener: listener, + proxyListener: handleEvent + }); + el.addEventListener(event, handleEvent, capture); + } + } else { + // Live events + for (j = 0; j < events.length; j += 1) { + var _event = events[j]; + if (!el.dom7LiveListeners) el.dom7LiveListeners = {}; + if (!el.dom7LiveListeners[_event]) el.dom7LiveListeners[_event] = []; + + el.dom7LiveListeners[_event].push({ + listener: listener, + proxyListener: handleLiveEvent + }); + + el.addEventListener(_event, handleLiveEvent, capture); + } + } + } + + return this; + } + + function off() { + for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) { + args[_key6] = arguments[_key6]; + } + + var eventType = args[0], + targetSelector = args[1], + listener = args[2], + capture = args[3]; + + if (typeof args[1] === 'function') { + eventType = args[0]; + listener = args[1]; + capture = args[2]; + targetSelector = undefined; + } + + if (!capture) capture = false; + var events = eventType.split(' '); + + for (var i = 0; i < events.length; i += 1) { + var event = events[i]; + + for (var j = 0; j < this.length; j += 1) { + var el = this[j]; + var handlers = void 0; + + if (!targetSelector && el.dom7Listeners) { + handlers = el.dom7Listeners[event]; + } else if (targetSelector && el.dom7LiveListeners) { + handlers = el.dom7LiveListeners[event]; + } + + if (handlers && handlers.length) { + for (var k = handlers.length - 1; k >= 0; k -= 1) { + var handler = handlers[k]; + + if (listener && handler.listener === listener) { + el.removeEventListener(event, handler.proxyListener, capture); + handlers.splice(k, 1); + } else if (listener && handler.listener && handler.listener.dom7proxy && handler.listener.dom7proxy === listener) { + el.removeEventListener(event, handler.proxyListener, capture); + handlers.splice(k, 1); + } else if (!listener) { + el.removeEventListener(event, handler.proxyListener, capture); + handlers.splice(k, 1); + } + } + } + } + } + + return this; + } + + function once() { + var dom = this; + + for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) { + args[_key7] = arguments[_key7]; + } + + var eventName = args[0], + targetSelector = args[1], + listener = args[2], + capture = args[3]; + + if (typeof args[1] === 'function') { + eventName = args[0]; + listener = args[1]; + capture = args[2]; + targetSelector = undefined; + } + + function onceHandler() { + for (var _len8 = arguments.length, eventArgs = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) { + eventArgs[_key8] = arguments[_key8]; + } + + listener.apply(this, eventArgs); + dom.off(eventName, targetSelector, onceHandler, capture); + + if (onceHandler.dom7proxy) { + delete onceHandler.dom7proxy; + } + } + + onceHandler.dom7proxy = listener; + return dom.on(eventName, targetSelector, onceHandler, capture); + } + + function trigger() { + var window = ssrWindow_umd.getWindow(); + + for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) { + args[_key9] = arguments[_key9]; + } + + var events = args[0].split(' '); + var eventData = args[1]; + + for (var i = 0; i < events.length; i += 1) { + var event = events[i]; + + for (var j = 0; j < this.length; j += 1) { + var el = this[j]; + + if (window.CustomEvent) { + var evt = new window.CustomEvent(event, { + detail: eventData, + bubbles: true, + cancelable: true + }); + el.dom7EventData = args.filter(function (data, dataIndex) { + return dataIndex > 0; + }); + el.dispatchEvent(evt); + el.dom7EventData = []; + delete el.dom7EventData; + } + } + } + + return this; + } + + function transitionEnd(callback) { + var dom = this; + + function fireCallBack(e) { + if (e.target !== this) return; + callback.call(this, e); + dom.off('transitionend', fireCallBack); + } + + if (callback) { + dom.on('transitionend', fireCallBack); + } + + return this; + } + + function animationEnd(callback) { + var dom = this; + + function fireCallBack(e) { + if (e.target !== this) return; + callback.call(this, e); + dom.off('animationend', fireCallBack); + } + + if (callback) { + dom.on('animationend', fireCallBack); + } + + return this; + } + + function width() { + var window = ssrWindow_umd.getWindow(); + + if (this[0] === window) { + return window.innerWidth; + } + + if (this.length > 0) { + return parseFloat(this.css('width')); + } + + return null; + } + + function outerWidth(includeMargins) { + if (this.length > 0) { + if (includeMargins) { + var _styles = this.styles(); + + return this[0].offsetWidth + parseFloat(_styles.getPropertyValue('margin-right')) + parseFloat(_styles.getPropertyValue('margin-left')); + } + + return this[0].offsetWidth; + } + + return null; + } + + function height() { + var window = ssrWindow_umd.getWindow(); + + if (this[0] === window) { + return window.innerHeight; + } + + if (this.length > 0) { + return parseFloat(this.css('height')); + } + + return null; + } + + function outerHeight(includeMargins) { + if (this.length > 0) { + if (includeMargins) { + var _styles2 = this.styles(); + + return this[0].offsetHeight + parseFloat(_styles2.getPropertyValue('margin-top')) + parseFloat(_styles2.getPropertyValue('margin-bottom')); + } + + return this[0].offsetHeight; + } + + return null; + } + + function offset() { + if (this.length > 0) { + var window = ssrWindow_umd.getWindow(); + var document = ssrWindow_umd.getDocument(); + var el = this[0]; + var box = el.getBoundingClientRect(); + var body = document.body; + var clientTop = el.clientTop || body.clientTop || 0; + var clientLeft = el.clientLeft || body.clientLeft || 0; + var scrollTop = el === window ? window.scrollY : el.scrollTop; + var scrollLeft = el === window ? window.scrollX : el.scrollLeft; + return { + top: box.top + scrollTop - clientTop, + left: box.left + scrollLeft - clientLeft + }; + } + + return null; + } + + function hide() { + for (var i = 0; i < this.length; i += 1) { + this[i].style.display = 'none'; + } + + return this; + } + + function show() { + var window = ssrWindow_umd.getWindow(); + + for (var i = 0; i < this.length; i += 1) { + var el = this[i]; + + if (el.style.display === 'none') { + el.style.display = ''; + } + + if (window.getComputedStyle(el, null).getPropertyValue('display') === 'none') { + // Still not visible + el.style.display = 'block'; + } + } + + return this; + } + + function styles() { + var window = ssrWindow_umd.getWindow(); + if (this[0]) return window.getComputedStyle(this[0], null); + return {}; + } + + function css(props, value) { + var window = ssrWindow_umd.getWindow(); + var i; + + if (arguments.length === 1) { + if (typeof props === 'string') { + // .css('width') + if (this[0]) return window.getComputedStyle(this[0], null).getPropertyValue(props); + } else { + // .css({ width: '100px' }) + for (i = 0; i < this.length; i += 1) { + for (var _prop in props) { + this[i].style[_prop] = props[_prop]; + } + } + + return this; + } + } + + if (arguments.length === 2 && typeof props === 'string') { + // .css('width', '100px') + for (i = 0; i < this.length; i += 1) { + this[i].style[props] = value; + } + + return this; + } + + return this; + } + + function each(callback) { + if (!callback) return this; + this.forEach(function (el, index) { + callback.apply(el, [el, index]); + }); + return this; + } + + function filter(callback) { + var result = arrayFilter(this, callback); + return $(result); + } + + function html(html) { + if (typeof html === 'undefined') { + return this[0] ? this[0].innerHTML : null; + } + + for (var i = 0; i < this.length; i += 1) { + this[i].innerHTML = html; + } + + return this; + } + + function text(text) { + if (typeof text === 'undefined') { + return this[0] ? this[0].textContent.trim() : null; + } + + for (var i = 0; i < this.length; i += 1) { + this[i].textContent = text; + } + + return this; + } + + function is(selector) { + var window = ssrWindow_umd.getWindow(); + var document = ssrWindow_umd.getDocument(); + var el = this[0]; + var compareWith; + var i; + if (!el || typeof selector === 'undefined') return false; + + if (typeof selector === 'string') { + if (el.matches) return el.matches(selector); + if (el.webkitMatchesSelector) return el.webkitMatchesSelector(selector); + if (el.msMatchesSelector) return el.msMatchesSelector(selector); + compareWith = $(selector); + + for (i = 0; i < compareWith.length; i += 1) { + if (compareWith[i] === el) return true; + } + + return false; + } + + if (selector === document) { + return el === document; + } + + if (selector === window) { + return el === window; + } + + if (selector.nodeType || selector instanceof Dom7) { + compareWith = selector.nodeType ? [selector] : selector; + + for (i = 0; i < compareWith.length; i += 1) { + if (compareWith[i] === el) return true; + } + + return false; + } + + return false; + } + + function index$1() { + var child = this[0]; + var i; + + if (child) { + i = 0; // eslint-disable-next-line + + while ((child = child.previousSibling) !== null) { + if (child.nodeType === 1) i += 1; + } + + return i; + } + + return undefined; + } + + function eq(index) { + if (typeof index === 'undefined') return this; + var length = this.length; + + if (index > length - 1) { + return $([]); + } + + if (index < 0) { + var returnIndex = length + index; + if (returnIndex < 0) return $([]); + return $([this[returnIndex]]); + } + + return $([this[index]]); + } + + function append() { + var newChild; + var document = ssrWindow_umd.getDocument(); + + for (var k = 0; k < arguments.length; k += 1) { + newChild = k < 0 || arguments.length <= k ? undefined : arguments[k]; + + for (var i = 0; i < this.length; i += 1) { + if (typeof newChild === 'string') { + var tempDiv = document.createElement('div'); + tempDiv.innerHTML = newChild; + + while (tempDiv.firstChild) { + this[i].appendChild(tempDiv.firstChild); + } + } else if (newChild instanceof Dom7) { + for (var j = 0; j < newChild.length; j += 1) { + this[i].appendChild(newChild[j]); + } + } else { + this[i].appendChild(newChild); + } + } + } + + return this; + } + + function appendTo(parent) { + $(parent).append(this); + return this; + } + + function prepend(newChild) { + var document = ssrWindow_umd.getDocument(); + var i; + var j; + + for (i = 0; i < this.length; i += 1) { + if (typeof newChild === 'string') { + var tempDiv = document.createElement('div'); + tempDiv.innerHTML = newChild; + + for (j = tempDiv.childNodes.length - 1; j >= 0; j -= 1) { + this[i].insertBefore(tempDiv.childNodes[j], this[i].childNodes[0]); + } + } else if (newChild instanceof Dom7) { + for (j = 0; j < newChild.length; j += 1) { + this[i].insertBefore(newChild[j], this[i].childNodes[0]); + } + } else { + this[i].insertBefore(newChild, this[i].childNodes[0]); + } + } + + return this; + } + + function prependTo(parent) { + $(parent).prepend(this); + return this; + } + + function insertBefore(selector) { + var before = $(selector); + + for (var i = 0; i < this.length; i += 1) { + if (before.length === 1) { + before[0].parentNode.insertBefore(this[i], before[0]); + } else if (before.length > 1) { + for (var j = 0; j < before.length; j += 1) { + before[j].parentNode.insertBefore(this[i].cloneNode(true), before[j]); + } + } + } + } + + function insertAfter(selector) { + var after = $(selector); + + for (var i = 0; i < this.length; i += 1) { + if (after.length === 1) { + after[0].parentNode.insertBefore(this[i], after[0].nextSibling); + } else if (after.length > 1) { + for (var j = 0; j < after.length; j += 1) { + after[j].parentNode.insertBefore(this[i].cloneNode(true), after[j].nextSibling); + } + } + } + } + + function next(selector) { + if (this.length > 0) { + if (selector) { + if (this[0].nextElementSibling && $(this[0].nextElementSibling).is(selector)) { + return $([this[0].nextElementSibling]); + } + + return $([]); + } + + if (this[0].nextElementSibling) return $([this[0].nextElementSibling]); + return $([]); + } + + return $([]); + } + + function nextAll(selector) { + var nextEls = []; + var el = this[0]; + if (!el) return $([]); + + while (el.nextElementSibling) { + var _next = el.nextElementSibling; // eslint-disable-line + + if (selector) { + if ($(_next).is(selector)) nextEls.push(_next); + } else nextEls.push(_next); + + el = _next; + } + + return $(nextEls); + } + + function prev(selector) { + if (this.length > 0) { + var el = this[0]; + + if (selector) { + if (el.previousElementSibling && $(el.previousElementSibling).is(selector)) { + return $([el.previousElementSibling]); + } + + return $([]); + } + + if (el.previousElementSibling) return $([el.previousElementSibling]); + return $([]); + } + + return $([]); + } + + function prevAll(selector) { + var prevEls = []; + var el = this[0]; + if (!el) return $([]); + + while (el.previousElementSibling) { + var _prev = el.previousElementSibling; // eslint-disable-line + + if (selector) { + if ($(_prev).is(selector)) prevEls.push(_prev); + } else prevEls.push(_prev); + + el = _prev; + } + + return $(prevEls); + } + + function siblings(selector) { + return this.nextAll(selector).add(this.prevAll(selector)); + } + + function parent(selector) { + var parents = []; // eslint-disable-line + + for (var i = 0; i < this.length; i += 1) { + if (this[i].parentNode !== null) { + if (selector) { + if ($(this[i].parentNode).is(selector)) parents.push(this[i].parentNode); + } else { + parents.push(this[i].parentNode); + } + } + } + + return $(parents); + } + + function parents(selector) { + var parents = []; // eslint-disable-line + + for (var i = 0; i < this.length; i += 1) { + var _parent = this[i].parentNode; // eslint-disable-line + + while (_parent) { + if (selector) { + if ($(_parent).is(selector)) parents.push(_parent); + } else { + parents.push(_parent); + } + + _parent = _parent.parentNode; + } + } + + return $(parents); + } + + function closest(selector) { + var closest = this; // eslint-disable-line + + if (typeof selector === 'undefined') { + return $([]); + } + + if (!closest.is(selector)) { + closest = closest.parents(selector).eq(0); + } + + return closest; + } + + function find(selector) { + var foundElements = []; + + for (var i = 0; i < this.length; i += 1) { + var found = this[i].querySelectorAll(selector); + + for (var j = 0; j < found.length; j += 1) { + foundElements.push(found[j]); + } + } + + return $(foundElements); + } + + function children(selector) { + var children = []; // eslint-disable-line + + for (var i = 0; i < this.length; i += 1) { + var childNodes = this[i].children; + + for (var j = 0; j < childNodes.length; j += 1) { + if (!selector || $(childNodes[j]).is(selector)) { + children.push(childNodes[j]); + } + } + } + + return $(children); + } + + function remove() { + for (var i = 0; i < this.length; i += 1) { + if (this[i].parentNode) this[i].parentNode.removeChild(this[i]); + } + + return this; + } + + function detach() { + return this.remove(); + } + + function add() { + var dom = this; + var i; + var j; + + for (var _len10 = arguments.length, els = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) { + els[_key10] = arguments[_key10]; + } + + for (i = 0; i < els.length; i += 1) { + var toAdd = $(els[i]); + + for (j = 0; j < toAdd.length; j += 1) { + dom.push(toAdd[j]); + } + } + + return dom; + } + + function empty() { + for (var i = 0; i < this.length; i += 1) { + var el = this[i]; + + if (el.nodeType === 1) { + for (var j = 0; j < el.childNodes.length; j += 1) { + if (el.childNodes[j].parentNode) { + el.childNodes[j].parentNode.removeChild(el.childNodes[j]); + } + } + + el.textContent = ''; + } + } + + return this; + } + + function scrollTo() { + var window = ssrWindow_umd.getWindow(); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + var left = args[0], + top = args[1], + duration = args[2], + easing = args[3], + callback = args[4]; + + if (args.length === 4 && typeof easing === 'function') { + callback = easing; + left = args[0]; + top = args[1]; + duration = args[2]; + callback = args[3]; + easing = args[4]; + } + + if (typeof easing === 'undefined') easing = 'swing'; + return this.each(function animate() { + var el = this; + var currentTop; + var currentLeft; + var maxTop; + var maxLeft; + var newTop; + var newLeft; + var scrollTop; // eslint-disable-line + + var scrollLeft; // eslint-disable-line + + var animateTop = top > 0 || top === 0; + var animateLeft = left > 0 || left === 0; + + if (typeof easing === 'undefined') { + easing = 'swing'; + } + + if (animateTop) { + currentTop = el.scrollTop; + + if (!duration) { + el.scrollTop = top; + } + } + + if (animateLeft) { + currentLeft = el.scrollLeft; + + if (!duration) { + el.scrollLeft = left; + } + } + + if (!duration) return; + + if (animateTop) { + maxTop = el.scrollHeight - el.offsetHeight; + newTop = Math.max(Math.min(top, maxTop), 0); + } + + if (animateLeft) { + maxLeft = el.scrollWidth - el.offsetWidth; + newLeft = Math.max(Math.min(left, maxLeft), 0); + } + + var startTime = null; + if (animateTop && newTop === currentTop) animateTop = false; + if (animateLeft && newLeft === currentLeft) animateLeft = false; + + function render(time) { + if (time === void 0) { + time = new Date().getTime(); + } + + if (startTime === null) { + startTime = time; + } + + var progress = Math.max(Math.min((time - startTime) / duration, 1), 0); + var easeProgress = easing === 'linear' ? progress : 0.5 - Math.cos(progress * Math.PI) / 2; + var done; + if (animateTop) scrollTop = currentTop + easeProgress * (newTop - currentTop); + if (animateLeft) scrollLeft = currentLeft + easeProgress * (newLeft - currentLeft); + + if (animateTop && newTop > currentTop && scrollTop >= newTop) { + el.scrollTop = newTop; + done = true; + } + + if (animateTop && newTop < currentTop && scrollTop <= newTop) { + el.scrollTop = newTop; + done = true; + } + + if (animateLeft && newLeft > currentLeft && scrollLeft >= newLeft) { + el.scrollLeft = newLeft; + done = true; + } + + if (animateLeft && newLeft < currentLeft && scrollLeft <= newLeft) { + el.scrollLeft = newLeft; + done = true; + } + + if (done) { + if (callback) callback(); + return; + } + + if (animateTop) el.scrollTop = scrollTop; + if (animateLeft) el.scrollLeft = scrollLeft; + window.requestAnimationFrame(render); + } + + window.requestAnimationFrame(render); + }); + } // scrollTop(top, duration, easing, callback) { + + + function scrollTop() { + for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments[_key2]; + } + + var top = args[0], + duration = args[1], + easing = args[2], + callback = args[3]; + + if (args.length === 3 && typeof easing === 'function') { + top = args[0]; + duration = args[1]; + callback = args[2]; + easing = args[3]; + } + + var dom = this; + + if (typeof top === 'undefined') { + if (dom.length > 0) return dom[0].scrollTop; + return null; + } + + return dom.scrollTo(undefined, top, duration, easing, callback); + } + + function scrollLeft() { + for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + args[_key3] = arguments[_key3]; + } + + var left = args[0], + duration = args[1], + easing = args[2], + callback = args[3]; + + if (args.length === 3 && typeof easing === 'function') { + left = args[0]; + duration = args[1]; + callback = args[2]; + easing = args[3]; + } + + var dom = this; + + if (typeof left === 'undefined') { + if (dom.length > 0) return dom[0].scrollLeft; + return null; + } + + return dom.scrollTo(left, undefined, duration, easing, callback); + } + + function animate(initialProps, initialParams) { + var window = ssrWindow_umd.getWindow(); + var els = this; + var a = { + props: Object.assign({}, initialProps), + params: Object.assign({ + duration: 300, + easing: 'swing' // or 'linear' + + /* Callbacks + begin(elements) + complete(elements) + progress(elements, complete, remaining, start, tweenValue) + */ + + }, initialParams), + elements: els, + animating: false, + que: [], + easingProgress: function easingProgress(easing, progress) { + if (easing === 'swing') { + return 0.5 - Math.cos(progress * Math.PI) / 2; + } + + if (typeof easing === 'function') { + return easing(progress); + } + + return progress; + }, + stop: function stop() { + if (a.frameId) { + window.cancelAnimationFrame(a.frameId); + } + + a.animating = false; + a.elements.each(function (el) { + var element = el; + delete element.dom7AnimateInstance; + }); + a.que = []; + }, + done: function done(complete) { + a.animating = false; + a.elements.each(function (el) { + var element = el; + delete element.dom7AnimateInstance; + }); + if (complete) complete(els); + + if (a.que.length > 0) { + var que = a.que.shift(); + a.animate(que[0], que[1]); + } + }, + animate: function animate(props, params) { + if (a.animating) { + a.que.push([props, params]); + return a; + } + + var elements = []; // Define & Cache Initials & Units + + a.elements.each(function (el, index) { + var initialFullValue; + var initialValue; + var unit; + var finalValue; + var finalFullValue; + if (!el.dom7AnimateInstance) a.elements[index].dom7AnimateInstance = a; + elements[index] = { + container: el + }; + Object.keys(props).forEach(function (prop) { + initialFullValue = window.getComputedStyle(el, null).getPropertyValue(prop).replace(',', '.'); + initialValue = parseFloat(initialFullValue); + unit = initialFullValue.replace(initialValue, ''); + finalValue = parseFloat(props[prop]); + finalFullValue = props[prop] + unit; + elements[index][prop] = { + initialFullValue: initialFullValue, + initialValue: initialValue, + unit: unit, + finalValue: finalValue, + finalFullValue: finalFullValue, + currentValue: initialValue + }; + }); + }); + var startTime = null; + var time; + var elementsDone = 0; + var propsDone = 0; + var done; + var began = false; + a.animating = true; + + function render() { + time = new Date().getTime(); + var progress; + var easeProgress; // let el; + + if (!began) { + began = true; + if (params.begin) params.begin(els); + } + + if (startTime === null) { + startTime = time; + } + + if (params.progress) { + // eslint-disable-next-line + params.progress(els, Math.max(Math.min((time - startTime) / params.duration, 1), 0), startTime + params.duration - time < 0 ? 0 : startTime + params.duration - time, startTime); + } + + elements.forEach(function (element) { + var el = element; + if (done || el.done) return; + Object.keys(props).forEach(function (prop) { + if (done || el.done) return; + progress = Math.max(Math.min((time - startTime) / params.duration, 1), 0); + easeProgress = a.easingProgress(params.easing, progress); + var _el$prop = el[prop], + initialValue = _el$prop.initialValue, + finalValue = _el$prop.finalValue, + unit = _el$prop.unit; + el[prop].currentValue = initialValue + easeProgress * (finalValue - initialValue); + var currentValue = el[prop].currentValue; + + if (finalValue > initialValue && currentValue >= finalValue || finalValue < initialValue && currentValue <= finalValue) { + el.container.style[prop] = finalValue + unit; + propsDone += 1; + + if (propsDone === Object.keys(props).length) { + el.done = true; + elementsDone += 1; + } + + if (elementsDone === elements.length) { + done = true; + } + } + + if (done) { + a.done(params.complete); + return; + } + + el.container.style[prop] = currentValue + unit; + }); + }); + if (done) return; // Then call + + a.frameId = window.requestAnimationFrame(render); + } + + a.frameId = window.requestAnimationFrame(render); + return a; + } + }; + + if (a.elements.length === 0) { + return els; + } + + var animateInstance; + + for (var i = 0; i < a.elements.length; i += 1) { + if (a.elements[i].dom7AnimateInstance) { + animateInstance = a.elements[i].dom7AnimateInstance; + } else a.elements[i].dom7AnimateInstance = a; + } + + if (!animateInstance) { + animateInstance = a; + } + + if (initialProps === 'stop') { + animateInstance.stop(); + } else { + animateInstance.animate(a.props, a.params); + } + + return els; + } + + function stop() { + var els = this; + + for (var i = 0; i < els.length; i += 1) { + if (els[i].dom7AnimateInstance) { + els[i].dom7AnimateInstance.stop(); + } + } + } + + var noTrigger = 'resize scroll'.split(' '); + + function shortcut(name) { + function eventHandler() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + if (typeof args[0] === 'undefined') { + for (var i = 0; i < this.length; i += 1) { + if (noTrigger.indexOf(name) < 0) { + if (name in this[i]) this[i][name]();else { + $(this[i]).trigger(name); + } + } + } + + return this; + } + + return this.on.apply(this, [name].concat(args)); + } + + return eventHandler; + } + + var click = shortcut('click'); + var blur = shortcut('blur'); + var focus = shortcut('focus'); + var focusin = shortcut('focusin'); + var focusout = shortcut('focusout'); + var keyup = shortcut('keyup'); + var keydown = shortcut('keydown'); + var keypress = shortcut('keypress'); + var submit = shortcut('submit'); + var change = shortcut('change'); + var mousedown = shortcut('mousedown'); + var mousemove = shortcut('mousemove'); + var mouseup = shortcut('mouseup'); + var mouseenter = shortcut('mouseenter'); + var mouseleave = shortcut('mouseleave'); + var mouseout = shortcut('mouseout'); + var mouseover = shortcut('mouseover'); + var touchstart = shortcut('touchstart'); + var touchend = shortcut('touchend'); + var touchmove = shortcut('touchmove'); + var resize = shortcut('resize'); + var scroll = shortcut('scroll'); + + var $_1 = $; + var add_1 = add; + var addClass_1 = addClass; + var animate_1 = animate; + var animationEnd_1 = animationEnd; + var append_1 = append; + var appendTo_1 = appendTo; + var attr_1 = attr; + var blur_1 = blur; + var change_1 = change; + var children_1 = children; + var click_1 = click; + var closest_1 = closest; + var css_1 = css; + var data_1 = data; + var dataset_1 = dataset; + var _default$1 = $; + var detach_1 = detach; + var each_1 = each; + var empty_1 = empty; + var eq_1 = eq; + var filter_1 = filter; + var find_1 = find; + var focus_1 = focus; + var focusin_1 = focusin; + var focusout_1 = focusout; + var hasClass_1 = hasClass; + var height_1 = height; + var hide_1 = hide; + var html_1 = html; + var index_1 = index$1; + var insertAfter_1 = insertAfter; + var insertBefore_1 = insertBefore; + var is_1 = is; + var keydown_1 = keydown; + var keypress_1 = keypress; + var keyup_1 = keyup; + var mousedown_1 = mousedown; + var mouseenter_1 = mouseenter; + var mouseleave_1 = mouseleave; + var mousemove_1 = mousemove; + var mouseout_1 = mouseout; + var mouseover_1 = mouseover; + var mouseup_1 = mouseup; + var next_1 = next; + var nextAll_1 = nextAll; + var off_1 = off; + var offset_1 = offset; + var on_1 = on; + var once_1 = once; + var outerHeight_1 = outerHeight; + var outerWidth_1 = outerWidth; + var parent_1 = parent; + var parents_1 = parents; + var prepend_1 = prepend; + var prependTo_1 = prependTo; + var prev_1 = prev; + var prevAll_1 = prevAll; + var prop_1 = prop; + var remove_1 = remove; + var removeAttr_1 = removeAttr; + var removeClass_1 = removeClass; + var removeData_1 = removeData; + var resize_1 = resize; + var scroll_1 = scroll; + var scrollLeft_1 = scrollLeft; + var scrollTo_1 = scrollTo; + var scrollTop_1 = scrollTop; + var show_1 = show; + var siblings_1 = siblings; + var stop_1 = stop; + var styles_1 = styles; + var submit_1 = submit; + var text_1 = text; + var toggleClass_1 = toggleClass; + var touchend_1 = touchend; + var touchmove_1 = touchmove; + var touchstart_1 = touchstart; + var transform_1 = transform; + var transition_1 = transition; + var transitionEnd_1 = transitionEnd; + var trigger_1 = trigger; + var val_1 = val; + var value_1 = value; + var width_1 = width; + + var dom7_cjs = /*#__PURE__*/Object.defineProperty({ + $: $_1, + add: add_1, + addClass: addClass_1, + animate: animate_1, + animationEnd: animationEnd_1, + append: append_1, + appendTo: appendTo_1, + attr: attr_1, + blur: blur_1, + change: change_1, + children: children_1, + click: click_1, + closest: closest_1, + css: css_1, + data: data_1, + dataset: dataset_1, + default: _default$1, + detach: detach_1, + each: each_1, + empty: empty_1, + eq: eq_1, + filter: filter_1, + find: find_1, + focus: focus_1, + focusin: focusin_1, + focusout: focusout_1, + hasClass: hasClass_1, + height: height_1, + hide: hide_1, + html: html_1, + index: index_1, + insertAfter: insertAfter_1, + insertBefore: insertBefore_1, + is: is_1, + keydown: keydown_1, + keypress: keypress_1, + keyup: keyup_1, + mousedown: mousedown_1, + mouseenter: mouseenter_1, + mouseleave: mouseleave_1, + mousemove: mousemove_1, + mouseout: mouseout_1, + mouseover: mouseover_1, + mouseup: mouseup_1, + next: next_1, + nextAll: nextAll_1, + off: off_1, + offset: offset_1, + on: on_1, + once: once_1, + outerHeight: outerHeight_1, + outerWidth: outerWidth_1, + parent: parent_1, + parents: parents_1, + prepend: prepend_1, + prependTo: prependTo_1, + prev: prev_1, + prevAll: prevAll_1, + prop: prop_1, + remove: remove_1, + removeAttr: removeAttr_1, + removeClass: removeClass_1, + removeData: removeData_1, + resize: resize_1, + scroll: scroll_1, + scrollLeft: scrollLeft_1, + scrollTo: scrollTo_1, + scrollTop: scrollTop_1, + show: show_1, + siblings: siblings_1, + stop: stop_1, + styles: styles_1, + submit: submit_1, + text: text_1, + toggleClass: toggleClass_1, + touchend: touchend_1, + touchmove: touchmove_1, + touchstart: touchstart_1, + transform: transform_1, + transition: transition_1, + transitionEnd: transitionEnd_1, + trigger: trigger_1, + val: val_1, + value: value_1, + width: width_1 + }, '__esModule', {value: true}); + + /** + * lodash (Custom Build) + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + /** Used as references for various `Number` constants. */ + var MAX_SAFE_INTEGER = 9007199254740991; + + /** `Object#toString` result references. */ + var argsTag = '[object Arguments]', + funcTag = '[object Function]', + genTag = '[object GeneratorFunction]'; + + /** Used to detect unsigned integer values. */ + var reIsUint = /^(?:0|[1-9]\d*)$/; + + /** + * A specialized version of `_.forEach` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns `array`. + */ + function arrayEach(array, iteratee) { + var index = -1, + length = array ? array.length : 0; + + while (++index < length) { + if (iteratee(array[index], index, array) === false) { + break; + } + } + return array; + } + + /** + * The base implementation of `_.times` without support for iteratee shorthands + * or max array length checks. + * + * @private + * @param {number} n The number of times to invoke `iteratee`. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the array of results. + */ + function baseTimes(n, iteratee) { + var index = -1, + result = Array(n); + + while (++index < n) { + result[index] = iteratee(index); + } + return result; + } + + /** + * Creates a unary function that invokes `func` with its argument transformed. + * + * @private + * @param {Function} func The function to wrap. + * @param {Function} transform The argument transform. + * @returns {Function} Returns the new function. + */ + function overArg(func, transform) { + return function(arg) { + return func(transform(arg)); + }; + } + + /** Used for built-in method references. */ + var objectProto$3 = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty$1 = objectProto$3.hasOwnProperty; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ + var objectToString$3 = objectProto$3.toString; + + /** Built-in value references. */ + var propertyIsEnumerable = objectProto$3.propertyIsEnumerable; + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeKeys = overArg(Object.keys, Object); + + /** + * Creates an array of the enumerable property names of the array-like `value`. + * + * @private + * @param {*} value The value to query. + * @param {boolean} inherited Specify returning inherited property names. + * @returns {Array} Returns the array of property names. + */ + function arrayLikeKeys(value, inherited) { + // Safari 8.1 makes `arguments.callee` enumerable in strict mode. + // Safari 9 makes `arguments.length` enumerable in strict mode. + var result = (isArray(value) || isArguments(value)) + ? baseTimes(value.length, String) + : []; + + var length = result.length, + skipIndexes = !!length; + + for (var key in value) { + if ((inherited || hasOwnProperty$1.call(value, key)) && + !(skipIndexes && (key == 'length' || isIndex(key, length)))) { + result.push(key); + } + } + return result; + } + + /** + * The base implementation of `_.forEach` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + */ + var baseEach = createBaseEach(baseForOwn); + + /** + * The base implementation of `baseForOwn` which iterates over `object` + * properties returned by `keysFunc` and invokes `iteratee` for each property. + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {Function} keysFunc The function to get the keys of `object`. + * @returns {Object} Returns `object`. + */ + var baseFor = createBaseFor(); + + /** + * The base implementation of `_.forOwn` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */ + function baseForOwn(object, iteratee) { + return object && baseFor(object, iteratee, keys); + } + + /** + * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + function baseKeys(object) { + if (!isPrototype(object)) { + return nativeKeys(object); + } + var result = []; + for (var key in Object(object)) { + if (hasOwnProperty$1.call(object, key) && key != 'constructor') { + result.push(key); + } + } + return result; + } + + /** + * Creates a `baseEach` or `baseEachRight` function. + * + * @private + * @param {Function} eachFunc The function to iterate over a collection. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ + function createBaseEach(eachFunc, fromRight) { + return function(collection, iteratee) { + if (collection == null) { + return collection; + } + if (!isArrayLike(collection)) { + return eachFunc(collection, iteratee); + } + var length = collection.length, + index = fromRight ? length : -1, + iterable = Object(collection); + + while ((fromRight ? index-- : ++index < length)) { + if (iteratee(iterable[index], index, iterable) === false) { + break; + } + } + return collection; + }; + } + + /** + * Creates a base function for methods like `_.forIn` and `_.forOwn`. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ + function createBaseFor(fromRight) { + return function(object, iteratee, keysFunc) { + var index = -1, + iterable = Object(object), + props = keysFunc(object), + length = props.length; + + while (length--) { + var key = props[fromRight ? length : ++index]; + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + return object; + }; + } + + /** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ + function isIndex(value, length) { + length = length == null ? MAX_SAFE_INTEGER : length; + return !!length && + (typeof value == 'number' || reIsUint.test(value)) && + (value > -1 && value % 1 == 0 && value < length); + } + + /** + * Checks if `value` is likely a prototype object. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. + */ + function isPrototype(value) { + var Ctor = value && value.constructor, + proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$3; + + return value === proto; + } + + /** + * Iterates over elements of `collection` and invokes `iteratee` for each element. + * The iteratee is invoked with three arguments: (value, index|key, collection). + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * **Note:** As with other "Collections" methods, objects with a "length" + * property are iterated like arrays. To avoid this behavior use `_.forIn` + * or `_.forOwn` for object iteration. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @alias each + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + * @see _.forEachRight + * @example + * + * _([1, 2]).forEach(function(value) { + * console.log(value); + * }); + * // => Logs `1` then `2`. + * + * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). + */ + function forEach(collection, iteratee) { + var func = isArray(collection) ? arrayEach : baseEach; + return func(collection, typeof iteratee == 'function' ? iteratee : identity); + } + + /** + * Checks if `value` is likely an `arguments` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + * else `false`. + * @example + * + * _.isArguments(function() { return arguments; }()); + * // => true + * + * _.isArguments([1, 2, 3]); + * // => false + */ + function isArguments(value) { + // Safari 8.1 makes `arguments.callee` enumerable in strict mode. + return isArrayLikeObject(value) && hasOwnProperty$1.call(value, 'callee') && + (!propertyIsEnumerable.call(value, 'callee') || objectToString$3.call(value) == argsTag); + } + + /** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ + var isArray = Array.isArray; + + /** + * Checks if `value` is array-like. A value is considered array-like if it's + * not a function and has a `value.length` that's an integer greater than or + * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + * @example + * + * _.isArrayLike([1, 2, 3]); + * // => true + * + * _.isArrayLike(document.body.children); + * // => true + * + * _.isArrayLike('abc'); + * // => true + * + * _.isArrayLike(_.noop); + * // => false + */ + function isArrayLike(value) { + return value != null && isLength(value.length) && !isFunction(value); + } + + /** + * This method is like `_.isArrayLike` except that it also checks if `value` + * is an object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array-like object, + * else `false`. + * @example + * + * _.isArrayLikeObject([1, 2, 3]); + * // => true + * + * _.isArrayLikeObject(document.body.children); + * // => true + * + * _.isArrayLikeObject('abc'); + * // => false + * + * _.isArrayLikeObject(_.noop); + * // => false + */ + function isArrayLikeObject(value) { + return isObjectLike$3(value) && isArrayLike(value); + } + + /** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ + function isFunction(value) { + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 8-9 which returns 'object' for typed array and other constructors. + var tag = isObject$2(value) ? objectToString$3.call(value) : ''; + return tag == funcTag || tag == genTag; + } + + /** + * Checks if `value` is a valid array-like length. + * + * **Note:** This method is loosely based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * @example + * + * _.isLength(3); + * // => true + * + * _.isLength(Number.MIN_VALUE); + * // => false + * + * _.isLength(Infinity); + * // => false + * + * _.isLength('3'); + * // => false + */ + function isLength(value) { + return typeof value == 'number' && + value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; + } + + /** + * 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$2(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); + } + + /** + * 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$3(value) { + return !!value && typeof value == 'object'; + } + + /** + * Creates an array of the own enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * for more details. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] + */ + function keys(object) { + return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); + } + + /** + * This method returns the first argument it receives. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Util + * @param {*} value Any value. + * @returns {*} Returns `value`. + * @example + * + * var object = { 'a': 1 }; + * + * console.log(_.identity(object) === object); + * // => true + */ + function identity(value) { + return value; + } + + var lodash_foreach = forEach; + + let urlAlphabet$1 = + 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'; + var urlAlphabet_1 = { urlAlphabet: urlAlphabet$1 }; + + let { urlAlphabet } = urlAlphabet_1; + { + if ( + typeof navigator !== 'undefined' && + navigator.product === 'ReactNative' && + typeof crypto === 'undefined' + ) { + throw new Error( + 'React Native does not have a built-in secure random generator. ' + + 'If you don’t need unpredictable IDs use `nanoid/non-secure`. ' + + 'For secure IDs, import `react-native-get-random-values` ' + + 'before Nano ID.' + ) + } + if (typeof msCrypto !== 'undefined' && typeof crypto === 'undefined') { + throw new Error( + 'Import file with `if (!window.crypto) window.crypto = window.msCrypto`' + + ' before importing Nano ID to fix IE 11 support' + ) + } + if (typeof crypto === 'undefined') { + throw new Error( + 'Your browser does not have secure random generator. ' + + 'If you don’t need unpredictable IDs, you can use nanoid/non-secure.' + ) + } + } + let random = bytes => crypto.getRandomValues(new Uint8Array(bytes)); + let customRandom = (alphabet, size, getRandom) => { + let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1; + let step = -~((1.6 * mask * size) / alphabet.length); + return () => { + let id = ''; + while (true) { + let bytes = getRandom(step); + let j = step; + while (j--) { + id += alphabet[bytes[j] & mask] || ''; + if (id.length === size) return id + } + } + } + }; + let customAlphabet = (alphabet, size) => customRandom(alphabet, size, random); + let nanoid$2 = (size = 21) => { + let id = ''; + let bytes = crypto.getRandomValues(new Uint8Array(size)); + while (size--) { + let byte = bytes[size] & 63; + if (byte < 36) { + id += byte.toString(36); + } else if (byte < 62) { + id += (byte - 26).toString(36).toUpperCase(); + } else if (byte < 63) { + id += '_'; + } else { + id += '-'; + } + } + return id + }; + var index_browser = { nanoid: nanoid$2, customAlphabet, customRandom, urlAlphabet, random }; + + /** + * lodash (Custom Build) + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + + /** Used as the `TypeError` message for "Functions" methods. */ + var FUNC_ERROR_TEXT$1 = 'Expected a function'; + + /** Used as references for various `Number` constants. */ + var NAN$1 = 0 / 0; + + /** `Object#toString` result references. */ + var symbolTag$2 = '[object Symbol]'; + + /** Used to match leading and trailing whitespace. */ + var reTrim$1 = /^\s+|\s+$/g; + + /** Used to detect bad signed hexadecimal string values. */ + var reIsBadHex$1 = /^[-+]0x[0-9a-f]+$/i; + + /** Used to detect binary string values. */ + var reIsBinary$1 = /^0b[01]+$/i; + + /** Used to detect octal string values. */ + var reIsOctal$1 = /^0o[0-7]+$/i; + + /** Built-in method references without a dependency on `root`. */ + var freeParseInt$1 = parseInt; + + /** Detect free variable `global` from Node.js. */ + var freeGlobal$2 = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal; + + /** Detect free variable `self`. */ + var freeSelf$2 = typeof self == 'object' && self && self.Object === Object && self; + + /** Used as a reference to the global object. */ + var root$2 = freeGlobal$2 || freeSelf$2 || Function('return this')(); + + /** Used for built-in method references. */ + var objectProto$2 = Object.prototype; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ + var objectToString$2 = objectProto$2.toString; + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeMax$1 = Math.max, + nativeMin$1 = Math.min; + + /** + * 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$1 = function() { + return root$2.Date.now(); + }; + + /** + * 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$2(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$1(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, + result = wait - timeSinceLastCall; + + return maxing ? nativeMin$1(result, maxWait - timeSinceLastInvoke) : result; + } + + 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. + timerId = setTimeout(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + if (timerId === undefined) { + timerId = setTimeout(timerExpired, wait); + } + return result; + } + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; + } + + /** + * 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$1); + } + if (isObject$1(options)) { + leading = 'leading' in options ? !!options.leading : leading; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + return debounce$2(func, wait, { + 'leading': leading, + 'maxWait': wait, + 'trailing': trailing + }); + } + + /** + * 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$1(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); + } + + /** + * 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$2(value) { + return !!value && typeof value == 'object'; + } + + /** + * 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$2(value) { + return typeof value == 'symbol' || + (isObjectLike$2(value) && objectToString$2.call(value) == symbolTag$2); + } + + /** + * 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$1(value) { + if (typeof value == 'number') { + return value; + } + if (isSymbol$2(value)) { + return NAN$1; + } + 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 = value.replace(reTrim$1, ''); + var isBinary = reIsBinary$1.test(value); + return (isBinary || reIsOctal$1.test(value)) + ? freeParseInt$1(value.slice(2), isBinary ? 2 : 8) + : (reIsBadHex$1.test(value) ? NAN$1 : +value); + } + + var lodash_throttle = throttle; + + var snabbdom_cjs = createCommonjsModule$1(function (module, exports) { + + Object.defineProperty(exports, '__esModule', { value: true }); + + function createElement(tagName, options) { + return document.createElement(tagName, options); + } + function createElementNS(namespaceURI, qualifiedName, options) { + return document.createElementNS(namespaceURI, qualifiedName, options); + } + function createTextNode(text) { + return document.createTextNode(text); + } + function createComment(text) { + return document.createComment(text); + } + function insertBefore(parentNode, newNode, referenceNode) { + parentNode.insertBefore(newNode, referenceNode); + } + function removeChild(node, child) { + node.removeChild(child); + } + function appendChild(node, child) { + node.appendChild(child); + } + function parentNode(node) { + return node.parentNode; + } + function nextSibling(node) { + return node.nextSibling; + } + function tagName(elm) { + return elm.tagName; + } + function setTextContent(node, text) { + node.textContent = text; + } + function getTextContent(node) { + return node.textContent; + } + function isElement(node) { + return node.nodeType === 1; + } + function isText(node) { + return node.nodeType === 3; + } + function isComment(node) { + return node.nodeType === 8; + } + const htmlDomApi = { + createElement, + createElementNS, + createTextNode, + createComment, + insertBefore, + removeChild, + appendChild, + parentNode, + nextSibling, + tagName, + setTextContent, + getTextContent, + isElement, + isText, + isComment, + }; + + function vnode(sel, data, children, text, elm) { + const key = data === undefined ? undefined : data.key; + return { sel, data, children, text, elm, key }; + } + + const array = Array.isArray; + function primitive(s) { + return typeof s === "string" || + typeof s === "number" || + s instanceof String || + s instanceof Number; + } + + function isUndef(s) { + return s === undefined; + } + function isDef(s) { + return s !== undefined; + } + const emptyNode = vnode("", {}, [], undefined, undefined); + function sameVnode(vnode1, vnode2) { + var _a, _b; + const isSameKey = vnode1.key === vnode2.key; + const isSameIs = ((_a = vnode1.data) === null || _a === void 0 ? void 0 : _a.is) === ((_b = vnode2.data) === null || _b === void 0 ? void 0 : _b.is); + const isSameSel = vnode1.sel === vnode2.sel; + return isSameSel && isSameKey && isSameIs; + } + function isVnode(vnode) { + return vnode.sel !== undefined; + } + function createKeyToOldIdx(children, beginIdx, endIdx) { + var _a; + const map = {}; + for (let i = beginIdx; i <= endIdx; ++i) { + const key = (_a = children[i]) === null || _a === void 0 ? void 0 : _a.key; + if (key !== undefined) { + map[key] = i; + } + } + return map; + } + const hooks = [ + "create", + "update", + "remove", + "destroy", + "pre", + "post", + ]; + function init$1(modules, domApi) { + const cbs = { + create: [], + update: [], + remove: [], + destroy: [], + pre: [], + post: [], + }; + const api = domApi !== undefined ? domApi : htmlDomApi; + for (const hook of hooks) { + for (const module of modules) { + const currentHook = module[hook]; + if (currentHook !== undefined) { + cbs[hook].push(currentHook); + } + } + } + function emptyNodeAt(elm) { + const id = elm.id ? "#" + elm.id : ""; + // elm.className doesn't return a string when elm is an SVG element inside a shadowRoot. + // https://stackoverflow.com/questions/29454340/detecting-classname-of-svganimatedstring + const classes = elm.getAttribute("class"); + const c = classes ? "." + classes.split(" ").join(".") : ""; + return vnode(api.tagName(elm).toLowerCase() + id + c, {}, [], undefined, elm); + } + function createRmCb(childElm, listeners) { + return function rmCb() { + if (--listeners === 0) { + const parent = api.parentNode(childElm); + api.removeChild(parent, childElm); + } + }; + } + function createElm(vnode, insertedVnodeQueue) { + var _a, _b; + let i; + let data = vnode.data; + if (data !== undefined) { + const init = (_a = data.hook) === null || _a === void 0 ? void 0 : _a.init; + if (isDef(init)) { + init(vnode); + data = vnode.data; + } + } + const children = vnode.children; + const sel = vnode.sel; + if (sel === "!") { + if (isUndef(vnode.text)) { + vnode.text = ""; + } + vnode.elm = api.createComment(vnode.text); + } + else if (sel !== undefined) { + // Parse selector + const hashIdx = sel.indexOf("#"); + const dotIdx = sel.indexOf(".", hashIdx); + const hash = hashIdx > 0 ? hashIdx : sel.length; + const dot = dotIdx > 0 ? dotIdx : sel.length; + const tag = hashIdx !== -1 || dotIdx !== -1 + ? sel.slice(0, Math.min(hash, dot)) + : sel; + const elm = (vnode.elm = + isDef(data) && isDef((i = data.ns)) + ? api.createElementNS(i, tag, data) + : api.createElement(tag, data)); + if (hash < dot) + elm.setAttribute("id", sel.slice(hash + 1, dot)); + if (dotIdx > 0) + elm.setAttribute("class", sel.slice(dot + 1).replace(/\./g, " ")); + for (i = 0; i < cbs.create.length; ++i) + cbs.create[i](emptyNode, vnode); + if (array(children)) { + for (i = 0; i < children.length; ++i) { + const ch = children[i]; + if (ch != null) { + api.appendChild(elm, createElm(ch, insertedVnodeQueue)); + } + } + } + else if (primitive(vnode.text)) { + api.appendChild(elm, api.createTextNode(vnode.text)); + } + const hook = vnode.data.hook; + if (isDef(hook)) { + (_b = hook.create) === null || _b === void 0 ? void 0 : _b.call(hook, emptyNode, vnode); + if (hook.insert) { + insertedVnodeQueue.push(vnode); + } + } + } + else { + vnode.elm = api.createTextNode(vnode.text); + } + return vnode.elm; + } + function addVnodes(parentElm, before, vnodes, startIdx, endIdx, insertedVnodeQueue) { + for (; startIdx <= endIdx; ++startIdx) { + const ch = vnodes[startIdx]; + if (ch != null) { + api.insertBefore(parentElm, createElm(ch, insertedVnodeQueue), before); + } + } + } + function invokeDestroyHook(vnode) { + var _a, _b; + const data = vnode.data; + if (data !== undefined) { + (_b = (_a = data === null || data === void 0 ? void 0 : data.hook) === null || _a === void 0 ? void 0 : _a.destroy) === null || _b === void 0 ? void 0 : _b.call(_a, vnode); + for (let i = 0; i < cbs.destroy.length; ++i) + cbs.destroy[i](vnode); + if (vnode.children !== undefined) { + for (let j = 0; j < vnode.children.length; ++j) { + const child = vnode.children[j]; + if (child != null && typeof child !== "string") { + invokeDestroyHook(child); + } + } + } + } + } + function removeVnodes(parentElm, vnodes, startIdx, endIdx) { + var _a, _b; + for (; startIdx <= endIdx; ++startIdx) { + let listeners; + let rm; + const ch = vnodes[startIdx]; + if (ch != null) { + if (isDef(ch.sel)) { + invokeDestroyHook(ch); + listeners = cbs.remove.length + 1; + rm = createRmCb(ch.elm, listeners); + for (let i = 0; i < cbs.remove.length; ++i) + cbs.remove[i](ch, rm); + const removeHook = (_b = (_a = ch === null || ch === void 0 ? void 0 : ch.data) === null || _a === void 0 ? void 0 : _a.hook) === null || _b === void 0 ? void 0 : _b.remove; + if (isDef(removeHook)) { + removeHook(ch, rm); + } + else { + rm(); + } + } + else { + // Text node + api.removeChild(parentElm, ch.elm); + } + } + } + } + function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue) { + let oldStartIdx = 0; + let newStartIdx = 0; + let oldEndIdx = oldCh.length - 1; + let oldStartVnode = oldCh[0]; + let oldEndVnode = oldCh[oldEndIdx]; + let newEndIdx = newCh.length - 1; + let newStartVnode = newCh[0]; + let newEndVnode = newCh[newEndIdx]; + let oldKeyToIdx; + let idxInOld; + let elmToMove; + let before; + while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { + if (oldStartVnode == null) { + oldStartVnode = oldCh[++oldStartIdx]; // Vnode might have been moved left + } + else if (oldEndVnode == null) { + oldEndVnode = oldCh[--oldEndIdx]; + } + else if (newStartVnode == null) { + newStartVnode = newCh[++newStartIdx]; + } + else if (newEndVnode == null) { + newEndVnode = newCh[--newEndIdx]; + } + else if (sameVnode(oldStartVnode, newStartVnode)) { + patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue); + oldStartVnode = oldCh[++oldStartIdx]; + newStartVnode = newCh[++newStartIdx]; + } + else if (sameVnode(oldEndVnode, newEndVnode)) { + patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue); + oldEndVnode = oldCh[--oldEndIdx]; + newEndVnode = newCh[--newEndIdx]; + } + else if (sameVnode(oldStartVnode, newEndVnode)) { + // Vnode moved right + patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue); + api.insertBefore(parentElm, oldStartVnode.elm, api.nextSibling(oldEndVnode.elm)); + oldStartVnode = oldCh[++oldStartIdx]; + newEndVnode = newCh[--newEndIdx]; + } + else if (sameVnode(oldEndVnode, newStartVnode)) { + // Vnode moved left + patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue); + api.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm); + oldEndVnode = oldCh[--oldEndIdx]; + newStartVnode = newCh[++newStartIdx]; + } + else { + if (oldKeyToIdx === undefined) { + oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); + } + idxInOld = oldKeyToIdx[newStartVnode.key]; + if (isUndef(idxInOld)) { + // New element + api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm); + } + else { + elmToMove = oldCh[idxInOld]; + if (elmToMove.sel !== newStartVnode.sel) { + api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm); + } + else { + patchVnode(elmToMove, newStartVnode, insertedVnodeQueue); + oldCh[idxInOld] = undefined; + api.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm); + } + } + newStartVnode = newCh[++newStartIdx]; + } + } + if (oldStartIdx <= oldEndIdx || newStartIdx <= newEndIdx) { + if (oldStartIdx > oldEndIdx) { + before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm; + addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue); + } + else { + removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx); + } + } + } + function patchVnode(oldVnode, vnode, insertedVnodeQueue) { + var _a, _b, _c, _d, _e; + const hook = (_a = vnode.data) === null || _a === void 0 ? void 0 : _a.hook; + (_b = hook === null || hook === void 0 ? void 0 : hook.prepatch) === null || _b === void 0 ? void 0 : _b.call(hook, oldVnode, vnode); + const elm = (vnode.elm = oldVnode.elm); + const oldCh = oldVnode.children; + const ch = vnode.children; + if (oldVnode === vnode) + return; + if (vnode.data !== undefined) { + for (let i = 0; i < cbs.update.length; ++i) + cbs.update[i](oldVnode, vnode); + (_d = (_c = vnode.data.hook) === null || _c === void 0 ? void 0 : _c.update) === null || _d === void 0 ? void 0 : _d.call(_c, oldVnode, vnode); + } + if (isUndef(vnode.text)) { + if (isDef(oldCh) && isDef(ch)) { + if (oldCh !== ch) + updateChildren(elm, oldCh, ch, insertedVnodeQueue); + } + else if (isDef(ch)) { + if (isDef(oldVnode.text)) + api.setTextContent(elm, ""); + addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue); + } + else if (isDef(oldCh)) { + removeVnodes(elm, oldCh, 0, oldCh.length - 1); + } + else if (isDef(oldVnode.text)) { + api.setTextContent(elm, ""); + } + } + else if (oldVnode.text !== vnode.text) { + if (isDef(oldCh)) { + removeVnodes(elm, oldCh, 0, oldCh.length - 1); + } + api.setTextContent(elm, vnode.text); + } + (_e = hook === null || hook === void 0 ? void 0 : hook.postpatch) === null || _e === void 0 ? void 0 : _e.call(hook, oldVnode, vnode); + } + return function patch(oldVnode, vnode) { + let i, elm, parent; + const insertedVnodeQueue = []; + for (i = 0; i < cbs.pre.length; ++i) + cbs.pre[i](); + if (!isVnode(oldVnode)) { + oldVnode = emptyNodeAt(oldVnode); + } + if (sameVnode(oldVnode, vnode)) { + patchVnode(oldVnode, vnode, insertedVnodeQueue); + } + else { + elm = oldVnode.elm; + parent = api.parentNode(elm); + createElm(vnode, insertedVnodeQueue); + if (parent !== null) { + api.insertBefore(parent, vnode.elm, api.nextSibling(elm)); + removeVnodes(parent, [oldVnode], 0, 0); + } + } + for (i = 0; i < insertedVnodeQueue.length; ++i) { + insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]); + } + for (i = 0; i < cbs.post.length; ++i) + cbs.post[i](); + return vnode; + }; + } + + function addNS(data, children, sel) { + data.ns = "http://www.w3.org/2000/svg"; + if (sel !== "foreignObject" && children !== undefined) { + for (let i = 0; i < children.length; ++i) { + const childData = children[i].data; + if (childData !== undefined) { + addNS(childData, children[i].children, children[i].sel); + } + } + } + } + function h(sel, b, c) { + let data = {}; + let children; + let text; + let i; + if (c !== undefined) { + if (b !== null) { + data = b; + } + if (array(c)) { + children = c; + } + else if (primitive(c)) { + text = c.toString(); + } + else if (c && c.sel) { + children = [c]; + } + } + else if (b !== undefined && b !== null) { + if (array(b)) { + children = b; + } + else if (primitive(b)) { + text = b.toString(); + } + else if (b && b.sel) { + children = [b]; + } + else { + data = b; + } + } + if (children !== undefined) { + for (i = 0; i < children.length; ++i) { + if (primitive(children[i])) + children[i] = vnode(undefined, undefined, undefined, children[i], undefined); + } + } + if (sel[0] === "s" && + sel[1] === "v" && + sel[2] === "g" && + (sel.length === 3 || sel[3] === "." || sel[3] === "#")) { + addNS(data, children, sel); + } + return vnode(sel, data, children, text, undefined); + } + + function copyToThunk(vnode, thunk) { + vnode.data.fn = thunk.data.fn; + vnode.data.args = thunk.data.args; + thunk.data = vnode.data; + thunk.children = vnode.children; + thunk.text = vnode.text; + thunk.elm = vnode.elm; + } + function init(thunk) { + const cur = thunk.data; + const vnode = cur.fn(...cur.args); + copyToThunk(vnode, thunk); + } + function prepatch(oldVnode, thunk) { + let i; + const old = oldVnode.data; + const cur = thunk.data; + const oldArgs = old.args; + const args = cur.args; + if (old.fn !== cur.fn || oldArgs.length !== args.length) { + copyToThunk(cur.fn(...args), thunk); + return; + } + for (i = 0; i < args.length; ++i) { + if (oldArgs[i] !== args[i]) { + copyToThunk(cur.fn(...args), thunk); + return; + } + } + copyToThunk(oldVnode, thunk); + } + const thunk = function thunk(sel, key, fn, args) { + if (args === undefined) { + args = fn; + fn = key; + key = undefined; + } + return h(sel, { + key: key, + hook: { init, prepatch }, + fn: fn, + args: args, + }); + }; + + function pre(vnode, newVnode) { + const attachData = vnode.data.attachData; + // Copy created placeholder and real element from old vnode + newVnode.data.attachData.placeholder = attachData.placeholder; + newVnode.data.attachData.real = attachData.real; + // Mount real element in vnode so the patch process operates on it + vnode.elm = vnode.data.attachData.real; + } + function post(_, vnode) { + // Mount dummy placeholder in vnode so potential reorders use it + vnode.elm = vnode.data.attachData.placeholder; + } + function destroy(vnode) { + // Remove placeholder + if (vnode.elm !== undefined) { + vnode.elm.parentNode.removeChild(vnode.elm); + } + // Remove real element from where it was inserted + vnode.elm = vnode.data.attachData.real; + } + function create(_, vnode) { + const real = vnode.elm; + const attachData = vnode.data.attachData; + const placeholder = document.createElement("span"); + // Replace actual element with dummy placeholder + // Snabbdom will then insert placeholder instead + vnode.elm = placeholder; + attachData.target.appendChild(real); + attachData.real = real; + attachData.placeholder = placeholder; + } + function attachTo(target, vnode) { + if (vnode.data === undefined) + vnode.data = {}; + if (vnode.data.hook === undefined) + vnode.data.hook = {}; + const data = vnode.data; + const hook = vnode.data.hook; + data.attachData = { target: target, placeholder: undefined, real: undefined }; + hook.create = create; + hook.prepatch = pre; + hook.postpatch = post; + hook.destroy = destroy; + return vnode; + } + + function toVNode(node, domApi) { + const api = domApi !== undefined ? domApi : htmlDomApi; + let text; + if (api.isElement(node)) { + const id = node.id ? "#" + node.id : ""; + const cn = node.getAttribute("class"); + const c = cn ? "." + cn.split(" ").join(".") : ""; + const sel = api.tagName(node).toLowerCase() + id + c; + const attrs = {}; + const children = []; + let name; + let i, n; + const elmAttrs = node.attributes; + const elmChildren = node.childNodes; + for (i = 0, n = elmAttrs.length; i < n; i++) { + name = elmAttrs[i].nodeName; + if (name !== "id" && name !== "class") { + attrs[name] = elmAttrs[i].nodeValue; + } + } + for (i = 0, n = elmChildren.length; i < n; i++) { + children.push(toVNode(elmChildren[i], domApi)); + } + return vnode(sel, { attrs }, children, undefined, node); + } + else if (api.isText(node)) { + text = api.getTextContent(node); + return vnode(undefined, undefined, undefined, text, node); + } + else if (api.isComment(node)) { + text = api.getTextContent(node); + return vnode("!", {}, [], text, node); + } + else { + return vnode("", {}, [], undefined, node); + } + } + + const xlinkNS = "http://www.w3.org/1999/xlink"; + const xmlNS = "http://www.w3.org/XML/1998/namespace"; + const colonChar = 58; + const xChar = 120; + function updateAttrs(oldVnode, vnode) { + let key; + const elm = vnode.elm; + let oldAttrs = oldVnode.data.attrs; + let attrs = vnode.data.attrs; + if (!oldAttrs && !attrs) + return; + if (oldAttrs === attrs) + return; + oldAttrs = oldAttrs || {}; + attrs = attrs || {}; + // update modified attributes, add new attributes + for (key in attrs) { + const cur = attrs[key]; + const old = oldAttrs[key]; + if (old !== cur) { + if (cur === true) { + elm.setAttribute(key, ""); + } + else if (cur === false) { + elm.removeAttribute(key); + } + else { + if (key.charCodeAt(0) !== xChar) { + elm.setAttribute(key, cur); + } + else if (key.charCodeAt(3) === colonChar) { + // Assume xml namespace + elm.setAttributeNS(xmlNS, key, cur); + } + else if (key.charCodeAt(5) === colonChar) { + // Assume xlink namespace + elm.setAttributeNS(xlinkNS, key, cur); + } + else { + elm.setAttribute(key, cur); + } + } + } + } + // remove removed attributes + // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value) + // the other option is to remove all attributes with value == undefined + for (key in oldAttrs) { + if (!(key in attrs)) { + elm.removeAttribute(key); + } + } + } + const attributesModule = { + create: updateAttrs, + update: updateAttrs, + }; + + function updateClass(oldVnode, vnode) { + let cur; + let name; + const elm = vnode.elm; + let oldClass = oldVnode.data.class; + let klass = vnode.data.class; + if (!oldClass && !klass) + return; + if (oldClass === klass) + return; + oldClass = oldClass || {}; + klass = klass || {}; + for (name in oldClass) { + if (oldClass[name] && !Object.prototype.hasOwnProperty.call(klass, name)) { + // was `true` and now not provided + elm.classList.remove(name); + } + } + for (name in klass) { + cur = klass[name]; + if (cur !== oldClass[name]) { + elm.classList[cur ? "add" : "remove"](name); + } + } + } + const classModule = { create: updateClass, update: updateClass }; + + const CAPS_REGEX = /[A-Z]/g; + function updateDataset(oldVnode, vnode) { + const elm = vnode.elm; + let oldDataset = oldVnode.data.dataset; + let dataset = vnode.data.dataset; + let key; + if (!oldDataset && !dataset) + return; + if (oldDataset === dataset) + return; + oldDataset = oldDataset || {}; + dataset = dataset || {}; + const d = elm.dataset; + for (key in oldDataset) { + if (!dataset[key]) { + if (d) { + if (key in d) { + delete d[key]; + } + } + else { + elm.removeAttribute("data-" + key.replace(CAPS_REGEX, "-$&").toLowerCase()); + } + } + } + for (key in dataset) { + if (oldDataset[key] !== dataset[key]) { + if (d) { + d[key] = dataset[key]; + } + else { + elm.setAttribute("data-" + key.replace(CAPS_REGEX, "-$&").toLowerCase(), dataset[key]); + } + } + } + } + const datasetModule = { + create: updateDataset, + update: updateDataset, + }; + + function invokeHandler(handler, vnode, event) { + if (typeof handler === "function") { + // call function handler + handler.call(vnode, event, vnode); + } + else if (typeof handler === "object") { + // call multiple handlers + for (let i = 0; i < handler.length; i++) { + invokeHandler(handler[i], vnode, event); + } + } + } + function handleEvent(event, vnode) { + const name = event.type; + const on = vnode.data.on; + // call event handler(s) if exists + if (on && on[name]) { + invokeHandler(on[name], vnode, event); + } + } + function createListener() { + return function handler(event) { + handleEvent(event, handler.vnode); + }; + } + function updateEventListeners(oldVnode, vnode) { + const oldOn = oldVnode.data.on; + const oldListener = oldVnode.listener; + const oldElm = oldVnode.elm; + const on = vnode && vnode.data.on; + const elm = (vnode && vnode.elm); + let name; + // optimization for reused immutable handlers + if (oldOn === on) { + return; + } + // remove existing listeners which no longer used + if (oldOn && oldListener) { + // if element changed or deleted we remove all existing listeners unconditionally + if (!on) { + for (name in oldOn) { + // remove listener if element was changed or existing listeners removed + oldElm.removeEventListener(name, oldListener, false); + } + } + else { + for (name in oldOn) { + // remove listener if existing listener removed + if (!on[name]) { + oldElm.removeEventListener(name, oldListener, false); + } + } + } + } + // add new listeners which has not already attached + if (on) { + // reuse existing listener or create new + const listener = (vnode.listener = + oldVnode.listener || createListener()); + // update vnode for listener + listener.vnode = vnode; + // if element changed or added we add all needed listeners unconditionally + if (!oldOn) { + for (name in on) { + // add listener if element was changed or new listeners added + elm.addEventListener(name, listener, false); + } + } + else { + for (name in on) { + // add listener if new listener added + if (!oldOn[name]) { + elm.addEventListener(name, listener, false); + } + } + } + } + } + const eventListenersModule = { + create: updateEventListeners, + update: updateEventListeners, + destroy: updateEventListeners, + }; + + function updateProps(oldVnode, vnode) { + let key; + let cur; + let old; + const elm = vnode.elm; + let oldProps = oldVnode.data.props; + let props = vnode.data.props; + if (!oldProps && !props) + return; + if (oldProps === props) + return; + oldProps = oldProps || {}; + props = props || {}; + for (key in props) { + cur = props[key]; + old = oldProps[key]; + if (old !== cur && (key !== "value" || elm[key] !== cur)) { + elm[key] = cur; + } + } + } + const propsModule = { create: updateProps, update: updateProps }; + + // Bindig `requestAnimationFrame` like this fixes a bug in IE/Edge. See #360 and #409. + const raf = (typeof window !== "undefined" && + window.requestAnimationFrame.bind(window)) || + setTimeout; + const nextFrame = function (fn) { + raf(function () { + raf(fn); + }); + }; + let reflowForced = false; + function setNextFrame(obj, prop, val) { + nextFrame(function () { + obj[prop] = val; + }); + } + function updateStyle(oldVnode, vnode) { + let cur; + let name; + const elm = vnode.elm; + let oldStyle = oldVnode.data.style; + let style = vnode.data.style; + if (!oldStyle && !style) + return; + if (oldStyle === style) + return; + oldStyle = oldStyle || {}; + style = style || {}; + const oldHasDel = "delayed" in oldStyle; + for (name in oldStyle) { + if (!style[name]) { + if (name[0] === "-" && name[1] === "-") { + elm.style.removeProperty(name); + } + else { + elm.style[name] = ""; + } + } + } + for (name in style) { + cur = style[name]; + if (name === "delayed" && style.delayed) { + for (const name2 in style.delayed) { + cur = style.delayed[name2]; + if (!oldHasDel || cur !== oldStyle.delayed[name2]) { + setNextFrame(elm.style, name2, cur); + } + } + } + else if (name !== "remove" && cur !== oldStyle[name]) { + if (name[0] === "-" && name[1] === "-") { + elm.style.setProperty(name, cur); + } + else { + elm.style[name] = cur; + } + } + } + } + function applyDestroyStyle(vnode) { + let style; + let name; + const elm = vnode.elm; + const s = vnode.data.style; + if (!s || !(style = s.destroy)) + return; + for (name in style) { + elm.style[name] = style[name]; + } + } + function applyRemoveStyle(vnode, rm) { + const s = vnode.data.style; + if (!s || !s.remove) { + rm(); + return; + } + if (!reflowForced) { + // eslint-disable-next-line @typescript-eslint/no-unused-expressions + vnode.elm.offsetLeft; + reflowForced = true; + } + let name; + const elm = vnode.elm; + let i = 0; + const style = s.remove; + let amount = 0; + const applied = []; + for (name in style) { + applied.push(name); + elm.style[name] = style[name]; + } + const compStyle = getComputedStyle(elm); + const props = compStyle["transition-property"].split(", "); + for (; i < props.length; ++i) { + if (applied.indexOf(props[i]) !== -1) + amount++; + } + elm.addEventListener("transitionend", function (ev) { + if (ev.target === elm) + --amount; + if (amount === 0) + rm(); + }); + } + function forceReflow() { + reflowForced = false; + } + const styleModule = { + pre: forceReflow, + create: updateStyle, + update: updateStyle, + destroy: applyDestroyStyle, + remove: applyRemoveStyle, + }; + + /* eslint-disable @typescript-eslint/no-namespace, import/export */ + function flattenAndFilter(children, flattened) { + for (const child of children) { + // filter out falsey children, except 0 since zero can be a valid value e.g inside a chart + if (child !== undefined && + child !== null && + child !== false && + child !== "") { + if (Array.isArray(child)) { + flattenAndFilter(child, flattened); + } + else if (typeof child === "string" || + typeof child === "number" || + typeof child === "boolean") { + flattened.push(vnode(undefined, undefined, undefined, String(child), undefined)); + } + else { + flattened.push(child); + } + } + } + return flattened; + } + /** + * jsx/tsx compatible factory function + * see: https://www.typescriptlang.org/docs/handbook/jsx.html#factory-functions + */ + function jsx(tag, data, ...children) { + const flatChildren = flattenAndFilter(children, []); + if (typeof tag === "function") { + // tag is a function component + return tag(data, flatChildren); + } + else { + if (flatChildren.length === 1 && + !flatChildren[0].sel && + flatChildren[0].text) { + // only child is a simple text node, pass as text for a simpler vtree + return h(tag, data, flatChildren[0].text); + } + else { + return h(tag, data, flatChildren); + } + } + } + (function (jsx) { + })(jsx || (jsx = {})); + + exports.array = array; + exports.attachTo = attachTo; + exports.attributesModule = attributesModule; + exports.classModule = classModule; + exports.datasetModule = datasetModule; + exports.eventListenersModule = eventListenersModule; + exports.h = h; + exports.htmlDomApi = htmlDomApi; + exports.init = init$1; + exports.jsx = jsx; + exports.primitive = primitive; + exports.propsModule = propsModule; + exports.styleModule = styleModule; + exports.thunk = thunk; + exports.toVNode = toVNode; + exports.vnode = vnode; + }); + + /** + * lodash (Custom Build) + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + + /** Used as references for various `Number` constants. */ + var INFINITY = 1 / 0; + + /** `Object#toString` result references. */ + var symbolTag$1 = '[object Symbol]'; + + /** Used to match words composed of alphanumeric characters. */ + var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g; + + /** Used to match Latin Unicode letters (excluding mathematical operators). */ + var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g; + + /** Used to compose unicode character classes. */ + var rsAstralRange = '\\ud800-\\udfff', + rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23', + rsComboSymbolsRange = '\\u20d0-\\u20f0', + rsDingbatRange = '\\u2700-\\u27bf', + rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff', + rsMathOpRange = '\\xac\\xb1\\xd7\\xf7', + rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf', + rsPunctuationRange = '\\u2000-\\u206f', + rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000', + rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde', + rsVarRange = '\\ufe0e\\ufe0f', + rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange; + + /** Used to compose unicode capture groups. */ + var rsApos = "['\u2019]", + rsAstral = '[' + rsAstralRange + ']', + rsBreak = '[' + rsBreakRange + ']', + rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']', + rsDigits = '\\d+', + rsDingbat = '[' + rsDingbatRange + ']', + rsLower = '[' + rsLowerRange + ']', + rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']', + rsFitz = '\\ud83c[\\udffb-\\udfff]', + rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')', + rsNonAstral = '[^' + rsAstralRange + ']', + rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}', + rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]', + rsUpper = '[' + rsUpperRange + ']', + rsZWJ = '\\u200d'; + + /** Used to compose unicode regexes. */ + var rsLowerMisc = '(?:' + rsLower + '|' + rsMisc + ')', + rsUpperMisc = '(?:' + rsUpper + '|' + rsMisc + ')', + rsOptLowerContr = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?', + rsOptUpperContr = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?', + reOptMod = rsModifier + '?', + rsOptVar = '[' + rsVarRange + ']?', + rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*', + rsSeq = rsOptVar + reOptMod + rsOptJoin, + rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq, + rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')'; + + /** Used to match apostrophes. */ + var reApos = RegExp(rsApos, 'g'); + + /** + * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and + * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols). + */ + var reComboMark = RegExp(rsCombo, 'g'); + + /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ + var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g'); + + /** Used to match complex or compound words. */ + var reUnicodeWord = RegExp([ + rsUpper + '?' + rsLower + '+' + rsOptLowerContr + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')', + rsUpperMisc + '+' + rsOptUpperContr + '(?=' + [rsBreak, rsUpper + rsLowerMisc, '$'].join('|') + ')', + rsUpper + '?' + rsLowerMisc + '+' + rsOptLowerContr, + rsUpper + '+' + rsOptUpperContr, + rsDigits, + rsEmoji + ].join('|'), 'g'); + + /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */ + var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']'); + + /** Used to detect strings that need a more robust regexp to match words. */ + var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/; + + /** Used to map Latin Unicode letters to basic Latin letters. */ + var deburredLetters = { + // Latin-1 Supplement block. + '\xc0': 'A', '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A', + '\xe0': 'a', '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a', + '\xc7': 'C', '\xe7': 'c', + '\xd0': 'D', '\xf0': 'd', + '\xc8': 'E', '\xc9': 'E', '\xca': 'E', '\xcb': 'E', + '\xe8': 'e', '\xe9': 'e', '\xea': 'e', '\xeb': 'e', + '\xcc': 'I', '\xcd': 'I', '\xce': 'I', '\xcf': 'I', + '\xec': 'i', '\xed': 'i', '\xee': 'i', '\xef': 'i', + '\xd1': 'N', '\xf1': 'n', + '\xd2': 'O', '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O', + '\xf2': 'o', '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o', + '\xd9': 'U', '\xda': 'U', '\xdb': 'U', '\xdc': 'U', + '\xf9': 'u', '\xfa': 'u', '\xfb': 'u', '\xfc': 'u', + '\xdd': 'Y', '\xfd': 'y', '\xff': 'y', + '\xc6': 'Ae', '\xe6': 'ae', + '\xde': 'Th', '\xfe': 'th', + '\xdf': 'ss', + // Latin Extended-A block. + '\u0100': 'A', '\u0102': 'A', '\u0104': 'A', + '\u0101': 'a', '\u0103': 'a', '\u0105': 'a', + '\u0106': 'C', '\u0108': 'C', '\u010a': 'C', '\u010c': 'C', + '\u0107': 'c', '\u0109': 'c', '\u010b': 'c', '\u010d': 'c', + '\u010e': 'D', '\u0110': 'D', '\u010f': 'd', '\u0111': 'd', + '\u0112': 'E', '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E', + '\u0113': 'e', '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e', + '\u011c': 'G', '\u011e': 'G', '\u0120': 'G', '\u0122': 'G', + '\u011d': 'g', '\u011f': 'g', '\u0121': 'g', '\u0123': 'g', + '\u0124': 'H', '\u0126': 'H', '\u0125': 'h', '\u0127': 'h', + '\u0128': 'I', '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I', + '\u0129': 'i', '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i', + '\u0134': 'J', '\u0135': 'j', + '\u0136': 'K', '\u0137': 'k', '\u0138': 'k', + '\u0139': 'L', '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L', + '\u013a': 'l', '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l', + '\u0143': 'N', '\u0145': 'N', '\u0147': 'N', '\u014a': 'N', + '\u0144': 'n', '\u0146': 'n', '\u0148': 'n', '\u014b': 'n', + '\u014c': 'O', '\u014e': 'O', '\u0150': 'O', + '\u014d': 'o', '\u014f': 'o', '\u0151': 'o', + '\u0154': 'R', '\u0156': 'R', '\u0158': 'R', + '\u0155': 'r', '\u0157': 'r', '\u0159': 'r', + '\u015a': 'S', '\u015c': 'S', '\u015e': 'S', '\u0160': 'S', + '\u015b': 's', '\u015d': 's', '\u015f': 's', '\u0161': 's', + '\u0162': 'T', '\u0164': 'T', '\u0166': 'T', + '\u0163': 't', '\u0165': 't', '\u0167': 't', + '\u0168': 'U', '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U', + '\u0169': 'u', '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u', + '\u0174': 'W', '\u0175': 'w', + '\u0176': 'Y', '\u0177': 'y', '\u0178': 'Y', + '\u0179': 'Z', '\u017b': 'Z', '\u017d': 'Z', + '\u017a': 'z', '\u017c': 'z', '\u017e': 'z', + '\u0132': 'IJ', '\u0133': 'ij', + '\u0152': 'Oe', '\u0153': 'oe', + '\u0149': "'n", '\u017f': 'ss' + }; + + /** Detect free variable `global` from Node.js. */ + var freeGlobal$1 = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal; + + /** Detect free variable `self`. */ + var freeSelf$1 = typeof self == 'object' && self && self.Object === Object && self; + + /** Used as a reference to the global object. */ + var root$1 = freeGlobal$1 || freeSelf$1 || Function('return this')(); + + /** + * A specialized version of `_.reduce` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @param {boolean} [initAccum] Specify using the first element of `array` as + * the initial value. + * @returns {*} Returns the accumulated value. + */ + function arrayReduce(array, iteratee, accumulator, initAccum) { + var index = -1, + length = array ? array.length : 0; + + if (initAccum && length) { + accumulator = array[++index]; + } + while (++index < length) { + accumulator = iteratee(accumulator, array[index], index, array); + } + return accumulator; + } + + /** + * Converts an ASCII `string` to an array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. + */ + function asciiToArray(string) { + return string.split(''); + } + + /** + * Splits an ASCII `string` into an array of its words. + * + * @private + * @param {string} The string to inspect. + * @returns {Array} Returns the words of `string`. + */ + function asciiWords(string) { + return string.match(reAsciiWord) || []; + } + + /** + * The base implementation of `_.propertyOf` without support for deep paths. + * + * @private + * @param {Object} object The object to query. + * @returns {Function} Returns the new accessor function. + */ + function basePropertyOf(object) { + return function(key) { + return object == null ? undefined : object[key]; + }; + } + + /** + * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A + * letters to basic Latin letters. + * + * @private + * @param {string} letter The matched letter to deburr. + * @returns {string} Returns the deburred letter. + */ + var deburrLetter = basePropertyOf(deburredLetters); + + /** + * Checks if `string` contains Unicode symbols. + * + * @private + * @param {string} string The string to inspect. + * @returns {boolean} Returns `true` if a symbol is found, else `false`. + */ + function hasUnicode(string) { + return reHasUnicode.test(string); + } + + /** + * Checks if `string` contains a word composed of Unicode symbols. + * + * @private + * @param {string} string The string to inspect. + * @returns {boolean} Returns `true` if a word is found, else `false`. + */ + function hasUnicodeWord(string) { + return reHasUnicodeWord.test(string); + } + + /** + * Converts `string` to an array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. + */ + function stringToArray(string) { + return hasUnicode(string) + ? unicodeToArray(string) + : asciiToArray(string); + } + + /** + * Converts a Unicode `string` to an array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. + */ + function unicodeToArray(string) { + return string.match(reUnicode) || []; + } + + /** + * Splits a Unicode `string` into an array of its words. + * + * @private + * @param {string} The string to inspect. + * @returns {Array} Returns the words of `string`. + */ + function unicodeWords(string) { + return string.match(reUnicodeWord) || []; + } + + /** Used for built-in method references. */ + var objectProto$1 = Object.prototype; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ + var objectToString$1 = objectProto$1.toString; + + /** Built-in value references. */ + var Symbol$1 = root$1.Symbol; + + /** Used to convert symbols to primitives and strings. */ + var symbolProto = Symbol$1 ? Symbol$1.prototype : undefined, + symbolToString = symbolProto ? symbolProto.toString : undefined; + + /** + * The base implementation of `_.slice` without an iteratee call guard. + * + * @private + * @param {Array} array The array to slice. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the slice of `array`. + */ + function baseSlice(array, start, end) { + var index = -1, + length = array.length; + + if (start < 0) { + start = -start > length ? 0 : (length + start); + } + end = end > length ? length : end; + if (end < 0) { + end += length; + } + length = start > end ? 0 : ((end - start) >>> 0); + start >>>= 0; + + var result = Array(length); + while (++index < length) { + result[index] = array[index + start]; + } + return result; + } + + /** + * The base implementation of `_.toString` which doesn't convert nullish + * values to empty strings. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ + function baseToString(value) { + // Exit early for strings to avoid a performance hit in some environments. + if (typeof value == 'string') { + return value; + } + if (isSymbol$1(value)) { + return symbolToString ? symbolToString.call(value) : ''; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; + } + + /** + * Casts `array` to a slice if it's needed. + * + * @private + * @param {Array} array The array to inspect. + * @param {number} start The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the cast slice. + */ + function castSlice(array, start, end) { + var length = array.length; + end = end === undefined ? length : end; + return (!start && end >= length) ? array : baseSlice(array, start, end); + } + + /** + * Creates a function like `_.lowerFirst`. + * + * @private + * @param {string} methodName The name of the `String` case method to use. + * @returns {Function} Returns the new case function. + */ + function createCaseFirst(methodName) { + return function(string) { + string = toString(string); + + var strSymbols = hasUnicode(string) + ? stringToArray(string) + : undefined; + + var chr = strSymbols + ? strSymbols[0] + : string.charAt(0); + + var trailing = strSymbols + ? castSlice(strSymbols, 1).join('') + : string.slice(1); + + return chr[methodName]() + trailing; + }; + } + + /** + * Creates a function like `_.camelCase`. + * + * @private + * @param {Function} callback The function to combine each word. + * @returns {Function} Returns the new compounder function. + */ + function createCompounder(callback) { + return function(string) { + return arrayReduce(words(deburr(string).replace(reApos, '')), callback, ''); + }; + } + + /** + * 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$1(value) { + return !!value && typeof value == 'object'; + } + + /** + * 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$1(value) { + return typeof value == 'symbol' || + (isObjectLike$1(value) && objectToString$1.call(value) == symbolTag$1); + } + + /** + * Converts `value` to a string. An empty string is returned for `null` + * and `undefined` values. The sign of `-0` is preserved. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {string} Returns the string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' + */ + function toString(value) { + return value == null ? '' : baseToString(value); + } + + /** + * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the camel cased string. + * @example + * + * _.camelCase('Foo Bar'); + * // => 'fooBar' + * + * _.camelCase('--foo-bar--'); + * // => 'fooBar' + * + * _.camelCase('__FOO_BAR__'); + * // => 'fooBar' + */ + var camelCase = createCompounder(function(result, word, index) { + word = word.toLowerCase(); + return result + (index ? capitalize(word) : word); + }); + + /** + * Converts the first character of `string` to upper case and the remaining + * to lower case. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to capitalize. + * @returns {string} Returns the capitalized string. + * @example + * + * _.capitalize('FRED'); + * // => 'Fred' + */ + function capitalize(string) { + return upperFirst(toString(string).toLowerCase()); + } + + /** + * Deburrs `string` by converting + * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table) + * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A) + * letters to basic Latin letters and removing + * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to deburr. + * @returns {string} Returns the deburred string. + * @example + * + * _.deburr('déjà vu'); + * // => 'deja vu' + */ + function deburr(string) { + string = toString(string); + return string && string.replace(reLatin, deburrLetter).replace(reComboMark, ''); + } + + /** + * Converts the first character of `string` to upper case. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the converted string. + * @example + * + * _.upperFirst('fred'); + * // => 'Fred' + * + * _.upperFirst('FRED'); + * // => 'FRED' + */ + var upperFirst = createCaseFirst('toUpperCase'); + + /** + * Splits `string` into an array of its words. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to inspect. + * @param {RegExp|string} [pattern] The pattern to match words. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the words of `string`. + * @example + * + * _.words('fred, barney, & pebbles'); + * // => ['fred', 'barney', 'pebbles'] + * + * _.words('fred, barney, & pebbles', /[^, ]+/g); + * // => ['fred', 'barney', '&', 'pebbles'] + */ + function words(string, pattern, guard) { + string = toString(string); + pattern = guard ? undefined : pattern; + + if (pattern === undefined) { + return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string); + } + return string.match(pattern) || []; + } + + var lodash_camelcase = camelCase; + + /** + * 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. + */ + + var _default = isHotkey; + var isHotkey_1 = isHotkey; + var isCodeHotkey_1 = isCodeHotkey; + var isKeyHotkey_1 = isKeyHotkey; + var parseHotkey_1 = parseHotkey; + var compareHotkey_1 = compareHotkey; + var toKeyCode_1 = toKeyCode; + var toKeyName_1 = toKeyName; + + var lib$4 = /*#__PURE__*/Object.defineProperty({ + default: _default, + isHotkey: isHotkey_1, + isCodeHotkey: isCodeHotkey_1, + isKeyHotkey: isKeyHotkey_1, + parseHotkey: parseHotkey_1, + compareHotkey: compareHotkey_1, + toKeyCode: toKeyCode_1, + toKeyName: toKeyName_1 + }, '__esModule', {value: true}); + + /** + * lodash (Custom Build) + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + + /** Used as the `TypeError` message for "Functions" methods. */ + var FUNC_ERROR_TEXT = 'Expected a function'; + + /** Used as references for various `Number` constants. */ + var NAN = 0 / 0; + + /** `Object#toString` result references. */ + var symbolTag = '[object Symbol]'; + + /** Used to match leading and trailing whitespace. */ + var reTrim = /^\s+|\s+$/g; + + /** 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; + + /** Detect free variable `global` from Node.js. */ + var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal; + + /** 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')(); + + /** 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 objectToString = objectProto.toString; + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeMax = Math.max, + nativeMin = Math.min; + + /** + * 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(); + }; + + /** + * 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$1(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 (isObject(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 = 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, + result = wait - timeSinceLastCall; + + return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result; + } + + 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(); + 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()); + } + + function debounced() { + var time = now(), + 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. + timerId = setTimeout(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + if (timerId === undefined) { + timerId = setTimeout(timerExpired, wait); + } + return result; + } + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; + } + + /** + * 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 && (type == 'object' || type == 'function'); + } + + /** + * 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 && typeof value == 'object'; + } + + /** + * 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(value) && objectToString.call(value) == symbolTag); + } + + /** + * 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(value)) { + return NAN; + } + if (isObject(value)) { + var other = typeof value.valueOf == 'function' ? value.valueOf() : value; + value = isObject(other) ? (other + '') : other; + } + if (typeof value != 'string') { + return value === 0 ? value : +value; + } + value = value.replace(reTrim, ''); + var isBinary = reIsBinary.test(value); + return (isBinary || reIsOctal.test(value)) + ? freeParseInt(value.slice(2), isBinary ? 2 : 8) + : (reIsBadHex.test(value) ? NAN : +value); + } + + var lodash_debounce = debounce$1; + + /** + * lodash (Custom Build) + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + + var lodash_clonedeep = createCommonjsModule$1(function (module, exports) { + /** Used as the size to enable large array optimizations. */ + var LARGE_ARRAY_SIZE = 200; + + /** Used to stand-in for `undefined` hash values. */ + var HASH_UNDEFINED = '__lodash_hash_undefined__'; + + /** Used as references for various `Number` constants. */ + var MAX_SAFE_INTEGER = 9007199254740991; + + /** `Object#toString` result references. */ + var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + boolTag = '[object Boolean]', + dateTag = '[object Date]', + errorTag = '[object Error]', + funcTag = '[object Function]', + genTag = '[object GeneratorFunction]', + mapTag = '[object Map]', + numberTag = '[object Number]', + objectTag = '[object Object]', + promiseTag = '[object Promise]', + regexpTag = '[object RegExp]', + setTag = '[object Set]', + stringTag = '[object String]', + symbolTag = '[object Symbol]', + weakMapTag = '[object WeakMap]'; + + var arrayBufferTag = '[object ArrayBuffer]', + dataViewTag = '[object DataView]', + float32Tag = '[object Float32Array]', + float64Tag = '[object Float64Array]', + int8Tag = '[object Int8Array]', + int16Tag = '[object Int16Array]', + int32Tag = '[object Int32Array]', + uint8Tag = '[object Uint8Array]', + uint8ClampedTag = '[object Uint8ClampedArray]', + uint16Tag = '[object Uint16Array]', + uint32Tag = '[object Uint32Array]'; + + /** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ + var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + + /** Used to match `RegExp` flags from their coerced string values. */ + var reFlags = /\w*$/; + + /** Used to detect host constructors (Safari). */ + var reIsHostCtor = /^\[object .+?Constructor\]$/; + + /** Used to detect unsigned integer values. */ + var reIsUint = /^(?:0|[1-9]\d*)$/; + + /** Used to identify `toStringTag` values supported by `_.clone`. */ + var cloneableTags = {}; + cloneableTags[argsTag] = cloneableTags[arrayTag] = + cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = + cloneableTags[boolTag] = cloneableTags[dateTag] = + cloneableTags[float32Tag] = cloneableTags[float64Tag] = + cloneableTags[int8Tag] = cloneableTags[int16Tag] = + cloneableTags[int32Tag] = cloneableTags[mapTag] = + cloneableTags[numberTag] = cloneableTags[objectTag] = + cloneableTags[regexpTag] = cloneableTags[setTag] = + cloneableTags[stringTag] = cloneableTags[symbolTag] = + cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = + cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true; + cloneableTags[errorTag] = cloneableTags[funcTag] = + cloneableTags[weakMapTag] = false; + + /** Detect free variable `global` from Node.js. */ + var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal; + + /** 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')(); + + /** Detect free variable `exports`. */ + var freeExports = exports && !exports.nodeType && exports; + + /** Detect free variable `module`. */ + var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module; + + /** Detect the popular CommonJS extension `module.exports`. */ + var moduleExports = freeModule && freeModule.exports === freeExports; + + /** + * Adds the key-value `pair` to `map`. + * + * @private + * @param {Object} map The map to modify. + * @param {Array} pair The key-value pair to add. + * @returns {Object} Returns `map`. + */ + function addMapEntry(map, pair) { + // Don't return `map.set` because it's not chainable in IE 11. + map.set(pair[0], pair[1]); + return map; + } + + /** + * Adds `value` to `set`. + * + * @private + * @param {Object} set The set to modify. + * @param {*} value The value to add. + * @returns {Object} Returns `set`. + */ + function addSetEntry(set, value) { + // Don't return `set.add` because it's not chainable in IE 11. + set.add(value); + return set; + } + + /** + * A specialized version of `_.forEach` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns `array`. + */ + function arrayEach(array, iteratee) { + var index = -1, + length = array ? array.length : 0; + + while (++index < length) { + if (iteratee(array[index], index, array) === false) { + break; + } + } + return array; + } + + /** + * Appends the elements of `values` to `array`. + * + * @private + * @param {Array} array The array to modify. + * @param {Array} values The values to append. + * @returns {Array} Returns `array`. + */ + function arrayPush(array, values) { + var index = -1, + length = values.length, + offset = array.length; + + while (++index < length) { + array[offset + index] = values[index]; + } + return array; + } + + /** + * A specialized version of `_.reduce` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @param {boolean} [initAccum] Specify using the first element of `array` as + * the initial value. + * @returns {*} Returns the accumulated value. + */ + function arrayReduce(array, iteratee, accumulator, initAccum) { + var index = -1, + length = array ? array.length : 0; + + if (initAccum && length) { + accumulator = array[++index]; + } + while (++index < length) { + accumulator = iteratee(accumulator, array[index], index, array); + } + return accumulator; + } + + /** + * The base implementation of `_.times` without support for iteratee shorthands + * or max array length checks. + * + * @private + * @param {number} n The number of times to invoke `iteratee`. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the array of results. + */ + function baseTimes(n, iteratee) { + var index = -1, + result = Array(n); + + while (++index < n) { + result[index] = iteratee(index); + } + return result; + } + + /** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ + function getValue(object, key) { + return object == null ? undefined : object[key]; + } + + /** + * Checks if `value` is a host object in IE < 9. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a host object, else `false`. + */ + function isHostObject(value) { + // Many host objects are `Object` objects that can coerce to strings + // despite having improperly defined `toString` methods. + var result = false; + if (value != null && typeof value.toString != 'function') { + try { + result = !!(value + ''); + } catch (e) {} + } + return result; + } + + /** + * Converts `map` to its key-value pairs. + * + * @private + * @param {Object} map The map to convert. + * @returns {Array} Returns the key-value pairs. + */ + function mapToArray(map) { + var index = -1, + result = Array(map.size); + + map.forEach(function(value, key) { + result[++index] = [key, value]; + }); + return result; + } + + /** + * Creates a unary function that invokes `func` with its argument transformed. + * + * @private + * @param {Function} func The function to wrap. + * @param {Function} transform The argument transform. + * @returns {Function} Returns the new function. + */ + function overArg(func, transform) { + return function(arg) { + return func(transform(arg)); + }; + } + + /** + * Converts `set` to an array of its values. + * + * @private + * @param {Object} set The set to convert. + * @returns {Array} Returns the values. + */ + function setToArray(set) { + var index = -1, + result = Array(set.size); + + set.forEach(function(value) { + result[++index] = value; + }); + return result; + } + + /** Used for built-in method references. */ + var arrayProto = Array.prototype, + funcProto = Function.prototype, + objectProto = Object.prototype; + + /** Used to detect overreaching core-js shims. */ + var coreJsData = root['__core-js_shared__']; + + /** Used to detect methods masquerading as native. */ + var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); + return uid ? ('Symbol(src)_1.' + uid) : ''; + }()); + + /** Used to resolve the decompiled source of functions. */ + var funcToString = funcProto.toString; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ + var objectToString = objectProto.toString; + + /** Used to detect if a method is native. */ + var reIsNative = RegExp('^' + + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' + ); + + /** Built-in value references. */ + var Buffer = moduleExports ? root.Buffer : undefined, + Symbol = root.Symbol, + Uint8Array = root.Uint8Array, + getPrototype = overArg(Object.getPrototypeOf, Object), + objectCreate = Object.create, + propertyIsEnumerable = objectProto.propertyIsEnumerable, + splice = arrayProto.splice; + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeGetSymbols = Object.getOwnPropertySymbols, + nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined, + nativeKeys = overArg(Object.keys, Object); + + /* Built-in method references that are verified to be native. */ + var DataView = getNative(root, 'DataView'), + Map = getNative(root, 'Map'), + Promise = getNative(root, 'Promise'), + Set = getNative(root, 'Set'), + WeakMap = getNative(root, 'WeakMap'), + nativeCreate = getNative(Object, 'create'); + + /** Used to detect maps, sets, and weakmaps. */ + var dataViewCtorString = toSource(DataView), + mapCtorString = toSource(Map), + promiseCtorString = toSource(Promise), + setCtorString = toSource(Set), + weakMapCtorString = toSource(WeakMap); + + /** Used to convert symbols to primitives and strings. */ + var symbolProto = Symbol ? Symbol.prototype : undefined, + symbolValueOf = symbolProto ? symbolProto.valueOf : undefined; + + /** + * Creates a hash object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function Hash(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + /** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ + function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; + } + + /** + * Removes `key` and its value from the hash. + * + * @private + * @name delete + * @memberOf Hash + * @param {Object} hash The hash to modify. + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function hashDelete(key) { + return this.has(key) && delete this.__data__[key]; + } + + /** + * Gets the hash value for `key`. + * + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED ? undefined : result; + } + return hasOwnProperty.call(data, key) ? data[key] : undefined; + } + + /** + * Checks if a hash value for `key` exists. + * + * @private + * @name has + * @memberOf Hash + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function hashHas(key) { + var data = this.__data__; + return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key); + } + + /** + * Sets the hash `key` to `value`. + * + * @private + * @name set + * @memberOf Hash + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the hash instance. + */ + function hashSet(key, value) { + var data = this.__data__; + data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; + return this; + } + + // Add methods to `Hash`. + Hash.prototype.clear = hashClear; + Hash.prototype['delete'] = hashDelete; + Hash.prototype.get = hashGet; + Hash.prototype.has = hashHas; + Hash.prototype.set = hashSet; + + /** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function ListCache(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + /** + * Removes all key-value entries from the list cache. + * + * @private + * @name clear + * @memberOf ListCache + */ + function listCacheClear() { + this.__data__ = []; + } + + /** + * Removes `key` and its value from the list cache. + * + * @private + * @name delete + * @memberOf ListCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + return true; + } + + /** + * Gets the list cache value for `key`. + * + * @private + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + return index < 0 ? undefined : data[index][1]; + } + + /** + * Checks if a list cache value for `key` exists. + * + * @private + * @name has + * @memberOf ListCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; + } + + /** + * Sets the list cache `key` to `value`. + * + * @private + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. + */ + function listCacheSet(key, value) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; + } + + // Add methods to `ListCache`. + ListCache.prototype.clear = listCacheClear; + ListCache.prototype['delete'] = listCacheDelete; + ListCache.prototype.get = listCacheGet; + ListCache.prototype.has = listCacheHas; + ListCache.prototype.set = listCacheSet; + + /** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function MapCache(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + /** + * Removes all key-value entries from the map. + * + * @private + * @name clear + * @memberOf MapCache + */ + function mapCacheClear() { + this.__data__ = { + 'hash': new Hash, + 'map': new (Map || ListCache), + 'string': new Hash + }; + } + + /** + * Removes `key` and its value from the map. + * + * @private + * @name delete + * @memberOf MapCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function mapCacheDelete(key) { + return getMapData(this, key)['delete'](key); + } + + /** + * Gets the map value for `key`. + * + * @private + * @name get + * @memberOf MapCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function mapCacheGet(key) { + return getMapData(this, key).get(key); + } + + /** + * Checks if a map value for `key` exists. + * + * @private + * @name has + * @memberOf MapCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function mapCacheHas(key) { + return getMapData(this, key).has(key); + } + + /** + * Sets the map `key` to `value`. + * + * @private + * @name set + * @memberOf MapCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the map cache instance. + */ + function mapCacheSet(key, value) { + getMapData(this, key).set(key, value); + return this; + } + + // Add methods to `MapCache`. + MapCache.prototype.clear = mapCacheClear; + MapCache.prototype['delete'] = mapCacheDelete; + MapCache.prototype.get = mapCacheGet; + MapCache.prototype.has = mapCacheHas; + MapCache.prototype.set = mapCacheSet; + + /** + * Creates a stack cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function Stack(entries) { + this.__data__ = new ListCache(entries); + } + + /** + * Removes all key-value entries from the stack. + * + * @private + * @name clear + * @memberOf Stack + */ + function stackClear() { + this.__data__ = new ListCache; + } + + /** + * Removes `key` and its value from the stack. + * + * @private + * @name delete + * @memberOf Stack + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function stackDelete(key) { + return this.__data__['delete'](key); + } + + /** + * Gets the stack value for `key`. + * + * @private + * @name get + * @memberOf Stack + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function stackGet(key) { + return this.__data__.get(key); + } + + /** + * Checks if a stack value for `key` exists. + * + * @private + * @name has + * @memberOf Stack + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function stackHas(key) { + return this.__data__.has(key); + } + + /** + * Sets the stack `key` to `value`. + * + * @private + * @name set + * @memberOf Stack + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the stack cache instance. + */ + function stackSet(key, value) { + var cache = this.__data__; + if (cache instanceof ListCache) { + var pairs = cache.__data__; + if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) { + pairs.push([key, value]); + return this; + } + cache = this.__data__ = new MapCache(pairs); + } + cache.set(key, value); + return this; + } + + // Add methods to `Stack`. + Stack.prototype.clear = stackClear; + Stack.prototype['delete'] = stackDelete; + Stack.prototype.get = stackGet; + Stack.prototype.has = stackHas; + Stack.prototype.set = stackSet; + + /** + * Creates an array of the enumerable property names of the array-like `value`. + * + * @private + * @param {*} value The value to query. + * @param {boolean} inherited Specify returning inherited property names. + * @returns {Array} Returns the array of property names. + */ + function arrayLikeKeys(value, inherited) { + // Safari 8.1 makes `arguments.callee` enumerable in strict mode. + // Safari 9 makes `arguments.length` enumerable in strict mode. + var result = (isArray(value) || isArguments(value)) + ? baseTimes(value.length, String) + : []; + + var length = result.length, + skipIndexes = !!length; + + for (var key in value) { + if ((inherited || hasOwnProperty.call(value, key)) && + !(skipIndexes && (key == 'length' || isIndex(key, length)))) { + result.push(key); + } + } + return result; + } + + /** + * Assigns `value` to `key` of `object` if the existing value is not equivalent + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + function assignValue(object, key, value) { + var objValue = object[key]; + if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || + (value === undefined && !(key in object))) { + object[key] = value; + } + } + + /** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; + } + + /** + * The base implementation of `_.assign` without support for multiple sources + * or `customizer` functions. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @returns {Object} Returns `object`. + */ + function baseAssign(object, source) { + return object && copyObject(source, keys(source), object); + } + + /** + * The base implementation of `_.clone` and `_.cloneDeep` which tracks + * traversed objects. + * + * @private + * @param {*} value The value to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @param {boolean} [isFull] Specify a clone including symbols. + * @param {Function} [customizer] The function to customize cloning. + * @param {string} [key] The key of `value`. + * @param {Object} [object] The parent object of `value`. + * @param {Object} [stack] Tracks traversed objects and their clone counterparts. + * @returns {*} Returns the cloned value. + */ + function baseClone(value, isDeep, isFull, customizer, key, object, stack) { + var result; + if (customizer) { + result = object ? customizer(value, key, object, stack) : customizer(value); + } + if (result !== undefined) { + return result; + } + if (!isObject(value)) { + return value; + } + var isArr = isArray(value); + if (isArr) { + result = initCloneArray(value); + if (!isDeep) { + return copyArray(value, result); + } + } else { + var tag = getTag(value), + isFunc = tag == funcTag || tag == genTag; + + if (isBuffer(value)) { + return cloneBuffer(value, isDeep); + } + if (tag == objectTag || tag == argsTag || (isFunc && !object)) { + if (isHostObject(value)) { + return object ? value : {}; + } + result = initCloneObject(isFunc ? {} : value); + if (!isDeep) { + return copySymbols(value, baseAssign(result, value)); + } + } else { + if (!cloneableTags[tag]) { + return object ? value : {}; + } + result = initCloneByTag(value, tag, baseClone, isDeep); + } + } + // Check for circular references and return its corresponding clone. + stack || (stack = new Stack); + var stacked = stack.get(value); + if (stacked) { + return stacked; + } + stack.set(value, result); + + if (!isArr) { + var props = isFull ? getAllKeys(value) : keys(value); + } + arrayEach(props || value, function(subValue, key) { + if (props) { + key = subValue; + subValue = value[key]; + } + // Recursively populate clone (susceptible to call stack limits). + assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack)); + }); + return result; + } + + /** + * The base implementation of `_.create` without support for assigning + * properties to the created object. + * + * @private + * @param {Object} prototype The object to inherit from. + * @returns {Object} Returns the new object. + */ + function baseCreate(proto) { + return isObject(proto) ? objectCreate(proto) : {}; + } + + /** + * The base implementation of `getAllKeys` and `getAllKeysIn` which uses + * `keysFunc` and `symbolsFunc` to get the enumerable property names and + * symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Function} keysFunc The function to get the keys of `object`. + * @param {Function} symbolsFunc The function to get the symbols of `object`. + * @returns {Array} Returns the array of property names and symbols. + */ + function baseGetAllKeys(object, keysFunc, symbolsFunc) { + var result = keysFunc(object); + return isArray(object) ? result : arrayPush(result, symbolsFunc(object)); + } + + /** + * The base implementation of `getTag`. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ + function baseGetTag(value) { + return objectToString.call(value); + } + + /** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ + function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); + } + + /** + * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + function baseKeys(object) { + if (!isPrototype(object)) { + return nativeKeys(object); + } + var result = []; + for (var key in Object(object)) { + if (hasOwnProperty.call(object, key) && key != 'constructor') { + result.push(key); + } + } + return result; + } + + /** + * Creates a clone of `buffer`. + * + * @private + * @param {Buffer} buffer The buffer to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Buffer} Returns the cloned buffer. + */ + function cloneBuffer(buffer, isDeep) { + if (isDeep) { + return buffer.slice(); + } + var result = new buffer.constructor(buffer.length); + buffer.copy(result); + return result; + } + + /** + * Creates a clone of `arrayBuffer`. + * + * @private + * @param {ArrayBuffer} arrayBuffer The array buffer to clone. + * @returns {ArrayBuffer} Returns the cloned array buffer. + */ + function cloneArrayBuffer(arrayBuffer) { + var result = new arrayBuffer.constructor(arrayBuffer.byteLength); + new Uint8Array(result).set(new Uint8Array(arrayBuffer)); + return result; + } + + /** + * Creates a clone of `dataView`. + * + * @private + * @param {Object} dataView The data view to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned data view. + */ + function cloneDataView(dataView, isDeep) { + var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer; + return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength); + } + + /** + * Creates a clone of `map`. + * + * @private + * @param {Object} map The map to clone. + * @param {Function} cloneFunc The function to clone values. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned map. + */ + function cloneMap(map, isDeep, cloneFunc) { + var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map); + return arrayReduce(array, addMapEntry, new map.constructor); + } + + /** + * Creates a clone of `regexp`. + * + * @private + * @param {Object} regexp The regexp to clone. + * @returns {Object} Returns the cloned regexp. + */ + function cloneRegExp(regexp) { + var result = new regexp.constructor(regexp.source, reFlags.exec(regexp)); + result.lastIndex = regexp.lastIndex; + return result; + } + + /** + * Creates a clone of `set`. + * + * @private + * @param {Object} set The set to clone. + * @param {Function} cloneFunc The function to clone values. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned set. + */ + function cloneSet(set, isDeep, cloneFunc) { + var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set); + return arrayReduce(array, addSetEntry, new set.constructor); + } + + /** + * Creates a clone of the `symbol` object. + * + * @private + * @param {Object} symbol The symbol object to clone. + * @returns {Object} Returns the cloned symbol object. + */ + function cloneSymbol(symbol) { + return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {}; + } + + /** + * Creates a clone of `typedArray`. + * + * @private + * @param {Object} typedArray The typed array to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned typed array. + */ + function cloneTypedArray(typedArray, isDeep) { + var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer; + return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length); + } + + /** + * Copies the values of `source` to `array`. + * + * @private + * @param {Array} source The array to copy values from. + * @param {Array} [array=[]] The array to copy values to. + * @returns {Array} Returns `array`. + */ + function copyArray(source, array) { + var index = -1, + length = source.length; + + array || (array = Array(length)); + while (++index < length) { + array[index] = source[index]; + } + return array; + } + + /** + * Copies properties of `source` to `object`. + * + * @private + * @param {Object} source The object to copy properties from. + * @param {Array} props The property identifiers to copy. + * @param {Object} [object={}] The object to copy properties to. + * @param {Function} [customizer] The function to customize copied values. + * @returns {Object} Returns `object`. + */ + function copyObject(source, props, object, customizer) { + object || (object = {}); + + var index = -1, + length = props.length; + + while (++index < length) { + var key = props[index]; + + var newValue = customizer + ? customizer(object[key], source[key], key, object, source) + : undefined; + + assignValue(object, key, newValue === undefined ? source[key] : newValue); + } + return object; + } + + /** + * Copies own symbol properties of `source` to `object`. + * + * @private + * @param {Object} source The object to copy symbols from. + * @param {Object} [object={}] The object to copy symbols to. + * @returns {Object} Returns `object`. + */ + function copySymbols(source, object) { + return copyObject(source, getSymbols(source), object); + } + + /** + * Creates an array of own enumerable property names and symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names and symbols. + */ + function getAllKeys(object) { + return baseGetAllKeys(object, keys, getSymbols); + } + + /** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ + function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) + ? data[typeof key == 'string' ? 'string' : 'hash'] + : data.map; + } + + /** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ + function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; + } + + /** + * Creates an array of the own enumerable symbol properties of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of symbols. + */ + var getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray; + + /** + * Gets the `toStringTag` of `value`. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ + var getTag = baseGetTag; + + // Fallback for data views, maps, sets, and weak maps in IE 11, + // for data views in Edge < 14, and promises in Node.js. + if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || + (Map && getTag(new Map) != mapTag) || + (Promise && getTag(Promise.resolve()) != promiseTag) || + (Set && getTag(new Set) != setTag) || + (WeakMap && getTag(new WeakMap) != weakMapTag)) { + getTag = function(value) { + var result = objectToString.call(value), + Ctor = result == objectTag ? value.constructor : undefined, + ctorString = Ctor ? toSource(Ctor) : undefined; + + if (ctorString) { + switch (ctorString) { + case dataViewCtorString: return dataViewTag; + case mapCtorString: return mapTag; + case promiseCtorString: return promiseTag; + case setCtorString: return setTag; + case weakMapCtorString: return weakMapTag; + } + } + return result; + }; + } + + /** + * Initializes an array clone. + * + * @private + * @param {Array} array The array to clone. + * @returns {Array} Returns the initialized clone. + */ + function initCloneArray(array) { + var length = array.length, + result = array.constructor(length); + + // Add properties assigned by `RegExp#exec`. + if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) { + result.index = array.index; + result.input = array.input; + } + return result; + } + + /** + * Initializes an object clone. + * + * @private + * @param {Object} object The object to clone. + * @returns {Object} Returns the initialized clone. + */ + function initCloneObject(object) { + return (typeof object.constructor == 'function' && !isPrototype(object)) + ? baseCreate(getPrototype(object)) + : {}; + } + + /** + * Initializes an object clone based on its `toStringTag`. + * + * **Note:** This function only supports cloning values with tags of + * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. + * + * @private + * @param {Object} object The object to clone. + * @param {string} tag The `toStringTag` of the object to clone. + * @param {Function} cloneFunc The function to clone values. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the initialized clone. + */ + function initCloneByTag(object, tag, cloneFunc, isDeep) { + var Ctor = object.constructor; + switch (tag) { + case arrayBufferTag: + return cloneArrayBuffer(object); + + case boolTag: + case dateTag: + return new Ctor(+object); + + case dataViewTag: + return cloneDataView(object, isDeep); + + case float32Tag: case float64Tag: + case int8Tag: case int16Tag: case int32Tag: + case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag: + return cloneTypedArray(object, isDeep); + + case mapTag: + return cloneMap(object, isDeep, cloneFunc); + + case numberTag: + case stringTag: + return new Ctor(object); + + case regexpTag: + return cloneRegExp(object); + + case setTag: + return cloneSet(object, isDeep, cloneFunc); + + case symbolTag: + return cloneSymbol(object); + } + } + + /** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ + function isIndex(value, length) { + length = length == null ? MAX_SAFE_INTEGER : length; + return !!length && + (typeof value == 'number' || reIsUint.test(value)) && + (value > -1 && value % 1 == 0 && value < length); + } + + /** + * Checks if `value` is suitable for use as unique object key. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is suitable, else `false`. + */ + function isKeyable(value) { + var type = typeof value; + return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') + ? (value !== '__proto__') + : (value === null); + } + + /** + * Checks if `func` has its source masked. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. + */ + function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); + } + + /** + * Checks if `value` is likely a prototype object. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. + */ + function isPrototype(value) { + var Ctor = value && value.constructor, + proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; + + return value === proto; + } + + /** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to process. + * @returns {string} Returns the source code. + */ + function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; + } + + /** + * This method is like `_.clone` except that it recursively clones `value`. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Lang + * @param {*} value The value to recursively clone. + * @returns {*} Returns the deep cloned value. + * @see _.clone + * @example + * + * var objects = [{ 'a': 1 }, { 'b': 2 }]; + * + * var deep = _.cloneDeep(objects); + * console.log(deep[0] === objects[0]); + * // => false + */ + function cloneDeep(value) { + return baseClone(value, true, true); + } + + /** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ + function eq(value, other) { + return value === other || (value !== value && other !== other); + } + + /** + * Checks if `value` is likely an `arguments` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + * else `false`. + * @example + * + * _.isArguments(function() { return arguments; }()); + * // => true + * + * _.isArguments([1, 2, 3]); + * // => false + */ + function isArguments(value) { + // Safari 8.1 makes `arguments.callee` enumerable in strict mode. + return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') && + (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag); + } + + /** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ + var isArray = Array.isArray; + + /** + * Checks if `value` is array-like. A value is considered array-like if it's + * not a function and has a `value.length` that's an integer greater than or + * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + * @example + * + * _.isArrayLike([1, 2, 3]); + * // => true + * + * _.isArrayLike(document.body.children); + * // => true + * + * _.isArrayLike('abc'); + * // => true + * + * _.isArrayLike(_.noop); + * // => false + */ + function isArrayLike(value) { + return value != null && isLength(value.length) && !isFunction(value); + } + + /** + * This method is like `_.isArrayLike` except that it also checks if `value` + * is an object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array-like object, + * else `false`. + * @example + * + * _.isArrayLikeObject([1, 2, 3]); + * // => true + * + * _.isArrayLikeObject(document.body.children); + * // => true + * + * _.isArrayLikeObject('abc'); + * // => false + * + * _.isArrayLikeObject(_.noop); + * // => false + */ + function isArrayLikeObject(value) { + return isObjectLike(value) && isArrayLike(value); + } + + /** + * Checks if `value` is a buffer. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. + * @example + * + * _.isBuffer(new Buffer(2)); + * // => true + * + * _.isBuffer(new Uint8Array(2)); + * // => false + */ + var isBuffer = nativeIsBuffer || stubFalse; + + /** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ + function isFunction(value) { + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 8-9 which returns 'object' for typed array and other constructors. + var tag = isObject(value) ? objectToString.call(value) : ''; + return tag == funcTag || tag == genTag; + } + + /** + * Checks if `value` is a valid array-like length. + * + * **Note:** This method is loosely based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * @example + * + * _.isLength(3); + * // => true + * + * _.isLength(Number.MIN_VALUE); + * // => false + * + * _.isLength(Infinity); + * // => false + * + * _.isLength('3'); + * // => false + */ + function isLength(value) { + return typeof value == 'number' && + value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; + } + + /** + * 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 && (type == 'object' || type == 'function'); + } + + /** + * 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 && typeof value == 'object'; + } + + /** + * Creates an array of the own enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * for more details. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] + */ + function keys(object) { + return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); + } + + /** + * This method returns a new empty array. + * + * @static + * @memberOf _ + * @since 4.13.0 + * @category Util + * @returns {Array} Returns the new empty array. + * @example + * + * var arrays = _.times(2, _.stubArray); + * + * console.log(arrays); + * // => [[], []] + * + * console.log(arrays[0] === arrays[1]); + * // => false + */ + function stubArray() { + return []; + } + + /** + * This method returns `false`. + * + * @static + * @memberOf _ + * @since 4.13.0 + * @category Util + * @returns {boolean} Returns `false`. + * @example + * + * _.times(2, _.stubFalse); + * // => [false, false] + */ + function stubFalse() { + return false; + } + + module.exports = cloneDeep; + }); + + var hasProperty = function has(object, key) { + return Object.prototype.hasOwnProperty.call(object, key); + }; + + var _apply; + + function _classPrivateFieldLooseBase$8(receiver, privateKey) { if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { throw new TypeError("attempted to use private field on non-instance"); } return receiver; } + + var id$8 = 0; + + function _classPrivateFieldLooseKey$8(name) { return "__private_" + id$8++ + "_" + name; } + + + + function insertReplacement(source, rx, replacement) { + const newParts = []; + source.forEach(chunk => { + // When the source contains multiple placeholders for interpolation, + // we should ignore chunks that are not strings, because those + // can be JSX objects and will be otherwise incorrectly turned into strings. + // Without this condition we’d get this: [object Object] hello [object Object] my