@vaadin/rich-text-editor 24.5.0-alpha7 → 24.5.0-alpha8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/package.json +15 -14
  2. package/vendor/vaadin-quill.js +3 -3
  3. package/vendor/vaadin-quill.js.map +1 -0
  4. package/web-types.json +1 -1
  5. package/web-types.lit.json +1 -1
  6. package/vendor/vaadin-quill.min.js.map +0 -1
package/vendor/vaadin-quill.js.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"vaadin-quill.min.js","mappings":"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","sources":["webpack://Quill/webpack/universalModuleDefinition","webpack://Quill/./core/polyfill.js","webpack://Quill/./node_modules/eventemitter3/index.js","webpack://Quill/./node_modules/fast-diff/diff.js","webpack://Quill/./node_modules/lodash.clonedeep/index.js","webpack://Quill/./node_modules/lodash.isequal/index.js","webpack://Quill/./node_modules/lodash.merge/index.js","webpack://Quill/../../../../webpack/universalModuleDefinition","webpack://Quill/../../../../webpack/bootstrap 3c334e19bc1efdeb80ab","webpack://Quill/../../../../src/registry.ts","webpack://Quill/../../../../src/attributor/attributor.ts","webpack://Quill/../../../../src/blot/abstract/container.ts","webpack://Quill/../../../../src/blot/abstract/format.ts","webpack://Quill/../../../../src/blot/abstract/leaf.ts","webpack://Quill/../../../../src/blot/abstract/shadow.ts","webpack://Quill/../../../../src/attributor/store.ts","webpack://Quill/../../../../src/attributor/class.ts","webpack://Quill/../../../../src/attributor/style.ts","webpack://Quill/../../../../src/parchment.ts","webpack://Quill/../../../../src/collection/linked-list.ts","webpack://Quill/../../../../src/blot/scroll.ts","webpack://Quill/../../../../src/blot/inline.ts","webpack://Quill/../../../../src/blot/block.ts","webpack://Quill/../../../../src/blot/embed.ts","webpack://Quill/../../../../src/blot/text.ts","webpack://Quill/./node_modules/quill-delta/src/AttributeMap.ts","webpack://Quill/./node_modules/quill-delta/src/Delta.ts","webpack://Quill/./node_modules/quill-delta/src/Iterator.ts","webpack://Quill/./node_modules/quill-delta/src/Op.ts","webpack://Quill/webpack/bootstrap","webpack://Quill/webpack/runtime/compat get default export","webpack://Quill/webpack/runtime/define property getters","webpack://Quill/webpack/runtime/global","webpack://Quill/webpack/runtime/hasOwnProperty shorthand","webpack://Quill/webpack/runtime/node module decorator","webpack://Quill/./blots/break.js","webpack://Quill/./blots/text.js","webpack://Quill/./blots/inline.js","webpack://Quill/./blots/block.js","webpack://Quill/./formats/code.js","webpack://Quill/./blots/cursor.js","webpack://Quill/./core/editor.js","webpack://Quill/./core/logger.js","webpack://Quill/./core/emitter.js","webpack://Quill/./core/module.js","webpack://Quill/./core/shadow-selection-polyfill.js","webpack://Quill/./core/selection.js","webpack://Quill/./core/theme.js","webpack://Quill/./core/quill.js","webpack://Quill/./blots/container.js","webpack://Quill/./blots/embed.js","webpack://Quill/./blots/scroll.js","webpack://Quill/./formats/align.js","webpack://Quill/./formats/color.js","webpack://Quill/./formats/background.js","webpack://Quill/./formats/direction.js","webpack://Quill/./formats/font.js","webpack://Quill/./formats/size.js","webpack://Quill/./modules/clipboard.js","webpack://Quill/./modules/history.js","webpack://Quill/./modules/keyboard.js","webpack://Quill/./core.js","webpack://Quill/./formats/indent.js","webpack://Quill/./formats/blockquote.js","webpack://Quill/./formats/header.js","webpack://Quill/./formats/list.js","webpack://Quill/./formats/bold.js","webpack://Quill/./formats/italic.js","webpack://Quill/./formats/link.js","webpack://Quill/./formats/script.js","webpack://Quill/./formats/strike.js","webpack://Quill/./formats/underline.js","webpack://Quill/./formats/image.js","webpack://Quill/./formats/video.js","webpack://Quill/./modules/toolbar.js","webpack://Quill/./vaadin-quill.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Quill\"] = factory();\n\telse\n\t\troot[\"Quill\"] = factory();\n})(self, () => {\nreturn ","let elem = document.createElement('div');\nelem.classList.toggle('test-class', false);\nif (elem.classList.contains('test-class')) {\n let _toggle = DOMTokenList.prototype.toggle;\n DOMTokenList.prototype.toggle = function(token, force) {\n if (arguments.length > 1 && !this.contains(token) === !force) {\n return force;\n } else {\n return _toggle.call(this, token);\n }\n };\n}\n\nif (!String.prototype.startsWith) {\n String.prototype.startsWith = function(searchString, position){\n position = position || 0;\n return this.substr(position, searchString.length) === searchString;\n };\n}\n\nif (!String.prototype.endsWith) {\n String.prototype.endsWith = function(searchString, position) {\n var subjectString = this.toString();\n if (typeof position !== 'number' || !isFinite(position) || Math.floor(position) !== position || position > subjectString.length) {\n position = subjectString.length;\n }\n position -= searchString.length;\n var lastIndex = subjectString.indexOf(searchString, position);\n return lastIndex !== -1 && lastIndex === position;\n };\n}\n\nif (!Array.prototype.find) {\n Object.defineProperty(Array.prototype, \"find\", {\n value: function(predicate) {\n if (this === null) {\n throw new TypeError('Array.prototype.find called on null or undefined');\n }\n if (typeof predicate !== 'function') {\n throw new TypeError('predicate must be a function');\n }\n var list = Object(this);\n var length = list.length >>> 0;\n var thisArg = arguments[1];\n var value;\n\n for (var i = 0; i < length; i++) {\n value = list[i];\n if (predicate.call(thisArg, value, i, list)) {\n return value;\n }\n }\n return undefined;\n }\n });\n}\n\ndocument.addEventListener(\"DOMContentLoaded\", function() {\n // Disable resizing in Firefox\n document.execCommand(\"enableObjectResizing\", false, false);\n // Disable automatic linkifying in IE11\n document.execCommand(\"autoUrlDetect\", false, false);\n});\n","'use strict';\n\nvar has = Object.prototype.hasOwnProperty\n , prefix = '~';\n\n/**\n * Constructor to create a storage for our `EE` objects.\n * An `Events` instance is a plain object whose properties are event names.\n *\n * @constructor\n * @api private\n */\nfunction Events() {}\n\n//\n// We try to not inherit from `Object.prototype`. In some engines creating an\n// instance in this way is faster than calling `Object.create(null)` directly.\n// If `Object.create(null)` is not supported we prefix the event names with a\n// character to make sure that the built-in object properties are not\n// overridden or used as an attack vector.\n//\nif (Object.create) {\n Events.prototype = Object.create(null);\n\n //\n // This hack is needed because the `__proto__` property is still inherited in\n // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.\n //\n if (!new Events().__proto__) prefix = false;\n}\n\n/**\n * Representation of a single event listener.\n *\n * @param {Function} fn The listener function.\n * @param {Mixed} context The context to invoke the listener with.\n * @param {Boolean} [once=false] Specify if the listener is a one-time listener.\n * @constructor\n * @api private\n */\nfunction EE(fn, context, once) {\n this.fn = fn;\n this.context = context;\n this.once = once || false;\n}\n\n/**\n * Minimal `EventEmitter` interface that is molded against the Node.js\n * `EventEmitter` interface.\n *\n * @constructor\n * @api public\n */\nfunction EventEmitter() {\n this._events = new Events();\n this._eventsCount = 0;\n}\n\n/**\n * Return an array listing the events for which the emitter has registered\n * listeners.\n *\n * @returns {Array}\n * @api public\n */\nEventEmitter.prototype.eventNames = function eventNames() {\n var names = []\n , events\n , name;\n\n if (this._eventsCount === 0) return names;\n\n for (name in (events = this._events)) {\n if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);\n }\n\n if (Object.getOwnPropertySymbols) {\n return names.concat(Object.getOwnPropertySymbols(events));\n }\n\n return names;\n};\n\n/**\n * Return the listeners registered for a given event.\n *\n * @param {String|Symbol} event The event name.\n * @param {Boolean} exists Only check if there are listeners.\n * @returns {Array|Boolean}\n * @api public\n */\nEventEmitter.prototype.listeners = function listeners(event, exists) {\n var evt = prefix ? prefix + event : event\n , available = this._events[evt];\n\n if (exists) return !!available;\n if (!available) return [];\n if (available.fn) return [available.fn];\n\n for (var i = 0, l = available.length, ee = new Array(l); i < l; i++) {\n ee[i] = available[i].fn;\n }\n\n return ee;\n};\n\n/**\n * Calls each of the listeners registered for a given event.\n *\n * @param {String|Symbol} event The event name.\n * @returns {Boolean} `true` if the event had listeners, else `false`.\n * @api public\n */\nEventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {\n var evt = prefix ? prefix + event : event;\n\n if (!this._events[evt]) return false;\n\n var listeners = this._events[evt]\n , len = arguments.length\n , args\n , i;\n\n if (listeners.fn) {\n if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);\n\n switch (len) {\n case 1: return listeners.fn.call(listeners.context), true;\n case 2: return listeners.fn.call(listeners.context, a1), true;\n case 3: return listeners.fn.call(listeners.context, a1, a2), true;\n case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;\n case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;\n case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;\n }\n\n for (i = 1, args = new Array(len -1); i < len; i++) {\n args[i - 1] = arguments[i];\n }\n\n listeners.fn.apply(listeners.context, args);\n } else {\n var length = listeners.length\n , j;\n\n for (i = 0; i < length; i++) {\n if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);\n\n switch (len) {\n case 1: listeners[i].fn.call(listeners[i].context); break;\n case 2: listeners[i].fn.call(listeners[i].context, a1); break;\n case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;\n case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;\n default:\n if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {\n args[j - 1] = arguments[j];\n }\n\n listeners[i].fn.apply(listeners[i].context, args);\n }\n }\n }\n\n return true;\n};\n\n/**\n * Add a listener for a given event.\n *\n * @param {String|Symbol} event The event name.\n * @param {Function} fn The listener function.\n * @param {Mixed} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @api public\n */\nEventEmitter.prototype.on = function on(event, fn, context) {\n var listener = new EE(fn, context || this)\n , evt = prefix ? prefix + event : event;\n\n if (!this._events[evt]) this._events[evt] = listener, this._eventsCount++;\n else if (!this._events[evt].fn) this._events[evt].push(listener);\n else this._events[evt] = [this._events[evt], listener];\n\n return this;\n};\n\n/**\n * Add a one-time listener for a given event.\n *\n * @param {String|Symbol} event The event name.\n * @param {Function} fn The listener function.\n * @param {Mixed} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @api public\n */\nEventEmitter.prototype.once = function once(event, fn, context) {\n var listener = new EE(fn, context || this, true)\n , evt = prefix ? prefix + event : event;\n\n if (!this._events[evt]) this._events[evt] = listener, this._eventsCount++;\n else if (!this._events[evt].fn) this._events[evt].push(listener);\n else this._events[evt] = [this._events[evt], listener];\n\n return this;\n};\n\n/**\n * Remove the listeners of a given event.\n *\n * @param {String|Symbol} event The event name.\n * @param {Function} fn Only remove the listeners that match this function.\n * @param {Mixed} context Only remove the listeners that have this context.\n * @param {Boolean} once Only remove one-time listeners.\n * @returns {EventEmitter} `this`.\n * @api public\n */\nEventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {\n var evt = prefix ? prefix + event : event;\n\n if (!this._events[evt]) return this;\n if (!fn) {\n if (--this._eventsCount === 0) this._events = new Events();\n else delete this._events[evt];\n return this;\n }\n\n var listeners = this._events[evt];\n\n if (listeners.fn) {\n if (\n listeners.fn === fn\n && (!once || listeners.once)\n && (!context || listeners.context === context)\n ) {\n if (--this._eventsCount === 0) this._events = new Events();\n else delete this._events[evt];\n }\n } else {\n for (var i = 0, events = [], length = listeners.length; i < length; i++) {\n if (\n listeners[i].fn !== fn\n || (once && !listeners[i].once)\n || (context && listeners[i].context !== context)\n ) {\n events.push(listeners[i]);\n }\n }\n\n //\n // Reset the array, or remove it completely if we have no more listeners.\n //\n if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;\n else if (--this._eventsCount === 0) this._events = new Events();\n else delete this._events[evt];\n }\n\n return this;\n};\n\n/**\n * Remove all listeners, or those of the specified event.\n *\n * @param {String|Symbol} [event] The event name.\n * @returns {EventEmitter} `this`.\n * @api public\n */\nEventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {\n var evt;\n\n if (event) {\n evt = prefix ? prefix + event : event;\n if (this._events[evt]) {\n if (--this._eventsCount === 0) this._events = new Events();\n else delete this._events[evt];\n }\n } else {\n this._events = new Events();\n this._eventsCount = 0;\n }\n\n return this;\n};\n\n//\n// Alias methods names because people roll like that.\n//\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\nEventEmitter.prototype.addListener = EventEmitter.prototype.on;\n\n//\n// This function doesn't apply anymore.\n//\nEventEmitter.prototype.setMaxListeners = function setMaxListeners() {\n return this;\n};\n\n//\n// Expose the prefix.\n//\nEventEmitter.prefixed = prefix;\n\n//\n// Allow `EventEmitter` to be imported as module namespace.\n//\nEventEmitter.EventEmitter = EventEmitter;\n\n//\n// Expose the module.\n//\nif ('undefined' !== typeof module) {\n module.exports = EventEmitter;\n}\n","/**\n * This library modifies the diff-patch-match library by Neil Fraser\n * by removing the patch and match functionality and certain advanced\n * options in the diff function. The original license is as follows:\n *\n * ===\n *\n * Diff Match and Patch\n *\n * Copyright 2006 Google Inc.\n * http://code.google.com/p/google-diff-match-patch/\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/**\n * The data structure representing a diff is an array of tuples:\n * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]\n * which means: delete 'Hello', add 'Goodbye' and keep ' world.'\n */\nvar DIFF_DELETE = -1;\nvar DIFF_INSERT = 1;\nvar DIFF_EQUAL = 0;\n\n\n/**\n * Find the differences between two texts. Simplifies the problem by stripping\n * any common prefix or suffix off the texts before diffing.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {Int|Object} [cursor_pos] Edit position in text1 or object with more info\n * @return {Array} Array of diff tuples.\n */\nfunction diff_main(text1, text2, cursor_pos, _fix_unicode) {\n // Check for equality\n if (text1 === text2) {\n if (text1) {\n return [[DIFF_EQUAL, text1]];\n }\n return [];\n }\n\n if (cursor_pos != null) {\n var editdiff = find_cursor_edit_diff(text1, text2, cursor_pos);\n if (editdiff) {\n return editdiff;\n }\n }\n\n // Trim off common prefix (speedup).\n var commonlength = diff_commonPrefix(text1, text2);\n var commonprefix = text1.substring(0, commonlength);\n text1 = text1.substring(commonlength);\n text2 = text2.substring(commonlength);\n\n // Trim off common suffix (speedup).\n commonlength = diff_commonSuffix(text1, text2);\n var commonsuffix = text1.substring(text1.length - commonlength);\n text1 = text1.substring(0, text1.length - commonlength);\n text2 = text2.substring(0, text2.length - commonlength);\n\n // Compute the diff on the middle block.\n var diffs = diff_compute_(text1, text2);\n\n // Restore the prefix and suffix.\n if (commonprefix) {\n diffs.unshift([DIFF_EQUAL, commonprefix]);\n }\n if (commonsuffix) {\n diffs.push([DIFF_EQUAL, commonsuffix]);\n }\n diff_cleanupMerge(diffs, _fix_unicode);\n return diffs;\n};\n\n\n/**\n * Find the differences between two texts. Assumes that the texts do not\n * have any common prefix or suffix.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @return {Array} Array of diff tuples.\n */\nfunction diff_compute_(text1, text2) {\n var diffs;\n\n if (!text1) {\n // Just add some text (speedup).\n return [[DIFF_INSERT, text2]];\n }\n\n if (!text2) {\n // Just delete some text (speedup).\n return [[DIFF_DELETE, text1]];\n }\n\n var longtext = text1.length > text2.length ? text1 : text2;\n var shorttext = text1.length > text2.length ? text2 : text1;\n var i = longtext.indexOf(shorttext);\n if (i !== -1) {\n // Shorter text is inside the longer text (speedup).\n diffs = [\n [DIFF_INSERT, longtext.substring(0, i)],\n [DIFF_EQUAL, shorttext],\n [DIFF_INSERT, longtext.substring(i + shorttext.length)]\n ];\n // Swap insertions for deletions if diff is reversed.\n if (text1.length > text2.length) {\n diffs[0][0] = diffs[2][0] = DIFF_DELETE;\n }\n return diffs;\n }\n\n if (shorttext.length === 1) {\n // Single character string.\n // After the previous speedup, the character can't be an equality.\n return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];\n }\n\n // Check to see if the problem can be split in two.\n var hm = diff_halfMatch_(text1, text2);\n if (hm) {\n // A half-match was found, sort out the return data.\n var text1_a = hm[0];\n var text1_b = hm[1];\n var text2_a = hm[2];\n var text2_b = hm[3];\n var mid_common = hm[4];\n // Send both pairs off for separate processing.\n var diffs_a = diff_main(text1_a, text2_a);\n var diffs_b = diff_main(text1_b, text2_b);\n // Merge the results.\n return diffs_a.concat([[DIFF_EQUAL, mid_common]], diffs_b);\n }\n\n return diff_bisect_(text1, text2);\n};\n\n\n/**\n * Find the 'middle snake' of a diff, split the problem in two\n * and return the recursively constructed diff.\n * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @return {Array} Array of diff tuples.\n * @private\n */\nfunction diff_bisect_(text1, text2) {\n // Cache the text lengths to prevent multiple calls.\n var text1_length = text1.length;\n var text2_length = text2.length;\n var max_d = Math.ceil((text1_length + text2_length) / 2);\n var v_offset = max_d;\n var v_length = 2 * max_d;\n var v1 = new Array(v_length);\n var v2 = new Array(v_length);\n // Setting all elements to -1 is faster in Chrome & Firefox than mixing\n // integers and undefined.\n for (var x = 0; x < v_length; x++) {\n v1[x] = -1;\n v2[x] = -1;\n }\n v1[v_offset + 1] = 0;\n v2[v_offset + 1] = 0;\n var delta = text1_length - text2_length;\n // If the total number of characters is odd, then the front path will collide\n // with the reverse path.\n var front = (delta % 2 !== 0);\n // Offsets for start and end of k loop.\n // Prevents mapping of space beyond the grid.\n var k1start = 0;\n var k1end = 0;\n var k2start = 0;\n var k2end = 0;\n for (var d = 0; d < max_d; d++) {\n // Walk the front path one step.\n for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {\n var k1_offset = v_offset + k1;\n var x1;\n if (k1 === -d || (k1 !== d && v1[k1_offset - 1] < v1[k1_offset + 1])) {\n x1 = v1[k1_offset + 1];\n } else {\n x1 = v1[k1_offset - 1] + 1;\n }\n var y1 = x1 - k1;\n while (\n x1 < text1_length && y1 < text2_length &&\n text1.charAt(x1) === text2.charAt(y1)\n ) {\n x1++;\n y1++;\n }\n v1[k1_offset] = x1;\n if (x1 > text1_length) {\n // Ran off the right of the graph.\n k1end += 2;\n } else if (y1 > text2_length) {\n // Ran off the bottom of the graph.\n k1start += 2;\n } else if (front) {\n var k2_offset = v_offset + delta - k1;\n if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] !== -1) {\n // Mirror x2 onto top-left coordinate system.\n var x2 = text1_length - v2[k2_offset];\n if (x1 >= x2) {\n // Overlap detected.\n return diff_bisectSplit_(text1, text2, x1, y1);\n }\n }\n }\n }\n\n // Walk the reverse path one step.\n for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {\n var k2_offset = v_offset + k2;\n var x2;\n if (k2 === -d || (k2 !== d && v2[k2_offset - 1] < v2[k2_offset + 1])) {\n x2 = v2[k2_offset + 1];\n } else {\n x2 = v2[k2_offset - 1] + 1;\n }\n var y2 = x2 - k2;\n while (\n x2 < text1_length && y2 < text2_length &&\n text1.charAt(text1_length - x2 - 1) === text2.charAt(text2_length - y2 - 1)\n ) {\n x2++;\n y2++;\n }\n v2[k2_offset] = x2;\n if (x2 > text1_length) {\n // Ran off the left of the graph.\n k2end += 2;\n } else if (y2 > text2_length) {\n // Ran off the top of the graph.\n k2start += 2;\n } else if (!front) {\n var k1_offset = v_offset + delta - k2;\n if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] !== -1) {\n var x1 = v1[k1_offset];\n var y1 = v_offset + x1 - k1_offset;\n // Mirror x2 onto top-left coordinate system.\n x2 = text1_length - x2;\n if (x1 >= x2) {\n // Overlap detected.\n return diff_bisectSplit_(text1, text2, x1, y1);\n }\n }\n }\n }\n }\n // Diff took too long and hit the deadline or\n // number of diffs equals number of characters, no commonality at all.\n return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];\n};\n\n\n/**\n * Given the location of the 'middle snake', split the diff in two parts\n * and recurse.\n * @param {string} text1 Old string to be diffed.\n * @param {string} text2 New string to be diffed.\n * @param {number} x Index of split point in text1.\n * @param {number} y Index of split point in text2.\n * @return {Array} Array of diff tuples.\n */\nfunction diff_bisectSplit_(text1, text2, x, y) {\n var text1a = text1.substring(0, x);\n var text2a = text2.substring(0, y);\n var text1b = text1.substring(x);\n var text2b = text2.substring(y);\n\n // Compute both diffs serially.\n var diffs = diff_main(text1a, text2a);\n var diffsb = diff_main(text1b, text2b);\n\n return diffs.concat(diffsb);\n};\n\n\n/**\n * Determine the common prefix of two strings.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the start of each\n * string.\n */\nfunction diff_commonPrefix(text1, text2) {\n // Quick check for common null cases.\n if (!text1 || !text2 || text1.charAt(0) !== text2.charAt(0)) {\n return 0;\n }\n // Binary search.\n // Performance analysis: http://neil.fraser.name/news/2007/10/09/\n var pointermin = 0;\n var pointermax = Math.min(text1.length, text2.length);\n var pointermid = pointermax;\n var pointerstart = 0;\n while (pointermin < pointermid) {\n if (\n text1.substring(pointerstart, pointermid) ==\n text2.substring(pointerstart, pointermid)\n ) {\n pointermin = pointermid;\n pointerstart = pointermin;\n } else {\n pointermax = pointermid;\n }\n pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n }\n\n if (is_surrogate_pair_start(text1.charCodeAt(pointermid - 1))) {\n pointermid--;\n }\n\n return pointermid;\n};\n\n\n/**\n * Determine the common suffix of two strings.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the end of each string.\n */\nfunction diff_commonSuffix(text1, text2) {\n // Quick check for common null cases.\n if (!text1 || !text2 || text1.slice(-1) !== text2.slice(-1)) {\n return 0;\n }\n // Binary search.\n // Performance analysis: http://neil.fraser.name/news/2007/10/09/\n var pointermin = 0;\n var pointermax = Math.min(text1.length, text2.length);\n var pointermid = pointermax;\n var pointerend = 0;\n while (pointermin < pointermid) {\n if (\n text1.substring(text1.length - pointermid, text1.length - pointerend) ==\n text2.substring(text2.length - pointermid, text2.length - pointerend)\n ) {\n pointermin = pointermid;\n pointerend = pointermin;\n } else {\n pointermax = pointermid;\n }\n pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n }\n\n if (is_surrogate_pair_end(text1.charCodeAt(text1.length - pointermid))) {\n pointermid--;\n }\n\n return pointermid;\n};\n\n\n/**\n * Do the two texts share a substring which is at least half the length of the\n * longer text?\n * This speedup can produce non-minimal diffs.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {Array.<string>} Five element Array, containing the prefix of\n * text1, the suffix of text1, the prefix of text2, the suffix of\n * text2 and the common middle. Or null if there was no match.\n */\nfunction diff_halfMatch_(text1, text2) {\n var longtext = text1.length > text2.length ? text1 : text2;\n var shorttext = text1.length > text2.length ? text2 : text1;\n if (longtext.length < 4 || shorttext.length * 2 < longtext.length) {\n return null; // Pointless.\n }\n\n /**\n * Does a substring of shorttext exist within longtext such that the substring\n * is at least half the length of longtext?\n * Closure, but does not reference any external variables.\n * @param {string} longtext Longer string.\n * @param {string} shorttext Shorter string.\n * @param {number} i Start index of quarter length substring within longtext.\n * @return {Array.<string>} Five element Array, containing the prefix of\n * longtext, the suffix of longtext, the prefix of shorttext, the suffix\n * of shorttext and the common middle. Or null if there was no match.\n * @private\n */\n function diff_halfMatchI_(longtext, shorttext, i) {\n // Start with a 1/4 length substring at position i as a seed.\n var seed = longtext.substring(i, i + Math.floor(longtext.length / 4));\n var j = -1;\n var best_common = '';\n var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b;\n while ((j = shorttext.indexOf(seed, j + 1)) !== -1) {\n var prefixLength = diff_commonPrefix(\n longtext.substring(i), shorttext.substring(j));\n var suffixLength = diff_commonSuffix(\n longtext.substring(0, i), shorttext.substring(0, j));\n if (best_common.length < suffixLength + prefixLength) {\n best_common = shorttext.substring(\n j - suffixLength, j) + shorttext.substring(j, j + prefixLength);\n best_longtext_a = longtext.substring(0, i - suffixLength);\n best_longtext_b = longtext.substring(i + prefixLength);\n best_shorttext_a = shorttext.substring(0, j - suffixLength);\n best_shorttext_b = shorttext.substring(j + prefixLength);\n }\n }\n if (best_common.length * 2 >= longtext.length) {\n return [\n best_longtext_a, best_longtext_b,\n best_shorttext_a, best_shorttext_b, best_common\n ];\n } else {\n return null;\n }\n }\n\n // First check if the second quarter is the seed for a half-match.\n var hm1 = diff_halfMatchI_(longtext, shorttext, Math.ceil(longtext.length / 4));\n // Check again based on the third quarter.\n var hm2 = diff_halfMatchI_(longtext, shorttext, Math.ceil(longtext.length / 2));\n var hm;\n if (!hm1 && !hm2) {\n return null;\n } else if (!hm2) {\n hm = hm1;\n } else if (!hm1) {\n hm = hm2;\n } else {\n // Both matched. Select the longest.\n hm = hm1[4].length > hm2[4].length ? hm1 : hm2;\n }\n\n // A half-match was found, sort out the return data.\n var text1_a, text1_b, text2_a, text2_b;\n if (text1.length > text2.length) {\n text1_a = hm[0];\n text1_b = hm[1];\n text2_a = hm[2];\n text2_b = hm[3];\n } else {\n text2_a = hm[0];\n text2_b = hm[1];\n text1_a = hm[2];\n text1_b = hm[3];\n }\n var mid_common = hm[4];\n return [text1_a, text1_b, text2_a, text2_b, mid_common];\n};\n\n\n/**\n * Reorder and merge like edit sections. Merge equalities.\n * Any edit section can move as long as it doesn't cross an equality.\n * @param {Array} diffs Array of diff tuples.\n * @param {boolean} fix_unicode Whether to normalize to a unicode-correct diff\n */\nfunction diff_cleanupMerge(diffs, fix_unicode) {\n diffs.push([DIFF_EQUAL, '']); // Add a dummy entry at the end.\n var pointer = 0;\n var count_delete = 0;\n var count_insert = 0;\n var text_delete = '';\n var text_insert = '';\n var commonlength;\n while (pointer < diffs.length) {\n if (pointer < diffs.length - 1 && !diffs[pointer][1]) {\n diffs.splice(pointer, 1);\n continue;\n }\n switch (diffs[pointer][0]) {\n case DIFF_INSERT:\n\n count_insert++;\n text_insert += diffs[pointer][1];\n pointer++;\n break;\n case DIFF_DELETE:\n count_delete++;\n text_delete += diffs[pointer][1];\n pointer++;\n break;\n case DIFF_EQUAL:\n var previous_equality = pointer - count_insert - count_delete - 1;\n if (fix_unicode) {\n // prevent splitting of unicode surrogate pairs. when fix_unicode is true,\n // we assume that the old and new text in the diff are complete and correct\n // unicode-encoded JS strings, but the tuple boundaries may fall between\n // surrogate pairs. we fix this by shaving off stray surrogates from the end\n // of the previous equality and the beginning of this equality. this may create\n // empty equalities or a common prefix or suffix. for example, if AB and AC are\n // emojis, `[[0, 'A'], [-1, 'BA'], [0, 'C']]` would turn into deleting 'ABAC' and\n // inserting 'AC', and then the common suffix 'AC' will be eliminated. in this\n // particular case, both equalities go away, we absorb any previous inequalities,\n // and we keep scanning for the next equality before rewriting the tuples.\n if (previous_equality >= 0 && ends_with_pair_start(diffs[previous_equality][1])) {\n var stray = diffs[previous_equality][1].slice(-1);\n diffs[previous_equality][1] = diffs[previous_equality][1].slice(0, -1);\n text_delete = stray + text_delete;\n text_insert = stray + text_insert;\n if (!diffs[previous_equality][1]) {\n // emptied out previous equality, so delete it and include previous delete/insert\n diffs.splice(previous_equality, 1);\n pointer--;\n var k = previous_equality - 1;\n if (diffs[k] && diffs[k][0] === DIFF_INSERT) {\n count_insert++;\n text_insert = diffs[k][1] + text_insert;\n k--;\n }\n if (diffs[k] && diffs[k][0] === DIFF_DELETE) {\n count_delete++;\n text_delete = diffs[k][1] + text_delete;\n k--;\n }\n previous_equality = k;\n }\n }\n if (starts_with_pair_end(diffs[pointer][1])) {\n var stray = diffs[pointer][1].charAt(0);\n diffs[pointer][1] = diffs[pointer][1].slice(1);\n text_delete += stray;\n text_insert += stray;\n }\n }\n if (pointer < diffs.length - 1 && !diffs[pointer][1]) {\n // for empty equality not at end, wait for next equality\n diffs.splice(pointer, 1);\n break;\n }\n if (text_delete.length > 0 || text_insert.length > 0) {\n // note that diff_commonPrefix and diff_commonSuffix are unicode-aware\n if (text_delete.length > 0 && text_insert.length > 0) {\n // Factor out any common prefixes.\n commonlength = diff_commonPrefix(text_insert, text_delete);\n if (commonlength !== 0) {\n if (previous_equality >= 0) {\n diffs[previous_equality][1] += text_insert.substring(0, commonlength);\n } else {\n diffs.splice(0, 0, [DIFF_EQUAL, text_insert.substring(0, commonlength)]);\n pointer++;\n }\n text_insert = text_insert.substring(commonlength);\n text_delete = text_delete.substring(commonlength);\n }\n // Factor out any common suffixes.\n commonlength = diff_commonSuffix(text_insert, text_delete);\n if (commonlength !== 0) {\n diffs[pointer][1] =\n text_insert.substring(text_insert.length - commonlength) + diffs[pointer][1];\n text_insert = text_insert.substring(0, text_insert.length - commonlength);\n text_delete = text_delete.substring(0, text_delete.length - commonlength);\n }\n }\n // Delete the offending records and add the merged ones.\n var n = count_insert + count_delete;\n if (text_delete.length === 0 && text_insert.length === 0) {\n diffs.splice(pointer - n, n);\n pointer = pointer - n;\n } else if (text_delete.length === 0) {\n diffs.splice(pointer - n, n, [DIFF_INSERT, text_insert]);\n pointer = pointer - n + 1;\n } else if (text_insert.length === 0) {\n diffs.splice(pointer - n, n, [DIFF_DELETE, text_delete]);\n pointer = pointer - n + 1;\n } else {\n diffs.splice(pointer - n, n, [DIFF_DELETE, text_delete], [DIFF_INSERT, text_insert]);\n pointer = pointer - n + 2;\n }\n }\n if (pointer !== 0 && diffs[pointer - 1][0] === DIFF_EQUAL) {\n // Merge this equality with the previous one.\n diffs[pointer - 1][1] += diffs[pointer][1];\n diffs.splice(pointer, 1);\n } else {\n pointer++;\n }\n count_insert = 0;\n count_delete = 0;\n text_delete = '';\n text_insert = '';\n break;\n }\n }\n if (diffs[diffs.length - 1][1] === '') {\n diffs.pop(); // Remove the dummy entry at the end.\n }\n\n // Second pass: look for single edits surrounded on both sides by equalities\n // which can be shifted sideways to eliminate an equality.\n // e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC\n var changes = false;\n pointer = 1;\n // Intentionally ignore the first and last element (don't need checking).\n while (pointer < diffs.length - 1) {\n if (diffs[pointer - 1][0] === DIFF_EQUAL &&\n diffs[pointer + 1][0] === DIFF_EQUAL) {\n // This is a single edit surrounded by equalities.\n if (diffs[pointer][1].substring(diffs[pointer][1].length -\n diffs[pointer - 1][1].length) === diffs[pointer - 1][1]) {\n // Shift the edit over the previous equality.\n diffs[pointer][1] = diffs[pointer - 1][1] +\n diffs[pointer][1].substring(0, diffs[pointer][1].length -\n diffs[pointer - 1][1].length);\n diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];\n diffs.splice(pointer - 1, 1);\n changes = true;\n } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==\n diffs[pointer + 1][1]) {\n // Shift the edit over the next equality.\n diffs[pointer - 1][1] += diffs[pointer + 1][1];\n diffs[pointer][1] =\n diffs[pointer][1].substring(diffs[pointer + 1][1].length) +\n diffs[pointer + 1][1];\n diffs.splice(pointer + 1, 1);\n changes = true;\n }\n }\n pointer++;\n }\n // If shifts were made, the diff needs reordering and another shift sweep.\n if (changes) {\n diff_cleanupMerge(diffs, fix_unicode);\n }\n};\n\nfunction is_surrogate_pair_start(charCode) {\n return charCode >= 0xD800 && charCode <= 0xDBFF;\n}\n\nfunction is_surrogate_pair_end(charCode) {\n return charCode >= 0xDC00 && charCode <= 0xDFFF;\n}\n\nfunction starts_with_pair_end(str) {\n return is_surrogate_pair_end(str.charCodeAt(0));\n}\n\nfunction ends_with_pair_start(str) {\n return is_surrogate_pair_start(str.charCodeAt(str.length - 1));\n}\n\nfunction remove_empty_tuples(tuples) {\n var ret = [];\n for (var i = 0; i < tuples.length; i++) {\n if (tuples[i][1].length > 0) {\n ret.push(tuples[i]);\n }\n }\n return ret;\n}\n\nfunction make_edit_splice(before, oldMiddle, newMiddle, after) {\n if (ends_with_pair_start(before) || starts_with_pair_end(after)) {\n return null;\n }\n return remove_empty_tuples([\n [DIFF_EQUAL, before],\n [DIFF_DELETE, oldMiddle],\n [DIFF_INSERT, newMiddle],\n [DIFF_EQUAL, after]\n ]);\n}\n\nfunction find_cursor_edit_diff(oldText, newText, cursor_pos) {\n // note: this runs after equality check has ruled out exact equality\n var oldRange = typeof cursor_pos === 'number' ?\n { index: cursor_pos, length: 0 } : cursor_pos.oldRange;\n var newRange = typeof cursor_pos === 'number' ?\n null : cursor_pos.newRange;\n // take into account the old and new selection to generate the best diff\n // possible for a text edit. for example, a text change from \"xxx\" to \"xx\"\n // could be a delete or forwards-delete of any one of the x's, or the\n // result of selecting two of the x's and typing \"x\".\n var oldLength = oldText.length;\n var newLength = newText.length;\n if (oldRange.length === 0 && (newRange === null || newRange.length === 0)) {\n // see if we have an insert or delete before or after cursor\n var oldCursor = oldRange.index;\n var oldBefore = oldText.slice(0, oldCursor);\n var oldAfter = oldText.slice(oldCursor);\n var maybeNewCursor = newRange ? newRange.index : null;\n editBefore: {\n // is this an insert or delete right before oldCursor?\n var newCursor = oldCursor + newLength - oldLength;\n if (maybeNewCursor !== null && maybeNewCursor !== newCursor) {\n break editBefore;\n }\n if (newCursor < 0 || newCursor > newLength) {\n break editBefore;\n }\n var newBefore = newText.slice(0, newCursor);\n var newAfter = newText.slice(newCursor);\n if (newAfter !== oldAfter) {\n break editBefore;\n }\n var prefixLength = Math.min(oldCursor, newCursor);\n var oldPrefix = oldBefore.slice(0, prefixLength);\n var newPrefix = newBefore.slice(0, prefixLength);\n if (oldPrefix !== newPrefix) {\n break editBefore;\n }\n var oldMiddle = oldBefore.slice(prefixLength);\n var newMiddle = newBefore.slice(prefixLength);\n return make_edit_splice(oldPrefix, oldMiddle, newMiddle, oldAfter);\n }\n editAfter: {\n // is this an insert or delete right after oldCursor?\n if (maybeNewCursor !== null && maybeNewCursor !== oldCursor) {\n break editAfter;\n }\n var cursor = oldCursor;\n var newBefore = newText.slice(0, cursor);\n var newAfter = newText.slice(cursor);\n if (newBefore !== oldBefore) {\n break editAfter;\n }\n var suffixLength = Math.min(oldLength - cursor, newLength - cursor);\n var oldSuffix = oldAfter.slice(oldAfter.length - suffixLength);\n var newSuffix = newAfter.slice(newAfter.length - suffixLength);\n if (oldSuffix !== newSuffix) {\n break editAfter;\n }\n var oldMiddle = oldAfter.slice(0, oldAfter.length - suffixLength);\n var newMiddle = newAfter.slice(0, newAfter.length - suffixLength);\n return make_edit_splice(oldBefore, oldMiddle, newMiddle, oldSuffix);\n }\n }\n if (oldRange.length > 0 && newRange && newRange.length === 0) {\n replaceRange: {\n // see if diff could be a splice of the old selection range\n var oldPrefix = oldText.slice(0, oldRange.index);\n var oldSuffix = oldText.slice(oldRange.index + oldRange.length);\n var prefixLength = oldPrefix.length;\n var suffixLength = oldSuffix.length;\n if (newLength < prefixLength + suffixLength) {\n break replaceRange;\n }\n var newPrefix = newText.slice(0, prefixLength);\n var newSuffix = newText.slice(newLength - suffixLength);\n if (oldPrefix !== newPrefix || oldSuffix !== newSuffix) {\n break replaceRange;\n }\n var oldMiddle = oldText.slice(prefixLength, oldLength - suffixLength);\n var newMiddle = newText.slice(prefixLength, newLength - suffixLength);\n return make_edit_splice(oldPrefix, oldMiddle, newMiddle, oldSuffix);\n }\n }\n\n return null;\n}\n\nfunction diff(text1, text2, cursor_pos) {\n // only pass fix_unicode=true at the top level, not when diff_main is\n // recursively invoked\n return diff_main(text1, text2, cursor_pos, true);\n}\n\ndiff.INSERT = DIFF_INSERT;\ndiff.DELETE = DIFF_DELETE;\ndiff.EQUAL = DIFF_EQUAL;\n\nmodule.exports = diff;\n","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n objectTag = '[object Object]',\n promiseTag = '[object Promise]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n symbolTag = '[object Symbol]',\n weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to match `RegExp` flags from their coerced string values. */\nvar reFlags = /\\w*$/;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Used to identify `toStringTag` values supported by `_.clone`. */\nvar cloneableTags = {};\ncloneableTags[argsTag] = cloneableTags[arrayTag] =\ncloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\ncloneableTags[boolTag] = cloneableTags[dateTag] =\ncloneableTags[float32Tag] = cloneableTags[float64Tag] =\ncloneableTags[int8Tag] = cloneableTags[int16Tag] =\ncloneableTags[int32Tag] = cloneableTags[mapTag] =\ncloneableTags[numberTag] = cloneableTags[objectTag] =\ncloneableTags[regexpTag] = cloneableTags[setTag] =\ncloneableTags[stringTag] = cloneableTags[symbolTag] =\ncloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\ncloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\ncloneableTags[errorTag] = cloneableTags[funcTag] =\ncloneableTags[weakMapTag] = false;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/**\n * Adds the key-value `pair` to `map`.\n *\n * @private\n * @param {Object} map The map to modify.\n * @param {Array} pair The key-value pair to add.\n * @returns {Object} Returns `map`.\n */\nfunction addMapEntry(map, pair) {\n // Don't return `map.set` because it's not chainable in IE 11.\n map.set(pair[0], pair[1]);\n return map;\n}\n\n/**\n * Adds `value` to `set`.\n *\n * @private\n * @param {Object} set The set to modify.\n * @param {*} value The value to add.\n * @returns {Object} Returns `set`.\n */\nfunction addSetEntry(set, value) {\n // Don't return `set.add` because it's not chainable in IE 11.\n set.add(value);\n return set;\n}\n\n/**\n * A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\nfunction arrayEach(array, iteratee) {\n var index = -1,\n length = array ? array.length : 0;\n\n while (++index < length) {\n if (iteratee(array[index], index, array) === false) {\n break;\n }\n }\n return array;\n}\n\n/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n var index = -1,\n length = values.length,\n offset = array.length;\n\n while (++index < length) {\n array[offset + index] = values[index];\n }\n return array;\n}\n\n/**\n * A specialized version of `_.reduce` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @param {boolean} [initAccum] Specify using the first element of `array` as\n * the initial value.\n * @returns {*} Returns the accumulated value.\n */\nfunction arrayReduce(array, iteratee, accumulator, initAccum) {\n var index = -1,\n length = array ? array.length : 0;\n\n if (initAccum && length) {\n accumulator = array[++index];\n }\n while (++index < length) {\n accumulator = iteratee(accumulator, array[index], index, array);\n }\n return accumulator;\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n var index = -1,\n result = Array(n);\n\n while (++index < n) {\n result[index] = iteratee(index);\n }\n return result;\n}\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n return object == null ? undefined : object[key];\n}\n\n/**\n * Checks if `value` is a host object in IE < 9.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a host object, else `false`.\n */\nfunction isHostObject(value) {\n // Many host objects are `Object` objects that can coerce to strings\n // despite having improperly defined `toString` methods.\n var result = false;\n if (value != null && typeof value.toString != 'function') {\n try {\n result = !!(value + '');\n } catch (e) {}\n }\n return result;\n}\n\n/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n var index = -1,\n result = Array(map.size);\n\n map.forEach(function(value, key) {\n result[++index] = [key, value];\n });\n return result;\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n}\n\n/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n var index = -1,\n result = Array(set.size);\n\n set.forEach(function(value) {\n result[++index] = value;\n });\n return result;\n}\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n Symbol = root.Symbol,\n Uint8Array = root.Uint8Array,\n getPrototype = overArg(Object.getPrototypeOf, Object),\n objectCreate = Object.create,\n propertyIsEnumerable = objectProto.propertyIsEnumerable,\n splice = arrayProto.splice;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n nativeKeys = overArg(Object.keys, Object);\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView'),\n Map = getNative(root, 'Map'),\n Promise = getNative(root, 'Promise'),\n Set = getNative(root, 'Set'),\n WeakMap = getNative(root, 'WeakMap'),\n nativeCreate = getNative(Object, 'create');\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n mapCtorString = toSource(Map),\n promiseCtorString = toSource(Promise),\n setCtorString = toSource(Set),\n weakMapCtorString = toSource(WeakMap);\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n var index = -1,\n length = entries ? entries.length : 0;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n this.__data__ = nativeCreate ? nativeCreate(null) : {};\n}\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n return this.has(key) && delete this.__data__[key];\n}\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n var data = this.__data__;\n if (nativeCreate) {\n var result = data[key];\n return result === HASH_UNDEFINED ? undefined : result;\n }\n return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n var data = this.__data__;\n return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);\n}\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n var data = this.__data__;\n data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n var index = -1,\n length = entries ? entries.length : 0;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n this.__data__ = [];\n}\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n return false;\n }\n var lastIndex = data.length - 1;\n if (index == lastIndex) {\n data.pop();\n } else {\n splice.call(data, index, 1);\n }\n return true;\n}\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n return index < 0 ? undefined : data[index][1];\n}\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n return assocIndexOf(this.__data__, key) > -1;\n}\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n data.push([key, value]);\n } else {\n data[index][1] = value;\n }\n return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n var index = -1,\n length = entries ? entries.length : 0;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n this.__data__ = {\n 'hash': new Hash,\n 'map': new (Map || ListCache),\n 'string': new Hash\n };\n}\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n return getMapData(this, key)['delete'](key);\n}\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n return getMapData(this, key).get(key);\n}\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n return getMapData(this, key).has(key);\n}\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n getMapData(this, key).set(key, value);\n return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n this.__data__ = new ListCache(entries);\n}\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n this.__data__ = new ListCache;\n}\n\n/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n return this.__data__['delete'](key);\n}\n\n/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n return this.__data__.get(key);\n}\n\n/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n return this.__data__.has(key);\n}\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n var cache = this.__data__;\n if (cache instanceof ListCache) {\n var pairs = cache.__data__;\n if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n pairs.push([key, value]);\n return this;\n }\n cache = this.__data__ = new MapCache(pairs);\n }\n cache.set(key, value);\n return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n // Safari 9 makes `arguments.length` enumerable in strict mode.\n var result = (isArray(value) || isArguments(value))\n ? baseTimes(value.length, String)\n : [];\n\n var length = result.length,\n skipIndexes = !!length;\n\n for (var key in value) {\n if ((inherited || hasOwnProperty.call(value, key)) &&\n !(skipIndexes && (key == 'length' || isIndex(key, length)))) {\n result.push(key);\n }\n }\n return result;\n}\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n var objValue = object[key];\n if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n (value === undefined && !(key in object))) {\n object[key] = value;\n }\n}\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n var length = array.length;\n while (length--) {\n if (eq(array[length][0], key)) {\n return length;\n }\n }\n return -1;\n}\n\n/**\n * The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssign(object, source) {\n return object && copyObject(source, keys(source), object);\n}\n\n/**\n * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n *\n * @private\n * @param {*} value The value to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @param {boolean} [isFull] Specify a clone including symbols.\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {*} Returns the cloned value.\n */\nfunction baseClone(value, isDeep, isFull, customizer, key, object, stack) {\n var result;\n if (customizer) {\n result = object ? customizer(value, key, object, stack) : customizer(value);\n }\n if (result !== undefined) {\n return result;\n }\n if (!isObject(value)) {\n return value;\n }\n var isArr = isArray(value);\n if (isArr) {\n result = initCloneArray(value);\n if (!isDeep) {\n return copyArray(value, result);\n }\n } else {\n var tag = getTag(value),\n isFunc = tag == funcTag || tag == genTag;\n\n if (isBuffer(value)) {\n return cloneBuffer(value, isDeep);\n }\n if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n if (isHostObject(value)) {\n return object ? value : {};\n }\n result = initCloneObject(isFunc ? {} : value);\n if (!isDeep) {\n return copySymbols(value, baseAssign(result, value));\n }\n } else {\n if (!cloneableTags[tag]) {\n return object ? value : {};\n }\n result = initCloneByTag(value, tag, baseClone, isDeep);\n }\n }\n // Check for circular references and return its corresponding clone.\n stack || (stack = new Stack);\n var stacked = stack.get(value);\n if (stacked) {\n return stacked;\n }\n stack.set(value, result);\n\n if (!isArr) {\n var props = isFull ? getAllKeys(value) : keys(value);\n }\n arrayEach(props || value, function(subValue, key) {\n if (props) {\n key = subValue;\n subValue = value[key];\n }\n // Recursively populate clone (susceptible to call stack limits).\n assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));\n });\n return result;\n}\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} prototype The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nfunction baseCreate(proto) {\n return isObject(proto) ? objectCreate(proto) : {};\n}\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n var result = keysFunc(object);\n return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\n/**\n * The base implementation of `getTag`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n return objectToString.call(value);\n}\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n */\nfunction baseIsNative(value) {\n if (!isObject(value) || isMasked(value)) {\n return false;\n }\n var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n if (!isPrototype(object)) {\n return nativeKeys(object);\n }\n var result = [];\n for (var key in Object(object)) {\n if (hasOwnProperty.call(object, key) && key != 'constructor') {\n result.push(key);\n }\n }\n return result;\n}\n\n/**\n * Creates a clone of `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n if (isDeep) {\n return buffer.slice();\n }\n var result = new buffer.constructor(buffer.length);\n buffer.copy(result);\n return result;\n}\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n return result;\n}\n\n/**\n * Creates a clone of `dataView`.\n *\n * @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n */\nfunction cloneDataView(dataView, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n}\n\n/**\n * Creates a clone of `map`.\n *\n * @private\n * @param {Object} map The map to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned map.\n */\nfunction cloneMap(map, isDeep, cloneFunc) {\n var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);\n return arrayReduce(array, addMapEntry, new map.constructor);\n}\n\n/**\n * Creates a clone of `regexp`.\n *\n * @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n */\nfunction cloneRegExp(regexp) {\n var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n result.lastIndex = regexp.lastIndex;\n return result;\n}\n\n/**\n * Creates a clone of `set`.\n *\n * @private\n * @param {Object} set The set to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned set.\n */\nfunction cloneSet(set, isDeep, cloneFunc) {\n var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);\n return arrayReduce(array, addSetEntry, new set.constructor);\n}\n\n/**\n * Creates a clone of the `symbol` object.\n *\n * @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n */\nfunction cloneSymbol(symbol) {\n return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n}\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\n/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n var index = -1,\n length = source.length;\n\n array || (array = Array(length));\n while (++index < length) {\n array[index] = source[index];\n }\n return array;\n}\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n object || (object = {});\n\n var index = -1,\n length = props.length;\n\n while (++index < length) {\n var key = props[index];\n\n var newValue = customizer\n ? customizer(object[key], source[key], key, object, source)\n : undefined;\n\n assignValue(object, key, newValue === undefined ? source[key] : newValue);\n }\n return object;\n}\n\n/**\n * Copies own symbol properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbols(source, object) {\n return copyObject(source, getSymbols(source), object);\n}\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n return baseGetAllKeys(object, keys, getSymbols);\n}\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n var data = map.__data__;\n return isKeyable(key)\n ? data[typeof key == 'string' ? 'string' : 'hash']\n : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * Creates an array of the own enumerable symbol properties of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11,\n// for data views in Edge < 14, and promises in Node.js.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n (Map && getTag(new Map) != mapTag) ||\n (Promise && getTag(Promise.resolve()) != promiseTag) ||\n (Set && getTag(new Set) != setTag) ||\n (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n getTag = function(value) {\n var result = objectToString.call(value),\n Ctor = result == objectTag ? value.constructor : undefined,\n ctorString = Ctor ? toSource(Ctor) : undefined;\n\n if (ctorString) {\n switch (ctorString) {\n case dataViewCtorString: return dataViewTag;\n case mapCtorString: return mapTag;\n case promiseCtorString: return promiseTag;\n case setCtorString: return setTag;\n case weakMapCtorString: return weakMapTag;\n }\n }\n return result;\n };\n}\n\n/**\n * Initializes an array clone.\n *\n * @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n */\nfunction initCloneArray(array) {\n var length = array.length,\n result = array.constructor(length);\n\n // Add properties assigned by `RegExp#exec`.\n if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n result.index = array.index;\n result.input = array.input;\n }\n return result;\n}\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n return (typeof object.constructor == 'function' && !isPrototype(object))\n ? baseCreate(getPrototype(object))\n : {};\n}\n\n/**\n * Initializes an object clone based on its `toStringTag`.\n *\n * **Note:** This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneByTag(object, tag, cloneFunc, isDeep) {\n var Ctor = object.constructor;\n switch (tag) {\n case arrayBufferTag:\n return cloneArrayBuffer(object);\n\n case boolTag:\n case dateTag:\n return new Ctor(+object);\n\n case dataViewTag:\n return cloneDataView(object, isDeep);\n\n case float32Tag: case float64Tag:\n case int8Tag: case int16Tag: case int32Tag:\n case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n return cloneTypedArray(object, isDeep);\n\n case mapTag:\n return cloneMap(object, isDeep, cloneFunc);\n\n case numberTag:\n case stringTag:\n return new Ctor(object);\n\n case regexpTag:\n return cloneRegExp(object);\n\n case setTag:\n return cloneSet(object, isDeep, cloneFunc);\n\n case symbolTag:\n return cloneSymbol(object);\n }\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n length = length == null ? MAX_SAFE_INTEGER : length;\n return !!length &&\n (typeof value == 'number' || reIsUint.test(value)) &&\n (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n var type = typeof value;\n return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n ? (value !== '__proto__')\n : (value === null);\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n return value === proto;\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to process.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n}\n\n/**\n * This method is like `_.clone` except that it recursively clones `value`.\n *\n * @static\n * @memberOf _\n * @since 1.0.0\n * @category Lang\n * @param {*} value The value to recursively clone.\n * @returns {*} Returns the deep cloned value.\n * @see _.clone\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var deep = _.cloneDeep(objects);\n * console.log(deep[0] === objects[0]);\n * // => false\n */\nfunction cloneDeep(value) {\n return baseClone(value, true, true);\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n return value === other || (value !== value && other !== other);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nfunction isArguments(value) {\n // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\n}\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n * else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 8-9 which returns 'object' for typed array and other constructors.\n var tag = isObject(value) ? objectToString.call(value) : '';\n return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return !!value && typeof value == 'object';\n}\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n return [];\n}\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n return false;\n}\n\nmodule.exports = cloneDeep;\n","/**\n * Lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright JS Foundation and other contributors <https://js.foundation/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n asyncTag = '[object AsyncFunction]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n nullTag = '[object Null]',\n objectTag = '[object Object]',\n promiseTag = '[object Promise]',\n proxyTag = '[object Proxy]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n symbolTag = '[object Symbol]',\n undefinedTag = '[object Undefined]',\n weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n try {\n return freeProcess && freeProcess.binding && freeProcess.binding('util');\n } catch (e) {}\n}());\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length,\n resIndex = 0,\n result = [];\n\n while (++index < length) {\n var value = array[index];\n if (predicate(value, index, array)) {\n result[resIndex++] = value;\n }\n }\n return result;\n}\n\n/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n var index = -1,\n length = values.length,\n offset = array.length;\n\n while (++index < length) {\n array[offset + index] = values[index];\n }\n return array;\n}\n\n/**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n * else `false`.\n */\nfunction arraySome(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (predicate(array[index], index, array)) {\n return true;\n }\n }\n return false;\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n var index = -1,\n result = Array(n);\n\n while (++index < n) {\n result[index] = iteratee(index);\n }\n return result;\n}\n\n/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n return function(value) {\n return func(value);\n };\n}\n\n/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n return cache.has(key);\n}\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n return object == null ? undefined : object[key];\n}\n\n/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n var index = -1,\n result = Array(map.size);\n\n map.forEach(function(value, key) {\n result[++index] = [key, value];\n });\n return result;\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n}\n\n/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n var index = -1,\n result = Array(set.size);\n\n set.forEach(function(value) {\n result[++index] = value;\n });\n return result;\n}\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n Symbol = root.Symbol,\n Uint8Array = root.Uint8Array,\n propertyIsEnumerable = objectProto.propertyIsEnumerable,\n splice = arrayProto.splice,\n symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n nativeKeys = overArg(Object.keys, Object);\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView'),\n Map = getNative(root, 'Map'),\n Promise = getNative(root, 'Promise'),\n Set = getNative(root, 'Set'),\n WeakMap = getNative(root, 'WeakMap'),\n nativeCreate = getNative(Object, 'create');\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n mapCtorString = toSource(Map),\n promiseCtorString = toSource(Promise),\n setCtorString = toSource(Set),\n weakMapCtorString = toSource(WeakMap);\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n this.__data__ = nativeCreate ? nativeCreate(null) : {};\n this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n var result = this.has(key) && delete this.__data__[key];\n this.size -= result ? 1 : 0;\n return result;\n}\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n var data = this.__data__;\n if (nativeCreate) {\n var result = data[key];\n return result === HASH_UNDEFINED ? undefined : result;\n }\n return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n var data = this.__data__;\n return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n var data = this.__data__;\n this.size += this.has(key) ? 0 : 1;\n data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n this.__data__ = [];\n this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n return false;\n }\n var lastIndex = data.length - 1;\n if (index == lastIndex) {\n data.pop();\n } else {\n splice.call(data, index, 1);\n }\n --this.size;\n return true;\n}\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n return index < 0 ? undefined : data[index][1];\n}\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n return assocIndexOf(this.__data__, key) > -1;\n}\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n ++this.size;\n data.push([key, value]);\n } else {\n data[index][1] = value;\n }\n return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n this.size = 0;\n this.__data__ = {\n 'hash': new Hash,\n 'map': new (Map || ListCache),\n 'string': new Hash\n };\n}\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n var result = getMapData(this, key)['delete'](key);\n this.size -= result ? 1 : 0;\n return result;\n}\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n return getMapData(this, key).get(key);\n}\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n return getMapData(this, key).has(key);\n}\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n var data = getMapData(this, key),\n size = data.size;\n\n data.set(key, value);\n this.size += data.size == size ? 0 : 1;\n return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n var index = -1,\n length = values == null ? 0 : values.length;\n\n this.__data__ = new MapCache;\n while (++index < length) {\n this.add(values[index]);\n }\n}\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n this.__data__.set(value, HASH_UNDEFINED);\n return this;\n}\n\n/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n return this.__data__.has(value);\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n var data = this.__data__ = new ListCache(entries);\n this.size = data.size;\n}\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n this.__data__ = new ListCache;\n this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n var data = this.__data__,\n result = data['delete'](key);\n\n this.size = data.size;\n return result;\n}\n\n/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n return this.__data__.get(key);\n}\n\n/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n return this.__data__.has(key);\n}\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n var data = this.__data__;\n if (data instanceof ListCache) {\n var pairs = data.__data__;\n if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n pairs.push([key, value]);\n this.size = ++data.size;\n return this;\n }\n data = this.__data__ = new MapCache(pairs);\n }\n data.set(key, value);\n this.size = data.size;\n return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n var isArr = isArray(value),\n isArg = !isArr && isArguments(value),\n isBuff = !isArr && !isArg && isBuffer(value),\n isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n skipIndexes = isArr || isArg || isBuff || isType,\n result = skipIndexes ? baseTimes(value.length, String) : [],\n length = result.length;\n\n for (var key in value) {\n if ((inherited || hasOwnProperty.call(value, key)) &&\n !(skipIndexes && (\n // Safari 9 has enumerable `arguments.length` in strict mode.\n key == 'length' ||\n // Node.js 0.10 has enumerable non-index properties on buffers.\n (isBuff && (key == 'offset' || key == 'parent')) ||\n // PhantomJS 2 has enumerable non-index properties on typed arrays.\n (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n // Skip index properties.\n isIndex(key, length)\n ))) {\n result.push(key);\n }\n }\n return result;\n}\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n var length = array.length;\n while (length--) {\n if (eq(array[length][0], key)) {\n return length;\n }\n }\n return -1;\n}\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n var result = keysFunc(object);\n return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n if (value == null) {\n return value === undefined ? undefinedTag : nullTag;\n }\n return (symToStringTag && symToStringTag in Object(value))\n ? getRawTag(value)\n : objectToString(value);\n}\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\n/**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n * 1 - Unordered comparison\n * 2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, bitmask, customizer, stack) {\n if (value === other) {\n return true;\n }\n if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n return value !== value && other !== other;\n }\n return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n}\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n var objIsArr = isArray(object),\n othIsArr = isArray(other),\n objTag = objIsArr ? arrayTag : getTag(object),\n othTag = othIsArr ? arrayTag : getTag(other);\n\n objTag = objTag == argsTag ? objectTag : objTag;\n othTag = othTag == argsTag ? objectTag : othTag;\n\n var objIsObj = objTag == objectTag,\n othIsObj = othTag == objectTag,\n isSameTag = objTag == othTag;\n\n if (isSameTag && isBuffer(object)) {\n if (!isBuffer(other)) {\n return false;\n }\n objIsArr = true;\n objIsObj = false;\n }\n if (isSameTag && !objIsObj) {\n stack || (stack = new Stack);\n return (objIsArr || isTypedArray(object))\n ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n }\n if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n if (objIsWrapped || othIsWrapped) {\n var objUnwrapped = objIsWrapped ? object.value() : object,\n othUnwrapped = othIsWrapped ? other.value() : other;\n\n stack || (stack = new Stack);\n return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n }\n }\n if (!isSameTag) {\n return false;\n }\n stack || (stack = new Stack);\n return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n}\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n */\nfunction baseIsNative(value) {\n if (!isObject(value) || isMasked(value)) {\n return false;\n }\n var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n return isObjectLike(value) &&\n isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n if (!isPrototype(object)) {\n return nativeKeys(object);\n }\n var result = [];\n for (var key in Object(object)) {\n if (hasOwnProperty.call(object, key) && key != 'constructor') {\n result.push(key);\n }\n }\n return result;\n}\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n arrLength = array.length,\n othLength = other.length;\n\n if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n return false;\n }\n // Assume cyclic values are equal.\n var stacked = stack.get(array);\n if (stacked && stack.get(other)) {\n return stacked == other;\n }\n var index = -1,\n result = true,\n seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n stack.set(array, other);\n stack.set(other, array);\n\n // Ignore non-index properties.\n while (++index < arrLength) {\n var arrValue = array[index],\n othValue = other[index];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, arrValue, index, other, array, stack)\n : customizer(arrValue, othValue, index, array, other, stack);\n }\n if (compared !== undefined) {\n if (compared) {\n continue;\n }\n result = false;\n break;\n }\n // Recursively compare arrays (susceptible to call stack limits).\n if (seen) {\n if (!arraySome(other, function(othValue, othIndex) {\n if (!cacheHas(seen, othIndex) &&\n (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n return seen.push(othIndex);\n }\n })) {\n result = false;\n break;\n }\n } else if (!(\n arrValue === othValue ||\n equalFunc(arrValue, othValue, bitmask, customizer, stack)\n )) {\n result = false;\n break;\n }\n }\n stack['delete'](array);\n stack['delete'](other);\n return result;\n}\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n switch (tag) {\n case dataViewTag:\n if ((object.byteLength != other.byteLength) ||\n (object.byteOffset != other.byteOffset)) {\n return false;\n }\n object = object.buffer;\n other = other.buffer;\n\n case arrayBufferTag:\n if ((object.byteLength != other.byteLength) ||\n !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n return false;\n }\n return true;\n\n case boolTag:\n case dateTag:\n case numberTag:\n // Coerce booleans to `1` or `0` and dates to milliseconds.\n // Invalid dates are coerced to `NaN`.\n return eq(+object, +other);\n\n case errorTag:\n return object.name == other.name && object.message == other.message;\n\n case regexpTag:\n case stringTag:\n // Coerce regexes to strings and treat strings, primitives and objects,\n // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n // for more details.\n return object == (other + '');\n\n case mapTag:\n var convert = mapToArray;\n\n case setTag:\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n convert || (convert = setToArray);\n\n if (object.size != other.size && !isPartial) {\n return false;\n }\n // Assume cyclic values are equal.\n var stacked = stack.get(object);\n if (stacked) {\n return stacked == other;\n }\n bitmask |= COMPARE_UNORDERED_FLAG;\n\n // Recursively compare objects (susceptible to call stack limits).\n stack.set(object, other);\n var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n stack['delete'](object);\n return result;\n\n case symbolTag:\n if (symbolValueOf) {\n return symbolValueOf.call(object) == symbolValueOf.call(other);\n }\n }\n return false;\n}\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n objProps = getAllKeys(object),\n objLength = objProps.length,\n othProps = getAllKeys(other),\n othLength = othProps.length;\n\n if (objLength != othLength && !isPartial) {\n return false;\n }\n var index = objLength;\n while (index--) {\n var key = objProps[index];\n if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n return false;\n }\n }\n // Assume cyclic values are equal.\n var stacked = stack.get(object);\n if (stacked && stack.get(other)) {\n return stacked == other;\n }\n var result = true;\n stack.set(object, other);\n stack.set(other, object);\n\n var skipCtor = isPartial;\n while (++index < objLength) {\n key = objProps[index];\n var objValue = object[key],\n othValue = other[key];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, objValue, key, other, object, stack)\n : customizer(objValue, othValue, key, object, other, stack);\n }\n // Recursively compare objects (susceptible to call stack limits).\n if (!(compared === undefined\n ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n : compared\n )) {\n result = false;\n break;\n }\n skipCtor || (skipCtor = key == 'constructor');\n }\n if (result && !skipCtor) {\n var objCtor = object.constructor,\n othCtor = other.constructor;\n\n // Non `Object` object instances with different constructors are not equal.\n if (objCtor != othCtor &&\n ('constructor' in object && 'constructor' in other) &&\n !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n result = false;\n }\n }\n stack['delete'](object);\n stack['delete'](other);\n return result;\n}\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n return baseGetAllKeys(object, keys, getSymbols);\n}\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n var data = map.__data__;\n return isKeyable(key)\n ? data[typeof key == 'string' ? 'string' : 'hash']\n : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n var isOwn = hasOwnProperty.call(value, symToStringTag),\n tag = value[symToStringTag];\n\n try {\n value[symToStringTag] = undefined;\n var unmasked = true;\n } catch (e) {}\n\n var result = nativeObjectToString.call(value);\n if (unmasked) {\n if (isOwn) {\n value[symToStringTag] = tag;\n } else {\n delete value[symToStringTag];\n }\n }\n return result;\n}\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n if (object == null) {\n return [];\n }\n object = Object(object);\n return arrayFilter(nativeGetSymbols(object), function(symbol) {\n return propertyIsEnumerable.call(object, symbol);\n });\n};\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n (Map && getTag(new Map) != mapTag) ||\n (Promise && getTag(Promise.resolve()) != promiseTag) ||\n (Set && getTag(new Set) != setTag) ||\n (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n getTag = function(value) {\n var result = baseGetTag(value),\n Ctor = result == objectTag ? value.constructor : undefined,\n ctorString = Ctor ? toSource(Ctor) : '';\n\n if (ctorString) {\n switch (ctorString) {\n case dataViewCtorString: return dataViewTag;\n case mapCtorString: return mapTag;\n case promiseCtorString: return promiseTag;\n case setCtorString: return setTag;\n case weakMapCtorString: return weakMapTag;\n }\n }\n return result;\n };\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n length = length == null ? MAX_SAFE_INTEGER : length;\n return !!length &&\n (typeof value == 'number' || reIsUint.test(value)) &&\n (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n var type = typeof value;\n return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n ? (value !== '__proto__')\n : (value === null);\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n return value === proto;\n}\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n return nativeObjectToString.call(value);\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n return value === other || (value !== value && other !== other);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n !propertyIsEnumerable.call(value, 'callee');\n};\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n return baseIsEqual(value, other);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n if (!isObject(value)) {\n return false;\n }\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 9 which returns 'object' for typed arrays and other constructors.\n var tag = baseGetTag(value);\n return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return value != null && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return value != null && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n return [];\n}\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n return false;\n}\n\nmodule.exports = isEqual;\n","/**\n * Lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n HOT_SPAN = 16;\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n asyncTag = '[object AsyncFunction]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n nullTag = '[object Null]',\n objectTag = '[object Object]',\n proxyTag = '[object Proxy]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n undefinedTag = '[object Undefined]',\n weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n try {\n // Use `util.types` for Node.js 10+.\n var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n if (types) {\n return types;\n }\n\n // Legacy `process.binding('util')` for Node.js < 10.\n return freeProcess && freeProcess.binding && freeProcess.binding('util');\n } catch (e) {}\n}());\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n switch (args.length) {\n case 0: return func.call(thisArg);\n case 1: return func.call(thisArg, args[0]);\n case 2: return func.call(thisArg, args[0], args[1]);\n case 3: return func.call(thisArg, args[0], args[1], args[2]);\n }\n return func.apply(thisArg, args);\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n var index = -1,\n result = Array(n);\n\n while (++index < n) {\n result[index] = iteratee(index);\n }\n return result;\n}\n\n/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n return function(value) {\n return func(value);\n };\n}\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n return object == null ? undefined : object[key];\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n}\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n Symbol = root.Symbol,\n Uint8Array = root.Uint8Array,\n allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,\n getPrototype = overArg(Object.getPrototypeOf, Object),\n objectCreate = Object.create,\n propertyIsEnumerable = objectProto.propertyIsEnumerable,\n splice = arrayProto.splice,\n symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\nvar defineProperty = (function() {\n try {\n var func = getNative(Object, 'defineProperty');\n func({}, '', {});\n return func;\n } catch (e) {}\n}());\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n nativeMax = Math.max,\n nativeNow = Date.now;\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map'),\n nativeCreate = getNative(Object, 'create');\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n function object() {}\n return function(proto) {\n if (!isObject(proto)) {\n return {};\n }\n if (objectCreate) {\n return objectCreate(proto);\n }\n object.prototype = proto;\n var result = new object;\n object.prototype = undefined;\n return result;\n };\n}());\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n this.__data__ = nativeCreate ? nativeCreate(null) : {};\n this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n var result = this.has(key) && delete this.__data__[key];\n this.size -= result ? 1 : 0;\n return result;\n}\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n var data = this.__data__;\n if (nativeCreate) {\n var result = data[key];\n return result === HASH_UNDEFINED ? undefined : result;\n }\n return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n var data = this.__data__;\n return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n var data = this.__data__;\n this.size += this.has(key) ? 0 : 1;\n data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n this.__data__ = [];\n this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n return false;\n }\n var lastIndex = data.length - 1;\n if (index == lastIndex) {\n data.pop();\n } else {\n splice.call(data, index, 1);\n }\n --this.size;\n return true;\n}\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n return index < 0 ? undefined : data[index][1];\n}\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n return assocIndexOf(this.__data__, key) > -1;\n}\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n ++this.size;\n data.push([key, value]);\n } else {\n data[index][1] = value;\n }\n return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n this.size = 0;\n this.__data__ = {\n 'hash': new Hash,\n 'map': new (Map || ListCache),\n 'string': new Hash\n };\n}\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n var result = getMapData(this, key)['delete'](key);\n this.size -= result ? 1 : 0;\n return result;\n}\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n return getMapData(this, key).get(key);\n}\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n return getMapData(this, key).has(key);\n}\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n var data = getMapData(this, key),\n size = data.size;\n\n data.set(key, value);\n this.size += data.size == size ? 0 : 1;\n return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n var data = this.__data__ = new ListCache(entries);\n this.size = data.size;\n}\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n this.__data__ = new ListCache;\n this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n var data = this.__data__,\n result = data['delete'](key);\n\n this.size = data.size;\n return result;\n}\n\n/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n return this.__data__.get(key);\n}\n\n/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n return this.__data__.has(key);\n}\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n var data = this.__data__;\n if (data instanceof ListCache) {\n var pairs = data.__data__;\n if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n pairs.push([key, value]);\n this.size = ++data.size;\n return this;\n }\n data = this.__data__ = new MapCache(pairs);\n }\n data.set(key, value);\n this.size = data.size;\n return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n var isArr = isArray(value),\n isArg = !isArr && isArguments(value),\n isBuff = !isArr && !isArg && isBuffer(value),\n isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n skipIndexes = isArr || isArg || isBuff || isType,\n result = skipIndexes ? baseTimes(value.length, String) : [],\n length = result.length;\n\n for (var key in value) {\n if ((inherited || hasOwnProperty.call(value, key)) &&\n !(skipIndexes && (\n // Safari 9 has enumerable `arguments.length` in strict mode.\n key == 'length' ||\n // Node.js 0.10 has enumerable non-index properties on buffers.\n (isBuff && (key == 'offset' || key == 'parent')) ||\n // PhantomJS 2 has enumerable non-index properties on typed arrays.\n (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n // Skip index properties.\n isIndex(key, length)\n ))) {\n result.push(key);\n }\n }\n return result;\n}\n\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n if ((value !== undefined && !eq(object[key], value)) ||\n (value === undefined && !(key in object))) {\n baseAssignValue(object, key, value);\n }\n}\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n var objValue = object[key];\n if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n (value === undefined && !(key in object))) {\n baseAssignValue(object, key, value);\n }\n}\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n var length = array.length;\n while (length--) {\n if (eq(array[length][0], key)) {\n return length;\n }\n }\n return -1;\n}\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n if (key == '__proto__' && defineProperty) {\n defineProperty(object, key, {\n 'configurable': true,\n 'enumerable': true,\n 'value': value,\n 'writable': true\n });\n } else {\n object[key] = value;\n }\n}\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n if (value == null) {\n return value === undefined ? undefinedTag : nullTag;\n }\n return (symToStringTag && symToStringTag in Object(value))\n ? getRawTag(value)\n : objectToString(value);\n}\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n */\nfunction baseIsNative(value) {\n if (!isObject(value) || isMasked(value)) {\n return false;\n }\n var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n return isObjectLike(value) &&\n isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n if (!isObject(object)) {\n return nativeKeysIn(object);\n }\n var isProto = isPrototype(object),\n result = [];\n\n for (var key in object) {\n if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n result.push(key);\n }\n }\n return result;\n}\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n if (object === source) {\n return;\n }\n baseFor(source, function(srcValue, key) {\n stack || (stack = new Stack);\n if (isObject(srcValue)) {\n baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n }\n else {\n var newValue = customizer\n ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n : undefined;\n\n if (newValue === undefined) {\n newValue = srcValue;\n }\n assignMergeValue(object, key, newValue);\n }\n }, keysIn);\n}\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n var objValue = safeGet(object, key),\n srcValue = safeGet(source, key),\n stacked = stack.get(srcValue);\n\n if (stacked) {\n assignMergeValue(object, key, stacked);\n return;\n }\n var newValue = customizer\n ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n : undefined;\n\n var isCommon = newValue === undefined;\n\n if (isCommon) {\n var isArr = isArray(srcValue),\n isBuff = !isArr && isBuffer(srcValue),\n isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n newValue = srcValue;\n if (isArr || isBuff || isTyped) {\n if (isArray(objValue)) {\n newValue = objValue;\n }\n else if (isArrayLikeObject(objValue)) {\n newValue = copyArray(objValue);\n }\n else if (isBuff) {\n isCommon = false;\n newValue = cloneBuffer(srcValue, true);\n }\n else if (isTyped) {\n isCommon = false;\n newValue = cloneTypedArray(srcValue, true);\n }\n else {\n newValue = [];\n }\n }\n else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n newValue = objValue;\n if (isArguments(objValue)) {\n newValue = toPlainObject(objValue);\n }\n else if (!isObject(objValue) || isFunction(objValue)) {\n newValue = initCloneObject(srcValue);\n }\n }\n else {\n isCommon = false;\n }\n }\n if (isCommon) {\n // Recursively merge objects and arrays (susceptible to call stack limits).\n stack.set(srcValue, newValue);\n mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n stack['delete'](srcValue);\n }\n assignMergeValue(object, key, newValue);\n}\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n return setToString(overRest(func, start, identity), func + '');\n}\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n return defineProperty(func, 'toString', {\n 'configurable': true,\n 'enumerable': false,\n 'value': constant(string),\n 'writable': true\n });\n};\n\n/**\n * Creates a clone of `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n if (isDeep) {\n return buffer.slice();\n }\n var length = buffer.length,\n result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n buffer.copy(result);\n return result;\n}\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n return result;\n}\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\n/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n var index = -1,\n length = source.length;\n\n array || (array = Array(length));\n while (++index < length) {\n array[index] = source[index];\n }\n return array;\n}\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n var isNew = !object;\n object || (object = {});\n\n var index = -1,\n length = props.length;\n\n while (++index < length) {\n var key = props[index];\n\n var newValue = customizer\n ? customizer(object[key], source[key], key, object, source)\n : undefined;\n\n if (newValue === undefined) {\n newValue = source[key];\n }\n if (isNew) {\n baseAssignValue(object, key, newValue);\n } else {\n assignValue(object, key, newValue);\n }\n }\n return object;\n}\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n return baseRest(function(object, sources) {\n var index = -1,\n length = sources.length,\n customizer = length > 1 ? sources[length - 1] : undefined,\n guard = length > 2 ? sources[2] : undefined;\n\n customizer = (assigner.length > 3 && typeof customizer == 'function')\n ? (length--, customizer)\n : undefined;\n\n if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n customizer = length < 3 ? undefined : customizer;\n length = 1;\n }\n object = Object(object);\n while (++index < length) {\n var source = sources[index];\n if (source) {\n assigner(object, source, index, customizer);\n }\n }\n return object;\n });\n}\n\n/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n return function(object, iteratee, keysFunc) {\n var index = -1,\n iterable = Object(object),\n props = keysFunc(object),\n length = props.length;\n\n while (length--) {\n var key = props[fromRight ? length : ++index];\n if (iteratee(iterable[key], key, iterable) === false) {\n break;\n }\n }\n return object;\n };\n}\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n var data = map.__data__;\n return isKeyable(key)\n ? data[typeof key == 'string' ? 'string' : 'hash']\n : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n var isOwn = hasOwnProperty.call(value, symToStringTag),\n tag = value[symToStringTag];\n\n try {\n value[symToStringTag] = undefined;\n var unmasked = true;\n } catch (e) {}\n\n var result = nativeObjectToString.call(value);\n if (unmasked) {\n if (isOwn) {\n value[symToStringTag] = tag;\n } else {\n delete value[symToStringTag];\n }\n }\n return result;\n}\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n return (typeof object.constructor == 'function' && !isPrototype(object))\n ? baseCreate(getPrototype(object))\n : {};\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n var type = typeof value;\n length = length == null ? MAX_SAFE_INTEGER : length;\n\n return !!length &&\n (type == 'number' ||\n (type != 'symbol' && reIsUint.test(value))) &&\n (value > -1 && value % 1 == 0 && value < length);\n}\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n * else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n if (!isObject(object)) {\n return false;\n }\n var type = typeof index;\n if (type == 'number'\n ? (isArrayLike(object) && isIndex(index, object.length))\n : (type == 'string' && index in object)\n ) {\n return eq(object[index], value);\n }\n return false;\n}\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n var type = typeof value;\n return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n ? (value !== '__proto__')\n : (value === null);\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n return value === proto;\n}\n\n/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n var result = [];\n if (object != null) {\n for (var key in Object(object)) {\n result.push(key);\n }\n }\n return result;\n}\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n return nativeObjectToString.call(value);\n}\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n return function() {\n var args = arguments,\n index = -1,\n length = nativeMax(args.length - start, 0),\n array = Array(length);\n\n while (++index < length) {\n array[index] = args[start + index];\n }\n index = -1;\n var otherArgs = Array(start + 1);\n while (++index < start) {\n otherArgs[index] = args[index];\n }\n otherArgs[start] = transform(array);\n return apply(func, this, otherArgs);\n };\n}\n\n/**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction safeGet(object, key) {\n if (key === 'constructor' && typeof object[key] === 'function') {\n return;\n }\n\n if (key == '__proto__') {\n return;\n }\n\n return object[key];\n}\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n var count = 0,\n lastCalled = 0;\n\n return function() {\n var stamp = nativeNow(),\n remaining = HOT_SPAN - (stamp - lastCalled);\n\n lastCalled = stamp;\n if (remaining > 0) {\n if (++count >= HOT_COUNT) {\n return arguments[0];\n }\n } else {\n count = 0;\n }\n return func.apply(undefined, arguments);\n };\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n return value === other || (value !== value && other !== other);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n !propertyIsEnumerable.call(value, 'callee');\n};\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n * else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n if (!isObject(value)) {\n return false;\n }\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 9 which returns 'object' for typed arrays and other constructors.\n var tag = baseGetTag(value);\n return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return value != null && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return value != null && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n return false;\n }\n var proto = getPrototype(value);\n if (proto === null) {\n return true;\n }\n var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n funcToString.call(Ctor) == objectCtorString;\n}\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n/**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n return copyObject(value, keysIn(value));\n}\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\n/**\n * This method is like `_.assign` except that it recursively merges own and\n * inherited enumerable string keyed properties of source objects into the\n * destination object. Source properties that resolve to `undefined` are\n * skipped if a destination value exists. Array and plain object properties\n * are merged recursively. Other objects and value types are overridden by\n * assignment. Source objects are applied from left to right. Subsequent\n * sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {\n * 'a': [{ 'b': 2 }, { 'd': 4 }]\n * };\n *\n * var other = {\n * 'a': [{ 'c': 3 }, { 'e': 5 }]\n * };\n *\n * _.merge(object, other);\n * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n */\nvar merge = createAssigner(function(object, source, srcIndex) {\n baseMerge(object, source, srcIndex);\n});\n\n/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n return function() {\n return value;\n };\n}\n\n/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n return value;\n}\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n return false;\n}\n\nmodule.exports = merge;\n","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Parchment\"] = factory();\n\telse\n\t\troot[\"Parchment\"] = factory();\n})(typeof self !== 'undefined' ? self : this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 9);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 3c334e19bc1efdeb80ab","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar ParchmentError = /** @class */ (function (_super) {\n __extends(ParchmentError, _super);\n function ParchmentError(message) {\n var _this = this;\n message = '[Parchment] ' + message;\n _this = _super.call(this, message) || this;\n _this.message = message;\n _this.name = _this.constructor.name;\n return _this;\n }\n return ParchmentError;\n}(Error));\nexports.ParchmentError = ParchmentError;\nvar attributes = {};\nvar classes = {};\nvar tags = {};\nvar types = {};\nexports.DATA_KEY = '__blot';\nvar Scope;\n(function (Scope) {\n Scope[Scope[\"TYPE\"] = 3] = \"TYPE\";\n Scope[Scope[\"LEVEL\"] = 12] = \"LEVEL\";\n Scope[Scope[\"ATTRIBUTE\"] = 13] = \"ATTRIBUTE\";\n Scope[Scope[\"BLOT\"] = 14] = \"BLOT\";\n Scope[Scope[\"INLINE\"] = 7] = \"INLINE\";\n Scope[Scope[\"BLOCK\"] = 11] = \"BLOCK\";\n Scope[Scope[\"BLOCK_BLOT\"] = 10] = \"BLOCK_BLOT\";\n Scope[Scope[\"INLINE_BLOT\"] = 6] = \"INLINE_BLOT\";\n Scope[Scope[\"BLOCK_ATTRIBUTE\"] = 9] = \"BLOCK_ATTRIBUTE\";\n Scope[Scope[\"INLINE_ATTRIBUTE\"] = 5] = \"INLINE_ATTRIBUTE\";\n Scope[Scope[\"ANY\"] = 15] = \"ANY\";\n})(Scope = exports.Scope || (exports.Scope = {}));\nfunction create(input, value) {\n var match = query(input);\n if (match == null) {\n throw new ParchmentError(\"Unable to create \" + input + \" blot\");\n }\n var BlotClass = match;\n var node = \n // @ts-ignore\n input instanceof Node || input['nodeType'] === Node.TEXT_NODE ? input : BlotClass.create(value);\n return new BlotClass(node, value);\n}\nexports.create = create;\nfunction find(node, bubble) {\n if (bubble === void 0) { bubble = false; }\n if (node == null)\n return null;\n // @ts-ignore\n if (node[exports.DATA_KEY] != null)\n return node[exports.DATA_KEY].blot;\n if (bubble)\n return find(node.parentNode, bubble);\n return null;\n}\nexports.find = find;\nfunction query(query, scope) {\n if (scope === void 0) { scope = Scope.ANY; }\n var match;\n if (typeof query === 'string') {\n match = types[query] || attributes[query];\n // @ts-ignore\n }\n else if (query instanceof Text || query['nodeType'] === Node.TEXT_NODE) {\n match = types['text'];\n }\n else if (typeof query === 'number') {\n if (query & Scope.LEVEL & Scope.BLOCK) {\n match = types['block'];\n }\n else if (query & Scope.LEVEL & Scope.INLINE) {\n match = types['inline'];\n }\n }\n else if (query instanceof HTMLElement) {\n var names = (query.getAttribute('class') || '').split(/\\s+/);\n for (var i in names) {\n match = classes[names[i]];\n if (match)\n break;\n }\n match = match || tags[query.tagName];\n }\n if (match == null)\n return null;\n // @ts-ignore\n if (scope & Scope.LEVEL & match.scope && scope & Scope.TYPE & match.scope)\n return match;\n return null;\n}\nexports.query = query;\nfunction register() {\n var Definitions = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n Definitions[_i] = arguments[_i];\n }\n if (Definitions.length > 1) {\n return Definitions.map(function (d) {\n return register(d);\n });\n }\n var Definition = Definitions[0];\n if (typeof Definition.blotName !== 'string' && typeof Definition.attrName !== 'string') {\n throw new ParchmentError('Invalid definition');\n }\n else if (Definition.blotName === 'abstract') {\n throw new ParchmentError('Cannot register abstract class');\n }\n types[Definition.blotName || Definition.attrName] = Definition;\n if (typeof Definition.keyName === 'string') {\n attributes[Definition.keyName] = Definition;\n }\n else {\n if (Definition.className != null) {\n classes[Definition.className] = Definition;\n }\n if (Definition.tagName != null) {\n if (Array.isArray(Definition.tagName)) {\n Definition.tagName = Definition.tagName.map(function (tagName) {\n return tagName.toUpperCase();\n });\n }\n else {\n Definition.tagName = Definition.tagName.toUpperCase();\n }\n var tagNames = Array.isArray(Definition.tagName) ? Definition.tagName : [Definition.tagName];\n tagNames.forEach(function (tag) {\n if (tags[tag] == null || Definition.className == null) {\n tags[tag] = Definition;\n }\n });\n }\n }\n return Definition;\n}\nexports.register = register;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/registry.ts\n// module id = 0\n// module chunks = 0","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Registry = require(\"../registry\");\nvar Attributor = /** @class */ (function () {\n function Attributor(attrName, keyName, options) {\n if (options === void 0) { options = {}; }\n this.attrName = attrName;\n this.keyName = keyName;\n var attributeBit = Registry.Scope.TYPE & Registry.Scope.ATTRIBUTE;\n if (options.scope != null) {\n // Ignore type bits, force attribute bit\n this.scope = (options.scope & Registry.Scope.LEVEL) | attributeBit;\n }\n else {\n this.scope = Registry.Scope.ATTRIBUTE;\n }\n if (options.whitelist != null)\n this.whitelist = options.whitelist;\n }\n Attributor.keys = function (node) {\n return [].map.call(node.attributes, function (item) {\n return item.name;\n });\n };\n Attributor.prototype.add = function (node, value) {\n if (!this.canAdd(node, value))\n return false;\n node.setAttribute(this.keyName, value);\n return true;\n };\n Attributor.prototype.canAdd = function (node, value) {\n var match = Registry.query(node, Registry.Scope.BLOT & (this.scope | Registry.Scope.TYPE));\n if (match == null)\n return false;\n if (this.whitelist == null)\n return true;\n if (typeof value === 'string') {\n return this.whitelist.indexOf(value.replace(/[\"']/g, '')) > -1;\n }\n else {\n return this.whitelist.indexOf(value) > -1;\n }\n };\n Attributor.prototype.remove = function (node) {\n node.removeAttribute(this.keyName);\n };\n Attributor.prototype.value = function (node) {\n var value = node.getAttribute(this.keyName);\n if (this.canAdd(node, value) && value) {\n return value;\n }\n return '';\n };\n return Attributor;\n}());\nexports.default = Attributor;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/attributor/attributor.ts\n// module id = 1\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar linked_list_1 = require(\"../../collection/linked-list\");\nvar shadow_1 = require(\"./shadow\");\nvar Registry = require(\"../../registry\");\nvar ContainerBlot = /** @class */ (function (_super) {\n __extends(ContainerBlot, _super);\n function ContainerBlot(domNode) {\n var _this = _super.call(this, domNode) || this;\n _this.build();\n return _this;\n }\n ContainerBlot.prototype.appendChild = function (other) {\n this.insertBefore(other);\n };\n ContainerBlot.prototype.attach = function () {\n _super.prototype.attach.call(this);\n this.children.forEach(function (child) {\n child.attach();\n });\n };\n ContainerBlot.prototype.build = function () {\n var _this = this;\n this.children = new linked_list_1.default();\n // Need to be reversed for if DOM nodes already in order\n [].slice\n .call(this.domNode.childNodes)\n .reverse()\n .forEach(function (node) {\n try {\n var child = makeBlot(node);\n _this.insertBefore(child, _this.children.head || undefined);\n }\n catch (err) {\n if (err instanceof Registry.ParchmentError)\n return;\n else\n throw err;\n }\n });\n };\n ContainerBlot.prototype.deleteAt = function (index, length) {\n if (index === 0 && length === this.length()) {\n return this.remove();\n }\n this.children.forEachAt(index, length, function (child, offset, length) {\n child.deleteAt(offset, length);\n });\n };\n ContainerBlot.prototype.descendant = function (criteria, index) {\n var _a = this.children.find(index), child = _a[0], offset = _a[1];\n if ((criteria.blotName == null && criteria(child)) ||\n (criteria.blotName != null && child instanceof criteria)) {\n return [child, offset];\n }\n else if (child instanceof ContainerBlot) {\n return child.descendant(criteria, offset);\n }\n else {\n return [null, -1];\n }\n };\n ContainerBlot.prototype.descendants = function (criteria, index, length) {\n if (index === void 0) { index = 0; }\n if (length === void 0) { length = Number.MAX_VALUE; }\n var descendants = [];\n var lengthLeft = length;\n this.children.forEachAt(index, length, function (child, index, length) {\n if ((criteria.blotName == null && criteria(child)) ||\n (criteria.blotName != null && child instanceof criteria)) {\n descendants.push(child);\n }\n if (child instanceof ContainerBlot) {\n descendants = descendants.concat(child.descendants(criteria, index, lengthLeft));\n }\n lengthLeft -= length;\n });\n return descendants;\n };\n ContainerBlot.prototype.detach = function () {\n this.children.forEach(function (child) {\n child.detach();\n });\n _super.prototype.detach.call(this);\n };\n ContainerBlot.prototype.formatAt = function (index, length, name, value) {\n this.children.forEachAt(index, length, function (child, offset, length) {\n child.formatAt(offset, length, name, value);\n });\n };\n ContainerBlot.prototype.insertAt = function (index, value, def) {\n var _a = this.children.find(index), child = _a[0], offset = _a[1];\n if (child) {\n child.insertAt(offset, value, def);\n }\n else {\n var blot = def == null ? Registry.create('text', value) : Registry.create(value, def);\n this.appendChild(blot);\n }\n };\n ContainerBlot.prototype.insertBefore = function (childBlot, refBlot) {\n if (this.statics.allowedChildren != null &&\n !this.statics.allowedChildren.some(function (child) {\n return childBlot instanceof child;\n })) {\n throw new Registry.ParchmentError(\"Cannot insert \" + childBlot.statics.blotName + \" into \" + this.statics.blotName);\n }\n childBlot.insertInto(this, refBlot);\n };\n ContainerBlot.prototype.length = function () {\n return this.children.reduce(function (memo, child) {\n return memo + child.length();\n }, 0);\n };\n ContainerBlot.prototype.moveChildren = function (targetParent, refNode) {\n this.children.forEach(function (child) {\n targetParent.insertBefore(child, refNode);\n });\n };\n ContainerBlot.prototype.optimize = function (context) {\n _super.prototype.optimize.call(this, context);\n if (this.children.length === 0) {\n if (this.statics.defaultChild != null) {\n var child = Registry.create(this.statics.defaultChild);\n this.appendChild(child);\n child.optimize(context);\n }\n else {\n this.remove();\n }\n }\n };\n ContainerBlot.prototype.path = function (index, inclusive) {\n if (inclusive === void 0) { inclusive = false; }\n var _a = this.children.find(index, inclusive), child = _a[0], offset = _a[1];\n var position = [[this, index]];\n if (child instanceof ContainerBlot) {\n return position.concat(child.path(offset, inclusive));\n }\n else if (child != null) {\n position.push([child, offset]);\n }\n return position;\n };\n ContainerBlot.prototype.removeChild = function (child) {\n this.children.remove(child);\n };\n ContainerBlot.prototype.replace = function (target) {\n if (target instanceof ContainerBlot) {\n target.moveChildren(this);\n }\n _super.prototype.replace.call(this, target);\n };\n ContainerBlot.prototype.split = function (index, force) {\n if (force === void 0) { force = false; }\n if (!force) {\n if (index === 0)\n return this;\n if (index === this.length())\n return this.next;\n }\n var after = this.clone();\n this.parent.insertBefore(after, this.next);\n this.children.forEachAt(index, this.length(), function (child, offset, length) {\n child = child.split(offset, force);\n after.appendChild(child);\n });\n return after;\n };\n ContainerBlot.prototype.unwrap = function () {\n this.moveChildren(this.parent, this.next);\n this.remove();\n };\n ContainerBlot.prototype.update = function (mutations, context) {\n var _this = this;\n var addedNodes = [];\n var removedNodes = [];\n mutations.forEach(function (mutation) {\n if (mutation.target === _this.domNode && mutation.type === 'childList') {\n addedNodes.push.apply(addedNodes, mutation.addedNodes);\n removedNodes.push.apply(removedNodes, mutation.removedNodes);\n }\n });\n removedNodes.forEach(function (node) {\n // Check node has actually been removed\n // One exception is Chrome does not immediately remove IFRAMEs\n // from DOM but MutationRecord is correct in its reported removal\n if (node.parentNode != null &&\n // @ts-ignore\n node.tagName !== 'IFRAME' &&\n document.body.compareDocumentPosition(node) & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n return;\n }\n var blot = Registry.find(node);\n if (blot == null)\n return;\n if (blot.domNode.parentNode == null || blot.domNode.parentNode === _this.domNode) {\n blot.detach();\n }\n });\n addedNodes\n .filter(function (node) {\n return node.parentNode == _this.domNode;\n })\n .sort(function (a, b) {\n if (a === b)\n return 0;\n if (a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING) {\n return 1;\n }\n return -1;\n })\n .forEach(function (node) {\n var refBlot = null;\n if (node.nextSibling != null) {\n refBlot = Registry.find(node.nextSibling);\n }\n var blot = makeBlot(node);\n if (blot.next != refBlot || blot.next == null) {\n if (blot.parent != null) {\n blot.parent.removeChild(_this);\n }\n _this.insertBefore(blot, refBlot || undefined);\n }\n });\n };\n return ContainerBlot;\n}(shadow_1.default));\nfunction makeBlot(node) {\n var blot = Registry.find(node);\n if (blot == null) {\n try {\n blot = Registry.create(node);\n }\n catch (e) {\n blot = Registry.create(Registry.Scope.INLINE);\n [].slice.call(node.childNodes).forEach(function (child) {\n // @ts-ignore\n blot.domNode.appendChild(child);\n });\n if (node.parentNode) {\n node.parentNode.replaceChild(blot.domNode, node);\n }\n blot.attach();\n }\n }\n return blot;\n}\nexports.default = ContainerBlot;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/blot/abstract/container.ts\n// module id = 2\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar attributor_1 = require(\"../../attributor/attributor\");\nvar store_1 = require(\"../../attributor/store\");\nvar container_1 = require(\"./container\");\nvar Registry = require(\"../../registry\");\nvar FormatBlot = /** @class */ (function (_super) {\n __extends(FormatBlot, _super);\n function FormatBlot(domNode) {\n var _this = _super.call(this, domNode) || this;\n _this.attributes = new store_1.default(_this.domNode);\n return _this;\n }\n FormatBlot.formats = function (domNode) {\n if (typeof this.tagName === 'string') {\n return true;\n }\n else if (Array.isArray(this.tagName)) {\n return domNode.tagName.toLowerCase();\n }\n return undefined;\n };\n FormatBlot.prototype.format = function (name, value) {\n var format = Registry.query(name);\n if (format instanceof attributor_1.default) {\n this.attributes.attribute(format, value);\n }\n else if (value) {\n if (format != null && (name !== this.statics.blotName || this.formats()[name] !== value)) {\n this.replaceWith(name, value);\n }\n }\n };\n FormatBlot.prototype.formats = function () {\n var formats = this.attributes.values();\n var format = this.statics.formats(this.domNode);\n if (format != null) {\n formats[this.statics.blotName] = format;\n }\n return formats;\n };\n FormatBlot.prototype.replaceWith = function (name, value) {\n var replacement = _super.prototype.replaceWith.call(this, name, value);\n this.attributes.copy(replacement);\n return replacement;\n };\n FormatBlot.prototype.update = function (mutations, context) {\n var _this = this;\n _super.prototype.update.call(this, mutations, context);\n if (mutations.some(function (mutation) {\n return mutation.target === _this.domNode && mutation.type === 'attributes';\n })) {\n this.attributes.build();\n }\n };\n FormatBlot.prototype.wrap = function (name, value) {\n var wrapper = _super.prototype.wrap.call(this, name, value);\n if (wrapper instanceof FormatBlot && wrapper.statics.scope === this.statics.scope) {\n this.attributes.move(wrapper);\n }\n return wrapper;\n };\n return FormatBlot;\n}(container_1.default));\nexports.default = FormatBlot;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/blot/abstract/format.ts\n// module id = 3\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar shadow_1 = require(\"./shadow\");\nvar Registry = require(\"../../registry\");\nvar LeafBlot = /** @class */ (function (_super) {\n __extends(LeafBlot, _super);\n function LeafBlot() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n LeafBlot.value = function (domNode) {\n return true;\n };\n LeafBlot.prototype.index = function (node, offset) {\n if (this.domNode === node ||\n this.domNode.compareDocumentPosition(node) & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n return Math.min(offset, 1);\n }\n return -1;\n };\n LeafBlot.prototype.position = function (index, inclusive) {\n var offset = [].indexOf.call(this.parent.domNode.childNodes, this.domNode);\n if (index > 0)\n offset += 1;\n return [this.parent.domNode, offset];\n };\n LeafBlot.prototype.value = function () {\n return _a = {}, _a[this.statics.blotName] = this.statics.value(this.domNode) || true, _a;\n var _a;\n };\n LeafBlot.scope = Registry.Scope.INLINE_BLOT;\n return LeafBlot;\n}(shadow_1.default));\nexports.default = LeafBlot;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/blot/abstract/leaf.ts\n// module id = 4\n// module chunks = 0","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Registry = require(\"../../registry\");\nvar ShadowBlot = /** @class */ (function () {\n function ShadowBlot(domNode) {\n this.domNode = domNode;\n // @ts-ignore\n this.domNode[Registry.DATA_KEY] = { blot: this };\n }\n Object.defineProperty(ShadowBlot.prototype, \"statics\", {\n // Hack for accessing inherited static methods\n get: function () {\n return this.constructor;\n },\n enumerable: true,\n configurable: true\n });\n ShadowBlot.create = function (value) {\n if (this.tagName == null) {\n throw new Registry.ParchmentError('Blot definition missing tagName');\n }\n var node;\n if (Array.isArray(this.tagName)) {\n if (typeof value === 'string') {\n value = value.toUpperCase();\n if (parseInt(value).toString() === value) {\n value = parseInt(value);\n }\n }\n if (typeof value === 'number') {\n node = document.createElement(this.tagName[value - 1]);\n }\n else if (this.tagName.indexOf(value) > -1) {\n node = document.createElement(value);\n }\n else {\n node = document.createElement(this.tagName[0]);\n }\n }\n else {\n node = document.createElement(this.tagName);\n }\n if (this.className) {\n node.classList.add(this.className);\n }\n return node;\n };\n ShadowBlot.prototype.attach = function () {\n if (this.parent != null) {\n this.scroll = this.parent.scroll;\n }\n };\n ShadowBlot.prototype.clone = function () {\n var domNode = this.domNode.cloneNode(false);\n return Registry.create(domNode);\n };\n ShadowBlot.prototype.detach = function () {\n if (this.parent != null)\n this.parent.removeChild(this);\n // @ts-ignore\n delete this.domNode[Registry.DATA_KEY];\n };\n ShadowBlot.prototype.deleteAt = function (index, length) {\n var blot = this.isolate(index, length);\n blot.remove();\n };\n ShadowBlot.prototype.formatAt = function (index, length, name, value) {\n var blot = this.isolate(index, length);\n if (Registry.query(name, Registry.Scope.BLOT) != null && value) {\n blot.wrap(name, value);\n }\n else if (Registry.query(name, Registry.Scope.ATTRIBUTE) != null) {\n var parent_1 = Registry.create(this.statics.scope);\n blot.wrap(parent_1);\n parent_1.format(name, value);\n }\n };\n ShadowBlot.prototype.insertAt = function (index, value, def) {\n var blot = def == null ? Registry.create('text', value) : Registry.create(value, def);\n var ref = this.split(index);\n this.parent.insertBefore(blot, ref);\n };\n ShadowBlot.prototype.insertInto = function (parentBlot, refBlot) {\n if (refBlot === void 0) { refBlot = null; }\n if (this.parent != null) {\n this.parent.children.remove(this);\n }\n var refDomNode = null;\n parentBlot.children.insertBefore(this, refBlot);\n if (refBlot != null) {\n refDomNode = refBlot.domNode;\n }\n if (this.domNode.parentNode != parentBlot.domNode ||\n this.domNode.nextSibling != refDomNode) {\n parentBlot.domNode.insertBefore(this.domNode, refDomNode);\n }\n this.parent = parentBlot;\n this.attach();\n };\n ShadowBlot.prototype.isolate = function (index, length) {\n var target = this.split(index);\n target.split(length);\n return target;\n };\n ShadowBlot.prototype.length = function () {\n return 1;\n };\n ShadowBlot.prototype.offset = function (root) {\n if (root === void 0) { root = this.parent; }\n if (this.parent == null || this == root)\n return 0;\n return this.parent.children.offset(this) + this.parent.offset(root);\n };\n ShadowBlot.prototype.optimize = function (context) {\n // TODO clean up once we use WeakMap\n // @ts-ignore\n if (this.domNode[Registry.DATA_KEY] != null) {\n // @ts-ignore\n delete this.domNode[Registry.DATA_KEY].mutations;\n }\n };\n ShadowBlot.prototype.remove = function () {\n if (this.domNode.parentNode != null) {\n this.domNode.parentNode.removeChild(this.domNode);\n }\n this.detach();\n };\n ShadowBlot.prototype.replace = function (target) {\n if (target.parent == null)\n return;\n target.parent.insertBefore(this, target.next);\n target.remove();\n };\n ShadowBlot.prototype.replaceWith = function (name, value) {\n var replacement = typeof name === 'string' ? Registry.create(name, value) : name;\n replacement.replace(this);\n return replacement;\n };\n ShadowBlot.prototype.split = function (index, force) {\n return index === 0 ? this : this.next;\n };\n ShadowBlot.prototype.update = function (mutations, context) {\n // Nothing to do by default\n };\n ShadowBlot.prototype.wrap = function (name, value) {\n var wrapper = typeof name === 'string' ? Registry.create(name, value) : name;\n if (this.parent != null) {\n this.parent.insertBefore(wrapper, this.next);\n }\n wrapper.appendChild(this);\n return wrapper;\n };\n ShadowBlot.blotName = 'abstract';\n return ShadowBlot;\n}());\nexports.default = ShadowBlot;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/blot/abstract/shadow.ts\n// module id = 5\n// module chunks = 0","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar attributor_1 = require(\"./attributor\");\nvar class_1 = require(\"./class\");\nvar style_1 = require(\"./style\");\nvar Registry = require(\"../registry\");\nvar AttributorStore = /** @class */ (function () {\n function AttributorStore(domNode) {\n this.attributes = {};\n this.domNode = domNode;\n this.build();\n }\n AttributorStore.prototype.attribute = function (attribute, value) {\n // verb\n if (value) {\n if (attribute.add(this.domNode, value)) {\n if (attribute.value(this.domNode) != null) {\n this.attributes[attribute.attrName] = attribute;\n }\n else {\n delete this.attributes[attribute.attrName];\n }\n }\n }\n else {\n attribute.remove(this.domNode);\n delete this.attributes[attribute.attrName];\n }\n };\n AttributorStore.prototype.build = function () {\n var _this = this;\n this.attributes = {};\n var attributes = attributor_1.default.keys(this.domNode);\n var classes = class_1.default.keys(this.domNode);\n var styles = style_1.default.keys(this.domNode);\n attributes\n .concat(classes)\n .concat(styles)\n .forEach(function (name) {\n var attr = Registry.query(name, Registry.Scope.ATTRIBUTE);\n if (attr instanceof attributor_1.default) {\n _this.attributes[attr.attrName] = attr;\n }\n });\n };\n AttributorStore.prototype.copy = function (target) {\n var _this = this;\n Object.keys(this.attributes).forEach(function (key) {\n var value = _this.attributes[key].value(_this.domNode);\n target.format(key, value);\n });\n };\n AttributorStore.prototype.move = function (target) {\n var _this = this;\n this.copy(target);\n Object.keys(this.attributes).forEach(function (key) {\n _this.attributes[key].remove(_this.domNode);\n });\n this.attributes = {};\n };\n AttributorStore.prototype.values = function () {\n var _this = this;\n return Object.keys(this.attributes).reduce(function (attributes, name) {\n attributes[name] = _this.attributes[name].value(_this.domNode);\n return attributes;\n }, {});\n };\n return AttributorStore;\n}());\nexports.default = AttributorStore;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/attributor/store.ts\n// module id = 6\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar attributor_1 = require(\"./attributor\");\nfunction match(node, prefix) {\n var className = node.getAttribute('class') || '';\n return className.split(/\\s+/).filter(function (name) {\n return name.indexOf(prefix + \"-\") === 0;\n });\n}\nvar ClassAttributor = /** @class */ (function (_super) {\n __extends(ClassAttributor, _super);\n function ClassAttributor() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n ClassAttributor.keys = function (node) {\n return (node.getAttribute('class') || '').split(/\\s+/).map(function (name) {\n return name\n .split('-')\n .slice(0, -1)\n .join('-');\n });\n };\n ClassAttributor.prototype.add = function (node, value) {\n if (!this.canAdd(node, value))\n return false;\n this.remove(node);\n node.classList.add(this.keyName + \"-\" + value);\n return true;\n };\n ClassAttributor.prototype.remove = function (node) {\n var matches = match(node, this.keyName);\n matches.forEach(function (name) {\n node.classList.remove(name);\n });\n if (node.classList.length === 0) {\n node.removeAttribute('class');\n }\n };\n ClassAttributor.prototype.value = function (node) {\n var result = match(node, this.keyName)[0] || '';\n var value = result.slice(this.keyName.length + 1); // +1 for hyphen\n return this.canAdd(node, value) ? value : '';\n };\n return ClassAttributor;\n}(attributor_1.default));\nexports.default = ClassAttributor;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/attributor/class.ts\n// module id = 7\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar attributor_1 = require(\"./attributor\");\nfunction camelize(name) {\n var parts = name.split('-');\n var rest = parts\n .slice(1)\n .map(function (part) {\n return part[0].toUpperCase() + part.slice(1);\n })\n .join('');\n return parts[0] + rest;\n}\nvar StyleAttributor = /** @class */ (function (_super) {\n __extends(StyleAttributor, _super);\n function StyleAttributor() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n StyleAttributor.keys = function (node) {\n return (node.getAttribute('style') || '').split(';').map(function (value) {\n var arr = value.split(':');\n return arr[0].trim();\n });\n };\n StyleAttributor.prototype.add = function (node, value) {\n if (!this.canAdd(node, value))\n return false;\n // @ts-ignore\n node.style[camelize(this.keyName)] = value;\n return true;\n };\n StyleAttributor.prototype.remove = function (node) {\n // @ts-ignore\n node.style[camelize(this.keyName)] = '';\n if (!node.getAttribute('style')) {\n node.removeAttribute('style');\n }\n };\n StyleAttributor.prototype.value = function (node) {\n // @ts-ignore\n var value = node.style[camelize(this.keyName)];\n return this.canAdd(node, value) ? value : '';\n };\n return StyleAttributor;\n}(attributor_1.default));\nexports.default = StyleAttributor;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/attributor/style.ts\n// module id = 8\n// module chunks = 0","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar container_1 = require(\"./blot/abstract/container\");\nvar format_1 = require(\"./blot/abstract/format\");\nvar leaf_1 = require(\"./blot/abstract/leaf\");\nvar scroll_1 = require(\"./blot/scroll\");\nvar inline_1 = require(\"./blot/inline\");\nvar block_1 = require(\"./blot/block\");\nvar embed_1 = require(\"./blot/embed\");\nvar text_1 = require(\"./blot/text\");\nvar attributor_1 = require(\"./attributor/attributor\");\nvar class_1 = require(\"./attributor/class\");\nvar style_1 = require(\"./attributor/style\");\nvar store_1 = require(\"./attributor/store\");\nvar Registry = require(\"./registry\");\nvar Parchment = {\n Scope: Registry.Scope,\n create: Registry.create,\n find: Registry.find,\n query: Registry.query,\n register: Registry.register,\n Container: container_1.default,\n Format: format_1.default,\n Leaf: leaf_1.default,\n Embed: embed_1.default,\n Scroll: scroll_1.default,\n Block: block_1.default,\n Inline: inline_1.default,\n Text: text_1.default,\n Attributor: {\n Attribute: attributor_1.default,\n Class: class_1.default,\n Style: style_1.default,\n Store: store_1.default,\n },\n};\nexports.default = Parchment;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/parchment.ts\n// module id = 10\n// module chunks = 0","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar LinkedList = /** @class */ (function () {\n function LinkedList() {\n this.head = this.tail = null;\n this.length = 0;\n }\n LinkedList.prototype.append = function () {\n var nodes = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n nodes[_i] = arguments[_i];\n }\n this.insertBefore(nodes[0], null);\n if (nodes.length > 1) {\n this.append.apply(this, nodes.slice(1));\n }\n };\n LinkedList.prototype.contains = function (node) {\n var cur, next = this.iterator();\n while ((cur = next())) {\n if (cur === node)\n return true;\n }\n return false;\n };\n LinkedList.prototype.insertBefore = function (node, refNode) {\n if (!node)\n return;\n node.next = refNode;\n if (refNode != null) {\n node.prev = refNode.prev;\n if (refNode.prev != null) {\n refNode.prev.next = node;\n }\n refNode.prev = node;\n if (refNode === this.head) {\n this.head = node;\n }\n }\n else if (this.tail != null) {\n this.tail.next = node;\n node.prev = this.tail;\n this.tail = node;\n }\n else {\n node.prev = null;\n this.head = this.tail = node;\n }\n this.length += 1;\n };\n LinkedList.prototype.offset = function (target) {\n var index = 0, cur = this.head;\n while (cur != null) {\n if (cur === target)\n return index;\n index += cur.length();\n cur = cur.next;\n }\n return -1;\n };\n LinkedList.prototype.remove = function (node) {\n if (!this.contains(node))\n return;\n if (node.prev != null)\n node.prev.next = node.next;\n if (node.next != null)\n node.next.prev = node.prev;\n if (node === this.head)\n this.head = node.next;\n if (node === this.tail)\n this.tail = node.prev;\n this.length -= 1;\n };\n LinkedList.prototype.iterator = function (curNode) {\n if (curNode === void 0) { curNode = this.head; }\n // TODO use yield when we can\n return function () {\n var ret = curNode;\n if (curNode != null)\n curNode = curNode.next;\n return ret;\n };\n };\n LinkedList.prototype.find = function (index, inclusive) {\n if (inclusive === void 0) { inclusive = false; }\n var cur, next = this.iterator();\n while ((cur = next())) {\n var length_1 = cur.length();\n if (index < length_1 ||\n (inclusive && index === length_1 && (cur.next == null || cur.next.length() !== 0))) {\n return [cur, index];\n }\n index -= length_1;\n }\n return [null, 0];\n };\n LinkedList.prototype.forEach = function (callback) {\n var cur, next = this.iterator();\n while ((cur = next())) {\n callback(cur);\n }\n };\n LinkedList.prototype.forEachAt = function (index, length, callback) {\n if (length <= 0)\n return;\n var _a = this.find(index), startNode = _a[0], offset = _a[1];\n var cur, curIndex = index - offset, next = this.iterator(startNode);\n while ((cur = next()) && curIndex < index + length) {\n var curLength = cur.length();\n if (index > curIndex) {\n callback(cur, index - curIndex, Math.min(length, curIndex + curLength - index));\n }\n else {\n callback(cur, 0, Math.min(curLength, index + length - curIndex));\n }\n curIndex += curLength;\n }\n };\n LinkedList.prototype.map = function (callback) {\n return this.reduce(function (memo, cur) {\n memo.push(callback(cur));\n return memo;\n }, []);\n };\n LinkedList.prototype.reduce = function (callback, memo) {\n var cur, next = this.iterator();\n while ((cur = next())) {\n memo = callback(memo, cur);\n }\n return memo;\n };\n return LinkedList;\n}());\nexports.default = LinkedList;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/collection/linked-list.ts\n// module id = 11\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar container_1 = require(\"./abstract/container\");\nvar Registry = require(\"../registry\");\nvar OBSERVER_CONFIG = {\n attributes: true,\n characterData: true,\n characterDataOldValue: true,\n childList: true,\n subtree: true,\n};\nvar MAX_OPTIMIZE_ITERATIONS = 100;\nvar ScrollBlot = /** @class */ (function (_super) {\n __extends(ScrollBlot, _super);\n function ScrollBlot(node) {\n var _this = _super.call(this, node) || this;\n _this.scroll = _this;\n _this.observer = new MutationObserver(function (mutations) {\n _this.update(mutations);\n });\n _this.observer.observe(_this.domNode, OBSERVER_CONFIG);\n _this.attach();\n return _this;\n }\n ScrollBlot.prototype.detach = function () {\n _super.prototype.detach.call(this);\n this.observer.disconnect();\n };\n ScrollBlot.prototype.deleteAt = function (index, length) {\n this.update();\n if (index === 0 && length === this.length()) {\n this.children.forEach(function (child) {\n child.remove();\n });\n }\n else {\n _super.prototype.deleteAt.call(this, index, length);\n }\n };\n ScrollBlot.prototype.formatAt = function (index, length, name, value) {\n this.update();\n _super.prototype.formatAt.call(this, index, length, name, value);\n };\n ScrollBlot.prototype.insertAt = function (index, value, def) {\n this.update();\n _super.prototype.insertAt.call(this, index, value, def);\n };\n ScrollBlot.prototype.optimize = function (mutations, context) {\n var _this = this;\n if (mutations === void 0) { mutations = []; }\n if (context === void 0) { context = {}; }\n _super.prototype.optimize.call(this, context);\n // We must modify mutations directly, cannot make copy and then modify\n var records = [].slice.call(this.observer.takeRecords());\n // Array.push currently seems to be implemented by a non-tail recursive function\n // so we cannot just mutations.push.apply(mutations, this.observer.takeRecords());\n while (records.length > 0)\n mutations.push(records.pop());\n // TODO use WeakMap\n var mark = function (blot, markParent) {\n if (markParent === void 0) { markParent = true; }\n if (blot == null || blot === _this)\n return;\n if (blot.domNode.parentNode == null)\n return;\n // @ts-ignore\n if (blot.domNode[Registry.DATA_KEY].mutations == null) {\n // @ts-ignore\n blot.domNode[Registry.DATA_KEY].mutations = [];\n }\n if (markParent)\n mark(blot.parent);\n };\n var optimize = function (blot) {\n // Post-order traversal\n if (\n // @ts-ignore\n blot.domNode[Registry.DATA_KEY] == null ||\n // @ts-ignore\n blot.domNode[Registry.DATA_KEY].mutations == null) {\n return;\n }\n if (blot instanceof container_1.default) {\n blot.children.forEach(optimize);\n }\n blot.optimize(context);\n };\n var remaining = mutations;\n for (var i = 0; remaining.length > 0; i += 1) {\n if (i >= MAX_OPTIMIZE_ITERATIONS) {\n throw new Error('[Parchment] Maximum optimize iterations reached');\n }\n remaining.forEach(function (mutation) {\n var blot = Registry.find(mutation.target, true);\n if (blot == null)\n return;\n if (blot.domNode === mutation.target) {\n if (mutation.type === 'childList') {\n mark(Registry.find(mutation.previousSibling, false));\n [].forEach.call(mutation.addedNodes, function (node) {\n var child = Registry.find(node, false);\n mark(child, false);\n if (child instanceof container_1.default) {\n child.children.forEach(function (grandChild) {\n mark(grandChild, false);\n });\n }\n });\n }\n else if (mutation.type === 'attributes') {\n mark(blot.prev);\n }\n }\n mark(blot);\n });\n this.children.forEach(optimize);\n remaining = [].slice.call(this.observer.takeRecords());\n records = remaining.slice();\n while (records.length > 0)\n mutations.push(records.pop());\n }\n };\n ScrollBlot.prototype.update = function (mutations, context) {\n var _this = this;\n if (context === void 0) { context = {}; }\n mutations = mutations || this.observer.takeRecords();\n // TODO use WeakMap\n mutations\n .map(function (mutation) {\n var blot = Registry.find(mutation.target, true);\n if (blot == null)\n return null;\n // @ts-ignore\n if (blot.domNode[Registry.DATA_KEY].mutations == null) {\n // @ts-ignore\n blot.domNode[Registry.DATA_KEY].mutations = [mutation];\n return blot;\n }\n else {\n // @ts-ignore\n blot.domNode[Registry.DATA_KEY].mutations.push(mutation);\n return null;\n }\n })\n .forEach(function (blot) {\n if (blot == null ||\n blot === _this ||\n //@ts-ignore\n blot.domNode[Registry.DATA_KEY] == null)\n return;\n // @ts-ignore\n blot.update(blot.domNode[Registry.DATA_KEY].mutations || [], context);\n });\n // @ts-ignore\n if (this.domNode[Registry.DATA_KEY].mutations != null) {\n // @ts-ignore\n _super.prototype.update.call(this, this.domNode[Registry.DATA_KEY].mutations, context);\n }\n this.optimize(mutations, context);\n };\n ScrollBlot.blotName = 'scroll';\n ScrollBlot.defaultChild = 'block';\n ScrollBlot.scope = Registry.Scope.BLOCK_BLOT;\n ScrollBlot.tagName = 'DIV';\n return ScrollBlot;\n}(container_1.default));\nexports.default = ScrollBlot;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/blot/scroll.ts\n// module id = 12\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar format_1 = require(\"./abstract/format\");\nvar Registry = require(\"../registry\");\n// Shallow object comparison\nfunction isEqual(obj1, obj2) {\n if (Object.keys(obj1).length !== Object.keys(obj2).length)\n return false;\n // @ts-ignore\n for (var prop in obj1) {\n // @ts-ignore\n if (obj1[prop] !== obj2[prop])\n return false;\n }\n return true;\n}\nvar InlineBlot = /** @class */ (function (_super) {\n __extends(InlineBlot, _super);\n function InlineBlot() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n InlineBlot.formats = function (domNode) {\n if (domNode.tagName === InlineBlot.tagName)\n return undefined;\n return _super.formats.call(this, domNode);\n };\n InlineBlot.prototype.format = function (name, value) {\n var _this = this;\n if (name === this.statics.blotName && !value) {\n this.children.forEach(function (child) {\n if (!(child instanceof format_1.default)) {\n child = child.wrap(InlineBlot.blotName, true);\n }\n _this.attributes.copy(child);\n });\n this.unwrap();\n }\n else {\n _super.prototype.format.call(this, name, value);\n }\n };\n InlineBlot.prototype.formatAt = function (index, length, name, value) {\n if (this.formats()[name] != null || Registry.query(name, Registry.Scope.ATTRIBUTE)) {\n var blot = this.isolate(index, length);\n blot.format(name, value);\n }\n else {\n _super.prototype.formatAt.call(this, index, length, name, value);\n }\n };\n InlineBlot.prototype.optimize = function (context) {\n _super.prototype.optimize.call(this, context);\n var formats = this.formats();\n if (Object.keys(formats).length === 0) {\n return this.unwrap(); // unformatted span\n }\n var next = this.next;\n if (next instanceof InlineBlot && next.prev === this && isEqual(formats, next.formats())) {\n next.moveChildren(this);\n next.remove();\n }\n };\n InlineBlot.blotName = 'inline';\n InlineBlot.scope = Registry.Scope.INLINE_BLOT;\n InlineBlot.tagName = 'SPAN';\n return InlineBlot;\n}(format_1.default));\nexports.default = InlineBlot;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/blot/inline.ts\n// module id = 13\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar format_1 = require(\"./abstract/format\");\nvar Registry = require(\"../registry\");\nvar BlockBlot = /** @class */ (function (_super) {\n __extends(BlockBlot, _super);\n function BlockBlot() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n BlockBlot.formats = function (domNode) {\n var tagName = Registry.query(BlockBlot.blotName).tagName;\n if (domNode.tagName === tagName)\n return undefined;\n return _super.formats.call(this, domNode);\n };\n BlockBlot.prototype.format = function (name, value) {\n if (Registry.query(name, Registry.Scope.BLOCK) == null) {\n return;\n }\n else if (name === this.statics.blotName && !value) {\n this.replaceWith(BlockBlot.blotName);\n }\n else {\n _super.prototype.format.call(this, name, value);\n }\n };\n BlockBlot.prototype.formatAt = function (index, length, name, value) {\n if (Registry.query(name, Registry.Scope.BLOCK) != null) {\n this.format(name, value);\n }\n else {\n _super.prototype.formatAt.call(this, index, length, name, value);\n }\n };\n BlockBlot.prototype.insertAt = function (index, value, def) {\n if (def == null || Registry.query(value, Registry.Scope.INLINE) != null) {\n // Insert text or inline\n _super.prototype.insertAt.call(this, index, value, def);\n }\n else {\n var after = this.split(index);\n var blot = Registry.create(value, def);\n after.parent.insertBefore(blot, after);\n }\n };\n BlockBlot.prototype.update = function (mutations, context) {\n if (navigator.userAgent.match(/Trident/)) {\n this.build();\n }\n else {\n _super.prototype.update.call(this, mutations, context);\n }\n };\n BlockBlot.blotName = 'block';\n BlockBlot.scope = Registry.Scope.BLOCK_BLOT;\n BlockBlot.tagName = 'P';\n return BlockBlot;\n}(format_1.default));\nexports.default = BlockBlot;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/blot/block.ts\n// module id = 14\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar leaf_1 = require(\"./abstract/leaf\");\nvar EmbedBlot = /** @class */ (function (_super) {\n __extends(EmbedBlot, _super);\n function EmbedBlot() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n EmbedBlot.formats = function (domNode) {\n return undefined;\n };\n EmbedBlot.prototype.format = function (name, value) {\n // super.formatAt wraps, which is what we want in general,\n // but this allows subclasses to overwrite for formats\n // that just apply to particular embeds\n _super.prototype.formatAt.call(this, 0, this.length(), name, value);\n };\n EmbedBlot.prototype.formatAt = function (index, length, name, value) {\n if (index === 0 && length === this.length()) {\n this.format(name, value);\n }\n else {\n _super.prototype.formatAt.call(this, index, length, name, value);\n }\n };\n EmbedBlot.prototype.formats = function () {\n return this.statics.formats(this.domNode);\n };\n return EmbedBlot;\n}(leaf_1.default));\nexports.default = EmbedBlot;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/blot/embed.ts\n// module id = 15\n// module chunks = 0","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar leaf_1 = require(\"./abstract/leaf\");\nvar Registry = require(\"../registry\");\nvar TextBlot = /** @class */ (function (_super) {\n __extends(TextBlot, _super);\n function TextBlot(node) {\n var _this = _super.call(this, node) || this;\n _this.text = _this.statics.value(_this.domNode);\n return _this;\n }\n TextBlot.create = function (value) {\n return document.createTextNode(value);\n };\n TextBlot.value = function (domNode) {\n var text = domNode.data;\n // @ts-ignore\n if (text['normalize'])\n text = text['normalize']();\n return text;\n };\n TextBlot.prototype.deleteAt = function (index, length) {\n this.domNode.data = this.text = this.text.slice(0, index) + this.text.slice(index + length);\n };\n TextBlot.prototype.index = function (node, offset) {\n if (this.domNode === node) {\n return offset;\n }\n return -1;\n };\n TextBlot.prototype.insertAt = function (index, value, def) {\n if (def == null) {\n this.text = this.text.slice(0, index) + value + this.text.slice(index);\n this.domNode.data = this.text;\n }\n else {\n _super.prototype.insertAt.call(this, index, value, def);\n }\n };\n TextBlot.prototype.length = function () {\n return this.text.length;\n };\n TextBlot.prototype.optimize = function (context) {\n _super.prototype.optimize.call(this, context);\n this.text = this.statics.value(this.domNode);\n if (this.text.length === 0) {\n this.remove();\n }\n else if (this.next instanceof TextBlot && this.next.prev === this) {\n this.insertAt(this.length(), this.next.value());\n this.next.remove();\n }\n };\n TextBlot.prototype.position = function (index, inclusive) {\n if (inclusive === void 0) { inclusive = false; }\n return [this.domNode, index];\n };\n TextBlot.prototype.split = function (index, force) {\n if (force === void 0) { force = false; }\n if (!force) {\n if (index === 0)\n return this;\n if (index === this.length())\n return this.next;\n }\n var after = Registry.create(this.domNode.splitText(index));\n this.parent.insertBefore(after, this.next);\n this.text = this.statics.value(this.domNode);\n return after;\n };\n TextBlot.prototype.update = function (mutations, context) {\n var _this = this;\n if (mutations.some(function (mutation) {\n return mutation.type === 'characterData' && mutation.target === _this.domNode;\n })) {\n this.text = this.statics.value(this.domNode);\n }\n };\n TextBlot.prototype.value = function () {\n return this.text;\n };\n TextBlot.blotName = 'text';\n TextBlot.scope = Registry.Scope.INLINE_BLOT;\n return TextBlot;\n}(leaf_1.default));\nexports.default = TextBlot;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/blot/text.ts\n// module id = 16\n// module chunks = 0","import cloneDeep from 'lodash.clonedeep';\nimport isEqual from 'lodash.isequal';\n\ninterface AttributeMap {\n [key: string]: any;\n}\n\nnamespace AttributeMap {\n export function compose(\n a: AttributeMap = {},\n b: AttributeMap = {},\n keepNull: boolean,\n ): AttributeMap | undefined {\n if (typeof a !== 'object') {\n a = {};\n }\n if (typeof b !== 'object') {\n b = {};\n }\n let attributes = cloneDeep(b);\n if (!keepNull) {\n attributes = Object.keys(attributes).reduce<AttributeMap>((copy, key) => {\n if (attributes[key] != null) {\n copy[key] = attributes[key];\n }\n return copy;\n }, {});\n }\n for (const key in a) {\n if (a[key] !== undefined && b[key] === undefined) {\n attributes[key] = a[key];\n }\n }\n return Object.keys(attributes).length > 0 ? attributes : undefined;\n }\n\n export function diff(\n a: AttributeMap = {},\n b: AttributeMap = {},\n ): AttributeMap | undefined {\n if (typeof a !== 'object') {\n a = {};\n }\n if (typeof b !== 'object') {\n b = {};\n }\n const attributes = Object.keys(a)\n .concat(Object.keys(b))\n .reduce<AttributeMap>((attrs, key) => {\n if (!isEqual(a[key], b[key])) {\n attrs[key] = b[key] === undefined ? null : b[key];\n }\n return attrs;\n }, {});\n return Object.keys(attributes).length > 0 ? attributes : undefined;\n }\n\n export function invert(\n attr: AttributeMap = {},\n base: AttributeMap = {},\n ): AttributeMap {\n attr = attr || {};\n const baseInverted = Object.keys(base).reduce<AttributeMap>((memo, key) => {\n if (base[key] !== attr[key] && attr[key] !== undefined) {\n memo[key] = base[key];\n }\n return memo;\n }, {});\n return Object.keys(attr).reduce<AttributeMap>((memo, key) => {\n if (attr[key] !== base[key] && base[key] === undefined) {\n memo[key] = null;\n }\n return memo;\n }, baseInverted);\n }\n\n export function transform(\n a: AttributeMap | undefined,\n b: AttributeMap | undefined,\n priority = false,\n ): AttributeMap | undefined {\n if (typeof a !== 'object') {\n return b;\n }\n if (typeof b !== 'object') {\n return undefined;\n }\n if (!priority) {\n return b; // b simply overwrites us without priority\n }\n const attributes = Object.keys(b).reduce<AttributeMap>((attrs, key) => {\n if (a[key] === undefined) {\n attrs[key] = b[key]; // null is a valid value\n }\n return attrs;\n }, {});\n return Object.keys(attributes).length > 0 ? attributes : undefined;\n }\n}\n\nexport default AttributeMap;\n","import diff from 'fast-diff';\nimport cloneDeep from 'lodash.clonedeep';\nimport isEqual from 'lodash.isequal';\nimport AttributeMap from './AttributeMap';\nimport Op from './Op';\n\nconst NULL_CHARACTER = String.fromCharCode(0); // Placeholder char for embed in diff()\n\nclass Delta {\n static Op = Op;\n static AttributeMap = AttributeMap;\n\n ops: Op[];\n constructor(ops?: Op[] | { ops: Op[] }) {\n // Assume we are given a well formed ops\n if (Array.isArray(ops)) {\n this.ops = ops;\n } else if (ops != null && Array.isArray(ops.ops)) {\n this.ops = ops.ops;\n } else {\n this.ops = [];\n }\n }\n\n insert(arg: string | object, attributes?: AttributeMap): this {\n const newOp: Op = {};\n if (typeof arg === 'string' && arg.length === 0) {\n return this;\n }\n newOp.insert = arg;\n if (\n attributes != null &&\n typeof attributes === 'object' &&\n Object.keys(attributes).length > 0\n ) {\n newOp.attributes = attributes;\n }\n return this.push(newOp);\n }\n\n delete(length: number): this {\n if (length <= 0) {\n return this;\n }\n return this.push({ delete: length });\n }\n\n retain(length: number, attributes?: AttributeMap): this {\n if (length <= 0) {\n return this;\n }\n const newOp: Op = { retain: length };\n if (\n attributes != null &&\n typeof attributes === 'object' &&\n Object.keys(attributes).length > 0\n ) {\n newOp.attributes = attributes;\n }\n return this.push(newOp);\n }\n\n push(newOp: Op): this {\n let index = this.ops.length;\n let lastOp = this.ops[index - 1];\n newOp = cloneDeep(newOp);\n if (typeof lastOp === 'object') {\n if (\n typeof newOp.delete === 'number' &&\n typeof lastOp.delete === 'number'\n ) {\n this.ops[index - 1] = { delete: lastOp.delete + newOp.delete };\n return this;\n }\n // Since it does not matter if we insert before or after deleting at the same index,\n // always prefer to insert first\n if (typeof lastOp.delete === 'number' && newOp.insert != null) {\n index -= 1;\n lastOp = this.ops[index - 1];\n if (typeof lastOp !== 'object') {\n this.ops.unshift(newOp);\n return this;\n }\n }\n if (isEqual(newOp.attributes, lastOp.attributes)) {\n if (\n typeof newOp.insert === 'string' &&\n typeof lastOp.insert === 'string'\n ) {\n this.ops[index - 1] = { insert: lastOp.insert + newOp.insert };\n if (typeof newOp.attributes === 'object') {\n this.ops[index - 1].attributes = newOp.attributes;\n }\n return this;\n } else if (\n typeof newOp.retain === 'number' &&\n typeof lastOp.retain === 'number'\n ) {\n this.ops[index - 1] = { retain: lastOp.retain + newOp.retain };\n if (typeof newOp.attributes === 'object') {\n this.ops[index - 1].attributes = newOp.attributes;\n }\n return this;\n }\n }\n }\n if (index === this.ops.length) {\n this.ops.push(newOp);\n } else {\n this.ops.splice(index, 0, newOp);\n }\n return this;\n }\n\n chop(): this {\n const lastOp = this.ops[this.ops.length - 1];\n if (lastOp && lastOp.retain && !lastOp.attributes) {\n this.ops.pop();\n }\n return this;\n }\n\n filter(predicate: (op: Op, index: number) => boolean): Op[] {\n return this.ops.filter(predicate);\n }\n\n forEach(predicate: (op: Op, index: number) => void): void {\n this.ops.forEach(predicate);\n }\n\n map<T>(predicate: (op: Op, index: number) => T): T[] {\n return this.ops.map(predicate);\n }\n\n partition(predicate: (op: Op) => boolean): [Op[], Op[]] {\n const passed: Op[] = [];\n const failed: Op[] = [];\n this.forEach((op) => {\n const target = predicate(op) ? passed : failed;\n target.push(op);\n });\n return [passed, failed];\n }\n\n reduce<T>(\n predicate: (accum: T, curr: Op, index: number) => T,\n initialValue: T,\n ): T {\n return this.ops.reduce(predicate, initialValue);\n }\n\n changeLength(): number {\n return this.reduce((length, elem) => {\n if (elem.insert) {\n return length + Op.length(elem);\n } else if (elem.delete) {\n return length - elem.delete;\n }\n return length;\n }, 0);\n }\n\n length(): number {\n return this.reduce((length, elem) => {\n return length + Op.length(elem);\n }, 0);\n }\n\n slice(start = 0, end = Infinity): Delta {\n const ops = [];\n const iter = Op.iterator(this.ops);\n let index = 0;\n while (index < end && iter.hasNext()) {\n let nextOp;\n if (index < start) {\n nextOp = iter.next(start - index);\n } else {\n nextOp = iter.next(end - index);\n ops.push(nextOp);\n }\n index += Op.length(nextOp);\n }\n return new Delta(ops);\n }\n\n compose(other: Delta): Delta {\n const thisIter = Op.iterator(this.ops);\n const otherIter = Op.iterator(other.ops);\n const ops = [];\n const firstOther = otherIter.peek();\n if (\n firstOther != null &&\n typeof firstOther.retain === 'number' &&\n firstOther.attributes == null\n ) {\n let firstLeft = firstOther.retain;\n while (\n thisIter.peekType() === 'insert' &&\n thisIter.peekLength() <= firstLeft\n ) {\n firstLeft -= thisIter.peekLength();\n ops.push(thisIter.next());\n }\n if (firstOther.retain - firstLeft > 0) {\n otherIter.next(firstOther.retain - firstLeft);\n }\n }\n const delta = new Delta(ops);\n while (thisIter.hasNext() || otherIter.hasNext()) {\n if (otherIter.peekType() === 'insert') {\n delta.push(otherIter.next());\n } else if (thisIter.peekType() === 'delete') {\n delta.push(thisIter.next());\n } else {\n const length = Math.min(thisIter.peekLength(), otherIter.peekLength());\n const thisOp = thisIter.next(length);\n const otherOp = otherIter.next(length);\n if (typeof otherOp.retain === 'number') {\n const newOp: Op = {};\n if (typeof thisOp.retain === 'number') {\n newOp.retain = length;\n } else {\n newOp.insert = thisOp.insert;\n }\n // Preserve null when composing with a retain, otherwise remove it for inserts\n const attributes = AttributeMap.compose(\n thisOp.attributes,\n otherOp.attributes,\n typeof thisOp.retain === 'number',\n );\n if (attributes) {\n newOp.attributes = attributes;\n }\n delta.push(newOp);\n\n // Optimization if rest of other is just retain\n if (\n !otherIter.hasNext() &&\n isEqual(delta.ops[delta.ops.length - 1], newOp)\n ) {\n const rest = new Delta(thisIter.rest());\n return delta.concat(rest).chop();\n }\n\n // Other op should be delete, we could be an insert or retain\n // Insert + delete cancels out\n } else if (\n typeof otherOp.delete === 'number' &&\n typeof thisOp.retain === 'number'\n ) {\n delta.push(otherOp);\n }\n }\n }\n return delta.chop();\n }\n\n concat(other: Delta): Delta {\n const delta = new Delta(this.ops.slice());\n if (other.ops.length > 0) {\n delta.push(other.ops[0]);\n delta.ops = delta.ops.concat(other.ops.slice(1));\n }\n return delta;\n }\n\n diff(other: Delta, cursor?: number | diff.CursorInfo): Delta {\n if (this.ops === other.ops) {\n return new Delta();\n }\n const strings = [this, other].map((delta) => {\n return delta\n .map((op) => {\n if (op.insert != null) {\n return typeof op.insert === 'string' ? op.insert : NULL_CHARACTER;\n }\n const prep = delta === other ? 'on' : 'with';\n throw new Error('diff() called ' + prep + ' non-document');\n })\n .join('');\n });\n const retDelta = new Delta();\n const diffResult = diff(strings[0], strings[1], cursor);\n const thisIter = Op.iterator(this.ops);\n const otherIter = Op.iterator(other.ops);\n diffResult.forEach((component: diff.Diff) => {\n let length = component[1].length;\n while (length > 0) {\n let opLength = 0;\n switch (component[0]) {\n case diff.INSERT:\n opLength = Math.min(otherIter.peekLength(), length);\n retDelta.push(otherIter.next(opLength));\n break;\n case diff.DELETE:\n opLength = Math.min(length, thisIter.peekLength());\n thisIter.next(opLength);\n retDelta.delete(opLength);\n break;\n case diff.EQUAL:\n opLength = Math.min(\n thisIter.peekLength(),\n otherIter.peekLength(),\n length,\n );\n const thisOp = thisIter.next(opLength);\n const otherOp = otherIter.next(opLength);\n if (isEqual(thisOp.insert, otherOp.insert)) {\n retDelta.retain(\n opLength,\n AttributeMap.diff(thisOp.attributes, otherOp.attributes),\n );\n } else {\n retDelta.push(otherOp).delete(opLength);\n }\n break;\n }\n length -= opLength;\n }\n });\n return retDelta.chop();\n }\n\n eachLine(\n predicate: (\n line: Delta,\n attributes: AttributeMap,\n index: number,\n ) => boolean | void,\n newline = '\\n',\n ): void {\n const iter = Op.iterator(this.ops);\n let line = new Delta();\n let i = 0;\n while (iter.hasNext()) {\n if (iter.peekType() !== 'insert') {\n return;\n }\n const thisOp = iter.peek();\n const start = Op.length(thisOp) - iter.peekLength();\n const index =\n typeof thisOp.insert === 'string'\n ? thisOp.insert.indexOf(newline, start) - start\n : -1;\n if (index < 0) {\n line.push(iter.next());\n } else if (index > 0) {\n line.push(iter.next(index));\n } else {\n if (predicate(line, iter.next(1).attributes || {}, i) === false) {\n return;\n }\n i += 1;\n line = new Delta();\n }\n }\n if (line.length() > 0) {\n predicate(line, {}, i);\n }\n }\n\n invert(base: Delta): Delta {\n const inverted = new Delta();\n this.reduce((baseIndex, op) => {\n if (op.insert) {\n inverted.delete(Op.length(op));\n } else if (op.retain && op.attributes == null) {\n inverted.retain(op.retain);\n return baseIndex + op.retain;\n } else if (op.delete || (op.retain && op.attributes)) {\n const length = (op.delete || op.retain) as number;\n const slice = base.slice(baseIndex, baseIndex + length);\n slice.forEach((baseOp) => {\n if (op.delete) {\n inverted.push(baseOp);\n } else if (op.retain && op.attributes) {\n inverted.retain(\n Op.length(baseOp),\n AttributeMap.invert(op.attributes, baseOp.attributes),\n );\n }\n });\n return baseIndex + length;\n }\n return baseIndex;\n }, 0);\n return inverted.chop();\n }\n\n transform(index: number, priority?: boolean): number;\n transform(other: Delta, priority?: boolean): Delta;\n transform(arg: number | Delta, priority = false): typeof arg {\n priority = !!priority;\n if (typeof arg === 'number') {\n return this.transformPosition(arg, priority);\n }\n const other: Delta = arg;\n const thisIter = Op.iterator(this.ops);\n const otherIter = Op.iterator(other.ops);\n const delta = new Delta();\n while (thisIter.hasNext() || otherIter.hasNext()) {\n if (\n thisIter.peekType() === 'insert' &&\n (priority || otherIter.peekType() !== 'insert')\n ) {\n delta.retain(Op.length(thisIter.next()));\n } else if (otherIter.peekType() === 'insert') {\n delta.push(otherIter.next());\n } else {\n const length = Math.min(thisIter.peekLength(), otherIter.peekLength());\n const thisOp = thisIter.next(length);\n const otherOp = otherIter.next(length);\n if (thisOp.delete) {\n // Our delete either makes their delete redundant or removes their retain\n continue;\n } else if (otherOp.delete) {\n delta.push(otherOp);\n } else {\n // We retain either their retain or insert\n delta.retain(\n length,\n AttributeMap.transform(\n thisOp.attributes,\n otherOp.attributes,\n priority,\n ),\n );\n }\n }\n }\n return delta.chop();\n }\n\n transformPosition(index: number, priority = false): number {\n priority = !!priority;\n const thisIter = Op.iterator(this.ops);\n let offset = 0;\n while (thisIter.hasNext() && offset <= index) {\n const length = thisIter.peekLength();\n const nextType = thisIter.peekType();\n thisIter.next();\n if (nextType === 'delete') {\n index -= Math.min(length, index - offset);\n continue;\n } else if (nextType === 'insert' && (offset < index || !priority)) {\n index += length;\n }\n offset += length;\n }\n return index;\n }\n}\n\nexport = Delta;\n","import Op from './Op';\n\nexport default class Iterator {\n ops: Op[];\n index: number;\n offset: number;\n\n constructor(ops: Op[]) {\n this.ops = ops;\n this.index = 0;\n this.offset = 0;\n }\n\n hasNext(): boolean {\n return this.peekLength() < Infinity;\n }\n\n next(length?: number): Op {\n if (!length) {\n length = Infinity;\n }\n const nextOp = this.ops[this.index];\n if (nextOp) {\n const offset = this.offset;\n const opLength = Op.length(nextOp);\n if (length >= opLength - offset) {\n length = opLength - offset;\n this.index += 1;\n this.offset = 0;\n } else {\n this.offset += length;\n }\n if (typeof nextOp.delete === 'number') {\n return { delete: length };\n } else {\n const retOp: Op = {};\n if (nextOp.attributes) {\n retOp.attributes = nextOp.attributes;\n }\n if (typeof nextOp.retain === 'number') {\n retOp.retain = length;\n } else if (typeof nextOp.insert === 'string') {\n retOp.insert = nextOp.insert.substr(offset, length);\n } else {\n // offset should === 0, length should === 1\n retOp.insert = nextOp.insert;\n }\n return retOp;\n }\n } else {\n return { retain: Infinity };\n }\n }\n\n peek(): Op {\n return this.ops[this.index];\n }\n\n peekLength(): number {\n if (this.ops[this.index]) {\n // Should never return 0 if our index is being managed correctly\n return Op.length(this.ops[this.index]) - this.offset;\n } else {\n return Infinity;\n }\n }\n\n peekType(): string {\n if (this.ops[this.index]) {\n if (typeof this.ops[this.index].delete === 'number') {\n return 'delete';\n } else if (typeof this.ops[this.index].retain === 'number') {\n return 'retain';\n } else {\n return 'insert';\n }\n }\n return 'retain';\n }\n\n rest(): Op[] {\n if (!this.hasNext()) {\n return [];\n } else if (this.offset === 0) {\n return this.ops.slice(this.index);\n } else {\n const offset = this.offset;\n const index = this.index;\n const next = this.next();\n const rest = this.ops.slice(this.index);\n this.offset = offset;\n this.index = index;\n return [next].concat(rest);\n }\n }\n}\n","import AttributeMap from './AttributeMap';\nimport Iterator from './Iterator';\n\ninterface Op {\n // only one property out of {insert, delete, retain} will be present\n insert?: string | object;\n delete?: number;\n retain?: number;\n\n attributes?: AttributeMap;\n}\n\nnamespace Op {\n export function iterator(ops: Op[]): Iterator {\n return new Iterator(ops);\n }\n\n export function length(op: Op): number {\n if (typeof op.delete === 'number') {\n return op.delete;\n } else if (typeof op.retain === 'number') {\n return op.retain;\n } else {\n return typeof op.insert === 'string' ? op.insert.length : 1;\n }\n }\n}\n\nexport default Op;\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","import Parchment from 'parchment';\n\n\nclass Break extends Parchment.Embed {\n static value() {\n return undefined;\n }\n\n insertInto(parent, ref) {\n if (parent.children.length === 0) {\n super.insertInto(parent, ref);\n } else {\n this.remove();\n }\n }\n\n length() {\n return 0;\n }\n\n value() {\n return '';\n }\n}\nBreak.blotName = 'break';\nBreak.tagName = 'BR';\n\n\nexport default Break;\n","import Parchment from 'parchment';\n\nclass TextBlot extends Parchment.Text { }\n\nexport default TextBlot;\n","import Text from './text';\nimport Parchment from 'parchment';\n\n\nclass Inline extends Parchment.Inline {\n static compare(self, other) {\n let selfIndex = Inline.order.indexOf(self);\n let otherIndex = Inline.order.indexOf(other);\n if (selfIndex >= 0 || otherIndex >= 0) {\n return selfIndex - otherIndex;\n } else if (self === other) {\n return 0;\n } else if (self < other) {\n return -1;\n } else {\n return 1;\n }\n }\n\n formatAt(index, length, name, value) {\n if (Inline.compare(this.statics.blotName, name) < 0 && Parchment.query(name, Parchment.Scope.BLOT)) {\n let blot = this.isolate(index, length);\n if (value) {\n blot.wrap(name, value);\n }\n } else {\n super.formatAt(index, length, name, value);\n }\n }\n\n optimize(context) {\n super.optimize(context);\n if (this.parent instanceof Inline &&\n Inline.compare(this.statics.blotName, this.parent.statics.blotName) > 0) {\n let parent = this.parent.isolate(this.offset(), this.length());\n this.moveChildren(parent);\n parent.wrap(this);\n }\n }\n}\nInline.allowedChildren = [Inline, Parchment.Embed, Text];\n// Lower index means deeper in the DOM tree, since not found (-1) is for embeds\nInline.order = [\n 'cursor', 'inline', // Must be lower\n 'underline', 'strike', 'italic', 'bold', 'script',\n 'link', 'code' // Must be higher\n];\n\n\nexport default Inline;\n","import merge from 'lodash.merge';\nimport Delta from 'quill-delta';\nimport Parchment from 'parchment';\nimport Break from './break';\nimport Inline from './inline';\nimport TextBlot from './text';\n\n\nconst NEWLINE_LENGTH = 1;\n\n\nclass BlockEmbed extends Parchment.Embed {\n attach() {\n super.attach();\n this.attributes = new Parchment.Attributor.Store(this.domNode);\n }\n\n delta() {\n return new Delta().insert(this.value(), merge(this.formats(), this.attributes.values()));\n }\n\n format(name, value) {\n let attribute = Parchment.query(name, Parchment.Scope.BLOCK_ATTRIBUTE);\n if (attribute != null) {\n this.attributes.attribute(attribute, value);\n }\n }\n\n formatAt(index, length, name, value) {\n this.format(name, value);\n }\n\n insertAt(index, value, def) {\n if (typeof value === 'string' && value.endsWith('\\n')) {\n let block = Parchment.create(Block.blotName);\n this.parent.insertBefore(block, index === 0 ? this : this.next);\n block.insertAt(0, value.slice(0, -1));\n } else {\n super.insertAt(index, value, def);\n }\n }\n}\nBlockEmbed.scope = Parchment.Scope.BLOCK_BLOT;\n// It is important for cursor behavior BlockEmbeds use tags that are block level elements\n\n\nclass Block extends Parchment.Block {\n constructor(domNode) {\n super(domNode);\n this.cache = {};\n }\n\n delta() {\n if (this.cache.delta == null) {\n this.cache.delta = this.descendants(Parchment.Leaf).reduce((delta, leaf) => {\n if (leaf.length() === 0) {\n return delta;\n } else {\n return delta.insert(leaf.value(), bubbleFormats(leaf));\n }\n }, new Delta()).insert('\\n', bubbleFormats(this));\n }\n return this.cache.delta;\n }\n\n deleteAt(index, length) {\n super.deleteAt(index, length);\n this.cache = {};\n }\n\n formatAt(index, length, name, value) {\n if (length <= 0) return;\n if (Parchment.query(name, Parchment.Scope.BLOCK)) {\n if (index + length === this.length()) {\n this.format(name, value);\n }\n } else {\n super.formatAt(index, Math.min(length, this.length() - index - 1), name, value);\n }\n this.cache = {};\n }\n\n insertAt(index, value, def) {\n if (def != null) return super.insertAt(index, value, def);\n if (value.length === 0) return;\n let lines = value.split('\\n');\n let text = lines.shift();\n if (text.length > 0) {\n if (index < this.length() - 1 || this.children.tail == null) {\n super.insertAt(Math.min(index, this.length() - 1), text);\n } else {\n this.children.tail.insertAt(this.children.tail.length(), text);\n }\n this.cache = {};\n }\n let block = this;\n lines.reduce(function(index, line) {\n block = block.split(index, true);\n block.insertAt(0, line);\n return line.length;\n }, index + text.length);\n }\n\n insertBefore(blot, ref) {\n let head = this.children.head;\n super.insertBefore(blot, ref);\n if (head instanceof Break) {\n head.remove();\n }\n this.cache = {};\n }\n\n length() {\n if (this.cache.length == null) {\n this.cache.length = super.length() + NEWLINE_LENGTH;\n }\n return this.cache.length;\n }\n\n moveChildren(target, ref) {\n super.moveChildren(target, ref);\n this.cache = {};\n }\n\n optimize(context) {\n super.optimize(context);\n this.cache = {};\n }\n\n path(index) {\n return super.path(index, true);\n }\n\n removeChild(child) {\n super.removeChild(child);\n this.cache = {};\n }\n\n split(index, force = false) {\n if (force && (index === 0 || index >= this.length() - NEWLINE_LENGTH)) {\n let clone = this.clone();\n if (index === 0) {\n this.parent.insertBefore(clone, this);\n return this;\n } else {\n this.parent.insertBefore(clone, this.next);\n return clone;\n }\n } else {\n let next = super.split(index, force);\n this.cache = {};\n return next;\n }\n }\n}\nBlock.blotName = 'block';\nBlock.tagName = 'P';\nBlock.defaultChild = 'break';\nBlock.allowedChildren = [Inline, Parchment.Embed, TextBlot];\n\n\nfunction bubbleFormats(blot, formats = {}) {\n if (blot == null) return formats;\n if (typeof blot.formats === 'function') {\n formats = merge(formats, blot.formats());\n }\n if (blot.parent == null || blot.parent.blotName == 'scroll' || blot.parent.statics.scope !== blot.statics.scope) {\n return formats;\n }\n return bubbleFormats(blot.parent, formats);\n}\n\n\nexport { bubbleFormats, BlockEmbed, Block as default };\n","import Delta from 'quill-delta';\nimport Parchment from 'parchment';\nimport Block from '../blots/block';\nimport Inline from '../blots/inline';\nimport TextBlot from '../blots/text';\n\n\nclass Code extends Inline {}\nCode.blotName = 'code';\nCode.tagName = 'CODE';\n\n\nclass CodeBlock extends Block {\n static create(value) {\n let domNode = super.create(value);\n domNode.setAttribute('spellcheck', false);\n return domNode;\n }\n\n static formats() {\n return true;\n }\n\n delta() {\n let text = this.domNode.textContent;\n if (text.endsWith('\\n')) { // Should always be true\n text = text.slice(0, -1);\n }\n return text.split('\\n').reduce((delta, frag) => {\n return delta.insert(frag).insert('\\n', this.formats());\n }, new Delta());\n }\n\n format(name, value) {\n if (name === this.statics.blotName && value) return;\n let [text, ] = this.descendant(TextBlot, this.length() - 1);\n if (text != null) {\n text.deleteAt(text.length() - 1, 1);\n }\n super.format(name, value);\n }\n\n formatAt(index, length, name, value) {\n if (length === 0) return;\n if (Parchment.query(name, Parchment.Scope.BLOCK) == null ||\n (name === this.statics.blotName && value === this.statics.formats(this.domNode))) {\n return;\n }\n let nextNewline = this.newlineIndex(index);\n if (nextNewline < 0 || nextNewline >= index + length) return;\n let prevNewline = this.newlineIndex(index, true) + 1;\n let isolateLength = nextNewline - prevNewline + 1;\n let blot = this.isolate(prevNewline, isolateLength);\n let next = blot.next;\n blot.format(name, value);\n if (next instanceof CodeBlock) {\n next.formatAt(0, index - prevNewline + length - isolateLength, name, value);\n }\n }\n\n insertAt(index, value, def) {\n if (def != null) return;\n let [text, offset] = this.descendant(TextBlot, index);\n text.insertAt(offset, value);\n }\n\n length() {\n let length = this.domNode.textContent.length;\n if (!this.domNode.textContent.endsWith('\\n')) {\n return length + 1;\n }\n return length;\n }\n\n newlineIndex(searchIndex, reverse = false) {\n if (!reverse) {\n let offset = this.domNode.textContent.slice(searchIndex).indexOf('\\n');\n return offset > -1 ? searchIndex + offset : -1;\n } else {\n return this.domNode.textContent.slice(0, searchIndex).lastIndexOf('\\n');\n }\n }\n\n optimize(context) {\n if (!this.domNode.textContent.endsWith('\\n')) {\n this.appendChild(Parchment.create('text', '\\n'));\n }\n super.optimize(context);\n let next = this.next;\n if (next != null && next.prev === this &&\n next.statics.blotName === this.statics.blotName &&\n this.statics.formats(this.domNode) === next.statics.formats(next.domNode)) {\n next.optimize(context);\n next.moveChildren(this);\n next.remove();\n }\n }\n\n replace(target) {\n super.replace(target);\n [].slice.call(this.domNode.querySelectorAll('*')).forEach(function(node) {\n let blot = Parchment.find(node);\n if (blot == null) {\n node.parentNode.removeChild(node);\n } else if (blot instanceof Parchment.Embed) {\n blot.remove();\n } else {\n blot.unwrap();\n }\n });\n }\n}\nCodeBlock.blotName = 'code-block';\nCodeBlock.tagName = 'PRE';\nCodeBlock.TAB = ' ';\n\n\nexport { Code, CodeBlock as default };\n","import Parchment from 'parchment';\nimport TextBlot from './text';\n\n\nclass Cursor extends Parchment.Embed {\n static value() {\n return undefined;\n }\n\n constructor(domNode, selection) {\n super(domNode);\n this.selection = selection;\n this.textNode = document.createTextNode(Cursor.CONTENTS);\n this.domNode.appendChild(this.textNode);\n this._length = 0;\n }\n\n detach() {\n // super.detach() will also clear domNode.__blot\n if (this.parent != null) this.parent.removeChild(this);\n }\n\n format(name, value) {\n if (this._length !== 0) {\n return super.format(name, value);\n }\n let target = this, index = 0;\n while (target != null && target.statics.scope !== Parchment.Scope.BLOCK_BLOT) {\n index += target.offset(target.parent);\n target = target.parent;\n }\n if (target != null) {\n this._length = Cursor.CONTENTS.length;\n target.optimize();\n target.formatAt(index, Cursor.CONTENTS.length, name, value);\n this._length = 0;\n }\n }\n\n index(node, offset) {\n if (node === this.textNode) return 0;\n return super.index(node, offset);\n }\n\n length() {\n return this._length;\n }\n\n position() {\n return [this.textNode, this.textNode.data.length];\n }\n\n remove() {\n super.remove();\n this.parent = null;\n }\n\n restore() {\n if (this.selection.composing || this.parent == null) return;\n let textNode = this.textNode;\n let range = this.selection.getNativeRange();\n let restoreText, start, end;\n if (range != null && range.start.node === textNode && range.end.node === textNode) {\n [restoreText, start, end] = [textNode, range.start.offset, range.end.offset];\n }\n // Link format will insert text outside of anchor tag\n while (this.domNode.lastChild != null && this.domNode.lastChild !== this.textNode) {\n this.domNode.parentNode.insertBefore(this.domNode.lastChild, this.domNode);\n }\n if (this.textNode.data !== Cursor.CONTENTS) {\n let text = this.textNode.data.split(Cursor.CONTENTS).join('');\n if (this.next instanceof TextBlot) {\n restoreText = this.next.domNode;\n this.next.insertAt(0, text);\n this.textNode.data = Cursor.CONTENTS;\n } else {\n this.textNode.data = text;\n this.parent.insertBefore(Parchment.create(this.textNode), this);\n this.textNode = document.createTextNode(Cursor.CONTENTS);\n this.domNode.appendChild(this.textNode);\n }\n }\n this.remove();\n if (start != null) {\n [start, end] = [start, end].map(function(offset) {\n return Math.max(0, Math.min(restoreText.data.length, offset - 1));\n });\n return {\n startNode: restoreText,\n startOffset: start,\n endNode: restoreText,\n endOffset: end\n };\n }\n }\n\n update(mutations, context) {\n if (mutations.some((mutation) => {\n return mutation.type === 'characterData' && mutation.target === this.textNode;\n })) {\n let range = this.restore();\n if (range) context.range = range;\n }\n }\n\n value() {\n return '';\n }\n}\nCursor.blotName = 'cursor';\nCursor.className = 'ql-cursor';\nCursor.tagName = 'span';\nCursor.CONTENTS = \"\\uFEFF\"; // Zero width no break space\n\n\nexport default Cursor;\n","import cloneDeep from 'lodash.clonedeep';\nimport isEqual from 'lodash.isequal';\nimport merge from 'lodash.merge';\nimport Delta, { AttributeMap } from 'quill-delta';\nimport Parchment from 'parchment';\nimport CodeBlock from '../formats/code';\nimport CursorBlot from '../blots/cursor';\nimport Block, { bubbleFormats } from '../blots/block';\nimport Break from '../blots/break';\n\nconst ASCII = /^[ -~]*$/;\n\n\nclass Editor {\n constructor(scroll) {\n this.scroll = scroll;\n this.delta = this.getDelta();\n }\n\n applyDelta(delta) {\n let consumeNextNewline = false;\n this.scroll.update();\n let scrollLength = this.scroll.length();\n this.scroll.batchStart();\n delta = normalizeDelta(delta);\n delta.reduce((index, op) => {\n let length = op.retain || op.delete || op.insert.length || 1;\n let attributes = op.attributes || {};\n if (op.insert != null) {\n if (typeof op.insert === 'string') {\n let text = op.insert;\n if (text.endsWith('\\n') && consumeNextNewline) {\n consumeNextNewline = false;\n text = text.slice(0, -1);\n }\n if (index >= scrollLength && !text.endsWith('\\n')) {\n consumeNextNewline = true;\n }\n this.scroll.insertAt(index, text);\n let [line, offset] = this.scroll.line(index);\n let formats = merge({}, bubbleFormats(line));\n if (line instanceof Block) {\n let [leaf, ] = line.descendant(Parchment.Leaf, offset);\n formats = merge(formats, bubbleFormats(leaf));\n }\n attributes = AttributeMap.diff(formats, attributes) || {};\n } else if (typeof op.insert === 'object') {\n let key = Object.keys(op.insert)[0]; // There should only be one key\n if (key == null) return index;\n this.scroll.insertAt(index, key, op.insert[key]);\n }\n scrollLength += length;\n }\n Object.keys(attributes).forEach((name) => {\n this.scroll.formatAt(index, length, name, attributes[name]);\n });\n return index + length;\n }, 0);\n delta.reduce((index, op) => {\n if (typeof op.delete === 'number') {\n this.scroll.deleteAt(index, op.delete);\n return index;\n }\n return index + (op.retain || op.insert.length || 1);\n }, 0);\n this.scroll.batchEnd();\n return this.update(delta);\n }\n\n deleteText(index, length) {\n this.scroll.deleteAt(index, length);\n return this.update(new Delta().retain(index).delete(length));\n }\n\n formatLine(index, length, formats = {}) {\n this.scroll.update();\n Object.keys(formats).forEach((format) => {\n if (this.scroll.whitelist != null && !this.scroll.whitelist[format]) return;\n let lines = this.scroll.lines(index, Math.max(length, 1));\n let lengthRemaining = length;\n lines.forEach((line) => {\n let lineLength = line.length();\n if (!(line instanceof CodeBlock)) {\n line.format(format, formats[format]);\n } else {\n let codeIndex = index - line.offset(this.scroll);\n let codeLength = line.newlineIndex(codeIndex + lengthRemaining) - codeIndex + 1;\n line.formatAt(codeIndex, codeLength, format, formats[format]);\n }\n lengthRemaining -= lineLength;\n });\n });\n this.scroll.optimize();\n return this.update(new Delta().retain(index).retain(length, cloneDeep(formats)));\n }\n\n formatText(index, length, formats = {}) {\n Object.keys(formats).forEach((format) => {\n this.scroll.formatAt(index, length, format, formats[format]);\n });\n return this.update(new Delta().retain(index).retain(length, cloneDeep(formats)));\n }\n\n getContents(index, length) {\n return this.delta.slice(index, index + length);\n }\n\n getDelta() {\n return this.scroll.lines().reduce((delta, line) => {\n return delta.concat(line.delta());\n }, new Delta());\n }\n\n getFormat(index, length = 0) {\n let lines = [], leaves = [];\n if (length === 0) {\n this.scroll.path(index).forEach(function(path) {\n let [blot, ] = path;\n if (blot instanceof Block) {\n lines.push(blot);\n } else if (blot instanceof Parchment.Leaf) {\n leaves.push(blot);\n }\n });\n } else {\n lines = this.scroll.lines(index, length);\n leaves = this.scroll.descendants(Parchment.Leaf, index, length);\n }\n const [lineFormats, leafFormats] = [lines, leaves].map(function(blots) {\n if (blots.length === 0) return {};\n let formats = bubbleFormats(blots.shift());\n while (Object.keys(formats).length > 0) {\n let blot = blots.shift();\n if (blot == null) return formats;\n formats = combineFormats(bubbleFormats(blot), formats);\n }\n return formats;\n });\n return { ...lineFormats, ...leafFormats };\n }\n\n getText(index, length) {\n return this.getContents(index, length).filter(function(op) {\n return typeof op.insert === 'string';\n }).map(function(op) {\n return op.insert;\n }).join('');\n }\n\n insertEmbed(index, embed, value) {\n this.scroll.insertAt(index, embed, value);\n return this.update(new Delta().retain(index).insert({ [embed]: value }));\n }\n\n insertText(index, text, formats = {}) {\n text = text.replace(/\\r\\n/g, '\\n').replace(/\\r/g, '\\n');\n this.scroll.insertAt(index, text);\n Object.keys(formats).forEach((format) => {\n this.scroll.formatAt(index, text.length, format, formats[format]);\n });\n return this.update(new Delta().retain(index).insert(text, cloneDeep(formats)));\n }\n\n isBlank() {\n if (this.scroll.children.length == 0) return true;\n if (this.scroll.children.length > 1) return false;\n let block = this.scroll.children.head;\n if (block.statics.blotName !== Block.blotName) return false;\n if (block.children.length > 1) return false;\n return block.children.head instanceof Break;\n }\n\n removeFormat(index, length) {\n let text = this.getText(index, length);\n let [line, offset] = this.scroll.line(index + length);\n let suffixLength = 0, suffix = new Delta();\n if (line != null) {\n if (!(line instanceof CodeBlock)) {\n suffixLength = line.length() - offset;\n } else {\n suffixLength = line.newlineIndex(offset) - offset + 1;\n }\n suffix = line.delta().slice(offset, offset + suffixLength - 1).insert('\\n');\n }\n let contents = this.getContents(index, length + suffixLength);\n let diff = contents.diff(new Delta().insert(text).concat(suffix));\n let delta = new Delta().retain(index).concat(diff);\n return this.applyDelta(delta);\n }\n\n update(change, mutations = [], cursorIndex = undefined) {\n let oldDelta = this.delta;\n if (mutations.length === 1 &&\n mutations[0].type === 'characterData' &&\n mutations[0].target.data.match(ASCII) &&\n Parchment.find(mutations[0].target)) {\n // Optimization for character changes\n let textBlot = Parchment.find(mutations[0].target);\n let formats = bubbleFormats(textBlot);\n let index = textBlot.offset(this.scroll);\n let oldValue = mutations[0].oldValue.replace(CursorBlot.CONTENTS, '');\n let oldText = new Delta().insert(oldValue);\n let newText = new Delta().insert(textBlot.value());\n let diffDelta = new Delta().retain(index).concat(oldText.diff(newText, cursorIndex));\n change = diffDelta.reduce(function(delta, op) {\n if (op.insert) {\n return delta.insert(op.insert, formats);\n } else {\n return delta.push(op);\n }\n }, new Delta());\n this.delta = oldDelta.compose(change);\n } else {\n this.delta = this.getDelta();\n if (!change || !isEqual(oldDelta.compose(change), this.delta)) {\n change = oldDelta.diff(this.delta, cursorIndex);\n }\n }\n return change;\n }\n}\n\n\nfunction combineFormats(formats, combined) {\n return Object.keys(combined).reduce(function(merged, name) {\n if (formats[name] == null) return merged;\n if (combined[name] === formats[name]) {\n merged[name] = combined[name];\n } else if (Array.isArray(combined[name])) {\n if (combined[name].indexOf(formats[name]) < 0) {\n merged[name] = combined[name].concat([formats[name]]);\n }\n } else {\n merged[name] = [combined[name], formats[name]];\n }\n return merged;\n }, {});\n}\n\nfunction normalizeDelta(delta) {\n return delta.reduce(function(delta, op) {\n if (op.insert === 1) {\n let attributes = cloneDeep(op.attributes);\n delete attributes['image'];\n return delta.insert({ image: op.attributes.image }, attributes);\n }\n if (op.attributes != null && (op.attributes.list === true || op.attributes.bullet === true)) {\n op = cloneDeep(op);\n if (op.attributes.list) {\n op.attributes.list = 'ordered';\n } else {\n op.attributes.list = 'bullet';\n delete op.attributes.bullet;\n }\n }\n if (typeof op.insert === 'string') {\n let text = op.insert.replace(/\\r\\n/g, '\\n').replace(/\\r/g, '\\n');\n return delta.insert(text, op.attributes);\n }\n return delta.push(op);\n }, new Delta());\n}\n\n\nexport default Editor;\n","let levels = ['error', 'warn', 'log', 'info'];\nlet level = 'warn';\n\nfunction debug(method, ...args) {\n if (levels.indexOf(method) <= levels.indexOf(level)) {\n console[method](...args); // eslint-disable-line no-console\n }\n}\n\nfunction namespace(ns) {\n return levels.reduce(function(logger, method) {\n logger[method] = debug.bind(console, method, ns);\n return logger;\n }, {});\n}\n\ndebug.level = namespace.level = function(newLevel) {\n level = newLevel;\n};\n\n\nexport default namespace;\n","import EventEmitter from 'eventemitter3';\nimport logger from './logger';\n\nconst debug = logger('quill:events');\nconst EVENTS = ['selectionchange', 'mousedown', 'mouseup', 'click'];\nconst EMITTERS = [];\nconst supportsRootNode = ('getRootNode' in document);\n\nEVENTS.forEach(function(eventName) {\n document.addEventListener(eventName, (...args) => {\n EMITTERS.forEach((em) => {\n em.handleDOM(...args);\n });\n });\n});\n\n\nclass Emitter extends EventEmitter {\n constructor() {\n super();\n this.listeners = {};\n this.on('error', debug.error);\n }\n\n emit() {\n debug.log.apply(debug, arguments);\n super.emit.apply(this, arguments);\n }\n\n connect() {\n EMITTERS.push(this);\n }\n\n disconnect() {\n EMITTERS.splice(EMITTERS.indexOf(this), 1);\n }\n\n handleDOM(event, ...args) {\n const target = (event.composedPath ? event.composedPath()[0] : event.target);\n const containsNode = (node, target) => {\n if (!supportsRootNode || target.getRootNode() === document) {\n return node.contains(target);\n }\n\n while (!node.contains(target)) {\n const root = target.getRootNode();\n if (!root || !root.host) {\n return false;\n }\n target = root.host;\n }\n\n return true;\n };\n\n (this.listeners[event.type] || []).forEach(function({ node, handler }) {\n if (target === node || containsNode(node, target)) {\n handler(event, ...args);\n }\n });\n }\n\n listenDOM(eventName, node, handler) {\n if (!this.listeners[eventName]) {\n this.listeners[eventName] = [];\n }\n this.listeners[eventName].push({ node, handler })\n }\n}\n\nEmitter.events = {\n EDITOR_CHANGE : 'editor-change',\n SCROLL_BEFORE_UPDATE : 'scroll-before-update',\n SCROLL_OPTIMIZE : 'scroll-optimize',\n SCROLL_UPDATE : 'scroll-update',\n SELECTION_CHANGE : 'selection-change',\n TEXT_CHANGE : 'text-change'\n};\nEmitter.sources = {\n API : 'api',\n SILENT : 'silent',\n USER : 'user'\n};\n\n\nexport default Emitter;\n","class Module {\n constructor(quill, options = {}) {\n this.quill = quill;\n this.options = options;\n }\n}\nModule.DEFAULTS = {};\n\n\nexport default Module;\n","// see https://github.com/GoogleChromeLabs/shadow-selection-polyfill/issues/11\nconst SUPPORTS_SHADOW_SELECTION = typeof window.ShadowRoot.prototype.getSelection === 'function';\nconst SUPPORTS_BEFORE_INPUT = window.InputEvent && typeof window.InputEvent.prototype.getTargetRanges === 'function';\nconst IS_FIREFOX = window.navigator.userAgent.toLowerCase().indexOf('firefox') > -1;\nconst IS_MSIE = !!(window.navigator.userAgent.match(/Trident/) && !window.navigator.userAgent.match(/MSIE/));\nconst IS_EDGE = window.navigator.userAgent.match(/Edge/);\n\nlet processing = false;\nexport class ShadowSelection {\n constructor() {\n this._ranges = [];\n }\n\n get rangeCount() {\n return this._ranges.length;\n }\n\n getRangeAt(index) {\n return this._ranges[index];\n }\n\n addRange(range) {\n this._ranges.push(range);\n if (!processing) {\n let windowSel = window.getSelection();\n windowSel.removeAllRanges();\n windowSel.setBaseAndExtent(range.startContainer, range.startOffset, range.endContainer, range.endOffset);\n }\n }\n\n removeAllRanges() {\n this._ranges = [];\n }\n\n // todo: implement remaining `Selection` methods and properties.\n}\n\nfunction getActiveElement() {\n let active = document.activeElement;\n\n /* eslint-disable no-constant-condition */\n while (true) {\n if (active && active.shadowRoot && active.shadowRoot.activeElement) {\n active = active.shadowRoot.activeElement;\n } else {\n break;\n }\n }\n\n return active;\n}\n\nif ((IS_FIREFOX || IS_MSIE || IS_EDGE) && !SUPPORTS_SHADOW_SELECTION) {\n window.ShadowRoot.prototype.getSelection = function() {\n return document.getSelection();\n }\n}\n\nif (!IS_FIREFOX && !SUPPORTS_SHADOW_SELECTION && SUPPORTS_BEFORE_INPUT) {\n let selection = new ShadowSelection();\n\n window.ShadowRoot.prototype.getSelection = function() {\n return selection;\n }\n\n window.addEventListener('selectionchange', () => {\n if (!processing) {\n processing = true;\n\n const active = getActiveElement();\n\n if (active && (active.getAttribute('contenteditable') === 'true')) {\n document.execCommand('indent');\n } else {\n selection.removeAllRanges();\n }\n\n processing = false;\n }\n }, true);\n\n window.addEventListener('beforeinput', (event) => {\n if (processing) {\n const ranges = event.getTargetRanges();\n const range = ranges[0];\n\n const newRange = new Range();\n\n newRange.setStart(range.startContainer, range.startOffset);\n newRange.setEnd(range.endContainer, range.endOffset);\n\n selection.removeAllRanges();\n selection.addRange(newRange);\n\n event.preventDefault();\n event.stopImmediatePropagation();\n }\n }, true);\n\n window.addEventListener('selectstart', () => {\n selection.removeAllRanges();\n }, true);\n}\n","import cloneDeep from 'lodash.clonedeep';\nimport isEqual from 'lodash.isequal';\nimport Parchment from 'parchment';\nimport Emitter from './emitter';\nimport logger from './logger';\nimport { ShadowSelection } from './shadow-selection-polyfill';\n\nconst debug = logger('quill:selection');\n\nclass Range {\n constructor(index, length = 0) {\n this.index = index;\n this.length = length;\n }\n}\n\n\nclass Selection {\n constructor(scroll, emitter) {\n this.emitter = emitter;\n this.scroll = scroll;\n this.composing = false;\n this.mouseDown = false;\n this.root = this.scroll.domNode;\n this.rootDocument = (this.root.getRootNode ? this.root.getRootNode() : document);\n this.cursor = Parchment.create('cursor', this);\n // savedRange is last non-null range\n this.lastRange = this.savedRange = new Range(0, 0);\n this.handleComposition();\n this.handleDragging();\n this.emitter.listenDOM('selectionchange', document, () => {\n if (!this.mouseDown && !this.composing) {\n setTimeout(this.update.bind(this, Emitter.sources.USER), 1);\n }\n });\n this.emitter.on(Emitter.events.SCROLL_BEFORE_UPDATE, (_, mutations) => {\n if (!this.hasFocus()) return;\n const native = this.getNativeRange();\n\n if (native == null) return;\n\n // We might need to hack the offset on Safari, when we are dealing with the first character of a row.\n // This likely happens because of a race condition between quill's update method being called before the\n // selectionchange event being fired in the selection polyfill.\n const hackOffset = (native.start.offset === 0 &&\n native.start.offset === native.end.offset &&\n this.rootDocument.getSelection() instanceof ShadowSelection &&\n mutations.some((a) => a.type === 'characterData' && a.oldValue === '')) ? 1 : 0;\n if (native.start.node === this.cursor.textNode) return; // cursor.restore() will handle\n // TODO unclear if this has negative side effects\n this.emitter.once(Emitter.events.SCROLL_UPDATE, () => {\n try {\n if (\n this.root.contains(native.start.node) &&\n this.root.contains(native.end.node)\n ) {\n this.setNativeRange(\n native.start.node,\n native.start.offset + hackOffset,\n native.end.node,\n native.end.offset + hackOffset\n );\n }\n this.update(Emitter.sources.SILENT);\n } catch (ignored) {\n // ignore\n }\n });\n });\n this.emitter.on(Emitter.events.SCROLL_OPTIMIZE, (mutations, context) => {\n if (context.range) {\n const { startNode, startOffset, endNode, endOffset } = context.range;\n this.setNativeRange(startNode, startOffset, endNode, endOffset);\n }\n });\n this.update(Emitter.sources.SILENT);\n }\n\n handleComposition() {\n this.root.addEventListener('compositionstart', () => {\n this.composing = true;\n });\n this.root.addEventListener('compositionend', () => {\n this.composing = false;\n if (this.cursor.parent) {\n const range = this.cursor.restore();\n if (!range) return;\n setTimeout(() => {\n this.setNativeRange(range.startNode, range.startOffset, range.endNode, range.endOffset);\n }, 1);\n }\n });\n }\n\n handleDragging() {\n this.emitter.listenDOM('mousedown', document.body, () => {\n this.mouseDown = true;\n });\n this.emitter.listenDOM('mouseup', document.body, () => {\n this.mouseDown = false;\n this.update(Emitter.sources.USER);\n });\n }\n\n focus() {\n if (this.hasFocus()) return;\n this.root.focus();\n this.setRange(this.savedRange);\n }\n\n format(format, value) {\n if (this.scroll.whitelist != null && !this.scroll.whitelist[format]) return;\n this.scroll.update();\n let nativeRange = this.getNativeRange();\n if (nativeRange == null || !nativeRange.native.collapsed || Parchment.query(format, Parchment.Scope.BLOCK)) return;\n if (nativeRange.start.node !== this.cursor.textNode) {\n let blot = Parchment.find(nativeRange.start.node, false);\n if (blot == null) return;\n // TODO Give blot ability to not split\n if (blot instanceof Parchment.Leaf) {\n let after = blot.split(nativeRange.start.offset);\n blot.parent.insertBefore(this.cursor, after);\n } else {\n blot.insertBefore(this.cursor, nativeRange.start.node); // Should never happen\n }\n this.cursor.attach();\n }\n this.cursor.format(format, value);\n this.scroll.optimize();\n this.setNativeRange(this.cursor.textNode, this.cursor.textNode.data.length);\n this.update();\n }\n\n getBounds(index, length = 0) {\n let scrollLength = this.scroll.length();\n index = Math.min(index, scrollLength - 1);\n length = Math.min(index + length, scrollLength - 1) - index;\n let node, [leaf, offset] = this.scroll.leaf(index);\n if (leaf == null) return null;\n [node, offset] = leaf.position(offset, true);\n let range = document.createRange();\n if (length > 0) {\n range.setStart(node, offset);\n [leaf, offset] = this.scroll.leaf(index + length);\n if (leaf == null) return null;\n [node, offset] = leaf.position(offset, true);\n range.setEnd(node, offset);\n return range.getBoundingClientRect();\n } else {\n let side = 'left';\n let rect;\n if (node instanceof Text) {\n if (offset < node.data.length) {\n range.setStart(node, offset);\n range.setEnd(node, offset + 1);\n } else {\n range.setStart(node, offset - 1);\n range.setEnd(node, offset);\n side = 'right';\n }\n rect = range.getBoundingClientRect();\n } else {\n rect = leaf.domNode.getBoundingClientRect();\n if (offset > 0) side = 'right';\n }\n return {\n bottom: rect.top + rect.height,\n height: rect.height,\n left: rect[side],\n right: rect[side],\n top: rect.top,\n width: 0\n };\n }\n }\n\n getNativeRange() {\n const selection = this.rootDocument.getSelection();\n if (selection == null || selection.rangeCount <= 0) return null;\n const nativeRange = selection.getRangeAt(0);\n if (nativeRange == null) return null;\n let range = this.normalizeNative(nativeRange);\n debug.info('getNativeRange', range);\n return range;\n }\n\n getRange() {\n let normalized = this.getNativeRange();\n if (normalized == null) return [null, null];\n let range = this.normalizedToRange(normalized);\n return [range, normalized];\n }\n\n hasFocus() {\n return this.rootDocument.activeElement === this.root;\n }\n\n normalizedToRange(range) {\n let positions = [[range.start.node, range.start.offset]];\n if (!range.native.collapsed) {\n positions.push([range.end.node, range.end.offset]);\n }\n let indexes = positions.map((position) => {\n let [node, offset] = position;\n let blot = Parchment.find(node, true);\n let index = blot.offset(this.scroll);\n if (offset === 0) {\n return index;\n } else if (blot instanceof Parchment.Container) {\n return index + blot.length();\n } else {\n return index + blot.index(node, offset);\n }\n });\n let end = Math.min(Math.max(...indexes), this.scroll.length() - 1);\n let start = Math.min(end, ...indexes);\n return new Range(start, end-start);\n }\n\n normalizeNative(nativeRange) {\n if (!contains(this.root, nativeRange.startContainer) ||\n (!nativeRange.collapsed && !contains(this.root, nativeRange.endContainer))) {\n return null;\n }\n let range = {\n start: { node: nativeRange.startContainer, offset: nativeRange.startOffset },\n end: { node: nativeRange.endContainer, offset: nativeRange.endOffset },\n native: nativeRange\n };\n [range.start, range.end].forEach(function(position) {\n let node = position.node, offset = position.offset;\n while (!(node instanceof Text) && node.childNodes.length > 0) {\n if (node.childNodes.length > offset) {\n node = node.childNodes[offset];\n offset = 0;\n } else if (node.childNodes.length === offset) {\n node = node.lastChild;\n offset = node instanceof Text ? node.data.length : node.childNodes.length + 1;\n } else {\n break;\n }\n }\n position.node = node, position.offset = offset;\n });\n return range;\n }\n\n rangeToNative(range) {\n let indexes = range.collapsed ? [range.index] : [range.index, range.index + range.length];\n let args = [];\n let scrollLength = this.scroll.length();\n indexes.forEach((index, i) => {\n index = Math.min(scrollLength - 1, index);\n let node, [leaf, offset] = this.scroll.leaf(index);\n [node, offset] = leaf.position(offset, i !== 0);\n args.push(node, offset);\n });\n if (args.length < 2) {\n args = args.concat(args);\n }\n return args;\n }\n\n scrollIntoView(scrollingContainer) {\n let range = this.lastRange;\n if (range == null) return;\n let bounds = this.getBounds(range.index, range.length);\n if (bounds == null) return;\n let limit = this.scroll.length()-1;\n let [first, ] = this.scroll.line(Math.min(range.index, limit));\n let last = first;\n if (range.length > 0) {\n [last, ] = this.scroll.line(Math.min(range.index + range.length, limit));\n }\n if (first == null || last == null) return;\n let scrollBounds = scrollingContainer.getBoundingClientRect();\n if (bounds.top < scrollBounds.top) {\n scrollingContainer.scrollTop -= (scrollBounds.top - bounds.top);\n } else if (bounds.bottom > scrollBounds.bottom) {\n scrollingContainer.scrollTop += (bounds.bottom - scrollBounds.bottom);\n }\n }\n\n setNativeRange(startNode, startOffset, endNode = startNode, endOffset = startOffset, force = false) {\n debug.info('setNativeRange', startNode, startOffset, endNode, endOffset);\n if (startNode != null && (this.root.parentNode == null || startNode.parentNode == null || endNode.parentNode == null)) {\n return;\n }\n const selection = this.rootDocument.getSelection();\n if (selection == null) return;\n if (startNode != null) {\n if (!this.hasFocus()) this.root.focus();\n let native = (this.getNativeRange() || {}).native;\n if (native == null || force ||\n startNode !== native.startContainer ||\n startOffset !== native.startOffset ||\n endNode !== native.endContainer ||\n endOffset !== native.endOffset) {\n\n if (startNode.tagName == \"BR\") {\n startOffset = [].indexOf.call(startNode.parentNode.childNodes, startNode);\n startNode = startNode.parentNode;\n }\n if (endNode.tagName == \"BR\") {\n endOffset = [].indexOf.call(endNode.parentNode.childNodes, endNode);\n endNode = endNode.parentNode;\n }\n let range = document.createRange();\n range.setStart(startNode, startOffset);\n range.setEnd(endNode, endOffset);\n selection.removeAllRanges();\n selection.addRange(range);\n }\n } else {\n selection.removeAllRanges();\n this.root.blur();\n document.body.focus(); // root.blur() not enough on IE11+Travis+SauceLabs (but not local VMs)\n }\n }\n\n setRange(range, force = false, source = Emitter.sources.API) {\n if (typeof force === 'string') {\n source = force;\n force = false;\n }\n debug.info('setRange', range);\n if (range != null) {\n let args = this.rangeToNative(range);\n this.setNativeRange(...args, force);\n } else {\n this.setNativeRange(null);\n }\n this.update(source);\n }\n\n update(source = Emitter.sources.USER) {\n let oldRange = this.lastRange;\n let [lastRange, nativeRange] = this.getRange();\n this.lastRange = lastRange;\n if (this.lastRange != null) {\n this.savedRange = this.lastRange;\n }\n if (!isEqual(oldRange, this.lastRange)) {\n if (!this.composing && nativeRange != null && nativeRange.native.collapsed && nativeRange.start.node !== this.cursor.textNode) {\n this.cursor.restore();\n }\n let args = [Emitter.events.SELECTION_CHANGE, cloneDeep(this.lastRange), cloneDeep(oldRange), source];\n this.emitter.emit(Emitter.events.EDITOR_CHANGE, ...args);\n if (source !== Emitter.sources.SILENT) {\n this.emitter.emit(...args);\n }\n }\n }\n}\n\n\nfunction contains(parent, descendant) {\n try {\n // Firefox inserts inaccessible nodes around video elements\n descendant.parentNode;\n } catch (e) {\n return false;\n }\n // IE11 has bug with Text nodes\n // https://connect.microsoft.com/IE/feedback/details/780874/node-contains-is-incorrect\n if (descendant instanceof Text) {\n descendant = descendant.parentNode;\n }\n return parent.contains(descendant);\n}\n\n\nexport { Range, Selection as default };\n","class Theme {\n constructor(quill, options) {\n this.quill = quill;\n this.options = options;\n this.modules = {};\n }\n\n init() {\n Object.keys(this.options.modules).forEach((name) => {\n if (this.modules[name] == null) {\n this.addModule(name);\n }\n });\n }\n\n addModule(name) {\n let moduleClass = this.quill.constructor.import(`modules/${name}`);\n this.modules[name] = new moduleClass(this.quill, this.options.modules[name] || {});\n return this.modules[name];\n }\n}\nTheme.DEFAULTS = {\n modules: {}\n};\nTheme.themes = {\n 'default': Theme\n};\n\n\nexport default Theme;\n","import './polyfill';\nimport merge from 'lodash.merge';\nimport Delta from 'quill-delta';\nimport Editor from './editor';\nimport Emitter from './emitter';\nimport Module from './module';\nimport Parchment from 'parchment';\nimport Selection, { Range } from './selection';\nimport logger from './logger';\nimport Theme from './theme';\n\nlet debug = logger('quill');\n\n\nclass Quill {\n static debug(limit) {\n if (limit === true) {\n limit = 'log';\n }\n logger.level(limit);\n }\n\n static find(node) {\n return node.__quill || Parchment.find(node);\n }\n\n static import(name) {\n if (this.imports[name] == null) {\n debug.error(`Cannot import ${name}. Are you sure it was registered?`);\n }\n return this.imports[name];\n }\n\n static register(path, target, overwrite = false) {\n if (typeof path !== 'string') {\n let name = path.attrName || path.blotName;\n if (typeof name === 'string') {\n // register(Blot | Attributor, overwrite)\n this.register('formats/' + name, path, target);\n } else {\n Object.keys(path).forEach((key) => {\n this.register(key, path[key], target);\n });\n }\n } else {\n if (this.imports[path] != null && !overwrite) {\n debug.warn(`Overwriting ${path} with`, target);\n }\n this.imports[path] = target;\n if ((path.startsWith('blots/') || path.startsWith('formats/')) &&\n target.blotName !== 'abstract') {\n Parchment.register(target);\n } else if (path.startsWith('modules') && typeof target.register === 'function') {\n target.register();\n }\n }\n }\n\n constructor(container, options = {}) {\n this.options = expandConfig(container, options);\n this.container = this.options.container;\n if (this.container == null) {\n return debug.error('Invalid Quill container', container);\n }\n if (this.options.debug) {\n Quill.debug(this.options.debug);\n }\n let html = this.container.innerHTML.trim();\n this.container.classList.add('ql-container');\n this.container.innerHTML = '';\n this.container.__quill = this;\n this.root = this.addContainer('ql-editor');\n this.root.classList.add('ql-blank');\n this.root.setAttribute('data-gramm', false);\n this.scrollingContainer = this.options.scrollingContainer || this.root;\n this.emitter = new Emitter();\n this.scroll = Parchment.create(this.root, {\n emitter: this.emitter,\n whitelist: this.options.formats\n });\n this.editor = new Editor(this.scroll);\n this.selection = new Selection(this.scroll, this.emitter);\n this.theme = new this.options.theme(this, this.options);\n this.keyboard = this.theme.addModule('keyboard');\n this.clipboard = this.theme.addModule('clipboard');\n this.history = this.theme.addModule('history');\n this.theme.init();\n this.emitter.on(Emitter.events.EDITOR_CHANGE, (type) => {\n if (type === Emitter.events.TEXT_CHANGE) {\n this.root.classList.toggle('ql-blank', this.editor.isBlank());\n }\n });\n this.emitter.on(Emitter.events.SCROLL_UPDATE, (source, mutations) => {\n let range = this.selection.lastRange;\n let index = range && range.length === 0 ? range.index : undefined;\n modify.call(this, () => {\n return this.editor.update(null, mutations, index);\n }, source);\n });\n let contents = this.clipboard.convert(`<div class='ql-editor' style=\"white-space: normal;\">${html}<p><br></p></div>`);\n this.setContents(contents);\n this.history.clear();\n if (this.options.placeholder) {\n this.root.setAttribute('data-placeholder', this.options.placeholder);\n }\n if (this.options.readOnly) {\n this.disable();\n }\n }\n\n addContainer(container, refNode = null) {\n if (typeof container === 'string') {\n let className = container;\n container = document.createElement('div');\n container.classList.add(className);\n }\n this.container.insertBefore(container, refNode);\n return container;\n }\n\n blur() {\n this.selection.setRange(null);\n }\n\n deleteText(index, length, source) {\n [index, length, , source] = overload(index, length, source);\n return modify.call(this, () => {\n return this.editor.deleteText(index, length);\n }, source, index, -1*length);\n }\n\n disable() {\n this.enable(false);\n }\n\n enable(enabled = true) {\n this.scroll.enable(enabled);\n this.container.classList.toggle('ql-disabled', !enabled);\n }\n\n focus() {\n let scrollTop = this.scrollingContainer.scrollTop;\n this.selection.focus();\n this.scrollingContainer.scrollTop = scrollTop;\n this.scrollIntoView();\n }\n\n format(name, value, source = Emitter.sources.API) {\n return modify.call(this, () => {\n let range = this.getSelection(true);\n let change = new Delta();\n if (range == null) {\n return change;\n } else if (Parchment.query(name, Parchment.Scope.BLOCK)) {\n change = this.editor.formatLine(range.index, range.length, { [name]: value });\n } else if (range.length === 0) {\n this.selection.format(name, value);\n return change;\n } else {\n change = this.editor.formatText(range.index, range.length, { [name]: value });\n }\n this.setSelection(range, Emitter.sources.SILENT);\n return change;\n }, source);\n }\n\n formatLine(index, length, name, value, source) {\n let formats;\n [index, length, formats, source] = overload(index, length, name, value, source);\n return modify.call(this, () => {\n return this.editor.formatLine(index, length, formats);\n }, source, index, 0);\n }\n\n formatText(index, length, name, value, source) {\n let formats;\n [index, length, formats, source] = overload(index, length, name, value, source);\n return modify.call(this, () => {\n return this.editor.formatText(index, length, formats);\n }, source, index, 0);\n }\n\n getBounds(index, length = 0) {\n let bounds;\n if (typeof index === 'number') {\n bounds = this.selection.getBounds(index, length);\n } else {\n bounds = this.selection.getBounds(index.index, index.length);\n }\n let containerBounds = this.container.getBoundingClientRect();\n return {\n bottom: bounds.bottom - containerBounds.top,\n height: bounds.height,\n left: bounds.left - containerBounds.left,\n right: bounds.right - containerBounds.left,\n top: bounds.top - containerBounds.top,\n width: bounds.width\n };\n }\n\n getContents(index = 0, length = this.getLength() - index) {\n [index, length] = overload(index, length);\n return this.editor.getContents(index, length);\n }\n\n getFormat(index = this.getSelection(true), length = 0) {\n if (typeof index === 'number') {\n return this.editor.getFormat(index, length);\n } else {\n return this.editor.getFormat(index.index, index.length);\n }\n }\n\n getIndex(blot) {\n return blot.offset(this.scroll);\n }\n\n getLength() {\n return this.scroll.length();\n }\n\n getLeaf(index) {\n return this.scroll.leaf(index);\n }\n\n getLine(index) {\n return this.scroll.line(index);\n }\n\n getLines(index = 0, length = Number.MAX_VALUE) {\n if (typeof index !== 'number') {\n return this.scroll.lines(index.index, index.length);\n } else {\n return this.scroll.lines(index, length);\n }\n }\n\n getModule(name) {\n return this.theme.modules[name];\n }\n\n getSelection(focus = false) {\n if (focus) this.focus();\n this.update(); // Make sure we access getRange with editor in consistent state\n return this.selection.getRange()[0];\n }\n\n getText(index = 0, length = this.getLength() - index) {\n [index, length] = overload(index, length);\n return this.editor.getText(index, length);\n }\n\n hasFocus() {\n return this.selection.hasFocus();\n }\n\n insertEmbed(index, embed, value, source = Quill.sources.API) {\n return modify.call(this, () => {\n return this.editor.insertEmbed(index, embed, value);\n }, source, index);\n }\n\n insertText(index, text, name, value, source) {\n let formats;\n [index, , formats, source] = overload(index, 0, name, value, source);\n return modify.call(this, () => {\n return this.editor.insertText(index, text, formats);\n }, source, index, text.length);\n }\n\n isEnabled() {\n return !this.container.classList.contains('ql-disabled');\n }\n\n off() {\n return this.emitter.off.apply(this.emitter, arguments);\n }\n\n on() {\n return this.emitter.on.apply(this.emitter, arguments);\n }\n\n once() {\n return this.emitter.once.apply(this.emitter, arguments);\n }\n\n pasteHTML(index, html, source) {\n this.clipboard.dangerouslyPasteHTML(index, html, source);\n }\n\n removeFormat(index, length, source) {\n [index, length, , source] = overload(index, length, source);\n return modify.call(this, () => {\n return this.editor.removeFormat(index, length);\n }, source, index);\n }\n\n scrollIntoView() {\n this.selection.scrollIntoView(this.scrollingContainer);\n }\n\n setContents(delta, source = Emitter.sources.API) {\n return modify.call(this, () => {\n delta = new Delta(delta);\n let length = this.getLength();\n let deleted = this.editor.deleteText(0, length);\n let applied = this.editor.applyDelta(delta);\n let lastOp = applied.ops[applied.ops.length - 1];\n if (lastOp != null && typeof(lastOp.insert) === 'string' && lastOp.insert[lastOp.insert.length-1] === '\\n') {\n this.editor.deleteText(this.getLength() - 1, 1);\n applied.delete(1);\n }\n let ret = deleted.compose(applied);\n return ret;\n }, source);\n }\n\n setSelection(index, length, source) {\n if (index == null) {\n this.selection.setRange(null, length || Quill.sources.API);\n } else {\n [index, length, , source] = overload(index, length, source);\n this.selection.setRange(new Range(index, length), source);\n if (source !== Emitter.sources.SILENT) {\n this.selection.scrollIntoView(this.scrollingContainer);\n }\n }\n }\n\n setText(text, source = Emitter.sources.API) {\n let delta = new Delta().insert(text);\n return this.setContents(delta, source);\n }\n\n update(source = Emitter.sources.USER) {\n let change = this.scroll.update(source); // Will update selection before selection.update() does if text changes\n this.selection.update(source);\n return change;\n }\n\n updateContents(delta, source = Emitter.sources.API) {\n return modify.call(this, () => {\n delta = new Delta(delta);\n return this.editor.applyDelta(delta, source);\n }, source, true);\n }\n}\nQuill.DEFAULTS = {\n bounds: null,\n formats: null,\n modules: {},\n placeholder: '',\n readOnly: false,\n scrollingContainer: null,\n strict: true,\n theme: 'default'\n};\nQuill.events = Emitter.events;\nQuill.sources = Emitter.sources;\n// eslint-disable-next-line no-undef\nQuill.version = typeof(QUILL_VERSION) === 'undefined' ? 'dev' : QUILL_VERSION;\n\nQuill.imports = {\n 'delta' : Delta,\n 'parchment' : Parchment,\n 'core/module' : Module,\n 'core/theme' : Theme\n};\n\n\nfunction expandConfig(container, userConfig) {\n userConfig = merge({\n container: container,\n modules: {\n clipboard: true,\n keyboard: true,\n history: true\n }\n }, userConfig);\n if (!userConfig.theme || userConfig.theme === Quill.DEFAULTS.theme) {\n userConfig.theme = Theme;\n } else {\n userConfig.theme = Quill.import(`themes/${userConfig.theme}`);\n if (userConfig.theme == null) {\n throw new Error(`Invalid theme ${userConfig.theme}. Did you register it?`);\n }\n }\n let themeConfig = merge({}, userConfig.theme.DEFAULTS);\n [themeConfig, userConfig].forEach(function(config) {\n config.modules = config.modules || {};\n Object.keys(config.modules).forEach(function(module) {\n if (config.modules[module] === true) {\n config.modules[module] = {};\n }\n });\n });\n let moduleNames = Object.keys(themeConfig.modules).concat(Object.keys(userConfig.modules));\n let moduleConfig = moduleNames.reduce(function(config, name) {\n let moduleClass = Quill.import(`modules/${name}`);\n if (moduleClass == null) {\n debug.error(`Cannot load ${name} module. Are you sure you registered it?`);\n } else {\n config[name] = moduleClass.DEFAULTS || {};\n }\n return config;\n }, {});\n // Special case toolbar shorthand\n if (userConfig.modules != null && userConfig.modules.toolbar &&\n userConfig.modules.toolbar.constructor !== Object) {\n userConfig.modules.toolbar = {\n container: userConfig.modules.toolbar\n };\n }\n userConfig = merge({}, Quill.DEFAULTS, { modules: moduleConfig }, themeConfig, userConfig);\n ['bounds', 'container', 'scrollingContainer'].forEach(function(key) {\n if (typeof userConfig[key] === 'string') {\n userConfig[key] = document.querySelector(userConfig[key]);\n }\n });\n userConfig.modules = Object.keys(userConfig.modules).reduce(function(config, name) {\n if (userConfig.modules[name]) {\n config[name] = userConfig.modules[name];\n }\n return config;\n }, {});\n return userConfig;\n}\n\n// Handle selection preservation and TEXT_CHANGE emission\n// common to modification APIs\nfunction modify(modifier, source, index, shift) {\n if (this.options.strict && !this.isEnabled() && source === Emitter.sources.USER) {\n return new Delta();\n }\n let range = index == null ? null : this.getSelection();\n let oldDelta = this.editor.delta;\n let change = modifier();\n if (range != null) {\n if (index === true) index = range.index;\n if (shift == null) {\n range = shiftRange(range, change, source);\n } else if (shift !== 0) {\n range = shiftRange(range, index, shift, source);\n }\n this.setSelection(range, Emitter.sources.SILENT);\n }\n if (change.length() > 0) {\n let args = [Emitter.events.TEXT_CHANGE, change, oldDelta, source];\n this.emitter.emit(Emitter.events.EDITOR_CHANGE, ...args);\n if (source !== Emitter.sources.SILENT) {\n this.emitter.emit(...args);\n }\n }\n return change;\n}\n\nfunction overload(index, length, name, value, source) {\n let formats = {};\n if (typeof index.index === 'number' && typeof index.length === 'number') {\n // Allow for throwaway end (used by insertText/insertEmbed)\n if (typeof length !== 'number') {\n source = value, value = name, name = length, length = index.length, index = index.index;\n } else {\n length = index.length, index = index.index;\n }\n } else if (typeof length !== 'number') {\n source = value, value = name, name = length, length = 0;\n }\n // Handle format being object, two format name/value strings or excluded\n if (typeof name === 'object') {\n formats = name;\n source = value;\n } else if (typeof name === 'string') {\n if (value != null) {\n formats[name] = value;\n } else {\n source = name;\n }\n }\n // Handle optional source\n source = source || Emitter.sources.API;\n return [index, length, formats, source];\n}\n\nfunction shiftRange(range, index, length, source) {\n if (range == null) return null;\n let start, end;\n if (index instanceof Delta) {\n [start, end] = [range.index, range.index + range.length].map(function(pos) {\n return index.transformPosition(pos, source !== Emitter.sources.USER);\n });\n } else {\n [start, end] = [range.index, range.index + range.length].map(function(pos) {\n if (pos < index || (pos === index && source === Emitter.sources.USER)) return pos;\n if (length >= 0) {\n return pos + length;\n } else {\n return Math.max(index, pos + length);\n }\n });\n }\n return new Range(start, end - start);\n}\n\n\nexport { expandConfig, overload, Quill as default };\n","import Parchment from 'parchment';\nimport Block, { BlockEmbed } from './block';\n\n\nclass Container extends Parchment.Container { }\nContainer.allowedChildren = [Block, BlockEmbed, Container];\n\n\nexport default Container;\n","import Parchment from 'parchment';\nimport TextBlot from './text';\n\nconst GUARD_TEXT = \"\\uFEFF\";\n\n\nclass Embed extends Parchment.Embed {\n constructor(node) {\n super(node);\n this.contentNode = document.createElement('span');\n this.contentNode.setAttribute('contenteditable', false);\n [].slice.call(this.domNode.childNodes).forEach((childNode) => {\n this.contentNode.appendChild(childNode);\n });\n this.leftGuard = document.createTextNode(GUARD_TEXT);\n this.rightGuard = document.createTextNode(GUARD_TEXT);\n this.domNode.appendChild(this.leftGuard);\n this.domNode.appendChild(this.contentNode);\n this.domNode.appendChild(this.rightGuard);\n }\n\n index(node, offset) {\n if (node === this.leftGuard) return 0;\n if (node === this.rightGuard) return 1;\n return super.index(node, offset);\n }\n\n restore(node) {\n let range, textNode;\n let text = node.data.split(GUARD_TEXT).join('');\n if (node === this.leftGuard) {\n if (this.prev instanceof TextBlot) {\n let prevLength = this.prev.length();\n this.prev.insertAt(prevLength, text);\n range = {\n startNode: this.prev.domNode,\n startOffset: prevLength + text.length\n };\n } else {\n textNode = document.createTextNode(text);\n this.parent.insertBefore(Parchment.create(textNode), this);\n range = {\n startNode: textNode,\n startOffset: text.length\n };\n }\n } else if (node === this.rightGuard) {\n if (this.next instanceof TextBlot) {\n this.next.insertAt(0, text);\n range = {\n startNode: this.next.domNode,\n startOffset: text.length\n }\n } else {\n textNode = document.createTextNode(text);\n this.parent.insertBefore(Parchment.create(textNode), this.next);\n range = {\n startNode: textNode,\n startOffset: text.length\n };\n }\n }\n node.data = GUARD_TEXT;\n return range;\n }\n\n update(mutations, context) {\n mutations.forEach((mutation) => {\n if (mutation.type === 'characterData' &&\n (mutation.target === this.leftGuard || mutation.target === this.rightGuard)) {\n let range = this.restore(mutation.target);\n if (range) context.range = range;\n }\n });\n }\n}\n\n\nexport default Embed;\n","import Parchment from 'parchment';\nimport Emitter from '../core/emitter';\nimport Block, { BlockEmbed } from './block';\nimport Break from './break';\nimport CodeBlock from '../formats/code';\nimport Container from './container';\n\n\nfunction isLine(blot) {\n return (blot instanceof Block || blot instanceof BlockEmbed);\n}\n\n\nclass Scroll extends Parchment.Scroll {\n constructor(domNode, config) {\n super(domNode);\n this.emitter = config.emitter;\n if (Array.isArray(config.whitelist)) {\n this.whitelist = config.whitelist.reduce(function(whitelist, format) {\n whitelist[format] = true;\n return whitelist;\n }, {});\n }\n this.optimize();\n this.enable();\n }\n\n batchStart() {\n this.batch = true;\n }\n\n batchEnd() {\n this.batch = false;\n this.optimize();\n }\n\n deleteAt(index, length) {\n let [first, offset] = this.line(index);\n let [last, ] = this.line(index + length);\n super.deleteAt(index, length);\n if (last != null && first !== last && offset > 0) {\n if (first instanceof BlockEmbed || last instanceof BlockEmbed) {\n this.optimize();\n return;\n }\n if (first instanceof CodeBlock) {\n let newlineIndex = first.newlineIndex(first.length(), true);\n if (newlineIndex > -1) {\n first = first.split(newlineIndex + 1);\n if (first === last) {\n this.optimize();\n return;\n }\n }\n } else if (last instanceof CodeBlock) {\n let newlineIndex = last.newlineIndex(0);\n if (newlineIndex > -1) {\n last.split(newlineIndex + 1);\n }\n }\n let ref = last.children.head instanceof Break ? null : last.children.head;\n first.moveChildren(last, ref);\n first.remove();\n }\n this.optimize();\n }\n\n enable(enabled = true) {\n this.domNode.setAttribute('contenteditable', enabled);\n }\n\n formatAt(index, length, format, value) {\n if (this.whitelist != null && !this.whitelist[format]) return;\n super.formatAt(index, length, format, value);\n this.optimize();\n }\n\n insertAt(index, value, def) {\n if (def != null && this.whitelist != null && !this.whitelist[value]) return;\n if (index >= this.length()) {\n if (def == null || Parchment.query(value, Parchment.Scope.BLOCK) == null) {\n let blot = Parchment.create(this.statics.defaultChild);\n this.appendChild(blot);\n if (def == null && value.endsWith('\\n')) {\n value = value.slice(0, -1);\n }\n blot.insertAt(0, value, def);\n } else {\n let embed = Parchment.create(value, def);\n this.appendChild(embed);\n }\n } else {\n super.insertAt(index, value, def);\n }\n this.optimize();\n }\n\n insertBefore(blot, ref) {\n if (blot.statics.scope === Parchment.Scope.INLINE_BLOT) {\n let wrapper = Parchment.create(this.statics.defaultChild);\n wrapper.appendChild(blot);\n blot = wrapper;\n }\n super.insertBefore(blot, ref);\n }\n\n leaf(index) {\n return this.path(index).pop() || [null, -1];\n }\n\n line(index) {\n if (index === this.length()) {\n return this.line(index - 1);\n }\n return this.descendant(isLine, index);\n }\n\n lines(index = 0, length = Number.MAX_VALUE) {\n let getLines = (blot, index, length) => {\n let lines = [], lengthLeft = length;\n blot.children.forEachAt(index, length, function(child, index, length) {\n if (isLine(child)) {\n lines.push(child);\n } else if (child instanceof Parchment.Container) {\n lines = lines.concat(getLines(child, index, lengthLeft));\n }\n lengthLeft -= length;\n });\n return lines;\n };\n return getLines(this, index, length);\n }\n\n optimize(mutations = [], context = {}) {\n if (this.batch === true) return;\n super.optimize(mutations, context);\n if (mutations.length > 0) {\n this.emitter.emit(Emitter.events.SCROLL_OPTIMIZE, mutations, context);\n }\n }\n\n path(index) {\n return super.path(index).slice(1); // Exclude self\n }\n\n update(mutations) {\n if (this.batch === true) return;\n let source = Emitter.sources.USER;\n if (typeof mutations === 'string') {\n source = mutations;\n }\n if (!Array.isArray(mutations)) {\n mutations = this.observer.takeRecords();\n }\n if (mutations.length > 0) {\n this.emitter.emit(Emitter.events.SCROLL_BEFORE_UPDATE, source, mutations);\n }\n super.update(mutations.concat([])); // pass copy\n if (mutations.length > 0) {\n this.emitter.emit(Emitter.events.SCROLL_UPDATE, source, mutations);\n }\n }\n}\nScroll.blotName = 'scroll';\nScroll.className = 'ql-editor';\nScroll.tagName = 'DIV';\nScroll.defaultChild = 'block';\nScroll.allowedChildren = [Block, BlockEmbed, Container];\n\n\nexport default Scroll;\n","import Parchment from 'parchment';\n\nlet config = {\n scope: Parchment.Scope.BLOCK,\n whitelist: ['right', 'center', 'justify']\n};\n\nlet AlignAttribute = new Parchment.Attributor.Attribute('align', 'align', config);\nlet AlignClass = new Parchment.Attributor.Class('align', 'ql-align', config);\nlet AlignStyle = new Parchment.Attributor.Style('align', 'text-align', config);\n\nexport { AlignAttribute, AlignClass, AlignStyle };\n","import Parchment from 'parchment';\n\nclass ColorAttributor extends Parchment.Attributor.Style {\n value(domNode) {\n let value = super.value(domNode);\n if (!value.startsWith('rgb(')) return value;\n value = value.replace(/^[^\\d]+/, '').replace(/[^\\d]+$/, '');\n return '#' + value.split(',').map(function(component) {\n return ('00' + parseInt(component).toString(16)).slice(-2);\n }).join('');\n }\n}\n\nlet ColorClass = new Parchment.Attributor.Class('color', 'ql-color', {\n scope: Parchment.Scope.INLINE\n});\nlet ColorStyle = new ColorAttributor('color', 'color', {\n scope: Parchment.Scope.INLINE\n});\n\nexport { ColorAttributor, ColorClass, ColorStyle };\n","import Parchment from 'parchment';\nimport { ColorAttributor } from './color';\n\nlet BackgroundClass = new Parchment.Attributor.Class('background', 'ql-bg', {\n scope: Parchment.Scope.INLINE\n});\nlet BackgroundStyle = new ColorAttributor('background', 'background-color', {\n scope: Parchment.Scope.INLINE\n});\n\nexport { BackgroundClass, BackgroundStyle };\n","import Parchment from 'parchment';\n\nlet config = {\n scope: Parchment.Scope.BLOCK,\n whitelist: ['rtl']\n};\n\nlet DirectionAttribute = new Parchment.Attributor.Attribute('direction', 'dir', config);\nlet DirectionClass = new Parchment.Attributor.Class('direction', 'ql-direction', config);\nlet DirectionStyle = new Parchment.Attributor.Style('direction', 'direction', config);\n\nexport { DirectionAttribute, DirectionClass, DirectionStyle };\n","import Parchment from 'parchment';\n\nlet config = {\n scope: Parchment.Scope.INLINE,\n whitelist: ['serif', 'monospace']\n};\n\nlet FontClass = new Parchment.Attributor.Class('font', 'ql-font', config);\n\nclass FontStyleAttributor extends Parchment.Attributor.Style {\n value(node) {\n return super.value(node).replace(/[\"']/g, '');\n }\n}\n\nlet FontStyle = new FontStyleAttributor('font', 'font-family', config);\n\nexport { FontStyle, FontClass };\n","import Parchment from 'parchment';\n\nlet SizeClass = new Parchment.Attributor.Class('size', 'ql-size', {\n scope: Parchment.Scope.INLINE,\n whitelist: ['small', 'large', 'huge']\n});\nlet SizeStyle = new Parchment.Attributor.Style('size', 'font-size', {\n scope: Parchment.Scope.INLINE,\n whitelist: ['10px', '18px', '32px']\n});\n\nexport { SizeClass, SizeStyle };\n","import merge from 'lodash.merge';\nimport Delta from 'quill-delta';\nimport Parchment from 'parchment';\nimport Quill from '../core/quill';\nimport logger from '../core/logger';\nimport Module from '../core/module';\n\nimport { AlignAttribute, AlignStyle } from '../formats/align';\nimport { BackgroundStyle } from '../formats/background';\nimport CodeBlock from '../formats/code';\nimport { ColorStyle } from '../formats/color';\nimport { DirectionAttribute, DirectionStyle } from '../formats/direction';\nimport { FontStyle } from '../formats/font';\nimport { SizeStyle } from '../formats/size';\n\nlet debug = logger('quill:clipboard');\n\n\nconst DOM_KEY = '__ql-matcher';\n\nconst CLIPBOARD_CONFIG = [\n [Node.TEXT_NODE, matchText],\n [Node.TEXT_NODE, matchNewline],\n ['br', matchBreak],\n [Node.ELEMENT_NODE, matchNewline],\n [Node.ELEMENT_NODE, matchBlot],\n [Node.ELEMENT_NODE, matchAttributor],\n [Node.ELEMENT_NODE, matchStyles],\n ['li', matchIndent],\n ['b', matchAlias.bind(matchAlias, 'bold')],\n ['i', matchAlias.bind(matchAlias, 'italic')],\n ['style', matchIgnore]\n];\n\nconst ATTRIBUTE_ATTRIBUTORS = [\n AlignAttribute,\n DirectionAttribute\n].reduce(function(memo, attr) {\n memo[attr.keyName] = attr;\n return memo;\n}, {});\n\nconst STYLE_ATTRIBUTORS = [\n AlignStyle,\n BackgroundStyle,\n ColorStyle,\n DirectionStyle,\n FontStyle,\n SizeStyle\n].reduce(function(memo, attr) {\n memo[attr.keyName] = attr;\n return memo;\n}, {});\n\n\nclass Clipboard extends Module {\n constructor(quill, options) {\n super(quill, options);\n this.quill.root.addEventListener('paste', this.onPaste.bind(this));\n this.container = this.quill.addContainer('ql-clipboard');\n this.container.setAttribute('contenteditable', true);\n this.container.setAttribute('tabindex', -1);\n this.matchers = [];\n CLIPBOARD_CONFIG.concat(this.options.matchers).forEach(([selector, matcher]) => {\n this.addMatcher(selector, matcher);\n });\n }\n\n addMatcher(selector, matcher) {\n this.matchers.push([selector, matcher]);\n }\n\n convert(html) {\n if (typeof html === 'string') {\n this.container.innerHTML = html.replace(/\\>\\r?\\n +\\</g, '><'); // Remove spaces between tags\n return this.convert();\n }\n const formats = this.quill.getFormat(this.quill.selection.savedRange.index);\n if (formats[CodeBlock.blotName]) {\n const text = this.container.innerText;\n this.container.innerHTML = '';\n return new Delta().insert(text, { [CodeBlock.blotName]: formats[CodeBlock.blotName] });\n }\n let [elementMatchers, textMatchers] = this.prepareMatching();\n let delta = traverse(this.container, elementMatchers, textMatchers);\n // Remove trailing newline\n if (deltaEndsWith(delta, '\\n') && delta.ops[delta.ops.length - 1].attributes == null) {\n delta = delta.compose(new Delta().retain(delta.length() - 1).delete(1));\n }\n debug.log('convert', this.container.innerHTML, delta);\n this.container.innerHTML = '';\n return delta;\n }\n\n dangerouslyPasteHTML(index, html, source = Quill.sources.API) {\n if (typeof index === 'string') {\n this.quill.setContents(this.convert(index), html);\n this.quill.setSelection(0, Quill.sources.SILENT);\n } else {\n let paste = this.convert(html);\n this.quill.updateContents(new Delta().retain(index).concat(paste), source);\n this.quill.setSelection(index + paste.length(), Quill.sources.SILENT);\n }\n }\n\n onPaste(e) {\n if (e.defaultPrevented || !this.quill.isEnabled()) return;\n let range = this.quill.getSelection();\n let delta = new Delta().retain(range.index);\n let scrollTop = this.quill.scrollingContainer.scrollTop;\n this.container.focus();\n this.quill.selection.update(Quill.sources.SILENT);\n setTimeout(() => {\n delta = delta.concat(this.convert()).delete(range.length);\n this.quill.updateContents(delta, Quill.sources.USER);\n // range.length contributes to delta.length()\n this.quill.setSelection(delta.length() - range.length, Quill.sources.SILENT);\n this.quill.scrollingContainer.scrollTop = scrollTop;\n this.quill.focus();\n }, 1);\n }\n\n prepareMatching() {\n let elementMatchers = [], textMatchers = [];\n this.matchers.forEach((pair) => {\n let [selector, matcher] = pair;\n switch (selector) {\n case Node.TEXT_NODE:\n textMatchers.push(matcher);\n break;\n case Node.ELEMENT_NODE:\n elementMatchers.push(matcher);\n break;\n default:\n [].forEach.call(this.container.querySelectorAll(selector), (node) => {\n // TODO use weakmap\n node[DOM_KEY] = node[DOM_KEY] || [];\n node[DOM_KEY].push(matcher);\n });\n break;\n }\n });\n return [elementMatchers, textMatchers];\n }\n}\nClipboard.DEFAULTS = {\n matchers: [],\n matchVisual: false\n};\n\n\nfunction applyFormat(delta, format, value) {\n if (typeof format === 'object') {\n return Object.keys(format).reduce(function(delta, key) {\n return applyFormat(delta, key, format[key]);\n }, delta);\n } else {\n return delta.reduce(function(delta, op) {\n if (op.attributes && op.attributes[format]) {\n return delta.push(op);\n } else {\n return delta.insert(op.insert, merge({}, {[format]: value}, op.attributes));\n }\n }, new Delta());\n }\n}\n\nfunction computeStyle(node) {\n if (node.nodeType !== Node.ELEMENT_NODE) return {};\n const DOM_KEY = '__ql-computed-style';\n return node[DOM_KEY] || (node[DOM_KEY] = window.getComputedStyle(node));\n}\n\nfunction deltaEndsWith(delta, text) {\n let endText = \"\";\n for (let i = delta.ops.length - 1; i >= 0 && endText.length < text.length; --i) {\n let op = delta.ops[i];\n if (typeof op.insert !== 'string') break;\n endText = op.insert + endText;\n }\n return endText.slice(-1*text.length) === text;\n}\n\nfunction isLine(node) {\n if (node.childNodes.length === 0) return false; // Exclude embed blocks\n let style = computeStyle(node);\n return ['block', 'list-item'].indexOf(style.display) > -1;\n}\n\nfunction traverse(node, elementMatchers, textMatchers) { // Post-order\n if (node.nodeType === node.TEXT_NODE) {\n return textMatchers.reduce(function(delta, matcher) {\n return matcher(node, delta);\n }, new Delta());\n } else if (node.nodeType === node.ELEMENT_NODE) {\n return [].reduce.call(node.childNodes || [], (delta, childNode) => {\n let childrenDelta = traverse(childNode, elementMatchers, textMatchers);\n if (childNode.nodeType === node.ELEMENT_NODE) {\n childrenDelta = elementMatchers.reduce(function(childrenDelta, matcher) {\n return matcher(childNode, childrenDelta);\n }, childrenDelta);\n childrenDelta = (childNode[DOM_KEY] || []).reduce(function(childrenDelta, matcher) {\n return matcher(childNode, childrenDelta);\n }, childrenDelta);\n }\n return delta.concat(childrenDelta);\n }, new Delta());\n } else {\n return new Delta();\n }\n}\n\n\nfunction matchAlias(format, node, delta) {\n return applyFormat(delta, format, true);\n}\n\nfunction matchAttributor(node, delta) {\n let attributes = Parchment.Attributor.Attribute.keys(node);\n let classes = Parchment.Attributor.Class.keys(node);\n let styles = Parchment.Attributor.Style.keys(node);\n let formats = {};\n attributes.concat(classes).concat(styles).forEach((name) => {\n let attr = Parchment.query(name, Parchment.Scope.ATTRIBUTE);\n if (attr != null) {\n formats[attr.attrName] = attr.value(node);\n if (formats[attr.attrName]) return;\n }\n attr = ATTRIBUTE_ATTRIBUTORS[name];\n if (attr != null && (attr.attrName === name || attr.keyName === name)) {\n formats[attr.attrName] = attr.value(node) || undefined;\n }\n attr = STYLE_ATTRIBUTORS[name]\n if (attr != null && (attr.attrName === name || attr.keyName === name)) {\n attr = STYLE_ATTRIBUTORS[name];\n formats[attr.attrName] = attr.value(node) || undefined;\n }\n });\n if (Object.keys(formats).length > 0) {\n delta = applyFormat(delta, formats);\n }\n return delta;\n}\n\nfunction matchBlot(node, delta) {\n let match = Parchment.query(node);\n if (match == null) return delta;\n if (match.prototype instanceof Parchment.Embed) {\n let embed = {};\n let value = match.value(node);\n if (value != null) {\n embed[match.blotName] = value;\n delta = new Delta().insert(embed, match.formats(node));\n }\n } else if (typeof match.formats === 'function') {\n delta = applyFormat(delta, match.blotName, match.formats(node));\n }\n return delta;\n}\n\nfunction matchBreak(node, delta) {\n if (!deltaEndsWith(delta, '\\n')) {\n delta.insert('\\n');\n }\n return delta;\n}\n\nfunction matchIgnore() {\n return new Delta();\n}\n\nfunction matchIndent(node, delta) {\n let match = Parchment.query(node);\n if (match == null || match.blotName !== 'list-item' || !deltaEndsWith(delta, '\\n')) {\n return delta;\n }\n let indent = -1, parent = node.parentNode;\n while (!parent.classList.contains('ql-clipboard')) {\n if ((Parchment.query(parent) || {}).blotName === 'list') {\n indent += 1;\n }\n parent = parent.parentNode;\n }\n if (indent <= 0) return delta;\n return delta.compose(new Delta().retain(delta.length() - 1).retain(1, { indent: indent}));\n}\n\nfunction matchNewline(node, delta) {\n if (!deltaEndsWith(delta, '\\n')) {\n if (isLine(node) || (delta.length() > 0 && node.nextSibling && isLine(node.nextSibling))) {\n delta.insert('\\n');\n }\n }\n return delta;\n}\n\nfunction matchStyles(node, delta) {\n let formats = {};\n let style = node.style || {};\n if (style.fontStyle && computeStyle(node).fontStyle === 'italic') {\n formats.italic = true;\n }\n if (style.fontWeight && (computeStyle(node).fontWeight.startsWith('bold') ||\n parseInt(computeStyle(node).fontWeight) >= 700)) {\n formats.bold = true;\n }\n if (Object.keys(formats).length > 0) {\n delta = applyFormat(delta, formats);\n }\n if (parseFloat(style.textIndent || 0) > 0) { // Could be 0.5in\n delta = new Delta().insert('\\t').concat(delta);\n }\n return delta;\n}\n\nfunction matchText(node, delta) {\n let text = node.data;\n // Word represents empty line with <o:p>&nbsp;</o:p>\n if (node.parentNode.tagName === 'O:P') {\n return delta.insert(text.trim());\n }\n if (text.trim().length === 0 && node.parentNode.classList.contains('ql-clipboard')) {\n return delta;\n }\n if (!computeStyle(node.parentNode).whiteSpace.startsWith('pre')) {\n // eslint-disable-next-line func-style\n let replacer = function(collapse, match) {\n match = match.replace(/[^\\u00a0]/g, ''); // \\u00a0 is nbsp;\n return match.length < 1 && collapse ? ' ' : match;\n };\n text = text.replace(/\\r\\n/g, ' ').replace(/\\n/g, ' ');\n text = text.replace(/\\s\\s+/g, replacer.bind(replacer, true)); // collapse whitespace\n if ((node.previousSibling == null && isLine(node.parentNode)) ||\n (node.previousSibling != null && isLine(node.previousSibling))) {\n text = text.replace(/^\\s+/, replacer.bind(replacer, false));\n }\n if ((node.nextSibling == null && isLine(node.parentNode)) ||\n (node.nextSibling != null && isLine(node.nextSibling))) {\n text = text.replace(/\\s+$/, replacer.bind(replacer, false));\n }\n }\n return delta.insert(text);\n}\n\n\nexport { Clipboard as default, matchAttributor, matchBlot, matchNewline, matchText };\n","import Parchment from 'parchment';\nimport Quill from '../core/quill';\nimport Module from '../core/module';\n\n\nclass History extends Module {\n constructor(quill, options) {\n super(quill, options);\n this.lastRecorded = 0;\n this.ignoreChange = false;\n this.clear();\n this.quill.on(Quill.events.EDITOR_CHANGE, (eventName, delta, oldDelta, source) => {\n if (eventName !== Quill.events.TEXT_CHANGE || this.ignoreChange) return;\n if (!this.options.userOnly || source === Quill.sources.USER) {\n this.record(delta, oldDelta);\n } else {\n this.transform(delta);\n }\n });\n this.quill.keyboard.addBinding({ key: 'Z', shortKey: true }, this.undo.bind(this));\n this.quill.keyboard.addBinding({ key: 'Z', shortKey: true, shiftKey: true }, this.redo.bind(this));\n if (/Win/i.test(navigator.platform)) {\n this.quill.keyboard.addBinding({ key: 'Y', shortKey: true }, this.redo.bind(this));\n }\n }\n\n change(source, dest) {\n if (this.stack[source].length === 0) return;\n let delta = this.stack[source].pop();\n this.stack[dest].push(delta);\n this.lastRecorded = 0;\n this.ignoreChange = true;\n this.quill.updateContents(delta[source], Quill.sources.USER);\n this.ignoreChange = false;\n let index = getLastChangeIndex(delta[source]);\n this.quill.setSelection(index);\n }\n\n clear() {\n this.stack = { undo: [], redo: [] };\n }\n\n cutoff() {\n this.lastRecorded = 0;\n }\n\n record(changeDelta, oldDelta) {\n if (changeDelta.ops.length === 0) return;\n this.stack.redo = [];\n let undoDelta = this.quill.getContents().diff(oldDelta);\n let timestamp = Date.now();\n if (this.lastRecorded + this.options.delay > timestamp && this.stack.undo.length > 0) {\n let delta = this.stack.undo.pop();\n undoDelta = undoDelta.compose(delta.undo);\n changeDelta = delta.redo.compose(changeDelta);\n } else {\n this.lastRecorded = timestamp;\n }\n this.stack.undo.push({\n redo: changeDelta,\n undo: undoDelta\n });\n if (this.stack.undo.length > this.options.maxStack) {\n this.stack.undo.shift();\n }\n }\n\n redo() {\n this.change('redo', 'undo');\n }\n\n transform(delta) {\n this.stack.undo.forEach(function(change) {\n change.undo = delta.transform(change.undo, true);\n change.redo = delta.transform(change.redo, true);\n });\n this.stack.redo.forEach(function(change) {\n change.undo = delta.transform(change.undo, true);\n change.redo = delta.transform(change.redo, true);\n });\n }\n\n undo() {\n this.change('undo', 'redo');\n }\n}\nHistory.DEFAULTS = {\n delay: 1000,\n maxStack: 100,\n userOnly: false\n};\n\nfunction endsWithNewlineChange(delta) {\n let lastOp = delta.ops[delta.ops.length - 1];\n if (lastOp == null) return false;\n if (lastOp.insert != null) {\n return typeof lastOp.insert === 'string' && lastOp.insert.endsWith('\\n');\n }\n if (lastOp.attributes != null) {\n return Object.keys(lastOp.attributes).some(function(attr) {\n return Parchment.query(attr, Parchment.Scope.BLOCK) != null;\n });\n }\n return false;\n}\n\nfunction getLastChangeIndex(delta) {\n let deleteLength = delta.reduce(function(length, op) {\n length += (op.delete || 0);\n return length;\n }, 0);\n let changeIndex = delta.length() - deleteLength;\n if (endsWithNewlineChange(delta)) {\n changeIndex -= 1;\n }\n return changeIndex;\n}\n\n\nexport { History as default, getLastChangeIndex };\n","import cloneDeep from 'lodash.clonedeep';\nimport isEqual from 'lodash.isequal';\nimport merge from 'lodash.merge';\nimport Delta, { AttributeMap } from 'quill-delta';\nimport Parchment from 'parchment';\nimport Quill from '../core/quill';\nimport logger from '../core/logger';\nimport Module from '../core/module';\n\nlet debug = logger('quill:keyboard');\n\nconst SHORTKEY = /Mac/i.test(navigator.platform) ? 'metaKey' : 'ctrlKey';\n\n\nclass Keyboard extends Module {\n static match(evt, binding) {\n binding = normalize(binding);\n if (['altKey', 'ctrlKey', 'metaKey', 'shiftKey'].some(function(key) {\n return (!!binding[key] !== evt[key] && binding[key] !== null);\n })) {\n return false;\n }\n return binding.key === (evt.which || evt.keyCode);\n }\n\n constructor(quill, options) {\n super(quill, options);\n this.bindings = {};\n Object.keys(this.options.bindings).forEach((name) => {\n if (name === 'list autofill' &&\n quill.scroll.whitelist != null &&\n !quill.scroll.whitelist['list']) {\n return;\n }\n if (this.options.bindings[name]) {\n this.addBinding(this.options.bindings[name]);\n }\n });\n this.addBinding({ key: Keyboard.keys.ENTER, shiftKey: null }, handleEnter);\n this.addBinding({ key: Keyboard.keys.ENTER, metaKey: null, ctrlKey: null, altKey: null }, function() {});\n if (/Firefox/i.test(navigator.userAgent)) {\n // Need to handle delete and backspace for Firefox in the general case #1171\n this.addBinding({ key: Keyboard.keys.BACKSPACE }, { collapsed: true }, handleBackspace);\n this.addBinding({ key: Keyboard.keys.DELETE }, { collapsed: true }, handleDelete);\n } else {\n this.addBinding({ key: Keyboard.keys.BACKSPACE }, { collapsed: true, prefix: /^.?$/ }, handleBackspace);\n this.addBinding({ key: Keyboard.keys.DELETE }, { collapsed: true, suffix: /^.?$/ }, handleDelete);\n }\n this.addBinding({ key: Keyboard.keys.BACKSPACE }, { collapsed: false }, handleDeleteRange);\n this.addBinding({ key: Keyboard.keys.DELETE }, { collapsed: false }, handleDeleteRange);\n this.addBinding({ key: Keyboard.keys.BACKSPACE, altKey: null, ctrlKey: null, metaKey: null, shiftKey: null },\n { collapsed: true, offset: 0 },\n handleBackspace);\n this.listen();\n }\n\n addBinding(key, context = {}, handler = {}) {\n let binding = normalize(key);\n if (binding == null || binding.key == null) {\n return debug.warn('Attempted to add invalid keyboard binding', binding);\n }\n if (typeof context === 'function') {\n context = { handler: context };\n }\n if (typeof handler === 'function') {\n handler = { handler: handler };\n }\n binding = merge(binding, context, handler);\n this.bindings[binding.key] = this.bindings[binding.key] || [];\n this.bindings[binding.key].push(binding);\n }\n\n listen() {\n this.quill.root.addEventListener('keydown', (evt) => {\n if (evt.defaultPrevented) return;\n let which = evt.which || evt.keyCode;\n let bindings = (this.bindings[which] || []).filter(function(binding) {\n return Keyboard.match(evt, binding);\n });\n if (bindings.length === 0) return;\n let range = this.quill.getSelection();\n if (range == null || !this.quill.hasFocus()) return;\n let [line, offset] = this.quill.getLine(range.index);\n let [leafStart, offsetStart] = this.quill.getLeaf(range.index);\n let [leafEnd, offsetEnd] = range.length === 0 ? [leafStart, offsetStart] : this.quill.getLeaf(range.index + range.length);\n let prefixText = leafStart instanceof Parchment.Text ? leafStart.value().slice(0, offsetStart) : '';\n let suffixText = leafEnd instanceof Parchment.Text ? leafEnd.value().slice(offsetEnd) : '';\n let curContext = {\n collapsed: range.length === 0,\n empty: range.length === 0 && line.length() <= 1,\n format: this.quill.getFormat(range),\n offset: offset,\n prefix: prefixText,\n suffix: suffixText\n };\n let prevented = bindings.some((binding) => {\n if (binding.collapsed != null && binding.collapsed !== curContext.collapsed) return false;\n if (binding.empty != null && binding.empty !== curContext.empty) return false;\n if (binding.offset != null && binding.offset !== curContext.offset) return false;\n if (Array.isArray(binding.format)) {\n // any format is present\n if (binding.format.every(function(name) {\n return curContext.format[name] == null;\n })) {\n return false;\n }\n } else if (typeof binding.format === 'object') {\n // all formats must match\n if (!Object.keys(binding.format).every(function(name) {\n if (binding.format[name] === true) return curContext.format[name] != null;\n if (binding.format[name] === false) return curContext.format[name] == null;\n return isEqual(binding.format[name], curContext.format[name]);\n })) {\n return false;\n }\n }\n if (binding.prefix != null && !binding.prefix.test(curContext.prefix)) return false;\n if (binding.suffix != null && !binding.suffix.test(curContext.suffix)) return false;\n return binding.handler.call(this, range, curContext) !== true;\n });\n if (prevented) {\n evt.preventDefault();\n }\n });\n }\n}\n\nKeyboard.keys = {\n BACKSPACE: 8,\n TAB: 9,\n ENTER: 13,\n ESCAPE: 27,\n LEFT: 37,\n UP: 38,\n RIGHT: 39,\n DOWN: 40,\n DELETE: 46\n};\n\nKeyboard.DEFAULTS = {\n bindings: {\n 'bold' : makeFormatHandler('bold'),\n 'italic' : makeFormatHandler('italic'),\n 'underline' : makeFormatHandler('underline'),\n 'indent': {\n // highlight tab or tab at beginning of list, indent or blockquote\n key: Keyboard.keys.TAB,\n format: ['blockquote', 'indent', 'list'],\n handler: function(range, context) {\n if (context.collapsed && context.offset !== 0) return true;\n this.quill.format('indent', '+1', Quill.sources.USER);\n }\n },\n 'outdent': {\n key: Keyboard.keys.TAB,\n shiftKey: true,\n format: ['blockquote', 'indent', 'list'],\n // highlight tab or tab at beginning of list, indent or blockquote\n handler: function(range, context) {\n if (context.collapsed && context.offset !== 0) return true;\n this.quill.format('indent', '-1', Quill.sources.USER);\n }\n },\n 'outdent backspace': {\n key: Keyboard.keys.BACKSPACE,\n collapsed: true,\n shiftKey: null,\n metaKey: null,\n ctrlKey: null,\n altKey: null,\n format: ['indent', 'list'],\n offset: 0,\n handler: function(range, context) {\n if (context.format.indent != null) {\n this.quill.format('indent', '-1', Quill.sources.USER);\n } else if (context.format.list != null) {\n this.quill.format('list', false, Quill.sources.USER);\n }\n }\n },\n 'indent code-block': makeCodeBlockHandler(true),\n 'outdent code-block': makeCodeBlockHandler(false),\n 'remove tab': {\n key: Keyboard.keys.TAB,\n shiftKey: true,\n collapsed: true,\n prefix: /\\t$/,\n handler: function(range) {\n this.quill.deleteText(range.index - 1, 1, Quill.sources.USER);\n }\n },\n 'tab': {\n key: Keyboard.keys.TAB,\n handler: function(range) {\n this.quill.history.cutoff();\n let delta = new Delta().retain(range.index)\n .delete(range.length)\n .insert('\\t');\n this.quill.updateContents(delta, Quill.sources.USER);\n this.quill.history.cutoff();\n this.quill.setSelection(range.index + 1, Quill.sources.SILENT);\n }\n },\n 'list empty enter': {\n key: Keyboard.keys.ENTER,\n collapsed: true,\n format: ['list'],\n empty: true,\n handler: function(range, context) {\n this.quill.format('list', false, Quill.sources.USER);\n if (context.format.indent) {\n this.quill.format('indent', false, Quill.sources.USER);\n }\n }\n },\n 'checklist enter': {\n key: Keyboard.keys.ENTER,\n collapsed: true,\n format: { list: 'checked' },\n handler: function(range) {\n let [line, offset] = this.quill.getLine(range.index);\n let formats = merge({}, line.formats(), { list: 'checked' });\n let delta = new Delta().retain(range.index)\n .insert('\\n', formats)\n .retain(line.length() - offset - 1)\n .retain(1, { list: 'unchecked' });\n this.quill.updateContents(delta, Quill.sources.USER);\n this.quill.setSelection(range.index + 1, Quill.sources.SILENT);\n this.quill.scrollIntoView();\n }\n },\n 'header enter': {\n key: Keyboard.keys.ENTER,\n collapsed: true,\n format: ['header'],\n suffix: /^$/,\n handler: function(range, context) {\n let [line, offset] = this.quill.getLine(range.index);\n let delta = new Delta().retain(range.index)\n .insert('\\n', context.format)\n .retain(line.length() - offset - 1)\n .retain(1, { header: null });\n this.quill.updateContents(delta, Quill.sources.USER);\n this.quill.setSelection(range.index + 1, Quill.sources.SILENT);\n this.quill.scrollIntoView();\n }\n },\n 'list autofill': {\n key: ' ',\n collapsed: true,\n format: { list: false },\n prefix: /^\\s*?(\\d+\\.|-|\\*|\\[ ?\\]|\\[x\\])$/,\n handler: function(range, context) {\n let length = context.prefix.length;\n let [line, offset] = this.quill.getLine(range.index);\n if (offset > length) return true;\n let value;\n switch (context.prefix.trim()) {\n case '[]': case '[ ]':\n value = 'unchecked';\n break;\n case '[x]':\n value = 'checked';\n break;\n case '-': case '*':\n value = 'bullet';\n break;\n default:\n value = 'ordered';\n }\n this.quill.insertText(range.index, ' ', Quill.sources.USER);\n this.quill.history.cutoff();\n let delta = new Delta().retain(range.index - offset)\n .delete(length + 1)\n .retain(line.length() - 2 - offset)\n .retain(1, { list: value });\n this.quill.updateContents(delta, Quill.sources.USER);\n this.quill.history.cutoff();\n this.quill.setSelection(range.index - length, Quill.sources.SILENT);\n }\n },\n 'code exit': {\n key: Keyboard.keys.ENTER,\n collapsed: true,\n format: ['code-block'],\n prefix: /\\n\\n$/,\n suffix: /^\\s+$/,\n handler: function(range) {\n const [line, offset] = this.quill.getLine(range.index);\n const delta = new Delta()\n .retain(range.index + line.length() - offset - 2)\n .retain(1, { 'code-block': null })\n .delete(1);\n this.quill.updateContents(delta, Quill.sources.USER);\n }\n },\n 'embed left': makeEmbedArrowHandler(Keyboard.keys.LEFT, false),\n 'embed left shift': makeEmbedArrowHandler(Keyboard.keys.LEFT, true),\n 'embed right': makeEmbedArrowHandler(Keyboard.keys.RIGHT, false),\n 'embed right shift': makeEmbedArrowHandler(Keyboard.keys.RIGHT, true)\n }\n};\n\nfunction makeEmbedArrowHandler(key, shiftKey) {\n const where = key === Keyboard.keys.LEFT ? 'prefix' : 'suffix';\n return {\n key,\n shiftKey,\n altKey: null,\n [where]: /^$/,\n handler: function(range) {\n let index = range.index;\n if (key === Keyboard.keys.RIGHT) {\n index += (range.length + 1);\n }\n const [leaf, ] = this.quill.getLeaf(index);\n if (!(leaf instanceof Parchment.Embed)) return true;\n if (key === Keyboard.keys.LEFT) {\n if (shiftKey) {\n this.quill.setSelection(range.index - 1, range.length + 1, Quill.sources.USER);\n } else {\n this.quill.setSelection(range.index - 1, Quill.sources.USER);\n }\n } else {\n if (shiftKey) {\n this.quill.setSelection(range.index, range.length + 1, Quill.sources.USER);\n } else {\n this.quill.setSelection(range.index + range.length + 1, Quill.sources.USER);\n }\n }\n return false;\n }\n };\n}\n\n\nfunction handleBackspace(range, context) {\n if (range.index === 0 || this.quill.getLength() <= 1) return;\n let [line, ] = this.quill.getLine(range.index);\n let formats = {};\n if (context.offset === 0) {\n let [prev, ] = this.quill.getLine(range.index - 1);\n if (prev != null && prev.length() > 1) {\n let curFormats = line.formats();\n let prevFormats = this.quill.getFormat(range.index-1, 1);\n formats = AttributeMap.diff(curFormats, prevFormats) || {};\n }\n }\n // Check for astral symbols\n let length = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]$/.test(context.prefix) ? 2 : 1;\n this.quill.deleteText(range.index-length, length, Quill.sources.USER);\n if (Object.keys(formats).length > 0) {\n this.quill.formatLine(range.index-length, length, formats, Quill.sources.USER);\n }\n this.quill.focus();\n}\n\nfunction handleDelete(range, context) {\n // Check for astral symbols\n let length = /^[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]/.test(context.suffix) ? 2 : 1;\n if (range.index >= this.quill.getLength() - length) return;\n let formats = {}, nextLength = 0;\n let [line, ] = this.quill.getLine(range.index);\n if (context.offset >= line.length() - 1) {\n let [next, ] = this.quill.getLine(range.index + 1);\n if (next) {\n let curFormats = line.formats();\n let nextFormats = this.quill.getFormat(range.index, 1);\n formats = DeltaOp.attributes.diff(curFormats, nextFormats) || {};\n nextLength = next.length();\n }\n }\n this.quill.deleteText(range.index, length, Quill.sources.USER);\n if (Object.keys(formats).length > 0) {\n this.quill.formatLine(range.index + nextLength - 1, length, formats, Quill.sources.USER);\n }\n}\n\nfunction handleDeleteRange(range) {\n let lines = this.quill.getLines(range);\n let formats = {};\n if (lines.length > 1) {\n let firstFormats = lines[0].formats();\n let lastFormats = lines[lines.length - 1].formats();\n formats = DeltaOp.attributes.diff(lastFormats, firstFormats) || {};\n }\n this.quill.deleteText(range, Quill.sources.USER);\n if (Object.keys(formats).length > 0) {\n this.quill.formatLine(range.index, 1, formats, Quill.sources.USER);\n }\n this.quill.setSelection(range.index, Quill.sources.SILENT);\n this.quill.focus();\n}\n\nfunction handleEnter(range, context) {\n if (range.length > 0) {\n this.quill.scroll.deleteAt(range.index, range.length); // So we do not trigger text-change\n }\n let lineFormats = Object.keys(context.format).reduce(function(lineFormats, format) {\n if (Parchment.query(format, Parchment.Scope.BLOCK) && !Array.isArray(context.format[format])) {\n lineFormats[format] = context.format[format];\n }\n return lineFormats;\n }, {});\n this.quill.insertText(range.index, '\\n', lineFormats, Quill.sources.USER);\n // Earlier scroll.deleteAt might have messed up our selection,\n // so insertText's built in selection preservation is not reliable\n this.quill.setSelection(range.index + 1, Quill.sources.SILENT);\n this.quill.focus();\n Object.keys(context.format).forEach((name) => {\n if (lineFormats[name] != null) return;\n if (Array.isArray(context.format[name])) return;\n if (name === 'link') return;\n this.quill.format(name, context.format[name], Quill.sources.USER);\n });\n}\n\nfunction makeCodeBlockHandler(indent) {\n return {\n key: Keyboard.keys.TAB,\n shiftKey: !indent,\n format: {'code-block': true },\n handler: function(range) {\n let CodeBlock = Parchment.query('code-block');\n let index = range.index, length = range.length;\n let [block, offset] = this.quill.scroll.descendant(CodeBlock, index);\n if (block == null) return;\n let scrollIndex = this.quill.getIndex(block);\n let start = block.newlineIndex(offset, true) + 1;\n let end = block.newlineIndex(scrollIndex + offset + length);\n let lines = block.domNode.textContent.slice(start, end).split('\\n');\n offset = 0;\n lines.forEach((line, i) => {\n if (indent) {\n block.insertAt(start + offset, CodeBlock.TAB);\n offset += CodeBlock.TAB.length;\n if (i === 0) {\n index += CodeBlock.TAB.length;\n } else {\n length += CodeBlock.TAB.length;\n }\n } else if (line.startsWith(CodeBlock.TAB)) {\n block.deleteAt(start + offset, CodeBlock.TAB.length);\n offset -= CodeBlock.TAB.length;\n if (i === 0) {\n index -= CodeBlock.TAB.length;\n } else {\n length -= CodeBlock.TAB.length;\n }\n }\n offset += line.length + 1;\n });\n this.quill.update(Quill.sources.USER);\n this.quill.setSelection(index, length, Quill.sources.SILENT);\n }\n };\n}\n\nfunction makeFormatHandler(format) {\n return {\n key: format[0].toUpperCase(),\n shortKey: true,\n handler: function(range, context) {\n this.quill.format(format, !context.format[format], Quill.sources.USER);\n }\n };\n}\n\nfunction normalize(binding) {\n if (typeof binding === 'string' || typeof binding === 'number') {\n return normalize({ key: binding });\n }\n if (typeof binding === 'object') {\n binding = cloneDeep(binding, false);\n }\n if (typeof binding.key === 'string') {\n if (Keyboard.keys[binding.key.toUpperCase()] != null) {\n binding.key = Keyboard.keys[binding.key.toUpperCase()];\n } else if (binding.key.length === 1) {\n binding.key = binding.key.toUpperCase().charCodeAt(0);\n } else {\n return null;\n }\n }\n if (binding.shortKey) {\n binding[SHORTKEY] = binding.shortKey;\n delete binding.shortKey;\n }\n return binding;\n}\n\n\nexport { Keyboard as default, SHORTKEY };\n","import Parchment from 'parchment';\nimport Quill from './core/quill';\n\nimport Block, { BlockEmbed } from './blots/block';\nimport Break from './blots/break';\nimport Container from './blots/container';\nimport Cursor from './blots/cursor';\nimport Embed from './blots/embed';\nimport Inline from './blots/inline';\nimport Scroll from './blots/scroll';\nimport TextBlot from './blots/text';\n\nimport Clipboard from './modules/clipboard';\nimport History from './modules/history';\nimport Keyboard from './modules/keyboard';\n\nQuill.register({\n 'blots/block' : Block,\n 'blots/block/embed' : BlockEmbed,\n 'blots/break' : Break,\n 'blots/container' : Container,\n 'blots/cursor' : Cursor,\n 'blots/embed' : Embed,\n 'blots/inline' : Inline,\n 'blots/scroll' : Scroll,\n 'blots/text' : TextBlot,\n\n 'modules/clipboard' : Clipboard,\n 'modules/history' : History,\n 'modules/keyboard' : Keyboard\n});\n\nParchment.register(Block, Break, Cursor, Inline, Scroll, TextBlot);\n\n\nexport default Quill;\n","import Parchment from 'parchment';\n\nclass IdentAttributor extends Parchment.Attributor.Class {\n add(node, value) {\n if (value === '+1' || value === '-1') {\n let indent = this.value(node) || 0;\n value = (value === '+1' ? (indent + 1) : (indent - 1));\n }\n if (value === 0) {\n this.remove(node);\n return true;\n } else {\n return super.add(node, value);\n }\n }\n\n canAdd(node, value) {\n return super.canAdd(node, value) || super.canAdd(node, parseInt(value));\n }\n\n value(node) {\n return parseInt(super.value(node)) || undefined; // Don't return NaN\n }\n}\n\nlet IndentClass = new IdentAttributor('indent', 'ql-indent', {\n scope: Parchment.Scope.BLOCK,\n whitelist: [1, 2, 3, 4, 5, 6, 7, 8]\n});\n\nexport { IndentClass };\n","import Block from '../blots/block';\n\n\nclass Blockquote extends Block {}\nBlockquote.blotName = 'blockquote';\nBlockquote.tagName = 'blockquote';\n\n\nexport default Blockquote;\n","import Block from '../blots/block';\n\n\nclass Header extends Block {\n static formats(domNode) {\n return this.tagName.indexOf(domNode.tagName) + 1;\n }\n}\nHeader.blotName = 'header';\nHeader.tagName = ['H1', 'H2', 'H3', 'H4', 'H5', 'H6'];\n\n\nexport default Header;\n","import Parchment from 'parchment';\nimport Block from '../blots/block';\nimport Container from '../blots/container';\n\n\nclass ListItem extends Block {\n static formats(domNode) {\n return domNode.tagName === this.tagName ? undefined : super.formats(domNode);\n }\n\n format(name, value) {\n if (name === List.blotName && !value) {\n this.replaceWith(Parchment.create(this.statics.scope));\n } else {\n super.format(name, value);\n }\n }\n\n remove() {\n if (this.prev == null && this.next == null) {\n this.parent.remove();\n } else {\n super.remove();\n }\n }\n\n replaceWith(name, value) {\n this.parent.isolate(this.offset(this.parent), this.length());\n if (name === this.parent.statics.blotName) {\n this.parent.replaceWith(name, value);\n return this;\n } else {\n this.parent.unwrap();\n return super.replaceWith(name, value);\n }\n }\n}\nListItem.blotName = 'list-item';\nListItem.tagName = 'LI';\n\n\nclass List extends Container {\n static create(value) {\n let tagName = value === 'ordered' ? 'OL' : 'UL';\n let node = super.create(tagName);\n if (value === 'checked' || value === 'unchecked') {\n node.setAttribute('data-checked', value === 'checked');\n }\n return node;\n }\n\n static formats(domNode) {\n if (domNode.tagName === 'OL') return 'ordered';\n if (domNode.tagName === 'UL') {\n if (domNode.hasAttribute('data-checked')) {\n return domNode.getAttribute('data-checked') === 'true' ? 'checked' : 'unchecked';\n } else {\n return 'bullet';\n }\n }\n return undefined;\n }\n\n constructor(domNode) {\n super(domNode);\n const listEventHandler = (e) => {\n if (e.target.parentNode !== domNode) return;\n let format = this.statics.formats(domNode);\n let blot = Parchment.find(e.target);\n if (format === 'checked') {\n blot.format('list', 'unchecked');\n } else if(format === 'unchecked') {\n blot.format('list', 'checked');\n }\n }\n\n domNode.addEventListener('touchstart', listEventHandler);\n domNode.addEventListener('mousedown', listEventHandler);\n }\n\n format(name, value) {\n if (this.children.length > 0) {\n this.children.tail.format(name, value);\n }\n }\n\n formats() {\n // We don't inherit from FormatBlot\n return { [this.statics.blotName]: this.statics.formats(this.domNode) };\n }\n\n insertBefore(blot, ref) {\n if (blot instanceof ListItem) {\n super.insertBefore(blot, ref);\n } else {\n let index = ref == null ? this.length() : ref.offset(this);\n let after = this.split(index);\n after.parent.insertBefore(blot, after);\n }\n }\n\n optimize(context) {\n super.optimize(context);\n let next = this.next;\n if (next != null && next.prev === this &&\n next.statics.blotName === this.statics.blotName &&\n next.domNode.tagName === this.domNode.tagName &&\n next.domNode.getAttribute('data-checked') === this.domNode.getAttribute('data-checked')) {\n next.moveChildren(this);\n next.remove();\n }\n }\n\n replace(target) {\n if (target.statics.blotName !== this.statics.blotName) {\n let item = Parchment.create(this.statics.defaultChild);\n target.moveChildren(item);\n this.appendChild(item);\n }\n super.replace(target);\n }\n}\nList.blotName = 'list';\nList.scope = Parchment.Scope.BLOCK_BLOT;\nList.tagName = ['OL', 'UL'];\nList.defaultChild = 'list-item';\nList.allowedChildren = [ListItem];\n\n\nexport { ListItem, List as default };\n","import Inline from '../blots/inline';\n\nclass Bold extends Inline {\n static create() {\n return super.create();\n }\n\n static formats() {\n return true;\n }\n\n optimize(context) {\n super.optimize(context);\n if (this.domNode.tagName !== this.statics.tagName[0]) {\n this.replaceWith(this.statics.blotName);\n }\n }\n}\nBold.blotName = 'bold';\nBold.tagName = ['STRONG', 'B'];\n\nexport default Bold;\n","import Bold from './bold';\n\nclass Italic extends Bold { }\nItalic.blotName = 'italic';\nItalic.tagName = ['EM', 'I'];\n\nexport default Italic;\n","import Inline from '../blots/inline';\n\n\nclass Link extends Inline {\n static create(value) {\n let node = super.create(value);\n value = this.sanitize(value);\n node.setAttribute('href', value);\n node.setAttribute('target', '_blank');\n return node;\n }\n\n static formats(domNode) {\n return domNode.getAttribute('href');\n }\n\n static sanitize(url) {\n return sanitize(url, this.PROTOCOL_WHITELIST) ? url : this.SANITIZED_URL;\n }\n\n format(name, value) {\n if (name !== this.statics.blotName || !value) return super.format(name, value);\n value = this.constructor.sanitize(value);\n this.domNode.setAttribute('href', value);\n }\n}\nLink.blotName = 'link';\nLink.tagName = 'A';\nLink.SANITIZED_URL = 'about:blank';\nLink.PROTOCOL_WHITELIST = ['http', 'https', 'mailto', 'tel'];\n\n\nfunction sanitize(url, protocols) {\n let anchor = document.createElement('a');\n anchor.href = url;\n let protocol = anchor.href.slice(0, anchor.href.indexOf(':'));\n return protocols.indexOf(protocol) > -1;\n}\n\n\nexport { Link as default, sanitize };\n","import Inline from '../blots/inline';\n\nclass Script extends Inline {\n static create(value) {\n if (value === 'super') {\n return document.createElement('sup');\n } else if (value === 'sub') {\n return document.createElement('sub');\n } else {\n return super.create(value);\n }\n }\n\n static formats(domNode) {\n if (domNode.tagName === 'SUB') return 'sub';\n if (domNode.tagName === 'SUP') return 'super';\n return undefined;\n }\n}\nScript.blotName = 'script';\nScript.tagName = ['SUB', 'SUP'];\n\nexport default Script;\n","import Inline from '../blots/inline';\n\nclass Strike extends Inline { }\nStrike.blotName = 'strike';\nStrike.tagName = 'S';\n\nexport default Strike;\n","import Inline from '../blots/inline';\n\nclass Underline extends Inline { }\nUnderline.blotName = 'underline';\nUnderline.tagName = 'U';\n\nexport default Underline;\n","import Parchment from 'parchment';\nimport { sanitize } from '../formats/link';\n\nconst ATTRIBUTES = [\n 'alt',\n 'height',\n 'width'\n];\n\n\nclass Image extends Parchment.Embed {\n static create(value) {\n let node = super.create(value);\n if (typeof value === 'string') {\n node.setAttribute('src', this.sanitize(value));\n }\n return node;\n }\n\n static formats(domNode) {\n return ATTRIBUTES.reduce(function(formats, attribute) {\n if (domNode.hasAttribute(attribute)) {\n formats[attribute] = domNode.getAttribute(attribute);\n }\n return formats;\n }, {});\n }\n\n static match(url) {\n return /\\.(jpe?g|gif|png)$/.test(url) || /^data:image\\/.+;base64/.test(url);\n }\n\n static sanitize(url) {\n return sanitize(url, ['http', 'https', 'data']) ? url : '//:0';\n }\n\n static value(domNode) {\n return domNode.getAttribute('src');\n }\n\n format(name, value) {\n if (ATTRIBUTES.indexOf(name) > -1) {\n if (value) {\n this.domNode.setAttribute(name, value);\n } else {\n this.domNode.removeAttribute(name);\n }\n } else {\n super.format(name, value);\n }\n }\n}\nImage.blotName = 'image';\nImage.tagName = 'IMG';\n\n\nexport default Image;\n","import { BlockEmbed } from '../blots/block';\nimport Link from '../formats/link';\n\nconst ATTRIBUTES = [\n 'height',\n 'width'\n];\n\n\nclass Video extends BlockEmbed {\n static create(value) {\n let node = super.create(value);\n node.setAttribute('frameborder', '0');\n node.setAttribute('allowfullscreen', true);\n node.setAttribute('src', this.sanitize(value));\n return node;\n }\n\n static formats(domNode) {\n return ATTRIBUTES.reduce(function(formats, attribute) {\n if (domNode.hasAttribute(attribute)) {\n formats[attribute] = domNode.getAttribute(attribute);\n }\n return formats;\n }, {});\n }\n\n static sanitize(url) {\n return Link.sanitize(url);\n }\n\n static value(domNode) {\n return domNode.getAttribute('src');\n }\n\n format(name, value) {\n if (ATTRIBUTES.indexOf(name) > -1) {\n if (value) {\n this.domNode.setAttribute(name, value);\n } else {\n this.domNode.removeAttribute(name);\n }\n } else {\n super.format(name, value);\n }\n }\n}\nVideo.blotName = 'video';\nVideo.className = 'ql-video';\nVideo.tagName = 'IFRAME';\n\n\nexport default Video;\n","import Delta from 'quill-delta';\nimport Parchment from 'parchment';\nimport Quill from '../core/quill';\nimport logger from '../core/logger';\nimport Module from '../core/module';\n\nconst supportsRootNode = ('getRootNode' in document);\nlet debug = logger('quill:toolbar');\n\nclass Toolbar extends Module {\n constructor(quill, options) {\n super(quill, options);\n if (Array.isArray(this.options.container)) {\n let container = document.createElement('div');\n addControls(container, this.options.container);\n quill.container.parentNode.insertBefore(container, quill.container);\n this.container = container;\n } else if (typeof this.options.container === 'string') {\n const rootDocument = (supportsRootNode ? quill.container.getRootNode() : document);\n this.container = rootDocument.querySelector(this.options.container);\n } else {\n this.container = this.options.container;\n }\n if (!(this.container instanceof HTMLElement)) {\n return debug.error('Container required for toolbar', this.options);\n }\n this.container.classList.add('ql-toolbar');\n this.controls = [];\n this.handlers = {};\n Object.keys(this.options.handlers).forEach((format) => {\n this.addHandler(format, this.options.handlers[format]);\n });\n [].forEach.call(this.container.querySelectorAll('button, select'), (input) => {\n this.attach(input);\n });\n this.quill.on(Quill.events.EDITOR_CHANGE, (type, range) => {\n if (type === Quill.events.SELECTION_CHANGE) {\n this.update(range);\n }\n });\n this.quill.on(Quill.events.SCROLL_OPTIMIZE, () => {\n let [range, ] = this.quill.selection.getRange(); // quill.getSelection triggers update\n this.update(range);\n });\n }\n\n addHandler(format, handler) {\n this.handlers[format] = handler;\n }\n\n attach(input) {\n let format = [].find.call(input.classList, (className) => {\n return className.indexOf('ql-') === 0;\n });\n if (!format) return;\n format = format.slice('ql-'.length);\n if (input.tagName === 'BUTTON') {\n input.setAttribute('type', 'button');\n }\n if (this.handlers[format] == null) {\n if (this.quill.scroll.whitelist != null && this.quill.scroll.whitelist[format] == null) {\n debug.warn('ignoring attaching to disabled format', format, input);\n return;\n }\n if (Parchment.query(format) == null) {\n debug.warn('ignoring attaching to nonexistent format', format, input);\n return;\n }\n }\n let eventName = input.tagName === 'SELECT' ? 'change' : 'click';\n input.addEventListener(eventName, (e) => {\n let value;\n if (input.tagName === 'SELECT') {\n if (input.selectedIndex < 0) return;\n let selected = input.options[input.selectedIndex];\n if (selected.hasAttribute('selected')) {\n value = false;\n } else {\n value = selected.value || false;\n }\n } else {\n if (input.classList.contains('ql-active')) {\n value = false;\n } else {\n value = input.value || !input.hasAttribute('value');\n }\n e.preventDefault();\n }\n this.quill.focus();\n let [range, ] = this.quill.selection.getRange();\n if (this.handlers[format] != null) {\n this.handlers[format].call(this, value);\n } else if (Parchment.query(format).prototype instanceof Parchment.Embed) {\n value = prompt(`Enter ${format}`);\n if (!value) return;\n this.quill.updateContents(new Delta()\n .retain(range.index)\n .delete(range.length)\n .insert({ [format]: value })\n , Quill.sources.USER);\n } else {\n this.quill.format(format, value, Quill.sources.USER);\n }\n this.update(range);\n });\n // TODO use weakmap\n this.controls.push([format, input]);\n }\n\n update(range) {\n let formats = range == null ? {} : this.quill.getFormat(range);\n this.controls.forEach(function(pair) {\n let [format, input] = pair;\n if (input.tagName === 'SELECT') {\n let option;\n if (range == null) {\n option = null;\n } else if (formats[format] == null) {\n option = input.querySelector('option[selected]');\n } else if (!Array.isArray(formats[format])) {\n let value = formats[format];\n if (typeof value === 'string') {\n value = value.replace(/\\\"/g, '\\\\\"');\n }\n option = input.querySelector(`option[value=\"${value}\"]`);\n }\n if (option == null) {\n input.value = ''; // TODO make configurable?\n input.selectedIndex = -1;\n } else {\n option.selected = true;\n }\n } else {\n if (range == null) {\n input.classList.remove('ql-active');\n } else if (input.hasAttribute('value')) {\n // both being null should match (default values)\n // '1' should match with 1 (headers)\n let isActive = formats[format] === input.getAttribute('value') ||\n (formats[format] != null && formats[format].toString() === input.getAttribute('value')) ||\n (formats[format] == null && !input.getAttribute('value'));\n input.classList.toggle('ql-active', isActive);\n } else {\n input.classList.toggle('ql-active', formats[format] != null);\n }\n }\n });\n }\n}\nToolbar.DEFAULTS = {};\n\n\nfunction addButton(container, format, value) {\n let input = document.createElement('button');\n input.setAttribute('type', 'button');\n input.classList.add('ql-' + format);\n if (value != null) {\n input.value = value;\n }\n container.appendChild(input);\n}\n\nfunction addControls(container, groups) {\n if (!Array.isArray(groups[0])) {\n groups = [groups];\n }\n groups.forEach(function(controls) {\n let group = document.createElement('span');\n group.classList.add('ql-formats');\n controls.forEach(function(control) {\n if (typeof control === 'string') {\n addButton(group, control);\n } else {\n let format = Object.keys(control)[0];\n let value = control[format];\n if (Array.isArray(value)) {\n addSelect(group, format, value);\n } else {\n addButton(group, format, value);\n }\n }\n });\n container.appendChild(group);\n });\n}\n\nfunction addSelect(container, format, values) {\n let input = document.createElement('select');\n input.classList.add('ql-' + format);\n values.forEach(function(value) {\n let option = document.createElement('option');\n if (value !== false) {\n option.setAttribute('value', value);\n } else {\n option.setAttribute('selected', 'selected');\n }\n input.appendChild(option);\n });\n container.appendChild(input);\n}\n\nToolbar.DEFAULTS = {\n container: null,\n handlers: {\n clean: function() {\n let range = this.quill.getSelection();\n if (range == null) return;\n if (range.length == 0) {\n let formats = this.quill.getFormat();\n Object.keys(formats).forEach((name) => {\n // Clean functionality in existing apps only clean inline formats\n if (Parchment.query(name, Parchment.Scope.INLINE) != null) {\n this.quill.format(name, false);\n }\n });\n } else {\n this.quill.removeFormat(range, Quill.sources.USER);\n }\n },\n direction: function(value) {\n let align = this.quill.getFormat()['align'];\n if (value === 'rtl' && align == null) {\n this.quill.format('align', 'right', Quill.sources.USER);\n } else if (!value && align === 'right') {\n this.quill.format('align', false, Quill.sources.USER);\n }\n this.quill.format('direction', value, Quill.sources.USER);\n },\n indent: function(value) {\n let range = this.quill.getSelection();\n let formats = this.quill.getFormat(range);\n let indent = parseInt(formats.indent || 0);\n if (value === '+1' || value === '-1') {\n let modifier = (value === '+1') ? 1 : -1;\n if (formats.direction === 'rtl') modifier *= -1;\n this.quill.format('indent', indent + modifier, Quill.sources.USER);\n }\n },\n link: function(value) {\n if (value === true) {\n value = prompt('Enter link URL:');\n }\n this.quill.format('link', value, Quill.sources.USER);\n },\n list: function(value) {\n let range = this.quill.getSelection();\n let formats = this.quill.getFormat(range);\n if (value === 'check') {\n if (formats['list'] === 'checked' || formats['list'] === 'unchecked') {\n this.quill.format('list', false, Quill.sources.USER);\n } else {\n this.quill.format('list', 'unchecked', Quill.sources.USER);\n }\n } else {\n this.quill.format('list', value, Quill.sources.USER);\n }\n }\n }\n}\n\n\nexport { Toolbar as default, addControls };\n","import Quill from './core';\n\nimport { AlignClass, AlignStyle } from './formats/align';\nimport { DirectionAttribute, DirectionClass, DirectionStyle } from './formats/direction';\nimport { IndentClass as Indent } from './formats/indent';\n\nimport Blockquote from './formats/blockquote';\nimport Header from './formats/header';\nimport List, { ListItem } from './formats/list';\n\nimport { BackgroundClass, BackgroundStyle } from './formats/background';\nimport { ColorClass, ColorStyle } from './formats/color';\nimport { FontClass, FontStyle } from './formats/font';\nimport { SizeClass, SizeStyle } from './formats/size';\n\nimport Bold from './formats/bold';\nimport Italic from './formats/italic';\nimport Link from './formats/link';\nimport Script from './formats/script';\nimport Strike from './formats/strike';\nimport Underline from './formats/underline';\n\nimport Image from './formats/image';\nimport Video from './formats/video';\n\nimport CodeBlock, { Code as InlineCode } from './formats/code';\n\n// import Formula from './modules/formula';\n// import Syntax from './modules/syntax';\nimport Toolbar from './modules/toolbar';\n\n// import Icons from './ui/icons';\n// import Picker from './ui/picker';\n// import ColorPicker from './ui/color-picker';\n// import IconPicker from './ui/icon-picker';\n// import Tooltip from './ui/tooltip';\n\n// import BubbleTheme from './themes/bubble';\n// import SnowTheme from './themes/snow';\n\n\nQuill.register({\n 'attributors/attribute/direction': DirectionAttribute,\n\n 'attributors/class/align': AlignClass,\n 'attributors/class/background': BackgroundClass,\n 'attributors/class/color': ColorClass,\n 'attributors/class/direction': DirectionClass,\n 'attributors/class/font': FontClass,\n 'attributors/class/size': SizeClass,\n\n 'attributors/style/align': AlignStyle,\n 'attributors/style/background': BackgroundStyle,\n 'attributors/style/color': ColorStyle,\n 'attributors/style/direction': DirectionStyle,\n 'attributors/style/font': FontStyle,\n 'attributors/style/size': SizeStyle\n}, true);\n\n\nQuill.register({\n 'formats/align': AlignClass,\n 'formats/direction': DirectionClass,\n 'formats/indent': Indent,\n\n 'formats/background': BackgroundStyle,\n 'formats/color': ColorStyle,\n 'formats/font': FontClass,\n 'formats/size': SizeClass,\n\n 'formats/blockquote': Blockquote,\n 'formats/code-block': CodeBlock,\n 'formats/header': Header,\n 'formats/list': List,\n\n 'formats/bold': Bold,\n 'formats/code': InlineCode,\n 'formats/italic': Italic,\n 'formats/link': Link,\n 'formats/script': Script,\n 'formats/strike': Strike,\n 'formats/underline': Underline,\n\n 'formats/image': Image,\n 'formats/video': Video,\n\n 'formats/list/item': ListItem,\n\n // 'modules/formula': Formula,\n // 'modules/syntax': Syntax,\n 'modules/toolbar': Toolbar\n\n // 'themes/bubble': BubbleTheme,\n // 'themes/snow': SnowTheme,\n\n // 'ui/icons': Icons,\n // 'ui/picker': Picker,\n // 'ui/icon-picker': IconPicker,\n // 'ui/color-picker': ColorPicker,\n // 'ui/tooltip': Tooltip\n}, true);\n\n\nexport default Quill;\n"],"names":["root","factory","exports","module","define","amd","self","elem","document","createElement","classList","toggle","contains","_toggle","DOMTokenList","prototype","token","force","arguments","length","this","call","String","startsWith","searchString","position","substr","endsWith","subjectString","toString","isFinite","Math","floor","lastIndex","indexOf","Array","find","Object","defineProperty","value","predicate","TypeError","list","thisArg","i","addEventListener","execCommand","has","hasOwnProperty","prefix","Events","EE","fn","context","once","EventEmitter","_events","_eventsCount","create","__proto__","eventNames","events","name","names","push","slice","getOwnPropertySymbols","concat","listeners","event","exists","evt","available","l","ee","emit","a1","a2","a3","a4","a5","args","len","removeListener","undefined","apply","j","on","listener","removeAllListeners","off","addListener","setMaxListeners","prefixed","DIFF_DELETE","DIFF_INSERT","DIFF_EQUAL","diff_main","text1","text2","cursor_pos","_fix_unicode","editdiff","oldText","newText","oldRange","index","newRange","oldLength","newLength","oldCursor","oldBefore","oldAfter","maybeNewCursor","newCursor","newBefore","newAfter","prefixLength","min","oldPrefix","newPrefix","make_edit_splice","cursor","suffixLength","oldSuffix","newSuffix","find_cursor_edit_diff","commonlength","diff_commonPrefix","commonprefix","substring","diff_commonSuffix","commonsuffix","diffs","longtext","shorttext","hm","diff_halfMatchI_","best_longtext_a","best_longtext_b","best_shorttext_a","best_shorttext_b","seed","best_common","text1_a","text1_b","text2_a","text2_b","hm1","ceil","hm2","mid_common","diff_halfMatch_","diffs_a","diffs_b","text1_length","text2_length","max_d","v_offset","v_length","v1","v2","x","delta","front","k1start","k1end","k2start","k2end","d","k1","k1_offset","y1","x1","charAt","k2_offset","x2","diff_bisectSplit_","k2","y2","diff_bisect_","diff_compute_","unshift","diff_cleanupMerge","y","text1a","text2a","text1b","text2b","diffsb","pointermin","pointermax","pointermid","pointerstart","is_surrogate_pair_start","charCodeAt","pointerend","is_surrogate_pair_end","fix_unicode","pointer","count_delete","count_insert","text_delete","text_insert","splice","previous_equality","ends_with_pair_start","stray","k","starts_with_pair_end","n","pop","changes","charCode","str","before","oldMiddle","newMiddle","after","tuples","ret","remove_empty_tuples","diff","INSERT","DELETE","EQUAL","HASH_UNDEFINED","MAX_SAFE_INTEGER","argsTag","boolTag","dateTag","funcTag","genTag","mapTag","numberTag","objectTag","promiseTag","regexpTag","setTag","stringTag","symbolTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reFlags","reIsHostCtor","reIsUint","cloneableTags","freeGlobal","g","freeSelf","Function","freeExports","nodeType","freeModule","moduleExports","addMapEntry","map","pair","set","addSetEntry","add","arrayReduce","array","iteratee","accumulator","initAccum","isHostObject","result","e","mapToArray","size","forEach","key","overArg","func","transform","arg","setToArray","uid","arrayProto","funcProto","objectProto","coreJsData","maskSrcKey","exec","keys","IE_PROTO","funcToString","objectToString","reIsNative","RegExp","replace","Buffer","Symbol","Uint8Array","getPrototype","getPrototypeOf","objectCreate","propertyIsEnumerable","nativeGetSymbols","nativeIsBuffer","isBuffer","nativeKeys","DataView","getNative","Map","Promise","Set","WeakMap","nativeCreate","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","valueOf","Hash","entries","clear","entry","ListCache","MapCache","Stack","__data__","arrayLikeKeys","inherited","isArray","isObjectLike","isArrayLike","isArrayLikeObject","isArguments","baseTimes","skipIndexes","isIndex","assignValue","object","objValue","eq","assocIndexOf","baseClone","isDeep","isFull","customizer","stack","isObject","isArr","constructor","input","initCloneArray","source","copyArray","tag","getTag","isFunc","buffer","copy","cloneBuffer","isPrototype","proto","initCloneObject","copyObject","getSymbols","copySymbols","baseAssign","cloneFunc","Ctor","cloneArrayBuffer","dataView","byteOffset","byteLength","cloneDataView","typedArray","cloneTypedArray","cloneMap","regexp","cloneRegExp","cloneSet","symbol","initCloneByTag","stacked","get","props","keysFunc","symbolsFunc","values","offset","arrayPush","baseGetAllKeys","getAllKeys","arrayEach","subValue","baseIsNative","isFunction","test","arrayBuffer","newValue","getMapData","type","data","getValue","cache","pairs","LARGE_ARRAY_SIZE","other","ArrayBuffer","resolve","ctorString","isLength","baseKeys","COMPARE_PARTIAL_FLAG","COMPARE_UNORDERED_FLAG","arrayTag","asyncTag","errorTag","nullTag","proxyTag","undefinedTag","typedArrayTags","freeProcess","process","nodeUtil","binding","nodeIsTypedArray","isTypedArray","arraySome","nativeObjectToString","symToStringTag","toStringTag","SetCache","isArg","isBuff","isType","baseGetTag","isOwn","unmasked","getRawTag","baseIsArguments","baseIsEqual","bitmask","equalFunc","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","equalArrays","message","convert","isPartial","equalByTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","objProps","objLength","othProps","othLength","skipCtor","othValue","compared","objCtor","othCtor","equalObjects","baseIsEqualDeep","isMasked","arrLength","seen","arrValue","othIndex","resIndex","arrayFilter","baseUnary","types","require","objectCtorString","allocUnsafe","nativeMax","max","nativeNow","Date","now","baseCreate","assignMergeValue","baseAssignValue","fromRight","baseFor","iterable","baseKeysIn","nativeKeysIn","isProto","baseMerge","srcIndex","srcValue","mergeFunc","safeGet","isCommon","isTyped","isPlainObject","isNew","keysIn","toPlainObject","baseMergeDeep","baseRest","start","setToString","otherArgs","overRest","identity","baseSetToString","string","count","lastCalled","stamp","remaining","shortOut","assigner","merge","sources","guard","isIterateeCall","property","extendStatics","__extends","setPrototypeOf","b","p","__","ParchmentError","_super","_this","Error","Scope","attributes","classes","tags","query","scope","match","ANY","Text","Node","TEXT_NODE","LEVEL","BLOCK","INLINE","HTMLElement","getAttribute","split","tagName","TYPE","DATA_KEY","BlotClass","node","bubble","blot","parentNode","register","Definitions","_i","Definition","blotName","attrName","keyName","className","toUpperCase","Registry","Attributor","options","attributeBit","ATTRIBUTE","whitelist","item","canAdd","setAttribute","BLOT","remove","removeAttribute","default","linked_list_1","shadow_1","ContainerBlot","domNode","build","appendChild","insertBefore","attach","children","child","childNodes","reverse","makeBlot","head","err","deleteAt","forEachAt","descendant","criteria","_a","descendants","Number","MAX_VALUE","lengthLeft","detach","formatAt","insertAt","def","childBlot","refBlot","statics","allowedChildren","some","insertInto","reduce","memo","moveChildren","targetParent","refNode","optimize","defaultChild","path","inclusive","removeChild","target","next","clone","parent","unwrap","update","mutations","addedNodes","removedNodes","mutation","body","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","filter","sort","a","DOCUMENT_POSITION_FOLLOWING","nextSibling","replaceChild","attributor_1","store_1","container_1","FormatBlot","formats","toLowerCase","format","attribute","replaceWith","replacement","wrap","wrapper","move","LeafBlot","INLINE_BLOT","ShadowBlot","enumerable","configurable","parseInt","scroll","cloneNode","isolate","parent_1","ref","parentBlot","refDomNode","class_1","style_1","AttributorStore","styles","attr","ClassAttributor","join","camelize","parts","rest","part","StyleAttributor","trim","style","format_1","leaf_1","scroll_1","inline_1","block_1","embed_1","text_1","Parchment","Container","Format","Leaf","Embed","Scroll","Block","Inline","Attribute","Class","Style","Store","LinkedList","tail","append","nodes","cur","iterator","prev","curNode","length_1","callback","startNode","curIndex","curLength","OBSERVER_CONFIG","characterData","characterDataOldValue","childList","subtree","ScrollBlot","observer","MutationObserver","observe","disconnect","records","takeRecords","mark","markParent","previousSibling","grandChild","BLOCK_BLOT","InlineBlot","obj1","obj2","prop","isEqual","BlockBlot","navigator","userAgent","EmbedBlot","TextBlot","text","createTextNode","splitText","AttributeMap","compose","keepNull","attrs","invert","base","baseInverted","priority","NULL_CHARACTER","fromCharCode","ops","insert","newOp","delete","retain","lastOp","chop","partition","passed","failed","op","initialValue","changeLength","end","iter","hasNext","nextOp","Delta","thisIter","otherIter","firstOther","peek","firstLeft","peekType","peekLength","thisOp","otherOp","strings","retDelta","diffResult","component","opLength","eachLine","newline","line","inverted","baseIndex","baseOp","transformPosition","nextType","Op","Infinity","retOp","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","id","loaded","__webpack_modules__","getter","__esModule","definition","o","globalThis","window","obj","nmd","paths","Break","super","compare","selfIndex","order","otherIndex","BlockEmbed","BLOCK_ATTRIBUTE","block","leaf","bubbleFormats","lines","shift","Code","CodeBlock","textContent","frag","nextNewline","newlineIndex","prevNewline","isolateLength","searchIndex","lastIndexOf","querySelectorAll","TAB","Cursor","selection","textNode","CONTENTS","_length","restore","composing","restoreText","range","getNativeRange","lastChild","startOffset","endNode","endOffset","ASCII","combineFormats","combined","merged","getDelta","applyDelta","consumeNextNewline","scrollLength","batchStart","cloneDeep","image","bullet","normalizeDelta","batchEnd","deleteText","formatLine","lengthRemaining","lineLength","codeIndex","codeLength","formatText","getContents","getFormat","leaves","lineFormats","leafFormats","blots","getText","insertEmbed","embed","insertText","isBlank","removeFormat","suffix","change","cursorIndex","oldDelta","textBlot","oldValue","CursorBlot","levels","level","debug","method","_len","_key","console","namespace","ns","logger","bind","newLevel","EMITTERS","supportsRootNode","eventName","em","handleDOM","Emitter","error","log","connect","_len2","_key2","composedPath","_ref","handler","containsNode","getRootNode","host","listenDOM","EDITOR_CHANGE","SCROLL_BEFORE_UPDATE","SCROLL_OPTIMIZE","SCROLL_UPDATE","SELECTION_CHANGE","TEXT_CHANGE","API","SILENT","USER","Module","quill","DEFAULTS","SUPPORTS_SHADOW_SELECTION","ShadowRoot","getSelection","SUPPORTS_BEFORE_INPUT","InputEvent","getTargetRanges","IS_FIREFOX","IS_MSIE","IS_EDGE","processing","ShadowSelection","_ranges","rangeCount","getRangeAt","addRange","windowSel","removeAllRanges","setBaseAndExtent","startContainer","endContainer","active","activeElement","shadowRoot","getActiveElement","Range","setStart","setEnd","preventDefault","stopImmediatePropagation","Selection","emitter","mouseDown","rootDocument","lastRange","savedRange","handleComposition","handleDragging","setTimeout","_","hasFocus","native","hackOffset","setNativeRange","ignored","focus","setRange","nativeRange","collapsed","getBounds","createRange","getBoundingClientRect","rect","side","bottom","top","height","left","right","width","normalizeNative","info","getRange","normalized","normalizedToRange","positions","indexes","rangeToNative","scrollIntoView","scrollingContainer","bounds","limit","first","last","scrollBounds","scrollTop","blur","Theme","modules","init","addModule","moduleClass","import","themes","Quill","__quill","imports","overwrite","warn","container","userConfig","clipboard","keyboard","history","theme","themeConfig","config","moduleConfig","toolbar","querySelector","expandConfig","html","innerHTML","addContainer","editor","Editor","modify","contents","setContents","placeholder","readOnly","disable","overload","enable","enabled","setSelection","containerBounds","getLength","getIndex","getLeaf","getLine","getLines","getModule","isEnabled","pasteHTML","dangerouslyPasteHTML","deleted","applied","setText","updateContents","modifier","strict","shiftRange","pos","version","GUARD_TEXT","contentNode","childNode","leftGuard","rightGuard","prevLength","isLine","batch","AlignAttribute","AlignClass","AlignStyle","ColorAttributor","ColorClass","ColorStyle","BackgroundClass","BackgroundStyle","DirectionAttribute","DirectionClass","DirectionStyle","FontClass","FontStyleAttributor","FontStyle","SizeClass","SizeStyle","DOM_KEY","CLIPBOARD_CONFIG","computeStyle","whiteSpace","replacer","collapse","matchNewline","deltaEndsWith","ELEMENT_NODE","applyFormat","ATTRIBUTE_ATTRIBUTORS","STYLE_ATTRIBUTORS","fontStyle","italic","fontWeight","bold","parseFloat","textIndent","indent","matchAlias","Clipboard","onPaste","matchers","selector","matcher","addMatcher","innerText","elementMatchers","textMatchers","prepareMatching","traverse","paste","defaultPrevented","getComputedStyle","endText","display","childrenDelta","matchVisual","History","lastRecorded","ignoreChange","userOnly","record","addBinding","shortKey","undo","shiftKey","redo","platform","dest","deleteLength","changeIndex","endsWithNewlineChange","getLastChangeIndex","cutoff","changeDelta","undoDelta","timestamp","delay","maxStack","SHORTKEY","Keyboard","normalize","which","keyCode","bindings","ENTER","handleEnter","metaKey","ctrlKey","altKey","BACKSPACE","handleBackspace","handleDelete","handleDeleteRange","listen","leafStart","offsetStart","leafEnd","offsetEnd","prefixText","suffixText","curContext","empty","every","makeEmbedArrowHandler","where","LEFT","RIGHT","curFormats","prevFormats","nextLength","nextFormats","DeltaOp","firstFormats","lastFormats","makeCodeBlockHandler","scrollIndex","makeFormatHandler","ESCAPE","UP","DOWN","header","IdentAttributor","IndentClass","Blockquote","Header","ListItem","List","hasAttribute","listEventHandler","Bold","Italic","Link","sanitize","url","PROTOCOL_WHITELIST","SANITIZED_URL","protocols","anchor","href","protocol","Script","Strike","Underline","ATTRIBUTES","Image","Video","Toolbar","groups","controls","group","control","addButton","option","addSelect","addControls","handlers","addHandler","selectedIndex","selected","prompt","isActive","clean","direction","align","link","Indent","InlineCode"],"sourceRoot":""}