@vaadin/rich-text-editor 25.0.0-alpha9 → 25.0.0-beta1

package/vendor/vaadin-quill.js.map

@@ -1 +1 @@
-{"version":3,"file":"vaadin-quill.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 = AttributeMap.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 = AttributeMap.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","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":""}
+{"version":3,"file":"vaadin-quill.js","mappings":";CAAA,SAA2CA,EAAMC,GAC1B,iBAAZC,SAA0C,iBAAXC,OACxCA,OAAOD,QAAUD,IACQ,mBAAXG,QAAyBA,OAAOC,IAC9CD,OAAO,GAAIH,GACe,iBAAZC,QACdA,QAAe,MAAID,IAEnBD,EAAY,MAAIC,GACjB,CATD,CASGK,MAAM,WACT,yLCKA,MAAMC,UAAcC,EAAAA,UAClBC,MAAmD,CAAC,EAEpDC,KAAAA,GAIE,OAHwB,MAApBC,KAAKF,MAAMC,QACbC,KAAKF,MAAMC,MAkKjB,SAAoBE,GAAgC,IAAfC,IAAMC,UAAAC,OAAA,QAAAC,IAAAF,UAAA,KAAAA,UAAA,GACzC,OAAOF,EACJK,YAAYC,EAAAA,UACZC,QAAO,CAACT,EAAOU,IACQ,IAAlBA,EAAKL,SACAL,EAEFA,EAAMW,OAAOD,EAAKE,QAASC,EAAcH,EAAM,CAAC,EAAGP,KACzD,IAAIW,EAAAA,IACNH,OAAO,KAAME,EAAcX,GAChC,CA5KyBa,CAAWd,OAEzBA,KAAKF,MAAMC,KACpB,CAEAgB,QAAAA,CAASC,EAAeZ,GACtBa,MAAMF,SAASC,EAAOZ,GACtBJ,KAAKF,MAAQ,CAAC,CAChB,CAEAoB,QAAAA,CAASF,EAAeZ,EAAgBe,EAAcR,GAChDP,GAAU,IACVJ,KAAKoB,OAAOC,MAAMF,EAAMG,EAAAA,MAAMC,OAC5BP,EAAQZ,IAAWJ,KAAKI,UAC1BJ,KAAKwB,OAAOL,EAAMR,GAGpBM,MAAMC,SACJF,EACAS,KAAKC,IAAItB,EAAQJ,KAAKI,SAAWY,EAAQ,GACzCG,EACAR,GAGJX,KAAKF,MAAQ,CAAC,EAChB,CAEA6B,QAAAA,CAASX,EAAeL,EAAeiB,GACrC,GAAW,MAAPA,EAGF,OAFAX,MAAMU,SAASX,EAAOL,EAAOiB,QAC7B5B,KAAKF,MAAQ,CAAC,GAGhB,GAAqB,IAAjBa,EAAMP,OAAc,OACxB,MAAMyB,EAAQlB,EAAMmB,MAAM,MACpBC,EAAOF,EAAMG,QACfD,EAAK3B,OAAS,IACZY,EAAQhB,KAAKI,SAAW,GAA2B,MAAtBJ,KAAKiC,SAASC,KAC7CjB,MAAMU,SAASF,KAAKC,IAAIV,EAAOhB,KAAKI,SAAW,GAAI2B,GAEnD/B,KAAKiC,SAASC,KAAKP,SAAS3B,KAAKiC,SAASC,KAAK9B,SAAU2B,GAE3D/B,KAAKF,MAAQ,CAAC,GAIhB,IAAIqC,EAAqBnC,KACzB6B,EAAMrB,QAAO,CAAC4B,EAAWC,KAEvBF,EAAQA,EAAML,MAAMM,GAAW,GAC/BD,EAAMR,SAAS,EAAGU,GACXA,EAAKjC,SACXY,EAAQe,EAAK3B,OAClB,CAEAkC,YAAAA,CAAarC,EAAYsC,GACvB,MAAM,KAAEC,GAASxC,KAAKiC,SACtBhB,MAAMqB,aAAarC,EAAMsC,GACrBC,aAAgBC,EAAAA,GAClBD,EAAKE,SAEP1C,KAAKF,MAAQ,CAAC,CAChB,CAEAM,MAAAA,GAIE,OAHyB,MAArBJ,KAAKF,MAAMM,SACbJ,KAAKF,MAAMM,OAASa,MAAMb,SAzET,GA2EZJ,KAAKF,MAAMM,MACpB,CAEAuC,YAAAA,CAAaC,EAAgBL,GAC3BtB,MAAM0B,aAAaC,EAAQL,GAC3BvC,KAAKF,MAAQ,CAAC,CAChB,CAEA+C,QAAAA,CAASC,GACP7B,MAAM4B,SAASC,GACf9C,KAAKF,MAAQ,CAAC,CAChB,CAEAiD,IAAAA,CAAK/B,GACH,OAAOC,MAAM8B,KAAK/B,GAAO,EAC3B,CAEAgC,WAAAA,CAAYC,GACVhC,MAAM+B,YAAYC,GAClBjD,KAAKF,MAAQ,CAAC,CAChB,CAEAgC,KAAAA,CAAMd,GAAgE,IAAjDkC,EAA0B/C,UAAAC,OAAA,QAAAC,IAAAF,UAAA,IAAAA,UAAA,GAC7C,GAAI+C,IAAoB,IAAVlC,GAAeA,GAAShB,KAAKI,SAlGxB,GAkGoD,CACrE,MAAM+C,EAAQnD,KAAKmD,QACnB,OAAc,IAAVnC,GACFhB,KAAKoD,OAAOd,aAAaa,EAAOnD,MACzBA,OAETA,KAAKoD,OAAOd,aAAaa,EAAOnD,KAAKqD,MAC9BF,EACT,CACA,MAAME,EAAOpC,MAAMa,MAAMd,EAAOkC,GAEhC,OADAlD,KAAKF,MAAQ,CAAC,EACPuD,CACT,EAEFzD,EAAM0D,SAAW,QACjB1D,EAAM2D,QAAU,IAChB3D,EAAM4D,aAAef,EAAAA,EACrB7C,EAAM6D,gBAAkB,CAAChB,EAAAA,EAAOiB,EAAAA,EAAQC,EAAAA,UAAWC,EAAAA,GAEnD,MAAMC,UAAmBF,EAAAA,UAIvBG,MAAAA,GACE7C,MAAM6C,SACN9D,KAAK+D,WAAa,IAAIC,EAAAA,gBAAgBhE,KAAKiE,QAC7C,CAEAlE,KAAAA,GACE,OAAO,IAAIc,EAAAA,IAAQH,OAAOV,KAAKW,QAAS,IACnCX,KAAKkE,aACLlE,KAAK+D,WAAWI,UAEvB,CAEA3C,MAAAA,CAAOL,EAAcR,GACnB,MAAMyD,EAAYpE,KAAKoB,OAAOC,MAAMF,EAAMG,EAAAA,MAAM+C,iBAC/B,MAAbD,GAEFpE,KAAK+D,WAAWK,UAAUA,EAAWzD,EAEzC,CAEAO,QAAAA,CAASF,EAAeZ,EAAgBe,EAAcR,GACpDX,KAAKwB,OAAOL,EAAMR,EACpB,CAEAgB,QAAAA,CAASX,EAAeL,EAAeiB,GACrC,GAAW,MAAPA,EAEF,YADAX,MAAMU,SAASX,EAAOL,EAAOiB,GAG/B,MAAMC,EAAQlB,EAAMmB,MAAM,MACpBC,EAAOF,EAAMyC,MACbC,EAAS1C,EAAM2C,KAAKnC,IACxB,MAAMF,EAAQnC,KAAKoB,OAAOqD,OAAO7E,EAAM0D,UAEvC,OADAnB,EAAMR,SAAS,EAAGU,GACXF,CAAK,IAERI,EAAMvC,KAAK8B,MAAMd,GACvBuD,EAAOG,SAASvC,IACdnC,KAAKoD,OAAOd,aAAaH,EAAOI,EAAI,IAElCR,GACF/B,KAAKoD,OAAOd,aAAatC,KAAKoB,OAAOqD,OAAO,OAAQ1C,GAAOQ,EAE/D,EAiBF,SAAS3B,EACPX,GAGyB,IAFzBiE,EAAgC/D,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,CAAC,EACpCD,IAAMC,UAAAC,OAAA,QAAAC,IAAAF,UAAA,KAAAA,UAAA,GAEN,OAAY,MAARF,EAAqBiE,GACrB,YAAajE,GAAgC,mBAAjBA,EAAKiE,UACnCA,EAAU,IACLA,KACAjE,EAAKiE,WAENhE,UAEKgE,EAAQ,eAIF,MAAfjE,EAAKmD,QAC4B,WAAjCnD,EAAKmD,OAAOuB,QAAQrB,UACpBrD,EAAKmD,OAAOuB,QAAQC,QAAU3E,EAAK0E,QAAQC,MAEpCV,EAEFtD,EAAcX,EAAKmD,OAAQc,EAAShE,GAC7C,CAvCA2D,EAAWe,MAAQtD,EAAAA,MAAMuD,0CCjLzB,MAAMpC,UAAckB,EAAAA,UAClB,YAAOhD,GAEP,CAEAkC,QAAAA,IACM7C,KAAK8E,MAAQ9E,KAAKqD,OACpBrD,KAAK0C,QAET,CAEAtC,MAAAA,GACE,OAAO,CACT,CAEAO,KAAAA,GACE,MAAO,EACT,EAEF8B,EAAMa,SAAW,QACjBb,EAAMc,QAAU,KAEhB,sCCtBA,MAAMwB,UAAkBC,EAAAA,eAExB,+CCEA,MAAMC,UAAetB,EAAAA,UACnBuB,gBAAkB,SAClBA,iBAAmB,YACnBA,eAAiB,OACjBA,gBAAkB,SAElB,YAAOvE,GAEP,CAMAwE,WAAAA,CAAY/D,EAAoB6C,EAAsBmB,GACpDnE,MAAMG,EAAQ6C,GACdjE,KAAKoF,UAAYA,EACjBpF,KAAKqF,SAAWC,SAASC,eAAeN,EAAOO,UAC/CxF,KAAKiE,QAAQwB,YAAYzF,KAAKqF,UAC9BrF,KAAK0F,YAAc,CACrB,CAEAC,MAAAA,GAEqB,MAAf3F,KAAKoD,QAAgBpD,KAAKoD,OAAOJ,YAAYhD,KACnD,CAEAwB,MAAAA,CAAOL,EAAcR,GACnB,GAAyB,IAArBX,KAAK0F,YAEP,YADAzE,MAAMO,OAAOL,EAAMR,GAKrB,IAAIiC,EAAwB5C,KACxBgB,EAAQ,EACZ,KAAiB,MAAV4B,GAAkBA,EAAO+B,QAAQC,QAAUtD,EAAAA,MAAMuD,YACtD7D,GAAS4B,EAAOgD,OAAOhD,EAAOQ,QAC9BR,EAASA,EAAOQ,OAEJ,MAAVR,IACF5C,KAAK0F,YAAcT,EAAOO,SAASpF,OAEnCwC,EAAOC,WACPD,EAAO1B,SAASF,EAAOiE,EAAOO,SAASpF,OAAQe,EAAMR,GACrDX,KAAK0F,YAAc,EAEvB,CAEA1E,KAAAA,CAAM6E,EAAYD,GAChB,OAAIC,IAAS7F,KAAKqF,SAAiB,EAC5BpE,MAAMD,MAAM6E,EAAMD,EAC3B,CAEAxF,MAAAA,GACE,OAAOJ,KAAK0F,WACd,CAEAI,QAAAA,GACE,MAAO,CAAC9F,KAAKqF,SAAUrF,KAAKqF,SAASU,KAAK3F,OAC5C,CAEAsC,MAAAA,GACEzB,MAAMyB,SAEN1C,KAAKoD,OAAS,IAChB,CAEA4C,OAAAA,GACE,GAAIhG,KAAKoF,UAAUa,WAA4B,MAAfjG,KAAKoD,OAAgB,OAAO,KAC5D,MAAM8C,EAAQlG,KAAKoF,UAAUe,iBAG7B,KAC4B,MAA1BnG,KAAKiE,QAAQmC,WACbpG,KAAKiE,QAAQmC,YAAcpG,KAAKqF,UAGhCrF,KAAKiE,QAAQoC,WAAW/D,aACtBtC,KAAKiE,QAAQmC,UACbpG,KAAKiE,SAIT,MAAMqC,EAAetG,KAAK8E,gBAAgBlB,EAAAA,EAAW5D,KAAK8E,KAAO,KAC3DyB,EAAiBD,EAAeA,EAAalG,SAAW,EACxDoG,EAAexG,KAAKqD,gBAAgBO,EAAAA,EAAW5D,KAAKqD,KAAO,KAE3DoD,EAAWD,EAAeA,EAAazE,KAAO,IAC9C,SAAEsD,GAAarF,KAEf0G,EAAUrB,EAASU,KAAKjE,MAAMmD,EAAOO,UAAUmB,KAAK,IAO1D,IAAIC,EACJ,GAPAvB,EAASU,KAAOd,EAAOO,SAOnBc,EACFM,EAAiBN,GACbI,GAAWF,KACbF,EAAa3E,SAAS2E,EAAalG,SAAUsG,EAAUD,GACnDD,GACFA,EAAa9D,eAGZ,GAAI8D,EACTI,EAAiBJ,EACjBA,EAAa7E,SAAS,EAAG+E,OACpB,CACL,MAAMG,EAAcvB,SAASC,eAAemB,GAC5CE,EAAiB5G,KAAKoB,OAAOqD,OAAOoC,GACpC7G,KAAKoD,OAAOd,aAAasE,EAAgB5G,KAC3C,CAGA,GADAA,KAAK0C,SACDwD,EAAO,CAET,MAAMY,EAAcA,CAACjB,EAAYD,IAC3BU,GAAgBT,IAASS,EAAarC,QACjC2B,EAELC,IAASR,EACJkB,EAAiBX,EAAS,EAE/BY,GAAgBX,IAASW,EAAavC,QACjCsC,EAAiBG,EAAQtG,OAASwF,EAEpC,KAGHmB,EAAQD,EAAYZ,EAAMa,MAAMlB,KAAMK,EAAMa,MAAMnB,QAClDoB,EAAMF,EAAYZ,EAAMc,IAAInB,KAAMK,EAAMc,IAAIpB,QAClD,GAAc,OAAVmB,GAA0B,OAARC,EACpB,MAAO,CACLC,UAAWL,EAAe3C,QAC1BiD,YAAaH,EACbI,QAASP,EAAe3C,QACxBmD,UAAWJ,EAGjB,CACA,OAAO,IACT,CAEAK,MAAAA,CAAOC,EAA6BxE,GAClC,GACEwE,EAAUC,MAAMC,GAEM,kBAAlBA,EAASC,MAA4BD,EAAS5E,SAAW5C,KAAKqF,WAGlE,CACA,MAAMa,EAAQlG,KAAKgG,UACfE,IAAOpD,EAAQoD,MAAQA,EAC7B,CACF,CAYArD,QAAAA,CAASC,GAEP7B,MAAM4B,SAASC,GAEf,IAAI,OAAEM,GAAWpD,KACjB,KAAOoD,GAAQ,CACb,GAA+B,MAA3BA,EAAOa,QAAQV,QAAiB,CAClCvD,KAAK0F,YAAcT,EAAOO,SAASpF,OAEnCgD,EAAOsE,QAAQ1H,KAAK4F,OAAOxC,GAASpD,KAAKI,UAAUuH,SACnD3H,KAAK0F,YAAc,EACnB,KACF,CACAtC,EAASA,EAAOA,MAClB,CACF,CAEAzC,KAAAA,GACE,MAAO,EACT,EAGF,+CCjMA,MAAMiH,EAAa,SASnB,MAAMC,UAAclE,EAAAA,UAKlBwB,WAAAA,CAAY/D,EAAoByE,GAC9B5E,MAAMG,EAAQyE,GACd7F,KAAK8H,YAAcxC,SAASyC,cAAc,QAC1C/H,KAAK8H,YAAYE,aAAa,kBAAmB,SACjDC,MAAMC,KAAKlI,KAAKiE,QAAQkE,YAAYzD,SAAS0D,IAC3CpI,KAAK8H,YAAYrC,YAAY2C,EAAU,IAEzCpI,KAAKqI,UAAY/C,SAASC,eAAeqC,GACzC5H,KAAKsI,WAAahD,SAASC,eAAeqC,GAC1C5H,KAAKiE,QAAQwB,YAAYzF,KAAKqI,WAC9BrI,KAAKiE,QAAQwB,YAAYzF,KAAK8H,aAC9B9H,KAAKiE,QAAQwB,YAAYzF,KAAKsI,WAChC,CAEAtH,KAAAA,CAAM6E,EAAYD,GAChB,OAAIC,IAAS7F,KAAKqI,UAAkB,EAChCxC,IAAS7F,KAAKsI,WAAmB,EAC9BrH,MAAMD,MAAM6E,EAAMD,EAC3B,CAEAI,OAAAA,CAAQH,GACN,IACIR,EADAa,EAAkC,KAEtC,MAAMnE,EAAO8D,EAAKE,KAAKjE,MAAM8F,GAAYjB,KAAK,IAC9C,GAAId,IAAS7F,KAAKqI,UAChB,GAAIrI,KAAK8E,gBAAgBlB,EAAAA,EAAU,CACjC,MAAM2E,EAAavI,KAAK8E,KAAK1E,SAC7BJ,KAAK8E,KAAKnD,SAAS4G,EAAYxG,GAC/BmE,EAAQ,CACNe,UAAWjH,KAAK8E,KAAKb,QACrBiD,YAAaqB,EAAaxG,EAAK3B,OAEnC,MACEiF,EAAWC,SAASC,eAAexD,GACnC/B,KAAKoD,OAAOd,aAAatC,KAAKoB,OAAOqD,OAAOY,GAAWrF,MACvDkG,EAAQ,CACNe,UAAW5B,EACX6B,YAAanF,EAAK3B,aAGbyF,IAAS7F,KAAKsI,aACnBtI,KAAKqD,gBAAgBO,EAAAA,GACvB5D,KAAKqD,KAAK1B,SAAS,EAAGI,GACtBmE,EAAQ,CACNe,UAAWjH,KAAKqD,KAAKY,QACrBiD,YAAanF,EAAK3B,UAGpBiF,EAAWC,SAASC,eAAexD,GACnC/B,KAAKoD,OAAOd,aAAatC,KAAKoB,OAAOqD,OAAOY,GAAWrF,KAAKqD,MAC5D6C,EAAQ,CACNe,UAAW5B,EACX6B,YAAanF,EAAK3B,UAKxB,OADAyF,EAAKE,KAAO6B,EACL1B,CACT,CAEAmB,MAAAA,CAAOC,EAA6BxE,GAClCwE,EAAU5C,SAAS8C,IACjB,GACoB,kBAAlBA,EAASC,OACRD,EAAS5E,SAAW5C,KAAKqI,WACxBb,EAAS5E,SAAW5C,KAAKsI,YAC3B,CACA,MAAMpC,EAAQlG,KAAKgG,QAAQwB,EAAS5E,QAChCsD,IAAOpD,EAAQoD,MAAQA,EAC7B,IAEJ,EAGF,uDCvFA,MAAMxC,UAAe8E,EAAAA,WACnBtD,uBAA4C,CAACxB,EAAQjB,EAAAA,EAAOkB,EAAAA,UAAW8E,EAAAA,GAEvEvD,aAAe,CACb,SACA,SACA,OACA,YACA,SACA,SACA,OACA,SACA,QAGF,cAAOwD,CAAQ/I,EAAcgJ,GAC3B,MAAMC,EAAYlF,EAAOmF,MAAMC,QAAQnJ,GACjCoJ,EAAarF,EAAOmF,MAAMC,QAAQH,GACxC,OAAIC,GAAa,GAAKG,GAAc,EAC3BH,EAAYG,EAEjBpJ,IAASgJ,EACJ,EAELhJ,EAAOgJ,GACD,EAEH,CACT,CAEAzH,QAAAA,CAASF,EAAeZ,EAAgBe,EAAcR,GACpD,GACE+C,EAAOgF,QAAQ1I,KAAK2E,QAAQrB,SAAUnC,GAAQ,GAC9CnB,KAAKoB,OAAOC,MAAMF,EAAMG,EAAAA,MAAM0H,MAC9B,CACA,MAAM/I,EAAOD,KAAK0H,QAAQ1G,EAAOZ,GAC7BO,GACFV,EAAKgJ,KAAK9H,EAAMR,EAEpB,MACEM,MAAMC,SAASF,EAAOZ,EAAQe,EAAMR,EAExC,CAEAkC,QAAAA,CAASC,GAEP,GADA7B,MAAM4B,SAASC,GAEb9C,KAAKoD,kBAAkBM,GACvBA,EAAOgF,QAAQ1I,KAAK2E,QAAQrB,SAAUtD,KAAKoD,OAAOuB,QAAQrB,UAAY,EACtE,CACA,MAAMF,EAASpD,KAAKoD,OAAOsE,QAAQ1H,KAAK4F,SAAU5F,KAAKI,UAEvDJ,KAAK2C,aAAaS,GAClBA,EAAO6F,KAAKjJ,KACd,CACF,EAGF,6FC7DA,MAAMyI,UAAa7E,EAAAA,UAGnB,MAAMsF,EAAoC,CACxC,IAAK,QACL,IAAK,OACL,IAAK,OACL,IAAK,SACL,IAAK,SAGP,SAASC,EAAWpH,GAClB,OAAOA,EAAKqH,QAAQ,YAAaC,GAAMH,EAAUG,IACnD,wJCGA,SAASC,EAAOrJ,GACd,OAAOA,aAAgBL,EAAAA,IAASK,aAAgB4D,EAAAA,EAClD,CAMA,SAAS0F,EAAYtJ,GACnB,MAAyD,mBAA1CA,EAAwBuJ,aACzC,CAEA,MAAMC,UAAeC,EAAAA,WACnBxE,gBAAkB,SAClBA,iBAAmB,YACnBA,eAAiB,MACjBA,oBAAsBtF,EAAAA,GACtBsF,uBAAyB,CAACtF,EAAAA,GAAOiE,EAAAA,GAAYkB,EAAAA,GAK7CI,WAAAA,CACEwE,EACA1F,EAAuB2F,GAEvB,IADA,QAAEC,GAA+BD,EAEjC3I,MAAM0I,EAAU1F,GAChBjE,KAAK6J,QAAUA,EACf7J,KAAK8J,OAAQ,EACb9J,KAAK6C,WACL7C,KAAK+J,SACL/J,KAAKiE,QAAQ+F,iBAAiB,aAAcC,GAAMjK,KAAKkK,gBAAgBD,IACzE,CAEAE,UAAAA,GACOlC,MAAMmC,QAAQpK,KAAK8J,SACtB9J,KAAK8J,MAAQ,GAEjB,CAEAO,QAAAA,GACE,IAAKrK,KAAK8J,MAAO,OACjB,MAAMxC,EAAYtH,KAAK8J,MACvB9J,KAAK8J,OAAQ,EACb9J,KAAKqH,OAAOC,EACd,CAEAgD,SAAAA,CAAUrK,GACRD,KAAK6J,QAAQU,KAAKC,EAAAA,EAAQC,OAAOC,kBAAmBzK,EACtD,CAEA0K,WAAAA,CAAY1K,GACVD,KAAK6J,QAAQU,KAAKC,EAAAA,EAAQC,OAAOG,oBAAqB3K,EACxD,CAEA4K,eAAAA,CAAgB5K,EAAY6K,GAC1B9K,KAAK6J,QAAQU,KAAKC,EAAAA,EAAQC,OAAOM,oBAAqB9K,EAAM6K,EAC9D,CAEA/J,QAAAA,CAASC,EAAeZ,GACtB,MAAO4K,EAAOpF,GAAU5F,KAAKqC,KAAKrB,IAC3BiK,GAAQjL,KAAKqC,KAAKrB,EAAQZ,GAEjC,GADAa,MAAMF,SAASC,EAAOZ,GACV,MAAR6K,GAAgBD,IAAUC,GAAQrF,EAAS,EAAG,CAChD,GAAIoF,aAAiBnH,EAAAA,IAAcoH,aAAgBpH,EAAAA,GAEjD,YADA7D,KAAK6C,WAGP,MAAMN,EACJ0I,EAAKhJ,SAASO,gBAAgBC,EAAAA,EAAQ,KAAOwI,EAAKhJ,SAASO,KAE7DwI,EAAMrI,aAAasI,EAAM1I,GAEzByI,EAAMtI,QACR,CACA1C,KAAK6C,UACP,CAEAkH,MAAAA,GAAuB,IAAhBmB,IAAO/K,UAAAC,OAAA,QAAAC,IAAAF,UAAA,KAAAA,UAAA,GACZH,KAAKiE,QAAQ+D,aAAa,kBAAmBkD,EAAU,OAAS,QAClE,CAEAhK,QAAAA,CAASF,EAAeZ,EAAgBoB,EAAgBb,GACtDM,MAAMC,SAASF,EAAOZ,EAAQoB,EAAQb,GACtCX,KAAK6C,UACP,CAEAlB,QAAAA,CAASX,EAAeL,EAAeiB,GACrC,GAAIZ,GAAShB,KAAKI,SAChB,GAAW,MAAPwB,GAAwD,MAAzC5B,KAAKoB,OAAOC,MAAMV,EAAOW,EAAAA,MAAMC,OAAgB,CAChE,MAAMtB,EAAOD,KAAKoB,OAAOqD,OAAOzE,KAAK2E,QAAQnB,aAAaF,UAC1DtD,KAAKyF,YAAYxF,GACN,MAAP2B,GAAejB,EAAMwK,SAAS,MAChClL,EAAK0B,SAAS,EAAGhB,EAAMyK,MAAM,GAAI,GAAIxJ,GAErC3B,EAAK0B,SAAS,EAAGhB,EAAOiB,EAE5B,KAAO,CACL,MAAMyJ,EAAQrL,KAAKoB,OAAOqD,OAAO9D,EAAOiB,GACxC5B,KAAKyF,YAAY4F,EACnB,MAEApK,MAAMU,SAASX,EAAOL,EAAOiB,GAE/B5B,KAAK6C,UACP,CAEAP,YAAAA,CAAarC,EAAYsC,GACvB,GAAItC,EAAK0E,QAAQC,QAAUtD,EAAAA,MAAMgK,YAAa,CAC5C,MAAMC,EAAUvL,KAAKoB,OAAOqD,OAC1BzE,KAAK2E,QAAQnB,aAAaF,UAE5BiI,EAAQ9F,YAAYxF,GACpBgB,MAAMqB,aAAaiJ,EAAShJ,EAC9B,MACEtB,MAAMqB,aAAarC,EAAMsC,EAE7B,CAEAiJ,cAAAA,CAAexK,EAAejB,GAC5B,MAAM0L,EAAezL,KAAK0L,oBACxB3L,EAAM4L,QAAO,IAAI9K,EAAAA,IAAQH,OAAO,QAE5BuK,EAAOQ,EAAanH,MAC1B,GAAY,MAAR2G,EAAc,OAElBjL,KAAKmK,aAEL,MAAMa,EAAQS,EAAazJ,QAC3B,GAAIgJ,EAAO,CACT,MAAMY,EACW,UAAfZ,EAAMvD,OACoB,IAAzBuD,EAAMjL,MAAMK,WACTJ,KAAK6L,WAAWhI,EAAAA,GAAY7C,GAAO,IAAMA,EAAQhB,KAAKI,UACtDL,EACW,UAAfiL,EAAMvD,KACFuD,EAAMjL,OACN,IAAIc,EAAAA,IAAQH,OAAO,CAAE,CAACsK,EAAMc,KAAMd,EAAMrK,QAC9CoL,EAAqB/L,KAAMgB,EAAOjB,GAClC,MAAMiM,EAAmC,UAAfhB,EAAMvD,KAAmB,EAAI,EACjDwE,EAAejL,EAAQjB,EAAMK,SAAW4L,EAC1CJ,GACF5L,KAAK2B,SAASsK,EAAe,EAAG,MAGlC,MAAM/H,GAAUtD,EAAAA,EAAAA,IAAcZ,KAAKqC,KAAKrB,GAAO,IACzC+C,EAAamI,EAAAA,GAAaC,KAAKjI,EAAS8G,EAAMjH,aAAe,CAAC,EACpEqI,OAAOC,KAAKtI,GAAYW,SAASvD,IAC/BnB,KAAKkB,SAAS+K,EAAe,EAAG,EAAG9K,EAAM4C,EAAW5C,GAAM,IAG5DH,EAAQiL,CACV,CAEA,IAAKK,EAASC,GAAiBvM,KAAKiC,SAASuK,KAAKxL,GAC9CyK,EAAarL,SACXkM,IACFA,EAAUA,EAAQxK,MAAMyK,GACxBA,EAAgB,GAGlBd,EAAa/G,SAAS+H,IACpB,GAAyB,UAArBA,EAAYhF,KAKdsE,EAJc/L,KAAK0M,YACjBD,EAAY1I,WACZuI,QAAWjM,GAEe,EAAGoM,EAAY1M,WACtC,CACL,MAAM4M,EAAa3M,KAAKyE,OACtBgI,EAAYX,IACZW,EAAY9L,OAEdX,KAAKsC,aAAaqK,EAAYL,QAAWjM,GACzC+L,OAAOC,KAAKI,EAAY1I,YAAYW,SAASvD,IAC3CwL,EAAWnL,OAAOL,EAAMsL,EAAY1I,WAAW5C,GAAM,GAEzD,MAIc,UAAd8J,EAAKxD,MAAoBwD,EAAKlL,MAAMK,UAItC2L,EAAqB/L,KAHNsM,EACXA,EAAQ1G,OAAO0G,EAAQlL,QAAUmL,EACjCvM,KAAKI,SAC0B6K,EAAKlL,OAG1CC,KAAKqK,WACLrK,KAAK6C,UACP,CAEA+J,SAAAA,GACE,MAAwD,SAAjD5M,KAAKiE,QAAQ4I,aAAa,kBACnC,CAEApM,IAAAA,CAAKO,GACH,MAAMiK,EAAOjL,KAAK+C,KAAK/B,GAAOsD,MAC9B,IAAK2G,EACH,MAAO,CAAC,MAAO,GAGjB,MAAOhL,EAAM2F,GAAUqF,EACvB,OAAOhL,aAAgBM,EAAAA,SAAW,CAACN,EAAM2F,GAAU,CAAC,MAAO,EAC7D,CAEAvD,IAAAA,CAAKrB,GACH,OAAIA,IAAUhB,KAAKI,SACVJ,KAAKqC,KAAKrB,EAAQ,GAGpBhB,KAAK6L,WAAWvC,EAAQtI,EACjC,CAEAa,KAAAA,GAAoE,IAA9Db,EAAKb,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,EAAGC,EAAMD,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG2M,OAAOC,UAC/B,MAAMC,EAAWA,CACf/M,EACAgN,EACAC,KAEA,IAAIrL,EAAgC,GAChCsL,EAAaD,EAajB,OAZAjN,EAAKgC,SAASmL,UACZH,EACAC,GACA,CAACjK,EAAOoK,EAAYC,KACdhE,EAAOrG,GACTpB,EAAM0L,KAAKtK,GACFA,aAAiB+B,EAAAA,gBAC1BnD,EAAQA,EAAM8J,OAAOqB,EAAS/J,EAAOoK,EAAYF,KAEnDA,GAAcG,CAAW,IAGtBzL,CAAK,EAEd,OAAOmL,EAAShN,KAAMgB,EAAOZ,EAC/B,CAOAyC,QAAAA,GAAuC,IAA9ByE,EAASnH,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,GAAI2C,EAAO3C,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,CAAC,EAC9BH,KAAK8J,QACT7I,MAAM4B,SAASyE,EAAWxE,GACtBwE,EAAUlH,OAAS,GACrBJ,KAAK6J,QAAQU,KAAKC,EAAAA,EAAQC,OAAO+C,gBAAiBlG,EAAWxE,GAEjE,CAEAC,IAAAA,CAAK/B,GACH,OAAOC,MAAM8B,KAAK/B,GAAOoK,MAAM,EACjC,CAEA1I,MAAAA,GACE,CAKF2E,MAAAA,CAAOC,GACL,GAAItH,KAAK8J,MAIP,YAHI7B,MAAMmC,QAAQ9C,KAChBtH,KAAK8J,MAAQ9J,KAAK8J,MAAM6B,OAAOrE,KAInC,IAAImG,EAAwBjD,EAAAA,EAAQkD,QAAQC,KACnB,iBAAdrG,IACTmG,EAASnG,GAENW,MAAMmC,QAAQ9C,KACjBA,EAAYtH,KAAK4N,SAASC,gBAE5BvG,EAAYA,EAAUpH,QAAO4N,IAAgB,IAAf,OAAElL,GAAQkL,EACtC,MAAM7N,EAAOD,KAAKwM,KAAK5J,GAAQ,GAC/B,OAAO3C,IAASsJ,EAAYtJ,EAAK,KAErBG,OAAS,GACrBJ,KAAK6J,QAAQU,KAAKC,EAAAA,EAAQC,OAAOsD,qBAAsBN,EAAQnG,GAEjErG,MAAMoG,OAAOC,EAAUqE,OAAO,KAC1BrE,EAAUlH,OAAS,GACrBJ,KAAK6J,QAAQU,KAAKC,EAAAA,EAAQC,OAAOuD,cAAeP,EAAQnG,EAE5D,CAEA2G,aAAAA,CAAcjN,EAAe8K,EAAahB,GAGxC,MAAO7K,GAAQD,KAAK6L,YAAYqC,GAAYA,aAAarK,EAAAA,IAAY7C,GACjEf,GAAQA,EAAK0E,QAAQrB,WAAawI,GAAOvC,EAAYtJ,IACvDA,EAAKuJ,cAAcsB,EAEvB,CAEUZ,eAAAA,CAAgBiE,GACxBA,EAAMC,gBACR,CAEQ1C,mBAAAA,CAAoB3L,GAC1B,MAAM0L,EAA8B,GAEpC,IAAI4C,EAAoB,IAAIxN,EAAAA,GAmD5B,OAlDAd,EAAM2E,SAAS4J,IACb,MAAM5N,EAAS4N,GAAI5N,OACnB,GAAKA,EACL,GAAsB,iBAAXA,EAAqB,CAC9B,MAAM6N,EAAW7N,EAAOoB,MAAM,MAC9ByM,EAASnD,MAAM,GAAI,GAAG1G,SAAS3C,IAC7BsM,EAAkB3N,OAAOqB,EAAMuM,EAAGvK,YAClC0H,EAAa8B,KAAK,CAChB9F,KAAM,QACN1H,MAAOsO,EACPtK,WAAYuK,EAAGvK,YAAc,CAAC,IAEhCsK,EAAoB,IAAIxN,EAAAA,EAAO,IAEjC,MAAMoK,EAAOsD,EAASA,EAASnO,OAAS,GACpC6K,GACFoD,EAAkB3N,OAAOuK,EAAMqD,EAAGvK,WAEtC,KAAO,CACL,MAAM+H,EAAMM,OAAOC,KAAK3L,GAAQ,GAChC,IAAKoL,EAAK,OACN9L,KAAKqB,MAAMyK,EAAKxK,EAAAA,MAAMkN,QACxBH,EAAkBd,KAAKe,IAEnBD,EAAkBjO,UACpBqL,EAAa8B,KAAK,CAChB9F,KAAM,QACN1H,MAAOsO,EACPtK,WAAY,CAAC,IAGjBsK,EAAoB,IAAIxN,EAAAA,GACxB4K,EAAa8B,KAAK,CAChB9F,KAAM,aACNqE,MACAnL,MAAOD,EAAOoL,GACd/H,WAAYuK,EAAGvK,YAAc,CAAC,IAGpC,KAGEsK,EAAkBjO,UACpBqL,EAAa8B,KAAK,CAChB9F,KAAM,QACN1H,MAAOsO,EACPtK,WAAY,CAAC,IAIV0H,CACT,CAEQiB,WAAAA,CAAY3I,EAA0BuI,GAC5C,IAAIhJ,EACJ,MAAMY,EAAwB,CAAC,EAE/BkI,OAAOqC,QAAQ1K,GAAYW,SAAQgK,IAAkB,IAAhB5C,EAAKnL,GAAM+N,EACmB,MAA7C1O,KAAKqB,MAAMyK,EAAKxK,EAAAA,MAAMC,MAAQD,EAAAA,MAAM0H,MAEtD1F,EAAWwI,EAEX5H,EAAQ4H,GAAOnL,CACjB,IAGF,MAAMwB,EAAQnC,KAAKyE,OACjBnB,GAAYtD,KAAK2E,QAAQnB,aAAaF,SACtCA,EAAWS,EAAWT,QAAYjD,GAGpCL,KAAKsC,aAAaH,EAAOmK,QAAWjM,GAEpC,MAAMD,EAAS+B,EAAM/B,SAKrB,OAJAgM,OAAOqC,QAAQvK,GAASQ,SAAQiK,IAAkB,IAAhB7C,EAAKnL,GAAMgO,EAC3CxM,EAAMjB,SAAS,EAAGd,EAAQ0L,EAAKnL,EAAM,IAGhCwB,CACT,EAGF,SAAS4J,EACP3I,EACApC,EACA4N,GAEAA,EAAepO,QAAO,CAACQ,EAAOsN,KAC5B,MAAMlO,EAASyO,EAAAA,GAAGzO,OAAOkO,GACzB,IAAIvK,EAAauK,EAAGvK,YAAc,CAAC,EACnC,GAAiB,MAAbuK,EAAG5N,OACL,GAAyB,iBAAd4N,EAAG5N,OAAqB,CACjC,MAAMqB,EAAOuM,EAAG5N,OAChB0C,EAAOzB,SAASX,EAAOe,GACvB,MAAOtB,GAAQ2C,EAAOyI,WAAWtL,EAAAA,SAAUS,GACrCkD,GAAUtD,EAAAA,EAAAA,IAAcH,GAC9BsD,EAAamI,EAAAA,GAAaC,KAAKjI,EAASH,IAAe,CAAC,CAC1D,MAAO,GAAyB,iBAAduK,EAAG5N,OAAqB,CACxC,MAAMoL,EAAMM,OAAOC,KAAKiC,EAAG5N,QAAQ,GACnC,GAAW,MAAPoL,EAAa,OAAO9K,EAGxB,GAFAoC,EAAOzB,SAASX,EAAO8K,EAAKwC,EAAG5N,OAAOoL,IAC0B,MAA1C1I,EAAOhC,OAAOC,MAAMyK,EAAKxK,EAAAA,MAAMkN,QAClC,CACjB,MAAO/N,GAAQ2C,EAAOyI,WAAWtL,EAAAA,SAAUS,GACrCkD,GAAUtD,EAAAA,EAAAA,IAAcH,GAC9BsD,EAAamI,EAAAA,GAAaC,KAAKjI,EAASH,IAAe,CAAC,CAC1D,CACF,CAKF,OAHAqI,OAAOC,KAAKtI,GAAYW,SAASoH,IAC/B1I,EAAOlC,SAASF,EAAOZ,EAAQ0L,EAAK/H,EAAW+H,GAAK,IAE/C9K,EAAQZ,CAAM,GACpBY,EACL,CAEA,mCClaA,MAAM8N,UAAgBC,EAAAA,EACpB7J,gBAAkC,CAChC8J,MAAO,IACPC,SAAU,IACVC,UAAU,GAGZC,aAAe,EACfC,cAAe,EACfC,MAAe,CAAEC,KAAM,GAAIC,KAAM,IACjCC,aAA6B,KAE7BrK,WAAAA,CAAYsK,EAAcC,GACxBzO,MAAMwO,EAAOC,GACb1P,KAAKyP,MAAME,GACTC,EAAAA,GAAMnF,OAAOoF,eACb,CAACC,EAAWnP,EAAOoP,EAAUtC,KACvBqC,IAAcF,EAAAA,GAAMnF,OAAOuF,iBACzBrP,GAAS8M,IAAWmC,EAAAA,GAAMlC,QAAQuC,SACpCjQ,KAAKwP,aAAe7O,GAEbmP,IAAcF,EAAAA,GAAMnF,OAAOyF,cAC/BlQ,KAAKoP,eACHpP,KAAK0P,QAAQR,UAAYzB,IAAWmC,EAAAA,GAAMlC,QAAQC,KAGrD3N,KAAKmQ,UAAUxP,GAFfX,KAAKoQ,OAAOzP,EAAOoP,IAMvB/P,KAAKwP,aAAea,EAAerQ,KAAKwP,aAAc7O,GACxD,IAIJX,KAAKyP,MAAMa,SAASC,WAClB,CAAEzE,IAAK,IAAK0E,UAAU,GACtBxQ,KAAKsP,KAAKmB,KAAKzQ,OAEjBA,KAAKyP,MAAMa,SAASC,WAClB,CAAEzE,IAAK,CAAC,IAAK,KAAM0E,UAAU,EAAME,UAAU,GAC7C1Q,KAAKuP,KAAKkB,KAAKzQ,OAEb,OAAO2Q,KAAKC,UAAUC,WACxB7Q,KAAKyP,MAAMa,SAASC,WAClB,CAAEzE,IAAK,IAAK0E,UAAU,GACtBxQ,KAAKuP,KAAKkB,KAAKzQ,OAInBA,KAAKyP,MAAMpQ,KAAK2K,iBAAiB,eAAgBmE,IACvB,gBAApBA,EAAM2C,WACR9Q,KAAKsP,OACLnB,EAAMC,kBACuB,gBAApBD,EAAM2C,YACf9Q,KAAKuP,OACLpB,EAAMC,iBACR,GAEJ,CAEAtD,MAAAA,CAAO2C,EAAyBsD,GAC9B,GAAkC,IAA9B/Q,KAAKqP,MAAM5B,GAAQrN,OAAc,OACrC,MAAM4Q,EAAOhR,KAAKqP,MAAM5B,GAAQnJ,MAChC,IAAK0M,EAAM,OACX,MAAMC,EAAOjR,KAAKyP,MAAMyB,cAClBC,EAAeH,EAAKjR,MAAMqR,OAAOH,GACvCjR,KAAKqP,MAAM0B,GAAMxD,KAAK,CACpBxN,MAAOoR,EACPjL,MAAOmK,EAAeW,EAAK9K,MAAOiL,KAEpCnR,KAAKmP,aAAe,EACpBnP,KAAKoP,cAAe,EACpBpP,KAAKyP,MAAM4B,eAAeL,EAAKjR,MAAO6P,EAAAA,GAAMlC,QAAQC,MACpD3N,KAAKoP,cAAe,EAEpBpP,KAAKsR,iBAAiBN,EACxB,CAEAO,KAAAA,GACEvR,KAAKqP,MAAQ,CAAEC,KAAM,GAAIC,KAAM,GACjC,CAEAiC,MAAAA,GACExR,KAAKmP,aAAe,CACtB,CAEAiB,MAAAA,CAAOqB,EAAoBC,GACzB,GAA+B,IAA3BD,EAAYE,IAAIvR,OAAc,OAClCJ,KAAKqP,MAAME,KAAO,GAClB,IAAIqC,EAAYH,EAAYL,OAAOM,GAC/BG,EAAY7R,KAAKwP,aACrB,MAAMsC,EAAYC,KAAKC,MACvB,GAEEhS,KAAKmP,aAAenP,KAAK0P,QAAQV,MAAQ8C,GACzC9R,KAAKqP,MAAMC,KAAKlP,OAAS,EACzB,CACA,MAAM4Q,EAAOhR,KAAKqP,MAAMC,KAAKhL,MACzB0M,IACFY,EAAYA,EAAUK,QAAQjB,EAAKjR,OACnC8R,EAAYb,EAAK9K,MAErB,MACElG,KAAKmP,aAAe2C,EAEK,IAAvBF,EAAUxR,WACdJ,KAAKqP,MAAMC,KAAK/B,KAAK,CAAExN,MAAO6R,EAAW1L,MAAO2L,IAE5C7R,KAAKqP,MAAMC,KAAKlP,OAASJ,KAAK0P,QAAQT,UACxCjP,KAAKqP,MAAMC,KAAKtN,QAEpB,CAEAuN,IAAAA,GACEvP,KAAK8K,OAAO,OAAQ,OACtB,CAEAqF,SAAAA,CAAUpQ,GACRmS,EAAelS,KAAKqP,MAAMC,KAAMvP,GAChCmS,EAAelS,KAAKqP,MAAME,KAAMxP,EAClC,CAEAuP,IAAAA,GACEtP,KAAK8K,OAAO,OAAQ,OACtB,CAEUwG,gBAAAA,CAAiBa,GACzB,GAAIA,EAAUjM,MACZlG,KAAKyP,MAAM2C,aAAaD,EAAUjM,MAAO0J,EAAAA,GAAMlC,QAAQC,UAClD,CACL,MAAM3M,EAmCZ,SAA4BI,EAAgBrB,GAC1C,MAAMsS,EAAetS,EAAMS,QAAO,CAACJ,EAAQkO,IAClClO,GAAUkO,EAAGgE,QAAU,IAC7B,GACH,IAAIC,EAAcxS,EAAMK,SAAWiS,EAInC,OAtBF,SAA+BjR,EAAgBrB,GAC7C,MAAMyS,EAASzS,EAAM4R,IAAI5R,EAAM4R,IAAIvR,OAAS,GAC5C,OAAc,MAAVoS,IACiB,MAAjBA,EAAO9R,OACuB,iBAAlB8R,EAAO9R,QAAuB8R,EAAO9R,OAAOyK,SAAS,MAE5C,MAArBqH,EAAOzO,YACFqI,OAAOC,KAAKmG,EAAOzO,YAAYwD,MAAMkL,GACA,MAAnCrR,EAAOC,MAAMoR,EAAMnR,EAAAA,MAAMC,SAItC,CAOMmR,CAAsBtR,EAAQrB,KAChCwS,GAAe,GAEVA,CACT,CA5CoBI,CAAmB3S,KAAKyP,MAAMrO,OAAQ+Q,EAAUpS,OAC9DC,KAAKyP,MAAM2C,aAAapR,EAAO4O,EAAAA,GAAMlC,QAAQC,KAC/C,CACF,EAGF,SAASuE,EAAe7C,EAAoBtP,GAC1C,IAAI6S,EAAc7S,EAClB,IAAK,IAAI8S,EAAIxD,EAAMjP,OAAS,EAAGyS,GAAK,EAAGA,GAAK,EAAG,CAC7C,MAAMC,EAAUzD,EAAMwD,GACtBxD,EAAMwD,GAAK,CACT9S,MAAO6S,EAAYzC,UAAU2C,EAAQ/S,OAAO,GAC5CmG,MAAO4M,EAAQ5M,OAASmK,EAAeyC,EAAQ5M,MAAO0M,IAExDA,EAAcE,EAAQ/S,MAAMoQ,UAAUyC,GACN,IAA5BvD,EAAMwD,GAAG9S,MAAMK,UACjBiP,EAAM0D,OAAOF,EAAG,EAEpB,CACF,CA2BA,SAASxC,EAAenK,EAAqBnG,GAC3C,IAAKmG,EAAO,OAAOA,EACnB,MAAMa,EAAQhH,EAAMiT,kBAAkB9M,EAAMlF,OAE5C,MAAO,CAAEA,MAAO+F,EAAO3G,OADXL,EAAMiT,kBAAkB9M,EAAMlF,MAAQkF,EAAM9F,QACnB2G,EACvC,cClMA,MAAMkM,UAAiBlE,EAAAA,EAGrB5J,WAAAA,CAAYsK,EAAcC,GACxBzO,MAAMwO,EAAOC,GACbD,EAAMpQ,KAAK2K,iBAAiB,QAASC,IACnCA,EAAEmE,iBACF,IAAI8E,EAAyD,KAC7D,GAAI5N,SAAS6N,oBACXD,EAAS5N,SAAS6N,oBAAoBlJ,EAAEmJ,QAASnJ,EAAEoJ,cAE9C,GAAI/N,SAASgO,uBAAwB,CAE1C,MAAMxN,EAAWR,SAASgO,uBAAuBrJ,EAAEmJ,QAASnJ,EAAEoJ,SAC9DH,EAAS5N,SAASiO,cAClBL,EAAOM,SAAS1N,EAAS2N,WAAY3N,EAASF,QAC9CsN,EAAOQ,OAAO5N,EAAS2N,WAAY3N,EAASF,OAC9C,CAEA,MAAM+N,EAAaT,GAAUzD,EAAMrK,UAAUwO,gBAAgBV,GAC7D,GAAIS,EAAY,CACd,MAAMzN,EAAQuJ,EAAMrK,UAAUyO,kBAAkBF,GAC5C1J,EAAE6J,cAAcC,OAClB/T,KAAKgU,OAAO9N,EAAO+D,EAAE6J,aAAaC,MAEtC,IAEJ,CAEAC,MAAAA,CAAO9N,EAAc6N,GACnB,MAAME,EAAkB,GACxBhM,MAAMC,KAAK6L,GAAOrP,SAASwP,IACrBA,GAAQlU,KAAK0P,QAAQyE,WAAWC,SAASF,EAAKzM,OAChDwM,EAAQ1G,KAAK2G,EACf,IAEED,EAAQ7T,OAAS,GAEnBJ,KAAK0P,QAAQ2E,QAAQC,KAAKtU,KAAMkG,EAAO+N,EAE3C,EAGFhB,EAASsB,SAAW,CAClBJ,UAAW,CAAC,YAAa,cACzBE,OAAAA,CAAQnO,EAAc6N,GACpB,IAAK/T,KAAKyP,MAAMrO,OAAOC,MAAM,SAC3B,OAEF,MAAMmT,EAAWT,EAAMvP,KAAsB0P,GACpC,IAAIO,SAASC,IAClB,MAAMC,EAAS,IAAIC,WACnBD,EAAOE,OAAS,KACdH,EAAQC,EAAOG,OAAiB,EAElCH,EAAOI,cAAcb,EAAK,MAG9BO,QAAQO,IAAIR,GAAUS,MAAMC,IAC1B,MAAM7N,EAAS6N,EAAO1U,QAAO,CAACT,EAAcoV,IACnCpV,EAAMW,OAAO,CAAEyU,YACrB,IAAItU,EAAAA,IAAQuU,OAAOlP,EAAMlF,OAAOsR,OAAOpM,EAAM9F,SAChDJ,KAAKyP,MAAM4B,eAAehK,EAAQmD,EAAAA,EAAQkD,QAAQC,MAClD3N,KAAKyP,MAAM2C,aACTlM,EAAMlF,MAAQkU,EAAO9U,OACrBoK,EAAAA,EAAQkD,QAAQuC,OACjB,GAEL,GAGF,QC5EA,MAAMoF,EAAe,CAAC,aAAc,yBAEpC,MAAMC,UAAcvG,EAAAA,EAClB5J,WAAAA,CAAYsK,EAAcC,GACxBzO,MAAMwO,EAAOC,GAEbD,EAAMpQ,KAAK2K,iBAAiB,eAAgBmE,IAC1CnO,KAAKuV,kBAAkBpH,EAAM,IAK1B,WAAWwC,KAAKC,UAAU4E,YAC7B/F,EAAME,GAAGC,EAAAA,GAAMnF,OAAOgL,0BAA0B,KAC9CzV,KAAK0V,wBAAwB,GAGnC,CAEQC,WAAAA,CAAYzP,IAClByP,EAAAA,EAAAA,IAAY,CAAEzP,QAAOuJ,MAAOzP,KAAKyP,OACnC,CAEQmG,WAAAA,CAAY1P,GAAyB,IAAXnE,EAAI5B,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,GACvC,GAAqB,IAAjB+F,EAAM9F,OAAc,OAAO,EAE/B,GAAI2B,EAAM,CAER,MAAMmC,EAAUlE,KAAKyP,MAAMoG,UAAU3P,EAAMlF,MAAO,GAClDhB,KAAK2V,YAAYzP,GACjBlG,KAAKyP,MAAM4B,gBACT,IAAIxQ,EAAAA,IAAQuU,OAAOlP,EAAMlF,OAAON,OAAOqB,EAAMmC,GAC7C0L,EAAAA,GAAMlC,QAAQC,KAElB,MACE3N,KAAK2V,YAAYzP,GAInB,OADAlG,KAAKyP,MAAM2C,aAAalM,EAAMlF,MAAQe,EAAK3B,OAAQ,EAAGwP,EAAAA,GAAMlC,QAAQuC,SAC7D,CACT,CAEQsF,iBAAAA,CAAkBpH,GACxB,GACEnO,KAAKyP,MAAMqG,YAAYC,aACvB5H,EAAM6H,mBACLX,EAAajB,SAASjG,EAAM2C,WAE7B,OAGF,MAAMmF,EAAc9H,EAAM+H,gBACtB/H,EAAM+H,kBAAkB,GACxB,KACJ,IAAKD,IAAyC,IAA1BA,EAAYE,UAC9B,OAGF,MAAMpU,EAqBV,SAAoCoM,GAQlC,MAA0B,iBAAfA,EAAMpI,KACRoI,EAAMpI,KAEXoI,EAAM2F,cAAcsC,MAAMhC,SAAS,cAC9BjG,EAAM2F,aAAauC,QAAQ,cAE7B,IACT,CApCiBC,CAA2BnI,GACxC,GAAY,MAARpM,EACF,OAEF,MAAM4R,EAAa3T,KAAKyP,MAAMrK,UAAUwO,gBAAgBqC,GAClD/P,EAAQyN,EACV3T,KAAKyP,MAAMrK,UAAUyO,kBAAkBF,GACvC,KACAzN,GAASlG,KAAK4V,YAAY1P,EAAOnE,IACnCoM,EAAMC,gBAEV,CAEQsH,sBAAAA,GACN,MAAMxP,EAAQlG,KAAKyP,MAAM8G,eACrBrQ,GACFlG,KAAK4V,YAAY1P,EAErB,EAoBF,QClGA,MAAMsQ,EAAQ,OAAO7F,KAAKC,UAAUC,UAyBpC,MAAM4F,UAAe1H,EAAAA,EACnB2H,aAAc,EACdC,wBAA0B,EAE1BxR,WAAAA,CAAYsK,EAAcC,GACxBzO,MAAMwO,EAAOC,GAEb1P,KAAK4W,kBACL5W,KAAK6W,2BACP,CAEQD,eAAAA,GACN5W,KAAKyP,MAAMa,SAASC,WAAW,CAC7BzE,IAAK,CAAC,YAAa,cACnBlG,OAAQ,EACR8K,SAAU,KACV2D,OAAAA,CAAQnO,EAAK0D,GAAmB,IAAjB,KAAEvH,EAAI,MAAE8L,GAAOvE,EAC5B,KAAMvH,aAAgByU,EAAAA,YAAgBzU,EAAK0U,QACzC,OAAO,EAGT,MAAMC,EAAwD,QAAhDC,iBAAiB5U,EAAK4B,SAAoB,UACxD,SACG+S,GAAuB,eAAd7I,EAAMrC,MACdkL,GAAuB,cAAd7I,EAAMrC,OAKnB9L,KAAKyP,MAAM2C,aACTlM,EAAMlF,MAAQ,EACdkF,EAAM9F,QAAU+N,EAAMuC,SAAW,EAAI,GACrCd,EAAAA,GAAMlC,QAAQC,OAET,EACT,GAEJ,CAEQkJ,yBAAAA,GACN7W,KAAKyP,MAAMpQ,KAAK2K,iBAAiB,WAAYmE,KACtCA,EAAM6H,kBA3DiB7H,IAEhB,cAAdA,EAAMrC,KACQ,eAAdqC,EAAMrC,KACQ,YAAdqC,EAAMrC,KACQ,cAAdqC,EAAMrC,KACQ,SAAdqC,EAAMrC,QAKJ0K,GAAuB,MAAdrI,EAAMrC,MAAiC,IAAlBqC,EAAM+I,SAgDLC,CAAyBhJ,IACtDnO,KAAKoX,kCACP,GAEJ,CAQQA,gCAAAA,GACNpX,KAAK2W,wBAA0B5E,KAAKC,MA5EM,IA8EtChS,KAAK0W,cACT1W,KAAK0W,aAAc,EAUnBpR,SAAS0E,iBAAiB,mBARTqN,KACfrX,KAAK0W,aAAc,EAEf3E,KAAKC,OAAShS,KAAK2W,yBACrB3W,KAAKsX,uBACP,GAGqD,CACrDC,MAAM,IAEV,CAEQD,qBAAAA,GACN,MAAMlS,EAAYE,SAASiR,eAC3B,IAAKnR,EAAW,OAChB,MAAMc,EAAQd,EAAUoS,WAAW,GACnC,IAAwB,IAApBtR,EAAMiQ,WAA4C,IAAtBjQ,EAAMgB,YAAmB,OAEzD,MAAM7E,EAAOrC,KAAKyP,MAAMrO,OAAOoL,KAAKtG,EAAMuR,gBAC1C,KAAMpV,aAAgByU,EAAAA,YAAgBzU,EAAK0U,QAAQ,OAEnD,MAAMW,EAAWpS,SAASiO,cAC1BmE,EAASC,cAActV,EAAK0U,QAC5BW,EAASE,YAAYvV,EAAK0U,QAC1B3R,EAAUyS,kBACVzS,EAAU0S,SAASJ,EACrB,EAGF,QClFA9H,EAAAA,GAAMmI,SAAS,CACb,cAAenY,EAAAA,GACf,oBAAqBiE,EAAAA,GACrB,cAAepB,EAAAA,EACf,kBAAmBsC,EAAAA,EACnB,eAAgBE,EAAAA,EAChB,cAAe4C,EAAAA,EACf,eAAgBnE,EAAAA,EAChB,eAAgB+F,EAChB,aAAc7F,EAAAA,EAEd,oBAAqBoU,EAAAA,GACrB,kBAAmBlJ,EACnB,mBAAoBmJ,EAAAA,GACpB,mBAAoBhF,EACpB,gBAAiBqC,EACjB,iBAAkBmB,IAGpB,MAAe7G,EAAK,wDCtDpB,MAAMsI,EACFb,SACAvU,QACAyU,KACA,WAAApS,CAAYkS,EAAUvU,EAASyU,GAAO,GAClCvX,KAAKqX,SAAWA,EAChBrX,KAAK8C,QAAUA,EACf9C,KAAKuX,KAAOA,CAChB,EAGG,MAAMY,EACTjT,iBAAkB,EAKlBkT,QAAUhM,OAAO3H,OAAO,MACxB4T,aAAe,EAEf,GAAalK,EAAOkJ,EAAUvU,EAASyU,GACnC,GAAwB,mBAAbF,EACP,MAAM,IAAIiB,UAAU,mCAExB,MAAMC,EAAkB,IAAIL,EAAgBb,EAAUvU,GAAW9C,KAAMuX,GACjE9M,EAASzK,KAAKoY,QAAQjK,GAiB5B,OAhBIlG,MAAMmC,QAAQK,GAEdA,EAAO8C,KAAKgL,GAEP9N,EAELzK,KAAKoY,QAAQjK,GAAS,CAClB1D,EACA8N,IAKJvY,KAAKoY,QAAQjK,GAASoK,EACtBvY,KAAKqY,gBAEFrY,IACX,CAEA,UAAAwY,CAAWrK,GACqB,KAAtBnO,KAAKqY,aACPrY,KAAKoY,QAAUhM,OAAO3H,OAAO,aAGtBzE,KAAKoY,QAAQjK,EAE5B,CAEA,UAAAsK,GACI,OAA0B,IAAtBzY,KAAKqY,aACE,GAMJK,QAAQC,QAAQ3Y,KAAKoY,QAChC,CAEA,SAAAQ,CAAUzK,GACN,MAAM0K,EAAW7Y,KAAKoY,QAAQjK,GAC9B,OAAK0K,EAGI5Q,MAAMmC,QAAQyO,GAEZA,EAASrU,KAAK6P,GAAYA,EAAQgD,WAIlC,CACHwB,EAASxB,UATN,EAYf,CAEA,aAAAyB,CAAc3K,GACV,MAAMyK,EAAY5Y,KAAKoY,QAAQjK,GAC/B,OAAKyK,EAGI3Q,MAAMmC,QAAQwO,GAEZA,EAAUxY,OAIV,EARA,CAUf,CAEA,IAAAmK,CAAK4D,KAAU4K,GACX,MAAMH,EAAY5Y,KAAKoY,QAAQjK,GAC/B,QAAKyK,IAGD3Q,MAAMmC,QAAQwO,GAGWA,EAAUxN,MAAM,GACxB1G,SAAS2S,IAClBA,EAASE,MACTvX,KAAKgZ,eAAe7K,EAAOkJ,EAASA,cAAUhX,GAAW,GAE7DgX,EAASA,SAAS/C,KAAK+C,EAASvU,WAAYiW,EAAK,KAKjDH,EAAUrB,MACVvX,KAAKgZ,eAAe7K,EAAOyK,EAAUvB,cAAUhX,GAAW,GAE9DuY,EAAUvB,SAAS/C,KAAKsE,EAAU9V,WAAYiW,KAE3C,EACX,CAEA,EAAApJ,CAAGxB,EAAOkJ,EAAUvU,GAChB,OAAO9C,MAAK,EAAamO,EAAOkJ,EAAUvU,GAAS,EACvD,CAEA,IAAAyU,CAAKpJ,EAAOkJ,EAAUvU,GAClB,OAAO9C,MAAK,EAAamO,EAAOkJ,EAAUvU,GAAS,EACvD,CAEA,cAAAkW,CAAe7K,EAAOkJ,EAAUvU,EAASyU,GACrC,MAAM0B,EAAmBjZ,KAAKoY,QAAQjK,GACtC,IAAK8K,EACD,OAAOjZ,KAEN,IAAKqX,EAEN,OADArX,KAAKwY,WAAWrK,GACTnO,KAEN,GAAIiI,MAAMmC,QAAQ6O,GAAmB,CACtC,MAAMxO,EAAS,GACfwO,EAAiBvU,SAAS6T,KAClBA,EAAgBlB,WAAaA,GAC5BE,IAASgB,EAAgBhB,MACzBzU,GAAWyV,EAAgBzV,UAAYA,IACxC2H,EAAO8C,KAAKgL,EAChB,IAEA9N,EAAOrK,OACPJ,KAAKoY,QAAQjK,GAA2B,IAAlB1D,EAAOrK,OAAeqK,EAAO,GAAKA,EAGxDzK,KAAKwY,WAAWrK,EAExB,MACS8K,EAAiB5B,WAAaA,GACjCE,IAAQ0B,EAAiB1B,MACzBzU,GAAWmW,EAAiBnW,UAAYA,GAC1C9C,KAAKwY,WAAWrK,GAEpB,OAAOnO,IACX,CAEA,kBAAAkZ,CAAmB/K,GAUf,OATIA,EACInO,KAAKoY,QAAQjK,IACbnO,KAAKwY,WAAWrK,IAIpBnO,KAAKoY,QAAUhM,OAAO3H,OAAO,MAC7BzE,KAAKqY,aAAe,GAEjBrY,IACX,CAEA,GAAAmZ,CAAIhL,EAAOkJ,EAAUvU,EAASyU,GAC1B,OAAOvX,KAAKgZ,eAAe7K,EAAOkJ,EAAUvU,EAASyU,EACzD,CAEA,WAAA6B,CAAYjL,EAAOkJ,EAAUvU,GACzB,OAAO9C,KAAK2P,GAAGxB,EAAOkJ,EAAUvU,EACpC,ECrLJ,MAAMuW,GAAQC,QAAAA,GAAO,gBAEfC,EAAsB,GADb,CAAC,kBAAmB,YAAa,UAAW,SAGpD7U,SAASoL,IACdxK,SAAS0E,iBAAiB8F,GAAW,WAAa,QAAA0J,EAAArZ,UAAAC,OAAT2Y,EAAI,IAAA9Q,MAAAuR,GAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAAJV,EAAIU,GAAAtZ,UAAAsZ,GAC3CF,EAAS7U,SAASgV,IAChBA,EAAGC,aAAaZ,EAAK,GAEzB,GAAE,IAwFJ,MArFA,cAAsBZ,EACpBjT,cAAgB,CACd2K,cAAe,gBACf9B,qBAAsB,uBACtBrD,kBAAmB,oBACnBE,oBAAqB,sBACrB4C,gBAAiB,kBACjBQ,cAAe,gBACfjD,oBAAqB,sBACrBiF,iBAAkB,mBAClBE,YAAa,cACbuF,yBAA0B,2BAC1BmE,kBAAmB,oBACnBC,uBAAwB,yBACxBC,gBAAiB,mBAGnB5U,eAAiB,CACf6U,IAAK,MACL9J,OAAQ,SACRtC,KAAM,QAKRxI,WAAAA,GACElE,QACAjB,KAAKga,aAAe,CAAC,EACrBha,KAAK2P,GAAG,QAAS0J,EAAMY,MACzB,CAEAC,OAAAA,GACEX,EAAShM,KAAKvN,KAChB,CAEAma,UAAAA,GACEZ,EAASxG,OAAOwG,EAASzQ,QAAQ9I,MAAO,EAC1C,CAEAuK,IAAAA,GAAkC,QAAA6P,EAAAja,UAAAC,OAA1B2Y,EAAI,IAAA9Q,MAAAmS,GAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAAJtB,EAAIsB,GAAAla,UAAAka,GAGV,OAFAhB,EAAMiB,IAAIhG,KAAK+E,KAAUN,GAElB9X,MAAMsJ,QAAQwO,EACvB,CAEAY,SAAAA,CAAUxL,GAAkC,QAAAoM,EAAApa,UAAAC,OAAjB2Y,EAAI,IAAA9Q,MAAAsS,EAAA,EAAAA,EAAA,KAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAAJzB,EAAIyB,EAAA,GAAAra,UAAAqa,GAC7B,MAAM5X,EAASuL,EAAMsM,eAAe,IAqBnCza,KAAKga,aAAa7L,EAAM1G,OAAS,IAAI/C,SAAQkF,IAAuB,IAAtB,KAAE/D,EAAI,QAAEwO,GAASzK,GAC1DhH,IAAWiD,GArBI6U,EAAC7U,EAAYjD,KAChC,GAAIA,EAAO+X,gBAAkBrV,SAC3B,OAAOO,EAAK+U,SAAShY,GAGvB,MAAQiD,EAAK+U,SAAShY,IAAS,CAC7B,MAAMvD,EAAOuD,EAAO+X,cACpB,IAAKtb,EACH,OAAO,EAET,MAAMwb,EAAQxb,EAAoBwb,KAClC,IAAKA,EACH,OAAO,EAETjY,EAASiY,CACX,CAEA,OAAO,CAAI,EAIYH,CAAa7U,EAAMjD,KACxCyR,EAAQlG,KAAU4K,EACpB,GAEJ,CAEA+B,SAAAA,CAAUhL,EAAmBjK,EAAYwO,GAClCrU,KAAKga,aAAalK,KACrB9P,KAAKga,aAAalK,GAAa,IAEjC9P,KAAKga,aAAalK,GAAWvC,KAAK,CAAE1H,OAAMwO,WAC5C,qBC9FF,MAAM0G,EAAS,CAAC,QAAS,OAAQ,MAAO,QAExC,IAAIC,EAA4B,OAEhC,SAAS3B,EAAM4B,GACb,GAAID,GACED,EAAOjS,QAAQmS,IAAWF,EAAOjS,QAAQkS,GAAQ,SAAAxB,EAAArZ,UAAAC,OAFnB2Y,EAAI,IAAA9Q,MAAAuR,EAAA,EAAAA,EAAA,KAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAAJV,EAAIU,EAAA,GAAAtZ,UAAAsZ,GAGpCyB,QAAQD,MAAWlC,EACrB,CAEJ,CAEA,SAASoC,EACPC,GAEA,OAAOL,EAAOva,QACZ,CAAC8Y,EAAQ2B,KACP3B,EAAO2B,GAAU5B,EAAM5I,KAAKyK,QAASD,EAAQG,GACtC9B,IAET,CAAC,EAEL,CAEA6B,EAAUH,MAASK,IACjBL,EAAQK,CAAQ,EAElBhC,EAAM2B,MAAQG,EAAUH,MAExB,yBClBA,IATA,MACE9V,gBAAkB,CAAC,EAEnBC,WAAAA,CACSsK,GAEP,IADUC,EAAmBvP,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,CAAC,EAAC,KAD3BsP,MAAAA,EAAY,KACTC,QAAAA,CACT,2ICIL,MAAM4L,EAAQ,WA0Td,SAASC,EACPC,EACAC,EACArF,GAEA,GAAqB,IAAjBoF,EAAMpb,OAAc,CACtB,MAAOsb,GAAUC,EAAYvF,EAAM9R,OACnC,OAAImX,GAAc,EACR,UAASC,KAEX,UAASA,KAAUH,EAAgB,GAAIE,EAAa,EAAGrF,IACjE,CACA,OAAO,MAAEnT,EAAK,OAAE2C,EAAM,OAAExF,EAAM,OAAEwb,EAAM,KAAEnU,MAAWoU,GAAQL,GACpDM,EAAK1X,GAAauX,EAAYlU,GACrC,GAAImU,EAASH,EAEX,OADArF,EAAM7I,KAAK9F,GACPmU,IAAWH,EAAa,EAClB,IAAGK,QAAU1X,KAAa2X,EAChC9Y,EACA2C,EACAxF,KACEmb,EAAgBM,EAAMD,EAAQxF,KAE5B,IAAG0F,SAAWP,EAAgBC,EAAOC,EAAa,EAAGrF,KAE/D,MAAM4F,EAAe5F,EAAMA,EAAMhW,OAAS,GAC1C,GAAIwb,IAAWH,GAAchU,IAASuU,EACpC,MAAQ,WAAU5X,KAAa2X,EAC7B9Y,EACA2C,EACAxF,KACEmb,EAAgBM,EAAMD,EAAQxF,KAEpC,MAAOsF,GAAUC,EAAYvF,EAAM9R,OACnC,MAAQ,UAASoX,KAAUH,EAAgBC,EAAOC,EAAa,EAAGrF,IACpE,CAEA,SAAS2F,EACP9b,EACAe,EACAZ,GAEQ,IADR6b,EAAM9b,UAAAC,OAAA,QAAAC,IAAAF,UAAA,IAAAA,UAAA,GAEN,GAAI,SAAUF,GAA6B,mBAAdA,EAAKic,KAChC,OAAOjc,EAAKic,KAAKlb,EAAOZ,GAE1B,GAAIH,aAAgB2D,EAAAA,EAGlB,OAFoBuF,EAAAA,EAAAA,GAAWlJ,EAAKU,QAAQyK,MAAMpK,EAAOA,EAAQZ,IAE9C+b,WACjB,QACCC,GAAU,SAASC,OAAOD,EAAMhc,OAAS,GAAK,MAGnD,GAAIH,aAAgB6W,EAAAA,WAAY,CAE9B,GAA8B,mBAA1B7W,EAAK0E,QAAQrB,SAA+B,CAC9C,MAAMkY,EAAe,GAcrB,OAbAvb,EAAKgC,SAASmL,UAAUpM,EAAOZ,GAAQ,CAAC6C,EAAO2C,EAAQ0H,KACrD,MAAMpJ,EACJ,YAAajB,GAAkC,mBAAlBA,EAAMiB,QAC/BjB,EAAMiB,UACN,CAAC,EACPsX,EAAMjO,KAAK,CACTtK,QACA2C,SACAxF,OAAQkN,EACRsO,OAAQ1X,EAAQ0X,QAAU,EAC1BnU,KAAMvD,EAAQoY,MACd,IAEGf,EAAgBC,GAAQ,EAAG,GACpC,CACA,MAAMe,EAAkB,GAIxB,GAHAtc,EAAKgC,SAASmL,UAAUpM,EAAOZ,GAAQ,CAAC6C,EAAO2C,EAAQ0H,KACrDiP,EAAMhP,KAAKwO,EAAY9Y,EAAO2C,EAAQ0H,GAAa,IAEjD2O,GAAoC,SAA1Bhc,EAAK0E,QAAQrB,SACzB,OAAOiZ,EAAM5V,KAAK,IAEpB,MAAM,UAAE6V,EAAS,UAAEC,GAAcxc,EAAKgE,SAC/B8C,EAAOC,GAAOwV,EAAU1a,MAAO,IAAG2a,MAEzC,MAAc,WAAV1V,EACM,0CAAyCwV,EAAM5V,KAAK,OAAOK,IAE7D,GAAED,KAASwV,EAAM5V,KAAK,OAAOK,GACvC,CACA,OAAO/G,EAAKgE,mBAAmByY,QAAUzc,EAAKgE,QAAQuY,UAAY,EACpE,CAEA,SAASG,EACPzY,EACA0Y,GAEA,OAAOxQ,OAAOC,KAAKuQ,GAAUpc,QAC3B,CAACqc,EAAQ1b,KACP,GAAqB,MAAjB+C,EAAQ/C,GAAe,OAAO0b,EAClC,MAAMC,EAAgBF,EAASzb,GAa/B,OAZI2b,IAAkB5Y,EAAQ/C,GAC5B0b,EAAO1b,GAAQ2b,EACN7U,MAAMmC,QAAQ0S,GACnBA,EAAchU,QAAQ5E,EAAQ/C,IAAS,EACzC0b,EAAO1b,GAAQ2b,EAAcnR,OAAO,CAACzH,EAAQ/C,KAG7C0b,EAAO1b,GAAQ2b,EAGjBD,EAAO1b,GAAQ,CAAC2b,EAAe5Y,EAAQ/C,IAElC0b,CAAM,GAEf,CAAC,EAEL,CAEA,SAASlB,EAAYlU,GACnB,MAAMqU,EAAe,YAATrU,EAAqB,KAAO,KACxC,OAAQA,GACN,IAAK,UACH,MAAO,CAACqU,EAAK,wBACf,IAAK,YACH,MAAO,CAACA,EAAK,0BACf,QACE,MAAO,CAACA,EAAK,IAEnB,CAEA,SAASiB,EAAehd,GACtB,OAAOA,EAAMS,QAAO,CAACwc,EAAiB1O,KACpC,GAAyB,iBAAdA,EAAG5N,OAAqB,CACjC,MAAMqB,EAAOuM,EAAG5N,OAAO0I,QAAQ,QAAS,MAAMA,QAAQ,MAAO,MAC7D,OAAO4T,EAAgBtc,OAAOqB,EAAMuM,EAAGvK,WACzC,CACA,OAAOiZ,EAAgBzP,KAAKe,EAAG,GAC9B,IAAIzN,EAAAA,GACT,CAEA,SAASoc,EAAUrT,EAA2BsT,GAAgB,IAA1C,MAAElc,EAAK,OAAEZ,GAAewJ,EAC1C,OAAO,IAAIuT,EAAAA,EAAMnc,EAAQkc,EAAQ9c,EACnC,CAmBA,MAndA,MAIE+E,WAAAA,CAAY/D,GACVpB,KAAKoB,OAASA,EACdpB,KAAKD,MAAQC,KAAKod,UACpB,CAEAC,UAAAA,CAAWtd,GACTC,KAAKoB,OAAOiG,SACZ,IAAIiW,EAAetd,KAAKoB,OAAOhB,SAC/BJ,KAAKoB,OAAO+I,aACZ,MAAM6S,EAAkBD,EAAehd,GACjCwd,EAAc,IAAI1c,EAAAA,GAyFxB,OA2VJ,SAAsB8Q,GACpB,MAAM7P,EAAc,GAapB,OAZA6P,EAAIjN,SAAS4J,IACc,iBAAdA,EAAG5N,OACE4N,EAAG5N,OAAOoB,MAAM,MACxB4C,SAAQ,CAACrC,EAAMrB,KACfA,GAAOc,EAAMyL,KAAK,CAAE7M,OAAQ,KAAMqD,WAAYuK,EAAGvK,aACjD1B,GAAMP,EAAMyL,KAAK,CAAE7M,OAAQ2B,EAAM0B,WAAYuK,EAAGvK,YAAa,IAGnEjC,EAAMyL,KAAKe,EACb,IAGKxM,CACT,CAlc0B0b,CAAaR,EAAgBrL,IAAIvG,SACzC5K,QAAO,CAACQ,EAAOsN,KAC3B,MAAMlO,EAASyO,EAAAA,GAAGzO,OAAOkO,GACzB,IAAIvK,EAAauK,EAAGvK,YAAc,CAAC,EAC/B0Z,GAA6B,EAC7BC,GAA4B,EAChC,GAAiB,MAAbpP,EAAG5N,OAAgB,CAErB,GADA6c,EAAYnI,OAAOhV,GACM,iBAAdkO,EAAG5N,OAAqB,CACjC,MAAMqB,EAAOuM,EAAG5N,OAChBgd,GACG3b,EAAKoJ,SAAS,QACdmS,GAAgBtc,KACbhB,KAAKoB,OAAOyK,WAAWhI,EAAAA,GAAY7C,GAAO,IAChDhB,KAAKoB,OAAOO,SAASX,EAAOe,GAC5B,MAAOM,EAAMuD,GAAU5F,KAAKoB,OAAOiB,KAAKrB,GACxC,IAAIkD,EAAUkI,OAAOuR,OAAO,CAAC,GAAG/c,EAAAA,EAAAA,IAAcyB,IAC9C,GAAIA,aAAgBzC,EAAAA,GAAO,CACzB,MAAOa,GAAQ4B,EAAKwJ,WAAWtL,EAAAA,SAAUqF,GACrCnF,IACFyD,EAAUkI,OAAOuR,OAAOzZ,GAAStD,EAAAA,EAAAA,IAAcH,IAEnD,CACAsD,EAAamI,EAAAA,GAAaC,KAAKjI,EAASH,IAAe,CAAC,CAC1D,MAAO,GAAyB,iBAAduK,EAAG5N,OAAqB,CACxC,MAAMoL,EAAMM,OAAOC,KAAKiC,EAAG5N,QAAQ,GACnC,GAAW,MAAPoL,EAAa,OAAO9K,EACxB,MAAM4c,EAAwD,MAAxC5d,KAAKoB,OAAOC,MAAMyK,EAAKxK,EAAAA,MAAMkN,QACnD,GAAIoP,GAEAN,GAAgBtc,GACdhB,KAAKoB,OAAOyK,WAAWhI,EAAAA,GAAY7C,GAAO,MAE5C0c,GAA4B,QAEzB,GAAI1c,EAAQ,EAAG,CACpB,MAAOP,EAAMmF,GAAU5F,KAAKoB,OAAOyK,WAAWtL,EAAAA,SAAUS,EAAQ,GAC5DP,aAAgBmD,EAAAA,EAEG,OADRnD,EAAKE,QACTiF,KACP6X,GAA6B,GAG/Bhd,aAAgBkD,EAAAA,WAChBlD,EAAKkE,QAAQC,QAAUtD,EAAAA,MAAMgK,cAE7BmS,GAA6B,EAEjC,CAGA,GAFAzd,KAAKoB,OAAOO,SAASX,EAAO8K,EAAKwC,EAAG5N,OAAOoL,IAEvC8R,EAAe,CACjB,MAAOnd,GAAQT,KAAKoB,OAAOyK,WAAWtL,EAAAA,SAAUS,GAChD,GAAIP,EAAM,CACR,MAAMyD,EAAUkI,OAAOuR,OAAO,CAAC,GAAG/c,EAAAA,EAAAA,IAAcH,IAChDsD,EAAamI,EAAAA,GAAaC,KAAKjI,EAASH,IAAe,CAAC,CAC1D,CACF,CACF,CACAuZ,GAAgBld,CAClB,MAGE,GAFAmd,EAAYhQ,KAAKe,GAEC,OAAdA,EAAG8G,QAAwC,iBAAd9G,EAAG8G,OAAqB,CACvD,MAAMtJ,EAAMM,OAAOC,KAAKiC,EAAG8G,QAAQ,GACnC,GAAW,MAAPtJ,EAAa,OAAO9K,EACxBhB,KAAKoB,OAAO6M,cAAcjN,EAAO8K,EAAKwC,EAAG8G,OAAOtJ,GAClD,CAEFM,OAAOC,KAAKtI,GAAYW,SAASvD,IAC/BnB,KAAKoB,OAAOF,SAASF,EAAOZ,EAAQe,EAAM4C,EAAW5C,GAAM,IAE7D,MAAM0c,EAAkBJ,EAA6B,EAAI,EACnDK,EAAcJ,EAA4B,EAAI,EAIpD,OAHAJ,GAAgBO,EAAkBC,EAClCP,EAAYnI,OAAOyI,GACnBN,EAAYjL,OAAOwL,GACZ9c,EAAQZ,EAASyd,EAAkBC,CAAW,GACpD,GACHP,EAAY/c,QAAO,CAACQ,EAAOsN,IACA,iBAAdA,EAAGgE,QACZtS,KAAKoB,OAAOL,SAASC,EAAOsN,EAAGgE,QACxBtR,GAEFA,EAAQ6N,EAAAA,GAAGzO,OAAOkO,IACxB,GACHtO,KAAKoB,OAAOiJ,WACZrK,KAAKoB,OAAOyB,WACL7C,KAAKqH,OAAO2V,EACrB,CAEAe,UAAAA,CAAW/c,EAAeZ,GAExB,OADAJ,KAAKoB,OAAOL,SAASC,EAAOZ,GACrBJ,KAAKqH,QAAO,IAAIxG,EAAAA,IAAQuU,OAAOpU,GAAOsR,OAAOlS,GACtD,CAEA4d,UAAAA,CACEhd,EACAZ,GAEO,IADP8D,EAAgC/D,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,CAAC,EAEpCH,KAAKoB,OAAOiG,SACZ+E,OAAOC,KAAKnI,GAASQ,SAASlD,IAC5BxB,KAAKoB,OAAOS,MAAMb,EAAOS,KAAKwc,IAAI7d,EAAQ,IAAIsE,SAASrC,IACrDA,EAAKb,OAAOA,EAAQ0C,EAAQ1C,GAAQ,GACpC,IAEJxB,KAAKoB,OAAOyB,WACZ,MAAM9C,GAAQ,IAAIc,EAAAA,IAAQuU,OAAOpU,GAAOoU,OAAOhV,GAAQ8d,EAAAA,EAAAA,GAAUha,IACjE,OAAOlE,KAAKqH,OAAOtH,EACrB,CAEAoe,UAAAA,CACEnd,EACAZ,GAEO,IADP8D,EAAgC/D,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,CAAC,EAEpCiM,OAAOC,KAAKnI,GAASQ,SAASlD,IAC5BxB,KAAKoB,OAAOF,SAASF,EAAOZ,EAAQoB,EAAQ0C,EAAQ1C,GAAQ,IAE9D,MAAMzB,GAAQ,IAAIc,EAAAA,IAAQuU,OAAOpU,GAAOoU,OAAOhV,GAAQ8d,EAAAA,EAAAA,GAAUha,IACjE,OAAOlE,KAAKqH,OAAOtH,EACrB,CAEAmR,WAAAA,CAAYlQ,EAAeZ,GACzB,OAAOJ,KAAKD,MAAMqL,MAAMpK,EAAOA,EAAQZ,EACzC,CAEAgd,QAAAA,GACE,OAAOpd,KAAKoB,OAAOS,QAAQrB,QAAO,CAACT,EAAOsC,IACjCtC,EAAM4L,OAAOtJ,EAAKtC,UACxB,IAAIc,EAAAA,GACT,CAEAgV,SAAAA,CAAU7U,GAAoD,IAArCZ,EAAMD,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,EAC5B0B,EAAgC,GAChCuc,EAAqB,GACV,IAAXhe,EACFJ,KAAKoB,OAAO2B,KAAK/B,GAAO0D,SAAS3B,IAC/B,MAAO9C,GAAQ8C,EACX9C,aAAgBL,EAAAA,GAClBiC,EAAM0L,KAAKtN,GACFA,aAAgBM,EAAAA,UACzB6d,EAAO7Q,KAAKtN,EACd,KAGF4B,EAAQ7B,KAAKoB,OAAOS,MAAMb,EAAOZ,GACjCge,EAASpe,KAAKoB,OAAOd,YAAYC,EAAAA,SAAUS,EAAOZ,IAEpD,MAAOie,EAAaC,GAAe,CAACzc,EAAOuc,GAAQ5Z,KAAK+Z,IACtD,MAAMte,EAAOse,EAAMvc,QACnB,GAAY,MAAR/B,EAAc,MAAO,CAAC,EAC1B,IAAIiE,GAAUtD,EAAAA,EAAAA,IAAcX,GAC5B,KAAOmM,OAAOC,KAAKnI,GAAS9D,OAAS,GAAG,CACtC,MAAMH,EAAOse,EAAMvc,QACnB,GAAY,MAAR/B,EAAc,OAAOiE,EACzBA,EAAUyY,GAAe/b,EAAAA,EAAAA,IAAcX,GAAOiE,EAChD,CACA,OAAOA,CAAO,IAEhB,MAAO,IAAKma,KAAgBC,EAC9B,CAEAE,OAAAA,CAAQxd,EAAeZ,GACrB,MAAOiC,EAAMoc,GAAcze,KAAKoB,OAAOiB,KAAKrB,GAC5C,GAAIqB,EAAM,CACR,MAAMqc,EAAarc,EAAKjC,SAExB,OADqBiC,EAAKjC,UAAYqe,EAAare,IACd,IAAfqe,GAAoBre,IAAWse,GAC5C3C,EAAY1Z,EAAMoc,EAAYre,GAAQ,GAExC2b,EAAY/b,KAAKoB,OAAQJ,EAAOZ,GAAQ,EACjD,CACA,MAAO,EACT,CAEAue,OAAAA,CAAQ3d,EAAeZ,GACrB,OAAOJ,KAAKkR,YAAYlQ,EAAOZ,GAC5BF,QAAQoO,GAA4B,iBAAdA,EAAG5N,SACzB8D,KAAK8J,GAAOA,EAAG5N,SACfiG,KAAK,GACV,CAEA6E,cAAAA,CAAexK,EAAe4d,GAC5B,MAAM5B,EAAkBD,EAAe6B,GACjC9T,GAAS,IAAIjK,EAAAA,IAAQuU,OAAOpU,GAAO2K,OAAOqR,GAEhD,OADAhd,KAAKoB,OAAOoK,eAAexK,EAAOgc,GAC3Bhd,KAAKqH,OAAOyD,EACrB,CAEA+T,WAAAA,CAAY7d,EAAeqK,EAAe1K,GAExC,OADAX,KAAKoB,OAAOO,SAASX,EAAOqK,EAAO1K,GAC5BX,KAAKqH,QAAO,IAAIxG,EAAAA,IAAQuU,OAAOpU,GAAON,OAAO,CAAE,CAAC2K,GAAQ1K,IACjE,CAEAme,UAAAA,CACE9d,EACAe,GAEO,IADPmC,EAAgC/D,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,CAAC,EAOpC,OALA4B,EAAOA,EAAKqH,QAAQ,QAAS,MAAMA,QAAQ,MAAO,MAClDpJ,KAAKoB,OAAOO,SAASX,EAAOe,GAC5BqK,OAAOC,KAAKnI,GAASQ,SAASlD,IAC5BxB,KAAKoB,OAAOF,SAASF,EAAOe,EAAK3B,OAAQoB,EAAQ0C,EAAQ1C,GAAQ,IAE5DxB,KAAKqH,QACV,IAAIxG,EAAAA,IAAQuU,OAAOpU,GAAON,OAAOqB,GAAMmc,EAAAA,EAAAA,GAAUha,IAErD,CAEA6a,OAAAA,GACE,GAAoC,IAAhC/e,KAAKoB,OAAOa,SAAS7B,OAAc,OAAO,EAC9C,GAAIJ,KAAKoB,OAAOa,SAAS7B,OAAS,EAAG,OAAO,EAC5C,MAAMH,EAAOD,KAAKoB,OAAOa,SAASO,KAClC,GAAIvC,GAAM0E,QAAQrB,WAAa1D,EAAAA,GAAM0D,SAAU,OAAO,EACtD,MAAMnB,EAAQlC,EACd,QAAIkC,EAAMF,SAAS7B,OAAS,IACrB+B,EAAMF,SAASO,gBAAgBC,EAAAA,CACxC,CAEAuc,YAAAA,CAAahe,EAAeZ,GAC1B,MAAM2B,EAAO/B,KAAK2e,QAAQ3d,EAAOZ,IAC1BiC,EAAMuD,GAAU5F,KAAKoB,OAAOiB,KAAKrB,EAAQZ,GAChD,IAAI6e,EAAe,EACfC,EAAS,IAAIre,EAAAA,GACL,MAARwB,IACF4c,EAAe5c,EAAKjC,SAAWwF,EAC/BsZ,EAAS7c,EACNtC,QACAqL,MAAMxF,EAAQA,EAASqZ,EAAe,GACtCve,OAAO,OAEZ,MACMyL,EADWnM,KAAKkR,YAAYlQ,EAAOZ,EAAS6e,GAC5B9S,MAAK,IAAItL,EAAAA,IAAQH,OAAOqB,GAAM4J,OAAOuT,IACrDnf,GAAQ,IAAIc,EAAAA,IAAQuU,OAAOpU,GAAO2K,OAAOQ,GAC/C,OAAOnM,KAAKqd,WAAWtd,EACzB,CAEAsH,MAAAA,CACEyD,GAGO,IAFPxD,EAA2BnH,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,GAC9Bgf,EAAwChf,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,QAAGE,EAE3C,MAAMqR,EAAW1R,KAAKD,MACtB,GACuB,IAArBuH,EAAUlH,QACY,kBAAtBkH,EAAU,GAAGG,MAEbH,EAAU,GAAG1E,OAAOmD,KAAKqW,MAAMd,IAC/Btb,KAAKoB,OAAOoL,KAAKlF,EAAU,GAAG1E,QAC9B,CAEA,MAAMwc,EAAWpf,KAAKoB,OAAOoL,KAAKlF,EAAU,GAAG1E,QACzCsB,GAAUtD,EAAAA,EAAAA,IAAcwe,GACxBpe,EAAQoe,EAASxZ,OAAO5F,KAAKoB,QAE7B2O,EAAWzI,EAAU,GAAGyI,SAAS3G,QAAQiW,EAAAA,EAAW7Z,SAAU,IAC9D8Z,GAAU,IAAIze,EAAAA,IAAQH,OAAOqP,GAE7BrJ,GAAU,IAAI7F,EAAAA,IAAQH,OAAO0e,EAASze,SACtC4e,EAAwBJ,GAAiB,CAC7CK,SAAUvC,EAAWkC,EAAcK,UAAWxe,GAC9C0W,SAAUuF,EAAWkC,EAAczH,UAAW1W,IAKhD8J,GAHkB,IAAIjK,EAAAA,IACnBuU,OAAOpU,GACP2K,OAAO2T,EAAQnT,KAAKzF,EAAS6Y,IACb/e,QAAO,CAACT,EAAOuO,IAC5BA,EAAG5N,OACEX,EAAMW,OAAO4N,EAAG5N,OAAQwD,GAE1BnE,EAAMwN,KAAKe,IACjB,IAAIzN,EAAAA,IACPb,KAAKD,MAAQ2R,EAASO,QAAQnH,EAChC,MACE9K,KAAKD,MAAQC,KAAKod,WACbtS,IAAW2U,EAAAA,EAAAA,GAAQ/N,EAASO,QAAQnH,GAAS9K,KAAKD,SACrD+K,EAAS4G,EAASvF,KAAKnM,KAAKD,MAAOof,IAGvC,OAAOrU,CACT,YC1TF,MAAmB4U,kCCqDnB,EAnDA,MACE3J,aAAc,EAEd5Q,WAAAA,CACU/D,EACAyI,GACR,KAFQzI,OAAAA,EAAc,KACdyI,QAAAA,EAER7J,KAAK2f,gBACP,CAEQA,cAAAA,GACN3f,KAAKoB,OAAO6C,QAAQ+F,iBAAiB,oBAAqBmE,IACnDnO,KAAK+V,aACR/V,KAAK0V,uBAAuBvH,EAC9B,IAGFnO,KAAKoB,OAAO6C,QAAQ+F,iBAAiB,kBAAmBmE,IAClDnO,KAAK+V,aAIP6J,gBAAe,KACb5f,KAAK6f,qBAAqB1R,EAAM,GAEpC,GAEJ,CAEQuH,sBAAAA,CAAuBvH,GAC7B,MAAMlO,EACJkO,EAAMvL,kBAAkBkd,KACpB9f,KAAKoB,OAAOoL,KAAK2B,EAAMvL,QAAQ,GAC/B,MAEF3C,GAAUA,aAAgB4H,EAAAA,IAC5B7H,KAAK6J,QAAQU,KAAKC,EAAAA,EAAQC,OAAOgL,yBAA0BtH,GAC3DnO,KAAKoB,OAAO+I,aACZnK,KAAK6J,QAAQU,KAAKC,EAAAA,EAAQC,OAAOmP,kBAAmBzL,GACpDnO,KAAK+V,aAAc,EAEvB,CAEQ8J,oBAAAA,CAAqB1R,GAC3BnO,KAAK6J,QAAQU,KAAKC,EAAAA,EAAQC,OAAOoP,uBAAwB1L,GACzDnO,KAAKoB,OAAOiJ,WACZrK,KAAK6J,QAAQU,KAAKC,EAAAA,EAAQC,OAAOqP,gBAAiB3L,GAClDnO,KAAK+V,aAAc,CACrB,YC7CF,MAGMgK,EAAkBC,IACtB,MAAMC,EAAOD,EAAQE,wBACfC,EACH,gBAAiBH,GAChBve,KAAK2e,IAAIH,EAAKI,OAAUL,EAAwBM,aAClD,EACIC,EACH,iBAAkBP,GACjBve,KAAK2e,IAAIH,EAAKO,QAAWR,EAAwBS,cACnD,EACF,MAAO,CACLC,IAAKT,EAAKS,IACVC,MAAOV,EAAKW,KAAOZ,EAAQa,YAAcV,EACzCW,OAAQb,EAAKS,IAAMV,EAAQe,aAAeR,EAC1CK,KAAMX,EAAKW,KACZ,EAGGI,EAAqBrgB,IACzB,MAAMsgB,EAASC,SAASvgB,EAAO,IAC/B,OAAOmM,OAAOqU,MAAMF,GAAU,EAAIA,CAAM,EAKpCG,EAAoBA,CACxBC,EACAC,EACAC,EACAC,EACAC,EACAC,IAEIL,EAAcE,GAAeD,EAAYE,EACpC,EAGLH,EAAcE,IACPA,EAAcF,EAAcI,GAGnCH,EAAYE,EACPF,EAAYD,EAAcG,EAAYD,EACzCF,EAAcI,EAAqBF,EACnCD,EAAYE,EAAYE,EAEvB,ECtDT,MACMC,EAAe,CAAC,QAAS,QAAS,SAAU,SAAU,SAAU,QCuBtE,MAAMtI,GAAQC,EAAAA,EAAAA,GAAO,SAEfsI,EAAiB,IAAIC,EAAAA,SAC3BA,EAAAA,WAAqBC,QAAU,QA6C/B,MAAMlS,EACJ1K,gBAAkB,CAChB6c,OAAQ,KACRC,QAAS,CACPC,WAAW,EACX3R,UAAU,EACV4R,SAAS,EACTC,UAAU,GAEZC,YAAa,GACbC,UAAU,EACV1Y,SAAUiY,EACVU,MAAO,WAETpd,cAAgBsF,EAAAA,EAAQC,OACxBvF,eAAiBsF,EAAAA,EAAQkD,QACzBxI,eAAgE,QAEhEA,eAA0C,CACxCnF,MAAOc,EAAAA,GACP0hB,UAAWV,EACX,cAAe9S,EAAAA,EACf,aAAcyT,EAAAA,GAGhB,YAAOnJ,CAAMoJ,IACG,IAAVA,IACFA,EAAQ,OAEVnJ,EAAAA,EAAO0B,MAAMyH,EACf,CAEA,WAAOjW,CAAK3G,GAA4B,IAAhB6c,EAAMviB,UAAAC,OAAA,QAAAC,IAAAF,UAAA,IAAAA,UAAA,GAC5B,OAAOwiB,EAAUC,IAAI/c,IAAS+b,EAAepV,KAAK3G,EAAM6c,EAC1D,CAOA,aAAOG,CAAO1hB,GAIZ,OAH0B,MAAtBnB,KAAK8iB,QAAQ3hB,IACfkY,EAAMY,MAAO,iBAAgB9Y,sCAExBnB,KAAK8iB,QAAQ3hB,EACtB,CAkBA,eAAO4W,GACL,GAAuB,iBAAnB5X,UAAAC,QAAA,OAAAC,EAAAF,UAAA,IAA6B,CAC/B,MAAMyC,EAAMzC,UAAAC,QAAA,OAAAC,EAAAF,UAAA,GACN4iB,KAAa5iB,UAAAC,QAAA,OAAAC,EAAAF,UAAA,IAEbgB,EAAO,aAAcyB,EAASA,EAAOogB,SAAWpgB,EAAOU,SACzC,iBAATnC,EAGTnB,KAAK+X,SAAU,WAAU5W,IAAQyB,EAAQmgB,GAEzC3W,OAAOC,KAAKzJ,GAAQ8B,SAASoH,IAC3B9L,KAAK+X,SAASjM,EAAKlJ,EAAOkJ,GAAMiX,EAAU,GAGhD,KAAO,CACL,MAAMhgB,EAAI5C,UAAAC,QAAA,OAAAC,EAAAF,UAAA,GACJyC,EAAMzC,UAAAC,QAAA,OAAAC,EAAAF,UAAA,GACN4iB,KAAa5iB,UAAAC,QAAA,OAAAC,EAAAF,UAAA,IAEO,MAAtBH,KAAK8iB,QAAQ/f,IAAkBggB,GACjC1J,EAAM4J,KAAM,eAAclgB,SAAaH,GAEzC5C,KAAK8iB,QAAQ/f,GAAQH,GAElBG,EAAKmgB,WAAW,WAAangB,EAAKmgB,WAAW,cAC9CtgB,GACkB,kBAAXA,GACa,aAApBA,EAAOU,UAEPse,EAAe7J,SAASnV,GAEK,mBAApBA,EAAOmV,UAChBnV,EAAOmV,SAAS6J,EAEpB,CACF,CAmBAzc,WAAAA,CAAYge,GAA6D,IAA5BzT,EAAqBvP,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,CAAC,EAGpE,GAFAH,KAAK0P,QAulBT,SACE0T,EACA1T,GAEA,MAAMyT,EAAYE,EAAgBD,GAClC,IAAKD,EACH,MAAM,IAAIG,MAAM,2BAGlB,MAEMhB,GADH5S,EAAQ4S,OAAS5S,EAAQ4S,QAAU1S,EAAM2E,SAAS+N,MAEjDE,EAAAA,EACA5S,EAAMiT,OAAQ,UAASnT,EAAQ4S,SACnC,IAAKA,EACH,MAAM,IAAIgB,MAAO,iBAAgB5T,EAAQ4S,+BAG3C,MAAQN,QAASuB,KAAwBC,GAAkB5T,EAAM2E,UACzDyN,QAASyB,KAAwBC,GAAkBpB,EAAM/N,SAEjE,IAAIoP,EAAoBC,EAAmBlU,EAAQsS,SAG5B,MAArB2B,GACAA,EAAkBE,SAClBF,EAAkBE,QAAQ1e,cAAgBiH,SAE1CuX,EAAoB,IACfA,EACHE,QAAS,CAAEV,UAAWQ,EAAkBE,WAI5C,MAAM7B,EAA2C,IAC5C4B,EAAmBL,MACnBK,EAAmBH,MACnBE,GAGCG,EAAS,IACVN,KACAO,EAA+BL,MAC/BK,EAA+BrU,IAGpC,IAAI/F,EAAW+F,EAAQ/F,SAWvB,OAVIA,EACE+F,EAAQxL,SACVmV,EAAM4J,KAAK,6DAGbtZ,EAAW+F,EAAQxL,QDx0BW8f,EAChC9f,EACA+f,EACA5K,KAEA,MAAM1P,EAAW,IAAIua,EAAAA,SA4BrB,OA3BAvC,EAAajd,SAASvD,IACpB,MAAMgjB,EAAWF,EAAe5iB,MAAMF,GAClCgjB,GAAUxa,EAASoO,SAASoM,EAAS,IAG3CjgB,EAAQQ,SAASvD,IACf,IAAIK,EAASyiB,EAAe5iB,MAAMF,GAC7BK,GACH6X,EAAMY,MACH,oBAAmB9Y,qEAGxB,IAAIijB,EAAa,EACjB,KAAO5iB,GAKL,GAJAmI,EAASoO,SAASvW,GAClBA,EAAS,aAAcA,EAASA,EAAO6iB,mBAAqB,KAAO,KAEnED,GAAc,EACVA,EA3BsB,IA2BgB,CACxC/K,EAAMY,MACH,0DAAyD9Y,MAE5D,KACF,CACF,IAGKwI,CAAQ,ECwyBTqa,CAA0BtU,EAAQxL,QAAS4f,EAAOna,SAAU0P,GAC5DyK,EAAOna,SAGN,IACFma,EACHna,WACAwZ,YACAb,QACAN,QAAS5V,OAAOqC,QAAQuT,GAASxhB,QAC/B,CAAC8jB,EAAmBxW,KAAoB,IAAjB3M,EAAMR,GAAMmN,EACjC,IAAKnN,EAAO,OAAO2jB,EAEnB,MAAMC,EAAc3U,EAAMiT,OAAQ,WAAU1hB,KAC5C,OAAmB,MAAfojB,GACFlL,EAAMY,MACH,eAAc9Y,6CAEVmjB,GAEF,IACFA,EAEH,CAACnjB,GAAO,IAAMojB,EAAYhQ,UAAY,CAAC,KAAO5T,GAC/C,GAEH,CAAC,GAEHohB,OAAQsB,EAAgBS,EAAO/B,QAEnC,CA1qBmByC,CAAarB,EAAWzT,GACvC1P,KAAKmjB,UAAYnjB,KAAK0P,QAAQyT,UACR,MAAlBnjB,KAAKmjB,UAEP,YADA9J,EAAMY,MAAM,0BAA2BkJ,GAGrCnjB,KAAK0P,QAAQ2J,OACfzJ,EAAMyJ,MAAMrZ,KAAK0P,QAAQ2J,OAE3B,MAAM6C,EAAOlc,KAAKmjB,UAAU1G,UAAUgI,OACtCzkB,KAAKmjB,UAAUuB,UAAUC,IAAI,gBAC7B3kB,KAAKmjB,UAAU1G,UAAY,GAC3BkG,EAAUiC,IAAI5kB,KAAKmjB,UAAWnjB,MAC9BA,KAAKX,KAAOW,KAAK6kB,aAAa,aAC9B7kB,KAAKX,KAAKqlB,UAAUC,IAAI,YACxB3kB,KAAK6J,QAAU,IAAIW,EAAAA,EACnB,MAAMsa,EAAiBjD,EAAAA,WAAqBve,SACtCoG,EAAa1J,KAAK0P,QAAQ/F,SAAStI,MAAMyjB,GAC/C,IAAKpb,KAAgB,aAAcA,GACjC,MAAM,IAAI4Z,MACP,oCAAmCwB,WAiDxC,GA9CA9kB,KAAKoB,OAAS,IAAIsI,EAAW1J,KAAK0P,QAAQ/F,SAAU3J,KAAKX,KAAM,CAC7DwK,QAAS7J,KAAK6J,UAEhB7J,KAAK+kB,OAAS,IAAIC,EAAOhlB,KAAKoB,QAC9BpB,KAAKoF,UAAY,IAAI6f,EAAAA,EAAUjlB,KAAKoB,OAAQpB,KAAK6J,SACjD7J,KAAK8V,YAAc,IAAIoP,EAAYllB,KAAKoB,OAAQpB,KAAK6J,SACrD7J,KAAKsiB,MAAQ,IAAItiB,KAAK0P,QAAQ4S,MAAMtiB,KAAMA,KAAK0P,SAC/C1P,KAAKsQ,SAAWtQ,KAAKsiB,MAAM6C,UAAU,YACrCnlB,KAAKiiB,UAAYjiB,KAAKsiB,MAAM6C,UAAU,aACtCnlB,KAAKkiB,QAAUliB,KAAKsiB,MAAM6C,UAAU,WACpCnlB,KAAKmiB,SAAWniB,KAAKsiB,MAAM6C,UAAU,YACrCnlB,KAAKsiB,MAAM6C,UAAU,SACrBnlB,KAAKsiB,MAAM6C,UAAU,UACrBnlB,KAAKsiB,MAAM8C,OACXplB,KAAK6J,QAAQ8F,GAAGnF,EAAAA,EAAQC,OAAOoF,eAAgBpI,IACzCA,IAAS+C,EAAAA,EAAQC,OAAOyF,aAC1BlQ,KAAKX,KAAKqlB,UAAUW,OAAO,WAAYrlB,KAAK+kB,OAAOhG,UACrD,IAEF/e,KAAK6J,QAAQ8F,GAAGnF,EAAAA,EAAQC,OAAOuD,eAAe,CAACP,EAAQnG,KACrD,MAAMkY,EAAWxf,KAAKoF,UAAUkgB,WACzB5N,GAAY1X,KAAKoF,UAAUmgB,WAC5BpG,EACJK,GAAY9H,EAAW,CAAE8H,WAAU9H,iBAAarX,EAClDmlB,EAAOlR,KACLtU,MACA,IAAMA,KAAK+kB,OAAO1d,OAAO,KAAMC,EAAW6X,IAC1C1R,EACD,IAEHzN,KAAK6J,QAAQ8F,GAAGnF,EAAAA,EAAQC,OAAOM,qBAAqB,CAAC9K,EAAMF,KACzD,MAAMyf,EAAWxf,KAAKoF,UAAUkgB,WACzB5N,GAAY1X,KAAKoF,UAAUmgB,WAC5BpG,EACJK,GAAY9H,EAAW,CAAE8H,WAAU9H,iBAAarX,EAClDmlB,EAAOlR,KACLtU,MACA,KACE,MAAM8K,GAAS,IAAIjK,EAAAA,IAChBuU,OAAOnV,EAAK2F,OAAO5F,OACnBoV,OAAO,CAAE,CAACnV,EAAK0E,QAAQrB,UAAWvD,IACrC,OAAOC,KAAK+kB,OAAO1d,OAAOyD,EAAQ,GAAIqU,EAAc,GAEtDvP,EAAMlC,QAAQC,KACf,IAECuO,EAAM,CACR,MAAM0C,EAAW5e,KAAKiiB,UAAUwD,QAAQ,CACtCvJ,KAAO,GAAEA,eACTna,KAAM,OAER/B,KAAK0lB,YAAY9G,EACnB,CACA5e,KAAKkiB,QAAQ3Q,QACTvR,KAAK0P,QAAQ0S,aACfpiB,KAAKX,KAAK2I,aAAa,mBAAoBhI,KAAK0P,QAAQ0S,aAEtDpiB,KAAK0P,QAAQ2S,UACfriB,KAAK2lB,UAEP3lB,KAAK4lB,oBAAqB,CAC5B,CAIAf,YAAAA,CACE1B,GAE8B,IAD9B0C,EAAoB1lB,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,KAEvB,GAAyB,iBAAdgjB,EAAwB,CACjC,MAAM2C,EAAY3C,GAClBA,EAAY7d,SAASyC,cAAc,QACzB2c,UAAUC,IAAImB,EAC1B,CAEA,OADA9lB,KAAKmjB,UAAU7gB,aAAa6gB,EAAW0C,GAChC1C,CACT,CAEA4C,IAAAA,GACE/lB,KAAKoF,UAAU4gB,SAAS,KAC1B,CAIAjI,UAAAA,CACE/c,EACAZ,EACAqN,GAIA,OADCzM,EAAOZ,EAAO,CAAGqN,GAAUwY,EAASjlB,EAAOZ,EAAQqN,GAC7C+X,EAAOlR,KACZtU,MACA,IACSA,KAAK+kB,OAAOhH,WAAW/c,EAAOZ,IAEvCqN,EACAzM,GACC,EAAIZ,EAET,CAEAulB,OAAAA,GACE3lB,KAAK+J,QAAO,EACd,CAEAmc,YAAAA,CAAgBC,GACdnmB,KAAK4lB,oBAAqB,EAC1B,MAAMjlB,EAAQwlB,IAEd,OADAnmB,KAAK4lB,oBAAqB,EACnBjlB,CACT,CAEAoJ,MAAAA,GAAuB,IAAhBmB,IAAO/K,UAAAC,OAAA,QAAAC,IAAAF,UAAA,KAAAA,UAAA,GACZH,KAAKoB,OAAO2I,OAAOmB,GACnBlL,KAAKmjB,UAAUuB,UAAUW,OAAO,eAAgBna,EAClD,CAEAkb,KAAAA,GAAiD,IAA3C1W,EAAoCvP,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,CAAC,EAC5CH,KAAKoF,UAAUghB,QACV1W,EAAQ2W,eACXrmB,KAAKsmB,yBAET,CAEA9kB,MAAAA,CACEL,EACAR,GAEO,IADP8M,EAAqBtN,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGqK,EAAAA,EAAQkD,QAAQqM,IAExC,OAAOyL,EAAOlR,KACZtU,MACA,KACE,IAAKA,KAAKumB,WAAY,CACpBvmB,KAAKX,KAAK+mB,MAAM,CAAEC,eAAe,IACjC,MAAMtN,EAAO/Y,KAAKoF,UAAUohB,cAAcxmB,KAAKoF,UAAUqhB,YACzDzmB,KAAKoF,UAAUshB,kBAAkB3N,EACnC,CACA,MAAO7S,GAASlG,KAAKoF,UAAUmgB,WAC/B,IAAIza,EAAS,IAAIjK,EAAAA,GACjB,GAAa,MAATqF,EAAe,OAAO4E,EAC1B,GAAI9K,KAAKoB,OAAOC,MAAMF,EAAM0gB,EAAAA,MAAgBtgB,OAC1CuJ,EAAS9K,KAAK+kB,OAAO/G,WAAW9X,EAAMlF,MAAOkF,EAAM9F,OAAQ,CACzD,CAACe,GAAOR,QAEL,IAAqB,IAAjBuF,EAAM9F,OAEf,OADAJ,KAAKoF,UAAU5D,OAAOL,EAAMR,GACrBmK,EAEPA,EAAS9K,KAAK+kB,OAAO5G,WAAWjY,EAAMlF,MAAOkF,EAAM9F,OAAQ,CACzD,CAACe,GAAOR,GAEZ,CAEA,OADAX,KAAKoS,aAAalM,EAAOsE,EAAAA,EAAQkD,QAAQuC,QAClCnF,CAAM,GAEf2C,EAEJ,CAeAuQ,UAAAA,CACEhd,EACAZ,EACAe,EACAR,EACA8M,GAEA,IAAIvJ,EAUJ,OARClD,EAAOZ,EAAQ8D,EAASuJ,GAAUwY,EACjCjlB,EACAZ,EAEAe,EACAR,EACA8M,GAEK+X,EAAOlR,KACZtU,MACA,IACSA,KAAK+kB,OAAO/G,WAAWhd,EAAOZ,EAAQ8D,IAE/CuJ,EACAzM,EACA,EAEJ,CAqBAmd,UAAAA,CACEnd,EACAZ,EACAe,EACAR,EACA8M,GAEA,IAAIvJ,EAUJ,OARClD,EAAOZ,EAAQ8D,EAASuJ,GAAUwY,EAEjCjlB,EACAZ,EACAe,EACAR,EACA8M,GAEK+X,EAAOlR,KACZtU,MACA,IACSA,KAAK+kB,OAAO5G,WAAWnd,EAAOZ,EAAQ8D,IAE/CuJ,EACAzM,EACA,EAEJ,CAEA2lB,SAAAA,CAAU3lB,GAAkD,IAA3BZ,EAAMD,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,EACpC4hB,EAAwB,KAM5B,GAJEA,EADmB,iBAAV/gB,EACAhB,KAAKoF,UAAUuhB,UAAU3lB,EAAOZ,GAEhCJ,KAAKoF,UAAUuhB,UAAU3lB,EAAMA,MAAOA,EAAMZ,SAElD2hB,EAAQ,OAAO,KACpB,MAAM6E,EAAkB5mB,KAAKmjB,UAAUjD,wBACvC,MAAO,CACLY,OAAQiB,EAAOjB,OAAS8F,EAAgBlG,IACxCF,OAAQuB,EAAOvB,OACfI,KAAMmB,EAAOnB,KAAOgG,EAAgBhG,KACpCD,MAAOoB,EAAOpB,MAAQiG,EAAgBhG,KACtCF,IAAKqB,EAAOrB,IAAMkG,EAAgBlG,IAClCL,MAAO0B,EAAO1B,MAElB,CAEAnP,WAAAA,GAA0D,IAA9ClQ,EAAKb,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,EAAGC,EAAMD,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGH,KAAK6mB,YAAc7lB,EAEjD,OADCA,EAAOZ,GAAU6lB,EAASjlB,EAAOZ,GAC3BJ,KAAK+kB,OAAO7T,YAAYlQ,EAAOZ,EACxC,CAMAyV,SAAAA,GAGiC,IAF/B7U,EAAqBb,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGH,KAAKuW,cAAa,GAC1CnW,EAAMD,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,EAET,MAAqB,iBAAVa,EACFhB,KAAK+kB,OAAOlP,UAAU7U,EAAOZ,GAE/BJ,KAAK+kB,OAAOlP,UAAU7U,EAAMA,MAAOA,EAAMZ,OAClD,CAEA0mB,QAAAA,CAAS7mB,GACP,OAAOA,EAAK2F,OAAO5F,KAAKoB,OAC1B,CAEAylB,SAAAA,GACE,OAAO7mB,KAAKoB,OAAOhB,QACrB,CAEA2mB,OAAAA,CAAQ/lB,GACN,OAAOhB,KAAKoB,OAAOX,KAAKO,EAC1B,CAEAgmB,OAAAA,CAAQhmB,GACN,OAAOhB,KAAKoB,OAAOiB,KAAKrB,EAC1B,CAIAgM,QAAAA,GAG0B,IAFxBhM,EAAqBb,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,EACxBC,EAAMD,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG2M,OAAOC,UAEhB,MAAqB,iBAAV/L,EACFhB,KAAKoB,OAAOS,MAAMb,EAAMA,MAAOA,EAAMZ,QAEvCJ,KAAKoB,OAAOS,MAAMb,EAAOZ,EAClC,CAEA6mB,SAAAA,CAAU9lB,GACR,OAAOnB,KAAKsiB,MAAMN,QAAQ7gB,EAC5B,CAIAoV,YAAAA,GAGE,OAHgBpW,UAAAC,OAAA,QAAAC,IAAAF,UAAA,IAAAA,UAAA,IACLH,KAAKomB,QAChBpmB,KAAKqH,SACErH,KAAKoF,UAAUmgB,WAAW,EACnC,CAIA2B,eAAAA,GAA4D,IAA5ClmB,EAAqBb,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,EAAGC,EAAeD,UAAAC,OAAA,EAAAD,UAAA,QAAAE,EAMxD,MALqB,iBAAVW,IACTZ,EAASA,GAAUJ,KAAK6mB,YAAc7lB,IAGvCA,EAAOZ,GAAU6lB,EAASjlB,EAAOZ,GAC3BJ,KAAK+kB,OAAOvG,QAAQxd,EAAOZ,EACpC,CAIAue,OAAAA,GAA4D,IAApD3d,EAAqBb,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,EAAGC,EAAeD,UAAAC,OAAA,EAAAD,UAAA,QAAAE,EAMhD,MALqB,iBAAVW,IACTZ,EAASA,GAAUJ,KAAK6mB,YAAc7lB,IAGvCA,EAAOZ,GAAU6lB,EAASjlB,EAAOZ,GAC3BJ,KAAK+kB,OAAOpG,QAAQ3d,EAAOZ,EACpC,CAEAmmB,QAAAA,GACE,OAAOvmB,KAAKoF,UAAUmhB,UACxB,CAEA1H,WAAAA,CACE7d,EACAqK,EACA1K,GAEO,IADP8M,EAAqBtN,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGyP,EAAMlC,QAAQqM,IAEtC,OAAOyL,EAAOlR,KACZtU,MACA,IACSA,KAAK+kB,OAAOlG,YAAY7d,EAAOqK,EAAO1K,IAE/C8M,EACAzM,EAEJ,CAgBA8d,UAAAA,CACE9d,EACAe,EACAZ,EACAR,EACA8M,GAEA,IAAIvJ,EAIJ,OADClD,EAAM,CAAGkD,EAASuJ,GAAUwY,EAASjlB,EAAO,EAAGG,EAAMR,EAAO8M,GACtD+X,EAAOlR,KACZtU,MACA,IACSA,KAAK+kB,OAAOjG,WAAW9d,EAAOe,EAAMmC,IAE7CuJ,EACAzM,EACAe,EAAK3B,OAET,CAEAwM,SAAAA,GACE,OAAO5M,KAAKoB,OAAOwL,WACrB,CAEAuM,GAAAA,GACE,OAAOnZ,KAAK6J,QAAQsP,OAAIhZ,UAC1B,CA6BAwP,EAAAA,GACE,OAAO3P,KAAK6J,QAAQ8F,MAAGxP,UACzB,CAEAoX,IAAAA,GACE,OAAOvX,KAAK6J,QAAQ0N,QAAKpX,UAC3B,CAEA6e,YAAAA,CAAahe,EAAeZ,EAAgBqN,GAE1C,OADCzM,EAAOZ,EAAO,CAAGqN,GAAUwY,EAASjlB,EAAOZ,EAAQqN,GAC7C+X,EAAOlR,KACZtU,MACA,IACSA,KAAK+kB,OAAO/F,aAAahe,EAAOZ,IAEzCqN,EACAzM,EAEJ,CAEAmmB,kBAAAA,CAAmBlH,GFzmBMkH,EAAC9nB,EAAmB+nB,KAC7C,MAAM9hB,EAAWjG,EAAKgoB,cAEtB,IAAIpH,EAAOmH,EAEPE,EAA0BjoB,EAC9B,KAAOioB,GAAS,CACd,MAAMC,EAA0BD,IAAYhiB,EAASkiB,KAC/CC,EAAWF,EACb,CACE7G,IAAK,EACLC,MACE+G,OAAOC,gBAAgBtH,OACvB/a,EAASsiB,gBAAgB/G,YAC3BC,OACE4G,OAAOC,gBAAgBnH,QACvBlb,EAASsiB,gBAAgB7G,aAC3BH,KAAM,GAERb,EAAeuH,GAEbO,EAAQ5Q,iBAAiBqQ,GACzBQ,EAAkB1G,EACtBnB,EAAKW,KACLX,EAAKU,MACL8G,EAAS7G,KACT6G,EAAS9G,MACTK,EAAkB6G,EAAME,mBACxB/G,EAAkB6G,EAAMG,qBAEpBC,EAAkB7G,EACtBnB,EAAKS,IACLT,EAAKa,OACL2G,EAAS/G,IACT+G,EAAS3G,OACTE,EAAkB6G,EAAMK,kBACxBlH,EAAkB6G,EAAMM,sBAE1B,GAAIL,GAAmBG,EACrB,GAAIV,EACFjiB,EAAS8iB,aAAaC,SAASP,EAAiBG,OAC3C,CACL,MAAM,WAAEK,EAAU,UAAEC,GAAcjB,EAC9BW,IACFX,EAAQiB,WAAaN,GAEnBH,IACFR,EAAQgB,YAAcR,GAExB,MAAMU,EAAelB,EAAQgB,WAAaA,EACpCG,EAAcnB,EAAQiB,UAAYA,EACxCtI,EAAO,CACLW,KAAMX,EAAKW,KAAO4H,EAClB9H,IAAKT,EAAKS,IAAM+H,EAChB9H,MAAOV,EAAKU,MAAQ6H,EACpB1H,OAAQb,EAAKa,OAAS2H,EAE1B,CAGFnB,EACEC,GAAqC,UAAnBM,EAAM/hB,SACpB,MAlHgBka,EAmHCsH,GAlHjBoB,eAAkB1I,EAAQrF,cAA6BE,MAAQ,IAmHvE,CApHwBmF,KAoHxB,EE0iBEmH,CAAmBnnB,KAAKX,KAAM4gB,EAChC,CAKA0I,cAAAA,GACEzN,QAAQ+H,KACN,0IAEFjjB,KAAKsmB,yBACP,CAMAA,uBAAAA,GACE,MAAMpgB,EAAQlG,KAAKoF,UAAUkgB,UACvBvD,EAAS7b,GAASlG,KAAKoF,UAAUuhB,UAAUzgB,EAAMlF,MAAOkF,EAAM9F,QAChE2hB,GACF/hB,KAAKmnB,mBAAmBpF,EAE5B,CAEA2D,WAAAA,CACE3lB,GAEO,IADP0N,EAAqBtN,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGqK,EAAAA,EAAQkD,QAAQqM,IAExC,OAAOyL,EAAOlR,KACZtU,MACA,KACED,EAAQ,IAAIc,EAAAA,GAAMd,GAClB,MAAMK,EAASJ,KAAK6mB,YAEd+B,EAAU5oB,KAAK+kB,OAAOhH,WAAW,EAAG3d,GACpCyoB,EAAU7oB,KAAK+kB,OAAOvZ,eAAe,EAAGzL,GAExC+oB,EAAU9oB,KAAK+kB,OAAOhH,WAAW/d,KAAK6mB,YAAc,EAAG,GAC7D,OAAO+B,EAAQ3W,QAAQ4W,GAAS5W,QAAQ6W,EAAQ,GAElDrb,EAEJ,CAKA2E,YAAAA,CACEpR,EACAZ,EACAqN,GAEa,MAATzM,EAEFhB,KAAKoF,UAAU4gB,SAAS,KAAM5lB,GAAUwP,EAAMlC,QAAQqM,OAGrD/Y,EAAOZ,EAAO,CAAGqN,GAAUwY,EAASjlB,EAAOZ,EAAQqN,GACpDzN,KAAKoF,UAAU4gB,SAAS,IAAI7I,EAAAA,EAAM1b,KAAKwc,IAAI,EAAGjd,GAAQZ,GAASqN,GAC3DA,IAAWjD,EAAAA,EAAQkD,QAAQuC,QAC7BjQ,KAAKsmB,0BAGX,CAEAyC,OAAAA,CAAQhnB,GAA2D,IAA7C0L,EAAqBtN,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGqK,EAAAA,EAAQkD,QAAQqM,IAC5D,MAAMha,GAAQ,IAAIc,EAAAA,IAAQH,OAAOqB,GACjC,OAAO/B,KAAK0lB,YAAY3lB,EAAO0N,EACjC,CAEApG,MAAAA,GAAqD,IAA9CoG,EAAqBtN,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGqK,EAAAA,EAAQkD,QAAQC,KAC7C,MAAM7C,EAAS9K,KAAKoB,OAAOiG,OAAOoG,GAGlC,OAFAzN,KAAKoF,UAAUiC,OAAOoG,GAEf3C,CACT,CAEAuG,cAAAA,CACEtR,GAEO,IADP0N,EAAqBtN,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGqK,EAAAA,EAAQkD,QAAQqM,IAExC,OAAOyL,EAAOlR,KACZtU,MACA,KACED,EAAQ,IAAIc,EAAAA,GAAMd,GACXC,KAAK+kB,OAAO1H,WAAWtd,KAEhC0N,GACA,EAEJ,EAGF,SAAS4V,EAAgB2F,GACvB,MAA2B,iBAAbA,EACV1jB,SAAS2jB,cAA2BD,GACpCA,CACN,CAEA,SAASpF,EAAmBE,GAC1B,OAAO1X,OAAOqC,QAAQqV,GAAU,CAAC,GAAGtjB,QAClC,CAAC0oB,EAAQtf,KAAA,IAAGkC,EAAKnL,GAAMiJ,EAAA,MAAM,IACxBsf,EACH,CAACpd,IAAgB,IAAVnL,EAAiB,CAAC,EAAIA,EAC9B,GACD,CAAC,EAEL,CAEA,SAASojB,EAA+BoF,GACtC,OAAO/c,OAAOgd,YACZhd,OAAOqC,QAAQ0a,GAAKjpB,QAAQmpB,QAAuBhpB,IAAbgpB,EAAM,KAEhD,CAyFA,SAAS7D,EACPW,EACA1Y,EACAzM,EACAgB,GAEA,IACGhC,KAAK4M,aACNa,IAAWjD,EAAAA,EAAQkD,QAAQC,OAC1B3N,KAAK4lB,mBAEN,OAAO,IAAI/kB,EAAAA,GAEb,IAAIqF,EAAiB,MAATlF,EAAgB,KAAOhB,KAAKuW,eACxC,MAAM7E,EAAW1R,KAAK+kB,OAAOhlB,MACvB+K,EAASqb,IAaf,GAZa,MAATjgB,KACY,IAAVlF,IACFA,EAAQkF,EAAMlF,OAEH,MAATgB,EACFkE,EAAQ+W,EAAW/W,EAAO4E,EAAQ2C,GACf,IAAVzL,IAETkE,EAAQ+W,EAAW/W,EAAOlF,EAAOgB,EAAOyL,IAE1CzN,KAAKoS,aAAalM,EAAOsE,EAAAA,EAAQkD,QAAQuC,SAEvCnF,EAAO1K,SAAW,EAAG,CACvB,MAAM2Y,EAAO,CAACvO,EAAAA,EAAQC,OAAOyF,YAAapF,EAAQ4G,EAAUjE,GAC5DzN,KAAK6J,QAAQU,KAAKC,EAAAA,EAAQC,OAAOoF,iBAAkBkJ,GAC/CtL,IAAWjD,EAAAA,EAAQkD,QAAQuC,QAC7BjQ,KAAK6J,QAAQU,QAAQwO,EAEzB,CACA,OAAOjO,CACT,CAuCA,SAASmb,EACPjlB,EACAZ,EACAe,EACAR,EACA8M,GAEA,IAAIvJ,EAAmC,CAAC,EA2CxC,MAzC2B,iBAAhBlD,EAAMA,OAA8C,iBAAjBA,EAAMZ,OAE5B,iBAAXA,GAETqN,EAAS9M,EACTA,EAAQQ,EACRA,EAAOf,EAEPA,EAASY,EAAMZ,OAEfY,EAAQA,EAAMA,QAGdZ,EAASY,EAAMZ,OAEfY,EAAQA,EAAMA,OAEW,iBAAXZ,IAEhBqN,EAAS9M,EACTA,EAAQQ,EACRA,EAAOf,EACPA,EAAS,GAGS,iBAATe,GAET+C,EAAU/C,EAEVsM,EAAS9M,GACgB,iBAATQ,IACH,MAATR,EACFuD,EAAQ/C,GAAQR,EAGhB8M,EAAStM,GAMN,CAACH,EAAOZ,EAAQ8D,EAFvBuJ,EAASA,GAAUjD,EAAAA,EAAQkD,QAAQqM,IAGrC,CASA,SAASkD,EACP/W,EACAlF,EACAsoB,EACA7b,GAEA,MAAMrN,EAAmC,iBAAnBkpB,EAA8BA,EAAiB,EACrE,GAAa,MAATpjB,EAAe,OAAO,KAC1B,IAAIa,EACAC,EAmBJ,OAjBIhG,GAA4C,mBAA5BA,EAAMgS,mBACvBjM,EAAOC,GAAO,CAACd,EAAMlF,MAAOkF,EAAMlF,MAAQkF,EAAM9F,QAAQoE,KAAK+kB,GAE5DvoB,EAAMgS,kBAAkBuW,EAAK9b,IAAWjD,EAAAA,EAAQkD,QAAQC,SAGzD5G,EAAOC,GAAO,CAACd,EAAMlF,MAAOkF,EAAMlF,MAAQkF,EAAM9F,QAAQoE,KAAK+kB,GAExDA,EAAMvoB,GAAUuoB,IAAQvoB,GAASyM,IAAWjD,EAAAA,EAAQkD,QAAQC,KACvD4b,EACLnpB,GAAU,EACLmpB,EAAMnpB,EAGRqB,KAAKwc,IAAIjd,EAAOuoB,EAAMnpB,KAG1B,IAAI+c,EAAAA,EAAMpW,EAAOC,EAAMD,EAChC,qGC3gCA,MAAMsS,GAAQC,EAAAA,EAAAA,GAAO,mBAIfkQ,EAAsBC,IAC1B,IACE,MACE,iBAAkBA,GACe,mBAA1BA,EAASlT,aAETkT,EAASlT,eAETmR,OAAOnR,cAElB,CAAE,MACA,OAAO,IACT,GAqBK,MAAM4G,EACXhY,WAAAA,CACSnE,GAEP,IADOZ,EAAMD,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,EAAC,KADVa,MAAAA,EAAa,KACbZ,OAAAA,CACN,EA0dL,SAASwa,EAASxX,EAAcyI,GAC9B,IAEEA,EAAWxF,UACb,CAAE,MAAO4D,GACP,OAAO,CACT,CACA,OAAO7G,EAAOwX,SAAS/O,EACzB,CAEA,IAjeA,MAaE1G,WAAAA,CAAY/D,EAAgByI,GAC1B7J,KAAK6J,QAAUA,EACf7J,KAAKoB,OAASA,EACdpB,KAAKiG,WAAY,EACjBjG,KAAK0pB,WAAY,EACjB1pB,KAAKX,KAAOW,KAAKoB,OAAO6C,QACxBjE,KAAK2pB,aAAe3pB,KAAKX,KAAKsb,cAE9B3a,KAAK4pB,OAAS5pB,KAAKoB,OAAOqD,OAAO,SAAUzE,MAE3CA,KAAKymB,WAAa,IAAItJ,EAAM,EAAG,GAC/Bnd,KAAKslB,UAAYtlB,KAAKymB,WACtBzmB,KAAK6pB,WAAa,KAClB7pB,KAAK8pB,oBACL9pB,KAAK+pB,iBACL/pB,KAAK6J,QAAQiR,UAAU,kBAAmB9a,KAAK2pB,cAAc,KACtD3pB,KAAK0pB,WAAc1pB,KAAKiG,WAC3B+jB,WAAWhqB,KAAKqH,OAAOoJ,KAAKzQ,KAAMwK,EAAAA,EAAQkD,QAAQC,MAAO,EAC3D,IAEF3N,KAAK6J,QAAQ8F,GAAGnF,EAAAA,EAAQC,OAAOsD,sBAAsB,KACnD,IAAK/N,KAAKumB,WAAY,OACtB,MAAMrT,EAASlT,KAAKmG,iBACN,MAAV+M,GACAA,EAAOnM,MAAMlB,OAAS7F,KAAK4pB,OAAOvkB,UACtCrF,KAAK6J,QAAQ0N,KACX/M,EAAAA,EAAQC,OAAOuD,eACf,CAACP,EAAQnG,KACP,IAEItH,KAAKX,KAAKub,SAAS1H,EAAOnM,MAAMlB,OAChC7F,KAAKX,KAAKub,SAAS1H,EAAOlM,IAAInB,OAE9B7F,KAAK0mB,eACHxT,EAAOnM,MAAMlB,KACbqN,EAAOnM,MAAMnB,OACbsN,EAAOlM,IAAInB,KACXqN,EAAOlM,IAAIpB,QAGf,MAAMqkB,EAAoB3iB,EAAUC,MACjCC,GACmB,kBAAlBA,EAASC,MACS,cAAlBD,EAASC,MACU,eAAlBD,EAASC,MACRD,EAAS5E,SAAW5C,KAAKX,OAE/BW,KAAKqH,OAAO4iB,EAAoBzf,EAAAA,EAAQkD,QAAQuC,OAASxC,EAC3D,CAAE,MAAOyc,GACP,IAGL,IAEHlqB,KAAK6J,QAAQ8F,GAAGnF,EAAAA,EAAQC,OAAO+C,iBAAiB,CAAClG,EAAWxE,KAC1D,GAAIA,EAAQoD,MAAO,CACjB,MAAM,UAAEe,EAAS,YAAEC,EAAW,QAAEC,EAAO,UAAEC,GAActE,EAAQoD,MAC/DlG,KAAK0mB,eAAezf,EAAWC,EAAaC,EAASC,GACrDpH,KAAKqH,OAAOmD,EAAAA,EAAQkD,QAAQuC,OAC9B,KAEFjQ,KAAKqH,OAAOmD,EAAAA,EAAQkD,QAAQuC,OAC9B,CAEA6Z,iBAAAA,GACE9pB,KAAK6J,QAAQ8F,GAAGnF,EAAAA,EAAQC,OAAOgL,0BAA0B,KACvDzV,KAAKiG,WAAY,CAAI,IAEvBjG,KAAK6J,QAAQ8F,GAAGnF,EAAAA,EAAQC,OAAOqP,iBAAiB,KAE9C,GADA9Z,KAAKiG,WAAY,EACbjG,KAAK4pB,OAAOxmB,OAAQ,CACtB,MAAM8C,EAAQlG,KAAK4pB,OAAO5jB,UAC1B,IAAKE,EAAO,OACZ8jB,YAAW,KACThqB,KAAK0mB,eACHxgB,EAAMe,UACNf,EAAMgB,YACNhB,EAAMiB,QACNjB,EAAMkB,UACP,GACA,EACL,IAEJ,CAEA2iB,cAAAA,GACE/pB,KAAK6J,QAAQiR,UAAU,YAAaxV,SAASkiB,MAAM,KACjDxnB,KAAK0pB,WAAY,CAAI,IAEvB1pB,KAAK6J,QAAQiR,UAAU,UAAWxV,SAASkiB,MAAM,KAC/CxnB,KAAK0pB,WAAY,EACjB1pB,KAAKqH,OAAOmD,EAAAA,EAAQkD,QAAQC,KAAK,GAErC,CAEAyY,KAAAA,GACMpmB,KAAKumB,aACTvmB,KAAKX,KAAK+mB,MAAM,CAAEC,eAAe,IACjCrmB,KAAKgmB,SAAShmB,KAAKymB,YACrB,CAEAjlB,MAAAA,CAAOA,EAAgBb,GACrBX,KAAKoB,OAAOiG,SACZ,MAAM8iB,EAAcnqB,KAAKmG,iBACzB,GACiB,MAAfgkB,GACCA,EAAYjX,OAAOiD,YACpBnW,KAAKoB,OAAOC,MAAMG,EAAQF,EAAAA,MAAMC,OAHlC,CAMA,GAAI4oB,EAAYpjB,MAAMlB,OAAS7F,KAAK4pB,OAAOvkB,SAAU,CACnD,MAAMpF,EAAOD,KAAKoB,OAAOoL,KAAK2d,EAAYpjB,MAAMlB,MAAM,GACtD,GAAY,MAAR5F,EAAc,OAElB,GAAIA,aAAgBM,EAAAA,SAAU,CAC5B,MAAM6pB,EAAQnqB,EAAK6B,MAAMqoB,EAAYpjB,MAAMnB,QAC3C3F,EAAKmD,OAAOd,aAAatC,KAAK4pB,OAAQQ,EACxC,MAEEnqB,EAAKqC,aAAatC,KAAK4pB,OAAQO,EAAYpjB,MAAMlB,MAEnD7F,KAAK4pB,OAAO9lB,QACd,CACA9D,KAAK4pB,OAAOpoB,OAAOA,EAAQb,GAC3BX,KAAKoB,OAAOyB,WACZ7C,KAAK0mB,eAAe1mB,KAAK4pB,OAAOvkB,SAAUrF,KAAK4pB,OAAOvkB,SAASU,KAAK3F,QACpEJ,KAAKqH,QAjBG,CAkBV,CAEAsf,SAAAA,CAAU3lB,GAA2B,IAAZZ,EAAMD,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,EAChC,MAAMmd,EAAetd,KAAKoB,OAAOhB,SAGjC,IAAIyF,EAFJ7E,EAAQS,KAAKC,IAAIV,EAAOsc,EAAe,GACvCld,EAASqB,KAAKC,IAAIV,EAAQZ,EAAQkd,EAAe,GAAKtc,EAEtD,IAAKP,EAAMmF,GAAU5F,KAAKoB,OAAOX,KAAKO,GACtC,GAAY,MAARP,EAAc,OAAO,KACzB,GAAIL,EAAS,GAAKwF,IAAWnF,EAAKL,SAAU,CAC1C,MAAOiD,GAAQrD,KAAKoB,OAAOX,KAAKO,EAAQ,GACxC,GAAIqC,EAAM,CACR,MAAOhB,GAAQrC,KAAKoB,OAAOiB,KAAKrB,IACzBqpB,GAAYrqB,KAAKoB,OAAOiB,KAAKrB,EAAQ,GACxCqB,IAASgoB,IACX5pB,EAAO4C,EACPuC,EAAS,EAEb,CACF,EACCC,EAAMD,GAAUnF,EAAKqF,SAASF,GAAQ,GACvC,MAAMM,EAAQZ,SAASiO,cACvB,GAAInT,EAAS,EAGX,OAFA8F,EAAMsN,SAAS3N,EAAMD,IACpBnF,EAAMmF,GAAU5F,KAAKoB,OAAOX,KAAKO,EAAQZ,GAC9B,MAARK,EAAqB,OACxBoF,EAAMD,GAAUnF,EAAKqF,SAASF,GAAQ,GACvCM,EAAMwN,OAAO7N,EAAMD,GACZM,EAAMga,yBAEf,IACID,EADAqK,EAAyB,OAE7B,GAAIzkB,aAAgB4C,KAAM,CAMxB,IAAK5C,EAAKE,KAAK3F,OACb,OAAO,KAELwF,EAASC,EAAKE,KAAK3F,QACrB8F,EAAMsN,SAAS3N,EAAMD,GACrBM,EAAMwN,OAAO7N,EAAMD,EAAS,KAE5BM,EAAMsN,SAAS3N,EAAMD,EAAS,GAC9BM,EAAMwN,OAAO7N,EAAMD,GACnB0kB,EAAO,SAETrK,EAAO/Z,EAAMga,uBACf,KAAO,CACL,KAAMzf,EAAKwD,mBAAmByY,SAAU,OAAO,KAC/CuD,EAAOxf,EAAKwD,QAAQic,wBAChBta,EAAS,IAAG0kB,EAAO,QACzB,CACA,MAAO,CACLxJ,OAAQb,EAAKS,IAAMT,EAAKO,OACxBA,OAAQP,EAAKO,OACbI,KAAMX,EAAKqK,GACX3J,MAAOV,EAAKqK,GACZ5J,IAAKT,EAAKS,IACVL,MAAO,EAEX,CAEAla,cAAAA,GAEE,MAsBMgkB,EAtBkBV,KACtB,MAAMrkB,EAAYokB,EAAmBC,GACrC,OAAKrkB,GAAWmlB,YAGdnlB,KACA,sBAAuBA,IACgB,mBAAhCA,EAAUolB,mBAGff,aAAoBgB,YAAc,iBAAkBhB,EASjDrkB,EAAUoS,WAAW,GALnBpS,EAAUolB,kBAAkBf,GAAU,GAZZ,IAiBL,EAGZtjB,CAAenG,KAAK2pB,cACxC,GAAmB,MAAfQ,EAAqB,OAAO,KAChC,MAAMjkB,EAAQlG,KAAK4T,gBAAgBuW,GAEnC,OADA9Q,EAAMqR,KAAK,iBAAkBxkB,GACtBA,CACT,CAEAqf,QAAAA,GACE,MAAMlmB,EAAOW,KAAKoB,OAAO6C,QACzB,GAAI,gBAAiB5E,IAASA,EAAKsrB,YAGjC,MAAO,CAAC,KAAM,MAEhB,MAAMhX,EAAa3T,KAAKmG,iBACxB,OAAkB,MAAdwN,EAA2B,CAAC,KAAM,MAE/B,CADO3T,KAAK6T,kBAAkBF,GACtBA,EACjB,CAEA4S,QAAAA,GACE,MAAMqE,EAAM5qB,KAAK2pB,aAEjB,OACEiB,EAAIC,gBAAkB7qB,KAAKX,MACL,MAArBurB,EAAIC,eAAyBjQ,EAAS5a,KAAKX,KAAMurB,EAAIC,cAE1D,CAEAhX,iBAAAA,CAAkB3N,GAChB,MAAM4kB,EAA8B,CAClC,CAAC5kB,EAAMa,MAAMlB,KAAMK,EAAMa,MAAMnB,SAE5BM,EAAMgN,OAAOiD,WAChB2U,EAAUvd,KAAK,CAACrH,EAAMc,IAAInB,KAAMK,EAAMc,IAAIpB,SAE5C,MAAMmlB,EAAUD,EAAUtmB,KAAKsB,IAC7B,MAAOD,EAAMD,GAAUE,EACjB7F,EAAOD,KAAKoB,OAAOoL,KAAK3G,GAAM,GAE9B7E,EAAQf,EAAK2F,OAAO5F,KAAKoB,QAC/B,OAAe,IAAXwE,EACK5E,EAELf,aAAgBM,EAAAA,SACXS,EAAQf,EAAKe,MAAM6E,EAAMD,GAG3B5E,EAAQf,EAAKG,QAAQ,IAExB4G,EAAMvF,KAAKC,IAAID,KAAKwc,OAAO8M,GAAU/qB,KAAKoB,OAAOhB,SAAW,GAC5D2G,EAAQtF,KAAKC,IAAIsF,KAAQ+jB,GAC/B,OAAO,IAAI5N,EAAMpW,EAAOC,EAAMD,EAChC,CAEA6M,eAAAA,CAAgBuW,GACd,IACGvP,EAAS5a,KAAKX,KAAM8qB,EAAY1S,kBAC/B0S,EAAYhU,YAAcyE,EAAS5a,KAAKX,KAAM8qB,EAAYa,cAE5D,OAAO,KAET,MAAM9kB,EAAQ,CACZa,MAAO,CACLlB,KAAMskB,EAAY1S,eAClB7R,OAAQukB,EAAYjjB,aAEtBF,IAAK,CAAEnB,KAAMskB,EAAYa,aAAcplB,OAAQukB,EAAY/iB,WAC3D8L,OAAQiX,GA2BV,MAzBA,CAACjkB,EAAMa,MAAOb,EAAMc,KAAKtC,SAASoB,IAChC,IAAI,KAAED,EAAI,OAAED,GAAWE,EACvB,OAASD,aAAgB4C,OAAS5C,EAAKsC,WAAW/H,OAAS,GACzD,GAAIyF,EAAKsC,WAAW/H,OAASwF,EAC3BC,EAAOA,EAAKsC,WAAWvC,GACvBA,EAAS,MACJ,IAAIC,EAAKsC,WAAW/H,SAAWwF,EAapC,MAXAC,EAAOA,EAAKO,UAEVR,EADEC,aAAgB4C,KACT5C,EAAKE,KAAK3F,OACVyF,EAAKsC,WAAW/H,OAAS,EAEzByF,EAAKsC,WAAW/H,OAGhByF,EAAKsC,WAAW/H,OAAS,CAItC,CAEF0F,EAASD,KAAOA,EAChBC,EAASF,OAASA,CAAM,IAEnBM,CACT,CAEAsgB,aAAAA,CAActgB,GACZ,MAAMoX,EAAetd,KAAKoB,OAAOhB,SAE3B6qB,EAAcA,CAClBjqB,EACAkqB,KAEAlqB,EAAQS,KAAKC,IAAI4b,EAAe,EAAGtc,GACnC,MAAOP,EAAM0qB,GAAcnrB,KAAKoB,OAAOX,KAAKO,GAC5C,OAAOP,EAAOA,EAAKqF,SAASqlB,EAAYD,GAAa,CAAC,MAAO,EAAE,EAEjE,MAAO,IACFD,EAAY/kB,EAAMlF,OAAO,MACzBiqB,EAAY/kB,EAAMlF,MAAQkF,EAAM9F,QAAQ,GAE/C,CAEAsmB,cAAAA,CACEzf,EACAC,GAIA,IAHAC,EAAOhH,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG8G,EACVG,EAASjH,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG+G,EACZhE,EAAK/C,UAAAC,OAAA,QAAAC,IAAAF,UAAA,IAAAA,UAAA,GAGL,GADAkZ,EAAMqR,KAAK,iBAAkBzjB,EAAWC,EAAaC,EAASC,GAE/C,MAAbH,IACyB,MAAxBjH,KAAKX,KAAKgH,YACe,MAAxBY,EAAUZ,YAEY,MAAtBc,EAAQd,YAEV,OAEF,MAAMjB,EAAYokB,EAAmBxpB,KAAK2pB,cAC1C,GAAiB,MAAbvkB,EACJ,GAAiB,MAAb6B,EAAmB,CAChBjH,KAAKumB,YAAYvmB,KAAKX,KAAK+mB,MAAM,CAAEC,eAAe,IACvD,MAAM,OAAEnT,GAAWlT,KAAKmG,kBAAoB,CAAC,GAEjC,MAAV+M,GACAhQ,GACA+D,IAAciM,EAAOuE,gBACrBvQ,IAAgBgM,EAAOhM,aACvBC,IAAY+L,EAAO8X,cACnB5jB,IAAc8L,EAAO9L,aAEjBH,aAAqByV,SAAiC,OAAtBzV,EAAU1D,UAE5C2D,EAAce,MAAMC,KAAKjB,EAAUZ,WAAW8B,YAAYW,QACxD7B,GAEFA,EAAYA,EAAUZ,YAEpBc,aAAmBuV,SAA+B,OAApBvV,EAAQ5D,UAExC6D,EAAYa,MAAMC,KAAKf,EAAQd,WAAW8B,YAAYW,QACpD3B,GAEFA,EAAUA,EAAQd,YAMlBY,GACAE,GACuB,iBAAhBD,GACc,iBAAdE,GAEPhC,EAAUgmB,iBACRnkB,EACAC,EACAC,EACAC,GAIR,MACEhC,EAAUyS,kBACV7X,KAAKX,KAAK0mB,MAEd,CAIAC,QAAAA,CACE9f,GAGM,IAFNhD,EAA8B/C,UAAAC,OAAA,QAAAC,IAAAF,UAAA,IAAAA,UAAA,GAC9BsN,EAAqBtN,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGqK,EAAAA,EAAQkD,QAAQqM,IAOxC,GALqB,iBAAV7W,IACTuK,EAASvK,EACTA,GAAQ,GAEVmW,EAAMqR,KAAK,WAAYxkB,GACV,MAATA,EAAe,CACjB,MAAM6S,EAAO/Y,KAAKwmB,cAActgB,GAChClG,KAAK0mB,kBAAkB3N,EAAM7V,EAC/B,MACElD,KAAK0mB,eAAe,MAEtB1mB,KAAKqH,OAAOoG,EACd,CAEApG,MAAAA,GAAqD,IAA9CoG,EAAqBtN,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGqK,EAAAA,EAAQkD,QAAQC,KAC7C,MAAM6R,EAAWxf,KAAKslB,WACfA,EAAW6E,GAAenqB,KAAKulB,WAMtC,GALAvlB,KAAKslB,UAAYA,EACjBtlB,KAAK6pB,WAAaM,EACI,MAAlBnqB,KAAKslB,YACPtlB,KAAKymB,WAAazmB,KAAKslB,aAEpB7F,EAAAA,EAAAA,GAAQD,EAAUxf,KAAKslB,WAAY,CACtC,IACGtlB,KAAKiG,WACS,MAAfkkB,GACAA,EAAYjX,OAAOiD,WACnBgU,EAAYpjB,MAAMlB,OAAS7F,KAAK4pB,OAAOvkB,SACvC,CACA,MAAMa,EAAQlG,KAAK4pB,OAAO5jB,UACtBE,GACFlG,KAAK0mB,eACHxgB,EAAMe,UACNf,EAAMgB,YACNhB,EAAMiB,QACNjB,EAAMkB,UAGZ,CACA,MAAM2R,EAAO,CACXvO,EAAAA,EAAQC,OAAOuF,kBACfkO,EAAAA,EAAAA,GAAUle,KAAKslB,YACfpH,EAAAA,EAAAA,GAAUsB,GACV/R,GAEFzN,KAAK6J,QAAQU,KAAKC,EAAAA,EAAQC,OAAOoF,iBAAkBkJ,GAC/CtL,IAAWjD,EAAAA,EAAQkD,QAAQuC,QAC7BjQ,KAAK6J,QAAQU,QAAQwO,EAEzB,CACF,sBC5fF,MAAMyJ,EACJtd,gBAAgC,CAC9B8c,QAAS,CAAC,GAGZ9c,cAAgB,CACdmmB,QAAS7I,GAGXR,QAAmC,CAAC,EAEpC7c,WAAAA,CACYsK,EACAC,GACV,KAFUD,MAAAA,EAAY,KACZC,QAAAA,CACT,CAEH0V,IAAAA,GACEhZ,OAAOC,KAAKrM,KAAK0P,QAAQsS,SAAStd,SAASvD,IACf,MAAtBnB,KAAKgiB,QAAQ7gB,IACfnB,KAAKmlB,UAAUhkB,EACjB,GAEJ,CAOAgkB,SAAAA,CAAUhkB,GAER,MAAMmqB,EAActrB,KAAKyP,MAAMtK,YAAY0d,OAAQ,WAAU1hB,KAK7D,OAJAnB,KAAKgiB,QAAQ7gB,GAAQ,IAAImqB,EACvBtrB,KAAKyP,MACLzP,KAAK0P,QAAQsS,QAAQ7gB,IAAS,CAAC,GAE1BnB,KAAKgiB,QAAQ7gB,EACtB,EAQF,yBCjDA,IAJA,SAAsBgoB,GACpB,OAAOoC,KAAKC,MAAMD,KAAKE,UAAUtC,GACnC,qBCgBA,SAASuC,EAAYvC,GACnB,OAAOA,IAAQ/c,OAAO+c,EACxB,CAEA,IAzBA,SAAS1J,EAAQkM,EAAWC,GAC1B,GAAID,IAASC,EAEX,OAAO,EAET,GAAIF,EAAYC,IAASD,EAAYE,GAEnC,OAAOD,IAASC,EAElB,GAAIxf,OAAOC,KAAKsf,GAAMvrB,SAAWgM,OAAOC,KAAKuf,GAAMxrB,OAAQ,OAAO,EAGlE,IAAK,MAAM0L,KAAO6f,EAAM,CACtB,KAAM7f,KAAO8f,GAAO,OAAO,EAC3B,IAAKnM,EAAQkM,EAAK7f,GAAM8f,EAAK9f,IAAO,OAAO,CAC7C,CAEA,OAAO,CACT,mHClBA,MAAMgY,EAAS,CACblf,MAAOtD,EAAAA,MAAMC,MACbsqB,UAAW,CAAC,QAAS,SAAU,YAG3BC,EAAiB,IAAIC,EAAAA,WAAW,QAAS,QAASjI,GAClDkI,EAAa,IAAIC,EAAAA,gBAAgB,QAAS,WAAYnI,GACtDoI,EAAa,IAAIC,EAAAA,gBAAgB,QAAS,aAAcrI,mGCN9D,MAAMsI,EAAkB,IAAIH,EAAAA,gBAAgB,aAAc,QAAS,CACjErnB,MAAOtD,EAAAA,MAAMkN,SAET6d,EAAkB,IAAIC,EAAAA,GAAgB,aAAc,mBAAoB,CAC5E1nB,MAAOtD,EAAAA,MAAMkN,yJCCf,MAAM+d,UAA2BxnB,EAAAA,EAC/B,aAAON,CAAO9D,GACZ,MAAMsD,EAAUhD,MAAMwD,OAAO9D,GAE7B,OADAsD,EAAQ+D,aAAa,aAAc,SAC5B/D,CACT,CAEAuoB,IAAAA,CAAKxrB,EAAeZ,GAClB,OACEJ,KAAKiC,SAEFuC,KAAKvB,GAAWA,EAAM7C,UAAY,EAAI,GAAK6C,EAAMgB,QAAQwoB,YACzD9lB,KAAK,MACLyE,MAAMpK,EAAOA,EAAQZ,EAE5B,CAEA8b,IAAAA,CAAKlb,EAAeZ,GAGlB,MAAQ,WAAS+I,EAAAA,EAAAA,GAAWnJ,KAAKwsB,KAAKxrB,EAAOZ,aAC/C,EAGF,MAAMssB,UAAkB9sB,EAAAA,GACtBsF,WAAa,KAEb,eAAO6S,GACLnI,EAAAA,GAAMmI,SAASwU,EACjB,EAGF,MAAMI,UAAajpB,EAAAA,GACnBipB,EAAKrpB,SAAW,OAChBqpB,EAAKppB,QAAU,OAEfmpB,EAAUppB,SAAW,aACrBopB,EAAU5G,UAAY,gBACtB4G,EAAUnpB,QAAU,MACpBgpB,EAAmBjpB,SAAW,uBAC9BipB,EAAmBzG,UAAY,0BAC/ByG,EAAmBhpB,QAAU,MAE7BgpB,EAAmB9oB,gBAAkB,CAACipB,GAEtCA,EAAUjpB,gBAAkB,CAACG,EAAAA,EAAUnB,EAAAA,EAAOwC,EAAAA,GAC9CynB,EAAUrI,kBAAoBkI,mHCpD9B,MAAMD,UAAwBH,EAAAA,gBAC5BxrB,KAAAA,CAAMsD,GACJ,IAAItD,EAAQM,MAAMN,MAAMsD,GACxB,OAAKtD,EAAMuiB,WAAW,SACtBviB,EAAQA,EAAMyI,QAAQ,UAAW,IAAIA,QAAQ,UAAW,IAKhD,IAJIzI,EACTmB,MAAM,KACN0C,KAAKooB,GAAe,KAAI1L,SAAS0L,EAAW,IAAIC,SAAS,MAAMzhB,OAAO,KACtEzE,KAAK,OAL8BhG,CAOxC,EAGF,MAAMmsB,EAAa,IAAIb,EAAAA,gBAAgB,QAAS,WAAY,CAC1DrnB,MAAOtD,EAAAA,MAAMkN,SAETue,EAAa,IAAIT,EAAgB,QAAS,QAAS,CACvD1nB,MAAOtD,EAAAA,MAAMkN,0HCjBf,MAAMsV,EAAS,CACblf,MAAOtD,EAAAA,MAAMC,MACbsqB,UAAW,CAAC,QAGRmB,EAAqB,IAAIjB,EAAAA,WAAW,YAAa,MAAOjI,GACxDmJ,EAAiB,IAAIhB,EAAAA,gBAAgB,YAAa,eAAgBnI,GAClEoJ,EAAiB,IAAIf,EAAAA,gBAAgB,YAAa,YAAarI,0FCPrE,MAAMA,EAAS,CACblf,MAAOtD,EAAAA,MAAMkN,OACbqd,UAAW,CAAC,QAAS,cAGjBsB,EAAY,IAAIlB,EAAAA,gBAAgB,OAAQ,UAAWnI,GAEzD,MAAMsJ,UAA4BjB,EAAAA,gBAChCxrB,KAAAA,CAAMkF,GACJ,OAAO5E,MAAMN,MAAMkF,GAAMuD,QAAQ,QAAS,GAC5C,EAGF,MAAMikB,EAAY,IAAID,EAAoB,OAAQ,cAAetJ,0FCbjE,MAAMwJ,EAAY,IAAIrB,EAAAA,gBAAgB,OAAQ,UAAW,CACvDrnB,MAAOtD,EAAAA,MAAMkN,OACbqd,UAAW,CAAC,QAAS,QAAS,UAE1B0B,EAAY,IAAIpB,EAAAA,gBAAgB,OAAQ,YAAa,CACzDvnB,MAAOtD,EAAAA,MAAMkN,OACbqd,UAAW,CAAC,OAAQ,OAAQ,+LCR9B,MAAM2B,EAAqB,wBACrBC,EAAgB,CAAC,IAAK,KAAM,MAE5BC,EAAkB1N,GACfA,GAAWyN,EAAcrZ,SAAS4L,EAAQzc,SCJ7CoqB,EAAe,0BACfC,EAAW,4BACXC,EAAe,gCCCfC,EAAc,CDsFL,SAAmBlD,GAG9B,0CADAA,EAAIhD,gBAAgB/a,aAAa,YA/DV+d,KACzB,MAAMmD,EAAU9lB,MAAMC,KAAK0iB,EAAIoD,iBAAiB,sBAC1C9D,EAAqB,GACrB+D,EAAoB,GAC1BF,EAAQrpB,SAASmB,KACOA,EAAKgH,aAAa,UAAY,IAAIuP,MAAMuR,GAE5DzD,EAAQ3c,KAAK1H,GAEbooB,EAAO1gB,KAAK1H,EACd,IAIFqkB,EAAQxlB,SAASmB,GAASA,EAAKQ,YAAYrD,YAAY6C,KAIvD,MAAMqW,EAAO0O,EAAIhD,gBAAgBnL,UAC3ByR,EAAYD,EACfzpB,KAAKwb,GA5CYmO,EAACnO,EAAkB9D,KACvC,MAAM2L,EAAQ7H,EAAQnT,aAAa,SAC7BuhB,EAAUvG,GAAOzL,MAAMwR,GAC7B,IAAKQ,EACH,OAAO,KAET,MAAMC,EAAKvhB,OAAOshB,EAAQ,IAEpBE,EAAczG,GAAOzL,MAAMyR,GAC3BjS,EAAS0S,EAAcxhB,OAAOwhB,EAAY,IAAM,EAEhDC,EAAa,IAAIC,OACpB,UAASH,UAAWzS,uDACrB,KAEI6S,EAAYvS,EAAKE,MAAMmS,GAG7B,MAAO,CAAEF,KAAIzS,SAAQnU,KAFRgnB,GAA8B,WAAjBA,EAAU,GAAkB,SAAW,UAEtCzO,UAAS,EA0BhBmO,CAAcnO,EAAS9D,KACxChc,QAAQwuB,GAAWA,IAEtB,KAAOR,EAAU9tB,QAAQ,CACvB,MAAMuuB,EAAiB,GAEvB,IAAIrH,EAAU4G,EAAUlsB,QAExB,KAAOslB,GACLqH,EAAephB,KAAK+Z,GACpBA,EACE4G,EAAU9tB,QACV8tB,EAAU,IAAIlO,UAAYsH,EAAQtH,QAAQ4O,oBAE1CV,EAAU,GAAGG,KAAO/G,EAAQ+G,GACxBH,EAAUlsB,QACV,KAGR,MAAM6sB,EAAKvpB,SAASyC,cAAc,MAClC4mB,EAAejqB,SAASoqB,IACtB,MAAMC,EAAKzpB,SAASyC,cAAc,MAClCgnB,EAAG/mB,aAAa,YAAa8mB,EAASrnB,MAClCqnB,EAASlT,OAAS,GACpBmT,EAAG/mB,aAAa,QAAU,cAAY8mB,EAASlT,OAAS,IAE1DmT,EAAGtS,UAAYqS,EAAS9O,QAAQvD,UAChCoS,EAAGppB,YAAYspB,EAAG,IAGpB,MAAM/O,EAAU2O,EAAe,IAAI3O,SAC7B,WAAE3Z,GAAe2Z,GAAW,CAAC,EAC/BA,GACF3Z,GAAY2oB,aAAaH,EAAI7O,GAE/B2O,EAAevjB,MAAM,GAAG1G,SAAQkF,IAAoB,IAAjBoW,QAAS/V,GAAGL,EAC7CvD,GAAYrD,YAAYiH,EAAE,GAE9B,GAQEglB,CAAkBrE,EAEtB,EDnEe,SAAmBA,GAC5BA,EAAI3B,cAAc,iCAXK2B,KAC3B3iB,MAAMC,KAAK0iB,EAAIoD,iBAAiB,4BAC7B9tB,QAAQ2F,GAASA,EAAKgH,aAAa,UAAUuP,MAAMoR,KACnD9oB,SAASmB,IACR,MAAMqpB,EAAWtE,EAAIuE,yBACrBD,EAASE,UAAUvpB,EAAKsC,YACxBtC,EAAKQ,YAAY2oB,aAAaE,EAAUrpB,EAAK,GAC7C,EAKFwpB,CAAoBzE,GAxBKA,KAC3B3iB,MAAMC,KAAK0iB,EAAIoD,iBAAiB,OAC7B9tB,QACEovB,GACC5B,EAAe4B,EAAGC,yBAClB7B,EAAe4B,EAAGV,sBAErBlqB,SAAS4qB,IACRA,EAAGjpB,YAAYrD,YAAYssB,EAAG,GAC9B,EAgBFE,CAAoB5E,GAExB,GGRA,MAAMvR,GAAQC,EAAAA,EAAAA,GAAO,mBAKfmW,EAA0C,CAC9C,CAAC3P,KAAK4P,UAklBR,SAAmB7pB,EAAmB9F,EAAcqB,GAElD,IAAIW,EAAO8D,EAAKE,KAEhB,GAAoC,QAAhCF,EAAK6iB,eAAenlB,QACtB,OAAOxD,EAAMW,OAAOqB,EAAK0iB,QAE3B,IAAKkL,EAAM9pB,GAAO,CAChB,GACyB,IAAvB9D,EAAK0iB,OAAOrkB,QACZ2B,EAAKqS,SAAS,QAvRpB,SAAiCvO,EAAmBzE,GAClD,OACEyE,EAAK0pB,wBACL1pB,EAAK+oB,qBACJtlB,EAAOzD,EAAK0pB,uBAAwBnuB,KACpCkI,EAAOzD,EAAK+oB,mBAAoBxtB,EAErC,CAiROwuB,CAAwB/pB,EAAMzE,GAE/B,OAAOrB,EAGTgC,EAAOA,EAAKqH,QAAQ,eAAgB,KAEpCrH,EAAOA,EAAKqH,QAAQ,SAAU,MAEH,MAAxBvD,EAAKgqB,iBACkB,MAAtBhqB,EAAK6iB,eACLpf,EAAOzD,EAAK6iB,cAAetnB,IAC5ByE,EAAKgqB,2BAA2BnT,SAC/BpT,EAAOzD,EAAKgqB,gBAAiBzuB,MAG/BW,EAAOA,EAAKqH,QAAQ,KAAM,MAGL,MAApBvD,EAAKiqB,aACkB,MAAtBjqB,EAAK6iB,eACLpf,EAAOzD,EAAK6iB,cAAetnB,IAC5ByE,EAAKiqB,uBAAuBpT,SAAWpT,EAAOzD,EAAKiqB,YAAa1uB,MAGjEW,EAAOA,EAAKqH,QAAQ,KAAM,KAG5BrH,EAAOA,EAAKoa,WAAW,IAAU,IACnC,CACA,OAAOpc,EAAMW,OAAOqB,EACtB,GA3nBE,CAAC+d,KAAK4P,UAAWK,GACjB,CAAC,KAycH,SAAoBlqB,EAAY9F,GAI9B,OAHKiwB,EAAcjwB,EAAO,OACxBA,EAAMW,OAAO,MAERX,CACT,GA7cE,CAAC+f,KAAKmQ,aAAcF,GACpB,CAACjQ,KAAKmQ,aAoaR,SAAmBpqB,EAAY9F,EAAcqB,GAC3C,MAAMgb,EAAQhb,EAAOC,MAAMwE,GAC3B,GAAa,MAATuW,EAAe,OAAOrc,EAE1B,GAAIqc,EAAM8T,qBAAqBvsB,EAAAA,UAAW,CACxC,MAAM0H,EAAQ,CAAC,EAET1K,EAAQyb,EAAMzb,MAAMkF,GAC1B,GAAa,MAATlF,EAIF,OAFA0K,EAAM+Q,EAAM9Y,UAAY3C,GAEjB,IAAIE,EAAAA,IAAQH,OAAO2K,EAAO+Q,EAAMlY,QAAQ2B,EAAMzE,GAEzD,MAKE,GAHIgb,EAAM8T,qBAAqBrwB,EAAAA,YAAcmwB,EAAcjwB,EAAO,OAChEA,EAAMW,OAAO,MAGb,aAAc0b,GACd,YAAaA,GACY,mBAAlBA,EAAMlY,QAEb,OAAOisB,EACLpwB,EACAqc,EAAM9Y,SACN8Y,EAAMlY,QAAQ2B,EAAMzE,GACpBA,GAIN,OAAOrB,CACT,GApcE,CAAC+f,KAAKmQ,aAoYR,SAAyBpqB,EAAmB9F,EAAcqB,GACxD,MAAM2C,EAAagoB,EAAAA,WAAW1f,KAAKxG,GAC7BuqB,EAAUnE,EAAAA,gBAAgB5f,KAAKxG,GAC/BwqB,EAASlE,EAAAA,gBAAgB9f,KAAKxG,GAC9B3B,EAA8C,CAAC,EAqBrD,OApBAH,EACG4H,OAAOykB,GACPzkB,OAAO0kB,GACP3rB,SAASvD,IACR,IAAIsR,EAAOrR,EAAOC,MAAMF,EAAMG,EAAAA,MAAMgvB,WACxB,MAAR7d,IACFvO,EAAQuO,EAAKuQ,UAAYvQ,EAAK9R,MAAMkF,GAChC3B,EAAQuO,EAAKuQ,aAEnBvQ,EAAO8d,EAAsBpvB,GACjB,MAARsR,GAAiBA,EAAKuQ,WAAa7hB,GAAQsR,EAAK+d,UAAYrvB,IAC9D+C,EAAQuO,EAAKuQ,UAAYvQ,EAAK9R,MAAMkF,SAASxF,GAE/CoS,EAAOge,EAAkBtvB,GACb,MAARsR,GAAiBA,EAAKuQ,WAAa7hB,GAAQsR,EAAK+d,UAAYrvB,IAC9DsR,EAAOge,EAAkBtvB,GACzB+C,EAAQuO,EAAKuQ,UAAYvQ,EAAK9R,MAAMkF,SAASxF,GAC/C,IAGG+L,OAAOqC,QAAQvK,GAAS1D,QAC7B,CAACkwB,EAAQ/hB,KAAA,IAAGxN,EAAMR,GAAMgO,EAAA,OAAKwhB,EAAYO,EAAUvvB,EAAMR,EAAOS,EAAO,GACvErB,EAEJ,GAhaE,CAAC+f,KAAKmQ,aA4hBR,SAAqBpqB,EAAmB9F,EAAcqB,GACpD,MAAM8C,EAAmC,CAAC,EACpC2jB,EAAsChiB,EAAKgiB,OAAS,CAAC,EAsB3D,MArBwB,WAApBA,EAAM8I,YACRzsB,EAAQ0sB,QAAS,GAEU,cAAzB/I,EAAMgJ,iBACR3sB,EAAQ4sB,WAAY,GAEO,iBAAzBjJ,EAAMgJ,iBACR3sB,EAAQ6sB,QAAS,IAGjBlJ,EAAMmJ,YAAY9N,WAAW,SAE7BhC,SAAS2G,EAAMmJ,WAAY,KAAO,OAElC9sB,EAAQ+sB,MAAO,GAEjBlxB,EAAQqM,OAAOqC,QAAQvK,GAAS1D,QAC9B,CAACkwB,EAAQQ,KAAA,IAAG/vB,EAAMR,GAAMuwB,EAAA,OAAKf,EAAYO,EAAUvvB,EAAMR,EAAOS,EAAO,GACvErB,GAGEoxB,WAAWtJ,EAAMuJ,YAAc,GAAK,GAE/B,IAAIvwB,EAAAA,IAAQH,OAAO,MAAMiL,OAAO5L,GAElCA,CACT,GAxjBE,CAAC,KAwdH,SAAqB8F,EAAY9F,EAAcqB,GAC7C,MAAMgb,EAAQhb,EAAOC,MAAMwE,GAC3B,GACW,MAATuW,GAEmB,SAAnBA,EAAM9Y,WACL0sB,EAAcjwB,EAAO,MAEtB,OAAOA,EAET,IAAI6b,GAAU,EACVxY,EAASyC,EAAKQ,WAClB,KAAiB,MAAVjD,GAED,CAAC,KAAM,MAAMgR,SAAShR,EAAOG,WAC/BqY,GAAU,GAEZxY,EAASA,EAAOiD,WAElB,OAAIuV,GAAU,EAAU7b,EACjBA,EAAMS,QAAO,CAAC6wB,EAAU/iB,IACxBA,EAAG5N,OACJ4N,EAAGvK,YAA8C,iBAAzBuK,EAAGvK,WAAW6X,OACjCyV,EAAS9jB,KAAKe,GAEhB+iB,EAAS3wB,OAAO4N,EAAG5N,OAAQ,CAAEkb,YAAYtN,EAAGvK,YAAc,CAAC,IAJ3CstB,GAKtB,IAAIxwB,EAAAA,GACT,GAlfE,CAAC,SAofH,SAAmBgF,EAAY9F,EAAcqB,GAC3C,MAAM4e,EAAUna,EAChB,IAAIyW,EAA2B,OAApB0D,EAAQzc,QAAmB,UAAY,SAElD,MAAM+tB,EAActR,EAAQnT,aAAa,gBAKzC,OAJIykB,IACFhV,EAAuB,SAAhBgV,EAAyB,UAAY,aAGvCnB,EAAYpwB,EAAO,OAAQuc,EAAMlb,EAC1C,GA7fE,CAAC,MAycH,SAAwByE,EAAY9F,EAAcqB,GAChD,MAAMgb,EAAQhb,EAAOC,MAAM,cAK3B,OAAO8uB,EAAYpwB,EAAO,cAHxBqc,KAAS,YAAaA,IAAkC,mBAAlBA,EAAMlY,SACxCkY,EAAMlY,QAAQ2B,EAAMzE,GAEwBA,EACpD,GA/cE,CAAC,KAujBH,SACEyE,EACA9F,EACAqB,GAEA,MAAMmwB,EAC4B,UAAhC1rB,EAAK6iB,eAAenlB,QAChBsC,EAAK6iB,cACL7iB,EAAK6iB,eAAeA,cAC1B,OAAa,MAAT6I,EAGKpB,EAAYpwB,EAAO,QAFbkI,MAAMC,KAAKqpB,EAAMvD,iBAAiB,OAC9BllB,QAAQjD,GAAQ,EACOzE,GAEnCrB,CACT,GArkBE,CAAC,IAAKyxB,EAAiB,SACvB,CAAC,IAAKA,EAAiB,WACvB,CAAC,SAAUA,EAAiB,WAC5B,CAAC,QA6cH,WACE,OAAO,IAAI3wB,EAAAA,EACb,IA5cM0vB,EAAwB,CAACzE,EAAAA,GAAgBkB,EAAAA,IAAoBxsB,QACjE,CAACixB,EAAkChf,KACjCgf,EAAKhf,EAAK+d,SAAW/d,EACdgf,IAET,CAAC,GAGGhB,EAAoB,CACxBvE,EAAAA,GACAG,EAAAA,EACAU,EAAAA,GACAG,EAAAA,GACAG,EAAAA,EACAE,EAAAA,GACA/sB,QAAO,CAACixB,EAAkChf,KAC1Cgf,EAAKhf,EAAK+d,SAAW/d,EACdgf,IACN,CAAC,GAMJ,MAAMzZ,UAAkBjJ,EAAAA,EACtB7J,gBAAoC,CAClCwsB,SAAU,IAKZvsB,WAAAA,CAAYsK,EAAcC,GACxBzO,MAAMwO,EAAOC,GACb1P,KAAKyP,MAAMpQ,KAAK2K,iBAAiB,QAASC,GACxCjK,KAAK2xB,cAAc1nB,GAAG,KAExBjK,KAAKyP,MAAMpQ,KAAK2K,iBAAiB,OAAQC,GAAMjK,KAAK2xB,cAAc1nB,GAAG,KACrEjK,KAAKyP,MAAMpQ,KAAK2K,iBAAiB,QAAShK,KAAK4xB,eAAenhB,KAAKzQ,OACnEA,KAAK0xB,SAAW,GAChBjC,EAAiB9jB,OAAO3L,KAAK0P,QAAQgiB,UAAY,IAAIhtB,SACnDkF,IAAyB,IAAvBof,EAAU6I,GAAQjoB,EAClB5J,KAAK8xB,WAAW9I,EAAU6I,EAAQ,GAGxC,CAEAC,UAAAA,CAAW9I,EAAoB6I,GAC7B7xB,KAAK0xB,SAASnkB,KAAK,CAACyb,EAAU6I,GAChC,CAEApM,OAAAA,CAAO3X,GAGL,IAFA,KAAEoO,EAAI,KAAEna,GAAwC+L,EAChD5J,EAAgC/D,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,CAAC,EAEpC,GAAI+D,EAAQwoB,EAAAA,GAAUppB,UACpB,OAAO,IAAIzC,EAAAA,IAAQH,OAAOqB,GAAQ,GAAI,CACpC,CAAC2qB,EAAAA,GAAUppB,UAAWY,EAAQwoB,EAAAA,GAAUppB,YAG5C,IAAK4Y,EACH,OAAO,IAAIrb,EAAAA,IAAQH,OAAOqB,GAAQ,GAAImC,GAExC,MAAMnE,EAAQC,KAAK+b,YAAYG,GAE/B,OACE8T,EAAcjwB,EAAO,QAC0B,MAA9CA,EAAM4R,IAAI5R,EAAM4R,IAAIvR,OAAS,GAAG2D,YAAsBG,EAAQqtB,OAExDxxB,EAAMkS,SAAQ,IAAIpR,EAAAA,IAAQuU,OAAOrV,EAAMK,SAAW,GAAGkS,OAAO,IAE9DvS,CACT,CAEUgyB,aAAAA,CAAcnH,GDrHKA,KACzBA,EAAIhD,iBACNkG,EAAYppB,SAASstB,IACnBA,EAAUpH,EAAI,GAElB,ECiHEqH,CAAsBrH,EACxB,CAEU7O,WAAAA,CAAYG,GACpB,MAAM0O,GAAM,IAAIsH,WAAYC,gBAAgBjW,EAAM,aAClDlc,KAAK+xB,cAAcnH,GACnB,MAAMzH,EAAYyH,EAAIpD,KAChB4K,EAAc,IAAI1S,SACjB2S,EAAiBC,GAAgBtyB,KAAKuyB,gBAC3CpP,EACAiP,GAEF,OAAOI,EACLxyB,KAAKyP,MAAMrO,OACX+hB,EACAkP,EACAC,EACAF,EAEJ,CAQAK,oBAAAA,CACEzxB,EACAkb,GAEA,IADAzO,EAAqBtN,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGyP,EAAAA,GAAMlC,QAAQqM,IAEtC,GAAqB,iBAAV/Y,EAAoB,CAC7B,MAAMjB,EAAQC,KAAKylB,QAAQ,CAAEvJ,KAAMlb,EAAOe,KAAM,KAEhD/B,KAAKyP,MAAMiW,YAAY3lB,EAAOmc,GAC9Blc,KAAKyP,MAAM2C,aAAa,EAAGxC,EAAAA,GAAMlC,QAAQuC,OAC3C,KAAO,CACL,MAAMyiB,EAAQ1yB,KAAKylB,QAAQ,CAAEvJ,OAAMna,KAAM,KACzC/B,KAAKyP,MAAM4B,gBACT,IAAIxQ,EAAAA,IAAQuU,OAAOpU,GAAO2K,OAAO+mB,GACjCjlB,GAEFzN,KAAKyP,MAAM2C,aAAapR,EAAQ0xB,EAAMtyB,SAAUwP,EAAAA,GAAMlC,QAAQuC,OAChE,CACF,CAEA0hB,aAAAA,CAAc1nB,GAAkC,IAAf0oB,EAAKxyB,UAAAC,OAAA,QAAAC,IAAAF,UAAA,IAAAA,UAAA,GACpC,GAAI8J,EAAE+L,iBAAkB,OACxB/L,EAAEmE,iBACF,MAAOlI,GAASlG,KAAKyP,MAAMrK,UAAUmgB,WACrC,GAAa,MAATrf,EAAe,OACnB,MAAM,KAAEgW,EAAI,KAAEna,GAAS/B,KAAK4yB,OAAO1sB,EAAOysB,GAC1C1oB,EAAE4oB,eAAeC,QAAQ,aAAc/wB,GACvCkI,EAAE4oB,eAAeC,QAAQ,YAAa5W,GAClCyW,IACFhd,EAAAA,EAAAA,IAAY,CAAEzP,QAAOuJ,MAAOzP,KAAKyP,OAErC,CAKQsjB,gBAAAA,CAAiBC,GACvB,OACEA,EACGlxB,MAAM,SAEN5B,QAAQ+yB,GAAmB,MAAXA,EAAI,KACpBtsB,KAAK,KAEZ,CAEAirB,cAAAA,CAAe3nB,GACb,GAAIA,EAAE+L,mBAAqBhW,KAAKyP,MAAM7C,YAAa,OACnD3C,EAAEmE,iBACF,MAAMlI,EAAQlG,KAAKyP,MAAM8G,cAAa,GACtC,GAAa,MAATrQ,EAAe,OACnB,MAAMgW,EAAOjS,EAAE4oB,eAAexc,QAAQ,aACtC,IAAItU,EAAOkI,EAAE4oB,eAAexc,QAAQ,cACpC,IAAK6F,IAASna,EAAM,CAClB,MAAMixB,EAAU/oB,EAAE4oB,eAAexc,QAAQ,iBACrC2c,IACFjxB,EAAO/B,KAAK+yB,iBAAiBC,GAEjC,CACA,MAAMjf,EAAQ9L,MAAMC,KAAK+B,EAAE4oB,eAAe9e,OAAS,IACnD,IAAKmI,GAAQnI,EAAM3T,OAAS,EAC1BJ,KAAKyP,MAAM0S,SAASnO,OAAO9N,EAAO6N,OADpC,CAIA,GAAImI,GAAQnI,EAAM3T,OAAS,EAAG,CAC5B,MAAMwqB,GAAM,IAAIsH,WAAYC,gBAAgBjW,EAAM,aAClD,GACiC,IAA/B0O,EAAIpD,KAAK0L,mBAC+B,QAAxCtI,EAAIpD,KAAK2L,mBAAmB5vB,QAG5B,YADAvD,KAAKyP,MAAM0S,SAASnO,OAAO9N,EAAO6N,EAGtC,CACA/T,KAAKozB,QAAQltB,EAAO,CAAEgW,OAAMna,QAX5B,CAYF,CAGA6wB,MAAAA,CAAO1sB,GACL,MAAMnE,EAAO/B,KAAKyP,MAAMkP,QAAQzY,GAEhC,MAAO,CAAEgW,KADIlc,KAAKyP,MAAMyX,gBAAgBhhB,GACzBnE,OACjB,CAEAqxB,OAAAA,CAAQltB,EAAYwI,GAAoD,IAAlD,KAAE3M,EAAI,KAAEma,GAAwCxN,EACpE,MAAMxK,EAAUlE,KAAKyP,MAAMoG,UAAU3P,EAAMlF,OACrCqyB,EAAcrzB,KAAKylB,QAAQ,CAAE1jB,OAAMma,QAAQhY,GACjDmV,EAAMiB,IAAI,UAAW+Y,EAAa,CAAEtxB,OAAMma,SAC1C,MAAMnc,GAAQ,IAAIc,EAAAA,IACfuU,OAAOlP,EAAMlF,OACbsR,OAAOpM,EAAM9F,QACbuL,OAAO0nB,GACVrzB,KAAKyP,MAAM4B,eAAetR,EAAO6P,EAAAA,GAAMlC,QAAQC,MAE/C3N,KAAKyP,MAAM2C,aACTrS,EAAMK,SAAW8F,EAAM9F,OACvBwP,EAAAA,GAAMlC,QAAQuC,QAEhBjQ,KAAKyP,MAAM6W,yBACb,CAEAiM,eAAAA,CAAgBpP,EAAoBiP,GAClC,MAAMC,EAA6B,GAC7BC,EAA0B,GAsBhC,OArBAtyB,KAAK0xB,SAAShtB,SAAS4uB,IACrB,MAAOtK,EAAU6I,GAAWyB,EAC5B,OAAQtK,GACN,KAAKlJ,KAAK4P,UACR4C,EAAa/kB,KAAKskB,GAClB,MACF,KAAK/R,KAAKmQ,aACRoC,EAAgB9kB,KAAKskB,GACrB,MACF,QACE5pB,MAAMC,KAAKib,EAAU6K,iBAAiBhF,IAAWtkB,SAASmB,IACxD,GAAIusB,EAAYmB,IAAI1tB,GAAO,CACzB,MAAM2tB,EAAUpB,EAAYxP,IAAI/c,GAChC2tB,GAASjmB,KAAKskB,EAChB,MACEO,EAAYxN,IAAI/e,EAAM,CAACgsB,GACzB,IAGN,IAEK,CAACQ,EAAiBC,EAC3B,EAGF,SAASnC,EACPpwB,EACAyB,EACAb,EACAS,GAEA,OAAKA,EAAOC,MAAMG,GAIXzB,EAAMS,QAAO,CAACkwB,EAAUpiB,KAC7B,IAAKA,EAAG5N,OAAQ,OAAOgwB,EACvB,GAAIpiB,EAAGvK,YAAcuK,EAAGvK,WAAWvC,GACjC,OAAOkvB,EAASnjB,KAAKe,GAEvB,MAAMpK,EAAUvD,EAAQ,CAAE,CAACa,GAASb,GAAU,CAAC,EAC/C,OAAO+vB,EAAShwB,OAAO4N,EAAG5N,OAAQ,IAAKwD,KAAYoK,EAAGvK,YAAa,GAClE,IAAIlD,EAAAA,IAVEd,CAWX,CAEA,SAASiwB,EAAcjwB,EAAcgC,GACnC,IAAI0xB,EAAU,GACd,IACE,IAAI5gB,EAAI9S,EAAM4R,IAAIvR,OAAS,EAC3ByS,GAAK,GAAK4gB,EAAQrzB,OAAS2B,EAAK3B,SAC9ByS,EACF,CACA,MAAMvE,EAAKvO,EAAM4R,IAAIkB,GACrB,GAAyB,iBAAdvE,EAAG5N,OAAqB,MACnC+yB,EAAUnlB,EAAG5N,OAAS+yB,CACxB,CACA,OAAOA,EAAQroB,OAAO,EAAIrJ,EAAK3B,UAAY2B,CAC7C,CAEA,SAASuH,EAAOzD,EAAYzE,GAC1B,KAAMyE,aAAgB6W,SAAU,OAAO,EACvC,MAAMN,EAAQhb,EAAOC,MAAMwE,GAE3B,QAAIuW,GAASA,EAAM8T,qBAAqBvsB,EAAAA,YAEjC,CACL,UACA,UACA,aACA,SACA,KACA,MACA,KACA,KACA,WACA,aACA,SACA,SACA,OACA,KACA,KACA,KACA,KACA,KACA,KACA,SACA,SACA,KACA,OACA,MACA,KACA,SACA,IACA,MACA,UACA,QACA,KACA,KACA,KACA,SACAyQ,SAASvO,EAAKtC,QAAQmwB,cAC1B,CAWA,MAAMC,EAAW,IAAIjU,QACrB,SAASiQ,EAAM9pB,GACb,OAAY,MAARA,IACC8tB,EAASJ,IAAI1tB,KAEK,QAAjBA,EAAKtC,QACPowB,EAAS/O,IAAI/e,GAAM,GAEnB8tB,EAAS/O,IAAI/e,EAAM8pB,EAAM9pB,EAAKQ,cAG3BstB,EAAS/Q,IAAI/c,GACtB,CAEA,SAAS2sB,EACPpxB,EACAyE,EACAwsB,EACAC,EACAF,GAGA,OAAIvsB,EAAK+tB,WAAa/tB,EAAK6pB,UAClB4C,EAAa9xB,QAAO,CAACT,EAAc8xB,IACjCA,EAAQhsB,EAAM9F,EAAOqB,IAC3B,IAAIP,EAAAA,IAELgF,EAAK+tB,WAAa/tB,EAAKoqB,aAClBhoB,MAAMC,KAAKrC,EAAKsC,YAAc,IAAI3H,QAAO,CAACT,EAAOqI,KACtD,IAAIyrB,EAAgBrB,EAClBpxB,EACAgH,EACAiqB,EACAC,EACAF,GAaF,OAXIhqB,EAAUwrB,WAAa/tB,EAAKoqB,eAC9B4D,EAAgBxB,EAAgB7xB,QAAO,CAACszB,EAAcjC,IAC7CA,EAAQzpB,EAA0B0rB,EAAc1yB,IACtDyyB,GACHA,GAAiBzB,EAAYxP,IAAIxa,IAAc,IAAI5H,QACjD,CAACszB,EAAcjC,IACNA,EAAQzpB,EAAW0rB,EAAc1yB,IAE1CyyB,IAGG9zB,EAAM4L,OAAOkoB,EAAc,GACjC,IAAIhzB,EAAAA,IAEF,IAAIA,EAAAA,EACb,CAEA,SAAS2wB,EAAiBhwB,GACxB,MAAO,CAACuyB,EAAgBh0B,EAAcqB,IAC7B+uB,EAAYpwB,EAAOyB,GAAQ,EAAMJ,EAE5C,CAiIA,SAAS2uB,EAAalqB,EAAY9F,EAAcqB,GAC9C,IAAK4uB,EAAcjwB,EAAO,MAAO,CAC/B,GACEuJ,EAAOzD,EAAMzE,KACZyE,EAAKsC,WAAW/H,OAAS,GAAKyF,aAAgBmuB,sBAE/C,OAAOj0B,EAAMW,OAAO,MAEtB,GAAIX,EAAMK,SAAW,GAAKyF,EAAKiqB,YAAa,CAC1C,IAAIA,EAA2BjqB,EAAKiqB,YACpC,KAAsB,MAAfA,GAAqB,CAC1B,GAAIxmB,EAAOwmB,EAAa1uB,GACtB,OAAOrB,EAAMW,OAAO,MAEtB,MAAM0b,EAAQhb,EAAOC,MAAMyuB,GAE3B,GAAI1T,GAASA,EAAM8T,qBAAqBrsB,EAAAA,GACtC,OAAO9D,EAAMW,OAAO,MAEtBovB,EAAcA,EAAYmE,UAC5B,CACF,CACF,CACA,OAAOl0B,CACT,uICtjBA,MAAMsZ,GAAQC,EAAAA,EAAAA,GAAO,kBAEf4a,EAAW,OAAOvjB,KAAKC,UAAUC,UAAY,UAAY,UA+C/D,MAAMoH,UAAiBlJ,EAAAA,EAGrB,YAAOqN,CAAM+X,EAAoBC,GAC/B,OACG,CAAC,SAAU,UAAW,UAAW,YAAsB7sB,MAAMuE,KACnDsoB,EAAQtoB,KAASqoB,EAAIroB,IAAyB,OAAjBsoB,EAAQtoB,OAK3CsoB,EAAQtoB,MAAQqoB,EAAIroB,KAAOsoB,EAAQtoB,MAAQqoB,EAAIE,MACxD,CAIAlvB,WAAAA,CAAYsK,EAAcC,GACxBzO,MAAMwO,EAAOC,GACb1P,KAAKs0B,SAAW,CAAC,EAEjBloB,OAAOC,KAAKrM,KAAK0P,QAAQ4kB,UAAU5vB,SAASvD,IAEtCnB,KAAK0P,QAAQ4kB,SAASnzB,IAExBnB,KAAKuQ,WAAWvQ,KAAK0P,QAAQ4kB,SAASnzB,GACxC,IAEFnB,KAAKuQ,WAAW,CAAEzE,IAAK,QAAS4E,SAAU,MAAQ1Q,KAAKu0B,aACvDv0B,KAAKuQ,WACH,CAAEzE,IAAK,QAAS0oB,QAAS,KAAMtd,QAAS,KAAMud,OAAQ,OACtD,SAEE,WAAW9jB,KAAKC,UAAU4E,YAE5BxV,KAAKuQ,WACH,CAAEzE,IAAK,aACP,CAAEqK,WAAW,GACbnW,KAAK00B,iBAEP10B,KAAKuQ,WACH,CAAEzE,IAAK,UACP,CAAEqK,WAAW,GACbnW,KAAK20B,gBAGP30B,KAAKuQ,WACH,CAAEzE,IAAK,aACP,CAAEqK,WAAW,EAAMye,OAAQ,QAC3B50B,KAAK00B,iBAEP10B,KAAKuQ,WACH,CAAEzE,IAAK,UACP,CAAEqK,WAAW,EAAM+I,OAAQ,QAC3Blf,KAAK20B,eAGT30B,KAAKuQ,WACH,CAAEzE,IAAK,aACP,CAAEqK,WAAW,GACbnW,KAAK60B,mBAEP70B,KAAKuQ,WACH,CAAEzE,IAAK,UACP,CAAEqK,WAAW,GACbnW,KAAK60B,mBAEP70B,KAAKuQ,WACH,CACEzE,IAAK,YACL2oB,OAAQ,KACRvd,QAAS,KACTsd,QAAS,KACT9jB,SAAU,MAEZ,CAAEyF,WAAW,EAAMvQ,OAAQ,GAC3B5F,KAAK00B,iBAEP10B,KAAK80B,QACP,CAEAvkB,UAAAA,CACEwkB,GAOA,IANAjyB,EAEmD3C,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,CAAC,EACvDkU,EAEmDlU,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,CAAC,EAEvD,MAAMi0B,EA6nBV,SAAmBA,GACjB,GAAuB,iBAAZA,GAA2C,iBAAZA,EACxCA,EAAU,CAAEtoB,IAAKsoB,OACZ,IAAuB,iBAAZA,EAGhB,OAAO,KAFPA,EAAU,IAAKA,EAGjB,CAKA,OAJIA,EAAQ5jB,WACV4jB,EAAQF,GAAYE,EAAQ5jB,gBACrB4jB,EAAQ5jB,UAEV4jB,CACT,CA1oBoBpC,CAAU+C,GACX,MAAXX,GAImB,mBAAZtxB,IACTA,EAAU,CAAEuR,QAASvR,IAEA,mBAAZuR,IACTA,EAAU,CAAEA,aAEDpM,MAAMmC,QAAQgqB,EAAQtoB,KAAOsoB,EAAQtoB,IAAM,CAACsoB,EAAQtoB,MAC5DpH,SAASoH,IACZ,MAAMkpB,EAAgB,IACjBZ,EACHtoB,SACGhJ,KACAuR,GAELrU,KAAKs0B,SAASU,EAAclpB,KAAO9L,KAAKs0B,SAASU,EAAclpB,MAAQ,GACvE9L,KAAKs0B,SAASU,EAAclpB,KAAKyB,KAAKynB,EAAc,KAlBpD3b,EAAM4J,KAAK,4CAA6CmR,EAoB5D,CAEAU,MAAAA,GACE90B,KAAKyP,MAAMpQ,KAAK2K,iBAAiB,WAAYmqB,IAC3C,GAAIA,EAAIne,kBAAoBme,EAAIpe,YAAa,OAM7C,GADkB,MAAhBoe,EAAIc,UAAgC,UAAZd,EAAIroB,KAA+B,cAAZqoB,EAAIroB,KACpC,OAEjB,MAGM0nB,GAHYxzB,KAAKs0B,SAASH,EAAIroB,MAAQ,IAAIH,OAC9C3L,KAAKs0B,SAASH,EAAIE,QAAU,IAELn0B,QAAQk0B,GAC/Bnc,EAASmE,MAAM+X,EAAKC,KAEtB,GAAuB,IAAnBZ,EAAQpzB,OAAc,OAE1B,MAAMH,EAAO2P,EAAAA,GAAMpD,KAAK2nB,EAAIvxB,QAAQ,GACpC,GAAI3C,GAAQA,EAAKmB,SAAWpB,KAAKyP,MAAMrO,OAAQ,OAC/C,MAAM8E,EAAQlG,KAAKyP,MAAM8G,eACzB,GAAa,MAATrQ,IAAkBlG,KAAKyP,MAAM8W,WAAY,OAC7C,MAAOlkB,EAAMuD,GAAU5F,KAAKyP,MAAMuX,QAAQ9gB,EAAMlF,QACzCk0B,EAAWC,GAAen1B,KAAKyP,MAAMsX,QAAQ7gB,EAAMlF,QACnDo0B,EAASC,GACG,IAAjBnvB,EAAM9F,OACF,CAAC80B,EAAWC,GACZn1B,KAAKyP,MAAMsX,QAAQ7gB,EAAMlF,MAAQkF,EAAM9F,QACvCk1B,EACJJ,aAAqBtxB,EAAAA,SACjBsxB,EAAUv0B,QAAQyK,MAAM,EAAG+pB,GAC3B,GACAI,EACJH,aAAmBxxB,EAAAA,SAAWwxB,EAAQz0B,QAAQyK,MAAMiqB,GAAa,GAC7DG,EAAa,CACjBrf,UAA4B,IAAjBjQ,EAAM9F,OAEjBq1B,MAAwB,IAAjBvvB,EAAM9F,QAAgBiC,EAAKjC,UAAY,EAC9CoB,OAAQxB,KAAKyP,MAAMoG,UAAU3P,GAC7B7D,OACAuD,SACAgvB,OAAQU,EACRpW,OAAQqW,EACRpnB,MAAOgmB,GAESX,EAAQjsB,MAAM6sB,IAC9B,GACuB,MAArBA,EAAQje,WACRie,EAAQje,YAAcqf,EAAWrf,UAEjC,OAAO,EAET,GAAqB,MAAjBie,EAAQqB,OAAiBrB,EAAQqB,QAAUD,EAAWC,MACxD,OAAO,EAET,GAAsB,MAAlBrB,EAAQxuB,QAAkBwuB,EAAQxuB,SAAW4vB,EAAW5vB,OAC1D,OAAO,EAET,GAAIqC,MAAMmC,QAAQgqB,EAAQ5yB,SAExB,GAAI4yB,EAAQ5yB,OAAOk0B,OAAOv0B,GAAoC,MAA3Bq0B,EAAWh0B,OAAOL,KACnD,OAAO,OAEJ,GAA8B,iBAAnBizB,EAAQ5yB,SAGrB4K,OAAOC,KAAK+nB,EAAQ5yB,QAAQk0B,OAAOv0B,IAEL,IAAzBizB,EAAQ5yB,OAAOL,GACiB,MAA3Bq0B,EAAWh0B,OAAOL,IAEE,IAAzBizB,EAAQ5yB,OAAOL,GACiB,MAA3Bq0B,EAAWh0B,OAAOL,IAEpBse,EAAAA,EAAAA,GAAQ2U,EAAQ5yB,OAAOL,GAAOq0B,EAAWh0B,OAAOL,MAGzD,OAAO,EAGX,QAAsB,MAAlBizB,EAAQQ,SAAmBR,EAAQQ,OAAOjkB,KAAK6kB,EAAWZ,SAGxC,MAAlBR,EAAQlV,SAAmBkV,EAAQlV,OAAOvO,KAAK6kB,EAAWtW,UAII,IAA3DkV,EAAQ/f,QAAQC,KAAKtU,KAAMkG,EAAOsvB,EAAYpB,GAAiB,KAGtED,EAAI/lB,gBACN,GAEJ,CAEAsmB,eAAAA,CAAgBxuB,EAAcpD,GAE5B,MAAM1C,EAAS,kCAAkCuQ,KAAK7N,EAAQ8xB,QAC1D,EACA,EACJ,GAAoB,IAAhB1uB,EAAMlF,OAAehB,KAAKyP,MAAMoX,aAAe,EAAG,OACtD,IAAI3iB,EAAU,CAAC,EACf,MAAO7B,GAAQrC,KAAKyP,MAAMuX,QAAQ9gB,EAAMlF,OACxC,IAAIjB,GAAQ,IAAIc,EAAAA,IAAQuU,OAAOlP,EAAMlF,MAAQZ,GAAQkS,OAAOlS,GAC5D,GAAuB,IAAnB0C,EAAQ8C,OAAc,CAExB,MAAOd,GAAQ9E,KAAKyP,MAAMuX,QAAQ9gB,EAAMlF,MAAQ,GAChD,GAAI8D,KAE0B,UAA1BA,EAAKH,QAAQrB,UAAwBwB,EAAK1E,UAAY,GAClC,CAEpB,MAAMu1B,EAAatzB,EAAK6B,UAClB0xB,EAAc51B,KAAKyP,MAAMoG,UAAU3P,EAAMlF,MAAQ,EAAG,GAE1D,GADAkD,EAAUgI,EAAAA,GAAaC,KAAKwpB,EAAYC,IAAgB,CAAC,EACrDxpB,OAAOC,KAAKnI,GAAS9D,OAAS,EAAG,CAEnC,MAAMy1B,GAAc,IAAIh1B,EAAAA,IAErBuU,OAAOlP,EAAMlF,MAAQqB,EAAKjC,SAAW,GACrCgV,OAAO,EAAGlR,GACbnE,EAAQA,EAAMkS,QAAQ4jB,EACxB,CACF,CAEJ,CACA71B,KAAKyP,MAAM4B,eAAetR,EAAO6P,EAAAA,GAAMlC,QAAQC,MAC/C3N,KAAKyP,MAAM2W,OACb,CAEAuO,YAAAA,CAAazuB,EAAcpD,GAEzB,MAAM1C,EAAS,kCAAkCuQ,KAAK7N,EAAQoc,QAC1D,EACA,EACJ,GAAIhZ,EAAMlF,OAAShB,KAAKyP,MAAMoX,YAAczmB,EAAQ,OACpD,IAAI8D,EAAU,CAAC,EACf,MAAO7B,GAAQrC,KAAKyP,MAAMuX,QAAQ9gB,EAAMlF,OACxC,IAAIjB,GAAQ,IAAIc,EAAAA,IAAQuU,OAAOlP,EAAMlF,OAAOsR,OAAOlS,GAEnD,GAAI0C,EAAQ8C,QAAUvD,EAAKjC,SAAW,EAAG,CACvC,MAAOiD,GAAQrD,KAAKyP,MAAMuX,QAAQ9gB,EAAMlF,MAAQ,GAChD,GAAIqC,EAAM,CAER,MAAMsyB,EAAatzB,EAAK6B,UAClB4xB,EAAc91B,KAAKyP,MAAMoG,UAAU3P,EAAMlF,MAAO,GACtDkD,EAAUgI,EAAAA,GAAaC,KAAKwpB,EAAYG,IAAgB,CAAC,EACrD1pB,OAAOC,KAAKnI,GAAS9D,OAAS,IAChCL,EAAQA,EAAMqV,OAAO/R,EAAKjD,SAAW,GAAGgV,OAAO,EAAGlR,GAEtD,CACF,CACAlE,KAAKyP,MAAM4B,eAAetR,EAAO6P,EAAAA,GAAMlC,QAAQC,MAC/C3N,KAAKyP,MAAM2W,OACb,CAEAyO,iBAAAA,CAAkB3uB,GAChByP,EAAY,CAAEzP,QAAOuJ,MAAOzP,KAAKyP,QACjCzP,KAAKyP,MAAM2W,OACb,CAEAmO,WAAAA,CAAYruB,EAAcpD,GACxB,MAAMub,EAAcjS,OAAOC,KAAKvJ,EAAQtB,QAAQhB,QAC9C,CAAC0D,EAAkC1C,KAE/BxB,KAAKyP,MAAMrO,OAAOC,MAAMG,EAAQF,EAAAA,MAAMC,SACrC0G,MAAMmC,QAAQtH,EAAQtB,OAAOA,MAE9B0C,EAAQ1C,GAAUsB,EAAQtB,OAAOA,IAE5B0C,IAET,CAAC,GAEGnE,GAAQ,IAAIc,EAAAA,IACfuU,OAAOlP,EAAMlF,OACbsR,OAAOpM,EAAM9F,QACbM,OAAO,KAAM2d,GAChBre,KAAKyP,MAAM4B,eAAetR,EAAO6P,EAAAA,GAAMlC,QAAQC,MAC/C3N,KAAKyP,MAAM2C,aAAalM,EAAMlF,MAAQ,EAAG4O,EAAAA,GAAMlC,QAAQuC,QACvDjQ,KAAKyP,MAAM2W,OACb,EAGF,MAAM2P,EAAkC,CACtCzB,SAAU,CACRrD,KAAM+E,EAAkB,QACxBpF,OAAQoF,EAAkB,UAC1BlF,UAAWkF,EAAkB,aAC7Bpa,OAAQ,CAEN9P,IAAK,MACLtK,OAAQ,CAAC,aAAc,SAAU,QACjC6S,OAAAA,CAAQnO,EAAOpD,GACb,SAAIA,EAAQqT,WAAgC,IAAnBrT,EAAQ8C,UACjC5F,KAAKyP,MAAMjO,OAAO,SAAU,KAAMoO,EAAAA,GAAMlC,QAAQC,OACzC,EACT,GAEFsoB,QAAS,CACPnqB,IAAK,MACL4E,UAAU,EACVlP,OAAQ,CAAC,aAAc,SAAU,QAEjC6S,OAAAA,CAAQnO,EAAOpD,GACb,SAAIA,EAAQqT,WAAgC,IAAnBrT,EAAQ8C,UACjC5F,KAAKyP,MAAMjO,OAAO,SAAU,KAAMoO,EAAAA,GAAMlC,QAAQC,OACzC,EACT,GAEF,oBAAqB,CACnB7B,IAAK,YACLqK,WAAW,EACXzF,SAAU,KACV8jB,QAAS,KACTtd,QAAS,KACTud,OAAQ,KACRjzB,OAAQ,CAAC,SAAU,QACnBoE,OAAQ,EACRyO,OAAAA,CAAQnO,EAAOpD,GACgB,MAAzBA,EAAQtB,OAAOoa,OACjB5b,KAAKyP,MAAMjO,OAAO,SAAU,KAAMoO,EAAAA,GAAMlC,QAAQC,MAChB,MAAvB7K,EAAQtB,OAAO8a,MACxBtc,KAAKyP,MAAMjO,OAAO,QAAQ,EAAOoO,EAAAA,GAAMlC,QAAQC,KAEnD,GAEF,oBAAqBuoB,GAAqB,GAC1C,qBAAsBA,GAAqB,GAC3C,aAAc,CACZpqB,IAAK,MACL4E,UAAU,EACVyF,WAAW,EACXye,OAAQ,MACRvgB,OAAAA,CAAQnO,GACNlG,KAAKyP,MAAMsO,WAAW7X,EAAMlF,MAAQ,EAAG,EAAG4O,EAAAA,GAAMlC,QAAQC,KAC1D,GAEFwoB,IAAK,CACHrqB,IAAK,MACLuI,OAAAA,CAAQnO,EAAOpD,GACb,GAAIA,EAAQtB,OAAO+vB,MAAO,OAAO,EACjCvxB,KAAKyP,MAAMyS,QAAQ1Q,SACnB,MAAMzR,GAAQ,IAAIc,EAAAA,IACfuU,OAAOlP,EAAMlF,OACbsR,OAAOpM,EAAM9F,QACbM,OAAO,MAIV,OAHAV,KAAKyP,MAAM4B,eAAetR,EAAO6P,EAAAA,GAAMlC,QAAQC,MAC/C3N,KAAKyP,MAAMyS,QAAQ1Q,SACnBxR,KAAKyP,MAAM2C,aAAalM,EAAMlF,MAAQ,EAAG4O,EAAAA,GAAMlC,QAAQuC,SAChD,CACT,GAEF,yBAA0B,CACxBnE,IAAK,QACLqK,WAAW,EACX3U,OAAQ,CAAC,cACTi0B,OAAO,EACPphB,OAAAA,GACErU,KAAKyP,MAAMjO,OAAO,cAAc,EAAOoO,EAAAA,GAAMlC,QAAQC,KACvD,GAEF,mBAAoB,CAClB7B,IAAK,QACLqK,WAAW,EACX3U,OAAQ,CAAC,QACTi0B,OAAO,EACPphB,OAAAA,CAAQnO,EAAOpD,GACb,MAAMoB,EAAmC,CAAEoY,MAAM,GAC7CxZ,EAAQtB,OAAOoa,SACjB1X,EAAQ0X,QAAS,GAEnB5b,KAAKyP,MAAMuO,WACT9X,EAAMlF,MACNkF,EAAM9F,OACN8D,EACA0L,EAAAA,GAAMlC,QAAQC,KAElB,GAEF,kBAAmB,CACjB7B,IAAK,QACLqK,WAAW,EACX3U,OAAQ,CAAE8a,KAAM,WAChBjI,OAAAA,CAAQnO,GACN,MAAO7D,EAAMuD,GAAU5F,KAAKyP,MAAMuX,QAAQ9gB,EAAMlF,OAC1CkD,EAAU,IAEX7B,EAAK6B,UACRoY,KAAM,WAEFvc,GAAQ,IAAIc,EAAAA,IACfuU,OAAOlP,EAAMlF,OACbN,OAAO,KAAMwD,GAEbkR,OAAO/S,EAAKjC,SAAWwF,EAAS,GAChCwP,OAAO,EAAG,CAAEkH,KAAM,cACrBtc,KAAKyP,MAAM4B,eAAetR,EAAO6P,EAAAA,GAAMlC,QAAQC,MAC/C3N,KAAKyP,MAAM2C,aAAalM,EAAMlF,MAAQ,EAAG4O,EAAAA,GAAMlC,QAAQuC,QACvDjQ,KAAKyP,MAAM6W,yBACb,GAEF,eAAgB,CACdxa,IAAK,QACLqK,WAAW,EACX3U,OAAQ,CAAC,UACT0d,OAAQ,KACR7K,OAAAA,CAAQnO,EAAOpD,GACb,MAAOT,EAAMuD,GAAU5F,KAAKyP,MAAMuX,QAAQ9gB,EAAMlF,OAC1CjB,GAAQ,IAAIc,EAAAA,IACfuU,OAAOlP,EAAMlF,OACbN,OAAO,KAAMoC,EAAQtB,QAErB4T,OAAO/S,EAAKjC,SAAWwF,EAAS,GAChCwP,OAAO,EAAG,CAAEghB,OAAQ,OACvBp2B,KAAKyP,MAAM4B,eAAetR,EAAO6P,EAAAA,GAAMlC,QAAQC,MAC/C3N,KAAKyP,MAAM2C,aAAalM,EAAMlF,MAAQ,EAAG4O,EAAAA,GAAMlC,QAAQuC,QACvDjQ,KAAKyP,MAAM6W,yBACb,GAEF,kBAAmB,CACjBxa,IAAK,YACLtK,OAAQ,CAAC,SACT2U,WAAW,EACXvQ,OAAQ,EACRyO,OAAAA,GAAW,GAEb,eAAgB,CACdvI,IAAK,SACLtK,OAAQ,CAAC,SACT2U,WAAW,EACX+I,OAAQ,KACR7K,OAAAA,GAAW,GAEb,cAAe,CACbvI,IAAK,QACL4E,SAAU,KACVlP,OAAQ,CAAC,SACT6S,OAAAA,CAAQnO,GACN,MAAM1G,EAASQ,KAAKyP,MAAMwX,UAAU,SACpC,GAAIznB,EAAQ,CAEV,MAAO+xB,EAAO8E,EAAKC,EAAM1wB,GAAUpG,EAAO+2B,SAASrwB,GAC7ClE,EA6ShB,SAAmBw0B,EAAiBH,EAAWC,EAAY1wB,GACzD,OAAgB,MAAZywB,EAAIvxB,MAA4B,MAAZuxB,EAAIhzB,KACT,MAAbizB,EAAKxxB,MAA6B,MAAbwxB,EAAKjzB,KACV,IAAXuC,GAAgB,EAAI,EAET,MAAb0wB,EAAKxxB,MAAgB,EAAI,EAElB,MAAZuxB,EAAIvxB,MACE,EAEM,MAAZuxB,EAAIhzB,KACC,EAEF,IACT,CA3TwBozB,CAAUlF,EAAO8E,EAAKC,EAAM1wB,GAC1C,GAAa,MAAT5D,EAAe,OACnB,IAAIhB,EAAQuwB,EAAM3rB,SAClB,GAAI5D,EAAQ,EAAG,CACb,MAAMjC,GAAQ,IAAIc,EAAAA,IAAQuU,OAAOpU,GAAON,OAAO,MAC/CV,KAAKyP,MAAM4B,eAAetR,EAAO6P,EAAAA,GAAMlC,QAAQC,MAC/C3N,KAAKyP,MAAM2C,aACTlM,EAAMlF,MAAQ,EACdkF,EAAM9F,OACNwP,EAAAA,GAAMlC,QAAQuC,OAElB,MAAO,GAAIjO,EAAQ,EAAG,CACpBhB,GAASuwB,EAAMnxB,SACf,MAAML,GAAQ,IAAIc,EAAAA,IAAQuU,OAAOpU,GAAON,OAAO,MAC/CV,KAAKyP,MAAM4B,eAAetR,EAAO6P,EAAAA,GAAMlC,QAAQC,MAC/C3N,KAAKyP,MAAM2C,aAAapR,EAAO4O,EAAAA,GAAMlC,QAAQC,KAC/C,CACF,CACF,GAEF,YAAa,CACX7B,IAAK,MACL4E,SAAU,KACVlP,OAAQ,CAAC,SACT6S,OAAAA,CAAQnO,EAAOpD,GACb,MAAM,MAAEqL,EAAO9L,KAAMi0B,GAASxzB,EACxB8C,EAAS0wB,EAAK1wB,OAAO5F,KAAKyP,MAAMrO,QAClC+M,EAAMuC,SACR1Q,KAAKyP,MAAM2C,aAAaxM,EAAS,EAAGgK,EAAAA,GAAMlC,QAAQC,MAElD3N,KAAKyP,MAAM2C,aAAaxM,EAAS0wB,EAAKl2B,SAAUwP,EAAAA,GAAMlC,QAAQC,KAElE,GAEF,gBAAiB,CACf7B,IAAK,IACL4E,SAAU,KACVyF,WAAW,EACX3U,OAAQ,CACN,cAAc,EACdk1B,YAAY,EACZnF,OAAO,GAETqD,OAAQ,kCACRvgB,OAAAA,CAAQnO,EAAOpD,GACb,GAAuC,MAAnC9C,KAAKyP,MAAMrO,OAAOC,MAAM,QAAiB,OAAO,EACpD,MAAM,OAAEjB,GAAW0C,EAAQ8xB,QACpBvyB,EAAMuD,GAAU5F,KAAKyP,MAAMuX,QAAQ9gB,EAAMlF,OAChD,GAAI4E,EAASxF,EAAQ,OAAO,EAC5B,IAAIO,EACJ,OAAQmC,EAAQ8xB,OAAOnQ,QACrB,IAAK,KACL,IAAK,MACH9jB,EAAQ,YACR,MACF,IAAK,MACHA,EAAQ,UACR,MACF,IAAK,IACL,IAAK,IACHA,EAAQ,SACR,MACF,QACEA,EAAQ,UAEZX,KAAKyP,MAAMqP,WAAW5Y,EAAMlF,MAAO,IAAK4O,EAAAA,GAAMlC,QAAQC,MACtD3N,KAAKyP,MAAMyS,QAAQ1Q,SACnB,MAAMzR,GAAQ,IAAIc,EAAAA,IACfuU,OAAOlP,EAAMlF,MAAQ4E,GACrB0M,OAAOlS,EAAS,GAEhBgV,OAAO/S,EAAKjC,SAAW,EAAIwF,GAC3BwP,OAAO,EAAG,CAAEkH,KAAM3b,IAIrB,OAHAX,KAAKyP,MAAM4B,eAAetR,EAAO6P,EAAAA,GAAMlC,QAAQC,MAC/C3N,KAAKyP,MAAMyS,QAAQ1Q,SACnBxR,KAAKyP,MAAM2C,aAAalM,EAAMlF,MAAQZ,EAAQwP,EAAAA,GAAMlC,QAAQuC,SACrD,CACT,GAEF,YAAa,CACXnE,IAAK,QACLqK,WAAW,EACX3U,OAAQ,CAAC,cACTozB,OAAQ,KACR1V,OAAQ,QACR7K,OAAAA,CAAQnO,GACN,MAAO7D,EAAMuD,GAAU5F,KAAKyP,MAAMuX,QAAQ9gB,EAAMlF,OAChD,IAAI21B,EAAW,EACXC,EAAMv0B,EACV,KACS,MAAPu0B,GACAA,EAAIx2B,UAAY,GAChBw2B,EAAI1yB,UAAU,eAMd,GAHA0yB,EAAMA,EAAI9xB,KACV6xB,GAAY,EAERA,GAAY,EAAG,CACjB,MAAM52B,GAAQ,IAAIc,EAAAA,IAEfuU,OAAOlP,EAAMlF,MAAQqB,EAAKjC,SAAWwF,EAAS,GAC9CwP,OAAO,EAAG,CAAE,aAAc,OAC1B9C,OAAO,GAGV,OAFAtS,KAAKyP,MAAM4B,eAAetR,EAAO6P,EAAAA,GAAMlC,QAAQC,MAC/C3N,KAAKyP,MAAM2C,aAAalM,EAAMlF,MAAQ,EAAG4O,EAAAA,GAAMlC,QAAQuC,SAChD,CACT,CAEF,OAAO,CACT,GAEF,aAAc4mB,EAAsB,aAAa,GACjD,mBAAoBA,EAAsB,aAAa,GACvD,cAAeA,EAAsB,cAAc,GACnD,oBAAqBA,EAAsB,cAAc,GACzD,aAAcC,GAAsB,GACpC,WAAYA,GAAsB,KAMtC,SAASZ,EAAqBta,GAC5B,MAAO,CACL9P,IAAK,MACL4E,UAAWkL,EACXpa,OAAQ,CAAE,cAAc,GACxB6S,OAAAA,CAAQnO,EAAK0D,GAAa,IAAX,MAAEuE,GAAOvE,EACtB,MAAM8iB,EAAY1sB,KAAKyP,MAAMrO,OAAOC,MAAM,eAEpC,IAAE01B,GAAQrK,EAChB,GAAqB,IAAjBxmB,EAAM9F,SAAiB+N,EAAMuC,SAG/B,OAFA1Q,KAAKyP,MAAMqP,WAAW5Y,EAAMlF,MAAO+1B,EAAKnnB,EAAAA,GAAMlC,QAAQC,WACtD3N,KAAKyP,MAAM2C,aAAalM,EAAMlF,MAAQ+1B,EAAI32B,OAAQwP,EAAAA,GAAMlC,QAAQuC,QAIlE,MAAMpO,EACa,IAAjBqE,EAAM9F,OACFJ,KAAKyP,MAAMzC,SAAS9G,EAAMlF,MAAO,GACjChB,KAAKyP,MAAMzC,SAAS9G,GAC1B,IAAI,MAAElF,EAAK,OAAEZ,GAAW8F,EACxBrE,EAAM6C,SAAQ,CAACrC,EAAMwQ,KACf+I,GACFvZ,EAAKV,SAAS,EAAGo1B,GACP,IAANlkB,EACF7R,GAAS+1B,EAAI32B,OAEbA,GAAU22B,EAAI32B,QAGPiC,EAAK4B,QAAQ+yB,YAAY9T,WAAW6T,KAC7C10B,EAAKtB,SAAS,EAAGg2B,EAAI32B,QACX,IAANyS,EACF7R,GAAS+1B,EAAI32B,OAEbA,GAAU22B,EAAI32B,OAElB,IAEFJ,KAAKyP,MAAMpI,OAAOuI,EAAAA,GAAMlC,QAAQC,MAChC3N,KAAKyP,MAAM2C,aAAapR,EAAOZ,EAAQwP,EAAAA,GAAMlC,QAAQuC,OACvD,EAEJ,CAEA,SAAS4mB,EACP/qB,EACA4E,GAGA,MAAO,CACL5E,MACA4E,WACA+jB,OAAQ,KACR,CALoB,cAAR3oB,EAAsB,SAAW,UAKpC,KACTuI,OAAAA,CAAQnO,GACN,IAAI,MAAElF,GAAUkF,EACJ,eAAR4F,IACF9K,GAASkF,EAAM9F,OAAS,GAE1B,MAAOK,GAAQT,KAAKyP,MAAMsX,QAAQ/lB,GAClC,QAAMP,aAAgBkD,EAAAA,YACV,cAARmI,EACE4E,EACF1Q,KAAKyP,MAAM2C,aACTlM,EAAMlF,MAAQ,EACdkF,EAAM9F,OAAS,EACfwP,EAAAA,GAAMlC,QAAQC,MAGhB3N,KAAKyP,MAAM2C,aAAalM,EAAMlF,MAAQ,EAAG4O,EAAAA,GAAMlC,QAAQC,MAEhD+C,EACT1Q,KAAKyP,MAAM2C,aACTlM,EAAMlF,MACNkF,EAAM9F,OAAS,EACfwP,EAAAA,GAAMlC,QAAQC,MAGhB3N,KAAKyP,MAAM2C,aACTlM,EAAMlF,MAAQkF,EAAM9F,OAAS,EAC7BwP,EAAAA,GAAMlC,QAAQC,MAGX,GACT,EAEJ,CAEA,SAASqoB,EAAkBx0B,GACzB,MAAO,CACLsK,IAAKtK,EAAO,GACZgP,UAAU,EACV6D,OAAAA,CAAQnO,EAAOpD,GACb9C,KAAKyP,MAAMjO,OAAOA,GAASsB,EAAQtB,OAAOA,GAASoO,EAAAA,GAAMlC,QAAQC,KACnE,EAEJ,CAEA,SAASmpB,EAAsBG,GAC7B,MAAO,CACLnrB,IAAKmrB,EAAK,UAAY,YACtB9gB,WAAW,EACX3U,OAAQ,CAAC,SACT6S,OAAAA,CAAQnO,EAAOpD,GAEb,MAAMgJ,EAAMmrB,EAAK,OAAS,OACpBX,EAAOxzB,EAAQT,KACf60B,EAAYZ,EAAKlzB,OAAO0I,GAC9B,GAAiB,MAAborB,GACF,GAAmC,cAA/BA,EAAUvyB,QAAQrB,SAA0B,CAE9C,IAAI6zB,EAAaD,EAAUj1B,SAASO,KAChCo0B,EAAMN,EACV,KAAmB,MAAZM,EAAI9xB,MAET8xB,EAAMA,EAAI9xB,KACVqyB,EAAaA,EAAW9zB,KAE1B,MAAMrC,EACJm2B,EAAWvxB,OAAO5F,KAAKyP,MAAMrO,QAC7BK,KAAKC,IAAIoB,EAAQ8C,OAAQuxB,EAAW/2B,SAAW,GACjDJ,KAAKyP,MAAM2C,aAAapR,EAAO,EAAG4O,EAAAA,GAAMlC,QAAQC,KAClD,MACK,CAEL,MAAMypB,EAAad,EAAK/E,QAAQzlB,GACd,MAAdsrB,IACEH,EACFj3B,KAAKyP,MAAM2C,aACTglB,EAAWxxB,OAAO5F,KAAKyP,MAAMrO,QAAUg2B,EAAWh3B,SAAW,EAC7D,EACAwP,EAAAA,GAAMlC,QAAQC,MAGhB3N,KAAKyP,MAAM2C,aACTglB,EAAWxxB,OAAO5F,KAAKyP,MAAMrO,QAC7B,EACAwO,EAAAA,GAAMlC,QAAQC,MAItB,CACA,OAAO,CACT,EAEJ,CAkBA,SAASgI,EAAW7H,GAAmD,IAAlD,MAAE2B,EAAK,MAAEvJ,GAAuC4H,EACnE,MAAMjM,EAAQ4N,EAAMzC,SAAS9G,GAC7B,IAAIhC,EAAU,CAAC,EACf,GAAIrC,EAAMzB,OAAS,EAAG,CACpB,MAAMi3B,EAAex1B,EAAM,GAAGqC,UACxBozB,EAAcz1B,EAAMA,EAAMzB,OAAS,GAAG8D,UAC5CA,EAAUgI,EAAAA,GAAaC,KAAKmrB,EAAaD,IAAiB,CAAC,CAC7D,CACA5nB,EAAMsO,WAAW7X,EAAO0J,EAAAA,GAAMlC,QAAQC,MAClCvB,OAAOC,KAAKnI,GAAS9D,OAAS,GAChCqP,EAAMuO,WAAW9X,EAAMlF,MAAO,EAAGkD,EAAS0L,EAAAA,GAAMlC,QAAQC,MAE1D8B,EAAM2C,aAAalM,EAAMlF,MAAO4O,EAAAA,GAAMlC,QAAQuC,OAChD,CAlLAgI,EAAS1D,SAAWwhB,wGC5nBpB,IAMkBwB,EAAIC,EANlBC,EAAWrrB,OAAO3H,OAClBizB,EAAYtrB,OAAOurB,eACnBC,EAAmBxrB,OAAOyrB,yBAC1BC,EAAoB1rB,OAAO2rB,oBAC3BC,EAAe5rB,OAAO6rB,eACtBC,EAAe9rB,OAAO8jB,UAAUiI,eAsxBhCC,EA1wBU,EAACZ,EAAKa,EAAYz1B,KAAYA,EAAgB,MAAP40B,EAAcC,EAASO,EAAaR,IAAQ,CAAC,EARhF,EAACc,EAAIpwB,EAAMqwB,EAAQC,KACnC,GAAItwB,GAAwB,iBAATA,GAAqC,mBAATA,EAC7C,IAAK,IAAI4D,KAAOgsB,EAAkB5vB,GAC3BgwB,EAAa5jB,KAAKgkB,EAAIxsB,IAKoE2sB,YAL5D3sB,GACjC4rB,EAAUY,EAAIxsB,EAAK,CAAE8W,IAAK,IAAM1a,EAAK4D,GAAM4sB,aAAcF,EAAOZ,EAAiB1vB,EAAM4D,KAAS0sB,EAAKE,aAE3G,OAAOJ,CAAE,EAE0FG,CAKpFjB,GAAQA,EAAImB,WAA8E/1B,EAAjE80B,EAAU90B,EAAQ,UAAW,CAAEjC,MAAO62B,EAAKkB,YAAY,IAC/FlB,IAowBqBoB,EArxBLrB,EAqBY,CAC5B,oEAAoEh4B,EAASs5B,GAC3E,IAAIC,GAAe,EAGnB,SAASC,EAAUC,EAAOC,EAAOC,EAAYC,EAASC,GACpD,GAAIJ,IAAUC,EACZ,OAAID,EACK,CAAC,CAJG,EAIUA,IAEhB,GAET,GAAkB,MAAdE,EAAoB,CACtB,IAAIG,EA6pBR,SAA+B/Z,EAAS5Y,EAASwyB,GAC/C,IAAI1Z,EAAiC,iBAAf0Z,EAA0B,CAAEl4B,MAAOk4B,EAAY94B,OAAQ,GAAM84B,EAAW1Z,SAC1F9H,EAAiC,iBAAfwhB,EAA0B,KAAOA,EAAWxhB,SAC9D4hB,EAAYha,EAAQlf,OACpBm5B,EAAY7yB,EAAQtG,OACxB,GAAwB,IAApBof,EAASpf,SAA8B,OAAbsX,GAAyC,IAApBA,EAAStX,QAAe,CACzE,IAAIo5B,EAAYha,EAASxe,MACrBy4B,EAAYna,EAAQlU,MAAM,EAAGouB,GAC7BE,EAAWpa,EAAQlU,MAAMouB,GACzBG,EAAiBjiB,EAAWA,EAAS1W,MAAQ,KAE3C44B,EAAYJ,EAAYD,EAAYD,EACxC,IAAuB,OAAnBK,GAA2BA,IAAmBC,MAG9CA,EAAY,GAAKA,EAAYL,GAAjC,CAGA,IAAIM,EAAYnzB,EAAQ0E,MAAM,EAAGwuB,GAEjC,IADIE,EAAWpzB,EAAQ0E,MAAMwuB,MACZF,EAAjB,CAGA,IAAIK,EAAet4B,KAAKC,IAAI83B,EAAWI,GAGvC,IAFII,EAAYP,EAAUruB,MAAM,EAAG2uB,OAC/BE,EAAYJ,EAAUzuB,MAAM,EAAG2uB,IAMnC,OAAOG,EAAiBF,EAFRP,EAAUruB,MAAM2uB,GAChBF,EAAUzuB,MAAM2uB,GACyBL,EATzD,CALA,CAiBA,GAAuB,OAAnBC,GAA2BA,IAAmBH,EAAlD,CAGA,IAAI5P,EAAS4P,EAETM,GADAD,EAAYnzB,EAAQ0E,MAAM,EAAGwe,GAClBljB,EAAQ0E,MAAMwe,IAC7B,GAAIiQ,IAAcJ,EAAlB,CAGA,IAAIxa,EAAexd,KAAKC,IAAI43B,EAAY1P,EAAQ2P,EAAY3P,GAG5D,IAFIuQ,EAAYT,EAAStuB,MAAMsuB,EAASt5B,OAAS6e,OAC7Cmb,EAAYN,EAAS1uB,MAAM0uB,EAAS15B,OAAS6e,IAMjD,OAAOib,EAAiBT,EAFRC,EAAStuB,MAAM,EAAGsuB,EAASt5B,OAAS6e,GACpC6a,EAAS1uB,MAAM,EAAG0uB,EAAS15B,OAAS6e,GACKkb,EATzD,CANA,CAiBJ,CACA,GAAI3a,EAASpf,OAAS,GAAKsX,GAAgC,IAApBA,EAAStX,OAAc,CAE1D,IAAI45B,EAAY1a,EAAQlU,MAAM,EAAGoU,EAASxe,OACtCm5B,EAAY7a,EAAQlU,MAAMoU,EAASxe,MAAQwe,EAASpf,QAGxD,KAAIm5B,GAFAQ,EAAeC,EAAU55B,SACzB6e,EAAekb,EAAU/5B,SAC7B,CAGA,IAAI65B,EAAYvzB,EAAQ0E,MAAM,EAAG2uB,GAC7BK,EAAY1zB,EAAQ0E,MAAMmuB,EAAYta,GAC1C,GAAI+a,IAAcC,GAAaE,IAAcC,EAK7C,OAAOF,EAAiBF,EAFR1a,EAAQlU,MAAM2uB,EAAcT,EAAYra,GACxCvY,EAAQ0E,MAAM2uB,EAAcR,EAAYta,GACCkb,EARzD,CAUJ,CACA,OAAO,IACT,CAvuBmBE,CAAsBrB,EAAOC,EAAOC,GACnD,GAAIG,EACF,OAAOA,CAEX,CACA,IAAIiB,EAAeC,EAAkBvB,EAAOC,GACxCuB,EAAexB,EAAMyB,UAAU,EAAGH,GAGtCA,EAAeI,EAFf1B,EAAQA,EAAMyB,UAAUH,GACxBrB,EAAQA,EAAMwB,UAAUH,IAExB,IAAIK,EAAe3B,EAAMyB,UAAUzB,EAAM54B,OAASk6B,GAG9CM,EAaN,SAAuB5B,EAAOC,GAC5B,IAAI2B,EACJ,IAAK5B,EACH,MAAO,CAAC,CAvCM,EAuCQC,IAExB,IAAKA,EACH,MAAO,CAAC,CAACH,EAAaE,IAExB,IAAI6B,EAAW7B,EAAM54B,OAAS64B,EAAM74B,OAAS44B,EAAQC,EACjD6B,EAAY9B,EAAM54B,OAAS64B,EAAM74B,OAAS64B,EAAQD,EAClDnmB,EAAIgoB,EAAS/xB,QAAQgyB,GACzB,IAAW,IAAPjoB,EASF,OARA+nB,EAAQ,CACN,CAjDY,EAiDEC,EAASJ,UAAU,EAAG5nB,IACpC,CAjDW,EAiDEioB,GACb,CAnDY,EAmDED,EAASJ,UAAU5nB,EAAIioB,EAAU16B,UAE7C44B,EAAM54B,OAAS64B,EAAM74B,SACvBw6B,EAAM,GAAG,GAAKA,EAAM,GAAG,GAAK9B,GAEvB8B,EAET,GAAyB,IAArBE,EAAU16B,OACZ,MAAO,CACL,CAAC04B,EAAaE,GACd,CA7DY,EA6DEC,IAGlB,IAAI8B,EAqLN,SAAyB/B,EAAOC,GAC9B,IAAI4B,EAAW7B,EAAM54B,OAAS64B,EAAM74B,OAAS44B,EAAQC,EACjD6B,EAAY9B,EAAM54B,OAAS64B,EAAM74B,OAAS64B,EAAQD,EACtD,GAAI6B,EAASz6B,OAAS,GAAwB,EAAnB06B,EAAU16B,OAAay6B,EAASz6B,OACzD,OAAO,KAET,SAAS46B,EAAiBC,EAAWC,EAAYroB,GAK/C,IAJA,IAGIsoB,EAAiBC,EAAiBC,EAAkBC,EAHpDC,EAAON,EAAUR,UAAU5nB,EAAGA,EAAIpR,KAAK+5B,MAAMP,EAAU76B,OAAS,IAChEq7B,GAAK,EACLC,EAAc,IAEgC,KAA1CD,EAAIP,EAAWpyB,QAAQyyB,EAAME,EAAI,KAAY,CACnD,IAAI1B,EAAeQ,EACjBU,EAAUR,UAAU5nB,GACpBqoB,EAAWT,UAAUgB,IAEnBxc,EAAeyb,EACjBO,EAAUR,UAAU,EAAG5nB,GACvBqoB,EAAWT,UAAU,EAAGgB,IAEtBC,EAAYt7B,OAAS6e,EAAe8a,IACtC2B,EAAcR,EAAWT,UAAUgB,EAAIxc,EAAcwc,GAAKP,EAAWT,UAAUgB,EAAGA,EAAI1B,GACtFoB,EAAkBF,EAAUR,UAAU,EAAG5nB,EAAIoM,GAC7Cmc,EAAkBH,EAAUR,UAAU5nB,EAAIknB,GAC1CsB,EAAmBH,EAAWT,UAAU,EAAGgB,EAAIxc,GAC/Cqc,EAAmBJ,EAAWT,UAAUgB,EAAI1B,GAEhD,CACA,OAAyB,EAArB2B,EAAYt7B,QAAc66B,EAAU76B,OAC/B,CACL+6B,EACAC,EACAC,EACAC,EACAI,GAGK,IAEX,CACA,IAUIX,EAUAY,EAASC,EAASC,EAASC,EApB3BC,EAAMf,EACRH,EACAC,EACAr5B,KAAKu6B,KAAKnB,EAASz6B,OAAS,IAE1B67B,EAAMjB,EACRH,EACAC,EACAr5B,KAAKu6B,KAAKnB,EAASz6B,OAAS,IAG9B,OAAK27B,GAAQE,GAOXlB,EALUkB,EAEAF,GAGLA,EAAI,GAAG37B,OAAS67B,EAAI,GAAG77B,OAAS27B,EAFhCE,EAFAF,EAOH/C,EAAM54B,OAAS64B,EAAM74B,QACvBu7B,EAAUZ,EAAG,GACba,EAAUb,EAAG,GACbc,EAAUd,EAAG,GACbe,EAAUf,EAAG,KAEbc,EAAUd,EAAG,GACbe,EAAUf,EAAG,GACbY,EAAUZ,EAAG,GACba,EAAUb,EAAG,IAGR,CAACY,EAASC,EAASC,EAASC,EADlBf,EAAG,KApBX,IAsBX,CA/PWmB,CAAgBlD,EAAOC,GAChC,GAAI8B,EAAI,CACN,IAAIY,EAAUZ,EAAG,GACba,EAAUb,EAAG,GACbc,EAAUd,EAAG,GACbe,EAAUf,EAAG,GACboB,EAAapB,EAAG,GAChBqB,EAAUrD,EAAU4C,EAASE,GAC7BQ,EAAUtD,EAAU6C,EAASE,GACjC,OAAOM,EAAQzwB,OAAO,CAAC,CAxEV,EAwEuBwwB,IAAcE,EACpD,CACA,OAEF,SAAsBrD,EAAOC,GAQ3B,IAPA,IAAIqD,EAAetD,EAAM54B,OACrBm8B,EAAetD,EAAM74B,OACrBo8B,EAAQ/6B,KAAKu6B,MAAMM,EAAeC,GAAgB,GAClDE,EAAWD,EACXE,EAAW,EAAIF,EACfG,EAAK,IAAI10B,MAAMy0B,GACfE,EAAK,IAAI30B,MAAMy0B,GACVG,EAAI,EAAGA,EAAIH,EAAUG,IAC5BF,EAAGE,IAAM,EACTD,EAAGC,IAAM,EAEXF,EAAGF,EAAW,GAAK,EACnBG,EAAGH,EAAW,GAAK,EAOnB,IANA,IAAI18B,EAAQu8B,EAAeC,EACvBO,EAAQ/8B,EAAQ,GAAM,EACtBg9B,EAAU,EACVC,EAAQ,EACRC,EAAU,EACVC,EAAQ,EACHC,EAAI,EAAGA,EAAIX,EAAOW,IAAK,CAC9B,IAAK,IAAIC,GAAMD,EAAIJ,EAASK,GAAMD,EAAIH,EAAOI,GAAM,EAAG,CASpD,IARA,IAAIC,EAAYZ,EAAWW,EAOvBE,GAJFC,EADEH,KAAQD,GAAKC,IAAOD,GAAKR,EAAGU,EAAY,GAAKV,EAAGU,EAAY,GACzDV,EAAGU,EAAY,GAEfV,EAAGU,EAAY,GAAK,GAEbD,EACPG,EAAKjB,GAAgBgB,EAAKf,GAAgBvD,EAAMwE,OAAOD,KAAQtE,EAAMuE,OAAOF,IACjFC,IACAD,IAGF,GADAX,EAAGU,GAAaE,EACZA,EAAKjB,EACPU,GAAS,OACJ,GAAIM,EAAKf,EACdQ,GAAW,OACN,GAAID,IACLW,EAAYhB,EAAW18B,EAAQq9B,IAClB,GAAKK,EAAYf,IAA+B,IAAnBE,EAAGa,IAE3CF,IADAG,EAAKpB,EAAeM,EAAGa,IAEzB,OAAOE,EAAkB3E,EAAOC,EAAOsE,EAAID,EAInD,CACA,IAAK,IAAIM,GAAMT,EAAIF,EAASW,GAAMT,EAAID,EAAOU,GAAM,EAAG,CASpD,IARA,IACIF,EADAD,EAAYhB,EAAWmB,EAOvBC,GAJFH,EADEE,KAAQT,GAAKS,IAAOT,GAAKP,EAAGa,EAAY,GAAKb,EAAGa,EAAY,GACzDb,EAAGa,EAAY,GAEfb,EAAGa,EAAY,GAAK,GAEbG,EACPF,EAAKpB,GAAgBuB,EAAKtB,GAAgBvD,EAAMwE,OAAOlB,EAAeoB,EAAK,KAAOzE,EAAMuE,OAAOjB,EAAesB,EAAK,IACxHH,IACAG,IAGF,GADAjB,EAAGa,GAAaC,EACZA,EAAKpB,EACPY,GAAS,OACJ,GAAIW,EAAKtB,EACdU,GAAW,OACN,IAAKH,EAAO,CAGf,IAAIS,EADN,IADIF,EAAYZ,EAAW18B,EAAQ69B,IAClB,GAAKP,EAAYX,IAA+B,IAAnBC,EAAGU,KAE3CC,EAAKb,GADLc,EAAKZ,EAAGU,IACaA,EAErBE,IADJG,EAAKpB,EAAeoB,IAElB,OAAOC,EAAkB3E,EAAOC,EAAOsE,EAAID,EAGjD,CACF,CACF,CACA,MAAO,CACL,CAACxE,EAAaE,GACd,CA/Jc,EA+JAC,GAElB,CAtFS6E,CAAa9E,EAAOC,EAC7B,CArDc8E,CAFZ/E,EAAQA,EAAMyB,UAAU,EAAGzB,EAAM54B,OAASk6B,GAC1CrB,EAAQA,EAAMwB,UAAU,EAAGxB,EAAM74B,OAASk6B,IAY1C,OAVIE,GACFI,EAAMoD,QAAQ,CAxBD,EAwBcxD,IAEzBG,GACFC,EAAMrtB,KAAK,CA3BE,EA2BWotB,IAE1BsD,EAAkBrD,EAAOxB,GACrBD,GAiSN,SAA8ByB,GAU5B,IATA,IAAIsD,GAAU,EACVC,EAAa,GACbC,EAAmB,EACnBC,EAAe,KACfC,EAAU,EACVC,EAAqB,EACrBC,EAAoB,EACpBC,EAAqB,EACrBC,EAAoB,EACjBJ,EAAU1D,EAAMx6B,QAzUR,GA0UTw6B,EAAM0D,GAAS,IACjBH,EAAWC,KAAsBE,EACjCC,EAAqBE,EACrBD,EAAoBE,EACpBD,EAAqB,EACrBC,EAAoB,EACpBL,EAAezD,EAAM0D,GAAS,KAjVlB,GAmVR1D,EAAM0D,GAAS,GACjBG,GAAsB7D,EAAM0D,GAAS,GAAGl+B,OAExCs+B,GAAqB9D,EAAM0D,GAAS,GAAGl+B,OAErCi+B,GAAgBA,EAAaj+B,QAAUqB,KAAKwc,IAAIsgB,EAAoBC,IAAsBH,EAAaj+B,QAAUqB,KAAKwc,IAAIwgB,EAAoBC,KAChJ9D,EAAM7nB,OAAOorB,EAAWC,EAAmB,GAAI,EAAG,CAChDtF,EACAuF,IAEFzD,EAAMuD,EAAWC,EAAmB,GAAK,GAAG,GA7VlC,EA8VVA,IAEAE,IADAF,EAC6B,EAAID,EAAWC,EAAmB,IAAM,EACrEG,EAAqB,EACrBC,EAAoB,EACpBC,EAAqB,EACrBC,EAAoB,EACpBL,EAAe,KACfH,GAAU,IAGdI,IAOF,IALIJ,GACFD,EAAkBrD,GAiDtB,SAAsCA,GACpC,SAAS+D,EAA2BC,EAAKC,GACvC,IAAKD,IAAQC,EACX,OAAO,EAET,IAAIC,EAAQF,EAAIpB,OAAOoB,EAAIx+B,OAAS,GAChC2+B,EAAQF,EAAIrB,OAAO,GACnBwB,EAAmBF,EAAM1iB,MAAM6iB,GAC/BC,EAAmBH,EAAM3iB,MAAM6iB,GAC/BE,EAAcH,GAAoBF,EAAM1iB,MAAMgjB,GAC9CC,EAAcH,GAAoBH,EAAM3iB,MAAMgjB,GAC9CE,EAAaH,GAAeL,EAAM1iB,MAAMmjB,GACxCC,EAAaH,GAAeN,EAAM3iB,MAAMmjB,GACxCE,EAAaH,GAAcV,EAAIxiB,MAAMsjB,GACrCC,EAAaH,GAAcX,EAAIziB,MAAMwjB,GACzC,OAAIH,GAAcE,EACT,EACEL,GAAcE,EAChB,EACER,IAAqBG,GAAeE,EACtC,EACEF,GAAeE,EACjB,EACEL,GAAoBE,EACtB,EAEF,CACT,CAEA,IADA,IAAIZ,EAAU,EACPA,EAAU1D,EAAMx6B,OAAS,GAAG,CACjC,GA1ba,GA0bTw6B,EAAM0D,EAAU,GAAG,IA1bV,GA0b8B1D,EAAM0D,EAAU,GAAG,GAAkB,CAC9E,IAAIuB,EAAYjF,EAAM0D,EAAU,GAAG,GAC/BwB,EAAOlF,EAAM0D,GAAS,GACtByB,EAAYnF,EAAM0D,EAAU,GAAG,GAC/B0B,EAAetF,EAAkBmF,EAAWC,GAChD,GAAIE,EAAc,CAChB,IAAIC,EAAeH,EAAKrF,UAAUqF,EAAK1/B,OAAS4/B,GAChDH,EAAYA,EAAUpF,UAAU,EAAGoF,EAAUz/B,OAAS4/B,GACtDF,EAAOG,EAAeH,EAAKrF,UAAU,EAAGqF,EAAK1/B,OAAS4/B,GACtDD,EAAYE,EAAeF,CAC7B,CAKA,IAJA,IAAIG,EAAgBL,EAChBM,EAAWL,EACXM,EAAgBL,EAChBM,EAAY1B,EAA2BkB,EAAWC,GAAQnB,EAA2BmB,EAAMC,GACxFD,EAAKtC,OAAO,KAAOuC,EAAUvC,OAAO,IAAI,CAC7CqC,GAAaC,EAAKtC,OAAO,GACzBsC,EAAOA,EAAKrF,UAAU,GAAKsF,EAAUvC,OAAO,GAC5CuC,EAAYA,EAAUtF,UAAU,GAChC,IAAI6F,EAAQ3B,EAA2BkB,EAAWC,GAAQnB,EAA2BmB,EAAMC,GACvFO,GAASD,IACXA,EAAYC,EACZJ,EAAgBL,EAChBM,EAAWL,EACXM,EAAgBL,EAEpB,CACInF,EAAM0D,EAAU,GAAG,IAAM4B,IACvBA,EACFtF,EAAM0D,EAAU,GAAG,GAAK4B,GAExBtF,EAAM7nB,OAAOurB,EAAU,EAAG,GAC1BA,KAEF1D,EAAM0D,GAAS,GAAK6B,EAChBC,EACFxF,EAAM0D,EAAU,GAAG,GAAK8B,GAExBxF,EAAM7nB,OAAOurB,EAAU,EAAG,GAC1BA,KAGN,CACAA,GACF,CACF,CA1HEiC,CAA6B3F,GAC7B0D,EAAU,EACHA,EAAU1D,EAAMx6B,QAAQ,CAC7B,GAAIw6B,EAAM0D,EAAU,GAAG,IAAMxF,GAjXf,GAiX8B8B,EAAM0D,GAAS,GAAmB,CAC5E,IAAIkC,EAAW5F,EAAM0D,EAAU,GAAG,GAC9BmC,EAAY7F,EAAM0D,GAAS,GAC3BoC,EAAkBC,EAAoBH,EAAUC,GAChDG,EAAkBD,EAAoBF,EAAWD,GACjDE,GAAmBE,GACjBF,GAAmBF,EAASpgC,OAAS,GAAKsgC,GAAmBD,EAAUrgC,OAAS,KAClFw6B,EAAM7nB,OAAOurB,EAAS,EAAG,CAvXlB,EAyXLmC,EAAUhG,UAAU,EAAGiG,KAEzB9F,EAAM0D,EAAU,GAAG,GAAKkC,EAAS/F,UAC/B,EACA+F,EAASpgC,OAASsgC,GAEpB9F,EAAM0D,EAAU,GAAG,GAAKmC,EAAUhG,UAAUiG,GAC5CpC,MAGEsC,GAAmBJ,EAASpgC,OAAS,GAAKwgC,GAAmBH,EAAUrgC,OAAS,KAClFw6B,EAAM7nB,OAAOurB,EAAS,EAAG,CApYlB,EAsYLkC,EAAS/F,UAAU,EAAGmG,KAExBhG,EAAM0D,EAAU,GAAG,GAzYX,EA0YR1D,EAAM0D,EAAU,GAAG,GAAKmC,EAAUhG,UAChC,EACAgG,EAAUrgC,OAASwgC,GAErBhG,EAAM0D,EAAU,GAAG,GAAKxF,EACxB8B,EAAM0D,EAAU,GAAG,GAAKkC,EAAS/F,UAAUmG,GAC3CtC,KAGJA,GACF,CACAA,GACF,CACF,CAvXIuC,CAAqBjG,GAEhBA,CACT,CA+HA,SAAS+C,EAAkB3E,EAAOC,EAAO4D,EAAGiE,GAC1C,IAAIC,EAAS/H,EAAMyB,UAAU,EAAGoC,GAC5BmE,EAAS/H,EAAMwB,UAAU,EAAGqG,GAC5BG,EAASjI,EAAMyB,UAAUoC,GACzBqE,EAASjI,EAAMwB,UAAUqG,GACzBlG,EAAQ7B,EAAUgI,EAAQC,GAC1BG,EAASpI,EAAUkI,EAAQC,GAC/B,OAAOtG,EAAMjvB,OAAOw1B,EACtB,CACA,SAAS5G,EAAkBvB,EAAOC,GAChC,IAAKD,IAAUC,GAASD,EAAMwE,OAAO,KAAOvE,EAAMuE,OAAO,GACvD,OAAO,EAMT,IAJA,IAAI4D,EAAa,EACbC,EAAa5/B,KAAKC,IAAIs3B,EAAM54B,OAAQ64B,EAAM74B,QAC1CkhC,EAAaD,EACbE,EAAe,EACZH,EAAaE,GACdtI,EAAMyB,UAAU8G,EAAcD,IAAerI,EAAMwB,UAAU8G,EAAcD,GAE7EC,EADAH,EAAaE,EAGbD,EAAaC,EAEfA,EAAa7/B,KAAK+5B,OAAO6F,EAAaD,GAAc,EAAIA,GAK1D,OAHII,EAAwBxI,EAAMyI,WAAWH,EAAa,KACxDA,IAEKA,CACT,CACA,SAASX,EAAoB3H,EAAOC,GAClC,IAAIqD,EAAetD,EAAM54B,OACrBm8B,EAAetD,EAAM74B,OACzB,GAAoB,GAAhBk8B,GAAqC,GAAhBC,EACvB,OAAO,EAELD,EAAeC,EACjBvD,EAAQA,EAAMyB,UAAU6B,EAAeC,GAC9BD,EAAeC,IACxBtD,EAAQA,EAAMwB,UAAU,EAAG6B,IAE7B,IAAIoF,EAAcjgC,KAAKC,IAAI46B,EAAcC,GACzC,GAAIvD,GAASC,EACX,OAAOyI,EAIT,IAFA,IAAIC,EAAO,EACPvhC,EAAS,IACA,CACX,IAAIwhC,EAAU5I,EAAMyB,UAAUiH,EAActhC,GACxCyhC,EAAQ5I,EAAMnwB,QAAQ84B,GAC1B,IAAc,GAAVC,EACF,OAAOF,EAETvhC,GAAUyhC,EACG,GAATA,GAAc7I,EAAMyB,UAAUiH,EAActhC,IAAW64B,EAAMwB,UAAU,EAAGr6B,KAC5EuhC,EAAOvhC,EACPA,IAEJ,CACF,CACA,SAASs6B,EAAkB1B,EAAOC,GAChC,IAAKD,IAAUC,GAASD,EAAM5tB,OAAO,KAAO6tB,EAAM7tB,OAAO,GACvD,OAAO,EAMT,IAJA,IAAIg2B,EAAa,EACbC,EAAa5/B,KAAKC,IAAIs3B,EAAM54B,OAAQ64B,EAAM74B,QAC1CkhC,EAAaD,EACbS,EAAa,EACVV,EAAaE,GACdtI,EAAMyB,UAAUzB,EAAM54B,OAASkhC,EAAYtI,EAAM54B,OAAS0hC,IAAe7I,EAAMwB,UAAUxB,EAAM74B,OAASkhC,EAAYrI,EAAM74B,OAAS0hC,GAErIA,EADAV,EAAaE,EAGbD,EAAaC,EAEfA,EAAa7/B,KAAK+5B,OAAO6F,EAAaD,GAAc,EAAIA,GAK1D,OAHIW,EAAsB/I,EAAMyI,WAAWzI,EAAM54B,OAASkhC,KACxDA,IAEKA,CACT,CAoKA,IAAIrC,EAAwB,eACxBG,EAAmB,KACnBG,EAAkB,SAClBG,EAAqB,WACrBE,EAAuB,cA6E3B,SAAS3B,EAAkBrD,EAAOoH,GAChCpH,EAAMrtB,KAAK,CAzeI,EAyeS,KAOxB,IANA,IAKI+sB,EALAgE,EAAU,EACV2D,EAAe,EACfC,EAAe,EACfC,EAAc,GACdC,EAAc,GAEX9D,EAAU1D,EAAMx6B,QACrB,GAAIk+B,EAAU1D,EAAMx6B,OAAS,IAAMw6B,EAAM0D,GAAS,GAChD1D,EAAM7nB,OAAOurB,EAAS,QAGxB,OAAQ1D,EAAM0D,GAAS,IACrB,KAvfY,EAwfV4D,IACAE,GAAexH,EAAM0D,GAAS,GAC9BA,IACA,MACF,KAAKxF,EACHmJ,IACAE,GAAevH,EAAM0D,GAAS,GAC9BA,IACA,MACF,KAhgBW,EAigBT,IAAI+D,EAAoB/D,EAAU4D,EAAeD,EAAe,EAChE,GAAID,EAAa,CACf,GAAIK,GAAqB,GAAKC,EAAqB1H,EAAMyH,GAAmB,IAAK,CAC/E,IAAIE,EAAQ3H,EAAMyH,GAAmB,GAAGj3B,OAAO,GAO/C,GANAwvB,EAAMyH,GAAmB,GAAKzH,EAAMyH,GAAmB,GAAGj3B,MACxD,GACC,GAEH+2B,EAAcI,EAAQJ,EACtBC,EAAcG,EAAQH,GACjBxH,EAAMyH,GAAmB,GAAI,CAChCzH,EAAM7nB,OAAOsvB,EAAmB,GAChC/D,IACA,IAAIkE,EAAIH,EAAoB,EACxBzH,EAAM4H,IAhhBN,IAghBY5H,EAAM4H,GAAG,KACvBN,IACAE,EAAcxH,EAAM4H,GAAG,GAAKJ,EAC5BI,KAEE5H,EAAM4H,IAAM5H,EAAM4H,GAAG,KAAO1J,IAC9BmJ,IACAE,EAAcvH,EAAM4H,GAAG,GAAKL,EAC5BK,KAEFH,EAAoBG,CACtB,CACF,CACIC,EAAqB7H,EAAM0D,GAAS,MAClCiE,EAAQ3H,EAAM0D,GAAS,GAAGd,OAAO,GACrC5C,EAAM0D,GAAS,GAAK1D,EAAM0D,GAAS,GAAGlzB,MAAM,GAC5C+2B,GAAeI,EACfH,GAAeG,EAEnB,CACA,GAAIjE,EAAU1D,EAAMx6B,OAAS,IAAMw6B,EAAM0D,GAAS,GAAI,CACpD1D,EAAM7nB,OAAOurB,EAAS,GACtB,KACF,CACA,GAAI6D,EAAY/hC,OAAS,GAAKgiC,EAAYhiC,OAAS,EAAG,CAChD+hC,EAAY/hC,OAAS,GAAKgiC,EAAYhiC,OAAS,IAE5B,KADrBk6B,EAAeC,EAAkB6H,EAAaD,MAExCE,GAAqB,EACvBzH,EAAMyH,GAAmB,IAAMD,EAAY3H,UACzC,EACAH,IAGFM,EAAM7nB,OAAO,EAAG,EAAG,CAjjBlB,EAmjBCqvB,EAAY3H,UAAU,EAAGH,KAE3BgE,KAEF8D,EAAcA,EAAY3H,UAAUH,GACpC6H,EAAcA,EAAY1H,UAAUH,IAGjB,KADrBA,EAAeI,EAAkB0H,EAAaD,MAE5CvH,EAAM0D,GAAS,GAAK8D,EAAY3H,UAAU2H,EAAYhiC,OAASk6B,GAAgBM,EAAM0D,GAAS,GAC9F8D,EAAcA,EAAY3H,UACxB,EACA2H,EAAYhiC,OAASk6B,GAEvB6H,EAAcA,EAAY1H,UACxB,EACA0H,EAAY/hC,OAASk6B,KAI3B,IAAIoI,EAAIR,EAAeD,EACI,IAAvBE,EAAY/hC,QAAuC,IAAvBgiC,EAAYhiC,QAC1Cw6B,EAAM7nB,OAAOurB,EAAUoE,EAAGA,GAC1BpE,GAAoBoE,GACY,IAAvBP,EAAY/hC,QACrBw6B,EAAM7nB,OAAOurB,EAAUoE,EAAGA,EAAG,CA7kBvB,EA6kBqCN,IAC3C9D,EAAUA,EAAUoE,EAAI,GACQ,IAAvBN,EAAYhiC,QACrBw6B,EAAM7nB,OAAOurB,EAAUoE,EAAGA,EAAG,CAAC5J,EAAaqJ,IAC3C7D,EAAUA,EAAUoE,EAAI,IAExB9H,EAAM7nB,OACJurB,EAAUoE,EACVA,EACA,CAAC5J,EAAaqJ,GACd,CAvlBI,EAulBUC,IAEhB9D,EAAUA,EAAUoE,EAAI,EAE5B,CACgB,IAAZpE,GA3lBK,IA2lBY1D,EAAM0D,EAAU,GAAG,IACtC1D,EAAM0D,EAAU,GAAG,IAAM1D,EAAM0D,GAAS,GACxC1D,EAAM7nB,OAAOurB,EAAS,IAEtBA,IAEF4D,EAAe,EACfD,EAAe,EACfE,EAAc,GACdC,EAAc,GAIe,KAA/BxH,EAAMA,EAAMx6B,OAAS,GAAG,IAC1Bw6B,EAAMt2B,MAER,IAAI45B,GAAU,EAEd,IADAI,EAAU,EACHA,EAAU1D,EAAMx6B,OAAS,GA7mBjB,IA8mBTw6B,EAAM0D,EAAU,GAAG,IA9mBV,IA8mB+B1D,EAAM0D,EAAU,GAAG,KACzD1D,EAAM0D,GAAS,GAAG7D,UACpBG,EAAM0D,GAAS,GAAGl+B,OAASw6B,EAAM0D,EAAU,GAAG,GAAGl+B,UAC7Cw6B,EAAM0D,EAAU,GAAG,IACvB1D,EAAM0D,GAAS,GAAK1D,EAAM0D,EAAU,GAAG,GAAK1D,EAAM0D,GAAS,GAAG7D,UAC5D,EACAG,EAAM0D,GAAS,GAAGl+B,OAASw6B,EAAM0D,EAAU,GAAG,GAAGl+B,QAEnDw6B,EAAM0D,EAAU,GAAG,GAAK1D,EAAM0D,EAAU,GAAG,GAAK1D,EAAM0D,EAAU,GAAG,GACnE1D,EAAM7nB,OAAOurB,EAAU,EAAG,GAC1BJ,GAAU,GACDtD,EAAM0D,GAAS,GAAG7D,UAAU,EAAGG,EAAM0D,EAAU,GAAG,GAAGl+B,SAAWw6B,EAAM0D,EAAU,GAAG,KAC5F1D,EAAM0D,EAAU,GAAG,IAAM1D,EAAM0D,EAAU,GAAG,GAC5C1D,EAAM0D,GAAS,GAAK1D,EAAM0D,GAAS,GAAG7D,UAAUG,EAAM0D,EAAU,GAAG,GAAGl+B,QAAUw6B,EAAM0D,EAAU,GAAG,GACnG1D,EAAM7nB,OAAOurB,EAAU,EAAG,GAC1BJ,GAAU,IAGdI,IAEEJ,GACFD,EAAkBrD,EAAOoH,EAE7B,CACA,SAASR,EAAwBmB,GAC/B,OAAOA,GAAY,OAASA,GAAY,KAC1C,CACA,SAASZ,EAAsBY,GAC7B,OAAOA,GAAY,OAASA,GAAY,KAC1C,CACA,SAASF,EAAqBG,GAC5B,OAAOb,EAAsBa,EAAInB,WAAW,GAC9C,CACA,SAASa,EAAqBM,GAC5B,OAAOpB,EAAwBoB,EAAInB,WAAWmB,EAAIxiC,OAAS,GAC7D,CAUA,SAAS85B,EAAiB2I,EAAQC,EAAWC,EAAW3Y,GACtD,OAAIkY,EAAqBO,IAAWJ,EAAqBrY,GAChD,KAXX,SAA6B4Y,GAE3B,IADA,IAAIC,EAAM,GACDpwB,EAAI,EAAGA,EAAImwB,EAAO5iC,OAAQyS,IAC7BmwB,EAAOnwB,GAAG,GAAGzS,OAAS,GACxB6iC,EAAI11B,KAAKy1B,EAAOnwB,IAGpB,OAAOowB,CACT,CAKSC,CAAoB,CACzB,CAhqBa,EAgqBAL,GACb,CAAC/J,EAAagK,GACd,CAnqBc,EAmqBAC,GACd,CAnqBa,EAmqBA3Y,IAEjB,CA4EA,SAAS+Y,EAAMnK,EAAOC,EAAOC,EAAYC,GACvC,OAAOJ,EAAUC,EAAOC,EAAOC,EAAYC,GAAS,EACtD,CACAgK,EAAMC,OArvBY,EAsvBlBD,EAAME,OAASvK,EACfqK,EAAMG,MAtvBW,EAuvBjBzK,EAAQt5B,QAAU4jC,CACpB,GAjxB4B,WAC5B,OAAO3L,IAAO,EAAID,EAAGO,EAAkBP,GAAI,MAAMC,EAAM,CAAEj4B,QAAS,CAAC,IAAKA,QAASi4B,GAAMA,EAAIj4B,OAC7F,MAyxBIgkC,EAHJ,SAAmBpa,GACjB,OAAOoC,KAAKC,MAAMD,KAAKE,UAAUtC,GACnC,EAmBA,SAASuC,EAAYvC,GACnB,OAAOA,IAAQ/c,OAAO+c,EACxB,CACA,IAGIjd,EACMs3B,EAJNC,EAlBJ,SAASC,EAAU/X,EAAMC,GACvB,GAAID,IAASC,EACX,OAAO,EACT,GAAIF,EAAYC,IAASD,EAAYE,GACnC,OAAOD,IAASC,EAClB,GAAIxf,OAAOC,KAAKsf,GAAMvrB,SAAWgM,OAAOC,KAAKuf,GAAMxrB,OACjD,OAAO,EACT,IAAK,IAAI0L,KAAO6f,EAAM,CACpB,KAAM7f,KAAO8f,GACX,OAAO,EACT,IAAK8X,EAAU/X,EAAK7f,GAAM8f,EAAK9f,IAC7B,OAAO,CACX,CACA,OAAO,CACT,GAQU03B,EA4EPt3B,IAAiBA,EAAe,CAAC,IApDpB+F,QAvBd,SAAiB0xB,EAAI,CAAC,EAAGz1B,EAAI,CAAC,EAAG01B,GAAW,GACzB,iBAAND,IACTA,EAAI,CAAC,GAEU,iBAANz1B,IACTA,EAAI,CAAC,GAEP,IAAInK,EAAaw/B,EAAkBr1B,GAC9B01B,IACH7/B,EAAaqI,OAAOC,KAAKtI,GAAYvD,QAAO,CAACqjC,EAAM/3B,KAC1B,MAAnB/H,EAAW+H,KACb+3B,EAAK/3B,GAAO/H,EAAW+H,IAElB+3B,IACN,CAAC,IAEN,IAAK,MAAM/3B,KAAO63B,OACD,IAAXA,EAAE73B,SAA8B,IAAXoC,EAAEpC,KACzB/H,EAAW+H,GAAO63B,EAAE73B,IAGxB,OAAOM,OAAOC,KAAKtI,GAAY3D,OAAS,EAAI2D,OAAa,CAC3D,EAiBAy/B,EAAcr3B,KAfd,SAAew3B,EAAI,CAAC,EAAGz1B,EAAI,CAAC,GACT,iBAANy1B,IACTA,EAAI,CAAC,GAEU,iBAANz1B,IACTA,EAAI,CAAC,GAEP,MAAMnK,EAAaqI,OAAOC,KAAKs3B,GAAGh4B,OAAOS,OAAOC,KAAK6B,IAAI1N,QAAO,CAACsjC,EAAOh4B,KACjE23B,EAAkBE,EAAE73B,GAAMoC,EAAEpC,MAC/Bg4B,EAAMh4B,QAAkB,IAAXoC,EAAEpC,GAAkB,KAAOoC,EAAEpC,IAErCg4B,IACN,CAAC,GACJ,OAAO13B,OAAOC,KAAKtI,GAAY3D,OAAS,EAAI2D,OAAa,CAC3D,EAiBAy/B,EAAcpyB,OAfd,SAAgBqB,EAAO,CAAC,EAAGxB,EAAO,CAAC,GACjCwB,EAAOA,GAAQ,CAAC,EAChB,MAAMsxB,EAAe33B,OAAOC,KAAK4E,GAAMzQ,QAAO,CAACixB,EAAM3lB,KAC/CmF,EAAKnF,KAAS2G,EAAK3G,SAAsB,IAAd2G,EAAK3G,KAClC2lB,EAAK3lB,GAAOmF,EAAKnF,IAEZ2lB,IACN,CAAC,GACJ,OAAOrlB,OAAOC,KAAKoG,GAAMjS,QAAO,CAACixB,EAAM3lB,KACjC2G,EAAK3G,KAASmF,EAAKnF,SAAsB,IAAdmF,EAAKnF,KAClC2lB,EAAK3lB,GAAO,MAEP2lB,IACNsS,EACL,EAoBAP,EAAcrzB,UAlBd,SAAmBwzB,EAAGz1B,EAAG81B,GAAW,GAClC,GAAiB,iBAANL,EACT,OAAOz1B,EAET,GAAiB,iBAANA,EACT,OAEF,IAAK81B,EACH,OAAO91B,EAET,MAAMnK,EAAaqI,OAAOC,KAAK6B,GAAG1N,QAAO,CAACsjC,EAAOh4B,UAChC,IAAX63B,EAAE73B,KACJg4B,EAAMh4B,GAAOoC,EAAEpC,IAEVg4B,IACN,CAAC,GACJ,OAAO13B,OAAOC,KAAKtI,GAAY3D,OAAS,EAAI2D,OAAa,CAC3D,EAGF,IAGI8K,EAHAo1B,EAAuB/3B,GAiBxB2C,IAAOA,EAAK,CAAC,IADVzO,OAXJ,SAAgBkO,GACd,MAAyB,iBAAdA,EAAGgE,OACLhE,EAAGgE,OACoB,iBAAdhE,EAAG8G,OACZ9G,EAAG8G,OACoB,iBAAd9G,EAAG8G,QAAqC,OAAd9G,EAAG8G,OACtC,EAEqB,iBAAd9G,EAAG5N,OAAsB4N,EAAG5N,OAAON,OAAS,CAE9D,EAGF,IAAI8jC,EAAar1B,EAGbs1B,EAAW,MACbxyB,IACA3Q,MACA4E,OACA,WAAAT,CAAYwM,GACV3R,KAAK2R,IAAMA,EACX3R,KAAKgB,MAAQ,EACbhB,KAAK4F,OAAS,CAChB,CACA,OAAAw+B,GACE,OAAOpkC,KAAKqkC,aAAeC,GAC7B,CACA,IAAAjhC,CAAKjD,GACEA,IACHA,EAASkkC,KAEX,MAAMC,EAASvkC,KAAK2R,IAAI3R,KAAKgB,OAC7B,GAAIujC,EAAQ,CACV,MAAM3+B,EAAS5F,KAAK4F,OACd4+B,EAAWN,EAAW9jC,OAAOmkC,GAQnC,GAPInkC,GAAUokC,EAAW5+B,GACvBxF,EAASokC,EAAW5+B,EACpB5F,KAAKgB,OAAS,EACdhB,KAAK4F,OAAS,GAEd5F,KAAK4F,QAAUxF,EAEY,iBAAlBmkC,EAAOjyB,OAChB,MAAO,CAAEA,OAAQlS,GACZ,CACL,MAAMqkC,EAAQ,CAAC,EAaf,OAZIF,EAAOxgC,aACT0gC,EAAM1gC,WAAawgC,EAAOxgC,YAEC,iBAAlBwgC,EAAOnvB,OAChBqvB,EAAMrvB,OAAShV,EACmB,iBAAlBmkC,EAAOnvB,QAAyC,OAAlBmvB,EAAOnvB,OACrDqvB,EAAMrvB,OAASmvB,EAAOnvB,OACY,iBAAlBmvB,EAAO7jC,OACvB+jC,EAAM/jC,OAAS6jC,EAAO7jC,OAAOgkC,OAAO9+B,EAAQxF,GAE5CqkC,EAAM/jC,OAAS6jC,EAAO7jC,OAEjB+jC,CACT,CACF,CACE,MAAO,CAAErvB,OAAQkvB,IAErB,CACA,IAAAK,GACE,OAAO3kC,KAAK2R,IAAI3R,KAAKgB,MACvB,CACA,UAAAqjC,GACE,OAAIrkC,KAAK2R,IAAI3R,KAAKgB,OACTkjC,EAAW9jC,OAAOJ,KAAK2R,IAAI3R,KAAKgB,QAAUhB,KAAK4F,OAE/C0+B,GAEX,CACA,QAAAM,GACE,MAAMt2B,EAAKtO,KAAK2R,IAAI3R,KAAKgB,OACzB,OAAIsN,EACuB,iBAAdA,EAAGgE,OACL,SACuB,iBAAdhE,EAAG8G,QAA4C,iBAAd9G,EAAG8G,QAAqC,OAAd9G,EAAG8G,OACvE,SAEA,SAGJ,QACT,CACA,IAAAyG,GACE,GAAK7b,KAAKokC,UAEH,IAAoB,IAAhBpkC,KAAK4F,OACd,OAAO5F,KAAK2R,IAAIvG,MAAMpL,KAAKgB,OACtB,CACL,MAAM4E,EAAS5F,KAAK4F,OACd5E,EAAQhB,KAAKgB,MACbqC,EAAOrD,KAAKqD,OACZwY,EAAO7b,KAAK2R,IAAIvG,MAAMpL,KAAKgB,OAGjC,OAFAhB,KAAK4F,OAASA,EACd5F,KAAKgB,MAAQA,EACN,CAACqC,GAAMsI,OAAOkQ,EACvB,EAXE,MAAO,EAYX,GAIEgpB,EAAiBC,OAAOC,aAAa,GACrCC,EAAsB,CAACrB,EAAGz1B,KAC5B,GAAiB,iBAANy1B,GAAwB,OAANA,EAC3B,MAAM,IAAIrgB,MAAM,0BAA0BqgB,GAE5C,GAAiB,iBAANz1B,GAAwB,OAANA,EAC3B,MAAM,IAAIoV,MAAM,0BAA0BpV,GAE5C,MAAM+2B,EAAY74B,OAAOC,KAAKs3B,GAAG,GACjC,IAAKsB,GAAaA,IAAc74B,OAAOC,KAAK6B,GAAG,GAC7C,MAAM,IAAIoV,MAAM,4BAA4B2hB,QAAgB74B,OAAOC,KAAK6B,GAAG,MAE7E,MAAO,CAAC+2B,EAAWtB,EAAEsB,GAAY/2B,EAAE+2B,GAAW,EAE5CpkC,EAAQ,MAAMqkC,EAChBhgC,UAAYg/B,EACZh/B,kBAAoBi/B,EACpBj/B,oBAAsB++B,EACtB/+B,gBAAkB,CAAC,EACnB,oBAAOigC,CAAcF,EAAW5wB,GAC9BrU,KAAK6Y,SAASosB,GAAa5wB,CAC7B,CACA,sBAAO+wB,CAAgBH,UACdjlC,KAAK6Y,SAASosB,EACvB,CACA,iBAAOI,CAAWJ,GAChB,MAAM5wB,EAAUrU,KAAK6Y,SAASosB,GAC9B,IAAK5wB,EACH,MAAM,IAAIiP,MAAM,+BAA+B2hB,MAEjD,OAAO5wB,CACT,CACA1C,IACA2zB,SACA,WAAAngC,CAAYwM,GACN1J,MAAMmC,QAAQuH,GAChB3R,KAAK2R,IAAMA,EACK,MAAPA,GAAe1J,MAAMmC,QAAQuH,EAAIA,MAC1C3R,KAAK2R,IAAMA,EAAIA,IACf3R,KAAKslC,SAAW3zB,EAAI2zB,UAEpBtlC,KAAK2R,IAAM,EAEf,CACA,MAAAjR,CAAO6kC,EAAKxhC,GACV,MAAMyhC,EAAQ,CAAC,EACf,MAAmB,iBAARD,GAAmC,IAAfA,EAAInlC,OAC1BJ,MAETwlC,EAAM9kC,OAAS6kC,EACG,MAAdxhC,GAA4C,iBAAfA,GAA2BqI,OAAOC,KAAKtI,GAAY3D,OAAS,IAC3FolC,EAAMzhC,WAAaA,GAEd/D,KAAKuN,KAAKi4B,GACnB,CACA,OAAOplC,GACL,OAAIA,GAAU,EACLJ,KAEFA,KAAKuN,KAAK,CAAE+E,OAAQlS,GAC7B,CACA,MAAAgV,CAAOhV,EAAQ2D,GACb,GAAsB,iBAAX3D,GAAuBA,GAAU,EAC1C,OAAOJ,KAET,MAAMwlC,EAAQ,CAAEpwB,OAAQhV,GAIxB,OAHkB,MAAd2D,GAA4C,iBAAfA,GAA2BqI,OAAOC,KAAKtI,GAAY3D,OAAS,IAC3FolC,EAAMzhC,WAAaA,GAEd/D,KAAKuN,KAAKi4B,EACnB,CACA,IAAAj4B,CAAKi4B,GACH,IAAIxkC,EAAQhB,KAAK2R,IAAIvR,OACjBoS,EAASxS,KAAK2R,IAAI3Q,EAAQ,GAE9B,GADAwkC,EAAQjC,EAAkBiC,GACJ,iBAAXhzB,EAAqB,CAC9B,GAA4B,iBAAjBgzB,EAAMlzB,QAAgD,iBAAlBE,EAAOF,OAEpD,OADAtS,KAAK2R,IAAI3Q,EAAQ,GAAK,CAAEsR,OAAQE,EAAOF,OAASkzB,EAAMlzB,QAC/CtS,KAET,GAA6B,iBAAlBwS,EAAOF,QAAuC,MAAhBkzB,EAAM9kC,SAC7CM,GAAS,EACTwR,EAASxS,KAAK2R,IAAI3Q,EAAQ,GACJ,iBAAXwR,GAET,OADAxS,KAAK2R,IAAIqsB,QAAQwH,GACVxlC,KAGX,GAAIyjC,EAAkB+B,EAAMzhC,WAAYyO,EAAOzO,YAAa,CAC1D,GAA4B,iBAAjByhC,EAAM9kC,QAAgD,iBAAlB8R,EAAO9R,OAKpD,OAJAV,KAAK2R,IAAI3Q,EAAQ,GAAK,CAAEN,OAAQ8R,EAAO9R,OAAS8kC,EAAM9kC,QACtB,iBAArB8kC,EAAMzhC,aACf/D,KAAK2R,IAAI3Q,EAAQ,GAAG+C,WAAayhC,EAAMzhC,YAElC/D,KACF,GAA4B,iBAAjBwlC,EAAMpwB,QAAgD,iBAAlB5C,EAAO4C,OAK3D,OAJApV,KAAK2R,IAAI3Q,EAAQ,GAAK,CAAEoU,OAAQ5C,EAAO4C,OAASowB,EAAMpwB,QACtB,iBAArBowB,EAAMzhC,aACf/D,KAAK2R,IAAI3Q,EAAQ,GAAG+C,WAAayhC,EAAMzhC,YAElC/D,IAEX,CACF,CAMA,OALIgB,IAAUhB,KAAK2R,IAAIvR,OACrBJ,KAAK2R,IAAIpE,KAAKi4B,GAEdxlC,KAAK2R,IAAIoB,OAAO/R,EAAO,EAAGwkC,GAErBxlC,IACT,CACA,IAAAylC,GACE,MAAMjzB,EAASxS,KAAK2R,IAAI3R,KAAK2R,IAAIvR,OAAS,GAI1C,OAHIoS,GAAmC,iBAAlBA,EAAO4C,SAAwB5C,EAAOzO,YACzD/D,KAAK2R,IAAIrN,MAEJtE,IACT,CACA,MAAAE,CAAOwlC,GACL,OAAO1lC,KAAK2R,IAAIzR,OAAOwlC,EACzB,CACA,OAAAhhC,CAAQghC,GACN1lC,KAAK2R,IAAIjN,QAAQghC,EACnB,CACA,GAAAlhC,CAAIkhC,GACF,OAAO1lC,KAAK2R,IAAInN,IAAIkhC,EACtB,CACA,SAAAC,CAAUD,GACR,MAAME,EAAS,GACTC,EAAS,GAKf,OAJA7lC,KAAK0E,SAAS4J,KACGo3B,EAAUp3B,GAAMs3B,EAASC,GACjCt4B,KAAKe,EAAG,IAEV,CAACs3B,EAAQC,EAClB,CACA,MAAArlC,CAAOklC,EAAWI,GAChB,OAAO9lC,KAAK2R,IAAInR,OAAOklC,EAAWI,EACpC,CACA,YAAAC,GACE,OAAO/lC,KAAKQ,QAAO,CAACJ,EAAQ4lC,IACtBA,EAAKtlC,OACAN,EAAS8jC,EAAW9jC,OAAO4lC,GACzBA,EAAK1zB,OACPlS,EAAS4lC,EAAK1zB,OAEhBlS,GACN,EACL,CACA,MAAAA,GACE,OAAOJ,KAAKQ,QAAO,CAACJ,EAAQ4lC,IACnB5lC,EAAS8jC,EAAW9jC,OAAO4lC,IACjC,EACL,CACA,KAAA56B,CAAMrE,EAAQ,EAAGC,EAAMs9B,KACrB,MAAM3yB,EAAM,GACNs0B,EAAO,IAAI9B,EAASnkC,KAAK2R,KAC/B,IAAI3Q,EAAQ,EACZ,KAAOA,EAAQgG,GAAOi/B,EAAK7B,WAAW,CACpC,IAAIG,EACAvjC,EAAQ+F,EACVw9B,EAAS0B,EAAK5iC,KAAK0D,EAAQ/F,IAE3BujC,EAAS0B,EAAK5iC,KAAK2D,EAAMhG,GACzB2Q,EAAIpE,KAAKg3B,IAEXvjC,GAASkjC,EAAW9jC,OAAOmkC,EAC7B,CACA,OAAO,IAAIW,EAAOvzB,EACpB,CACA,OAAAM,CAAQtJ,GACN,MAAMu9B,EAAW,IAAI/B,EAASnkC,KAAK2R,KAC7Bw0B,EAAY,IAAIhC,EAASx7B,EAAMgJ,KAC/BA,EAAM,GACNy0B,EAAaD,EAAUxB,OAC7B,GAAkB,MAAdyB,GAAmD,iBAAtBA,EAAWhxB,QAAgD,MAAzBgxB,EAAWriC,WAAoB,CAChG,IAAIsiC,EAAYD,EAAWhxB,OAC3B,KAA+B,WAAxB8wB,EAAStB,YAA2BsB,EAAS7B,cAAgBgC,GAClEA,GAAaH,EAAS7B,aACtB1yB,EAAIpE,KAAK24B,EAAS7iC,QAEhB+iC,EAAWhxB,OAASixB,EAAY,GAClCF,EAAU9iC,KAAK+iC,EAAWhxB,OAASixB,EAEvC,CACA,MAAMtmC,EAAQ,IAAImlC,EAAOvzB,GACzB,KAAOu0B,EAAS9B,WAAa+B,EAAU/B,WACrC,GAA6B,WAAzB+B,EAAUvB,WACZ7kC,EAAMwN,KAAK44B,EAAU9iC,aAChB,GAA4B,WAAxB6iC,EAAStB,WAClB7kC,EAAMwN,KAAK24B,EAAS7iC,YACf,CACL,MAAMjD,EAASqB,KAAKC,IAAIwkC,EAAS7B,aAAc8B,EAAU9B,cACnDiC,EAASJ,EAAS7iC,KAAKjD,GACvBmmC,EAAUJ,EAAU9iC,KAAKjD,GAC/B,GAAImmC,EAAQnxB,OAAQ,CAClB,MAAMowB,EAAQ,CAAC,EACf,GAA6B,iBAAlBc,EAAOlxB,OAChBowB,EAAMpwB,OAAmC,iBAAnBmxB,EAAQnxB,OAAsBhV,EAASmmC,EAAQnxB,YAErE,GAA8B,iBAAnBmxB,EAAQnxB,OACI,MAAjBkxB,EAAOlxB,OACTowB,EAAM9kC,OAAS4lC,EAAO5lC,OAEtB8kC,EAAMpwB,OAASkxB,EAAOlxB,WAEnB,CACL,MAAMoxB,EAA0B,MAAjBF,EAAOlxB,OAAiB,SAAW,UAC3C6vB,EAAWwB,EAAUC,GAAa1B,EAAoBsB,EAAOE,GAASD,EAAQnxB,QAC/Ef,EAAU6wB,EAAOG,WAAWJ,GAClCO,EAAMgB,GAAU,CACd,CAACvB,GAAY5wB,EAAQpC,QAAQw0B,EAAUC,EAAsB,WAAXF,GAEtD,CAEF,MAAMziC,EAAakgC,EAAqBhyB,QAAQq0B,EAAOviC,WAAYwiC,EAAQxiC,WAAqC,iBAAlBuiC,EAAOlxB,QAKrG,GAJIrR,IACFyhC,EAAMzhC,WAAaA,GAErBhE,EAAMwN,KAAKi4B,IACNW,EAAU/B,WAAaX,EAAkB1jC,EAAM4R,IAAI5R,EAAM4R,IAAIvR,OAAS,GAAIolC,GAAQ,CACrF,MAAM3pB,EAAO,IAAIqpB,EAAOgB,EAASrqB,QACjC,OAAO9b,EAAM4L,OAAOkQ,GAAM4pB,MAC5B,CACF,KAAqC,iBAAnBc,EAAQj0B,SAAiD,iBAAlBg0B,EAAOlxB,QAAgD,iBAAlBkxB,EAAOlxB,QAAyC,OAAlBkxB,EAAOlxB,SACjIrV,EAAMwN,KAAKg5B,EAEf,CAEF,OAAOxmC,EAAM0lC,MACf,CACA,MAAA95B,CAAOhD,GACL,MAAM5I,EAAQ,IAAImlC,EAAOllC,KAAK2R,IAAIvG,SAKlC,OAJIzC,EAAMgJ,IAAIvR,OAAS,IACrBL,EAAMwN,KAAK5E,EAAMgJ,IAAI,IACrB5R,EAAM4R,IAAM5R,EAAM4R,IAAIhG,OAAOhD,EAAMgJ,IAAIvG,MAAM,KAExCrL,CACT,CACA,IAAAoM,CAAKxD,EAAOihB,GACV,GAAI5pB,KAAK2R,MAAQhJ,EAAMgJ,IACrB,OAAO,IAAIuzB,EAEb,MAAMyB,EAAU,CAAC3mC,KAAM2I,GAAOnE,KAAKzE,GAC1BA,EAAMyE,KAAK8J,IAChB,GAAiB,MAAbA,EAAG5N,OACL,MAA4B,iBAAd4N,EAAG5N,OAAsB4N,EAAG5N,OAASmkC,EAGrD,MAAM,IAAIvhB,MAAM,kBADHvjB,IAAU4I,EAAQ,KAAO,QACI,gBAAgB,IACzDhC,KAAK,MAEJigC,EAAW,IAAI1B,EACf2B,GAAa,EAAIzO,EAAiB/M,SAASsb,EAAQ,GAAIA,EAAQ,GAAI/c,GAAQ,GAC3Esc,EAAW,IAAI/B,EAASnkC,KAAK2R,KAC7Bw0B,EAAY,IAAIhC,EAASx7B,EAAMgJ,KA6BrC,OA5BAk1B,EAAWniC,SAASkoB,IAClB,IAAIxsB,EAASwsB,EAAU,GAAGxsB,OAC1B,KAAOA,EAAS,GAAG,CACjB,IAAIokC,EAAW,EACf,OAAQ5X,EAAU,IAChB,KAAKwL,EAAiB/M,QAAQ+X,OAC5BoB,EAAW/iC,KAAKC,IAAIykC,EAAU9B,aAAcjkC,GAC5CwmC,EAASr5B,KAAK44B,EAAU9iC,KAAKmhC,IAC7B,MACF,KAAKpM,EAAiB/M,QAAQgY,OAC5BmB,EAAW/iC,KAAKC,IAAItB,EAAQ8lC,EAAS7B,cACrC6B,EAAS7iC,KAAKmhC,GACdoC,EAASt0B,OAAOkyB,GAChB,MACF,KAAKpM,EAAiB/M,QAAQiY,MAC5BkB,EAAW/iC,KAAKC,IAAIwkC,EAAS7B,aAAc8B,EAAU9B,aAAcjkC,GACnE,MAAMkmC,EAASJ,EAAS7iC,KAAKmhC,GACvB+B,EAAUJ,EAAU9iC,KAAKmhC,GAC3Bf,EAAkB6C,EAAO5lC,OAAQ6lC,EAAQ7lC,QAC3CkmC,EAASxxB,OAAOovB,EAAUP,EAAqB93B,KAAKm6B,EAAOviC,WAAYwiC,EAAQxiC,aAE/E6iC,EAASr5B,KAAKg5B,GAASj0B,OAAOkyB,GAIpCpkC,GAAUokC,CACZ,KAEKoC,EAASnB,MAClB,CACA,QAAAqB,CAASpB,EAAWqB,EAAU,MAC5B,MAAMd,EAAO,IAAI9B,EAASnkC,KAAK2R,KAC/B,IAAItP,EAAO,IAAI6iC,EACXryB,EAAI,EACR,KAAOozB,EAAK7B,WAAW,CACrB,GAAwB,WAApB6B,EAAKrB,WACP,OAEF,MAAM0B,EAASL,EAAKtB,OACd59B,EAAQm9B,EAAW9jC,OAAOkmC,GAAUL,EAAK5B,aACzCrjC,EAAiC,iBAAlBslC,EAAO5lC,OAAsB4lC,EAAO5lC,OAAOoI,QAAQi+B,EAAShgC,GAASA,GAAS,EACnG,GAAI/F,EAAQ,EACVqB,EAAKkL,KAAK04B,EAAK5iC,aACV,GAAIrC,EAAQ,EACjBqB,EAAKkL,KAAK04B,EAAK5iC,KAAKrC,QACf,CACL,IAA0D,IAAtD0kC,EAAUrjC,EAAM4jC,EAAK5iC,KAAK,GAAGU,YAAc,CAAC,EAAG8O,GACjD,OAEFA,GAAK,EACLxQ,EAAO,IAAI6iC,CACb,CACF,CACI7iC,EAAKjC,SAAW,GAClBslC,EAAUrjC,EAAM,CAAC,EAAGwQ,EAExB,CACA,MAAAzB,CAAOH,GACL,MAAMq0B,EAAW,IAAIJ,EA4BrB,OA3BAllC,KAAKQ,QAAO,CAACwmC,EAAW14B,KACtB,GAAIA,EAAG5N,OACL4kC,EAAShzB,OAAO4xB,EAAW9jC,OAAOkO,QAC7B,IAAyB,iBAAdA,EAAG8G,QAAwC,MAAjB9G,EAAGvK,WAE7C,OADAuhC,EAASlwB,OAAO9G,EAAG8G,QACZ4xB,EAAY14B,EAAG8G,OACjB,GAAI9G,EAAGgE,QAA+B,iBAAdhE,EAAG8G,OAAqB,CACrD,MAAMhV,EAASkO,EAAGgE,QAAUhE,EAAG8G,OAS/B,OARcnE,EAAK7F,MAAM47B,EAAWA,EAAY5mC,GAC1CsE,SAASuiC,IACT34B,EAAGgE,OACLgzB,EAAS/3B,KAAK05B,GACL34B,EAAG8G,QAAU9G,EAAGvK,YACzBuhC,EAASlwB,OAAO8uB,EAAW9jC,OAAO6mC,GAAShD,EAAqB7yB,OAAO9C,EAAGvK,WAAYkjC,EAAOljC,YAC/F,IAEKijC,EAAY5mC,CACrB,CAAO,GAAyB,iBAAdkO,EAAG8G,QAAqC,OAAd9G,EAAG8G,OAAiB,CAC9D,MAAMhK,EAAQ6F,EAAK7F,MAAM47B,EAAWA,EAAY,GAC1CC,EAAS,IAAI9C,EAAS/4B,EAAMuG,KAAKtO,QAChC4hC,EAAWiC,EAAQC,GAAcnC,EAAoB12B,EAAG8G,OAAQ6xB,EAAOvmC,QACxE2T,EAAU6wB,EAAOG,WAAWJ,GAElC,OADAK,EAASlwB,OAAO,CAAE,CAAC6vB,GAAY5wB,EAAQjD,OAAO81B,EAAQC,IAAelD,EAAqB7yB,OAAO9C,EAAGvK,WAAYkjC,EAAOljC,aAChHijC,EAAY,CACrB,EACA,OAAOA,CAAS,GACf,GACI1B,EAASG,MAClB,CACA,SAAAt1B,CAAUo1B,EAAKvB,GAAW,GAExB,GADAA,IAAaA,EACM,iBAARuB,EACT,OAAOvlC,KAAKgT,kBAAkBuyB,EAAKvB,GAErC,MAAMr7B,EAAQ48B,EACRW,EAAW,IAAI/B,EAASnkC,KAAK2R,KAC7Bw0B,EAAY,IAAIhC,EAASx7B,EAAMgJ,KAC/B5R,EAAQ,IAAImlC,EAClB,KAAOgB,EAAS9B,WAAa+B,EAAU/B,WACrC,GAA4B,WAAxB8B,EAAStB,aAA4BZ,GAAqC,WAAzBmC,EAAUvB,WAExD,GAA6B,WAAzBuB,EAAUvB,WACnB7kC,EAAMwN,KAAK44B,EAAU9iC,YAChB,CACL,MAAMjD,EAASqB,KAAKC,IAAIwkC,EAAS7B,aAAc8B,EAAU9B,cACnDiC,EAASJ,EAAS7iC,KAAKjD,GACvBmmC,EAAUJ,EAAU9iC,KAAKjD,GAC/B,GAAIkmC,EAAOh0B,OACT,SACK,GAAIi0B,EAAQj0B,OACjBvS,EAAMwN,KAAKg5B,OACN,CACL,MAAME,EAAWH,EAAOlxB,OAClBsxB,EAAYH,EAAQnxB,OAC1B,IAAIgyB,EAAuC,iBAAdV,GAAwC,OAAdA,EAAqBA,EAAYtmC,EACxF,GAAwB,iBAAbqmC,GAAsC,OAAbA,GAA0C,iBAAdC,GAAwC,OAAdA,EAAoB,CAC5G,MAAMzB,EAAY74B,OAAOC,KAAKo6B,GAAU,GACxC,GAAIxB,IAAc74B,OAAOC,KAAKq6B,GAAW,GAAI,CAC3C,MAAMryB,EAAU6wB,EAAOG,WAAWJ,GAC9B5wB,IACF+yB,EAAkB,CAChB,CAACnC,GAAY5wB,EAAQlE,UAAUs2B,EAASxB,GAAYyB,EAAUzB,GAAYjB,IAGhF,CACF,CACAjkC,EAAMqV,OAAOgyB,EAAiBnD,EAAqB9zB,UAAUm2B,EAAOviC,WAAYwiC,EAAQxiC,WAAYigC,GACtG,CACF,MA5BEjkC,EAAMqV,OAAO8uB,EAAW9jC,OAAO8lC,EAAS7iC,SA8B5C,OAAOtD,EAAM0lC,MACf,CACA,iBAAAzyB,CAAkBhS,EAAOgjC,GAAW,GAClCA,IAAaA,EACb,MAAMkC,EAAW,IAAI/B,EAASnkC,KAAK2R,KACnC,IAAI/L,EAAS,EACb,KAAOsgC,EAAS9B,WAAax+B,GAAU5E,GAAO,CAC5C,MAAMZ,EAAS8lC,EAAS7B,aAClBgD,EAAWnB,EAAStB,WAC1BsB,EAAS7iC,OACQ,WAAbgkC,GAGoB,WAAbA,IAA0BzhC,EAAS5E,IAAUgjC,KACtDhjC,GAASZ,GAEXwF,GAAUxF,GALRY,GAASS,KAAKC,IAAItB,EAAQY,EAAQ4E,EAMtC,CACA,OAAO5E,CACT,GAEEsmC,EAAgBzmC,EACE,iBAAXrB,SACTA,OAAOD,QAAUsB,EACjBrB,OAAOD,QAAQ8rB,QAAUxqB,2eC/4CtB,IAAAS,EAAA,CAAAA,IACHA,EAAAA,EAAAimC,KAAQ,GAAR,OACAjmC,EAAAA,EAAAkmC,MAAU,IAAV,QAEAlmC,EAAAA,EAAAgvB,UAAa,IAAb,YACAhvB,EAAAA,EAAA0H,KAAQ,IAAR,OACA1H,EAAAA,EAAAkN,OAAU,GAAV,SACAlN,EAAAA,EAAAC,MAAS,IAAT,QAEAD,EAAAA,EAAAuD,WAAa,IAAb,aACAvD,EAAAA,EAAAgK,YAAc,GAAd,cACAhK,EAAAA,EAAA+C,gBAAkB,GAAlB,kBACA/C,EAAAA,EAAAmmC,iBAAmB,GAAnB,mBAEAnmC,EAAAA,EAAAomC,IAAM,IAAN,MAdGpmC,GAAA,CAAAA,GAAA,ICOL,MAAqByqB,EAQnB,WAAA5mB,CACkB6d,EACAwN,EAChB9gB,EAA6B,CAAC,GAFd,KAAAsT,SAAAA,EACA,KAAAwN,QAAAA,EAGV,MAAAmX,EAAermC,EAAMimC,KAAOjmC,EAAMgvB,UACnC,KAAA1rB,MACc,MAAjB8K,EAAQ9K,MAEH8K,EAAQ9K,MAAQtD,EAAMkmC,MAASG,EAChCrmC,EAAMgvB,UACa,MAArB5gB,EAAQmc,YACV7rB,KAAK6rB,UAAYnc,EAAQmc,UAE7B,CArBA,WAAcxf,CAAKxG,GACV,OAAAoC,MAAMC,KAAKrC,EAAK9B,YAAYS,KAAKwM,GAAeA,EAAK7P,MAC9D,CAqBO,GAAAwjB,CAAI9e,EAAmBlF,GAC5B,QAAKX,KAAK4nC,OAAO/hC,EAAMlF,KAGlB,EAAAqH,aAAahI,KAAKwwB,QAAS7vB,IACzB,EACT,CAEO,MAAAinC,CAAO7T,EAAoBpzB,GAC5B,OAAkB,MAAlBX,KAAK6rB,YAGY,iBAAVlrB,EACFX,KAAK6rB,UAAU/iB,QAAQnI,EAAMyI,QAAQ,QAAS,MAAQ,EAEtDpJ,KAAK6rB,UAAU/iB,QAAQnI,IAAU,EAE5C,CAEO,MAAA+B,CAAOmD,GACP,EAAAgiC,gBAAgB7nC,KAAKwwB,QAC5B,CAEO,KAAA7vB,CAAMkF,GACX,MAAMlF,EAAQkF,EAAKgH,aAAa7M,KAAKwwB,SACrC,OAAIxwB,KAAK4nC,OAAO/hC,EAAMlF,IAAUA,EACvBA,EAEF,EACT,EC5DF,MAAqBmnC,UAAuBxkB,MAK1C,WAAAne,CAAY4iC,GAEV9mC,MADA8mC,EAAU,eAAiBA,GAE3B/nC,KAAK+nC,QAAUA,EACV,KAAA5mC,KAAOnB,KAAKmF,YAAYhE,IAC/B,ECOF,MAAqB,EAArB,MAAqB,EAArB,cA0BE,KAAQ4C,WAA4C,CAAC,EACrD,KAAQqsB,QAA8C,CAAC,EACvD,KAAQ4X,KAA2C,CAAC,EACpD,KAAQ5xB,MAA+C,CAAC,EA1BxD,WAAc5J,CAAK3G,EAAoB6c,GAAS,GAC9C,GAAY,MAAR7c,EACK,YAET,GAAI7F,KAAKue,MAAMgV,IAAI1tB,GACjB,OAAO7F,KAAKue,MAAMqE,IAAI/c,IAAS,KAEjC,GAAI6c,EAAQ,CACV,IAAIrc,EAA0B,KAC1B,IACFA,EAAaR,EAAKQ,UAAA,OAMX,WACT,CACO,OAAArG,KAAKwM,KAAKnG,EAAYqc,EAC/B,CACO,WACT,CAOO,MAAAje,CAAOrD,EAAc6mC,EAA8BtnC,GAClD,MAAAyb,EAAQpc,KAAKqB,MAAM4mC,GACzB,GAAa,MAAT7rB,EACF,MAAM,IAAI0rB,EAAe,oBAAoBG,UAE/C,MAAMC,EAAY9rB,EACZvW,EAEJoiC,aAAiBnoB,MAAQmoB,EAAMrU,WAAa9T,KAAK4P,UAC7CuY,EACAC,EAAUzjC,OAAO9D,GAEjBV,EAAO,IAAIioC,EAAU9mC,EAAQyE,EAAclF,GACjD,SAAS4d,MAAMqG,IAAI3kB,EAAKgE,QAAShE,GAC1BA,CACT,CAEO,IAAAuM,CAAK3G,EAAmB6c,GAAS,GAC/B,SAASlW,KAAK3G,EAAM6c,EAC7B,CAEO,KAAArhB,CACLA,EACAuD,EAAetD,EAAMomC,KAEjB,IAAAtrB,EAuBJ,MAtBqB,iBAAV/a,EACT+a,EAAQpc,KAAKoW,MAAM/U,IAAUrB,KAAK+D,WAAW1C,GAEpCA,aAAiBoH,MAAQpH,EAAMuyB,WAAa9T,KAAK4P,UAC1DtT,EAAQpc,KAAKoW,MAAMrU,KACO,iBAAVV,EACZA,EAAQC,EAAMkmC,MAAQlmC,EAAMC,MAC9B6a,EAAQpc,KAAKoW,MAAMjU,MACVd,EAAQC,EAAMkmC,MAAQlmC,EAAMkN,SACrC4N,EAAQpc,KAAKoW,MAAM+xB,QAEZ9mC,aAAiBqb,WACXrb,EAAMwL,aAAa,UAAY,IAAI/K,MAAM,OAClDyF,MAAMpG,IACFib,EAAApc,KAAKowB,QAAQjvB,KACjBib,KAKNA,EAAQA,GAASpc,KAAKgoC,KAAK3mC,EAAMkC,UAEtB,MAAT6Y,EACK,KAGP,UAAWA,GACXxX,EAAQtD,EAAMkmC,MAAQprB,EAAMxX,OAC5BA,EAAQtD,EAAMimC,KAAOnrB,EAAMxX,MAEpBwX,EAEF,IACT,CAEO,QAAArE,IAAYqwB,GACV,OAAAA,EAAY5jC,KAAK6jC,IACtB,MAAMC,EAAS,aAAcD,EACvBE,EAAS,aAAcF,EACzB,IAACC,IAAWC,EACR,UAAIT,EAAe,sBAChB,GAAAQ,GAAkC,aAAxBD,EAAW/kC,SACxB,UAAIwkC,EAAe,kCAE3B,MAAMh8B,EAAMw8B,EACRD,EAAW/kC,SACXilC,EACEF,EAAWrlB,cACV,EACF,YAAA5M,MAAMtK,GAAOu8B,EAEdE,EACgC,iBAAvBF,EAAW7X,UACf,KAAAzsB,WAAWskC,EAAW7X,SAAW6X,GAE/BC,IACLD,EAAWviB,YACR,KAAAsK,QAAQiY,EAAWviB,WAAauiB,GAEnCA,EAAW9kC,UACT0E,MAAMmC,QAAQi+B,EAAW9kC,SAC3B8kC,EAAW9kC,QAAU8kC,EAAW9kC,QAAQiB,KAAKjB,GACpCA,EAAQilC,gBAGN,EAAAjlC,QAAU8kC,EAAW9kC,QAAQilC,eAEzBvgC,MAAMmC,QAAQi+B,EAAW9kC,SACtC8kC,EAAW9kC,QACX,CAAC8kC,EAAW9kC,UACPmB,SAASoX,KACM,MAAlB9b,KAAKgoC,KAAKlsB,IAAwC,MAAxBusB,EAAWviB,aAClC,KAAAkiB,KAAKlsB,GAAOusB,EAAA,MAKlBA,CAAU,GAErB,GAvIc,EAAA9pB,MAAA,IAAYmB,QAD5B,IAAqBwE,EAArB,ECfA,SAAS9H,EAAMvW,EAAmB+uB,GAEhC,OADkB/uB,EAAKgH,aAAa,UAAY,IAE7C/K,MAAM,OACN5B,QAAQiB,GAAwC,IAA/BA,EAAK2H,QAAQ,GAAG8rB,OACtC,CAmCA,QAjCA,cAA8B7I,EAC5B,WAAc1f,CAAKxG,GACT,OAAAA,EAAKgH,aAAa,UAAY,IACnC/K,MAAM,OACN0C,KAAKrD,GAASA,EAAKW,MAAM,KAAKsJ,MAAM,GAAI,GAAGzE,KAAK,MACrD,CAEO,GAAAge,CAAI9e,EAAmBlF,GAC5B,QAAKX,KAAK4nC,OAAO/hC,EAAMlF,KAGvBX,KAAK0C,OAAOmD,GACZA,EAAK6e,UAAUC,IAAI,GAAG3kB,KAAKwwB,WAAW7vB,MAC/B,EACT,CAEO,MAAA+B,CAAOmD,GACIuW,EAAMvW,EAAM7F,KAAKwwB,SACzB9rB,SAASvD,IACV,EAAAujB,UAAUhiB,OAAOvB,EAAK,IAEC,IAA1B0E,EAAK6e,UAAUtkB,QACjByF,EAAKgiC,gBAAgB,QAEzB,CAEO,KAAAlnC,CAAMkF,GAEX,MAAMlF,GADSyb,EAAMvW,EAAM7F,KAAKwwB,SAAS,IAAM,IAC1BplB,MAAMpL,KAAKwwB,QAAQpwB,OAAS,GACjD,OAAOJ,KAAK4nC,OAAO/hC,EAAMlF,GAASA,EAAQ,EAC5C,GCrCF,SAAS8nC,EAAStnC,GACV,MAAAob,EAAQpb,EAAKW,MAAM,KACnB+Z,EAAOU,EACVnR,MAAM,GACN5G,KAAKkkC,GAAiBA,EAAK,GAAGF,cAAgBE,EAAKt9B,MAAM,KACzDzE,KAAK,IACD,OAAA4V,EAAM,GAAKV,CACpB,CAkCA,QAhCA,cAA8BkQ,EAC5B,WAAc1f,CAAKxG,GACT,OAAAA,EAAKgH,aAAa,UAAY,IAAI/K,MAAM,KAAK0C,KAAK7D,GAC5CA,EAAMmB,MAAM,KACb,GAAG2iB,QAElB,CAEO,GAAAE,CAAI9e,EAAmBlF,GAC5B,QAAKX,KAAK4nC,OAAO/hC,EAAMlF,KAIvBkF,EAAKgiB,MAAM4gB,EAASzoC,KAAKwwB,UAAY7vB,GAC9B,EACT,CAEO,MAAA+B,CAAOmD,GAEZA,EAAKgiB,MAAM4gB,EAASzoC,KAAKwwB,UAAY,GAChC3qB,EAAKgH,aAAa,UACrBhH,EAAKgiC,gBAAgB,QAEzB,CAEO,KAAAlnC,CAAMkF,GAEX,MAAMlF,EAAQkF,EAAKgiB,MAAM4gB,EAASzoC,KAAKwwB,UACvC,OAAOxwB,KAAK4nC,OAAO/hC,EAAMlF,GAASA,EAAQ,EAC5C,GCsCF,EAvEA,MAIE,WAAAwE,CAAYlB,GAHZ,KAAQF,WAA4C,CAAC,EAInD/D,KAAKiE,QAAUA,EACfjE,KAAK2oC,OACP,CAEO,SAAAvkC,CAAUA,EAAuBzD,GAElCA,EACEyD,EAAUugB,IAAI3kB,KAAKiE,QAAStD,KACO,MAAjCyD,EAAUzD,MAAMX,KAAKiE,SAClB,KAAAF,WAAWK,EAAU4e,UAAY5e,SAE/BpE,KAAK+D,WAAWK,EAAU4e,YAI3B,EAAAtgB,OAAO1C,KAAKiE,gBACfjE,KAAK+D,WAAWK,EAAU4e,UAErC,CAEO,KAAA2lB,GACL3oC,KAAK+D,WAAa,CAAC,EACnB,MAAM9D,EAAOikB,EAAS1X,KAAKxM,KAAKiE,SAChC,GAAY,MAARhE,EACF,OAEF,MAAM8D,EAAagoB,EAAW1f,KAAKrM,KAAKiE,SAClCmsB,EAAUnE,EAAgB5f,KAAKrM,KAAKiE,SACpCosB,EAASlE,EAAgB9f,KAAKrM,KAAKiE,SAEtC,EAAA0H,OAAOykB,GACPzkB,OAAO0kB,GACP3rB,SAASvD,IACR,MAAMsR,EAAOxS,EAAKmB,OAAOC,MAAMF,EAAMG,EAAMgvB,WACvC7d,aAAgBsZ,IACb,KAAAhoB,WAAW0O,EAAKuQ,UAAYvQ,EAAA,GAGzC,CAEO,IAAAoxB,CAAKjhC,GACVwJ,OAAOC,KAAKrM,KAAK+D,YAAYW,SAASoH,IACpC,MAAMnL,EAAQX,KAAK+D,WAAW+H,GAAKnL,MAAMX,KAAKiE,SACvC,EAAAzC,OAAOsK,EAAKnL,EAAM,GAE7B,CAEO,IAAAioC,CAAKhmC,GACV5C,KAAK6jC,KAAKjhC,GACVwJ,OAAOC,KAAKrM,KAAK+D,YAAYW,SAASoH,IACpC9L,KAAK+D,WAAW+H,GAAKpJ,OAAO1C,KAAKiE,QAAQ,IAE3CjE,KAAK+D,WAAa,CAAC,CACrB,CAEO,MAAAI,GACL,OAAOiI,OAAOC,KAAKrM,KAAK+D,YAAYvD,QAClC,CAACuD,EAAoC5C,KACxB,EAAAA,GAAQnB,KAAK+D,WAAW5C,GAAMR,MAAMX,KAAKiE,SAC7CF,IAET,CAAC,EAEL,GChEI,EAAN,MA+CE,WAAAoB,CACS/D,EACA6C,GADA,KAAA7C,OAAAA,EACA,KAAA6C,QAAAA,EAEE,EAAAsa,MAAMqG,IAAI3gB,EAASjE,MAC5BA,KAAK8E,KAAO,KACZ9E,KAAKqD,KAAO,IACd,CA/CA,aAAcoB,CAAOokC,GACf,GAAgB,MAAhB7oC,KAAKuD,QACD,UAAIukC,EAAe,mCAEvB,IAAAjiC,EACAlF,EACJ,OAAIsH,MAAMmC,QAAQpK,KAAKuD,UACG,iBAAbslC,GACTloC,EAAQkoC,EAASL,cACbtnB,SAASvgB,EAAO,IAAIksB,aAAelsB,IAC7B,EAAAugB,SAASvgB,EAAO,MAEG,iBAAbkoC,IACR,EAAAA,GAGRhjC,EADmB,iBAAVlF,EACF2E,SAASyC,cAAc/H,KAAKuD,QAAQ5C,EAAQ,IAC1CA,GAASX,KAAKuD,QAAQuF,QAAQnI,IAAU,EAC1C2E,SAASyC,cAAcpH,GAEvB2E,SAASyC,cAAc/H,KAAKuD,QAAQ,KAGtC,EAAA+B,SAASyC,cAAc/H,KAAKuD,SAEjCvD,KAAK8lB,WACF,EAAApB,UAAUC,IAAI3kB,KAAK8lB,WAEnBjgB,CACT,CAQA,WAAIlB,GACF,OAAO3E,KAAKmF,WACd,CAUO,MAAArB,GAEP,CAEO,KAAAX,GACL,MAAMc,EAAUjE,KAAKiE,QAAQ6kC,WAAU,GAChC,OAAA9oC,KAAKoB,OAAOqD,OAAOR,EAC5B,CAEO,MAAA0B,GACc,MAAf3F,KAAKoD,QACF,KAAAA,OAAOJ,YAAYhD,MAEjB,EAAAue,MAAMjM,OAAOtS,KAAKiE,QAC7B,CAEO,QAAAlD,CAASC,EAAeZ,GAChBJ,KAAK0H,QAAQ1G,EAAOZ,GAC5BsC,QACP,CAEO,QAAAxB,CACLF,EACAZ,EACAe,EACAR,GAEA,MAAMV,EAAOD,KAAK0H,QAAQ1G,EAAOZ,GAC7B,GAAuC,MAAvCJ,KAAKoB,OAAOC,MAAMF,EAAMG,EAAM0H,OAAiBrI,EAC5C,EAAAsI,KAAK9H,EAAMR,QAAK,GACgC,MAA5CX,KAAKoB,OAAOC,MAAMF,EAAMG,EAAMgvB,WAAoB,CAC3D,MAAMltB,EAASpD,KAAKoB,OAAOqD,OAAOzE,KAAK2E,QAAQC,OAE/C3E,EAAKgJ,KAAK7F,GACH,EAAA5B,OAAOL,EAAMR,EACtB,CACF,CAEO,QAAAgB,CAASX,EAAeL,EAAeiB,GAC5C,MAAM3B,EACG,MAAP2B,EACI5B,KAAKoB,OAAOqD,OAAO,OAAQ9D,GAC3BX,KAAKoB,OAAOqD,OAAO9D,EAAOiB,GAC1BW,EAAMvC,KAAK8B,MAAMd,GACvBhB,KAAKoD,OAAOd,aAAarC,EAAMsC,QAAO,EACxC,CAEO,OAAAmF,CAAQ1G,EAAeZ,GACtB,MAAAwC,EAAS5C,KAAK8B,MAAMd,GAC1B,GAAc,MAAV4B,EACI,UAAI0gB,MAAM,6BAElB,OAAA1gB,EAAOd,MAAM1B,GACNwC,CACT,CAEO,MAAAxC,GACE,QACT,CAEO,MAAAwF,CAAOvG,EAAaW,KAAKoD,QAC9B,OAAmB,MAAfpD,KAAKoD,QAAkBpD,OAASX,EAC3B,EAEFW,KAAKoD,OAAOnB,SAAS2D,OAAO5F,MAAQA,KAAKoD,OAAOwC,OAAOvG,EAChE,CAEO,QAAAwD,CAASkmC,GAEZ/oC,KAAK2E,QAAQ0f,qBACXrkB,KAAKoD,kBAAkBpD,KAAK2E,QAAQ0f,oBAEtCrkB,KAAKiJ,KAAKjJ,KAAK2E,QAAQ0f,kBAAkB/gB,SAE7C,CAEO,MAAAZ,GAC0B,MAA3B1C,KAAKiE,QAAQoC,YACfrG,KAAKiE,QAAQoC,WAAWrD,YAAYhD,KAAKiE,SAE3CjE,KAAK2F,QACP,CAEO,WAAAqjC,CAAY7nC,EAAqBR,GAChC,MAAAsoC,EACY,iBAAT9nC,EAAoBnB,KAAKoB,OAAOqD,OAAOtD,EAAMR,GAASQ,EAC3D,OAAe,MAAfnB,KAAKoD,SACPpD,KAAKoD,OAAOd,aAAa2mC,EAAajpC,KAAKqD,WAAQ,GACnDrD,KAAK0C,UAEAumC,CACT,CAEO,KAAAnnC,CAAMd,EAAekoC,GACnB,OAAU,IAAVloC,EAAchB,KAAOA,KAAKqD,IACnC,CAEO,MAAAgE,CACL8hC,EACAJ,GAGF,CAEO,IAAA9/B,CAAK9H,EAAuBR,GAC3B,MAAA4K,EACY,iBAATpK,EACFnB,KAAKoB,OAAOqD,OAAOtD,EAAMR,GAC1BQ,EAIF,GAHe,MAAfnB,KAAKoD,QACPpD,KAAKoD,OAAOd,aAAaiJ,EAASvL,KAAKqD,WAAQ,GAEd,mBAAxBkI,EAAQ9F,YACjB,MAAM,IAAIqiC,EAAe,eAAe3mC,KAE1C,OAAAoK,EAAQ9F,YAAYzF,MACbuL,CACT,GA5KA,EAAcjI,SAAW,WAD3B,IAAM8lC,EAAN,ECPA,MAAM,EAAN,cAAuBA,EAQrB,YAAczoC,CAAM0oC,GACX,QACT,CAMO,KAAAroC,CAAM6E,EAAYD,GAErB,OAAA5F,KAAKiE,UAAY4B,GACjB7F,KAAKiE,QAAQqlC,wBAAwBzjC,GACnCia,KAAKypB,+BAEA9nC,KAAKC,IAAIkE,EAAQ,IAElB,CACV,CAMO,QAAAE,CAAS9E,EAAewoC,GAE7B,IAAI5jC,EADuBqC,MAAMC,KAAKlI,KAAKoD,OAAOa,QAAQkE,YAClCW,QAAQ9I,KAAKiE,SACrC,OAAIjD,EAAQ,IACA,MAEL,CAAChB,KAAKoD,OAAOa,QAAS2B,EAC/B,CAOO,KAAAjF,GACE,OACL,CAACX,KAAK2E,QAAQrB,UAAWtD,KAAK2E,QAAQhE,MAAMX,KAAKiE,WAAY,EAEjE,GAhDA,EAAcW,MAAQtD,EAAMgK,YAmD9B,QApDA,ECFA,MAAMm+B,EAKJ,WAAAtkC,GACEnF,KAAKwC,KAAO,KACZxC,KAAKkC,KAAO,KACZlC,KAAKI,OAAS,CAChB,CAEO,MAAAgvB,IAAUsa,GAEX,GADJ1pC,KAAKsC,aAAaonC,EAAM,GAAI,MACxBA,EAAMtpC,OAAS,EAAG,CACd,MAAAyb,EAAO6tB,EAAMt+B,MAAM,GACpB,KAAAgkB,UAAUvT,EACjB,CACF,CAEO,EAAA8tB,CAAG3oC,GACF,MAAAqC,EAAOrD,KAAK4pC,WAClB,IAAIhT,EAAMvzB,IACH,KAAAuzB,GAAO51B,EAAQ,GACX,KACT41B,EAAMvzB,IAED,OAAAuzB,CACT,CAEO,QAAAhc,CAAS/U,GACR,MAAAxC,EAAOrD,KAAK4pC,WAClB,IAAIhT,EAAMvzB,IACV,KAAOuzB,GAAK,CACV,GAAIA,IAAQ/wB,EACH,SAET+wB,EAAMvzB,GACR,CACO,QACT,CAEO,OAAAyF,CAAQjD,GACP,MAAAxC,EAAOrD,KAAK4pC,WAClB,IAAIhT,EAAMvzB,IACNrC,EAAQ,EACZ,KAAO41B,GAAK,CACV,GAAIA,IAAQ/wB,EACH,OAAA7E,EAEA,KACT41B,EAAMvzB,GACR,CACO,QACT,CAEO,YAAAf,CAAauD,EAAgBggB,GACtB,MAARhgB,IAGJ7F,KAAK0C,OAAOmD,GACZA,EAAKxC,KAAOwiB,EACG,MAAXA,GACFhgB,EAAKf,KAAO+gB,EAAQ/gB,KACA,MAAhB+gB,EAAQ/gB,OACV+gB,EAAQ/gB,KAAKzB,KAAOwC,GAEtBggB,EAAQ/gB,KAAOe,EACXggB,IAAY7lB,KAAKwC,OACnBxC,KAAKwC,KAAOqD,IAEQ,MAAb7F,KAAKkC,MACdlC,KAAKkC,KAAKmB,KAAOwC,EACjBA,EAAKf,KAAO9E,KAAKkC,KACjBlC,KAAKkC,KAAO2D,IAEZA,EAAKf,KAAO,KACP,KAAAtC,KAAOxC,KAAKkC,KAAO2D,GAE1B7F,KAAKI,QAAU,EACjB,CAEO,MAAAwF,CAAOhD,GACZ,IAAI5B,EAAQ,EACR41B,EAAM52B,KAAKwC,KACf,KAAc,MAAPo0B,GAAa,CAClB,GAAIA,IAAQh0B,EACH,OAAA5B,EAETA,GAAS41B,EAAIx2B,SACbw2B,EAAMA,EAAIvzB,IACZ,CACO,QACT,CAEO,MAAAX,CAAOmD,GACP7F,KAAK4a,SAAS/U,KAGF,MAAbA,EAAKf,OACF,EAAAA,KAAKzB,KAAOwC,EAAKxC,MAEP,MAAbwC,EAAKxC,OACF,EAAAA,KAAKyB,KAAOe,EAAKf,MAEpBe,IAAS7F,KAAKwC,OAChBxC,KAAKwC,KAAOqD,EAAKxC,MAEfwC,IAAS7F,KAAKkC,OAChBlC,KAAKkC,KAAO2D,EAAKf,MAEnB9E,KAAKI,QAAU,EACjB,CAEO,QAAAwpC,CAASC,EAAoB7pC,KAAKwC,MAEvC,MAAO,KACL,MAAMygC,EAAM4G,EACZ,OAAe,MAAXA,IACFA,EAAUA,EAAQxmC,MAEb4/B,CAAG,CAEd,CAEO,IAAAz2B,CAAKxL,EAAekqB,GAAY,GAC/B,MAAA7nB,EAAOrD,KAAK4pC,WAClB,IAAIhT,EAAMvzB,IACV,KAAOuzB,GAAK,CACJ,MAAAx2B,EAASw2B,EAAIx2B,SACnB,GACEY,EAAQZ,GACP8qB,GACClqB,IAAUZ,IACG,MAAZw2B,EAAIvzB,MAAsC,IAAtBuzB,EAAIvzB,KAAKjD,UAEzB,OAACw2B,EAAK51B,GAEN,GAAAZ,EACTw2B,EAAMvzB,GACR,CACO,OAAC,KAAM,EAChB,CAEO,OAAAqB,CAAQolC,GACP,MAAAzmC,EAAOrD,KAAK4pC,WAClB,IAAIhT,EAAMvzB,IACV,KAAOuzB,GACLkT,EAASlT,GACTA,EAAMvzB,GAEV,CAEO,SAAA+J,CACLpM,EACAZ,EACA0pC,GAEA,GAAI1pC,GAAU,EACZ,OAEF,MAAO6G,EAAWrB,GAAU5F,KAAKwM,KAAKxL,GACtC,IAAI+oC,EAAW/oC,EAAQ4E,EACjB,MAAAvC,EAAOrD,KAAK4pC,SAAS3iC,GAC3B,IAAI2vB,EAAMvzB,IACH,KAAAuzB,GAAOmT,EAAW/oC,EAAQZ,GAAQ,CACjC,MAAA4pC,EAAYpT,EAAIx2B,SAClBY,EAAQ+oC,EACVD,EACElT,EACA51B,EAAQ+oC,EACRtoC,KAAKC,IAAItB,EAAQ2pC,EAAWC,EAAYhpC,IAGjC,EAAA41B,EAAK,EAAGn1B,KAAKC,IAAIsoC,EAAWhpC,EAAQZ,EAAS2pC,IAE5C,GAAAC,EACZpT,EAAMvzB,GACR,CACF,CAEO,GAAAmB,CAAIslC,GACT,OAAO9pC,KAAKQ,QAAO,CAACixB,EAAWmF,KACxB,EAAArpB,KAAKu8B,EAASlT,IACZnF,IACN,GACL,CAEO,MAAAjxB,CAAUspC,EAAkCrY,GAC3C,MAAApuB,EAAOrD,KAAK4pC,WAClB,IAAIhT,EAAMvzB,IACV,KAAOuzB,GACE,EAAAkT,EAASrY,EAAMmF,GACtBA,EAAMvzB,IAED,OAAAouB,CACT,EC/LF,SAASwY,EAAiBpkC,EAAYzE,GAC9B,MAAAygC,EAAQzgC,EAAOoL,KAAK3G,GACtB,GAAAg8B,EAAc,OAAAA,EACd,IACK,OAAAzgC,EAAOqD,OAAOoB,EAAI,OAEzB,MAAM5F,EAAOmB,EAAOqD,OAAOnD,EAAMkN,QACjC,OAAAvG,MAAMC,KAAKrC,EAAKsC,YAAYzD,SAASzB,IAC9B,EAAAgB,QAAQwB,YAAYxC,EAAM,IAE7B4C,EAAKQ,YACPR,EAAKQ,WAAW2oB,aAAa/uB,EAAKgE,QAAS4B,GAE7C5F,EAAK6D,SACE7D,CACT,CACF,CAEA,MAAM,EAAN,MAAM,UAAmBmpC,EAgBvB,WAAAjkC,CAAY/D,EAAc6C,GACxBhD,MAAMG,EAAQ6C,GAHhB,KAAO8S,OAA6B,KAIlC/W,KAAK2oC,OACP,CAEO,WAAAljC,CAAYkD,GACjB3I,KAAKsC,aAAaqG,EACpB,CAEO,MAAA7E,GACL7C,MAAM6C,SACD,KAAA7B,SAASyC,SAASzB,IACrBA,EAAMa,QAAQ,GAElB,CAEO,QAAAomC,CAASrkC,GACK,MAAf7F,KAAK+W,QACP/W,KAAK+W,OAAOrU,SAEd1C,KAAK+W,OAASlR,EACV,EAAWic,SACb9hB,KAAK+W,OAAO2N,UAAUC,IAAI,EAAW7C,SAElC,KAAA/K,OAAO/O,aAAa,kBAAmB,SAC5ChI,KAAKiE,QAAQ3B,aAAatC,KAAK+W,OAAQ/W,KAAKiE,QAAQgwB,WACtD,CAKO,KAAA0U,GACA,KAAA1mC,SAAW,IAAIwnC,EAEpBxhC,MAAMC,KAAKlI,KAAKiE,QAAQkE,YACrBjI,QAAQ2F,GAAeA,IAAS7F,KAAK+W,SACrCozB,UACAzlC,SAASmB,IACJ,IACF,MAAM5C,EAAQgnC,EAAiBpkC,EAAM7F,KAAKoB,QAC1CpB,KAAKsC,aAAaW,EAAOjD,KAAKiC,SAASO,WAAQ,EAAS,OACjD4nC,GACP,GAAIA,aAAetC,EACjB,OAEM,MAAAsC,CAEV,IAEN,CAEO,QAAArpC,CAASC,EAAeZ,GAC7B,GAAc,IAAVY,GAAeZ,IAAWJ,KAAKI,SACjC,OAAOJ,KAAK0C,SAEd1C,KAAKiC,SAASmL,UAAUpM,EAAOZ,GAAQ,CAAC6C,EAAO2C,EAAQ0H,KAC/C,EAAAvM,SAAS6E,EAAQ0H,EAAY,GAEvC,CAUO,UAAAzB,CAAWw+B,EAAerpC,EAAQ,GACvC,MAAOiC,EAAO2C,GAAU5F,KAAKiC,SAASuK,KAAKxL,GAExC,OAAqB,MAArBqpC,EAAS/mC,UAAoB+mC,EAASpnC,IACjB,MAArBonC,EAAS/mC,UAAoBL,aAAiBonC,EAExC,CAACpnC,EAAc2C,GACb3C,aAAiB,EACnBA,EAAM4I,WAAWw+B,EAAUzkC,GAE3B,CAAC,MAAO,EAEnB,CAYO,WAAAtF,CACL+pC,EACArpC,EAAQ,EACRZ,EAAiB0M,OAAOC,WAExB,IAAIzM,EAAsB,GACtB6M,EAAa/M,EACjB,OAAAJ,KAAKiC,SAASmL,UACZpM,EACAZ,GACA,CAAC6C,EAAaoK,EAAoBC,MAER,MAArB+8B,EAAS/mC,UAAoB+mC,EAASpnC,IACjB,MAArBonC,EAAS/mC,UAAoBL,aAAiBonC,IAE/C/pC,EAAYiN,KAAKtK,GAEfA,aAAiB,IACnB3C,EAAcA,EAAYqL,OACxB1I,EAAM3C,YAAY+pC,EAAUh9B,EAAYF,KAG9B,GAAAG,CAAA,IAGXhN,CACT,CAEO,MAAAqF,GACA,KAAA1D,SAASyC,SAASzB,IACrBA,EAAM0C,QAAQ,IAEhB1E,MAAM0E,QACR,CAEO,sBAAA2kC,GACL,IAAIC,GAAO,EACN,KAAAtoC,SAASyC,SAASzB,IACjBsnC,GAGYvqC,KAAK2E,QAAQlB,gBAAgB8D,MAC1C3F,GAAyBqB,aAAiBrB,MAKzCqB,EAAM0B,QAAQC,QAAUtD,EAAMuD,YACd,MAAd5B,EAAMI,MACRrD,KAAKwqC,WAAWvnC,GAEA,MAAdA,EAAM6B,MACH,KAAA0lC,WAAWvnC,EAAM6B,MAExB7B,EAAMG,OAAOuE,SACN,MACE1E,aAAiB,EAC1BA,EAAM0E,SAEN1E,EAAMP,SAAO,GAGnB,CAEO,QAAAxB,CACLF,EACAZ,EACAe,EACAR,GAEAX,KAAKiC,SAASmL,UAAUpM,EAAOZ,GAAQ,CAAC6C,EAAO2C,EAAQ0H,KACrDrK,EAAM/B,SAAS0E,EAAQ0H,EAAanM,EAAMR,EAAM,GAEpD,CAEO,QAAAgB,CAASX,EAAeL,EAAeiB,GAC5C,MAAOqB,EAAO2C,GAAU5F,KAAKiC,SAASuK,KAAKxL,GAC3C,GAAIiC,EACI,EAAAtB,SAASiE,EAAQjF,EAAOiB,OACzB,CACL,MAAM3B,EACG,MAAP2B,EACI5B,KAAKoB,OAAOqD,OAAO,OAAQ9D,GAC3BX,KAAKoB,OAAOqD,OAAO9D,EAAOiB,GAChC5B,KAAKyF,YAAYxF,EACnB,CACF,CAEO,YAAAqC,CAAamoC,EAAiBn+B,GACX,MAApBm+B,EAAUrnC,QACF,EAAAA,OAAOnB,SAASS,OAAO+nC,GAEnC,IAAIC,EAA0B,KAC9B1qC,KAAKiC,SAASK,aAAamoC,EAAWn+B,GAAW,MACjDm+B,EAAUrnC,OAASpD,KACJ,MAAXsM,IACFo+B,EAAap+B,EAAQrI,UAGrBjE,KAAKiE,QAAQoC,aAAeokC,EAAUxmC,SACtCjE,KAAKiE,QAAQ6rB,cAAgB4a,IAE7B1qC,KAAKiE,QAAQ3B,aAAamoC,EAAUxmC,QAASymC,GAE/CD,EAAU3mC,QACZ,CAEO,MAAA1D,GACL,OAAOJ,KAAKiC,SAASzB,QAAO,CAACixB,EAAMxuB,IAC1BwuB,EAAOxuB,EAAM7C,UACnB,EACL,CAEO,YAAAuC,CAAagoC,EAAsB9kB,GACnC,KAAA5jB,SAASyC,SAASzB,IACR,EAAAX,aAAaW,EAAO4iB,EAAQ,GAE7C,CAEO,QAAAhjB,CAASC,GAMV,GALJ7B,MAAM4B,SAASC,GACf9C,KAAKsqC,yBACc,MAAftqC,KAAK+W,QAAkB/W,KAAK+W,SAAW/W,KAAKiE,QAAQgwB,YACtDj0B,KAAKiE,QAAQ3B,aAAatC,KAAK+W,OAAQ/W,KAAKiE,QAAQgwB,YAEzB,IAAzBj0B,KAAKiC,SAAS7B,OACZ,GAA6B,MAA7BJ,KAAK2E,QAAQnB,aAAsB,CACrC,MAAMP,EAAQjD,KAAKoB,OAAOqD,OAAOzE,KAAK2E,QAAQnB,aAAaF,UAC3DtD,KAAKyF,YAAYxC,EAAK,MAItBjD,KAAK0C,QAGX,CAEO,IAAAK,CAAK/B,EAAekqB,GAAY,GAC/B,MAACjoB,EAAO2C,GAAU5F,KAAKiC,SAASuK,KAAKxL,EAAOkqB,GAC5CplB,EAA6B,CAAC,CAAC9F,KAAMgB,IAC3C,OAAIiC,aAAiB,EACZ6C,EAAS6F,OAAO1I,EAAMF,KAAK6C,EAAQslB,KACxB,MAATjoB,GACT6C,EAASyH,KAAK,CAACtK,EAAO2C,IAEjBE,EACT,CAEO,WAAA9C,CAAYC,GACZ,KAAAhB,SAASS,OAAOO,EACvB,CAEO,WAAA+lC,CAAY7nC,EAAqBR,GAChC,MAAAsoC,EACY,iBAAT9nC,EAAoBnB,KAAKoB,OAAOqD,OAAOtD,EAAMR,GAASQ,EAC/D,OAAI8nC,aAAuB,GACzBjpC,KAAK2C,aAAasmC,GAEbhoC,MAAM+nC,YAAYC,EAC3B,CAEO,KAAAnnC,CAAMd,EAAekC,GAAQ,GAClC,IAAKA,EAAO,CACV,GAAc,IAAVlC,EACK,OAAAhB,KAEL,GAAAgB,IAAUhB,KAAKI,SACjB,OAAOJ,KAAKqD,IAEhB,CACM,MAAA+mB,EAAQpqB,KAAKmD,QACnB,OAAInD,KAAKoD,QACPpD,KAAKoD,OAAOd,aAAa8nB,EAAOpqB,KAAKqD,WAAQ,GAE1C,KAAApB,SAASmL,UAAUpM,EAAOhB,KAAKI,UAAU,CAAC6C,EAAO2C,EAAQglC,KAC5D,MAAM9oC,EAAQmB,EAAMnB,MAAM8D,EAAQ1C,GACrB,MAATpB,GACFsoB,EAAM3kB,YAAY3D,EAAM,IAGrBsoB,CACT,CAEO,UAAAogB,CAAWvnC,GACV,MAAAmnB,EAAQpqB,KAAKmD,QACZ,KAAc,MAAdF,EAAMI,MACL,EAAAoC,YAAYxC,EAAMI,MAE1B,OAAIrD,KAAKoD,QACPpD,KAAKoD,OAAOd,aAAa8nB,EAAOpqB,KAAKqD,WAAQ,GAExC+mB,CACT,CAEO,MAAAziB,GACD3H,KAAKoD,QACPpD,KAAK2C,aAAa3C,KAAKoD,OAAQpD,KAAKqD,WAAQ,GAE9CrD,KAAK0C,QACP,CAEO,MAAA2E,CACLC,EACAyhC,GAEA,MAAM8B,EAAqB,GACrBC,EAAuB,GACnB,EAAApmC,SAAS8C,IACbA,EAAS5E,SAAW5C,KAAKiE,SAA6B,cAAlBuD,EAASC,OACpC,EAAA8F,QAAQ/F,EAASqjC,YACf,EAAAt9B,QAAQ/F,EAASsjC,cAAY,IAGjC,EAAApmC,SAASmB,IAIpB,GACqB,MAAnBA,EAAKQ,YAEY,WAAjBR,EAAKtC,SACL+B,SAASkiB,KAAK8hB,wBAAwBzjC,GACpCia,KAAKypB,+BAEP,OAEF,MAAMtpC,EAAOD,KAAKoB,OAAOoL,KAAK3G,GAClB,MAAR5F,IAIyB,MAA3BA,EAAKgE,QAAQoC,YACbpG,EAAKgE,QAAQoC,aAAerG,KAAKiE,UAEjChE,EAAK0F,QAAQ,IAId,EAAAzF,QAAQ2F,GACAA,EAAKQ,aAAerG,KAAKiE,SAAW4B,IAAS7F,KAAK+W,SAE1Dg0B,MAAK,CAACpH,EAAGz1B,IACJy1B,IAAMz1B,EACD,EAELy1B,EAAE2F,wBAAwBp7B,GAAK4R,KAAKkrB,4BAC/B,GAED,IAETtmC,SAASmB,IACR,IAAIyG,EAAuB,KACH,MAApBzG,EAAKiqB,cACPxjB,EAAUtM,KAAKoB,OAAOoL,KAAK3G,EAAKiqB,cAElC,MAAM7vB,EAAOgqC,EAAiBpkC,EAAM7F,KAAKoB,SACrCnB,EAAKoD,OAASiJ,GAAwB,MAAbrM,EAAKoD,QACb,MAAfpD,EAAKmD,QACF,EAAAA,OAAOJ,YAAYhD,MAErB,KAAAsC,aAAarC,EAAMqM,QAAW,GAAS,IAGlDtM,KAAKsqC,wBACP,GA1WA,EAAcxoB,QAAU,GA6W1B,QAvXA,ECKM,EAAN,MAAM,UAAmBhL,EAMvB,aAAOrS,CAAO9D,GACL,OAAAM,MAAMwD,OAAO9D,EACtB,CAEA,cAAcuD,CAAQD,EAAsB7C,GAC1C,MAAMgb,EAAQhb,EAAOC,MAAM,EAAWiC,UACtC,GACW,MAAT8Y,GACAnY,EAAQV,UAAa6Y,EAA0B7Y,QAGtC,IAAwB,iBAAjBvD,KAAKuD,QACd,SACE,GAAA0E,MAAMmC,QAAQpK,KAAKuD,SACrB,OAAAU,EAAQV,QAAQmwB,cAG3B,CAIA,WAAAvuB,CAAY/D,EAAc6C,GACxBhD,MAAMG,EAAQ6C,GACdjE,KAAK+D,WAAa,IAAIC,EAAgBhE,KAAKiE,QAC7C,CAEO,MAAAzC,CAAOL,EAAcR,GAC1B,GAAIQ,IAASnB,KAAK2E,QAAQrB,UAAa3C,EAQhC,CACL,MAAMa,EAASxB,KAAKoB,OAAOC,MAAMF,EAAMG,EAAMkN,QAC7C,GAAc,MAAVhN,EACF,OAEEA,aAAkBuqB,EACf,KAAAhoB,WAAWK,UAAU5C,EAAQb,GAElCA,IACCQ,IAASnB,KAAK2E,QAAQrB,UAAYtD,KAAKkE,UAAU/C,KAAUR,IAEvD,KAAAqoC,YAAY7nC,EAAMR,EAE3B,MApBO,KAAAsB,SAASyC,SAASzB,IACfA,aAAiB,IACrBA,EAAQA,EAAMgG,KAAK,EAAW3F,UAAU,IAErC,KAAAS,WAAW8/B,KAAK5gC,EAAoB,IAE3CjD,KAAK2H,QAeT,CAEO,OAAAzD,GACC,MAAAA,EAAUlE,KAAK+D,WAAWI,SAC1B3C,EAASxB,KAAK2E,QAAQT,QAAQlE,KAAKiE,QAASjE,KAAKoB,QACvD,OAAc,MAAVI,IACM,EAAAxB,KAAK2E,QAAQrB,UAAY9B,GAE5B0C,CACT,CAEO,QAAAhD,CACLF,EACAZ,EACAe,EACAR,GAG0B,MAAxBX,KAAKkE,UAAU/C,IACfnB,KAAKoB,OAAOC,MAAMF,EAAMG,EAAMgvB,WAEjBtwB,KAAK0H,QAAQ1G,EAAOZ,GAC5BoB,OAAOL,EAAMR,GAElBM,MAAMC,SAASF,EAAOZ,EAAQe,EAAMR,EAExC,CAEO,QAAAkC,CAASC,GACd7B,MAAM4B,SAASC,GACT,MAAAoB,EAAUlE,KAAKkE,UACrB,GAAoC,IAAhCkI,OAAOC,KAAKnI,GAAS9D,OACvB,OAAOJ,KAAK2H,SAEd,MAAMtE,EAAOrD,KAAKqD,KAEhBA,aAAgB,GAChBA,EAAKyB,OAAS9E,MA3GpB,SACE2rB,EACAC,GAEI,GAAAxf,OAAOC,KAAKsf,GAAMvrB,SAAWgM,OAAOC,KAAKuf,GAAMxrB,OAC1C,SAET,UAAW6qC,KAAQtf,EACjB,GAAIA,EAAKsf,KAAUrf,EAAKqf,GACf,SAGJ,QACT,CA+FMxrB,CAAQvb,EAASb,EAAKa,aAEtBb,EAAKV,aAAa3C,MAClBqD,EAAKX,SAET,CAEO,WAAAsmC,CAAY7nC,EAAqBR,GACtC,MAAMsoC,EAAchoC,MAAM+nC,YAAY7nC,EAAMR,GACvC,YAAAoD,WAAW8/B,KAAKoF,GACdA,CACT,CAEO,MAAA5hC,CACLC,EACAxE,GAEM,MAAAuE,OAAOC,EAAWxE,GACCwE,EAAUC,MAChCC,GACCA,EAAS5E,SAAW5C,KAAKiE,SAA6B,eAAlBuD,EAASC,QAG/CzH,KAAK+D,WAAW4kC,OAEpB,CAEO,IAAA1/B,CAAK9H,EAAuBR,GACjC,MAAM4K,EAAUtK,MAAMgI,KAAK9H,EAAMR,GACjC,OAAI4K,aAAmB,GAChB,KAAAxH,WAAW6kC,KAAKr9B,GAEhBA,CACT,GA7Hc,EAAA9H,gBAAqC,CAAC,EAAYlD,GAChE,EAAc+C,SAAW,SACzB,EAAcsB,MAAQtD,EAAMgK,YAC5B,EAAc/H,QAA6B,OA6H7C,QAjIA,EChBM,EAAN,MAAM,UAAkBuT,EAUtB,aAAOrS,CAAO9D,GACL,OAAAM,MAAMwD,OAAO9D,EACtB,CAEA,cAAcuD,CAAQD,EAAsB7C,GAC1C,MAAMgb,EAAQhb,EAAOC,MAAM,EAAUiC,UACrC,GACW,MAAT8Y,GACAnY,EAAQV,UAAa6Y,EAA0B7Y,QAGtC,IAAwB,iBAAjBvD,KAAKuD,QACd,SACE,GAAA0E,MAAMmC,QAAQpK,KAAKuD,SACrB,OAAAU,EAAQV,QAAQmwB,cAE3B,CAIA,WAAAvuB,CAAY/D,EAAc6C,GACxBhD,MAAMG,EAAQ6C,GACdjE,KAAK+D,WAAa,IAAIC,EAAgBhE,KAAKiE,QAC7C,CAEO,MAAAzC,CAAOL,EAAcR,GAC1B,MAAMa,EAASxB,KAAKoB,OAAOC,MAAMF,EAAMG,EAAMC,OAC/B,MAAVC,IAEOA,aAAkBuqB,EACtB,KAAAhoB,WAAWK,UAAU5C,EAAQb,GACzBQ,IAASnB,KAAK2E,QAAQrB,UAAa3C,EAG5CA,IACCQ,IAASnB,KAAK2E,QAAQrB,UAAYtD,KAAKkE,UAAU/C,KAAUR,IAEvD,KAAAqoC,YAAY7nC,EAAMR,GALlB,KAAAqoC,YAAY,EAAU1lC,UAO/B,CAEO,OAAAY,GACC,MAAAA,EAAUlE,KAAK+D,WAAWI,SAC1B3C,EAASxB,KAAK2E,QAAQT,QAAQlE,KAAKiE,QAASjE,KAAKoB,QACvD,OAAc,MAAVI,IACM,EAAAxB,KAAK2E,QAAQrB,UAAY9B,GAE5B0C,CACT,CAEO,QAAAhD,CACLF,EACAZ,EACAe,EACAR,GAE4C,MAAxCX,KAAKoB,OAAOC,MAAMF,EAAMG,EAAMC,OAC3B,KAAAC,OAAOL,EAAMR,GAElBM,MAAMC,SAASF,EAAOZ,EAAQe,EAAMR,EAExC,CAEO,QAAAgB,CAASX,EAAeL,EAAeiB,GACxC,GAAO,MAAPA,GAAyD,MAA1C5B,KAAKoB,OAAOC,MAAMV,EAAOW,EAAMkN,QAE1C,MAAA7M,SAASX,EAAOL,EAAOiB,OACxB,CACC,MAAAwoB,EAAQpqB,KAAK8B,MAAMd,GACzB,GAAa,MAATopB,EAII,UAAI9G,MAAM,8CAJC,CACjB,MAAMrjB,EAAOD,KAAKoB,OAAOqD,OAAO9D,EAAOiB,GACjC,EAAAwB,OAAOd,aAAarC,EAAMmqB,EAAK,CAIzC,CACF,CAEO,WAAA4e,CAAY7nC,EAAqBR,GACtC,MAAMsoC,EAAchoC,MAAM+nC,YAAY7nC,EAAMR,GACvC,YAAAoD,WAAW8/B,KAAKoF,GACdA,CACT,CAEO,MAAA5hC,CACLC,EACAxE,GAEM,MAAAuE,OAAOC,EAAWxE,GACCwE,EAAUC,MAChCC,GACCA,EAAS5E,SAAW5C,KAAKiE,SAA6B,eAAlBuD,EAASC,QAG/CzH,KAAK+D,WAAW4kC,OAEpB,GAzGA,EAAcrlC,SAAW,QACzB,EAAcsB,MAAQtD,EAAMuD,WAC5B,EAActB,QAA6B,IAC3C,EAAcE,gBAAqC,CACjD+E,EACA,EACAjI,GAsGJ,QA7GA,ECTM,EAAN,cAA4BuW,EAQnB,UAAAo0B,GAEH,OAAc,OAAdlrC,KAAKqD,MAAiBrD,KAAKqD,KAAKsB,QAAQrB,WAAatD,KAAK2E,QAAQrB,QAEtE,CAEO,QAAAvC,CAASC,EAAeZ,GACvB,MAAAW,SAASC,EAAOZ,GACtBJ,KAAKsqC,wBACP,CAEO,QAAAppC,CACLF,EACAZ,EACAe,EACAR,GAEAM,MAAMC,SAASF,EAAOZ,EAAQe,EAAMR,GACpCX,KAAKsqC,wBACP,CAEO,QAAA3oC,CAASX,EAAeL,EAAeiB,GACtC,MAAAD,SAASX,EAAOL,EAAOiB,GAC7B5B,KAAKsqC,wBACP,CAEO,QAAAznC,CAASC,GACd7B,MAAM4B,SAASC,GACX9C,KAAKiC,SAAS7B,OAAS,GAAkB,MAAbJ,KAAKqD,MAAgBrD,KAAKkrC,eACnD,KAAA7nC,KAAKV,aAAa3C,MACvBA,KAAKqD,KAAKX,SAEd,GAvCA,EAAcY,SAAW,YACzB,EAAcsB,MAAQtD,EAAMuD,WAyC9B,QA3CA,EC6BA,EA9BA,cAAwBtE,EACtB,cAAc2D,CAAQmlC,EAAuB8B,GAE7C,CAEO,MAAA3pC,CAAOL,EAAcR,GAI1BM,MAAMC,SAAS,EAAGlB,KAAKI,SAAUe,EAAMR,EACzC,CAEO,QAAAO,CACLF,EACAZ,EACAe,EACAR,GAEc,IAAVK,GAAeZ,IAAWJ,KAAKI,SAC5B,KAAAoB,OAAOL,EAAMR,GAElBM,MAAMC,SAASF,EAAOZ,EAAQe,EAAMR,EAExC,CAEO,OAAAuD,GACL,OAAOlE,KAAK2E,QAAQT,QAAQlE,KAAKiE,QAASjE,KAAKoB,OACjD,GCvBIgqC,EAAkB,CACtBrnC,YAAY,EACZsnC,eAAe,EACfC,uBAAuB,EACvBC,WAAW,EACXC,SAAS,GAKL,EAAN,cAAyB10B,EASvB,WAAA3R,CACSwE,EACP9D,GAGA5E,MAAM,KAAM4E,GAJL,KAAA8D,SAAAA,EAKP3J,KAAKoB,OAASpB,KACdA,KAAK2oC,QACL3oC,KAAK4N,SAAW,IAAI69B,kBAAkBnkC,IACpCtH,KAAKqH,OAAOC,EAAU,IAExBtH,KAAK4N,SAAS89B,QAAQ1rC,KAAKiE,QAASmnC,GACpCprC,KAAK8D,QACP,CAEO,MAAAW,CAAOwjC,EAA8BtnC,GAC1C,OAAOX,KAAK2J,SAASlF,OAAOzE,KAAMioC,EAAOtnC,EAC3C,CAEO,IAAA6L,CAAK3G,EAAmB6c,GAAS,GACtC,MAAMziB,EAAOD,KAAK2J,SAAS6C,KAAK3G,EAAM6c,GACtC,OAAKziB,EAGDA,EAAKmB,SAAWpB,KACXC,EAEFyiB,EAAS1iB,KAAKwM,KAAKvM,EAAKmB,OAAO6C,QAAQoC,YAAY,GAAQ,KALzD,IAMX,CAEO,KAAAhF,CACLA,EACAuD,EAAetD,EAAMomC,KAErB,OAAO1nC,KAAK2J,SAAStI,MAAMA,EAAOuD,EACpC,CAEO,QAAAmT,IAAYqwB,GACjB,OAAOpoC,KAAK2J,SAASoO,YAAYqwB,EACnC,CAEO,KAAAO,GACc,MAAf3oC,KAAKoB,QAGTH,MAAM0nC,OACR,CAEO,MAAAhjC,GACL1E,MAAM0E,SACN3F,KAAK4N,SAASuM,YAChB,CAEO,QAAApZ,CAASC,EAAeZ,GAC7BJ,KAAKqH,SACS,IAAVrG,GAAeZ,IAAWJ,KAAKI,SAC5B,KAAA6B,SAASyC,SAASzB,IACrBA,EAAMP,QAAQ,IAGV,MAAA3B,SAASC,EAAOZ,EAE1B,CAEO,QAAAc,CACLF,EACAZ,EACAe,EACAR,GAEAX,KAAKqH,SACLpG,MAAMC,SAASF,EAAOZ,EAAQe,EAAMR,EACtC,CAEO,QAAAgB,CAASX,EAAeL,EAAeiB,GAC5C5B,KAAKqH,SACC,MAAA1F,SAASX,EAAOL,EAAOiB,EAC/B,CAOO,QAAAiB,CAASyE,EAAiB,GAAIxE,EAAe,CAAC,GACnD7B,MAAM4B,SAASC,GACf,MAAM6oC,EAAe7oC,EAAQ6oC,cAAgB,IAAIjsB,QAEjD,IAAIksB,EAAU3jC,MAAMC,KAAKlI,KAAK4N,SAASC,eAGhC,KAAA+9B,EAAQxrC,OAAS,GACZ,EAAAmN,KAAKq+B,EAAQtnC,OAEzB,MAAMunC,EAAO,CAAC5rC,EAAmB6rC,GAAa,KAChC,MAAR7rC,GAAgBA,IAASD,MAGE,MAA3BC,EAAKgE,QAAQoC,aAGZslC,EAAapY,IAAItzB,EAAKgE,UACzB0nC,EAAa/mB,IAAI3kB,EAAKgE,QAAS,IAE7B6nC,GACFD,EAAK5rC,EAAKmD,QAAM,EAGdP,EAAY5C,IAEX0rC,EAAapY,IAAItzB,EAAKgE,WAGvBhE,aAAgB6W,GACb,EAAA7U,SAASyC,QAAQ7B,GAEX,EAAAyP,OAAOrS,EAAKgE,SACzBhE,EAAK4C,SAASC,GAAO,EAEvB,IAAIipC,EAAYzkC,EAChB,QAASuL,EAAI,EAAGk5B,EAAU3rC,OAAS,EAAGyS,GAAK,EAAG,CAC5C,GAAIA,GApIsB,IAqIlB,UAAIyQ,MAAM,mDA4BX,IA1BG,EAAA5e,SAAS8C,IACjB,MAAMvH,EAAOD,KAAKwM,KAAKhF,EAAS5E,QAAQ,GAC5B,MAAR3C,IAGAA,EAAKgE,UAAYuD,EAAS5E,SACN,cAAlB4E,EAASC,MACXokC,EAAK7rC,KAAKwM,KAAKhF,EAASqoB,iBAAiB,IACzC5nB,MAAMC,KAAKV,EAASqjC,YAAYnmC,SAASmB,IACvC,MAAM5C,EAAQjD,KAAKwM,KAAK3G,GAAM,GAC9BgmC,EAAK5oC,GAAO,GACRA,aAAiB6T,GACb7T,EAAAhB,SAASyC,SAASsnC,IACtBH,EAAKG,GAAY,EAAM,GACvB,KAGqB,eAAlBxkC,EAASC,MAClBokC,EAAK5rC,EAAK6E,OAGd+mC,EAAK5rC,GAAI,IAEN,KAAAgC,SAASyC,QAAQ7B,GACtBkpC,EAAY9jC,MAAMC,KAAKlI,KAAK4N,SAASC,eACrC+9B,EAAUG,EAAU3gC,QACbwgC,EAAQxrC,OAAS,GACZ,EAAAmN,KAAKq+B,EAAQtnC,MAE3B,CACF,CAEO,MAAA+C,CACLC,EACAxE,EAAkC,CAAC,GAEvBwE,EAAAA,GAAatH,KAAK4N,SAASC,cACjC,MAAA89B,EAAA,IAAmBjsB,QAEtB,EAAAlb,KAAKgD,IACJ,MAAMvH,EAAOD,KAAKwM,KAAKhF,EAAS5E,QAAQ,GACxC,OAAY,MAAR3C,EACK,KAEL0rC,EAAapY,IAAItzB,EAAKgE,UACxB0nC,EAAa/oB,IAAI3iB,EAAKgE,SAASsJ,KAAK/F,GAC7B,OAEPmkC,EAAa/mB,IAAI3kB,EAAKgE,QAAS,CAACuD,IACzBvH,EAAA,IAGVyE,SAASzE,IACI,MAARA,GAAgBA,IAASD,MAAQ2rC,EAAapY,IAAItzB,EAAKgE,UACpD,EAAAoD,OAAOskC,EAAa/oB,IAAI3iB,EAAKgE,UAAY,GAAInB,EAAQ,IAGhEA,EAAQ6oC,aAAeA,EACnBA,EAAapY,IAAIvzB,KAAKiE,UACxBhD,MAAMoG,OAAOskC,EAAa/oB,IAAI5iB,KAAKiE,SAAUnB,GAE1C,KAAAD,SAASyE,EAAWxE,EAC3B,GAlMA,EAAcQ,SAAW,SACzB,EAAcE,aAAe3D,EACf,EAAA4D,gBAAqC,CAAC5D,EAAWmF,GAC/D,EAAcJ,MAAQtD,EAAMuD,WAC5B,EAActB,QAAU,MAiM1B,QAtMA,ECbM,EAAN,MAAM,UAAiBhD,EAIrB,aAAckE,CAAO9D,GACZ,OAAA2E,SAASC,eAAe5E,EACjC,CAEA,YAAcA,CAAMsD,GAClB,OAAOA,EAAQ8B,IACjB,CAKA,WAAAZ,CAAY/D,EAAcyE,GACxB5E,MAAMG,EAAQyE,GACd7F,KAAK+B,KAAO/B,KAAK2E,QAAQhE,MAAMX,KAAKiE,QACtC,CAEO,QAAAlD,CAASC,EAAeZ,GAC7BJ,KAAKiE,QAAQ8B,KAAO/F,KAAK+B,KACvB/B,KAAK+B,KAAKqJ,MAAM,EAAGpK,GAAShB,KAAK+B,KAAKqJ,MAAMpK,EAAQZ,EACxD,CAEO,KAAAY,CAAM6E,EAAYD,GACnB,OAAA5F,KAAKiE,UAAY4B,EACZD,GAED,CACV,CAEO,QAAAjE,CAASX,EAAeL,EAAeiB,GACjC,MAAPA,GACG,KAAAG,KAAO/B,KAAK+B,KAAKqJ,MAAM,EAAGpK,GAASL,EAAQX,KAAK+B,KAAKqJ,MAAMpK,GAC3D,KAAAiD,QAAQ8B,KAAO/F,KAAK+B,MAEnB,MAAAJ,SAASX,EAAOL,EAAOiB,EAEjC,CAEO,MAAAxB,GACL,OAAOJ,KAAK+B,KAAK3B,MACnB,CAEO,QAAAyC,CAASC,GACd7B,MAAM4B,SAASC,GACf9C,KAAK+B,KAAO/B,KAAK2E,QAAQhE,MAAMX,KAAKiE,SACX,IAArBjE,KAAK+B,KAAK3B,OACZJ,KAAK0C,SACI1C,KAAKqD,gBAAgB,GAAYrD,KAAKqD,KAAKyB,OAAS9E,OAC7DA,KAAK2B,SAAS3B,KAAKI,SAAWJ,KAAKqD,KAAkB1C,SACrDX,KAAKqD,KAAKX,SAEd,CAEO,QAAAoD,CAAS9E,EAAewoC,GAAa,GACnC,OAACxpC,KAAKiE,QAASjD,EACxB,CAEO,KAAAc,CAAMd,EAAekC,GAAQ,GAClC,IAAKA,EAAO,CACV,GAAc,IAAVlC,EACK,OAAAhB,KAEL,GAAAgB,IAAUhB,KAAKI,SACjB,OAAOJ,KAAKqD,IAEhB,CACM,MAAA+mB,EAAQpqB,KAAKoB,OAAOqD,OAAOzE,KAAKiE,QAAQgoC,UAAUjrC,IACxD,OAAAhB,KAAKoD,OAAOd,aAAa8nB,EAAOpqB,KAAKqD,WAAQ,GAC7CrD,KAAK+B,KAAO/B,KAAK2E,QAAQhE,MAAMX,KAAKiE,SAC7BmmB,CACT,CAEO,MAAA/iB,CACLC,EACAyhC,GAGEzhC,EAAUC,MAAMC,GAEM,kBAAlBA,EAASC,MAA4BD,EAAS5E,SAAW5C,KAAKiE,YAIlEjE,KAAK+B,KAAO/B,KAAK2E,QAAQhE,MAAMX,KAAKiE,SAExC,CAEO,KAAAtD,GACL,OAAOX,KAAK+B,IACd,GA3FA,EAAuBuB,SAAW,OAClC,EAAcsB,MAAQtD,EAAMgK,YA6F9B,QA/FA,ICHI4gC,EAA2B,CAAC,EAGhC,SAASC,EAAoBC,GAE5B,IAAIC,EAAeH,EAAyBE,GAC5C,QAAqB/rC,IAAjBgsC,EACH,OAAOA,EAAa9sC,QAGrB,IAAIC,EAAS0sC,EAAyBE,GAAY,CAGjD7sC,QAAS,CAAC,GAOX,OAHA+sC,EAAoBF,GAAU5sC,EAAQA,EAAOD,QAAS4sC,GAG/C3sC,EAAOD,OACf,CCrBA4sC,EAAoBhP,EAAI,SAAS59B,EAAS8oC,GACzC,IAAI,IAAIv8B,KAAOu8B,EACX8D,EAAoBI,EAAElE,EAAYv8B,KAASqgC,EAAoBI,EAAEhtC,EAASuM,IAC5EM,OAAOurB,eAAep4B,EAASuM,EAAK,CAAE4sB,YAAY,EAAM9V,IAAKylB,EAAWv8B,IAG3E,ECPAqgC,EAAoBI,EAAI,SAASpjB,EAAK8hB,GAAQ,OAAO7+B,OAAO8jB,UAAUiI,eAAe7jB,KAAK6U,EAAK8hB,EAAO,ECCtGkB,EAAoBK,EAAI,SAASjtC,GACX,oBAAXktC,QAA0BA,OAAOC,aAC1CtgC,OAAOurB,eAAep4B,EAASktC,OAAOC,YAAa,CAAE/rC,MAAO,WAE7DyL,OAAOurB,eAAep4B,EAAS,aAAc,CAAEoB,OAAO,GACvD,yGCJA,MAAMgsC,UAAyB1gB,EAAAA,gBAC7BtH,GAAAA,CAAI9e,EAAmBlF,GACrB,IAAIisC,EAAkB,EACtB,GAAc,OAAVjsC,GAA4B,OAAVA,EAAgB,CACpC,MAAMib,EAAS5b,KAAKW,MAAMkF,IAAS,EACnC+mC,EAA4B,OAAVjsC,EAAiBib,EAAS,EAAIA,EAAS,CAC3D,KAA4B,iBAAVjb,IAChBisC,EAAkBjsC,GAEpB,OAAwB,IAApBisC,GACF5sC,KAAK0C,OAAOmD,IACL,GAEF5E,MAAM0jB,IAAI9e,EAAM+mC,EAAgB/f,WACzC,CAEA+a,MAAAA,CAAO/hC,EAAmBlF,GACxB,OAAOM,MAAM2mC,OAAO/hC,EAAMlF,IAAUM,MAAM2mC,OAAO/hC,EAAMqb,SAASvgB,EAAO,IACzE,CAEAA,KAAAA,CAAMkF,GACJ,OAAOqb,SAASjgB,MAAMN,MAAMkF,GAAO,UAAOxF,CAC5C,EASF,MANoB,IAAIssC,EAAiB,SAAU,YAAa,CAC9D/nC,MAAOtD,EAAAA,MAAMC,MAEbsqB,UAAW,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,cC5BnC,MAAMghB,UAAmBjtC,EAAAA,GACvBsF,gBAAkB,aAClBA,eAAiB,aAGnB,QCLA,MAAM4nC,UAAeltC,EAAAA,GACnBsF,gBAAkB,SAClBA,eAAiB,CAAC,KAAM,KAAM,KAAM,KAAM,KAAM,MAEhD,cAAOhB,CAAQD,GACb,OAAOjE,KAAKuD,QAAQuF,QAAQ7E,EAAQV,SAAW,CACjD,EAGF,0BCNA,MAAMwpC,UAAsBhoC,EAAAA,GAC5BgoC,EAAczpC,SAAW,iBACzBypC,EAAcxpC,QAAU,KAExB,MAAMypC,UAAiBptC,EAAAA,GACrB,aAAO6E,CAAO9D,GACZ,MAAMkF,EAAO5E,MAAMwD,SAEnB,OADAoB,EAAKmC,aAAa,YAAarH,GACxBkF,CACT,CAEA,cAAO3B,CAAQD,GACb,OAAOA,EAAQ4I,aAAa,mBAAgBxM,CAC9C,CAEA,eAAO0X,GACLnI,EAAAA,GAAMmI,SAASg1B,EACjB,CAEA5nC,WAAAA,CAAY/D,EAAgB6C,GAC1BhD,MAAMG,EAAQ6C,GACd,MAAMgpC,EAAKhpC,EAAQojB,cAActf,cAAc,QACzCmlC,EAAoBjjC,IACxB,IAAK7I,EAAOwL,YAAa,OACzB,MAAMpL,EAASxB,KAAK2E,QAAQT,QAAQD,EAAS7C,GAC9B,YAAXI,GACFxB,KAAKwB,OAAO,OAAQ,aACpByI,EAAEmE,kBACkB,cAAX5M,IACTxB,KAAKwB,OAAO,OAAQ,WACpByI,EAAEmE,iBACJ,EAEF6+B,EAAGjjC,iBAAiB,YAAakjC,GACjCD,EAAGjjC,iBAAiB,aAAckjC,GAClCltC,KAAKkqC,SAAS+C,EAChB,CAEAzrC,MAAAA,CAAOL,EAAcR,GACfQ,IAASnB,KAAK2E,QAAQrB,UAAY3C,EACpCX,KAAKiE,QAAQ+D,aAAa,YAAarH,GAEvCM,MAAMO,OAAOL,EAAMR,EAEvB,EAEFqsC,EAAS1pC,SAAW,OACpB0pC,EAASzpC,QAAU,KAEnBwpC,EAActpC,gBAAkB,CAACupC,GACjCA,EAAS3oB,kBAAoB0oB,mDCrD7B,MAAMI,UAAazpC,EAAAA,EACjBwB,gBAAkB,OAClBA,eAAiB,CAAC,SAAU,KAE5B,aAAOT,GACL,OAAOxD,MAAMwD,QACf,CAEA,cAAOP,GACL,OAAO,CACT,CAEArB,QAAAA,CAASC,GACP7B,MAAM4B,SAASC,GACX9C,KAAKiE,QAAQV,UAAYvD,KAAK2E,QAAQpB,QAAQ,IAChDvD,KAAKgpC,YAAYhpC,KAAK2E,QAAQrB,SAElC,EAGF,QCpBA,MAAM8pC,UAAa1pC,EAAAA,EACjBwB,gBAAkB,OAClBA,eAAiB,IACjBA,qBAAuB,cACvBA,0BAA4B,CAAC,OAAQ,QAAS,SAAU,MAAO,OAE/D,aAAOT,CAAO9D,GACZ,MAAMkF,EAAO5E,MAAMwD,OAAO9D,GAI1B,OAHAkF,EAAKmC,aAAa,OAAQhI,KAAKqtC,SAAS1sC,IACxCkF,EAAKmC,aAAa,MAAO,uBACzBnC,EAAKmC,aAAa,SAAU,UACrBnC,CACT,CAEA,cAAO3B,CAAQD,GACb,OAAOA,EAAQ4I,aAAa,OAC9B,CAEA,eAAOwgC,CAASpa,GACd,OAAOoa,EAASpa,EAAKjzB,KAAKstC,oBAAsBra,EAAMjzB,KAAKutC,aAC7D,CAEA/rC,MAAAA,CAAOL,EAAcR,GACfQ,IAASnB,KAAK2E,QAAQrB,UAAa3C,EAIrCX,KAAKiE,QAAQ+D,aAAa,OAAQhI,KAAKmF,YAAYkoC,SAAS1sC,IAH5DM,MAAMO,OAAOL,EAAMR,EAKvB,EAGF,SAAS0sC,EAASpa,EAAaua,GAC7B,MAAMC,EAASnoC,SAASyC,cAAc,KACtC0lC,EAAOC,KAAOza,EACd,MAAM0a,EAAWF,EAAOC,KAAKtiC,MAAM,EAAGqiC,EAAOC,KAAK5kC,QAAQ,MAC1D,OAAO0kC,EAAU1kC,QAAQ6kC,IAAa,CACxC,CCrCA,MAAMC,UAAelqC,EAAAA,EACnBwB,gBAAkB,SAClBA,eAAiB,CAAC,MAAO,OAEzB,aAAOT,CAAO9D,GACZ,MAAc,UAAVA,EACK2E,SAASyC,cAAc,OAElB,QAAVpH,EACK2E,SAASyC,cAAc,OAEzB9G,MAAMwD,OAAO9D,EACtB,CAEA,cAAOuD,CAAQD,GACb,MAAwB,QAApBA,EAAQV,QAA0B,MACd,QAApBU,EAAQV,QAA0B,aAAtC,CAEF,EAGF,QCrBA,MAAMsqC,UAAkBnqC,EAAAA,EACtBwB,gBAAkB,YAClBA,eAAiB,IAGnB,QCJA,MAAM4oC,EAAa,CAAC,MAAO,SAAU,SAErC,MAAMC,UAAcpqC,EAAAA,UAClBuB,gBAAkB,QAClBA,eAAiB,MAEjB,aAAOT,CAAO9D,GACZ,MAAMkF,EAAO5E,MAAMwD,OAAO9D,GAI1B,MAHqB,iBAAVA,GACTkF,EAAKmC,aAAa,MAAOhI,KAAKqtC,SAAS1sC,IAElCkF,CACT,CAEA,cAAO3B,CAAQD,GACb,OAAO6pC,EAAWttC,QAChB,CAAC0D,EAAwCE,KACnCH,EAAQ+pC,aAAa5pC,KACvBF,EAAQE,GAAaH,EAAQ4I,aAAazI,IAErCF,IAET,CAAC,EAEL,CAEA,YAAOkY,CAAM6W,GACX,MAAO,qBAAqBtiB,KAAKsiB,IAAQ,yBAAyBtiB,KAAKsiB,EACzE,CAEA,eAAOoa,CAASpa,GACd,OAAOoa,EAASpa,EAAK,CAAC,OAAQ,QAAS,SAAWA,EAAM,MAC1D,CAEA,YAAOtyB,CAAMsD,GACX,OAAOA,EAAQ4I,aAAa,MAC9B,CAIArL,MAAAA,CAAOL,EAAcR,GACfmtC,EAAWhlC,QAAQ3H,IAAS,EAC1BR,EACFX,KAAKiE,QAAQ+D,aAAa7G,EAAMR,GAEhCX,KAAKiE,QAAQ4jC,gBAAgB1mC,GAG/BF,MAAMO,OAAOL,EAAMR,EAEvB,EAGF,QCrDA,MAAMmtC,EAAa,CAAC,SAAU,SAE9B,MAAMG,UAAcpqC,EAAAA,GAClBqB,gBAAkB,QAClBA,iBAAmB,WACnBA,eAAiB,SAEjB,aAAOT,CAAO9D,GACZ,MAAMkF,EAAO5E,MAAMwD,OAAO9D,GAI1B,OAHAkF,EAAKmC,aAAa,cAAe,KACjCnC,EAAKmC,aAAa,kBAAmB,QACrCnC,EAAKmC,aAAa,MAAOhI,KAAKqtC,SAAS1sC,IAChCkF,CACT,CAEA,cAAO3B,CAAQD,GACb,OAAO6pC,EAAWttC,QAChB,CAAC0D,EAAwCE,KACnCH,EAAQ+pC,aAAa5pC,KACvBF,EAAQE,GAAaH,EAAQ4I,aAAazI,IAErCF,IAET,CAAC,EAEL,CAEA,eAAOmpC,CAASpa,GACd,OAAOma,EAAKC,SAASpa,EACvB,CAEA,YAAOtyB,CAAMsD,GACX,OAAOA,EAAQ4I,aAAa,MAC9B,CAIArL,MAAAA,CAAOL,EAAcR,GACfmtC,EAAWhlC,QAAQ3H,IAAS,EAC1BR,EACFX,KAAKiE,QAAQ+D,aAAa7G,EAAMR,GAEhCX,KAAKiE,QAAQ4jC,gBAAgB1mC,GAG/BF,MAAMO,OAAOL,EAAMR,EAEvB,CAEAub,IAAAA,GACE,MAAM,MAAEgyB,GAAUluC,KAAKW,QACvB,MAAQ,YAAWutC,MAAUA,OAC/B,EAGF,2CCnDA,MAAM70B,GAAQC,EAAAA,EAAAA,GAAO,iBAerB,MAAM60B,UAAgBp/B,EAAAA,EAOpB5J,WAAAA,CAAYsK,EAAcC,GAExB,GADAzO,MAAMwO,EAAOC,GACTzH,MAAMmC,QAAQpK,KAAK0P,QAAQyT,WAAY,CACzC,MAAMA,EAAY7d,SAASyC,cAAc,OACzCob,EAAUnb,aAAa,OAAQ,WAwKrC,SACEmb,EACAirB,GAIKnmC,MAAMmC,QAAQgkC,EAAO,MAExBA,EAAS,CAACA,IAEZA,EAAO1pC,SAAS2pC,IACd,MAAMC,EAAQhpC,SAASyC,cAAc,QACrCumC,EAAM5pB,UAAUC,IAAI,cACpB0pB,EAAS3pC,SAAS6pC,IAChB,GAAuB,iBAAZA,EACTC,EAAUF,EAAOC,OACZ,CACL,MAAM/sC,EAAS4K,OAAOC,KAAKkiC,GAAS,GAC9B5tC,EAAQ4tC,EAAQ/sC,GAClByG,MAAMmC,QAAQzJ,GAW1B,SACEwiB,EACA3hB,EACA2C,GAEA,MAAM8jC,EAAQ3iC,SAASyC,cAAc,UACrCkgC,EAAMvjB,UAAUC,IAAK,MAAKnjB,KAC1B2C,EAAOO,SAAS/D,IACd,MAAM8tC,EAASnpC,SAASyC,cAAc,WACxB,IAAVpH,EACF8tC,EAAOzmC,aAAa,QAAS88B,OAAOnkC,IAEpC8tC,EAAOzmC,aAAa,WAAY,YAElCigC,EAAMxiC,YAAYgpC,EAAO,IAE3BtrB,EAAU1d,YAAYwiC,EACxB,CA3BUyG,CAAUJ,EAAO9sC,EAAQb,GAEzB6tC,EAAUF,EAAO9sC,EAAQb,EAE7B,KAEFwiB,EAAU1d,YAAY6oC,EAAM,GAEhC,CAnMMK,CAAYxrB,EAAWnjB,KAAK0P,QAAQyT,WACpC1T,EAAM0T,WAAW9c,YAAY/D,aAAa6gB,EAAW1T,EAAM0T,WAC3DnjB,KAAKmjB,UAAYA,CACnB,MAAO,GAAsC,iBAA3BnjB,KAAK0P,QAAQyT,UAAwB,CACrD,MAAMwG,EAAela,EAAM0T,UAAUxI,cACrC3a,KAAKmjB,UAAYwG,EAAaV,cAAcjpB,KAAK0P,QAAQyT,UAC3D,MACEnjB,KAAKmjB,UAAYnjB,KAAK0P,QAAQyT,UAE1BnjB,KAAKmjB,qBAAqByrB,aAIhC5uC,KAAKmjB,UAAUuB,UAAUC,IAAI,cAC7B3kB,KAAKquC,SAAW,GAChBruC,KAAK6Y,SAAW,CAAC,EACb7Y,KAAK0P,QAAQmJ,UACfzM,OAAOC,KAAKrM,KAAK0P,QAAQmJ,UAAUnU,SAASlD,IAC1C,MAAM6S,EAAUrU,KAAK0P,QAAQmJ,WAAWrX,GACpC6S,GACFrU,KAAK6uC,WAAWrtC,EAAQ6S,EAC1B,IAGJpM,MAAMC,KAAKlI,KAAKmjB,UAAU6K,iBAAiB,mBAAmBtpB,SAC3DujC,IAECjoC,KAAK8D,OAAOmkC,EAAM,IAGtBjoC,KAAKyP,MAAME,GAAGC,EAAAA,GAAMnF,OAAOoF,eAAe,KACxC,MAAO3J,GAASlG,KAAKyP,MAAMrK,UAAUmgB,WACrCvlB,KAAKqH,OAAOnB,EAAM,KAtBlBmT,EAAMY,MAAM,iCAAkCja,KAAK0P,QAwBvD,CAEAm/B,UAAAA,CAAWrtC,EAAgB6S,GACzBrU,KAAK6Y,SAASrX,GAAU6S,CAC1B,CAEAvQ,MAAAA,CAAOmkC,GACL,IAAIzmC,EAASyG,MAAMC,KAAK+/B,EAAMvjB,WAAWlY,MAAMsZ,GACT,IAA7BA,EAAUhd,QAAQ,SAE3B,IAAKtH,EAAQ,OAKb,GAJAA,EAASA,EAAO4J,MAAM,GACA,WAAlB68B,EAAM1kC,SACR0kC,EAAMjgC,aAAa,OAAQ,UAGF,MAAzBhI,KAAK6Y,SAASrX,IACqB,MAAnCxB,KAAKyP,MAAMrO,OAAOC,MAAMG,GAGxB,YADA6X,EAAM4J,KAAK,2CAA4CzhB,EAAQymC,GAGjE,MAAMn4B,EAA8B,WAAlBm4B,EAAM1kC,QAAuB,SAAW,QAC1D0kC,EAAMj+B,iBAAiB8F,GAAY7F,IACjC,IAAItJ,EACJ,GAAsB,WAAlBsnC,EAAM1kC,QAAsB,CAE9B,GAAI0kC,EAAM6G,cAAgB,EAAG,OAE7B,MAAMC,EAAW9G,EAAMv4B,QAAQu4B,EAAM6G,eAEnCnuC,GADEouC,EAASf,aAAa,cAGhBe,EAASpuC,QAAS,EAE9B,MAEIA,GADEsnC,EAAMvjB,UAAU9J,SAAS,eAInBqtB,EAAMtnC,QAAUsnC,EAAM+F,aAAa,UAE7C/jC,EAAEmE,iBAEJpO,KAAKyP,MAAM2W,QACX,MAAOlgB,GAASlG,KAAKyP,MAAMrK,UAAUmgB,WACrC,GAA6B,MAAzBvlB,KAAK6Y,SAASrX,GAChBxB,KAAK6Y,SAASrX,GAAQ8S,KAAKtU,KAAMW,QAC5B,GAELX,KAAKyP,MAAMrO,OAAOC,MAAMG,GAAQ0uB,qBAAqBvsB,EAAAA,UACrD,CAEA,GADAhD,EAAQquC,OAAQ,SAAQxtC,MACnBb,EAAO,OACZX,KAAKyP,MAAM4B,gBACT,IAAIxQ,EAAAA,IAEDuU,OAAOlP,EAAMlF,OAEbsR,OAAOpM,EAAM9F,QACbM,OAAO,CAAE,CAACc,GAASb,IACtBiP,EAAAA,GAAMlC,QAAQC,KAElB,MACE3N,KAAKyP,MAAMjO,OAAOA,EAAQb,EAAOiP,EAAAA,GAAMlC,QAAQC,MAEjD3N,KAAKqH,OAAOnB,EAAM,IAEpBlG,KAAKquC,SAAS9gC,KAAK,CAAC/L,EAAQymC,GAC9B,CAEA5gC,MAAAA,CAAOnB,GACL,MAAMhC,EAAmB,MAATgC,EAAgB,CAAC,EAAIlG,KAAKyP,MAAMoG,UAAU3P,GAC1DlG,KAAKquC,SAAS3pC,SAAS4uB,IACrB,MAAO9xB,EAAQymC,GAAS3U,EACxB,GAAsB,WAAlB2U,EAAM1kC,QAAsB,CAC9B,IAAIkrC,EAAmC,KACvC,GAAa,MAATvoC,EACFuoC,EAAS,UACJ,GAAuB,MAAnBvqC,EAAQ1C,GACjBitC,EAASxG,EAAMhf,cAAc,yBACxB,IAAKhhB,MAAMmC,QAAQlG,EAAQ1C,IAAU,CAC1C,IAAIb,EAAQuD,EAAQ1C,GACC,iBAAVb,IACTA,EAAQA,EAAMyI,QAAQ,KAAM,QAE9BqlC,EAASxG,EAAMhf,cAAe,iBAAgBtoB,MAChD,CACc,MAAV8tC,GAEFxG,EAAMtnC,MAAQ,GAEdsnC,EAAM6G,eAAiB,GAEvBL,EAAOM,UAAW,CAEtB,MAAO,GAAa,MAAT7oC,EACT+hC,EAAMvjB,UAAUhiB,OAAO,aACvBulC,EAAMjgC,aAAa,eAAgB,cAC9B,GAAIigC,EAAM+F,aAAa,SAAU,CAGtC,MAAMrtC,EAAQuD,EAAQ1C,GAChBytC,EACJtuC,IAAUsnC,EAAMp7B,aAAa,UACnB,MAATlM,GAAiBA,EAAMksB,aAAeob,EAAMp7B,aAAa,UAChD,MAATlM,IAAkBsnC,EAAMp7B,aAAa,SACxCo7B,EAAMvjB,UAAUW,OAAO,YAAa4pB,GACpChH,EAAMjgC,aAAa,eAAgBinC,EAASpiB,WAC9C,KAAO,CACL,MAAMoiB,EAA8B,MAAnB/qC,EAAQ1C,GACzBymC,EAAMvjB,UAAUW,OAAO,YAAa4pB,GACpChH,EAAMjgC,aAAa,eAAgBinC,EAASpiB,WAC9C,IAEJ,EAIF,SAAS2hB,EAAUrrB,EAAwB3hB,EAAgBb,GACzD,MAAMsnC,EAAQ3iC,SAASyC,cAAc,UACrCkgC,EAAMjgC,aAAa,OAAQ,UAC3BigC,EAAMvjB,UAAUC,IAAK,MAAKnjB,KAC1BymC,EAAMjgC,aAAa,eAAgB,SACtB,MAATrH,GACFsnC,EAAMtnC,MAAQA,EACdsnC,EAAMjgC,aAAa,aAAe,GAAExG,MAAWb,MAE/CsnC,EAAMjgC,aAAa,aAAcxG,GAEnC2hB,EAAU1d,YAAYwiC,EACxB,CAdAkG,EAAQ55B,SAAW,CAAC,EAiEpB45B,EAAQ55B,SAAW,CACjB4O,UAAW,KACXtK,SAAU,CACRq2B,KAAAA,GACE,MAAMhpC,EAAQlG,KAAKyP,MAAM8G,eACzB,GAAa,MAATrQ,EACJ,GAAqB,IAAjBA,EAAM9F,OAAc,CACtB,MAAM8D,EAAUlE,KAAKyP,MAAMoG,YAC3BzJ,OAAOC,KAAKnI,GAASQ,SAASvD,IAEuB,MAA/CnB,KAAKyP,MAAMrO,OAAOC,MAAMF,EAAMG,EAAAA,MAAMkN,SACtCxO,KAAKyP,MAAMjO,OAAOL,GAAM,EAAOyO,EAAAA,GAAMlC,QAAQC,KAC/C,GAEJ,MACE3N,KAAKyP,MAAMuP,aAAa9Y,EAAMlF,MAAOkF,EAAM9F,OAAQwP,EAAAA,GAAMlC,QAAQC,KAErE,EACAwhC,SAAAA,CAAUxuC,GACR,MAAM,MAAEyuC,GAAUpvC,KAAKyP,MAAMoG,YACf,QAAVlV,GAA4B,MAATyuC,EACrBpvC,KAAKyP,MAAMjO,OAAO,QAAS,QAASoO,EAAAA,GAAMlC,QAAQC,MACxChN,GAAmB,UAAVyuC,GACnBpvC,KAAKyP,MAAMjO,OAAO,SAAS,EAAOoO,EAAAA,GAAMlC,QAAQC,MAElD3N,KAAKyP,MAAMjO,OAAO,YAAab,EAAOiP,EAAAA,GAAMlC,QAAQC,KACtD,EACAiO,MAAAA,CAAOjb,GACL,MAAMuF,EAAQlG,KAAKyP,MAAM8G,eAEnBrS,EAAUlE,KAAKyP,MAAMoG,UAAU3P,GAE/B0V,EAASsF,SAAShd,EAAQ0X,QAAU,EAAG,IAC7C,GAAc,OAAVjb,GAA4B,OAAVA,EAAgB,CACpC,IAAIwlB,EAAqB,OAAVxlB,EAAiB,GAAK,EACX,QAAtBuD,EAAQirC,YAAqBhpB,IAAa,GAC9CnmB,KAAKyP,MAAMjO,OAAO,SAAUoa,EAASuK,EAAUvW,EAAAA,GAAMlC,QAAQC,KAC/D,CACF,EACA0hC,IAAAA,CAAK1uC,IACW,IAAVA,IACFA,EAAQquC,OAAO,oBAEjBhvC,KAAKyP,MAAMjO,OAAO,OAAQb,EAAOiP,EAAAA,GAAMlC,QAAQC,KACjD,EACA2O,IAAAA,CAAK3b,GACH,MAAMuF,EAAQlG,KAAKyP,MAAM8G,eAEnBrS,EAAUlE,KAAKyP,MAAMoG,UAAU3P,GACvB,UAAVvF,EACmB,YAAjBuD,EAAQoY,MAAuC,cAAjBpY,EAAQoY,KACxCtc,KAAKyP,MAAMjO,OAAO,QAAQ,EAAOoO,EAAAA,GAAMlC,QAAQC,MAE/C3N,KAAKyP,MAAMjO,OAAO,OAAQ,YAAaoO,EAAAA,GAAMlC,QAAQC,MAGvD3N,KAAKyP,MAAMjO,OAAO,OAAQb,EAAOiP,EAAAA,GAAMlC,QAAQC,KAEnD,IChQJiC,EAAAA,QAAMmI,SACJ,CACE,kCAAmCiV,EAAAA,GAEnC,0BAA2BhB,EAAAA,GAC3B,+BAAgCI,EAAAA,EAChC,0BAA2BU,EAAAA,GAC3B,8BAA+BG,EAAAA,GAC/B,yBAA0BE,EAAAA,EAC1B,yBAA0BG,EAAAA,EAE1B,0BAA2BpB,EAAAA,GAC3B,+BAAgCG,EAAAA,EAChC,0BAA2BU,EAAAA,GAC3B,8BAA+BG,EAAAA,GAC/B,yBAA0BG,EAAAA,EAC1B,yBAA0BE,EAAAA,IAE5B,GAGF3d,EAAAA,QAAMmI,SACJ,CACE,gBAAiBiU,EAAAA,GACjB,oBAAqBiB,EAAAA,GACrB,iBAAkBqiB,EAElB,qBAAsBjjB,EAAAA,EACtB,gBAAiBU,EAAAA,GACjB,eAAgBI,EAAAA,EAChB,eAAgBG,EAAAA,EAEhB,qBAAsBuf,EACtB,qBAAsBngB,EAAAA,GACtB,iBAAkBogB,EAClB,eAAgByC,EAEhB,eAAgBpC,EAChB,eAAgBqC,EAAAA,GAChB,iBCzFJ,cAAqBrC,EACnBjoC,gBAAkB,SAClBA,eAAiB,CAAC,KAAM,MDwFtB,eAAgBkoC,EAChB,iBAAkBQ,EAClB,iBE5FJ,cAAqBT,EACnBjoC,gBAAkB,SAClBA,eAAiB,CAAC,IAAK,WF2FrB,oBAAqB2oC,EAGrB,gBAAiBE,EACjB,gBAAiBE,EAIjB,kBAAmBE,IAWrB,GAoBF,MAAev+B,EAAK,qBzE5HpB","sources":["webpack://Quill/webpack/universalModuleDefinition","webpack://Quill/./src/blots/block.ts","webpack://Quill/./src/blots/break.ts","webpack://Quill/./src/blots/container.ts","webpack://Quill/./src/blots/cursor.ts","webpack://Quill/./src/blots/embed.ts","webpack://Quill/./src/blots/inline.ts","webpack://Quill/./src/blots/text.ts","webpack://Quill/./src/blots/scroll.ts","webpack://Quill/./src/modules/history.ts","webpack://Quill/./src/modules/uploader.ts","webpack://Quill/./src/modules/input.ts","webpack://Quill/./src/modules/uiNode.ts","webpack://Quill/./src/core.ts","webpack://Quill/../../node_modules/@electrovir/eventemitter3/dist/index.js","webpack://Quill/./src/core/emitter.ts","webpack://Quill/./src/core/logger.ts","webpack://Quill/./src/core/module.ts","webpack://Quill/./src/core/editor.ts","webpack://Quill/./src/core/instances.ts","webpack://Quill/./src/core/composition.ts","webpack://Quill/./src/core/utils/scrollRectIntoView.ts","webpack://Quill/./src/core/utils/createRegistryWithFormats.ts","webpack://Quill/./src/core/quill.ts","webpack://Quill/./src/core/selection.ts","webpack://Quill/./src/core/theme.ts","webpack://Quill/./src/core/utils/cloneDeep.ts","webpack://Quill/./src/core/utils/isEqual.ts","webpack://Quill/./src/formats/align.ts","webpack://Quill/./src/formats/background.ts","webpack://Quill/./src/formats/code.ts","webpack://Quill/./src/formats/color.ts","webpack://Quill/./src/formats/direction.ts","webpack://Quill/./src/formats/font.ts","webpack://Quill/./src/formats/size.ts","webpack://Quill/./src/modules/normalizeExternalHTML/normalizers/googleDocs.ts","webpack://Quill/./src/modules/normalizeExternalHTML/normalizers/msWord.ts","webpack://Quill/./src/modules/normalizeExternalHTML/index.ts","webpack://Quill/./src/modules/clipboard.ts","webpack://Quill/./src/modules/keyboard.ts","webpack://Quill/../../node_modules/quill-delta-es/dist/index.mjs","webpack://Quill/../../node_modules/parchment/src/scope.ts","webpack://Quill/../../node_modules/parchment/src/attributor/attributor.ts","webpack://Quill/../../node_modules/parchment/src/error.ts","webpack://Quill/../../node_modules/parchment/src/registry.ts","webpack://Quill/../../node_modules/parchment/src/attributor/class.ts","webpack://Quill/../../node_modules/parchment/src/attributor/style.ts","webpack://Quill/../../node_modules/parchment/src/attributor/store.ts","webpack://Quill/../../node_modules/parchment/src/blot/abstract/shadow.ts","webpack://Quill/../../node_modules/parchment/src/blot/abstract/leaf.ts","webpack://Quill/../../node_modules/parchment/src/collection/linked-list.ts","webpack://Quill/../../node_modules/parchment/src/blot/abstract/parent.ts","webpack://Quill/../../node_modules/parchment/src/blot/inline.ts","webpack://Quill/../../node_modules/parchment/src/blot/block.ts","webpack://Quill/../../node_modules/parchment/src/blot/abstract/container.ts","webpack://Quill/../../node_modules/parchment/src/blot/embed.ts","webpack://Quill/../../node_modules/parchment/src/blot/scroll.ts","webpack://Quill/../../node_modules/parchment/src/blot/text.ts","webpack://Quill/webpack/bootstrap","webpack://Quill/webpack/runtime/define property getters","webpack://Quill/webpack/runtime/hasOwnProperty shorthand","webpack://Quill/webpack/runtime/make namespace object","webpack://Quill/./src/formats/indent.ts","webpack://Quill/./src/formats/blockquote.ts","webpack://Quill/./src/formats/header.ts","webpack://Quill/./src/formats/list.ts","webpack://Quill/./src/formats/bold.ts","webpack://Quill/./src/formats/link.ts","webpack://Quill/./src/formats/script.ts","webpack://Quill/./src/formats/underline.ts","webpack://Quill/./src/formats/image.ts","webpack://Quill/./src/formats/video.ts","webpack://Quill/./src/modules/toolbar.ts","webpack://Quill/./src/vaadin-quill.ts","webpack://Quill/./src/formats/italic.ts","webpack://Quill/./src/formats/strike.ts"],"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, function() {\nreturn ","import {\n  AttributorStore,\n  BlockBlot,\n  EmbedBlot,\n  LeafBlot,\n  Scope,\n} from 'parchment';\nimport type { Blot, Parent } from 'parchment';\nimport Delta from 'quill-delta-es';\nimport Break from './break.js';\nimport Inline from './inline.js';\nimport TextBlot from './text.js';\n\nconst NEWLINE_LENGTH = 1;\n\nclass Block extends BlockBlot {\n  cache: { delta?: Delta | null; length?: number } = {};\n\n  delta(): Delta {\n    if (this.cache.delta == null) {\n      this.cache.delta = blockDelta(this);\n    }\n    return this.cache.delta;\n  }\n\n  deleteAt(index: number, length: number) {\n    super.deleteAt(index, length);\n    this.cache = {};\n  }\n\n  formatAt(index: number, length: number, name: string, value: unknown) {\n    if (length <= 0) return;\n    if (this.scroll.query(name, Scope.BLOCK)) {\n      if (index + length === this.length()) {\n        this.format(name, value);\n      }\n    } else {\n      super.formatAt(\n        index,\n        Math.min(length, this.length() - index - 1),\n        name,\n        value,\n      );\n    }\n    this.cache = {};\n  }\n\n  insertAt(index: number, value: string, def?: unknown) {\n    if (def != null) {\n      super.insertAt(index, value, def);\n      this.cache = {};\n      return;\n    }\n    if (value.length === 0) return;\n    const lines = value.split('\\n');\n    const text = lines.shift() as string;\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    // TODO: Fix this next time the file is edited.\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    let block: Blot | this = this;\n    lines.reduce((lineIndex, line) => {\n      // @ts-expect-error Fix me later\n      block = block.split(lineIndex, true);\n      block.insertAt(0, line);\n      return line.length;\n    }, index + text.length);\n  }\n\n  insertBefore(blot: Blot, ref?: Blot | null) {\n    const { head } = this.children;\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: Parent, ref?: Blot | null) {\n    super.moveChildren(target, ref);\n    this.cache = {};\n  }\n\n  optimize(context: { [key: string]: any }) {\n    super.optimize(context);\n    this.cache = {};\n  }\n\n  path(index: number) {\n    return super.path(index, true);\n  }\n\n  removeChild(child: Blot) {\n    super.removeChild(child);\n    this.cache = {};\n  }\n\n  split(index: number, force: boolean | undefined = false): Blot | null {\n    if (force && (index === 0 || index >= this.length() - NEWLINE_LENGTH)) {\n      const clone = this.clone();\n      if (index === 0) {\n        this.parent.insertBefore(clone, this);\n        return this;\n      }\n      this.parent.insertBefore(clone, this.next);\n      return clone;\n    }\n    const next = super.split(index, force);\n    this.cache = {};\n    return next;\n  }\n}\nBlock.blotName = 'block';\nBlock.tagName = 'P';\nBlock.defaultChild = Break;\nBlock.allowedChildren = [Break, Inline, EmbedBlot, TextBlot];\n\nclass BlockEmbed extends EmbedBlot {\n  attributes: AttributorStore;\n  domNode: HTMLElement;\n\n  attach() {\n    super.attach();\n    this.attributes = new AttributorStore(this.domNode);\n  }\n\n  delta() {\n    return new Delta().insert(this.value(), {\n      ...this.formats(),\n      ...this.attributes.values(),\n    });\n  }\n\n  format(name: string, value: unknown) {\n    const attribute = this.scroll.query(name, Scope.BLOCK_ATTRIBUTE);\n    if (attribute != null) {\n      // @ts-expect-error TODO: Scroll#query() should return Attributor when scope is attribute\n      this.attributes.attribute(attribute, value);\n    }\n  }\n\n  formatAt(index: number, length: number, name: string, value: unknown) {\n    this.format(name, value);\n  }\n\n  insertAt(index: number, value: string, def?: unknown) {\n    if (def != null) {\n      super.insertAt(index, value, def);\n      return;\n    }\n    const lines = value.split('\\n');\n    const text = lines.pop();\n    const blocks = lines.map((line) => {\n      const block = this.scroll.create(Block.blotName);\n      block.insertAt(0, line);\n      return block;\n    });\n    const ref = this.split(index);\n    blocks.forEach((block) => {\n      this.parent.insertBefore(block, ref);\n    });\n    if (text) {\n      this.parent.insertBefore(this.scroll.create('text', text), ref);\n    }\n  }\n}\nBlockEmbed.scope = Scope.BLOCK_BLOT;\n// It is important for cursor behavior BlockEmbeds use tags that are block level elements\n\nfunction blockDelta(blot: BlockBlot, filter = true) {\n  return blot\n    .descendants(LeafBlot)\n    .reduce((delta, leaf) => {\n      if (leaf.length() === 0) {\n        return delta;\n      }\n      return delta.insert(leaf.value(), bubbleFormats(leaf, {}, filter));\n    }, new Delta())\n    .insert('\\n', bubbleFormats(blot));\n}\n\nfunction bubbleFormats(\n  blot: Blot | null,\n  formats: Record<string, unknown> = {},\n  filter = true,\n): Record<string, unknown> {\n  if (blot == null) return formats;\n  if ('formats' in blot && typeof blot.formats === 'function') {\n    formats = {\n      ...formats,\n      ...blot.formats(),\n    };\n    if (filter) {\n      // exclude syntax highlighting from deltas and getFormat()\n      delete formats['code-token'];\n    }\n  }\n  if (\n    blot.parent == null ||\n    blot.parent.statics.blotName === 'scroll' ||\n    blot.parent.statics.scope !== blot.statics.scope\n  ) {\n    return formats;\n  }\n  return bubbleFormats(blot.parent, formats, filter);\n}\n\nexport { blockDelta, bubbleFormats, BlockEmbed, Block as default };\n","import { EmbedBlot } from 'parchment';\n\nclass Break extends EmbedBlot {\n  static value() {\n    return undefined;\n  }\n\n  optimize() {\n    if (this.prev || this.next) {\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\nexport default Break;\n","import { ContainerBlot } from 'parchment';\n\nclass Container extends ContainerBlot {}\n\nexport default Container;\n","import { EmbedBlot, Scope } from 'parchment';\nimport type { Parent, ScrollBlot } from 'parchment';\nimport type Selection from '../core/selection.js';\nimport TextBlot from './text.js';\nimport type { EmbedContextRange } from './embed.js';\n\nclass Cursor extends EmbedBlot {\n  static blotName = 'cursor';\n  static className = 'ql-cursor';\n  static tagName = 'span';\n  static CONTENTS = '\\uFEFF'; // Zero width no break space\n\n  static value() {\n    return undefined;\n  }\n\n  selection: Selection;\n  textNode: Text;\n  savedLength: number;\n\n  constructor(scroll: ScrollBlot, domNode: HTMLElement, selection: Selection) {\n    super(scroll, domNode);\n    this.selection = selection;\n    this.textNode = document.createTextNode(Cursor.CONTENTS);\n    this.domNode.appendChild(this.textNode);\n    this.savedLength = 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: string, value: unknown) {\n    if (this.savedLength !== 0) {\n      super.format(name, value);\n      return;\n    }\n    // TODO: Fix this next time the file is edited.\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    let target: Parent | this = this;\n    let index = 0;\n    while (target != null && target.statics.scope !== Scope.BLOCK_BLOT) {\n      index += target.offset(target.parent);\n      target = target.parent;\n    }\n    if (target != null) {\n      this.savedLength = Cursor.CONTENTS.length;\n      // @ts-expect-error TODO: allow empty context in Parchment\n      target.optimize();\n      target.formatAt(index, Cursor.CONTENTS.length, name, value);\n      this.savedLength = 0;\n    }\n  }\n\n  index(node: Node, offset: number) {\n    if (node === this.textNode) return 0;\n    return super.index(node, offset);\n  }\n\n  length() {\n    return this.savedLength;\n  }\n\n  position(): [Text, number] {\n    return [this.textNode, this.textNode.data.length];\n  }\n\n  remove() {\n    super.remove();\n    // @ts-expect-error Fix me later\n    this.parent = null;\n  }\n\n  restore(): EmbedContextRange | null {\n    if (this.selection.composing || this.parent == null) return null;\n    const range = this.selection.getNativeRange();\n    // Browser may push down styles/nodes inside the cursor blot.\n    // https://dvcs.w3.org/hg/editing/raw-file/tip/editing.html#push-down-values\n    while (\n      this.domNode.lastChild != null &&\n      this.domNode.lastChild !== this.textNode\n    ) {\n      // @ts-expect-error Fix me later\n      this.domNode.parentNode.insertBefore(\n        this.domNode.lastChild,\n        this.domNode,\n      );\n    }\n\n    const prevTextBlot = this.prev instanceof TextBlot ? this.prev : null;\n    const prevTextLength = prevTextBlot ? prevTextBlot.length() : 0;\n    const nextTextBlot = this.next instanceof TextBlot ? this.next : null;\n    // @ts-expect-error TODO: make TextBlot.text public\n    const nextText = nextTextBlot ? nextTextBlot.text : '';\n    const { textNode } = this;\n    // take text from inside this blot and reset it\n    const newText = textNode.data.split(Cursor.CONTENTS).join('');\n    textNode.data = Cursor.CONTENTS;\n\n    // proactively merge TextBlots around cursor so that optimization\n    // doesn't lose the cursor.  the reason we are here in cursor.restore\n    // could be that the user clicked in prevTextBlot or nextTextBlot, or\n    // the user typed something.\n    let mergedTextBlot;\n    if (prevTextBlot) {\n      mergedTextBlot = prevTextBlot;\n      if (newText || nextTextBlot) {\n        prevTextBlot.insertAt(prevTextBlot.length(), newText + nextText);\n        if (nextTextBlot) {\n          nextTextBlot.remove();\n        }\n      }\n    } else if (nextTextBlot) {\n      mergedTextBlot = nextTextBlot;\n      nextTextBlot.insertAt(0, newText);\n    } else {\n      const newTextNode = document.createTextNode(newText);\n      mergedTextBlot = this.scroll.create(newTextNode);\n      this.parent.insertBefore(mergedTextBlot, this);\n    }\n\n    this.remove();\n    if (range) {\n      // calculate selection to restore\n      const remapOffset = (node: Node, offset: number) => {\n        if (prevTextBlot && node === prevTextBlot.domNode) {\n          return offset;\n        }\n        if (node === textNode) {\n          return prevTextLength + offset - 1;\n        }\n        if (nextTextBlot && node === nextTextBlot.domNode) {\n          return prevTextLength + newText.length + offset;\n        }\n        return null;\n      };\n\n      const start = remapOffset(range.start.node, range.start.offset);\n      const end = remapOffset(range.end.node, range.end.offset);\n      if (start !== null && end !== null) {\n        return {\n          startNode: mergedTextBlot.domNode,\n          startOffset: start,\n          endNode: mergedTextBlot.domNode,\n          endOffset: end,\n        };\n      }\n    }\n    return null;\n  }\n\n  update(mutations: MutationRecord[], context: Record<string, unknown>) {\n    if (\n      mutations.some((mutation) => {\n        return (\n          mutation.type === 'characterData' && mutation.target === this.textNode\n        );\n      })\n    ) {\n      const range = this.restore();\n      if (range) context.range = range;\n    }\n  }\n\n  // Avoid .ql-cursor being a descendant of `<a/>`.\n  // The reason is Safari pushes down `<a/>` on text insertion.\n  // That will cause DOM nodes not sync with the model.\n  //\n  // For example ({I} is the caret), given the markup:\n  //    <a><span class=\"ql-cursor\">\\uFEFF{I}</span></a>\n  // When typing a char \"x\", `<a/>` will be pushed down inside the `<span>` first:\n  //    <span class=\"ql-cursor\"><a>\\uFEFF{I}</a></span>\n  // And then \"x\" will be inserted after `<a/>`:\n  //    <span class=\"ql-cursor\"><a>\\uFEFF</a>d{I}</span>\n  optimize(context?: unknown) {\n    // @ts-expect-error Fix me later\n    super.optimize(context);\n\n    let { parent } = this;\n    while (parent) {\n      if (parent.domNode.tagName === 'A') {\n        this.savedLength = Cursor.CONTENTS.length;\n        // @ts-expect-error TODO: make isolate generic\n        parent.isolate(this.offset(parent), this.length()).unwrap();\n        this.savedLength = 0;\n        break;\n      }\n      parent = parent.parent;\n    }\n  }\n\n  value() {\n    return '';\n  }\n}\n\nexport default Cursor;\n","import type { ScrollBlot } from 'parchment';\nimport { EmbedBlot } from 'parchment';\nimport TextBlot from './text.js';\n\nconst GUARD_TEXT = '\\uFEFF';\n\nexport interface EmbedContextRange {\n  startNode: Node | Text;\n  startOffset: number;\n  endNode?: Node | Text;\n  endOffset?: number;\n}\n\nclass Embed extends EmbedBlot {\n  contentNode: HTMLSpanElement;\n  leftGuard: Text;\n  rightGuard: Text;\n\n  constructor(scroll: ScrollBlot, node: Node) {\n    super(scroll, node);\n    this.contentNode = document.createElement('span');\n    this.contentNode.setAttribute('contenteditable', 'false');\n    Array.from(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: Node, offset: number) {\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: Text): EmbedContextRange | null {\n    let range: EmbedContextRange | null = null;\n    let textNode: Text;\n    const text = node.data.split(GUARD_TEXT).join('');\n    if (node === this.leftGuard) {\n      if (this.prev instanceof TextBlot) {\n        const 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(this.scroll.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(this.scroll.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: MutationRecord[], context: Record<string, unknown>) {\n    mutations.forEach((mutation) => {\n      if (\n        mutation.type === 'characterData' &&\n        (mutation.target === this.leftGuard ||\n          mutation.target === this.rightGuard)\n      ) {\n        const range = this.restore(mutation.target as Text);\n        if (range) context.range = range;\n      }\n    });\n  }\n}\n\nexport default Embed;\n","import { EmbedBlot, InlineBlot, Scope } from 'parchment';\nimport type { BlotConstructor } from 'parchment';\nimport Break from './break.js';\nimport Text from './text.js';\n\nclass Inline extends InlineBlot {\n  static allowedChildren: BlotConstructor[] = [Inline, Break, EmbedBlot, Text];\n  // Lower index means deeper in the DOM tree, since not found (-1) is for embeds\n  static order = [\n    'cursor',\n    'inline', // Must be lower\n    'link', // Chrome wants <a> to be lower\n    'underline',\n    'strike',\n    'italic',\n    'bold',\n    'script',\n    'code', // Must be higher\n  ];\n\n  static compare(self: string, other: string) {\n    const selfIndex = Inline.order.indexOf(self);\n    const otherIndex = Inline.order.indexOf(other);\n    if (selfIndex >= 0 || otherIndex >= 0) {\n      return selfIndex - otherIndex;\n    }\n    if (self === other) {\n      return 0;\n    }\n    if (self < other) {\n      return -1;\n    }\n    return 1;\n  }\n\n  formatAt(index: number, length: number, name: string, value: unknown) {\n    if (\n      Inline.compare(this.statics.blotName, name) < 0 &&\n      this.scroll.query(name, Scope.BLOT)\n    ) {\n      const 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: { [key: string]: any }) {\n    super.optimize(context);\n    if (\n      this.parent instanceof Inline &&\n      Inline.compare(this.statics.blotName, this.parent.statics.blotName) > 0\n    ) {\n      const parent = this.parent.isolate(this.offset(), this.length());\n      // @ts-expect-error TODO: make isolate generic\n      this.moveChildren(parent);\n      parent.wrap(this);\n    }\n  }\n}\n\nexport default Inline;\n","import { TextBlot } from 'parchment';\n\nclass Text extends TextBlot {}\n\n// https://lodash.com/docs#escape\nconst entityMap: Record<string, string> = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;',\n  \"'\": '&#39;',\n};\n\nfunction escapeText(text: string) {\n  return text.replace(/[&<>\"']/g, (s) => entityMap[s]);\n}\n\nexport { Text as default, escapeText };\n","import { ContainerBlot, LeafBlot, Scope, ScrollBlot } from 'parchment';\nimport type { Blot, Parent, EmbedBlot, ParentBlot, Registry } from 'parchment';\nimport Delta, { AttributeMap, Op } from 'quill-delta-es';\nimport Emitter from '../core/emitter.js';\nimport type { EmitterSource } from '../core/emitter.js';\nimport Block, { BlockEmbed, bubbleFormats } from './block.js';\nimport Break from './break.js';\nimport Container from './container.js';\n\ntype RenderBlock =\n  | {\n      type: 'blockEmbed';\n      attributes: AttributeMap;\n      key: string;\n      value: unknown;\n    }\n  | { type: 'block'; attributes: AttributeMap; delta: Delta };\n\nfunction isLine(blot: unknown): blot is Block | BlockEmbed {\n  return blot instanceof Block || blot instanceof BlockEmbed;\n}\n\ninterface UpdatableEmbed {\n  updateContent(change: unknown): void;\n}\n\nfunction isUpdatable(blot: Blot): blot is Blot & UpdatableEmbed {\n  return typeof (blot as unknown as any).updateContent === 'function';\n}\n\nclass Scroll extends ScrollBlot {\n  static blotName = 'scroll';\n  static className = 'ql-editor';\n  static tagName = 'DIV';\n  static defaultChild = Block;\n  static allowedChildren = [Block, BlockEmbed, Container];\n\n  emitter: Emitter;\n  batch: false | MutationRecord[];\n\n  constructor(\n    registry: Registry,\n    domNode: HTMLDivElement,\n    { emitter }: { emitter: Emitter },\n  ) {\n    super(registry, domNode);\n    this.emitter = emitter;\n    this.batch = false;\n    this.optimize();\n    this.enable();\n    this.domNode.addEventListener('dragstart', (e) => this.handleDragStart(e));\n  }\n\n  batchStart() {\n    if (!Array.isArray(this.batch)) {\n      this.batch = [];\n    }\n  }\n\n  batchEnd() {\n    if (!this.batch) return;\n    const mutations = this.batch;\n    this.batch = false;\n    this.update(mutations);\n  }\n\n  emitMount(blot: Blot) {\n    this.emitter.emit(Emitter.events.SCROLL_BLOT_MOUNT, blot);\n  }\n\n  emitUnmount(blot: Blot) {\n    this.emitter.emit(Emitter.events.SCROLL_BLOT_UNMOUNT, blot);\n  }\n\n  emitEmbedUpdate(blot: Blot, change: unknown) {\n    this.emitter.emit(Emitter.events.SCROLL_EMBED_UPDATE, blot, change);\n  }\n\n  deleteAt(index: number, length: number) {\n    const [first, offset] = this.line(index);\n    const [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      const ref =\n        last.children.head instanceof Break ? null : last.children.head;\n      // @ts-expect-error\n      first.moveChildren(last, ref);\n      // @ts-expect-error\n      first.remove();\n    }\n    this.optimize();\n  }\n\n  enable(enabled = true) {\n    this.domNode.setAttribute('contenteditable', enabled ? 'true' : 'false');\n  }\n\n  formatAt(index: number, length: number, format: string, value: unknown) {\n    super.formatAt(index, length, format, value);\n    this.optimize();\n  }\n\n  insertAt(index: number, value: string, def?: unknown) {\n    if (index >= this.length()) {\n      if (def == null || this.scroll.query(value, Scope.BLOCK) == null) {\n        const blot = this.scroll.create(this.statics.defaultChild.blotName);\n        this.appendChild(blot);\n        if (def == null && value.endsWith('\\n')) {\n          blot.insertAt(0, value.slice(0, -1), def);\n        } else {\n          blot.insertAt(0, value, def);\n        }\n      } else {\n        const embed = this.scroll.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: Blot, ref?: Blot | null) {\n    if (blot.statics.scope === Scope.INLINE_BLOT) {\n      const wrapper = this.scroll.create(\n        this.statics.defaultChild.blotName,\n      ) as Parent;\n      wrapper.appendChild(blot);\n      super.insertBefore(wrapper, ref);\n    } else {\n      super.insertBefore(blot, ref);\n    }\n  }\n\n  insertContents(index: number, delta: Delta) {\n    const renderBlocks = this.deltaToRenderBlocks(\n      delta.concat(new Delta().insert('\\n')),\n    );\n    const last = renderBlocks.pop();\n    if (last == null) return;\n\n    this.batchStart();\n\n    const first = renderBlocks.shift();\n    if (first) {\n      const shouldInsertNewlineChar =\n        first.type === 'block' &&\n        (first.delta.length() === 0 ||\n          (!this.descendant(BlockEmbed, index)[0] && index < this.length()));\n      const delta =\n        first.type === 'block'\n          ? first.delta\n          : new Delta().insert({ [first.key]: first.value });\n      insertInlineContents(this, index, delta);\n      const newlineCharLength = first.type === 'block' ? 1 : 0;\n      const lineEndIndex = index + delta.length() + newlineCharLength;\n      if (shouldInsertNewlineChar) {\n        this.insertAt(lineEndIndex - 1, '\\n');\n      }\n\n      const formats = bubbleFormats(this.line(index)[0]);\n      const attributes = AttributeMap.diff(formats, first.attributes) || {};\n      Object.keys(attributes).forEach((name) => {\n        this.formatAt(lineEndIndex - 1, 1, name, attributes[name]);\n      });\n\n      index = lineEndIndex;\n    }\n\n    let [refBlot, refBlotOffset] = this.children.find(index);\n    if (renderBlocks.length) {\n      if (refBlot) {\n        refBlot = refBlot.split(refBlotOffset);\n        refBlotOffset = 0;\n      }\n\n      renderBlocks.forEach((renderBlock) => {\n        if (renderBlock.type === 'block') {\n          const block = this.createBlock(\n            renderBlock.attributes,\n            refBlot || undefined,\n          );\n          insertInlineContents(block, 0, renderBlock.delta);\n        } else {\n          const blockEmbed = this.create(\n            renderBlock.key,\n            renderBlock.value,\n          ) as EmbedBlot;\n          this.insertBefore(blockEmbed, refBlot || undefined);\n          Object.keys(renderBlock.attributes).forEach((name) => {\n            blockEmbed.format(name, renderBlock.attributes[name]);\n          });\n        }\n      });\n    }\n\n    if (last.type === 'block' && last.delta.length()) {\n      const offset = refBlot\n        ? refBlot.offset(refBlot.scroll) + refBlotOffset\n        : this.length();\n      insertInlineContents(this, offset, last.delta);\n    }\n\n    this.batchEnd();\n    this.optimize();\n  }\n\n  isEnabled() {\n    return this.domNode.getAttribute('contenteditable') === 'true';\n  }\n\n  leaf(index: number): [LeafBlot | null, number] {\n    const last = this.path(index).pop();\n    if (!last) {\n      return [null, -1];\n    }\n\n    const [blot, offset] = last;\n    return blot instanceof LeafBlot ? [blot, offset] : [null, -1];\n  }\n\n  line(index: number): [Block | BlockEmbed | null, number] {\n    if (index === this.length()) {\n      return this.line(index - 1);\n    }\n    // @ts-expect-error TODO: make descendant() generic\n    return this.descendant(isLine, index);\n  }\n\n  lines(index = 0, length = Number.MAX_VALUE): (Block | BlockEmbed)[] {\n    const getLines = (\n      blot: ParentBlot,\n      blotIndex: number,\n      blotLength: number,\n    ) => {\n      let lines: (Block | BlockEmbed)[] = [];\n      let lengthLeft = blotLength;\n      blot.children.forEachAt(\n        blotIndex,\n        blotLength,\n        (child, childIndex, childLength) => {\n          if (isLine(child)) {\n            lines.push(child);\n          } else if (child instanceof ContainerBlot) {\n            lines = lines.concat(getLines(child, childIndex, lengthLeft));\n          }\n          lengthLeft -= childLength;\n        },\n      );\n      return lines;\n    };\n    return getLines(this, index, length);\n  }\n\n  optimize(context?: { [key: string]: any }): void;\n  optimize(\n    mutations?: MutationRecord[],\n    context?: { [key: string]: any },\n  ): void;\n  optimize(mutations = [], context = {}) {\n    if (this.batch) 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: number) {\n    return super.path(index).slice(1); // Exclude self\n  }\n\n  remove() {\n    // Never remove self\n  }\n\n  update(source?: EmitterSource): void;\n  update(mutations?: MutationRecord[]): void;\n  update(mutations?: MutationRecord[] | EmitterSource): void {\n    if (this.batch) {\n      if (Array.isArray(mutations)) {\n        this.batch = this.batch.concat(mutations);\n      }\n      return;\n    }\n    let source: EmitterSource = Emitter.sources.USER;\n    if (typeof mutations === 'string') {\n      source = mutations;\n    }\n    if (!Array.isArray(mutations)) {\n      mutations = this.observer.takeRecords();\n    }\n    mutations = mutations.filter(({ target }) => {\n      const blot = this.find(target, true);\n      return blot && !isUpdatable(blot);\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\n  updateEmbedAt(index: number, key: string, change: unknown) {\n    // Currently it only supports top-level embeds (BlockEmbed).\n    // We can update `ParentBlot` in parchment to support inline embeds.\n    const [blot] = this.descendant((b: Blot) => b instanceof BlockEmbed, index);\n    if (blot && blot.statics.blotName === key && isUpdatable(blot)) {\n      blot.updateContent(change);\n    }\n  }\n\n  protected handleDragStart(event: DragEvent) {\n    event.preventDefault();\n  }\n\n  private deltaToRenderBlocks(delta: Delta) {\n    const renderBlocks: RenderBlock[] = [];\n\n    let currentBlockDelta = new Delta();\n    delta.forEach((op) => {\n      const insert = op?.insert;\n      if (!insert) return;\n      if (typeof insert === 'string') {\n        const splitted = insert.split('\\n');\n        splitted.slice(0, -1).forEach((text) => {\n          currentBlockDelta.insert(text, op.attributes);\n          renderBlocks.push({\n            type: 'block',\n            delta: currentBlockDelta,\n            attributes: op.attributes ?? {},\n          });\n          currentBlockDelta = new Delta();\n        });\n        const last = splitted[splitted.length - 1];\n        if (last) {\n          currentBlockDelta.insert(last, op.attributes);\n        }\n      } else {\n        const key = Object.keys(insert)[0];\n        if (!key) return;\n        if (this.query(key, Scope.INLINE)) {\n          currentBlockDelta.push(op);\n        } else {\n          if (currentBlockDelta.length()) {\n            renderBlocks.push({\n              type: 'block',\n              delta: currentBlockDelta,\n              attributes: {},\n            });\n          }\n          currentBlockDelta = new Delta();\n          renderBlocks.push({\n            type: 'blockEmbed',\n            key,\n            value: insert[key],\n            attributes: op.attributes ?? {},\n          });\n        }\n      }\n    });\n\n    if (currentBlockDelta.length()) {\n      renderBlocks.push({\n        type: 'block',\n        delta: currentBlockDelta,\n        attributes: {},\n      });\n    }\n\n    return renderBlocks;\n  }\n\n  private createBlock(attributes: AttributeMap, refBlot?: Blot) {\n    let blotName: string | undefined;\n    const formats: AttributeMap = {};\n\n    Object.entries(attributes).forEach(([key, value]) => {\n      const isBlockBlot = this.query(key, Scope.BLOCK & Scope.BLOT) != null;\n      if (isBlockBlot) {\n        blotName = key;\n      } else {\n        formats[key] = value;\n      }\n    });\n\n    const block = this.create(\n      blotName || this.statics.defaultChild.blotName,\n      blotName ? attributes[blotName] : undefined,\n    ) as ParentBlot;\n\n    this.insertBefore(block, refBlot || undefined);\n\n    const length = block.length();\n    Object.entries(formats).forEach(([key, value]) => {\n      block.formatAt(0, length, key, value);\n    });\n\n    return block;\n  }\n}\n\nfunction insertInlineContents(\n  parent: ParentBlot,\n  index: number,\n  inlineContents: Delta,\n) {\n  inlineContents.reduce((index, op) => {\n    const length = Op.length(op);\n    let attributes = op.attributes || {};\n    if (op.insert != null) {\n      if (typeof op.insert === 'string') {\n        const text = op.insert;\n        parent.insertAt(index, text);\n        const [leaf] = parent.descendant(LeafBlot, index);\n        const formats = bubbleFormats(leaf);\n        attributes = AttributeMap.diff(formats, attributes) || {};\n      } else if (typeof op.insert === 'object') {\n        const key = Object.keys(op.insert)[0]; // There should only be one key\n        if (key == null) return index;\n        parent.insertAt(index, key, op.insert[key]);\n        const isInlineEmbed = parent.scroll.query(key, Scope.INLINE) != null;\n        if (isInlineEmbed) {\n          const [leaf] = parent.descendant(LeafBlot, index);\n          const formats = bubbleFormats(leaf);\n          attributes = AttributeMap.diff(formats, attributes) || {};\n        }\n      }\n    }\n    Object.keys(attributes).forEach((key) => {\n      parent.formatAt(index, length, key, attributes[key]);\n    });\n    return index + length;\n  }, index);\n}\n\nexport default Scroll;\n","import { Scope } from 'parchment';\nimport type Delta from 'quill-delta-es';\nimport Module from '../core/module.js';\nimport Quill from '../core/quill.js';\nimport type Scroll from '../blots/scroll.js';\nimport type { Range } from '../core/selection.js';\n\nexport interface HistoryOptions {\n  userOnly: boolean;\n  delay: number;\n  maxStack: number;\n}\n\nexport interface StackItem {\n  delta: Delta;\n  range: Range | null;\n}\n\ninterface Stack {\n  undo: StackItem[];\n  redo: StackItem[];\n}\n\nclass History extends Module<HistoryOptions> {\n  static DEFAULTS: HistoryOptions = {\n    delay: 1000,\n    maxStack: 100,\n    userOnly: false,\n  };\n\n  lastRecorded = 0;\n  ignoreChange = false;\n  stack: Stack = { undo: [], redo: [] };\n  currentRange: Range | null = null;\n\n  constructor(quill: Quill, options: Partial<HistoryOptions>) {\n    super(quill, options);\n    this.quill.on(\n      Quill.events.EDITOR_CHANGE,\n      (eventName, value, oldValue, source) => {\n        if (eventName === Quill.events.SELECTION_CHANGE) {\n          if (value && source !== Quill.sources.SILENT) {\n            this.currentRange = value;\n          }\n        } else if (eventName === Quill.events.TEXT_CHANGE) {\n          if (!this.ignoreChange) {\n            if (!this.options.userOnly || source === Quill.sources.USER) {\n              this.record(value, oldValue);\n            } else {\n              this.transform(value);\n            }\n          }\n\n          this.currentRange = transformRange(this.currentRange, value);\n        }\n      },\n    );\n\n    this.quill.keyboard.addBinding(\n      { key: 'z', shortKey: true },\n      this.undo.bind(this),\n    );\n    this.quill.keyboard.addBinding(\n      { key: ['z', 'Z'], shortKey: true, shiftKey: true },\n      this.redo.bind(this),\n    );\n    if (/Win/i.test(navigator.platform)) {\n      this.quill.keyboard.addBinding(\n        { key: 'y', shortKey: true },\n        this.redo.bind(this),\n      );\n    }\n\n    this.quill.root.addEventListener('beforeinput', (event) => {\n      if (event.inputType === 'historyUndo') {\n        this.undo();\n        event.preventDefault();\n      } else if (event.inputType === 'historyRedo') {\n        this.redo();\n        event.preventDefault();\n      }\n    });\n  }\n\n  change(source: 'undo' | 'redo', dest: 'redo' | 'undo') {\n    if (this.stack[source].length === 0) return;\n    const item = this.stack[source].pop();\n    if (!item) return;\n    const base = this.quill.getContents();\n    const inverseDelta = item.delta.invert(base);\n    this.stack[dest].push({\n      delta: inverseDelta,\n      range: transformRange(item.range, inverseDelta),\n    });\n    this.lastRecorded = 0;\n    this.ignoreChange = true;\n    this.quill.updateContents(item.delta, Quill.sources.USER);\n    this.ignoreChange = false;\n\n    this.restoreSelection(item);\n  }\n\n  clear() {\n    this.stack = { undo: [], redo: [] };\n  }\n\n  cutoff() {\n    this.lastRecorded = 0;\n  }\n\n  record(changeDelta: Delta, oldDelta: Delta) {\n    if (changeDelta.ops.length === 0) return;\n    this.stack.redo = [];\n    let undoDelta = changeDelta.invert(oldDelta);\n    let undoRange = this.currentRange;\n    const timestamp = Date.now();\n    if (\n      // @ts-expect-error Fix me later\n      this.lastRecorded + this.options.delay > timestamp &&\n      this.stack.undo.length > 0\n    ) {\n      const item = this.stack.undo.pop();\n      if (item) {\n        undoDelta = undoDelta.compose(item.delta);\n        undoRange = item.range;\n      }\n    } else {\n      this.lastRecorded = timestamp;\n    }\n    if (undoDelta.length() === 0) return;\n    this.stack.undo.push({ delta: undoDelta, range: undoRange });\n    // @ts-expect-error Fix me later\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: Delta) {\n    transformStack(this.stack.undo, delta);\n    transformStack(this.stack.redo, delta);\n  }\n\n  undo() {\n    this.change('undo', 'redo');\n  }\n\n  protected restoreSelection(stackItem: StackItem) {\n    if (stackItem.range) {\n      this.quill.setSelection(stackItem.range, Quill.sources.USER);\n    } else {\n      const index = getLastChangeIndex(this.quill.scroll, stackItem.delta);\n      this.quill.setSelection(index, Quill.sources.USER);\n    }\n  }\n}\n\nfunction transformStack(stack: StackItem[], delta: Delta) {\n  let remoteDelta = delta;\n  for (let i = stack.length - 1; i >= 0; i -= 1) {\n    const oldItem = stack[i];\n    stack[i] = {\n      delta: remoteDelta.transform(oldItem.delta, true),\n      range: oldItem.range && transformRange(oldItem.range, remoteDelta),\n    };\n    remoteDelta = oldItem.delta.transform(remoteDelta);\n    if (stack[i].delta.length() === 0) {\n      stack.splice(i, 1);\n    }\n  }\n}\n\nfunction endsWithNewlineChange(scroll: Scroll, delta: Delta) {\n  const 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((attr) => {\n      return scroll.query(attr, Scope.BLOCK) != null;\n    });\n  }\n  return false;\n}\n\nfunction getLastChangeIndex(scroll: Scroll, delta: Delta) {\n  const deleteLength = delta.reduce((length, op) => {\n    return length + (op.delete || 0);\n  }, 0);\n  let changeIndex = delta.length() - deleteLength;\n  if (endsWithNewlineChange(scroll, delta)) {\n    changeIndex -= 1;\n  }\n  return changeIndex;\n}\n\nfunction transformRange(range: Range | null, delta: Delta) {\n  if (!range) return range;\n  const start = delta.transformPosition(range.index);\n  const end = delta.transformPosition(range.index + range.length);\n  return { index: start, length: end - start };\n}\n\nexport { History as default, getLastChangeIndex };\n","import Delta from 'quill-delta-es';\nimport type Quill from '../core/quill.js';\nimport Emitter from '../core/emitter.js';\nimport Module from '../core/module.js';\nimport type { Range } from '../core/selection.js';\n\ninterface UploaderOptions {\n  mimetypes: string[];\n  handler: (this: { quill: Quill }, range: Range, files: File[]) => void;\n}\n\nclass Uploader extends Module<UploaderOptions> {\n  static DEFAULTS: UploaderOptions;\n\n  constructor(quill: Quill, options: Partial<UploaderOptions>) {\n    super(quill, options);\n    quill.root.addEventListener('drop', (e) => {\n      e.preventDefault();\n      let native: ReturnType<typeof document.createRange> | null = null;\n      if (document.caretRangeFromPoint) {\n        native = document.caretRangeFromPoint(e.clientX, e.clientY);\n        // @ts-expect-error\n      } else if (document.caretPositionFromPoint) {\n        // @ts-expect-error\n        const position = document.caretPositionFromPoint(e.clientX, e.clientY);\n        native = document.createRange();\n        native.setStart(position.offsetNode, position.offset);\n        native.setEnd(position.offsetNode, position.offset);\n      }\n\n      const normalized = native && quill.selection.normalizeNative(native);\n      if (normalized) {\n        const range = quill.selection.normalizedToRange(normalized);\n        if (e.dataTransfer?.files) {\n          this.upload(range, e.dataTransfer.files);\n        }\n      }\n    });\n  }\n\n  upload(range: Range, files: FileList | File[]) {\n    const uploads: File[] = [];\n    Array.from(files).forEach((file) => {\n      if (file && this.options.mimetypes?.includes(file.type)) {\n        uploads.push(file);\n      }\n    });\n    if (uploads.length > 0) {\n      // @ts-expect-error Fix me later\n      this.options.handler.call(this, range, uploads);\n    }\n  }\n}\n\nUploader.DEFAULTS = {\n  mimetypes: ['image/png', 'image/jpeg'],\n  handler(range: Range, files: File[]) {\n    if (!this.quill.scroll.query('image')) {\n      return;\n    }\n    const promises = files.map<Promise<string>>((file) => {\n      return new Promise((resolve) => {\n        const reader = new FileReader();\n        reader.onload = () => {\n          resolve(reader.result as string);\n        };\n        reader.readAsDataURL(file);\n      });\n    });\n    Promise.all(promises).then((images) => {\n      const update = images.reduce((delta: Delta, image) => {\n        return delta.insert({ image });\n      }, new Delta().retain(range.index).delete(range.length)) as Delta;\n      this.quill.updateContents(update, Emitter.sources.USER);\n      this.quill.setSelection(\n        range.index + images.length,\n        Emitter.sources.SILENT,\n      );\n    });\n  },\n};\n\nexport default Uploader;\n","import Delta from 'quill-delta-es';\nimport Module from '../core/module.js';\nimport Quill from '../core/quill.js';\nimport type { Range } from '../core/selection.js';\nimport { deleteRange } from './keyboard.js';\n\nconst INSERT_TYPES = ['insertText', 'insertReplacementText'];\n\nclass Input extends Module {\n  constructor(quill: Quill, options: Record<string, never>) {\n    super(quill, options);\n\n    quill.root.addEventListener('beforeinput', (event) => {\n      this.handleBeforeInput(event);\n    });\n\n    // Gboard with English input on Android triggers `compositionstart` sometimes even\n    // users are not going to type anything.\n    if (!/Android/i.test(navigator.userAgent)) {\n      quill.on(Quill.events.COMPOSITION_BEFORE_START, () => {\n        this.handleCompositionStart();\n      });\n    }\n  }\n\n  private deleteRange(range: Range) {\n    deleteRange({ range, quill: this.quill });\n  }\n\n  private replaceText(range: Range, text = '') {\n    if (range.length === 0) return false;\n\n    if (text) {\n      // Follow the native behavior that inherits the formats of the first character\n      const formats = this.quill.getFormat(range.index, 1);\n      this.deleteRange(range);\n      this.quill.updateContents(\n        new Delta().retain(range.index).insert(text, formats),\n        Quill.sources.USER,\n      );\n    } else {\n      this.deleteRange(range);\n    }\n\n    this.quill.setSelection(range.index + text.length, 0, Quill.sources.SILENT);\n    return true;\n  }\n\n  private handleBeforeInput(event: InputEvent) {\n    if (\n      this.quill.composition.isComposing ||\n      event.defaultPrevented ||\n      !INSERT_TYPES.includes(event.inputType)\n    ) {\n      return;\n    }\n\n    const staticRange = event.getTargetRanges\n      ? event.getTargetRanges()[0]\n      : null;\n    if (!staticRange || staticRange.collapsed === true) {\n      return;\n    }\n\n    const text = getPlainTextFromInputEvent(event);\n    if (text == null) {\n      return;\n    }\n    const normalized = this.quill.selection.normalizeNative(staticRange);\n    const range = normalized\n      ? this.quill.selection.normalizedToRange(normalized)\n      : null;\n    if (range && this.replaceText(range, text)) {\n      event.preventDefault();\n    }\n  }\n\n  private handleCompositionStart() {\n    const range = this.quill.getSelection();\n    if (range) {\n      this.replaceText(range);\n    }\n  }\n}\n\nfunction getPlainTextFromInputEvent(event: InputEvent) {\n  // When `inputType` is \"insertText\":\n  // - `event.data` should be string (Safari uses `event.dataTransfer`).\n  // - `event.dataTransfer` should be null.\n  // When `inputType` is \"insertReplacementText\":\n  // - `event.data` should be null.\n  // - `event.dataTransfer` should contain \"text/plain\" data.\n\n  if (typeof event.data === 'string') {\n    return event.data;\n  }\n  if (event.dataTransfer?.types.includes('text/plain')) {\n    return event.dataTransfer.getData('text/plain');\n  }\n  return null;\n}\n\nexport default Input;\n","import { ParentBlot } from 'parchment';\nimport Module from '../core/module.js';\nimport Quill from '../core/quill.js';\n\nconst isMac = /Mac/i.test(navigator.platform);\n\n// Export for testing\nexport const TTL_FOR_VALID_SELECTION_CHANGE = 100;\n\n// A loose check to determine if the shortcut can move the caret before a UI node:\n// <ANY_PARENT>[CARET]<div class=\"ql-ui\"></div>[CONTENT]</ANY_PARENT>\nconst canMoveCaretBeforeUINode = (event: KeyboardEvent) => {\n  if (\n    event.key === 'ArrowLeft' ||\n    event.key === 'ArrowRight' || // RTL scripts or moving from the end of the previous line\n    event.key === 'ArrowUp' ||\n    event.key === 'ArrowDown' ||\n    event.key === 'Home'\n  ) {\n    return true;\n  }\n\n  if (isMac && event.key === 'a' && event.ctrlKey === true) {\n    return true;\n  }\n\n  return false;\n};\n\nclass UINode extends Module {\n  isListening = false;\n  selectionChangeDeadline = 0;\n\n  constructor(quill: Quill, options: Record<string, never>) {\n    super(quill, options);\n\n    this.handleArrowKeys();\n    this.handleNavigationShortcuts();\n  }\n\n  private handleArrowKeys() {\n    this.quill.keyboard.addBinding({\n      key: ['ArrowLeft', 'ArrowRight'],\n      offset: 0,\n      shiftKey: null,\n      handler(range, { line, event }) {\n        if (!(line instanceof ParentBlot) || !line.uiNode) {\n          return true;\n        }\n\n        const isRTL = getComputedStyle(line.domNode)['direction'] === 'rtl';\n        if (\n          (isRTL && event.key !== 'ArrowRight') ||\n          (!isRTL && event.key !== 'ArrowLeft')\n        ) {\n          return true;\n        }\n\n        this.quill.setSelection(\n          range.index - 1,\n          range.length + (event.shiftKey ? 1 : 0),\n          Quill.sources.USER,\n        );\n        return false;\n      },\n    });\n  }\n\n  private handleNavigationShortcuts() {\n    this.quill.root.addEventListener('keydown', (event) => {\n      if (!event.defaultPrevented && canMoveCaretBeforeUINode(event)) {\n        this.ensureListeningToSelectionChange();\n      }\n    });\n  }\n\n  /**\n   * We only listen to the `selectionchange` event when\n   * there is an intention of moving the caret to the beginning using shortcuts.\n   * This is primarily implemented to prevent infinite loops, as we are changing\n   * the selection within the handler of a `selectionchange` event.\n   */\n  private ensureListeningToSelectionChange() {\n    this.selectionChangeDeadline = Date.now() + TTL_FOR_VALID_SELECTION_CHANGE;\n\n    if (this.isListening) return;\n    this.isListening = true;\n\n    const listener = () => {\n      this.isListening = false;\n\n      if (Date.now() <= this.selectionChangeDeadline) {\n        this.handleSelectionChange();\n      }\n    };\n\n    document.addEventListener('selectionchange', listener, {\n      once: true,\n    });\n  }\n\n  private handleSelectionChange() {\n    const selection = document.getSelection();\n    if (!selection) return;\n    const range = selection.getRangeAt(0);\n    if (range.collapsed !== true || range.startOffset !== 0) return;\n\n    const line = this.quill.scroll.find(range.startContainer);\n    if (!(line instanceof ParentBlot) || !line.uiNode) return;\n\n    const newRange = document.createRange();\n    newRange.setStartAfter(line.uiNode);\n    newRange.setEndAfter(line.uiNode);\n    selection.removeAllRanges();\n    selection.addRange(newRange);\n  }\n}\n\nexport default UINode;\n","import Quill, { Parchment, Range } from './core/quill.js';\nimport type {\n  Bounds,\n  DebugLevel,\n  EmitterSource,\n  ExpandedQuillOptions,\n  QuillOptions,\n} from './core/quill.js';\n\nimport Block, { BlockEmbed } from './blots/block.js';\nimport Break from './blots/break.js';\nimport Container from './blots/container.js';\nimport Cursor from './blots/cursor.js';\nimport Embed from './blots/embed.js';\nimport Inline from './blots/inline.js';\nimport Scroll from './blots/scroll.js';\nimport TextBlot from './blots/text.js';\n\nimport Clipboard from './modules/clipboard.js';\nimport History from './modules/history.js';\nimport Keyboard from './modules/keyboard.js';\nimport Uploader from './modules/uploader.js';\nimport Delta, { Op, OpIterator, AttributeMap } from 'quill-delta-es';\nimport Input from './modules/input.js';\nimport UINode from './modules/uiNode.js';\n\nexport { default as Module } from './core/module.js';\nexport { Delta, Op, OpIterator, AttributeMap, Parchment, Range };\nexport type {\n  Bounds,\n  DebugLevel,\n  EmitterSource,\n  ExpandedQuillOptions,\n  QuillOptions,\n};\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  'modules/uploader': Uploader,\n  'modules/input': Input,\n  'modules/uiNode': UINode,\n});\n\nexport default Quill;\n","/** Representation of a single event listener. */\nclass WrappedListener {\n    listener;\n    context;\n    once;\n    constructor(listener, context, once = false) {\n        this.listener = listener;\n        this.context = context;\n        this.once = once;\n    }\n}\n/** Minimal `EventEmitter` interface that is molded against the Node.js `EventEmitter` interface. */\nexport class EventEmitter {\n    static prefixed = false;\n    /**\n     * Use Object.create(null) to create a truly empty object for storing events, avoiding potential\n     * prototype pollution or interference from built-in Object properties.\n     */\n    _events = Object.create(null);\n    _eventsCount = 0;\n    /** Add a listener for a given event. */\n    #addListener(event, listener, context, once) {\n        if (typeof listener !== 'function') {\n            throw new TypeError('The listener must be a function');\n        }\n        const wrappedListener = new WrappedListener(listener, context || this, once);\n        const events = this._events[event];\n        if (Array.isArray(events)) {\n            /** Third or more listener for this event (pushing to existing array) */\n            events.push(wrappedListener);\n        }\n        else if (events) {\n            /** Second listener for this event (converting single EE to array) */\n            this._events[event] = [\n                events,\n                wrappedListener,\n            ];\n        }\n        else {\n            /** First listener for this event */\n            this._events[event] = wrappedListener;\n            this._eventsCount++;\n        }\n        return this;\n    }\n    /** Clear event by name. */\n    clearEvent(event) {\n        if (--this._eventsCount === 0) {\n            this._events = Object.create(null); // Re-initialize\n        }\n        else {\n            delete this._events[event];\n        }\n    }\n    /** Return an array listing the events for which the emitter has registered listeners. */\n    eventNames() {\n        if (this._eventsCount === 0) {\n            return [];\n        }\n        /**\n         * Use `Reflect.ownKeys` to get both string and symbol properties directly from the _events\n         * object.\n         */\n        return Reflect.ownKeys(this._events);\n    }\n    /** Return the listeners registered for a given event. */\n    listeners(event) {\n        const handlers = this._events[event];\n        if (!handlers) {\n            return [];\n        }\n        else if (Array.isArray(handlers)) {\n            /** Array of listeners. */\n            return handlers.map((handler) => handler.listener);\n        }\n        else {\n            /** Single listener. */\n            return [\n                handlers.listener,\n            ];\n        }\n    }\n    /** Return the number of listeners listening to a given event. */\n    listenerCount(event) {\n        const listeners = this._events[event];\n        if (!listeners) {\n            return 0;\n        }\n        else if (Array.isArray(listeners)) {\n            /** Array of listeners. */\n            return listeners.length;\n        }\n        else {\n            /** Single listener. */\n            return 1;\n        }\n    }\n    /** Calls each of the listeners registered for a given event. */\n    emit(event, ...args) {\n        const listeners = this._events[event];\n        if (!listeners) {\n            return false;\n        }\n        if (Array.isArray(listeners)) {\n            /** Multiple listeners (array) */\n            /** Create a copy to avoid issues if listeners are removed during iteration. */\n            const currentListeners = listeners.slice(0);\n            currentListeners.forEach((listener) => {\n                if (listener.once) {\n                    this.removeListener(event, listener.listener, undefined, true);\n                }\n                listener.listener.call(listener.context, ...args);\n            });\n        }\n        else {\n            // Single listener\n            if (listeners.once) {\n                this.removeListener(event, listeners.listener, undefined, true);\n            }\n            listeners.listener.call(listeners.context, ...args);\n        }\n        return true;\n    }\n    /** Add a listener for a given event. */\n    on(event, listener, context) {\n        return this.#addListener(event, listener, context, false);\n    }\n    /** Add a one-time listener for a given event. */\n    once(event, listener, context) {\n        return this.#addListener(event, listener, context, true);\n    }\n    /** Remove the listeners of a given event. */\n    removeListener(event, listener, context, once) {\n        const wrappedListeners = this._events[event];\n        if (!wrappedListeners) {\n            return this;\n        }\n        else if (!listener) {\n            this.clearEvent(event);\n            return this;\n        }\n        else if (Array.isArray(wrappedListeners)) {\n            const events = [];\n            wrappedListeners.forEach((wrappedListener) => {\n                if (wrappedListener.listener !== listener ||\n                    (once && !wrappedListener.once) ||\n                    (context && wrappedListener.context !== context)) {\n                    events.push(wrappedListener);\n                }\n            });\n            if (events.length) {\n                this._events[event] = events.length === 1 ? events[0] : events;\n            }\n            else {\n                this.clearEvent(event);\n            }\n        }\n        else if (wrappedListeners.listener === listener &&\n            (!once || wrappedListeners.once) &&\n            (!context || wrappedListeners.context === context)) {\n            this.clearEvent(event);\n        }\n        return this;\n    }\n    /** Remove all listeners, or those of the specified event. */\n    removeAllListeners(event) {\n        if (event) {\n            if (this._events[event]) {\n                this.clearEvent(event);\n            }\n        }\n        else {\n            this._events = Object.create(null);\n            this._eventsCount = 0;\n        }\n        return this;\n    }\n    /** Remove the listeners of a given event. */\n    off(event, listener, context, once) {\n        return this.removeListener(event, listener, context, once);\n    }\n    /** Add a listener for a given event. */\n    addListener(event, listener, context) {\n        return this.on(event, listener, context);\n    }\n}\nexport default EventEmitter;\n","import { EventEmitter } from '@electrovir/eventemitter3';\nimport logger from './logger.js';\n\nconst debug = logger('quill:events');\nconst EVENTS = ['selectionchange', 'mousedown', 'mouseup', 'click'];\nconst EMITTERS: Emitter[] = [];\n\nEVENTS.forEach((eventName) => {\n  document.addEventListener(eventName, (...args) => {\n    EMITTERS.forEach((em) => {\n      em.handleDOM(...args);\n    });\n  });\n});\n\nclass Emitter extends EventEmitter<string> {\n  static events = {\n    EDITOR_CHANGE: 'editor-change',\n    SCROLL_BEFORE_UPDATE: 'scroll-before-update',\n    SCROLL_BLOT_MOUNT: 'scroll-blot-mount',\n    SCROLL_BLOT_UNMOUNT: 'scroll-blot-unmount',\n    SCROLL_OPTIMIZE: 'scroll-optimize',\n    SCROLL_UPDATE: 'scroll-update',\n    SCROLL_EMBED_UPDATE: 'scroll-embed-update',\n    SELECTION_CHANGE: 'selection-change',\n    TEXT_CHANGE: 'text-change',\n    COMPOSITION_BEFORE_START: 'composition-before-start',\n    COMPOSITION_START: 'composition-start',\n    COMPOSITION_BEFORE_END: 'composition-before-end',\n    COMPOSITION_END: 'composition-end',\n  } as const;\n\n  static sources = {\n    API: 'api',\n    SILENT: 'silent',\n    USER: 'user',\n  } as const;\n\n  protected domListeners: Record<string, { node: Node; handler: Function }[]>;\n\n  constructor() {\n    super();\n    this.domListeners = {};\n    this.on('error', debug.error);\n  }\n\n  connect() {\n    EMITTERS.push(this);\n  }\n\n  disconnect() {\n    EMITTERS.splice(EMITTERS.indexOf(this), 1);\n  }\n\n  emit(...args: unknown[]): boolean {\n    debug.log.call(debug, ...args);\n    // @ts-expect-error\n    return super.emit(...args);\n  }\n\n  handleDOM(event: Event, ...args: unknown[]) {\n    const target = event.composedPath()[0];\n    const containsNode = (node: Node, target: Node) => {\n      if (target.getRootNode() === document) {\n        return node.contains(target);\n      }\n\n      while (!node.contains(target)) {\n        const root = target.getRootNode();\n        if (!root) {\n          return false;\n        }\n        const host = (root as ShadowRoot).host;\n        if (!host) {\n          return false;\n        }\n        target = host;\n      }\n\n      return true;\n    };\n\n    (this.domListeners[event.type] || []).forEach(({ node, handler }) => {\n      if (target === node || containsNode(node, target as Node)) {\n        handler(event, ...args);\n      }\n    });\n  }\n\n  listenDOM(eventName: string, node: Node, handler: EventListener) {\n    if (!this.domListeners[eventName]) {\n      this.domListeners[eventName] = [];\n    }\n    this.domListeners[eventName].push({ node, handler });\n  }\n}\n\nexport type EmitterSource =\n  (typeof Emitter.sources)[keyof typeof Emitter.sources];\n\nexport default Emitter;\n","const levels = ['error', 'warn', 'log', 'info'] as const;\nexport type DebugLevel = (typeof levels)[number];\nlet level: DebugLevel | false = 'warn';\n\nfunction debug(method: DebugLevel, ...args: unknown[]) {\n  if (level) {\n    if (levels.indexOf(method) <= levels.indexOf(level)) {\n      console[method](...args); // eslint-disable-line no-console\n    }\n  }\n}\n\nfunction namespace(\n  ns: string,\n): Record<DebugLevel, (...args: unknown[]) => void> {\n  return levels.reduce(\n    (logger, method) => {\n      logger[method] = debug.bind(console, method, ns);\n      return logger;\n    },\n    {} as Record<DebugLevel, (...args: unknown[]) => void>,\n  );\n}\n\nnamespace.level = (newLevel: DebugLevel | false) => {\n  level = newLevel;\n};\ndebug.level = namespace.level;\n\nexport default namespace;\n","import type Quill from './quill.js';\n\nabstract class Module<T extends {} = {}> {\n  static DEFAULTS = {};\n\n  constructor(\n    public quill: Quill,\n    protected options: Partial<T> = {},\n  ) {}\n}\n\nexport default Module;\n","import { LeafBlot, EmbedBlot, Scope, ParentBlot } from 'parchment';\nimport type { Blot } from 'parchment';\nimport Delta, { AttributeMap, Op } from 'quill-delta-es';\nimport Block, { BlockEmbed, bubbleFormats } from '../blots/block.js';\nimport Break from '../blots/break.js';\nimport CursorBlot from '../blots/cursor.js';\nimport type Scroll from '../blots/scroll.js';\nimport TextBlot, { escapeText } from '../blots/text.js';\nimport { Range } from './selection.js';\nimport cloneDeep from './utils/cloneDeep.js';\nimport isEqual from './utils/isEqual.js';\n\nconst ASCII = /^[ -~]*$/;\n\ntype SelectionInfo = {\n  newRange: Range;\n  oldRange: Range;\n};\n\nclass Editor {\n  scroll: Scroll;\n  delta: Delta;\n\n  constructor(scroll: Scroll) {\n    this.scroll = scroll;\n    this.delta = this.getDelta();\n  }\n\n  applyDelta(delta: Delta): Delta {\n    this.scroll.update();\n    let scrollLength = this.scroll.length();\n    this.scroll.batchStart();\n    const normalizedDelta = normalizeDelta(delta);\n    const deleteDelta = new Delta();\n    const normalizedOps = splitOpLines(normalizedDelta.ops.slice());\n    normalizedOps.reduce((index, op) => {\n      const length = Op.length(op);\n      let attributes = op.attributes || {};\n      let isImplicitNewlinePrepended = false;\n      let isImplicitNewlineAppended = false;\n      if (op.insert != null) {\n        deleteDelta.retain(length);\n        if (typeof op.insert === 'string') {\n          const text = op.insert;\n          isImplicitNewlineAppended =\n            !text.endsWith('\\n') &&\n            (scrollLength <= index ||\n              !!this.scroll.descendant(BlockEmbed, index)[0]);\n          this.scroll.insertAt(index, text);\n          const [line, offset] = this.scroll.line(index);\n          let formats = Object.assign({}, bubbleFormats(line));\n          if (line instanceof Block) {\n            const [leaf] = line.descendant(LeafBlot, offset);\n            if (leaf) {\n              formats = Object.assign(formats, bubbleFormats(leaf));\n            }\n          }\n          attributes = AttributeMap.diff(formats, attributes) || {};\n        } else if (typeof op.insert === 'object') {\n          const key = Object.keys(op.insert)[0]; // There should only be one key\n          if (key == null) return index;\n          const isInlineEmbed = this.scroll.query(key, Scope.INLINE) != null;\n          if (isInlineEmbed) {\n            if (\n              scrollLength <= index ||\n              !!this.scroll.descendant(BlockEmbed, index)[0]\n            ) {\n              isImplicitNewlineAppended = true;\n            }\n          } else if (index > 0) {\n            const [leaf, offset] = this.scroll.descendant(LeafBlot, index - 1);\n            if (leaf instanceof TextBlot) {\n              const text = leaf.value();\n              if (text[offset] !== '\\n') {\n                isImplicitNewlinePrepended = true;\n              }\n            } else if (\n              leaf instanceof EmbedBlot &&\n              leaf.statics.scope === Scope.INLINE_BLOT\n            ) {\n              isImplicitNewlinePrepended = true;\n            }\n          }\n          this.scroll.insertAt(index, key, op.insert[key]);\n\n          if (isInlineEmbed) {\n            const [leaf] = this.scroll.descendant(LeafBlot, index);\n            if (leaf) {\n              const formats = Object.assign({}, bubbleFormats(leaf));\n              attributes = AttributeMap.diff(formats, attributes) || {};\n            }\n          }\n        }\n        scrollLength += length;\n      } else {\n        deleteDelta.push(op);\n\n        if (op.retain !== null && typeof op.retain === 'object') {\n          const key = Object.keys(op.retain)[0];\n          if (key == null) return index;\n          this.scroll.updateEmbedAt(index, key, op.retain[key]);\n        }\n      }\n      Object.keys(attributes).forEach((name) => {\n        this.scroll.formatAt(index, length, name, attributes[name]);\n      });\n      const prependedLength = isImplicitNewlinePrepended ? 1 : 0;\n      const addedLength = isImplicitNewlineAppended ? 1 : 0;\n      scrollLength += prependedLength + addedLength;\n      deleteDelta.retain(prependedLength);\n      deleteDelta.delete(addedLength);\n      return index + length + prependedLength + addedLength;\n    }, 0);\n    deleteDelta.reduce((index, op) => {\n      if (typeof op.delete === 'number') {\n        this.scroll.deleteAt(index, op.delete);\n        return index;\n      }\n      return index + Op.length(op);\n    }, 0);\n    this.scroll.batchEnd();\n    this.scroll.optimize();\n    return this.update(normalizedDelta);\n  }\n\n  deleteText(index: number, length: number): Delta {\n    this.scroll.deleteAt(index, length);\n    return this.update(new Delta().retain(index).delete(length));\n  }\n\n  formatLine(\n    index: number,\n    length: number,\n    formats: Record<string, unknown> = {},\n  ): Delta {\n    this.scroll.update();\n    Object.keys(formats).forEach((format) => {\n      this.scroll.lines(index, Math.max(length, 1)).forEach((line) => {\n        line.format(format, formats[format]);\n      });\n    });\n    this.scroll.optimize();\n    const delta = new Delta().retain(index).retain(length, cloneDeep(formats));\n    return this.update(delta);\n  }\n\n  formatText(\n    index: number,\n    length: number,\n    formats: Record<string, unknown> = {},\n  ): Delta {\n    Object.keys(formats).forEach((format) => {\n      this.scroll.formatAt(index, length, format, formats[format]);\n    });\n    const delta = new Delta().retain(index).retain(length, cloneDeep(formats));\n    return this.update(delta);\n  }\n\n  getContents(index: number, length: number): Delta {\n    return this.delta.slice(index, index + length);\n  }\n\n  getDelta(): Delta {\n    return this.scroll.lines().reduce((delta, line) => {\n      return delta.concat(line.delta());\n    }, new Delta());\n  }\n\n  getFormat(index: number, length = 0): Record<string, unknown> {\n    let lines: (Block | BlockEmbed)[] = [];\n    let leaves: LeafBlot[] = [];\n    if (length === 0) {\n      this.scroll.path(index).forEach((path) => {\n        const [blot] = path;\n        if (blot instanceof Block) {\n          lines.push(blot);\n        } else if (blot instanceof LeafBlot) {\n          leaves.push(blot);\n        }\n      });\n    } else {\n      lines = this.scroll.lines(index, length);\n      leaves = this.scroll.descendants(LeafBlot, index, length);\n    }\n    const [lineFormats, leafFormats] = [lines, leaves].map((blots) => {\n      const blot = blots.shift();\n      if (blot == null) return {};\n      let formats = bubbleFormats(blot);\n      while (Object.keys(formats).length > 0) {\n        const 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  getHTML(index: number, length: number): string {\n    const [line, lineOffset] = this.scroll.line(index);\n    if (line) {\n      const lineLength = line.length();\n      const isWithinLine = line.length() >= lineOffset + length;\n      if (isWithinLine && !(lineOffset === 0 && length === lineLength)) {\n        return convertHTML(line, lineOffset, length, true);\n      }\n      return convertHTML(this.scroll, index, length, true);\n    }\n    return '';\n  }\n\n  getText(index: number, length: number): string {\n    return this.getContents(index, length)\n      .filter((op) => typeof op.insert === 'string')\n      .map((op) => op.insert)\n      .join('');\n  }\n\n  insertContents(index: number, contents: Delta): Delta {\n    const normalizedDelta = normalizeDelta(contents);\n    const change = new Delta().retain(index).concat(normalizedDelta);\n    this.scroll.insertContents(index, normalizedDelta);\n    return this.update(change);\n  }\n\n  insertEmbed(index: number, embed: string, value: unknown): Delta {\n    this.scroll.insertAt(index, embed, value);\n    return this.update(new Delta().retain(index).insert({ [embed]: value }));\n  }\n\n  insertText(\n    index: number,\n    text: string,\n    formats: Record<string, unknown> = {},\n  ): Delta {\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(\n      new Delta().retain(index).insert(text, cloneDeep(formats)),\n    );\n  }\n\n  isBlank(): boolean {\n    if (this.scroll.children.length === 0) return true;\n    if (this.scroll.children.length > 1) return false;\n    const blot = this.scroll.children.head;\n    if (blot?.statics.blotName !== Block.blotName) return false;\n    const block = blot as Block;\n    if (block.children.length > 1) return false;\n    return block.children.head instanceof Break;\n  }\n\n  removeFormat(index: number, length: number): Delta {\n    const text = this.getText(index, length);\n    const [line, offset] = this.scroll.line(index + length);\n    let suffixLength = 0;\n    let suffix = new Delta();\n    if (line != null) {\n      suffixLength = line.length() - offset;\n      suffix = line\n        .delta()\n        .slice(offset, offset + suffixLength - 1)\n        .insert('\\n');\n    }\n    const contents = this.getContents(index, length + suffixLength);\n    const diff = contents.diff(new Delta().insert(text).concat(suffix));\n    const delta = new Delta().retain(index).concat(diff);\n    return this.applyDelta(delta);\n  }\n\n  update(\n    change: Delta | null,\n    mutations: MutationRecord[] = [],\n    selectionInfo: SelectionInfo | undefined = undefined,\n  ): Delta {\n    const oldDelta = this.delta;\n    if (\n      mutations.length === 1 &&\n      mutations[0].type === 'characterData' &&\n      // @ts-expect-error Fix me later\n      mutations[0].target.data.match(ASCII) &&\n      this.scroll.find(mutations[0].target)\n    ) {\n      // Optimization for character changes\n      const textBlot = this.scroll.find(mutations[0].target) as Blot;\n      const formats = bubbleFormats(textBlot);\n      const index = textBlot.offset(this.scroll);\n      // @ts-expect-error Fix me later\n      const oldValue = mutations[0].oldValue.replace(CursorBlot.CONTENTS, '');\n      const oldText = new Delta().insert(oldValue);\n      // @ts-expect-error\n      const newText = new Delta().insert(textBlot.value());\n      const relativeSelectionInfo = selectionInfo && {\n        oldRange: shiftRange(selectionInfo.oldRange, -index),\n        newRange: shiftRange(selectionInfo.newRange, -index),\n      };\n      const diffDelta = new Delta()\n        .retain(index)\n        .concat(oldText.diff(newText, relativeSelectionInfo));\n      change = diffDelta.reduce((delta, op) => {\n        if (op.insert) {\n          return delta.insert(op.insert, formats);\n        }\n        return delta.push(op);\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, selectionInfo);\n      }\n    }\n    return change;\n  }\n}\n\ninterface ListItem {\n  child: Blot;\n  offset: number;\n  length: number;\n  indent: number;\n  type: string;\n}\nfunction convertListHTML(\n  items: ListItem[],\n  lastIndent: number,\n  types: string[],\n): string {\n  if (items.length === 0) {\n    const [endTag] = getListType(types.pop());\n    if (lastIndent <= 0) {\n      return `</li></${endTag}>`;\n    }\n    return `</li></${endTag}>${convertListHTML([], lastIndent - 1, types)}`;\n  }\n  const [{ child, offset, length, indent, type }, ...rest] = items;\n  const [tag, attribute] = getListType(type);\n  if (indent > lastIndent) {\n    types.push(type);\n    if (indent === lastIndent + 1) {\n      return `<${tag}><li${attribute}>${convertHTML(\n        child,\n        offset,\n        length,\n      )}${convertListHTML(rest, indent, types)}`;\n    }\n    return `<${tag}><li>${convertListHTML(items, lastIndent + 1, types)}`;\n  }\n  const previousType = types[types.length - 1];\n  if (indent === lastIndent && type === previousType) {\n    return `</li><li${attribute}>${convertHTML(\n      child,\n      offset,\n      length,\n    )}${convertListHTML(rest, indent, types)}`;\n  }\n  const [endTag] = getListType(types.pop());\n  return `</li></${endTag}>${convertListHTML(items, lastIndent - 1, types)}`;\n}\n\nfunction convertHTML(\n  blot: Blot,\n  index: number,\n  length: number,\n  isRoot = false,\n): string {\n  if ('html' in blot && typeof blot.html === 'function') {\n    return blot.html(index, length);\n  }\n  if (blot instanceof TextBlot) {\n    const escapedText = escapeText(blot.value().slice(index, index + length));\n    // Based on https://github.com/slab/quill/issues/4509#issuecomment-2521334016\n    return escapedText.replaceAll(\n      /  +/g,\n      (match) => '&nbsp;'.repeat(match.length - 1) + ' ',\n    );\n  }\n  if (blot instanceof ParentBlot) {\n    // TODO fix API\n    if (blot.statics.blotName === 'list-container') {\n      const items: any[] = [];\n      blot.children.forEachAt(index, length, (child, offset, childLength) => {\n        const formats =\n          'formats' in child && typeof child.formats === 'function'\n            ? child.formats()\n            : {};\n        items.push({\n          child,\n          offset,\n          length: childLength,\n          indent: formats.indent || 0,\n          type: formats.list,\n        });\n      });\n      return convertListHTML(items, -1, []);\n    }\n    const parts: string[] = [];\n    blot.children.forEachAt(index, length, (child, offset, childLength) => {\n      parts.push(convertHTML(child, offset, childLength));\n    });\n    if (isRoot || blot.statics.blotName === 'list') {\n      return parts.join('');\n    }\n    const { outerHTML, innerHTML } = blot.domNode as Element;\n    const [start, end] = outerHTML.split(`>${innerHTML}<`);\n    // TODO cleanup\n    if (start === '<table') {\n      return `<table style=\"border: 1px solid #000;\">${parts.join('')}<${end}`;\n    }\n    return `${start}>${parts.join('')}<${end}`;\n  }\n  return blot.domNode instanceof Element ? blot.domNode.outerHTML : '';\n}\n\nfunction combineFormats(\n  formats: Record<string, unknown>,\n  combined: Record<string, unknown>,\n): Record<string, unknown> {\n  return Object.keys(combined).reduce(\n    (merged, name) => {\n      if (formats[name] == null) return merged;\n      const combinedValue = combined[name];\n      if (combinedValue === formats[name]) {\n        merged[name] = combinedValue;\n      } else if (Array.isArray(combinedValue)) {\n        if (combinedValue.indexOf(formats[name]) < 0) {\n          merged[name] = combinedValue.concat([formats[name]]);\n        } else {\n          // If style already exists, don't add to an array, but don't lose other styles\n          merged[name] = combinedValue;\n        }\n      } else {\n        merged[name] = [combinedValue, formats[name]];\n      }\n      return merged;\n    },\n    {} as Record<string, unknown>,\n  );\n}\n\nfunction getListType(type: string | undefined) {\n  const tag = type === 'ordered' ? 'ol' : 'ul';\n  switch (type) {\n    case 'checked':\n      return [tag, ' data-list=\"checked\"'];\n    case 'unchecked':\n      return [tag, ' data-list=\"unchecked\"'];\n    default:\n      return [tag, ''];\n  }\n}\n\nfunction normalizeDelta(delta: Delta) {\n  return delta.reduce((normalizedDelta, op) => {\n    if (typeof op.insert === 'string') {\n      const text = op.insert.replace(/\\r\\n/g, '\\n').replace(/\\r/g, '\\n');\n      return normalizedDelta.insert(text, op.attributes);\n    }\n    return normalizedDelta.push(op);\n  }, new Delta());\n}\n\nfunction shiftRange({ index, length }: Range, amount: number) {\n  return new Range(index + amount, length);\n}\n\nfunction splitOpLines(ops: Op[]) {\n  const split: Op[] = [];\n  ops.forEach((op) => {\n    if (typeof op.insert === 'string') {\n      const lines = op.insert.split('\\n');\n      lines.forEach((line, index) => {\n        if (index) split.push({ insert: '\\n', attributes: op.attributes });\n        if (line) split.push({ insert: line, attributes: op.attributes });\n      });\n    } else {\n      split.push(op);\n    }\n  });\n\n  return split;\n}\n\nexport default Editor;\n","import type Quill from '../core.js';\n\nexport default new WeakMap<Node, Quill>();\n","import Embed from '../blots/embed.js';\nimport type Scroll from '../blots/scroll.js';\nimport Emitter from './emitter.js';\n\nclass Composition {\n  isComposing = false;\n\n  constructor(\n    private scroll: Scroll,\n    private emitter: Emitter,\n  ) {\n    this.setupListeners();\n  }\n\n  private setupListeners() {\n    this.scroll.domNode.addEventListener('compositionstart', (event) => {\n      if (!this.isComposing) {\n        this.handleCompositionStart(event);\n      }\n    });\n\n    this.scroll.domNode.addEventListener('compositionend', (event) => {\n      if (this.isComposing) {\n        // Webkit makes DOM changes after compositionend, so we use microtask to\n        // ensure the order.\n        // https://bugs.webkit.org/show_bug.cgi?id=31902\n        queueMicrotask(() => {\n          this.handleCompositionEnd(event);\n        });\n      }\n    });\n  }\n\n  private handleCompositionStart(event: CompositionEvent) {\n    const blot =\n      event.target instanceof Node\n        ? this.scroll.find(event.target, true)\n        : null;\n\n    if (blot && !(blot instanceof Embed)) {\n      this.emitter.emit(Emitter.events.COMPOSITION_BEFORE_START, event);\n      this.scroll.batchStart();\n      this.emitter.emit(Emitter.events.COMPOSITION_START, event);\n      this.isComposing = true;\n    }\n  }\n\n  private handleCompositionEnd(event: CompositionEvent) {\n    this.emitter.emit(Emitter.events.COMPOSITION_BEFORE_END, event);\n    this.scroll.batchEnd();\n    this.emitter.emit(Emitter.events.COMPOSITION_END, event);\n    this.isComposing = false;\n  }\n}\n\nexport default Composition;\n","export type Rect = {\n  top: number;\n  right: number;\n  bottom: number;\n  left: number;\n};\n\nconst getParentElement = (element: Node): Element | null =>\n  element.parentElement || (element.getRootNode() as ShadowRoot).host || null;\n\nconst getElementRect = (element: Element): Rect => {\n  const rect = element.getBoundingClientRect();\n  const scaleX =\n    ('offsetWidth' in element &&\n      Math.abs(rect.width) / (element as HTMLElement).offsetWidth) ||\n    1;\n  const scaleY =\n    ('offsetHeight' in element &&\n      Math.abs(rect.height) / (element as HTMLElement).offsetHeight) ||\n    1;\n  return {\n    top: rect.top,\n    right: rect.left + element.clientWidth * scaleX,\n    bottom: rect.top + element.clientHeight * scaleY,\n    left: rect.left,\n  };\n};\n\nconst paddingValueToInt = (value: string) => {\n  const number = parseInt(value, 10);\n  return Number.isNaN(number) ? 0 : number;\n};\n\n// Follow the steps described in https://www.w3.org/TR/cssom-view-1/#element-scrolling-members,\n// assuming that the scroll option is set to 'nearest'.\nconst getScrollDistance = (\n  targetStart: number,\n  targetEnd: number,\n  scrollStart: number,\n  scrollEnd: number,\n  scrollPaddingStart: number,\n  scrollPaddingEnd: number,\n) => {\n  if (targetStart < scrollStart && targetEnd > scrollEnd) {\n    return 0;\n  }\n\n  if (targetStart < scrollStart) {\n    return -(scrollStart - targetStart + scrollPaddingStart);\n  }\n\n  if (targetEnd > scrollEnd) {\n    return targetEnd - targetStart > scrollEnd - scrollStart\n      ? targetStart + scrollPaddingStart - scrollStart\n      : targetEnd - scrollEnd + scrollPaddingEnd;\n  }\n  return 0;\n};\n\nconst scrollRectIntoView = (root: HTMLElement, targetRect: Rect) => {\n  const document = root.ownerDocument;\n\n  let rect = targetRect;\n\n  let current: Element | null = root;\n  while (current) {\n    const isDocumentBody: boolean = current === document.body;\n    const bounding = isDocumentBody\n      ? {\n          top: 0,\n          right:\n            window.visualViewport?.width ??\n            document.documentElement.clientWidth,\n          bottom:\n            window.visualViewport?.height ??\n            document.documentElement.clientHeight,\n          left: 0,\n        }\n      : getElementRect(current);\n\n    const style = getComputedStyle(current);\n    const scrollDistanceX = getScrollDistance(\n      rect.left,\n      rect.right,\n      bounding.left,\n      bounding.right,\n      paddingValueToInt(style.scrollPaddingLeft),\n      paddingValueToInt(style.scrollPaddingRight),\n    );\n    const scrollDistanceY = getScrollDistance(\n      rect.top,\n      rect.bottom,\n      bounding.top,\n      bounding.bottom,\n      paddingValueToInt(style.scrollPaddingTop),\n      paddingValueToInt(style.scrollPaddingBottom),\n    );\n    if (scrollDistanceX || scrollDistanceY) {\n      if (isDocumentBody) {\n        document.defaultView?.scrollBy(scrollDistanceX, scrollDistanceY);\n      } else {\n        const { scrollLeft, scrollTop } = current;\n        if (scrollDistanceY) {\n          current.scrollTop += scrollDistanceY;\n        }\n        if (scrollDistanceX) {\n          current.scrollLeft += scrollDistanceX;\n        }\n        const scrolledLeft = current.scrollLeft - scrollLeft;\n        const scrolledTop = current.scrollTop - scrollTop;\n        rect = {\n          left: rect.left - scrolledLeft,\n          top: rect.top - scrolledTop,\n          right: rect.right - scrolledLeft,\n          bottom: rect.bottom - scrolledTop,\n        };\n      }\n    }\n\n    current =\n      isDocumentBody || style.position === 'fixed'\n        ? null\n        : getParentElement(current);\n  }\n};\n\nexport default scrollRectIntoView;\n","import { Registry } from 'parchment';\n\nconst MAX_REGISTER_ITERATIONS = 100;\nconst CORE_FORMATS = ['block', 'break', 'cursor', 'inline', 'scroll', 'text'];\n\nconst createRegistryWithFormats = (\n  formats: string[],\n  sourceRegistry: Registry,\n  debug: { error: (errorMessage: string) => void },\n) => {\n  const registry = new Registry();\n  CORE_FORMATS.forEach((name) => {\n    const coreBlot = sourceRegistry.query(name);\n    if (coreBlot) registry.register(coreBlot);\n  });\n\n  formats.forEach((name) => {\n    let format = sourceRegistry.query(name);\n    if (!format) {\n      debug.error(\n        `Cannot register \"${name}\" specified in \"formats\" config. Are you sure it was registered?`,\n      );\n    }\n    let iterations = 0;\n    while (format) {\n      registry.register(format);\n      format = 'blotName' in format ? format.requiredContainer ?? null : null;\n\n      iterations += 1;\n      if (iterations > MAX_REGISTER_ITERATIONS) {\n        debug.error(\n          `Cycle detected in registering blot requiredContainer: \"${name}\"`,\n        );\n        break;\n      }\n    }\n  });\n\n  return registry;\n};\n\nexport default createRegistryWithFormats;\n","import * as Parchment from 'parchment';\nimport type { Op } from 'quill-delta-es';\nimport Delta from 'quill-delta-es';\nimport type { BlockEmbed } from '../blots/block.js';\nimport type Block from '../blots/block.js';\nimport type Scroll from '../blots/scroll.js';\nimport type Clipboard from '../modules/clipboard.js';\nimport type History from '../modules/history.js';\nimport type Keyboard from '../modules/keyboard.js';\nimport type Uploader from '../modules/uploader.js';\nimport Editor from './editor.js';\nimport Emitter from './emitter.js';\nimport type { EmitterSource } from './emitter.js';\nimport instances from './instances.js';\nimport logger from './logger.js';\nimport type { DebugLevel } from './logger.js';\nimport Module from './module.js';\nimport Selection, { Range } from './selection.js';\nimport type { Bounds } from './selection.js';\nimport Composition from './composition.js';\nimport Theme from './theme.js';\nimport type { ThemeConstructor } from './theme.js';\nimport scrollRectIntoView from './utils/scrollRectIntoView.js';\nimport type { Rect } from './utils/scrollRectIntoView.js';\nimport createRegistryWithFormats from './utils/createRegistryWithFormats.js';\n\nconst debug = logger('quill');\n\nconst globalRegistry = new Parchment.Registry();\nParchment.ParentBlot.uiClass = 'ql-ui';\n\n/**\n * Options for initializing a Quill instance\n */\nexport interface QuillOptions {\n  theme?: string;\n  debug?: DebugLevel | boolean;\n  registry?: Parchment.Registry;\n  /**\n   * Whether to disable the editing\n   * @default false\n   */\n  readOnly?: boolean;\n\n  /**\n   * Placeholder text to display when the editor is empty\n   * @default \"\"\n   */\n  placeholder?: string;\n  bounds?: HTMLElement | string | null;\n  modules?: Record<string, unknown>;\n\n  /**\n   * A list of formats that are recognized and can exist within the editor contents.\n   * `null` means all formats are allowed.\n   * @default null\n   */\n  formats?: string[] | null;\n}\n\n/**\n * Similar to QuillOptions, but with all properties expanded to their default values,\n * and all selectors resolved to HTMLElements.\n */\nexport interface ExpandedQuillOptions\n  extends Omit<QuillOptions, 'theme' | 'formats'> {\n  theme: ThemeConstructor;\n  registry: Parchment.Registry;\n  container: HTMLElement;\n  modules: Record<string, unknown>;\n  bounds?: HTMLElement | null;\n  readOnly: boolean;\n}\n\nclass Quill {\n  static DEFAULTS = {\n    bounds: null,\n    modules: {\n      clipboard: true,\n      keyboard: true,\n      history: true,\n      uploader: true,\n    },\n    placeholder: '',\n    readOnly: false,\n    registry: globalRegistry,\n    theme: 'default',\n  } satisfies Partial<QuillOptions>;\n  static events = Emitter.events;\n  static sources = Emitter.sources;\n  static version = typeof QUILL_VERSION === 'undefined' ? 'dev' : QUILL_VERSION;\n\n  static imports: Record<string, unknown> = {\n    delta: Delta,\n    parchment: Parchment,\n    'core/module': Module,\n    'core/theme': Theme,\n  };\n\n  static debug(limit: DebugLevel | boolean) {\n    if (limit === true) {\n      limit = 'log';\n    }\n    logger.level(limit);\n  }\n\n  static find(node: Node, bubble = false) {\n    return instances.get(node) || globalRegistry.find(node, bubble);\n  }\n\n  static import(name: 'core/module'): typeof Module;\n  static import(name: `themes/${string}`): typeof Theme;\n  static import(name: 'parchment'): typeof Parchment;\n  static import(name: 'delta'): typeof Delta;\n  static import(name: string): unknown;\n  static import(name: string) {\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(\n    targets: Record<\n      string,\n      | Parchment.RegistryDefinition\n      | Record<string, unknown> // any objects\n      | Theme\n      | Module\n      | Function // ES5 constructors\n    >,\n    overwrite?: boolean,\n  ): void;\n  static register(\n    target: Parchment.RegistryDefinition,\n    overwrite?: boolean,\n  ): void;\n  static register(path: string, target: any, overwrite?: boolean): void;\n  static register(...args: any[]): void {\n    if (typeof args[0] !== 'string') {\n      const target = args[0];\n      const overwrite = !!args[1];\n\n      const name = 'attrName' in target ? target.attrName : target.blotName;\n      if (typeof name === 'string') {\n        // Shortcut for formats:\n        // register(Blot | Attributor, overwrite)\n        this.register(`formats/${name}`, target, overwrite);\n      } else {\n        Object.keys(target).forEach((key) => {\n          this.register(key, target[key], overwrite);\n        });\n      }\n    } else {\n      const path = args[0];\n      const target = args[1];\n      const overwrite = !!args[2];\n\n      if (this.imports[path] != null && !overwrite) {\n        debug.warn(`Overwriting ${path} with`, target);\n      }\n      this.imports[path] = target;\n      if (\n        (path.startsWith('blots/') || path.startsWith('formats/')) &&\n        target &&\n        typeof target !== 'boolean' &&\n        target.blotName !== 'abstract'\n      ) {\n        globalRegistry.register(target);\n      }\n      if (typeof target.register === 'function') {\n        target.register(globalRegistry);\n      }\n    }\n  }\n\n  container: HTMLElement;\n  root: HTMLDivElement;\n  scroll: Scroll;\n  emitter: Emitter;\n  protected allowReadOnlyEdits: boolean;\n  editor: Editor;\n  composition: Composition;\n  selection: Selection;\n\n  theme: Theme;\n  keyboard: Keyboard;\n  clipboard: Clipboard;\n  history: History;\n  uploader: Uploader;\n\n  options: ExpandedQuillOptions;\n\n  constructor(container: HTMLElement | string, options: QuillOptions = {}) {\n    this.options = expandConfig(container, options);\n    this.container = this.options.container;\n    if (this.container == null) {\n      debug.error('Invalid Quill container', container);\n      return;\n    }\n    if (this.options.debug) {\n      Quill.debug(this.options.debug);\n    }\n    const html = this.container.innerHTML.trim();\n    this.container.classList.add('ql-container');\n    this.container.innerHTML = '';\n    instances.set(this.container, this);\n    this.root = this.addContainer('ql-editor');\n    this.root.classList.add('ql-blank');\n    this.emitter = new Emitter();\n    const scrollBlotName = Parchment.ScrollBlot.blotName;\n    const ScrollBlot = this.options.registry.query(scrollBlotName);\n    if (!ScrollBlot || !('blotName' in ScrollBlot)) {\n      throw new Error(\n        `Cannot initialize Quill without \"${scrollBlotName}\" blot`,\n      );\n    }\n    this.scroll = new ScrollBlot(this.options.registry, this.root, {\n      emitter: this.emitter,\n    }) as Scroll;\n    this.editor = new Editor(this.scroll);\n    this.selection = new Selection(this.scroll, this.emitter);\n    this.composition = new Composition(this.scroll, this.emitter);\n    this.theme = new this.options.theme(this, this.options); // eslint-disable-line new-cap\n    this.keyboard = this.theme.addModule('keyboard');\n    this.clipboard = this.theme.addModule('clipboard');\n    this.history = this.theme.addModule('history');\n    this.uploader = this.theme.addModule('uploader');\n    this.theme.addModule('input');\n    this.theme.addModule('uiNode');\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      const oldRange = this.selection.lastRange;\n      const [newRange] = this.selection.getRange();\n      const selectionInfo =\n        oldRange && newRange ? { oldRange, newRange } : undefined;\n      modify.call(\n        this,\n        () => this.editor.update(null, mutations, selectionInfo),\n        source,\n      );\n    });\n    this.emitter.on(Emitter.events.SCROLL_EMBED_UPDATE, (blot, delta) => {\n      const oldRange = this.selection.lastRange;\n      const [newRange] = this.selection.getRange();\n      const selectionInfo =\n        oldRange && newRange ? { oldRange, newRange } : undefined;\n      modify.call(\n        this,\n        () => {\n          const change = new Delta()\n            .retain(blot.offset(this))\n            .retain({ [blot.statics.blotName]: delta });\n          return this.editor.update(change, [], selectionInfo);\n        },\n        Quill.sources.USER,\n      );\n    });\n    if (html) {\n      const contents = this.clipboard.convert({\n        html: `${html}<p><br></p>`,\n        text: '\\n',\n      });\n      this.setContents(contents);\n    }\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    this.allowReadOnlyEdits = false;\n  }\n\n  addContainer(container: string, refNode?: Node | null): HTMLDivElement;\n  addContainer(container: HTMLElement, refNode?: Node | null): HTMLElement;\n  addContainer(\n    container: string | HTMLElement,\n    refNode: Node | null = null,\n  ): HTMLDivElement | HTMLElement {\n    if (typeof container === 'string') {\n      const 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(range: Range, source?: EmitterSource): Delta;\n  deleteText(index: number, length: number, source?: EmitterSource): Delta;\n  deleteText(\n    index: number | Range,\n    length?: number | EmitterSource,\n    source?: EmitterSource,\n  ): Delta {\n    // @ts-expect-error\n    [index, length, , source] = overload(index, length, source);\n    return modify.call(\n      this,\n      () => {\n        return this.editor.deleteText(index, length);\n      },\n      source,\n      index,\n      -1 * length,\n    );\n  }\n\n  disable() {\n    this.enable(false);\n  }\n\n  editReadOnly<T>(modifier: () => T): T {\n    this.allowReadOnlyEdits = true;\n    const value = modifier();\n    this.allowReadOnlyEdits = false;\n    return value;\n  }\n\n  enable(enabled = true) {\n    this.scroll.enable(enabled);\n    this.container.classList.toggle('ql-disabled', !enabled);\n  }\n\n  focus(options: { preventScroll?: boolean } = {}) {\n    this.selection.focus();\n    if (!options.preventScroll) {\n      this.scrollSelectionIntoView();\n    }\n  }\n\n  format(\n    name: string,\n    value: unknown,\n    source: EmitterSource = Emitter.sources.API,\n  ): Delta {\n    return modify.call(\n      this,\n      () => {\n        if (!this.hasFocus()) {\n          this.root.focus({ preventScroll: true });\n          const args = this.selection.rangeToNative(this.selection.savedRange);\n          this.selection.setNativeRange(...args);\n        }\n        const [range] = this.selection.getRange(); // quill.getSelection triggers update\n        let change = new Delta();\n        if (range == null) return change;\n        if (this.scroll.query(name, Parchment.Scope.BLOCK)) {\n          change = this.editor.formatLine(range.index, range.length, {\n            [name]: value,\n          });\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, {\n            [name]: value,\n          });\n        }\n        this.setSelection(range, Emitter.sources.SILENT);\n        return change;\n      },\n      source,\n    );\n  }\n\n  formatLine(\n    index: number,\n    length: number,\n    formats: Record<string, unknown>,\n    source?: EmitterSource,\n  ): Delta;\n  formatLine(\n    index: number,\n    length: number,\n    name: string,\n    value?: unknown,\n    source?: EmitterSource,\n  ): Delta;\n  formatLine(\n    index: number,\n    length: number,\n    name: string | Record<string, unknown>,\n    value?: unknown | EmitterSource,\n    source?: EmitterSource,\n  ): Delta {\n    let formats: Record<string, unknown>;\n    // eslint-disable-next-line prefer-const\n    [index, length, formats, source] = overload(\n      index,\n      length,\n      // @ts-expect-error\n      name,\n      value,\n      source,\n    );\n    return modify.call(\n      this,\n      () => {\n        return this.editor.formatLine(index, length, formats);\n      },\n      source,\n      index,\n      0,\n    );\n  }\n\n  formatText(\n    range: Range,\n    name: string,\n    value: unknown,\n    source?: EmitterSource,\n  ): Delta;\n  formatText(\n    index: number,\n    length: number,\n    name: string,\n    value: unknown,\n    source?: EmitterSource,\n  ): Delta;\n  formatText(\n    index: number,\n    length: number,\n    formats: Record<string, unknown>,\n    source?: EmitterSource,\n  ): Delta;\n  formatText(\n    index: number | Range,\n    length: number | string,\n    name: string | unknown,\n    value?: unknown | EmitterSource,\n    source?: EmitterSource,\n  ): Delta {\n    let formats: Record<string, unknown>;\n    // eslint-disable-next-line prefer-const\n    [index, length, formats, source] = overload(\n      // @ts-expect-error\n      index,\n      length,\n      name,\n      value,\n      source,\n    );\n    return modify.call(\n      this,\n      () => {\n        return this.editor.formatText(index, length, formats);\n      },\n      source,\n      index,\n      0,\n    );\n  }\n\n  getBounds(index: number | Range, length = 0): Bounds | null {\n    let bounds: Bounds | null = null;\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    if (!bounds) return null;\n    const 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?: number, length?: number): { [format: string]: unknown };\n  getFormat(range?: Range): {\n    [format: string]: unknown;\n  };\n  getFormat(\n    index: Range | number = this.getSelection(true),\n    length = 0,\n  ): { [format: string]: unknown } {\n    if (typeof index === 'number') {\n      return this.editor.getFormat(index, length);\n    }\n    return this.editor.getFormat(index.index, index.length);\n  }\n\n  getIndex(blot: Parchment.Blot) {\n    return blot.offset(this.scroll);\n  }\n\n  getLength() {\n    return this.scroll.length();\n  }\n\n  getLeaf(index: number) {\n    return this.scroll.leaf(index);\n  }\n\n  getLine(index: number) {\n    return this.scroll.line(index);\n  }\n\n  getLines(range: Range): (Block | BlockEmbed)[];\n  getLines(index?: number, length?: number): (Block | BlockEmbed)[];\n  getLines(\n    index: Range | number = 0,\n    length = Number.MAX_VALUE,\n  ): (Block | BlockEmbed)[] {\n    if (typeof index !== 'number') {\n      return this.scroll.lines(index.index, index.length);\n    }\n    return this.scroll.lines(index, length);\n  }\n\n  getModule(name: string) {\n    return this.theme.modules[name];\n  }\n\n  getSelection(focus: true): Range;\n  getSelection(focus?: boolean): Range | null;\n  getSelection(focus = false): Range | null {\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  getSemanticHTML(range: Range): string;\n  getSemanticHTML(index?: number, length?: number): string;\n  getSemanticHTML(index: Range | number = 0, length?: number) {\n    if (typeof index === 'number') {\n      length = length ?? this.getLength() - index;\n    }\n    // @ts-expect-error\n    [index, length] = overload(index, length);\n    return this.editor.getHTML(index, length);\n  }\n\n  getText(range?: Range): string;\n  getText(index?: number, length?: number): string;\n  getText(index: Range | number = 0, length?: number): string {\n    if (typeof index === 'number') {\n      length = length ?? this.getLength() - index;\n    }\n    // @ts-expect-error\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(\n    index: number,\n    embed: string,\n    value: unknown,\n    source: EmitterSource = Quill.sources.API,\n  ): Delta {\n    return modify.call(\n      this,\n      () => {\n        return this.editor.insertEmbed(index, embed, value);\n      },\n      source,\n      index,\n    );\n  }\n\n  insertText(index: number, text: string, source?: EmitterSource): Delta;\n  insertText(\n    index: number,\n    text: string,\n    formats: Record<string, unknown>,\n    source?: EmitterSource,\n  ): Delta;\n  insertText(\n    index: number,\n    text: string,\n    name: string,\n    value: unknown,\n    source?: EmitterSource,\n  ): Delta;\n  insertText(\n    index: number,\n    text: string,\n    name?: string | Record<string, unknown> | EmitterSource,\n    value?: unknown,\n    source?: EmitterSource,\n  ): Delta {\n    let formats: Record<string, unknown>;\n    // eslint-disable-next-line prefer-const\n    // @ts-expect-error\n    [index, , formats, source] = overload(index, 0, name, value, source);\n    return modify.call(\n      this,\n      () => {\n        return this.editor.insertText(index, text, formats);\n      },\n      source,\n      index,\n      text.length,\n    );\n  }\n\n  isEnabled() {\n    return this.scroll.isEnabled();\n  }\n\n  off(...args: Parameters<(typeof Emitter)['prototype']['off']>) {\n    return this.emitter.off(...args);\n  }\n\n  on(\n    event: (typeof Emitter)['events']['TEXT_CHANGE'],\n    handler: (delta: Delta, oldContent: Delta, source: EmitterSource) => void,\n  ): Emitter;\n  on(\n    event: (typeof Emitter)['events']['SELECTION_CHANGE'],\n    handler: (range: Range, oldRange: Range, source: EmitterSource) => void,\n  ): Emitter;\n  on(\n    event: (typeof Emitter)['events']['EDITOR_CHANGE'],\n    handler: (\n      ...args:\n        | [\n            (typeof Emitter)['events']['TEXT_CHANGE'],\n            Delta,\n            Delta,\n            EmitterSource,\n          ]\n        | [\n            (typeof Emitter)['events']['SELECTION_CHANGE'],\n            Range,\n            Range,\n            EmitterSource,\n          ]\n    ) => void,\n  ): Emitter;\n  on(event: string, ...args: unknown[]): Emitter;\n  on(...args: Parameters<(typeof Emitter)['prototype']['on']>): Emitter {\n    return this.emitter.on(...args);\n  }\n\n  once(...args: Parameters<(typeof Emitter)['prototype']['once']>) {\n    return this.emitter.once(...args);\n  }\n\n  removeFormat(index: number, length: number, source?: EmitterSource): Delta {\n    [index, length, , source] = overload(index, length, source);\n    return modify.call(\n      this,\n      () => {\n        return this.editor.removeFormat(index, length);\n      },\n      source,\n      index,\n    );\n  }\n\n  scrollRectIntoView(rect: Rect) {\n    scrollRectIntoView(this.root, rect);\n  }\n\n  /**\n   * @deprecated Use Quill#scrollSelectionIntoView() instead.\n   */\n  scrollIntoView() {\n    console.warn(\n      'Quill#scrollIntoView() has been deprecated and will be removed in the near future. Please use Quill#scrollSelectionIntoView() instead.',\n    );\n    this.scrollSelectionIntoView();\n  }\n\n  /**\n   * Scroll the current selection into the visible area.\n   * If the selection is already visible, no scrolling will occur.\n   */\n  scrollSelectionIntoView() {\n    const range = this.selection.lastRange;\n    const bounds = range && this.selection.getBounds(range.index, range.length);\n    if (bounds) {\n      this.scrollRectIntoView(bounds);\n    }\n  }\n\n  setContents(\n    delta: Delta | Op[],\n    source: EmitterSource = Emitter.sources.API,\n  ): Delta {\n    return modify.call(\n      this,\n      () => {\n        delta = new Delta(delta);\n        const length = this.getLength();\n        // Quill will set empty editor to \\n\n        const delete1 = this.editor.deleteText(0, length);\n        const applied = this.editor.insertContents(0, delta);\n        // Remove extra \\n from empty editor initialization\n        const delete2 = this.editor.deleteText(this.getLength() - 1, 1);\n        return delete1.compose(applied).compose(delete2);\n      },\n      source,\n    );\n  }\n  setSelection(range: Range | null, source?: EmitterSource): void;\n  setSelection(index: number, source?: EmitterSource): void;\n  setSelection(index: number, length?: number, source?: EmitterSource): void;\n  setSelection(index: number, source?: EmitterSource): void;\n  setSelection(\n    index: Range | null | number,\n    length?: EmitterSource | number,\n    source?: EmitterSource,\n  ): void {\n    if (index == null) {\n      // @ts-expect-error https://github.com/microsoft/TypeScript/issues/22609\n      this.selection.setRange(null, length || Quill.sources.API);\n    } else {\n      // @ts-expect-error\n      [index, length, , source] = overload(index, length, source);\n      this.selection.setRange(new Range(Math.max(0, index), length), source);\n      if (source !== Emitter.sources.SILENT) {\n        this.scrollSelectionIntoView();\n      }\n    }\n  }\n\n  setText(text: string, source: EmitterSource = Emitter.sources.API) {\n    const delta = new Delta().insert(text);\n    return this.setContents(delta, source);\n  }\n\n  update(source: EmitterSource = Emitter.sources.USER) {\n    const change = this.scroll.update(source); // Will update selection before selection.update() does if text changes\n    this.selection.update(source);\n    // TODO this is usually undefined\n    return change;\n  }\n\n  updateContents(\n    delta: Delta | Op[],\n    source: EmitterSource = Emitter.sources.API,\n  ): Delta {\n    return modify.call(\n      this,\n      () => {\n        delta = new Delta(delta);\n        return this.editor.applyDelta(delta);\n      },\n      source,\n      true,\n    );\n  }\n}\n\nfunction resolveSelector(selector: string | HTMLElement | null | undefined) {\n  return typeof selector === 'string'\n    ? document.querySelector<HTMLElement>(selector)\n    : selector;\n}\n\nfunction expandModuleConfig(config: Record<string, unknown> | undefined) {\n  return Object.entries(config ?? {}).reduce(\n    (expanded, [key, value]) => ({\n      ...expanded,\n      [key]: value === true ? {} : value,\n    }),\n    {} as Record<string, unknown>,\n  );\n}\n\nfunction omitUndefinedValuesFromOptions(obj: QuillOptions) {\n  return Object.fromEntries(\n    Object.entries(obj).filter((entry) => entry[1] !== undefined),\n  );\n}\n\nfunction expandConfig(\n  containerOrSelector: HTMLElement | string,\n  options: QuillOptions,\n): ExpandedQuillOptions {\n  const container = resolveSelector(containerOrSelector);\n  if (!container) {\n    throw new Error('Invalid Quill container');\n  }\n\n  const shouldUseDefaultTheme =\n    !options.theme || options.theme === Quill.DEFAULTS.theme;\n  const theme = shouldUseDefaultTheme\n    ? Theme\n    : Quill.import(`themes/${options.theme}`);\n  if (!theme) {\n    throw new Error(`Invalid theme ${options.theme}. Did you register it?`);\n  }\n\n  const { modules: quillModuleDefaults, ...quillDefaults } = Quill.DEFAULTS;\n  const { modules: themeModuleDefaults, ...themeDefaults } = theme.DEFAULTS;\n\n  let userModuleOptions = expandModuleConfig(options.modules);\n  // Special case toolbar shorthand\n  if (\n    userModuleOptions != null &&\n    userModuleOptions.toolbar &&\n    userModuleOptions.toolbar.constructor !== Object\n  ) {\n    userModuleOptions = {\n      ...userModuleOptions,\n      toolbar: { container: userModuleOptions.toolbar },\n    };\n  }\n\n  const modules: ExpandedQuillOptions['modules'] = {\n    ...expandModuleConfig(quillModuleDefaults),\n    ...expandModuleConfig(themeModuleDefaults),\n    ...userModuleOptions,\n  };\n\n  const config = {\n    ...quillDefaults,\n    ...omitUndefinedValuesFromOptions(themeDefaults),\n    ...omitUndefinedValuesFromOptions(options),\n  };\n\n  let registry = options.registry;\n  if (registry) {\n    if (options.formats) {\n      debug.warn('Ignoring \"formats\" option because \"registry\" is specified');\n    }\n  } else {\n    registry = options.formats\n      ? createRegistryWithFormats(options.formats, config.registry, debug)\n      : config.registry;\n  }\n\n  return {\n    ...config,\n    registry,\n    container,\n    theme,\n    modules: Object.entries(modules).reduce(\n      (modulesWithDefaults, [name, value]) => {\n        if (!value) return modulesWithDefaults;\n\n        const moduleClass = Quill.import(`modules/${name}`);\n        if (moduleClass == null) {\n          debug.error(\n            `Cannot load ${name} module. Are you sure you registered it?`,\n          );\n          return modulesWithDefaults;\n        }\n        return {\n          ...modulesWithDefaults,\n          // @ts-expect-error\n          [name]: { ...(moduleClass.DEFAULTS || {}), ...value },\n        };\n      },\n      {},\n    ),\n    bounds: resolveSelector(config.bounds),\n  };\n}\n\n// Handle selection preservation and TEXT_CHANGE emission\n// common to modification APIs\nfunction modify(\n  modifier: () => Delta,\n  source: EmitterSource,\n  index: number | boolean,\n  shift: number | null,\n) {\n  if (\n    !this.isEnabled() &&\n    source === Emitter.sources.USER &&\n    !this.allowReadOnlyEdits\n  ) {\n    return new Delta();\n  }\n  let range = index == null ? null : this.getSelection();\n  const oldDelta = this.editor.delta;\n  const change = modifier();\n  if (range != null) {\n    if (index === true) {\n      index = range.index; // eslint-disable-line prefer-destructuring\n    }\n    if (shift == null) {\n      range = shiftRange(range, change, source);\n    } else if (shift !== 0) {\n      // @ts-expect-error index should always be number\n      range = shiftRange(range, index, shift, source);\n    }\n    this.setSelection(range, Emitter.sources.SILENT);\n  }\n  if (change.length() > 0) {\n    const 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\ntype NormalizedIndexLength = [\n  number,\n  number,\n  Record<string, unknown>,\n  EmitterSource,\n];\nfunction overload(index: number, source?: EmitterSource): NormalizedIndexLength;\nfunction overload(\n  index: number,\n  length: number,\n  source?: EmitterSource,\n): NormalizedIndexLength;\nfunction overload(\n  index: number,\n  length: number,\n  format: string,\n  value: unknown,\n  source?: EmitterSource,\n): NormalizedIndexLength;\nfunction overload(\n  index: number,\n  length: number,\n  format: Record<string, unknown>,\n  source?: EmitterSource,\n): NormalizedIndexLength;\nfunction overload(range: Range, source?: EmitterSource): NormalizedIndexLength;\nfunction overload(\n  range: Range,\n  format: string,\n  value: unknown,\n  source?: EmitterSource,\n): NormalizedIndexLength;\nfunction overload(\n  range: Range,\n  format: Record<string, unknown>,\n  source?: EmitterSource,\n): NormalizedIndexLength;\nfunction overload(\n  index: Range | number,\n  length?: number | string | Record<string, unknown> | EmitterSource,\n  name?: string | unknown | Record<string, unknown> | EmitterSource,\n  value?: unknown | EmitterSource,\n  source?: EmitterSource,\n): NormalizedIndexLength {\n  let formats: Record<string, unknown> = {};\n  // @ts-expect-error\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      // @ts-expect-error\n      source = value;\n      value = name;\n      name = length;\n      // @ts-expect-error\n      length = index.length; // eslint-disable-line prefer-destructuring\n      // @ts-expect-error\n      index = index.index; // eslint-disable-line prefer-destructuring\n    } else {\n      // @ts-expect-error\n      length = index.length; // eslint-disable-line prefer-destructuring\n      // @ts-expect-error\n      index = index.index; // eslint-disable-line prefer-destructuring\n    }\n  } else if (typeof length !== 'number') {\n    // @ts-expect-error\n    source = value;\n    value = name;\n    name = length;\n    length = 0;\n  }\n  // Handle format being object, two format name/value strings or excluded\n  if (typeof name === 'object') {\n    // @ts-expect-error Fix me later\n    formats = name;\n    // @ts-expect-error\n    source = value;\n  } else if (typeof name === 'string') {\n    if (value != null) {\n      formats[name] = value;\n    } else {\n      // @ts-expect-error\n      source = name;\n    }\n  }\n  // Handle optional source\n  source = source || Emitter.sources.API;\n  // @ts-expect-error\n  return [index, length, formats, source];\n}\n\nfunction shiftRange(range: Range, change: Delta, source?: EmitterSource): Range;\nfunction shiftRange(\n  range: Range,\n  index: number,\n  length?: number,\n  source?: EmitterSource,\n): Range;\nfunction shiftRange(\n  range: Range,\n  index: number | Delta,\n  lengthOrSource?: number | EmitterSource,\n  source?: EmitterSource,\n) {\n  const length = typeof lengthOrSource === 'number' ? lengthOrSource : 0;\n  if (range == null) return null;\n  let start;\n  let end;\n  // @ts-expect-error -- TODO: add a better type guard around `index`\n  if (index && typeof index.transformPosition === 'function') {\n    [start, end] = [range.index, range.index + range.length].map((pos) =>\n      // @ts-expect-error -- TODO: add a better type guard around `index`\n      index.transformPosition(pos, source !== Emitter.sources.USER),\n    );\n  } else {\n    [start, end] = [range.index, range.index + range.length].map((pos) => {\n      // @ts-expect-error -- TODO: add a better type guard around `index`\n      if (pos < index || (pos === index && source === Emitter.sources.USER))\n        return pos;\n      if (length >= 0) {\n        return pos + length;\n      }\n      // @ts-expect-error -- TODO: add a better type guard around `index`\n      return Math.max(index, pos + length);\n    });\n  }\n  return new Range(start, end - start);\n}\n\nexport type { Bounds, DebugLevel, EmitterSource };\nexport { Parchment, Range };\n\nexport { globalRegistry, expandConfig, overload, Quill as default };\n","import { LeafBlot, Scope } from 'parchment';\nimport Emitter from './emitter.js';\nimport type { EmitterSource } from './emitter.js';\nimport logger from './logger.js';\nimport type Cursor from '../blots/cursor.js';\nimport type Scroll from '../blots/scroll.js';\nimport cloneDeep from './utils/cloneDeep.js';\nimport isEqual from './utils/isEqual.js';\n\nconst debug = logger('quill:selection');\n\ntype NativeRange = AbstractRange;\n\nconst getNativeSelection = (rootNode: Node): globalThis.Selection | null => {\n  try {\n    if (\n      'getSelection' in rootNode &&\n      typeof rootNode.getSelection === 'function'\n    ) {\n      return rootNode.getSelection();\n    } else {\n      return window.getSelection();\n    }\n  } catch {\n    return null;\n  }\n};\n\ninterface NormalizedRange {\n  start: {\n    node: NativeRange['startContainer'];\n    offset: NativeRange['startOffset'];\n  };\n  end: { node: NativeRange['endContainer']; offset: NativeRange['endOffset'] };\n  native: NativeRange;\n}\n\nexport interface Bounds {\n  bottom: number;\n  height: number;\n  left: number;\n  right: number;\n  top: number;\n  width: number;\n}\n\nexport class Range {\n  constructor(\n    public index: number,\n    public length = 0,\n  ) {}\n}\n\nclass Selection {\n  scroll: Scroll;\n  emitter: Emitter;\n  composing: boolean;\n  mouseDown: boolean;\n\n  root: HTMLElement;\n  rootDocument: Node;\n  cursor: Cursor;\n  savedRange: Range;\n  lastRange: Range | null;\n  lastNative: NormalizedRange | null;\n\n  constructor(scroll: Scroll, emitter: 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();\n    // @ts-expect-error\n    this.cursor = this.scroll.create('cursor', this);\n    // savedRange is last non-null range\n    this.savedRange = new Range(0, 0);\n    this.lastRange = this.savedRange;\n    this.lastNative = null;\n    this.handleComposition();\n    this.handleDragging();\n    this.emitter.listenDOM('selectionchange', this.rootDocument, () => {\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, () => {\n      if (!this.hasFocus()) return;\n      const native = this.getNativeRange();\n      if (native == null) return;\n      if (native.start.node === this.cursor.textNode) return; // cursor.restore() will handle\n      this.emitter.once(\n        Emitter.events.SCROLL_UPDATE,\n        (source, mutations: MutationRecord[]) => {\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,\n                native.end.node,\n                native.end.offset,\n              );\n            }\n            const triggeredByTyping = mutations.some(\n              (mutation) =>\n                mutation.type === 'characterData' ||\n                mutation.type === 'childList' ||\n                (mutation.type === 'attributes' &&\n                  mutation.target === this.root),\n            );\n            this.update(triggeredByTyping ? Emitter.sources.SILENT : source);\n          } catch (ignored) {\n            // ignore\n          }\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        this.update(Emitter.sources.SILENT);\n      }\n    });\n    this.update(Emitter.sources.SILENT);\n  }\n\n  handleComposition() {\n    this.emitter.on(Emitter.events.COMPOSITION_BEFORE_START, () => {\n      this.composing = true;\n    });\n    this.emitter.on(Emitter.events.COMPOSITION_END, () => {\n      this.composing = false;\n      if (this.cursor.parent) {\n        const range = this.cursor.restore();\n        if (!range) return;\n        setTimeout(() => {\n          this.setNativeRange(\n            range.startNode,\n            range.startOffset,\n            range.endNode,\n            range.endOffset,\n          );\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({ preventScroll: true });\n    this.setRange(this.savedRange);\n  }\n\n  format(format: string, value: unknown) {\n    this.scroll.update();\n    const nativeRange = this.getNativeRange();\n    if (\n      nativeRange == null ||\n      !nativeRange.native.collapsed ||\n      this.scroll.query(format, Scope.BLOCK)\n    )\n      return;\n    if (nativeRange.start.node !== this.cursor.textNode) {\n      const blot = this.scroll.find(nativeRange.start.node, false);\n      if (blot == null) return;\n      // TODO Give blot ability to not split\n      if (blot instanceof LeafBlot) {\n        const after = blot.split(nativeRange.start.offset);\n        blot.parent.insertBefore(this.cursor, after);\n      } else {\n        // @ts-expect-error TODO: nativeRange.start.node doesn't seem to match function signature\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: number, length = 0) {\n    const scrollLength = this.scroll.length();\n    index = Math.min(index, scrollLength - 1);\n    length = Math.min(index + length, scrollLength - 1) - index;\n    let node: Node;\n    let [leaf, offset] = this.scroll.leaf(index);\n    if (leaf == null) return null;\n    if (length > 0 && offset === leaf.length()) {\n      const [next] = this.scroll.leaf(index + 1);\n      if (next) {\n        const [line] = this.scroll.line(index);\n        const [nextLine] = this.scroll.line(index + 1);\n        if (line === nextLine) {\n          leaf = next;\n          offset = 0;\n        }\n      }\n    }\n    [node, offset] = leaf.position(offset, true);\n    const 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    }\n    let side: 'left' | 'right' = 'left';\n    let rect: DOMRect;\n    if (node instanceof Text) {\n      // Return null if the text node is empty because it is\n      // not able to get a useful client rect:\n      // https://github.com/w3c/csswg-drafts/issues/2514.\n      // Empty text nodes are most likely caused by TextBlot#optimize()\n      // not getting called when editor content changes.\n      if (!node.data.length) {\n        return null;\n      }\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      if (!(leaf.domNode instanceof Element)) return null;\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  getNativeRange(): NormalizedRange | null {\n    // Each browser engine has a different implementation for retrieving the Range\n    const getNativeRange = (rootNode: Node): globalThis.Range | null => {\n      const selection = getNativeSelection(rootNode);\n      if (!selection?.anchorNode) return null;\n\n      if (\n        selection &&\n        'getComposedRanges' in selection &&\n        typeof selection.getComposedRanges === 'function' &&\n        // Chrome 137 also has `getComposedRanges()` but it's messed up\n        // when using it on the result of `shadowRoot.getSelection()`\n        !(rootNode instanceof ShadowRoot && 'getSelection' in rootNode)\n      ) {\n        // Safari 17+ supports `getComposedRanges()` for range retrieval\n        // See https://caniuse.com/mdn-api_selection_getcomposedranges\n        return selection.getComposedRanges(rootNode)[0];\n      }\n\n      // Chrome and Firefox implement the range API properly in Shadow DOM\n      // https://developer.mozilla.org/en-US/docs/Web/API/Selection/getRangeAt\n      return selection.getRangeAt(0);\n    };\n\n    const nativeRange = getNativeRange(this.rootDocument);\n    if (nativeRange == null) return null;\n    const range = this.normalizeNative(nativeRange);\n    debug.info('getNativeRange', range);\n    return range;\n  }\n\n  getRange(): [Range, NormalizedRange] | [null, null] {\n    const root = this.scroll.domNode;\n    if ('isConnected' in root && !root.isConnected) {\n      // document.getSelection() forces layout on Blink, so we trend to\n      // not calling it.\n      return [null, null];\n    }\n    const normalized = this.getNativeRange();\n    if (normalized == null) return [null, null];\n    const range = this.normalizedToRange(normalized);\n    return [range, normalized];\n  }\n\n  hasFocus(): boolean {\n    const doc = this.rootDocument as Document;\n\n    return (\n      doc.activeElement === this.root ||\n      (doc.activeElement != null && contains(this.root, doc.activeElement))\n    );\n  }\n\n  normalizedToRange(range: NormalizedRange) {\n    const positions: [Node, number][] = [\n      [range.start.node, range.start.offset],\n    ];\n    if (!range.native.collapsed) {\n      positions.push([range.end.node, range.end.offset]);\n    }\n    const indexes = positions.map((position) => {\n      const [node, offset] = position;\n      const blot = this.scroll.find(node, true);\n      // @ts-expect-error Fix me later\n      const index = blot.offset(this.scroll);\n      if (offset === 0) {\n        return index;\n      }\n      if (blot instanceof LeafBlot) {\n        return index + blot.index(node, offset);\n      }\n      // @ts-expect-error Fix me later\n      return index + blot.length();\n    });\n    const end = Math.min(Math.max(...indexes), this.scroll.length() - 1);\n    const start = Math.min(end, ...indexes);\n    return new Range(start, end - start);\n  }\n\n  normalizeNative(nativeRange: NativeRange) {\n    if (\n      !contains(this.root, nativeRange.startContainer) ||\n      (!nativeRange.collapsed && !contains(this.root, nativeRange.endContainer))\n    ) {\n      return null;\n    }\n    const range = {\n      start: {\n        node: nativeRange.startContainer,\n        offset: nativeRange.startOffset,\n      },\n      end: { node: nativeRange.endContainer, offset: nativeRange.endOffset },\n      native: nativeRange,\n    };\n    [range.start, range.end].forEach((position) => {\n      let { node, offset } = position;\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          // @ts-expect-error Fix me later\n          node = node.lastChild;\n          if (node instanceof Text) {\n            offset = node.data.length;\n          } else if (node.childNodes.length > 0) {\n            // Container case\n            offset = node.childNodes.length;\n          } else {\n            // Embed case\n            offset = node.childNodes.length + 1;\n          }\n        } else {\n          break;\n        }\n      }\n      position.node = node;\n      position.offset = offset;\n    });\n    return range;\n  }\n\n  rangeToNative(range: Range): [Node | null, number, Node | null, number] {\n    const scrollLength = this.scroll.length();\n\n    const getPosition = (\n      index: number,\n      inclusive: boolean,\n    ): [Node | null, number] => {\n      index = Math.min(scrollLength - 1, index);\n      const [leaf, leafOffset] = this.scroll.leaf(index);\n      return leaf ? leaf.position(leafOffset, inclusive) : [null, -1];\n    };\n    return [\n      ...getPosition(range.index, false),\n      ...getPosition(range.index + range.length, true),\n    ];\n  }\n\n  setNativeRange(\n    startNode: Node | null,\n    startOffset?: number,\n    endNode = startNode,\n    endOffset = startOffset,\n    force = false,\n  ) {\n    debug.info('setNativeRange', startNode, startOffset, endNode, endOffset);\n    if (\n      startNode != null &&\n      (this.root.parentNode == null ||\n        startNode.parentNode == null ||\n        // @ts-expect-error Fix me later\n        endNode.parentNode == null)\n    ) {\n      return;\n    }\n    const selection = getNativeSelection(this.rootDocument as Document);\n    if (selection == null) return;\n    if (startNode != null) {\n      if (!this.hasFocus()) this.root.focus({ preventScroll: true });\n      const { native } = this.getNativeRange() || {};\n      if (\n        native == null ||\n        force ||\n        startNode !== native.startContainer ||\n        startOffset !== native.startOffset ||\n        endNode !== native.endContainer ||\n        endOffset !== native.endOffset\n      ) {\n        if (startNode instanceof Element && startNode.tagName === 'BR') {\n          // @ts-expect-error Fix me later\n          startOffset = Array.from(startNode.parentNode.childNodes).indexOf(\n            startNode,\n          );\n          startNode = startNode.parentNode;\n        }\n        if (endNode instanceof Element && endNode.tagName === 'BR') {\n          // @ts-expect-error Fix me later\n          endOffset = Array.from(endNode.parentNode.childNodes).indexOf(\n            endNode,\n          );\n          endNode = endNode.parentNode;\n        }\n        // Original implementation relies on Selection.addRange, which does not work\n        // in Webkit with shadow DOM. Use `setBaseAndExtent()` as a workaround.\n        // See https://github.com/slab/quill/issues/2021#issuecomment-1776007758\n        if (\n          startNode &&\n          endNode &&\n          typeof startOffset === 'number' &&\n          typeof endOffset === 'number'\n        ) {\n          selection.setBaseAndExtent(\n            startNode,\n            startOffset,\n            endNode,\n            endOffset,\n          );\n        }\n      }\n    } else {\n      selection.removeAllRanges();\n      this.root.blur();\n    }\n  }\n\n  setRange(range: Range | null, force: boolean, source?: EmitterSource): void;\n  setRange(range: Range | null, source?: EmitterSource): void;\n  setRange(\n    range: Range | null,\n    force: boolean | EmitterSource = false,\n    source: EmitterSource = Emitter.sources.API,\n  ): void {\n    if (typeof force === 'string') {\n      source = force;\n      force = false;\n    }\n    debug.info('setRange', range);\n    if (range != null) {\n      const 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: EmitterSource = Emitter.sources.USER) {\n    const oldRange = this.lastRange;\n    const [lastRange, nativeRange] = this.getRange();\n    this.lastRange = lastRange;\n    this.lastNative = nativeRange;\n    if (this.lastRange != null) {\n      this.savedRange = this.lastRange;\n    }\n    if (!isEqual(oldRange, this.lastRange)) {\n      if (\n        !this.composing &&\n        nativeRange != null &&\n        nativeRange.native.collapsed &&\n        nativeRange.start.node !== this.cursor.textNode\n      ) {\n        const range = this.cursor.restore();\n        if (range) {\n          this.setNativeRange(\n            range.startNode,\n            range.startOffset,\n            range.endNode,\n            range.endOffset,\n          );\n        }\n      }\n      const args = [\n        Emitter.events.SELECTION_CHANGE,\n        cloneDeep(this.lastRange),\n        cloneDeep(oldRange),\n        source,\n      ];\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\nfunction contains(parent: Node, descendant: Node) {\n  try {\n    // Firefox inserts inaccessible nodes around video elements\n    descendant.parentNode; // eslint-disable-line @typescript-eslint/no-unused-expressions\n  } catch (e) {\n    return false;\n  }\n  return parent.contains(descendant);\n}\n\nexport default Selection;\n","import type Quill from '../core.js';\nimport type Clipboard from '../modules/clipboard.js';\nimport type History from '../modules/history.js';\nimport type Keyboard from '../modules/keyboard.js';\nimport type { ToolbarProps } from '../modules/toolbar.js';\nimport type Uploader from '../modules/uploader.js';\n\nexport interface ThemeOptions {\n  modules: Record<string, unknown> & {\n    toolbar?: null | ToolbarProps;\n  };\n}\n\nclass Theme {\n  static DEFAULTS: ThemeOptions = {\n    modules: {},\n  };\n\n  static themes = {\n    default: Theme,\n  };\n\n  modules: ThemeOptions['modules'] = {};\n\n  constructor(\n    protected quill: Quill,\n    protected options: ThemeOptions,\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: 'clipboard'): Clipboard;\n  addModule(name: 'keyboard'): Keyboard;\n  addModule(name: 'uploader'): Uploader;\n  addModule(name: 'history'): History;\n  addModule(name: string): unknown;\n  addModule(name: string) {\n    // @ts-expect-error\n    const ModuleClass = this.quill.constructor.import(`modules/${name}`);\n    this.modules[name] = new ModuleClass(\n      this.quill,\n      this.options.modules[name] || {},\n    );\n    return this.modules[name];\n  }\n}\n\nexport interface ThemeConstructor {\n  new (quill: Quill, options: unknown): Theme;\n  DEFAULTS: ThemeOptions;\n}\n\nexport default Theme;\n","// Copied from https://github.com/vincentdchan/delta-es/blob/main/src/cloneDeep.ts\n\n/**\n * This is much smaller and faster than the lodash-es version.\n */\nfunction cloneDeep<T>(obj: T): T {\n  return JSON.parse(JSON.stringify(obj));\n}\n\nexport default cloneDeep;\n","// Copied from https://github.com/vincentdchan/delta-es/blob/main/src/deepEqual.ts\n\nfunction isEqual(obj1: any, obj2: any): boolean {\n  if (obj1 === obj2)\n    // it's just the same object. No need to compare.\n    return true;\n\n  if (isPrimitive(obj1) || isPrimitive(obj2))\n    // compare primitives\n    return obj1 === obj2;\n\n  if (Object.keys(obj1).length !== Object.keys(obj2).length) return false;\n\n  // compare objects with same number of keys\n  for (const key in obj1) {\n    if (!(key in obj2)) return false; // other object doesn't have this prop\n    if (!isEqual(obj1[key], obj2[key])) return false;\n  }\n\n  return true;\n}\n\n// check if value is primitive\nfunction isPrimitive(obj: any) {\n  return obj !== Object(obj);\n}\n\nexport default isEqual;\n","import { Attributor, ClassAttributor, Scope, StyleAttributor } from 'parchment';\n\nconst config = {\n  scope: Scope.BLOCK,\n  whitelist: ['right', 'center', 'justify'],\n};\n\nconst AlignAttribute = new Attributor('align', 'align', config);\nconst AlignClass = new ClassAttributor('align', 'ql-align', config);\nconst AlignStyle = new StyleAttributor('align', 'text-align', config);\n\nexport { AlignAttribute, AlignClass, AlignStyle };\n","import { ClassAttributor, Scope } from 'parchment';\nimport { ColorAttributor } from './color.js';\n\nconst BackgroundClass = new ClassAttributor('background', 'ql-bg', {\n  scope: Scope.INLINE,\n});\nconst BackgroundStyle = new ColorAttributor('background', 'background-color', {\n  scope: Scope.INLINE,\n});\n\nexport { BackgroundClass, BackgroundStyle };\n","import Block from '../blots/block.js';\nimport Break from '../blots/break.js';\nimport Cursor from '../blots/cursor.js';\nimport Inline from '../blots/inline.js';\nimport TextBlot, { escapeText } from '../blots/text.js';\nimport Container from '../blots/container.js';\nimport Quill from '../core/quill.js';\n\nclass CodeBlockContainer extends Container {\n  static create(value: string) {\n    const domNode = super.create(value) as Element;\n    domNode.setAttribute('spellcheck', 'false');\n    return domNode;\n  }\n\n  code(index: number, length: number) {\n    return (\n      this.children\n        // @ts-expect-error\n        .map((child) => (child.length() <= 1 ? '' : child.domNode.innerText))\n        .join('\\n')\n        .slice(index, index + length)\n    );\n  }\n\n  html(index: number, length: number) {\n    // `\\n`s are needed in order to support empty lines at the beginning and the end.\n    // https://html.spec.whatwg.org/multipage/syntax.html#element-restrictions\n    return `<pre>\\n${escapeText(this.code(index, length))}\\n</pre>`;\n  }\n}\n\nclass CodeBlock extends Block {\n  static TAB = '  ';\n\n  static register() {\n    Quill.register(CodeBlockContainer);\n  }\n}\n\nclass Code extends Inline {}\nCode.blotName = 'code';\nCode.tagName = 'CODE';\n\nCodeBlock.blotName = 'code-block';\nCodeBlock.className = 'ql-code-block';\nCodeBlock.tagName = 'DIV';\nCodeBlockContainer.blotName = 'code-block-container';\nCodeBlockContainer.className = 'ql-code-block-container';\nCodeBlockContainer.tagName = 'DIV';\n\nCodeBlockContainer.allowedChildren = [CodeBlock];\n\nCodeBlock.allowedChildren = [TextBlot, Break, Cursor];\nCodeBlock.requiredContainer = CodeBlockContainer;\n\nexport { Code, CodeBlockContainer, CodeBlock as default };\n","import { ClassAttributor, Scope, StyleAttributor } from 'parchment';\n\nclass ColorAttributor extends StyleAttributor {\n  value(domNode: HTMLElement) {\n    let value = super.value(domNode) as string;\n    if (!value.startsWith('rgb(')) return value;\n    value = value.replace(/^[^\\d]+/, '').replace(/[^\\d]+$/, '');\n    const hex = value\n      .split(',')\n      .map((component) => `00${parseInt(component, 10).toString(16)}`.slice(-2))\n      .join('');\n    return `#${hex}`;\n  }\n}\n\nconst ColorClass = new ClassAttributor('color', 'ql-color', {\n  scope: Scope.INLINE,\n});\nconst ColorStyle = new ColorAttributor('color', 'color', {\n  scope: Scope.INLINE,\n});\n\nexport { ColorAttributor, ColorClass, ColorStyle };\n","import { Attributor, ClassAttributor, Scope, StyleAttributor } from 'parchment';\n\nconst config = {\n  scope: Scope.BLOCK,\n  whitelist: ['rtl'],\n};\n\nconst DirectionAttribute = new Attributor('direction', 'dir', config);\nconst DirectionClass = new ClassAttributor('direction', 'ql-direction', config);\nconst DirectionStyle = new StyleAttributor('direction', 'direction', config);\n\nexport { DirectionAttribute, DirectionClass, DirectionStyle };\n","import { ClassAttributor, Scope, StyleAttributor } from 'parchment';\n\nconst config = {\n  scope: Scope.INLINE,\n  whitelist: ['serif', 'monospace'],\n};\n\nconst FontClass = new ClassAttributor('font', 'ql-font', config);\n\nclass FontStyleAttributor extends StyleAttributor {\n  value(node: HTMLElement) {\n    return super.value(node).replace(/[\"']/g, '');\n  }\n}\n\nconst FontStyle = new FontStyleAttributor('font', 'font-family', config);\n\nexport { FontStyle, FontClass };\n","import { ClassAttributor, Scope, StyleAttributor } from 'parchment';\n\nconst SizeClass = new ClassAttributor('size', 'ql-size', {\n  scope: Scope.INLINE,\n  whitelist: ['small', 'large', 'huge'],\n});\nconst SizeStyle = new StyleAttributor('size', 'font-size', {\n  scope: Scope.INLINE,\n  whitelist: ['10px', '18px', '32px'],\n});\n\nexport { SizeClass, SizeStyle };\n","const normalWeightRegexp = /font-weight:\\s*normal/;\nconst blockTagNames = ['P', 'OL', 'UL'];\n\nconst isBlockElement = (element: Element | null) => {\n  return element && blockTagNames.includes(element.tagName);\n};\n\nconst normalizeEmptyLines = (doc: Document) => {\n  Array.from(doc.querySelectorAll('br'))\n    .filter(\n      (br) =>\n        isBlockElement(br.previousElementSibling) &&\n        isBlockElement(br.nextElementSibling),\n    )\n    .forEach((br) => {\n      br.parentNode?.removeChild(br);\n    });\n};\n\nconst normalizeFontWeight = (doc: Document) => {\n  Array.from(doc.querySelectorAll('b[style*=\"font-weight\"]'))\n    .filter((node) => node.getAttribute('style')?.match(normalWeightRegexp))\n    .forEach((node) => {\n      const fragment = doc.createDocumentFragment();\n      fragment.append(...node.childNodes);\n      node.parentNode?.replaceChild(fragment, node);\n    });\n};\n\nexport default function normalize(doc: Document) {\n  if (doc.querySelector('[id^=\"docs-internal-guid-\"]')) {\n    normalizeFontWeight(doc);\n    normalizeEmptyLines(doc);\n  }\n}\n","const ignoreRegexp = /\\bmso-list:[^;]*ignore/i;\nconst idRegexp = /\\bmso-list:[^;]*\\bl(\\d+)/i;\nconst indentRegexp = /\\bmso-list:[^;]*\\blevel(\\d+)/i;\n\nconst parseListItem = (element: Element, html: string) => {\n  const style = element.getAttribute('style');\n  const idMatch = style?.match(idRegexp);\n  if (!idMatch) {\n    return null;\n  }\n  const id = Number(idMatch[1]);\n\n  const indentMatch = style?.match(indentRegexp);\n  const indent = indentMatch ? Number(indentMatch[1]) : 1;\n\n  const typeRegexp = new RegExp(\n    `@list l${id}:level${indent}\\\\s*\\\\{[^\\\\}]*mso-level-number-format:\\\\s*([\\\\w-]+)`,\n    'i',\n  );\n  const typeMatch = html.match(typeRegexp);\n  const type = typeMatch && typeMatch[1] === 'bullet' ? 'bullet' : 'ordered';\n\n  return { id, indent, type, element };\n};\n\n// list items are represented as `p` tags with styles like `mso-list: l0 level1` where:\n// 1. \"0\" in \"l0\" means the list item id;\n// 2. \"1\" in \"level1\" means the indent level, starting from 1.\nconst normalizeListItem = (doc: Document) => {\n  const msoList = Array.from(doc.querySelectorAll('[style*=mso-list]'));\n  const ignored: Element[] = [];\n  const others: Element[] = [];\n  msoList.forEach((node) => {\n    const shouldIgnore = (node.getAttribute('style') || '').match(ignoreRegexp);\n    if (shouldIgnore) {\n      ignored.push(node);\n    } else {\n      others.push(node);\n    }\n  });\n\n  // Each list item contains a marker wrapped with \"mso-list: Ignore\".\n  ignored.forEach((node) => node.parentNode?.removeChild(node));\n\n  // The list stype is not defined inline with the tag, instead, it's in the\n  // style tag so we need to pass the html as a string.\n  const html = doc.documentElement.innerHTML;\n  const listItems = others\n    .map((element) => parseListItem(element, html))\n    .filter((parsed) => parsed);\n\n  while (listItems.length) {\n    const childListItems = [];\n\n    let current = listItems.shift();\n    // Group continuous items into the same group (aka \"ul\")\n    while (current) {\n      childListItems.push(current);\n      current =\n        listItems.length &&\n        listItems[0]?.element === current.element.nextElementSibling &&\n        // Different id means the next item doesn't belong to this group.\n        listItems[0].id === current.id\n          ? listItems.shift()\n          : null;\n    }\n\n    const ul = document.createElement('ul');\n    childListItems.forEach((listItem) => {\n      const li = document.createElement('li');\n      li.setAttribute('data-list', listItem.type);\n      if (listItem.indent > 1) {\n        li.setAttribute('class', `ql-indent-${listItem.indent - 1}`);\n      }\n      li.innerHTML = listItem.element.innerHTML;\n      ul.appendChild(li);\n    });\n\n    const element = childListItems[0]?.element;\n    const { parentNode } = element ?? {};\n    if (element) {\n      parentNode?.replaceChild(ul, element);\n    }\n    childListItems.slice(1).forEach(({ element: e }) => {\n      parentNode?.removeChild(e);\n    });\n  }\n};\n\nexport default function normalize(doc: Document) {\n  if (\n    doc.documentElement.getAttribute('xmlns:w') ===\n    'urn:schemas-microsoft-com:office:word'\n  ) {\n    normalizeListItem(doc);\n  }\n}\n","import googleDocs from './normalizers/googleDocs.js';\nimport msWord from './normalizers/msWord.js';\n\nconst NORMALIZERS = [msWord, googleDocs];\n\nconst normalizeExternalHTML = (doc: Document) => {\n  if (doc.documentElement) {\n    NORMALIZERS.forEach((normalize) => {\n      normalize(doc);\n    });\n  }\n};\n\nexport default normalizeExternalHTML;\n","import type { ScrollBlot } from 'parchment';\nimport {\n  Attributor,\n  BlockBlot,\n  ClassAttributor,\n  EmbedBlot,\n  Scope,\n  StyleAttributor,\n} from 'parchment';\nimport Delta from 'quill-delta-es';\nimport { BlockEmbed } from '../blots/block.js';\nimport type { EmitterSource } from '../core/emitter.js';\nimport logger from '../core/logger.js';\nimport Module from '../core/module.js';\nimport Quill from '../core/quill.js';\nimport type { Range } from '../core/selection.js';\nimport { AlignAttribute, AlignStyle } from '../formats/align.js';\nimport { BackgroundStyle } from '../formats/background.js';\nimport CodeBlock from '../formats/code.js';\nimport { ColorStyle } from '../formats/color.js';\nimport { DirectionAttribute, DirectionStyle } from '../formats/direction.js';\nimport { FontStyle } from '../formats/font.js';\nimport { SizeStyle } from '../formats/size.js';\nimport { deleteRange } from './keyboard.js';\nimport normalizeExternalHTML from './normalizeExternalHTML/index.js';\n\nconst debug = logger('quill:clipboard');\n\ntype Selector = string | Node['TEXT_NODE'] | Node['ELEMENT_NODE'];\ntype Matcher = (node: Node, delta: Delta, scroll: ScrollBlot) => Delta;\n\nconst CLIPBOARD_CONFIG: [Selector, Matcher][] = [\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  ['ol, ul', matchList],\n  ['pre', matchCodeBlock],\n  ['tr', matchTable],\n  ['b', createMatchAlias('bold')],\n  ['i', createMatchAlias('italic')],\n  ['strike', createMatchAlias('strike')],\n  ['style', matchIgnore],\n];\n\nconst ATTRIBUTE_ATTRIBUTORS = [AlignAttribute, DirectionAttribute].reduce(\n  (memo: Record<string, Attributor>, attr) => {\n    memo[attr.keyName] = attr;\n    return memo;\n  },\n  {},\n);\n\nconst STYLE_ATTRIBUTORS = [\n  AlignStyle,\n  BackgroundStyle,\n  ColorStyle,\n  DirectionStyle,\n  FontStyle,\n  SizeStyle,\n].reduce((memo: Record<string, Attributor>, attr) => {\n  memo[attr.keyName] = attr;\n  return memo;\n}, {});\n\ninterface ClipboardOptions {\n  matchers: [Selector, Matcher][];\n}\n\nclass Clipboard extends Module<ClipboardOptions> {\n  static DEFAULTS: ClipboardOptions = {\n    matchers: [],\n  };\n\n  matchers: [Selector, Matcher][];\n\n  constructor(quill: Quill, options: Partial<ClipboardOptions>) {\n    super(quill, options);\n    this.quill.root.addEventListener('copy', (e) =>\n      this.onCaptureCopy(e, false),\n    );\n    this.quill.root.addEventListener('cut', (e) => this.onCaptureCopy(e, true));\n    this.quill.root.addEventListener('paste', this.onCapturePaste.bind(this));\n    this.matchers = [];\n    CLIPBOARD_CONFIG.concat(this.options.matchers ?? []).forEach(\n      ([selector, matcher]) => {\n        this.addMatcher(selector, matcher);\n      },\n    );\n  }\n\n  addMatcher(selector: Selector, matcher: Matcher) {\n    this.matchers.push([selector, matcher]);\n  }\n\n  convert(\n    { html, text }: { html?: string; text?: string },\n    formats: Record<string, unknown> = {},\n  ) {\n    if (formats[CodeBlock.blotName]) {\n      return new Delta().insert(text || '', {\n        [CodeBlock.blotName]: formats[CodeBlock.blotName],\n      });\n    }\n    if (!html) {\n      return new Delta().insert(text || '', formats);\n    }\n    const delta = this.convertHTML(html);\n    // Remove trailing newline\n    if (\n      deltaEndsWith(delta, '\\n') &&\n      (delta.ops[delta.ops.length - 1].attributes == null || formats.table)\n    ) {\n      return delta.compose(new Delta().retain(delta.length() - 1).delete(1));\n    }\n    return delta;\n  }\n\n  protected normalizeHTML(doc: Document) {\n    normalizeExternalHTML(doc);\n  }\n\n  protected convertHTML(html: string) {\n    const doc = new DOMParser().parseFromString(html, 'text/html');\n    this.normalizeHTML(doc);\n    const container = doc.body;\n    const nodeMatches = new WeakMap();\n    const [elementMatchers, textMatchers] = this.prepareMatching(\n      container,\n      nodeMatches,\n    );\n    return traverse(\n      this.quill.scroll,\n      container,\n      elementMatchers,\n      textMatchers,\n      nodeMatches,\n    );\n  }\n\n  dangerouslyPasteHTML(html: string, source?: EmitterSource): void;\n  dangerouslyPasteHTML(\n    index: number,\n    html: string,\n    source?: EmitterSource,\n  ): void;\n  dangerouslyPasteHTML(\n    index: number | string,\n    html?: string,\n    source: EmitterSource = Quill.sources.API,\n  ) {\n    if (typeof index === 'string') {\n      const delta = this.convert({ html: index, text: '' });\n      // @ts-expect-error\n      this.quill.setContents(delta, html);\n      this.quill.setSelection(0, Quill.sources.SILENT);\n    } else {\n      const paste = this.convert({ html, text: '' });\n      this.quill.updateContents(\n        new Delta().retain(index).concat(paste),\n        source,\n      );\n      this.quill.setSelection(index + paste.length(), Quill.sources.SILENT);\n    }\n  }\n\n  onCaptureCopy(e: ClipboardEvent, isCut = false) {\n    if (e.defaultPrevented) return;\n    e.preventDefault();\n    const [range] = this.quill.selection.getRange();\n    if (range == null) return;\n    const { html, text } = this.onCopy(range, isCut);\n    e.clipboardData?.setData('text/plain', text);\n    e.clipboardData?.setData('text/html', html);\n    if (isCut) {\n      deleteRange({ range, quill: this.quill });\n    }\n  }\n\n  /*\n   * https://www.iana.org/assignments/media-types/text/uri-list\n   */\n  private normalizeURIList(urlList: string) {\n    return (\n      urlList\n        .split(/\\r?\\n/)\n        // Ignore all comments\n        .filter((url) => url[0] !== '#')\n        .join('\\n')\n    );\n  }\n\n  onCapturePaste(e: ClipboardEvent) {\n    if (e.defaultPrevented || !this.quill.isEnabled()) return;\n    e.preventDefault();\n    const range = this.quill.getSelection(true);\n    if (range == null) return;\n    const html = e.clipboardData?.getData('text/html');\n    let text = e.clipboardData?.getData('text/plain');\n    if (!html && !text) {\n      const urlList = e.clipboardData?.getData('text/uri-list');\n      if (urlList) {\n        text = this.normalizeURIList(urlList);\n      }\n    }\n    const files = Array.from(e.clipboardData?.files || []);\n    if (!html && files.length > 0) {\n      this.quill.uploader.upload(range, files);\n      return;\n    }\n    if (html && files.length > 0) {\n      const doc = new DOMParser().parseFromString(html, 'text/html');\n      if (\n        doc.body.childElementCount === 1 &&\n        doc.body.firstElementChild?.tagName === 'IMG'\n      ) {\n        this.quill.uploader.upload(range, files);\n        return;\n      }\n    }\n    this.onPaste(range, { html, text });\n  }\n\n  onCopy(range: Range, isCut: boolean): { html: string; text: string };\n  onCopy(range: Range) {\n    const text = this.quill.getText(range);\n    const html = this.quill.getSemanticHTML(range);\n    return { html, text };\n  }\n\n  onPaste(range: Range, { text, html }: { text?: string; html?: string }) {\n    const formats = this.quill.getFormat(range.index);\n    const pastedDelta = this.convert({ text, html }, formats);\n    debug.log('onPaste', pastedDelta, { text, html });\n    const delta = new Delta()\n      .retain(range.index)\n      .delete(range.length)\n      .concat(pastedDelta);\n    this.quill.updateContents(delta, Quill.sources.USER);\n    // range.length contributes to delta.length()\n    this.quill.setSelection(\n      delta.length() - range.length,\n      Quill.sources.SILENT,\n    );\n    this.quill.scrollSelectionIntoView();\n  }\n\n  prepareMatching(container: Element, nodeMatches: WeakMap<Node, Matcher[]>) {\n    const elementMatchers: Matcher[] = [];\n    const textMatchers: Matcher[] = [];\n    this.matchers.forEach((pair) => {\n      const [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          Array.from(container.querySelectorAll(selector)).forEach((node) => {\n            if (nodeMatches.has(node)) {\n              const matches = nodeMatches.get(node);\n              matches?.push(matcher);\n            } else {\n              nodeMatches.set(node, [matcher]);\n            }\n          });\n          break;\n      }\n    });\n    return [elementMatchers, textMatchers];\n  }\n}\n\nfunction applyFormat(\n  delta: Delta,\n  format: string,\n  value: unknown,\n  scroll: ScrollBlot,\n): Delta {\n  if (!scroll.query(format)) {\n    return delta;\n  }\n\n  return delta.reduce((newDelta, op) => {\n    if (!op.insert) return newDelta;\n    if (op.attributes && op.attributes[format]) {\n      return newDelta.push(op);\n    }\n    const formats = value ? { [format]: value } : {};\n    return newDelta.insert(op.insert, { ...formats, ...op.attributes });\n  }, new Delta());\n}\n\nfunction deltaEndsWith(delta: Delta, text: string) {\n  let endText = '';\n  for (\n    let i = delta.ops.length - 1;\n    i >= 0 && endText.length < text.length;\n    --i // eslint-disable-line no-plusplus\n  ) {\n    const 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: Node, scroll: ScrollBlot) {\n  if (!(node instanceof Element)) return false;\n  const match = scroll.query(node);\n  // @ts-expect-error\n  if (match && match.prototype instanceof EmbedBlot) return false;\n\n  return [\n    'address',\n    'article',\n    'blockquote',\n    'canvas',\n    'dd',\n    'div',\n    'dl',\n    'dt',\n    'fieldset',\n    'figcaption',\n    'figure',\n    'footer',\n    'form',\n    'h1',\n    'h2',\n    'h3',\n    'h4',\n    'h5',\n    'h6',\n    'header',\n    'iframe',\n    'li',\n    'main',\n    'nav',\n    'ol',\n    'output',\n    'p',\n    'pre',\n    'section',\n    'table',\n    'td',\n    'tr',\n    'ul',\n    'video',\n  ].includes(node.tagName.toLowerCase());\n}\n\nfunction isBetweenInlineElements(node: HTMLElement, scroll: ScrollBlot) {\n  return (\n    node.previousElementSibling &&\n    node.nextElementSibling &&\n    !isLine(node.previousElementSibling, scroll) &&\n    !isLine(node.nextElementSibling, scroll)\n  );\n}\n\nconst preNodes = new WeakMap();\nfunction isPre(node: Node | null) {\n  if (node == null) return false;\n  if (!preNodes.has(node)) {\n    // @ts-expect-error\n    if (node.tagName === 'PRE') {\n      preNodes.set(node, true);\n    } else {\n      preNodes.set(node, isPre(node.parentNode));\n    }\n  }\n  return preNodes.get(node);\n}\n\nfunction traverse(\n  scroll: ScrollBlot,\n  node: ChildNode,\n  elementMatchers: Matcher[],\n  textMatchers: Matcher[],\n  nodeMatches: WeakMap<Node, Matcher[]>,\n): Delta {\n  // Post-order\n  if (node.nodeType === node.TEXT_NODE) {\n    return textMatchers.reduce((delta: Delta, matcher) => {\n      return matcher(node, delta, scroll);\n    }, new Delta());\n  }\n  if (node.nodeType === node.ELEMENT_NODE) {\n    return Array.from(node.childNodes || []).reduce((delta, childNode) => {\n      let childrenDelta = traverse(\n        scroll,\n        childNode,\n        elementMatchers,\n        textMatchers,\n        nodeMatches,\n      );\n      if (childNode.nodeType === node.ELEMENT_NODE) {\n        childrenDelta = elementMatchers.reduce((reducedDelta, matcher) => {\n          return matcher(childNode as HTMLElement, reducedDelta, scroll);\n        }, childrenDelta);\n        childrenDelta = (nodeMatches.get(childNode) || []).reduce(\n          (reducedDelta, matcher) => {\n            return matcher(childNode, reducedDelta, scroll);\n          },\n          childrenDelta,\n        );\n      }\n      return delta.concat(childrenDelta);\n    }, new Delta());\n  }\n  return new Delta();\n}\n\nfunction createMatchAlias(format: string) {\n  return (_node: Element, delta: Delta, scroll: ScrollBlot) => {\n    return applyFormat(delta, format, true, scroll);\n  };\n}\n\nfunction matchAttributor(node: HTMLElement, delta: Delta, scroll: ScrollBlot) {\n  const attributes = Attributor.keys(node);\n  const classes = ClassAttributor.keys(node);\n  const styles = StyleAttributor.keys(node);\n  const formats: Record<string, string | undefined> = {};\n  attributes\n    .concat(classes)\n    .concat(styles)\n    .forEach((name) => {\n      let attr = scroll.query(name, Scope.ATTRIBUTE) as Attributor;\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\n  return Object.entries(formats).reduce(\n    (newDelta, [name, value]) => applyFormat(newDelta, name, value, scroll),\n    delta,\n  );\n}\n\nfunction matchBlot(node: Node, delta: Delta, scroll: ScrollBlot) {\n  const match = scroll.query(node);\n  if (match == null) return delta;\n  // @ts-expect-error\n  if (match.prototype instanceof EmbedBlot) {\n    const embed = {};\n    // @ts-expect-error\n    const value = match.value(node);\n    if (value != null) {\n      // @ts-expect-error\n      embed[match.blotName] = value;\n      // @ts-expect-error\n      return new Delta().insert(embed, match.formats(node, scroll));\n    }\n  } else {\n    // @ts-expect-error\n    if (match.prototype instanceof BlockBlot && !deltaEndsWith(delta, '\\n')) {\n      delta.insert('\\n');\n    }\n    if (\n      'blotName' in match &&\n      'formats' in match &&\n      typeof match.formats === 'function'\n    ) {\n      return applyFormat(\n        delta,\n        match.blotName,\n        match.formats(node, scroll),\n        scroll,\n      );\n    }\n  }\n  return delta;\n}\n\nfunction matchBreak(node: Node, delta: Delta) {\n  if (!deltaEndsWith(delta, '\\n')) {\n    delta.insert('\\n');\n  }\n  return delta;\n}\n\nfunction matchCodeBlock(node: Node, delta: Delta, scroll: ScrollBlot) {\n  const match = scroll.query('code-block');\n  const language =\n    match && 'formats' in match && typeof match.formats === 'function'\n      ? match.formats(node, scroll)\n      : true;\n  return applyFormat(delta, 'code-block', language, scroll);\n}\n\nfunction matchIgnore() {\n  return new Delta();\n}\n\nfunction matchIndent(node: Node, delta: Delta, scroll: ScrollBlot) {\n  const match = scroll.query(node);\n  if (\n    match == null ||\n    // @ts-expect-error\n    match.blotName !== 'list' ||\n    !deltaEndsWith(delta, '\\n')\n  ) {\n    return delta;\n  }\n  let indent = -1;\n  let parent = node.parentNode;\n  while (parent != null) {\n    // @ts-expect-error\n    if (['OL', 'UL'].includes(parent.tagName)) {\n      indent += 1;\n    }\n    parent = parent.parentNode;\n  }\n  if (indent <= 0) return delta;\n  return delta.reduce((composed, op) => {\n    if (!op.insert) return composed;\n    if (op.attributes && typeof op.attributes.indent === 'number') {\n      return composed.push(op);\n    }\n    return composed.insert(op.insert, { indent, ...(op.attributes || {}) });\n  }, new Delta());\n}\n\nfunction matchList(node: Node, delta: Delta, scroll: ScrollBlot) {\n  const element = node as Element;\n  let list = element.tagName === 'OL' ? 'ordered' : 'bullet';\n\n  const checkedAttr = element.getAttribute('data-checked');\n  if (checkedAttr) {\n    list = checkedAttr === 'true' ? 'checked' : 'unchecked';\n  }\n\n  return applyFormat(delta, 'list', list, scroll);\n}\n\nfunction matchNewline(node: Node, delta: Delta, scroll: ScrollBlot) {\n  if (!deltaEndsWith(delta, '\\n')) {\n    if (\n      isLine(node, scroll) &&\n      (node.childNodes.length > 0 || node instanceof HTMLParagraphElement)\n    ) {\n      return delta.insert('\\n');\n    }\n    if (delta.length() > 0 && node.nextSibling) {\n      let nextSibling: Node | null = node.nextSibling;\n      while (nextSibling != null) {\n        if (isLine(nextSibling, scroll)) {\n          return delta.insert('\\n');\n        }\n        const match = scroll.query(nextSibling);\n        // @ts-expect-error\n        if (match && match.prototype instanceof BlockEmbed) {\n          return delta.insert('\\n');\n        }\n        nextSibling = nextSibling.firstChild;\n      }\n    }\n  }\n  return delta;\n}\n\nfunction matchStyles(node: HTMLElement, delta: Delta, scroll: ScrollBlot) {\n  const formats: Record<string, unknown> = {};\n  const style: Partial<CSSStyleDeclaration> = node.style || {};\n  if (style.fontStyle === 'italic') {\n    formats.italic = true;\n  }\n  if (style.textDecoration === 'underline') {\n    formats.underline = true;\n  }\n  if (style.textDecoration === 'line-through') {\n    formats.strike = true;\n  }\n  if (\n    style.fontWeight?.startsWith('bold') ||\n    // @ts-expect-error Fix me later\n    parseInt(style.fontWeight, 10) >= 700\n  ) {\n    formats.bold = true;\n  }\n  delta = Object.entries(formats).reduce(\n    (newDelta, [name, value]) => applyFormat(newDelta, name, value, scroll),\n    delta,\n  );\n  // @ts-expect-error\n  if (parseFloat(style.textIndent || 0) > 0) {\n    // Could be 0.5in\n    return new Delta().insert('\\t').concat(delta);\n  }\n  return delta;\n}\n\nfunction matchTable(\n  node: HTMLTableRowElement,\n  delta: Delta,\n  scroll: ScrollBlot,\n) {\n  const table =\n    node.parentElement?.tagName === 'TABLE'\n      ? node.parentElement\n      : node.parentElement?.parentElement;\n  if (table != null) {\n    const rows = Array.from(table.querySelectorAll('tr'));\n    const row = rows.indexOf(node) + 1;\n    return applyFormat(delta, 'table', row, scroll);\n  }\n  return delta;\n}\n\nfunction matchText(node: HTMLElement, delta: Delta, scroll: ScrollBlot) {\n  // @ts-expect-error\n  let text = node.data as string;\n  // Word represents empty line with <o:p>&nbsp;</o:p>\n  if (node.parentElement?.tagName === 'O:P') {\n    return delta.insert(text.trim());\n  }\n  if (!isPre(node)) {\n    if (\n      text.trim().length === 0 &&\n      text.includes('\\n') &&\n      !isBetweenInlineElements(node, scroll)\n    ) {\n      return delta;\n    }\n    // convert all non-nbsp whitespace into regular space\n    text = text.replace(/[^\\S\\u00a0]/g, ' ');\n    // collapse consecutive spaces into one\n    text = text.replace(/ {2,}/g, ' ');\n    if (\n      (node.previousSibling == null &&\n        node.parentElement != null &&\n        isLine(node.parentElement, scroll)) ||\n      (node.previousSibling instanceof Element &&\n        isLine(node.previousSibling, scroll))\n    ) {\n      // block structure means we don't need leading space\n      text = text.replace(/^ /, '');\n    }\n    if (\n      (node.nextSibling == null &&\n        node.parentElement != null &&\n        isLine(node.parentElement, scroll)) ||\n      (node.nextSibling instanceof Element && isLine(node.nextSibling, scroll))\n    ) {\n      // block structure means we don't need trailing space\n      text = text.replace(/ $/, '');\n    }\n    // done removing whitespace and can normalize all to regular space\n    text = text.replaceAll('\\u00a0', ' ');\n  }\n  return delta.insert(text);\n}\n\nexport {\n  Clipboard as default,\n  matchAttributor,\n  matchBlot,\n  matchNewline,\n  matchText,\n  traverse,\n};\n","import Delta, { AttributeMap } from 'quill-delta-es';\nimport { EmbedBlot, Scope, TextBlot } from 'parchment';\nimport type { Blot, BlockBlot } from 'parchment';\nimport Quill from '../core/quill.js';\nimport logger from '../core/logger.js';\nimport Module from '../core/module.js';\nimport type { BlockEmbed } from '../blots/block.js';\nimport type { Range } from '../core/selection.js';\nimport isEqual from '../core/utils/isEqual.js';\n\nconst debug = logger('quill:keyboard');\n\nconst SHORTKEY = /Mac/i.test(navigator.platform) ? 'metaKey' : 'ctrlKey';\n\nexport interface Context {\n  collapsed: boolean;\n  empty: boolean;\n  offset: number;\n  prefix: string;\n  suffix: string;\n  format: Record<string, unknown>;\n  event: KeyboardEvent;\n  line: BlockEmbed | BlockBlot;\n}\n\ninterface BindingObject\n  extends Partial<Omit<Context, 'prefix' | 'suffix' | 'format'>> {\n  key: number | string | string[];\n  shortKey?: boolean | null;\n  shiftKey?: boolean | null;\n  altKey?: boolean | null;\n  metaKey?: boolean | null;\n  ctrlKey?: boolean | null;\n  prefix?: RegExp;\n  suffix?: RegExp;\n  format?: Record<string, unknown> | string[];\n  handler?: (\n    this: { quill: Quill },\n    range: Range,\n    curContext: Context,\n    // eslint-disable-next-line no-use-before-define\n    binding: NormalizedBinding,\n  ) => boolean | void;\n}\n\ntype Binding = BindingObject | string | number;\n\ninterface NormalizedBinding extends Omit<BindingObject, 'key' | 'shortKey'> {\n  key: string | number;\n}\n\ninterface KeyboardOptions {\n  bindings: Record<string, Binding>;\n}\n\ninterface KeyboardOptions {\n  bindings: Record<string, Binding>;\n}\n\nclass Keyboard extends Module<KeyboardOptions> {\n  static DEFAULTS: KeyboardOptions;\n\n  static match(evt: KeyboardEvent, binding: BindingObject) {\n    if (\n      (['altKey', 'ctrlKey', 'metaKey', 'shiftKey'] as const).some((key) => {\n        return !!binding[key] !== evt[key] && binding[key] !== null;\n      })\n    ) {\n      return false;\n    }\n    return binding.key === evt.key || binding.key === evt.which;\n  }\n\n  bindings: Record<string, NormalizedBinding[]>;\n\n  constructor(quill: Quill, options: Partial<KeyboardOptions>) {\n    super(quill, options);\n    this.bindings = {};\n    // @ts-expect-error Fix me later\n    Object.keys(this.options.bindings).forEach((name) => {\n      // @ts-expect-error Fix me later\n      if (this.options.bindings[name]) {\n        // @ts-expect-error Fix me later\n        this.addBinding(this.options.bindings[name]);\n      }\n    });\n    this.addBinding({ key: 'Enter', shiftKey: null }, this.handleEnter);\n    this.addBinding(\n      { key: 'Enter', metaKey: null, ctrlKey: null, altKey: null },\n      () => {},\n    );\n    if (/Firefox/i.test(navigator.userAgent)) {\n      // Need to handle delete and backspace for Firefox in the general case #1171\n      this.addBinding(\n        { key: 'Backspace' },\n        { collapsed: true },\n        this.handleBackspace,\n      );\n      this.addBinding(\n        { key: 'Delete' },\n        { collapsed: true },\n        this.handleDelete,\n      );\n    } else {\n      this.addBinding(\n        { key: 'Backspace' },\n        { collapsed: true, prefix: /^.?$/ },\n        this.handleBackspace,\n      );\n      this.addBinding(\n        { key: 'Delete' },\n        { collapsed: true, suffix: /^.?$/ },\n        this.handleDelete,\n      );\n    }\n    this.addBinding(\n      { key: 'Backspace' },\n      { collapsed: false },\n      this.handleDeleteRange,\n    );\n    this.addBinding(\n      { key: 'Delete' },\n      { collapsed: false },\n      this.handleDeleteRange,\n    );\n    this.addBinding(\n      {\n        key: 'Backspace',\n        altKey: null,\n        ctrlKey: null,\n        metaKey: null,\n        shiftKey: null,\n      },\n      { collapsed: true, offset: 0 },\n      this.handleBackspace,\n    );\n    this.listen();\n  }\n\n  addBinding(\n    keyBinding: Binding,\n    context:\n      | Required<BindingObject['handler']>\n      | Partial<Omit<BindingObject, 'key' | 'handler'>> = {},\n    handler:\n      | Required<BindingObject['handler']>\n      | Partial<Omit<BindingObject, 'key' | 'handler'>> = {},\n  ) {\n    const binding = normalize(keyBinding);\n    if (binding == null) {\n      debug.warn('Attempted to add invalid keyboard binding', binding);\n      return;\n    }\n    if (typeof context === 'function') {\n      context = { handler: context };\n    }\n    if (typeof handler === 'function') {\n      handler = { handler };\n    }\n    const keys = Array.isArray(binding.key) ? binding.key : [binding.key];\n    keys.forEach((key) => {\n      const singleBinding = {\n        ...binding,\n        key,\n        ...context,\n        ...handler,\n      };\n      this.bindings[singleBinding.key] = this.bindings[singleBinding.key] || [];\n      this.bindings[singleBinding.key].push(singleBinding);\n    });\n  }\n\n  listen() {\n    this.quill.root.addEventListener('keydown', (evt) => {\n      if (evt.defaultPrevented || evt.isComposing) return;\n\n      // evt.isComposing is false when pressing Enter/Backspace when composing in Safari\n      // https://bugs.webkit.org/show_bug.cgi?id=165004\n      const isComposing =\n        evt.keyCode === 229 && (evt.key === 'Enter' || evt.key === 'Backspace');\n      if (isComposing) return;\n\n      const bindings = (this.bindings[evt.key] || []).concat(\n        this.bindings[evt.which] || [],\n      );\n      const matches = bindings.filter((binding) =>\n        Keyboard.match(evt, binding),\n      );\n      if (matches.length === 0) return;\n      // @ts-expect-error\n      const blot = Quill.find(evt.target, true);\n      if (blot && blot.scroll !== this.quill.scroll) return;\n      const range = this.quill.getSelection();\n      if (range == null || !this.quill.hasFocus()) return;\n      const [line, offset] = this.quill.getLine(range.index);\n      const [leafStart, offsetStart] = this.quill.getLeaf(range.index);\n      const [leafEnd, offsetEnd] =\n        range.length === 0\n          ? [leafStart, offsetStart]\n          : this.quill.getLeaf(range.index + range.length);\n      const prefixText =\n        leafStart instanceof TextBlot\n          ? leafStart.value().slice(0, offsetStart)\n          : '';\n      const suffixText =\n        leafEnd instanceof TextBlot ? leafEnd.value().slice(offsetEnd) : '';\n      const curContext = {\n        collapsed: range.length === 0,\n        // @ts-expect-error Fix me later\n        empty: range.length === 0 && line.length() <= 1,\n        format: this.quill.getFormat(range),\n        line,\n        offset,\n        prefix: prefixText,\n        suffix: suffixText,\n        event: evt,\n      };\n      const prevented = matches.some((binding) => {\n        if (\n          binding.collapsed != null &&\n          binding.collapsed !== curContext.collapsed\n        ) {\n          return false;\n        }\n        if (binding.empty != null && binding.empty !== curContext.empty) {\n          return false;\n        }\n        if (binding.offset != null && binding.offset !== curContext.offset) {\n          return false;\n        }\n        if (Array.isArray(binding.format)) {\n          // any format is present\n          if (binding.format.every((name) => curContext.format[name] == null)) {\n            return false;\n          }\n        } else if (typeof binding.format === 'object') {\n          // all formats must match\n          if (\n            !Object.keys(binding.format).every((name) => {\n              // @ts-expect-error Fix me later\n              if (binding.format[name] === true)\n                return curContext.format[name] != null;\n              // @ts-expect-error Fix me later\n              if (binding.format[name] === false)\n                return curContext.format[name] == null;\n              // @ts-expect-error Fix me later\n              return isEqual(binding.format[name], curContext.format[name]);\n            })\n          ) {\n            return false;\n          }\n        }\n        if (binding.prefix != null && !binding.prefix.test(curContext.prefix)) {\n          return false;\n        }\n        if (binding.suffix != null && !binding.suffix.test(curContext.suffix)) {\n          return false;\n        }\n        // @ts-expect-error Fix me later\n        return binding.handler.call(this, range, curContext, binding) !== true;\n      });\n      if (prevented) {\n        evt.preventDefault();\n      }\n    });\n  }\n\n  handleBackspace(range: Range, context: Context) {\n    // Check for astral symbols\n    const length = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]$/.test(context.prefix)\n      ? 2\n      : 1;\n    if (range.index === 0 || this.quill.getLength() <= 1) return;\n    let formats = {};\n    const [line] = this.quill.getLine(range.index);\n    let delta = new Delta().retain(range.index - length).delete(length);\n    if (context.offset === 0) {\n      // Always deleting newline here, length always 1\n      const [prev] = this.quill.getLine(range.index - 1);\n      if (prev) {\n        const isPrevLineEmpty =\n          prev.statics.blotName === 'block' && prev.length() <= 1;\n        if (!isPrevLineEmpty) {\n          // @ts-expect-error Fix me later\n          const curFormats = line.formats();\n          const prevFormats = this.quill.getFormat(range.index - 1, 1);\n          formats = AttributeMap.diff(curFormats, prevFormats) || {};\n          if (Object.keys(formats).length > 0) {\n            // line.length() - 1 targets \\n in line, another -1 for newline being deleted\n            const formatDelta = new Delta()\n              // @ts-expect-error Fix me later\n              .retain(range.index + line.length() - 2)\n              .retain(1, formats);\n            delta = delta.compose(formatDelta);\n          }\n        }\n      }\n    }\n    this.quill.updateContents(delta, Quill.sources.USER);\n    this.quill.focus();\n  }\n\n  handleDelete(range: Range, context: Context) {\n    // Check for astral symbols\n    const length = /^[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]/.test(context.suffix)\n      ? 2\n      : 1;\n    if (range.index >= this.quill.getLength() - length) return;\n    let formats = {};\n    const [line] = this.quill.getLine(range.index);\n    let delta = new Delta().retain(range.index).delete(length);\n    // @ts-expect-error Fix me later\n    if (context.offset >= line.length() - 1) {\n      const [next] = this.quill.getLine(range.index + 1);\n      if (next) {\n        // @ts-expect-error Fix me later\n        const curFormats = line.formats();\n        const nextFormats = this.quill.getFormat(range.index, 1);\n        formats = AttributeMap.diff(curFormats, nextFormats) || {};\n        if (Object.keys(formats).length > 0) {\n          delta = delta.retain(next.length() - 1).retain(1, formats);\n        }\n      }\n    }\n    this.quill.updateContents(delta, Quill.sources.USER);\n    this.quill.focus();\n  }\n\n  handleDeleteRange(range: Range) {\n    deleteRange({ range, quill: this.quill });\n    this.quill.focus();\n  }\n\n  handleEnter(range: Range, context: Context) {\n    const lineFormats = Object.keys(context.format).reduce(\n      (formats: Record<string, unknown>, format) => {\n        if (\n          this.quill.scroll.query(format, Scope.BLOCK) &&\n          !Array.isArray(context.format[format])\n        ) {\n          formats[format] = context.format[format];\n        }\n        return formats;\n      },\n      {},\n    );\n    const delta = new Delta()\n      .retain(range.index)\n      .delete(range.length)\n      .insert('\\n', lineFormats);\n    this.quill.updateContents(delta, Quill.sources.USER);\n    this.quill.setSelection(range.index + 1, Quill.sources.SILENT);\n    this.quill.focus();\n  }\n}\n\nconst defaultOptions: KeyboardOptions = {\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: 'Tab',\n      format: ['blockquote', 'indent', 'list'],\n      handler(range, context) {\n        if (context.collapsed && context.offset !== 0) return true;\n        this.quill.format('indent', '+1', Quill.sources.USER);\n        return false;\n      },\n    },\n    outdent: {\n      key: 'Tab',\n      shiftKey: true,\n      format: ['blockquote', 'indent', 'list'],\n      // highlight tab or tab at beginning of list, indent or blockquote\n      handler(range, context) {\n        if (context.collapsed && context.offset !== 0) return true;\n        this.quill.format('indent', '-1', Quill.sources.USER);\n        return false;\n      },\n    },\n    'outdent backspace': {\n      key: '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(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: 'Tab',\n      shiftKey: true,\n      collapsed: true,\n      prefix: /\\t$/,\n      handler(range) {\n        this.quill.deleteText(range.index - 1, 1, Quill.sources.USER);\n      },\n    },\n    tab: {\n      key: 'Tab',\n      handler(range, context) {\n        if (context.format.table) return true;\n        this.quill.history.cutoff();\n        const delta = new Delta()\n          .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        return false;\n      },\n    },\n    'blockquote empty enter': {\n      key: 'Enter',\n      collapsed: true,\n      format: ['blockquote'],\n      empty: true,\n      handler() {\n        this.quill.format('blockquote', false, Quill.sources.USER);\n      },\n    },\n    'list empty enter': {\n      key: 'Enter',\n      collapsed: true,\n      format: ['list'],\n      empty: true,\n      handler(range, context) {\n        const formats: Record<string, unknown> = { list: false };\n        if (context.format.indent) {\n          formats.indent = false;\n        }\n        this.quill.formatLine(\n          range.index,\n          range.length,\n          formats,\n          Quill.sources.USER,\n        );\n      },\n    },\n    'checklist enter': {\n      key: 'Enter',\n      collapsed: true,\n      format: { list: 'checked' },\n      handler(range) {\n        const [line, offset] = this.quill.getLine(range.index);\n        const formats = {\n          // @ts-expect-error Fix me later\n          ...line.formats(),\n          list: 'checked',\n        };\n        const delta = new Delta()\n          .retain(range.index)\n          .insert('\\n', formats)\n          // @ts-expect-error Fix me later\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.scrollSelectionIntoView();\n      },\n    },\n    'header enter': {\n      key: 'Enter',\n      collapsed: true,\n      format: ['header'],\n      suffix: /^$/,\n      handler(range, context) {\n        const [line, offset] = this.quill.getLine(range.index);\n        const delta = new Delta()\n          .retain(range.index)\n          .insert('\\n', context.format)\n          // @ts-expect-error Fix me later\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.scrollSelectionIntoView();\n      },\n    },\n    'table backspace': {\n      key: 'Backspace',\n      format: ['table'],\n      collapsed: true,\n      offset: 0,\n      handler() {},\n    },\n    'table delete': {\n      key: 'Delete',\n      format: ['table'],\n      collapsed: true,\n      suffix: /^$/,\n      handler() {},\n    },\n    'table enter': {\n      key: 'Enter',\n      shiftKey: null,\n      format: ['table'],\n      handler(range) {\n        const module = this.quill.getModule('table');\n        if (module) {\n          // @ts-expect-error\n          const [table, row, cell, offset] = module.getTable(range);\n          const shift = tableSide(table, row, cell, offset);\n          if (shift == null) return;\n          let index = table.offset();\n          if (shift < 0) {\n            const delta = new Delta().retain(index).insert('\\n');\n            this.quill.updateContents(delta, Quill.sources.USER);\n            this.quill.setSelection(\n              range.index + 1,\n              range.length,\n              Quill.sources.SILENT,\n            );\n          } else if (shift > 0) {\n            index += table.length();\n            const delta = new Delta().retain(index).insert('\\n');\n            this.quill.updateContents(delta, Quill.sources.USER);\n            this.quill.setSelection(index, Quill.sources.USER);\n          }\n        }\n      },\n    },\n    'table tab': {\n      key: 'Tab',\n      shiftKey: null,\n      format: ['table'],\n      handler(range, context) {\n        const { event, line: cell } = context;\n        const offset = cell.offset(this.quill.scroll);\n        if (event.shiftKey) {\n          this.quill.setSelection(offset - 1, Quill.sources.USER);\n        } else {\n          this.quill.setSelection(offset + cell.length(), Quill.sources.USER);\n        }\n      },\n    },\n    'list autofill': {\n      key: ' ',\n      shiftKey: null,\n      collapsed: true,\n      format: {\n        'code-block': false,\n        blockquote: false,\n        table: false,\n      },\n      prefix: /^\\s*?(\\d+\\.|-|\\*|\\[ ?\\]|\\[x\\])$/,\n      handler(range, context) {\n        if (this.quill.scroll.query('list') == null) return true;\n        const { length } = context.prefix;\n        const [line, offset] = this.quill.getLine(range.index);\n        if (offset > length) return true;\n        let value;\n        switch (context.prefix.trim()) {\n          case '[]':\n          case '[ ]':\n            value = 'unchecked';\n            break;\n          case '[x]':\n            value = 'checked';\n            break;\n          case '-':\n          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        const delta = new Delta()\n          .retain(range.index - offset)\n          .delete(length + 1)\n          // @ts-expect-error Fix me later\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        return false;\n      },\n    },\n    'code exit': {\n      key: 'Enter',\n      collapsed: true,\n      format: ['code-block'],\n      prefix: /^$/,\n      suffix: /^\\s*$/,\n      handler(range) {\n        const [line, offset] = this.quill.getLine(range.index);\n        let numLines = 2;\n        let cur = line;\n        while (\n          cur != null &&\n          cur.length() <= 1 &&\n          cur.formats()['code-block']\n        ) {\n          // @ts-expect-error\n          cur = cur.prev;\n          numLines -= 1;\n          // Requisite prev lines are empty\n          if (numLines <= 0) {\n            const delta = new Delta()\n              // @ts-expect-error Fix me later\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            this.quill.setSelection(range.index - 1, Quill.sources.SILENT);\n            return false;\n          }\n        }\n        return true;\n      },\n    },\n    'embed left': makeEmbedArrowHandler('ArrowLeft', false),\n    'embed left shift': makeEmbedArrowHandler('ArrowLeft', true),\n    'embed right': makeEmbedArrowHandler('ArrowRight', false),\n    'embed right shift': makeEmbedArrowHandler('ArrowRight', true),\n    'table down': makeTableArrowHandler(false),\n    'table up': makeTableArrowHandler(true),\n  },\n};\n\nKeyboard.DEFAULTS = defaultOptions;\n\nfunction makeCodeBlockHandler(indent: boolean): BindingObject {\n  return {\n    key: 'Tab',\n    shiftKey: !indent,\n    format: { 'code-block': true },\n    handler(range, { event }) {\n      const CodeBlock = this.quill.scroll.query('code-block');\n      // @ts-expect-error\n      const { TAB } = CodeBlock;\n      if (range.length === 0 && !event.shiftKey) {\n        this.quill.insertText(range.index, TAB, Quill.sources.USER);\n        this.quill.setSelection(range.index + TAB.length, Quill.sources.SILENT);\n        return;\n      }\n\n      const lines =\n        range.length === 0\n          ? this.quill.getLines(range.index, 1)\n          : this.quill.getLines(range);\n      let { index, length } = range;\n      lines.forEach((line, i) => {\n        if (indent) {\n          line.insertAt(0, TAB);\n          if (i === 0) {\n            index += TAB.length;\n          } else {\n            length += TAB.length;\n          }\n          // @ts-expect-error Fix me later\n        } else if (line.domNode.textContent.startsWith(TAB)) {\n          line.deleteAt(0, TAB.length);\n          if (i === 0) {\n            index -= TAB.length;\n          } else {\n            length -= TAB.length;\n          }\n        }\n      });\n      this.quill.update(Quill.sources.USER);\n      this.quill.setSelection(index, length, Quill.sources.SILENT);\n    },\n  };\n}\n\nfunction makeEmbedArrowHandler(\n  key: string,\n  shiftKey: boolean | null,\n): BindingObject {\n  const where = key === 'ArrowLeft' ? 'prefix' : 'suffix';\n  return {\n    key,\n    shiftKey,\n    altKey: null,\n    [where]: /^$/,\n    handler(range) {\n      let { index } = range;\n      if (key === 'ArrowRight') {\n        index += range.length + 1;\n      }\n      const [leaf] = this.quill.getLeaf(index);\n      if (!(leaf instanceof EmbedBlot)) return true;\n      if (key === 'ArrowLeft') {\n        if (shiftKey) {\n          this.quill.setSelection(\n            range.index - 1,\n            range.length + 1,\n            Quill.sources.USER,\n          );\n        } else {\n          this.quill.setSelection(range.index - 1, Quill.sources.USER);\n        }\n      } else if (shiftKey) {\n        this.quill.setSelection(\n          range.index,\n          range.length + 1,\n          Quill.sources.USER,\n        );\n      } else {\n        this.quill.setSelection(\n          range.index + range.length + 1,\n          Quill.sources.USER,\n        );\n      }\n      return false;\n    },\n  };\n}\n\nfunction makeFormatHandler(format: string): BindingObject {\n  return {\n    key: format[0],\n    shortKey: true,\n    handler(range, context) {\n      this.quill.format(format, !context.format[format], Quill.sources.USER);\n    },\n  };\n}\n\nfunction makeTableArrowHandler(up: boolean): BindingObject {\n  return {\n    key: up ? 'ArrowUp' : 'ArrowDown',\n    collapsed: true,\n    format: ['table'],\n    handler(range, context) {\n      // TODO move to table module\n      const key = up ? 'prev' : 'next';\n      const cell = context.line;\n      const targetRow = cell.parent[key];\n      if (targetRow != null) {\n        if (targetRow.statics.blotName === 'table-row') {\n          // @ts-expect-error\n          let targetCell = targetRow.children.head;\n          let cur = cell;\n          while (cur.prev != null) {\n            // @ts-expect-error\n            cur = cur.prev;\n            targetCell = targetCell.next;\n          }\n          const index =\n            targetCell.offset(this.quill.scroll) +\n            Math.min(context.offset, targetCell.length() - 1);\n          this.quill.setSelection(index, 0, Quill.sources.USER);\n        }\n      } else {\n        // @ts-expect-error\n        const targetLine = cell.table()[key];\n        if (targetLine != null) {\n          if (up) {\n            this.quill.setSelection(\n              targetLine.offset(this.quill.scroll) + targetLine.length() - 1,\n              0,\n              Quill.sources.USER,\n            );\n          } else {\n            this.quill.setSelection(\n              targetLine.offset(this.quill.scroll),\n              0,\n              Quill.sources.USER,\n            );\n          }\n        }\n      }\n      return false;\n    },\n  };\n}\n\nfunction normalize(binding: Binding): BindingObject | null {\n  if (typeof binding === 'string' || typeof binding === 'number') {\n    binding = { key: binding };\n  } else if (typeof binding === 'object') {\n    binding = { ...binding };\n  } else {\n    return null;\n  }\n  if (binding.shortKey) {\n    binding[SHORTKEY] = binding.shortKey;\n    delete binding.shortKey;\n  }\n  return binding;\n}\n\n// TODO: Move into quill.ts or editor.ts\nfunction deleteRange({ quill, range }: { quill: Quill; range: Range }) {\n  const lines = quill.getLines(range);\n  let formats = {};\n  if (lines.length > 1) {\n    const firstFormats = lines[0].formats();\n    const lastFormats = lines[lines.length - 1].formats();\n    formats = AttributeMap.diff(lastFormats, firstFormats) || {};\n  }\n  quill.deleteText(range, Quill.sources.USER);\n  if (Object.keys(formats).length > 0) {\n    quill.formatLine(range.index, 1, formats, Quill.sources.USER);\n  }\n  quill.setSelection(range.index, Quill.sources.SILENT);\n}\n\nfunction tableSide(_table: unknown, row: Blot, cell: Blot, offset: number) {\n  if (row.prev == null && row.next == null) {\n    if (cell.prev == null && cell.next == null) {\n      return offset === 0 ? -1 : 1;\n    }\n    return cell.prev == null ? -1 : 1;\n  }\n  if (row.prev == null) {\n    return -1;\n  }\n  if (row.next == null) {\n    return 1;\n  }\n  return null;\n}\n\nexport { Keyboard as default, SHORTKEY, normalize, deleteRange };\n","var __create = Object.create;\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __getProtoOf = Object.getPrototypeOf;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __commonJS = (cb, mod) => function __require() {\n  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n  // If the importer is in node compatibility mode or this is not an ESM\n  // file that has been converted to a CommonJS file using a Babel-\n  // compatible transform (i.e. \"__esModule\" has not been set), then set\n  // \"default\" to the CommonJS \"module.exports\" for node compatibility.\n  isNodeMode || !mod || !mod.__esModule ? __defProp(target, \"default\", { value: mod, enumerable: true }) : target,\n  mod\n));\n\n// node_modules/.pnpm/fast-diff@1.3.0/node_modules/fast-diff/diff.js\nvar require_diff = __commonJS({\n  \"node_modules/.pnpm/fast-diff@1.3.0/node_modules/fast-diff/diff.js\"(exports, module2) {\n    var DIFF_DELETE = -1;\n    var DIFF_INSERT = 1;\n    var DIFF_EQUAL = 0;\n    function diff_main(text1, text2, cursor_pos, cleanup, _fix_unicode) {\n      if (text1 === text2) {\n        if (text1) {\n          return [[DIFF_EQUAL, text1]];\n        }\n        return [];\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      var commonlength = diff_commonPrefix(text1, text2);\n      var commonprefix = text1.substring(0, commonlength);\n      text1 = text1.substring(commonlength);\n      text2 = text2.substring(commonlength);\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      var diffs = diff_compute_(text1, text2);\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      if (cleanup) {\n        diff_cleanupSemantic(diffs);\n      }\n      return diffs;\n    }\n    function diff_compute_(text1, text2) {\n      var diffs;\n      if (!text1) {\n        return [[DIFF_INSERT, text2]];\n      }\n      if (!text2) {\n        return [[DIFF_DELETE, text1]];\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        diffs = [\n          [DIFF_INSERT, longtext.substring(0, i)],\n          [DIFF_EQUAL, shorttext],\n          [DIFF_INSERT, longtext.substring(i + shorttext.length)]\n        ];\n        if (text1.length > text2.length) {\n          diffs[0][0] = diffs[2][0] = DIFF_DELETE;\n        }\n        return diffs;\n      }\n      if (shorttext.length === 1) {\n        return [\n          [DIFF_DELETE, text1],\n          [DIFF_INSERT, text2]\n        ];\n      }\n      var hm = diff_halfMatch_(text1, text2);\n      if (hm) {\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        var diffs_a = diff_main(text1_a, text2_a);\n        var diffs_b = diff_main(text1_b, text2_b);\n        return diffs_a.concat([[DIFF_EQUAL, mid_common]], diffs_b);\n      }\n      return diff_bisect_(text1, text2);\n    }\n    function diff_bisect_(text1, text2) {\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      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      var front = delta % 2 !== 0;\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        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 (x1 < text1_length && y1 < text2_length && text1.charAt(x1) === text2.charAt(y1)) {\n            x1++;\n            y1++;\n          }\n          v1[k1_offset] = x1;\n          if (x1 > text1_length) {\n            k1end += 2;\n          } else if (y1 > text2_length) {\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              var x2 = text1_length - v2[k2_offset];\n              if (x1 >= x2) {\n                return diff_bisectSplit_(text1, text2, x1, y1);\n              }\n            }\n          }\n        }\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 (x2 < text1_length && y2 < text2_length && text1.charAt(text1_length - x2 - 1) === text2.charAt(text2_length - y2 - 1)) {\n            x2++;\n            y2++;\n          }\n          v2[k2_offset] = x2;\n          if (x2 > text1_length) {\n            k2end += 2;\n          } else if (y2 > text2_length) {\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              x2 = text1_length - x2;\n              if (x1 >= x2) {\n                return diff_bisectSplit_(text1, text2, x1, y1);\n              }\n            }\n          }\n        }\n      }\n      return [\n        [DIFF_DELETE, text1],\n        [DIFF_INSERT, text2]\n      ];\n    }\n    function 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      var diffs = diff_main(text1a, text2a);\n      var diffsb = diff_main(text1b, text2b);\n      return diffs.concat(diffsb);\n    }\n    function diff_commonPrefix(text1, text2) {\n      if (!text1 || !text2 || text1.charAt(0) !== text2.charAt(0)) {\n        return 0;\n      }\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 (text1.substring(pointerstart, pointermid) == text2.substring(pointerstart, pointermid)) {\n          pointermin = pointermid;\n          pointerstart = pointermin;\n        } else {\n          pointermax = pointermid;\n        }\n        pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n      }\n      if (is_surrogate_pair_start(text1.charCodeAt(pointermid - 1))) {\n        pointermid--;\n      }\n      return pointermid;\n    }\n    function diff_commonOverlap_(text1, text2) {\n      var text1_length = text1.length;\n      var text2_length = text2.length;\n      if (text1_length == 0 || text2_length == 0) {\n        return 0;\n      }\n      if (text1_length > text2_length) {\n        text1 = text1.substring(text1_length - text2_length);\n      } else if (text1_length < text2_length) {\n        text2 = text2.substring(0, text1_length);\n      }\n      var text_length = Math.min(text1_length, text2_length);\n      if (text1 == text2) {\n        return text_length;\n      }\n      var best = 0;\n      var length = 1;\n      while (true) {\n        var pattern = text1.substring(text_length - length);\n        var found = text2.indexOf(pattern);\n        if (found == -1) {\n          return best;\n        }\n        length += found;\n        if (found == 0 || text1.substring(text_length - length) == text2.substring(0, length)) {\n          best = length;\n          length++;\n        }\n      }\n    }\n    function diff_commonSuffix(text1, text2) {\n      if (!text1 || !text2 || text1.slice(-1) !== text2.slice(-1)) {\n        return 0;\n      }\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 (text1.substring(text1.length - pointermid, text1.length - pointerend) == text2.substring(text2.length - pointermid, text2.length - pointerend)) {\n          pointermin = pointermid;\n          pointerend = pointermin;\n        } else {\n          pointermax = pointermid;\n        }\n        pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n      }\n      if (is_surrogate_pair_end(text1.charCodeAt(text1.length - pointermid))) {\n        pointermid--;\n      }\n      return pointermid;\n    }\n    function 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;\n      }\n      function diff_halfMatchI_(longtext2, shorttext2, i) {\n        var seed = longtext2.substring(i, i + Math.floor(longtext2.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 = shorttext2.indexOf(seed, j + 1)) !== -1) {\n          var prefixLength = diff_commonPrefix(\n            longtext2.substring(i),\n            shorttext2.substring(j)\n          );\n          var suffixLength = diff_commonSuffix(\n            longtext2.substring(0, i),\n            shorttext2.substring(0, j)\n          );\n          if (best_common.length < suffixLength + prefixLength) {\n            best_common = shorttext2.substring(j - suffixLength, j) + shorttext2.substring(j, j + prefixLength);\n            best_longtext_a = longtext2.substring(0, i - suffixLength);\n            best_longtext_b = longtext2.substring(i + prefixLength);\n            best_shorttext_a = shorttext2.substring(0, j - suffixLength);\n            best_shorttext_b = shorttext2.substring(j + prefixLength);\n          }\n        }\n        if (best_common.length * 2 >= longtext2.length) {\n          return [\n            best_longtext_a,\n            best_longtext_b,\n            best_shorttext_a,\n            best_shorttext_b,\n            best_common\n          ];\n        } else {\n          return null;\n        }\n      }\n      var hm1 = diff_halfMatchI_(\n        longtext,\n        shorttext,\n        Math.ceil(longtext.length / 4)\n      );\n      var hm2 = diff_halfMatchI_(\n        longtext,\n        shorttext,\n        Math.ceil(longtext.length / 2)\n      );\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        hm = hm1[4].length > hm2[4].length ? hm1 : hm2;\n      }\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    function diff_cleanupSemantic(diffs) {\n      var changes = false;\n      var equalities = [];\n      var equalitiesLength = 0;\n      var lastequality = null;\n      var pointer = 0;\n      var length_insertions1 = 0;\n      var length_deletions1 = 0;\n      var length_insertions2 = 0;\n      var length_deletions2 = 0;\n      while (pointer < diffs.length) {\n        if (diffs[pointer][0] == DIFF_EQUAL) {\n          equalities[equalitiesLength++] = pointer;\n          length_insertions1 = length_insertions2;\n          length_deletions1 = length_deletions2;\n          length_insertions2 = 0;\n          length_deletions2 = 0;\n          lastequality = diffs[pointer][1];\n        } else {\n          if (diffs[pointer][0] == DIFF_INSERT) {\n            length_insertions2 += diffs[pointer][1].length;\n          } else {\n            length_deletions2 += diffs[pointer][1].length;\n          }\n          if (lastequality && lastequality.length <= Math.max(length_insertions1, length_deletions1) && lastequality.length <= Math.max(length_insertions2, length_deletions2)) {\n            diffs.splice(equalities[equalitiesLength - 1], 0, [\n              DIFF_DELETE,\n              lastequality\n            ]);\n            diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;\n            equalitiesLength--;\n            equalitiesLength--;\n            pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;\n            length_insertions1 = 0;\n            length_deletions1 = 0;\n            length_insertions2 = 0;\n            length_deletions2 = 0;\n            lastequality = null;\n            changes = true;\n          }\n        }\n        pointer++;\n      }\n      if (changes) {\n        diff_cleanupMerge(diffs);\n      }\n      diff_cleanupSemanticLossless(diffs);\n      pointer = 1;\n      while (pointer < diffs.length) {\n        if (diffs[pointer - 1][0] == DIFF_DELETE && diffs[pointer][0] == DIFF_INSERT) {\n          var deletion = diffs[pointer - 1][1];\n          var insertion = diffs[pointer][1];\n          var overlap_length1 = diff_commonOverlap_(deletion, insertion);\n          var overlap_length2 = diff_commonOverlap_(insertion, deletion);\n          if (overlap_length1 >= overlap_length2) {\n            if (overlap_length1 >= deletion.length / 2 || overlap_length1 >= insertion.length / 2) {\n              diffs.splice(pointer, 0, [\n                DIFF_EQUAL,\n                insertion.substring(0, overlap_length1)\n              ]);\n              diffs[pointer - 1][1] = deletion.substring(\n                0,\n                deletion.length - overlap_length1\n              );\n              diffs[pointer + 1][1] = insertion.substring(overlap_length1);\n              pointer++;\n            }\n          } else {\n            if (overlap_length2 >= deletion.length / 2 || overlap_length2 >= insertion.length / 2) {\n              diffs.splice(pointer, 0, [\n                DIFF_EQUAL,\n                deletion.substring(0, overlap_length2)\n              ]);\n              diffs[pointer - 1][0] = DIFF_INSERT;\n              diffs[pointer - 1][1] = insertion.substring(\n                0,\n                insertion.length - overlap_length2\n              );\n              diffs[pointer + 1][0] = DIFF_DELETE;\n              diffs[pointer + 1][1] = deletion.substring(overlap_length2);\n              pointer++;\n            }\n          }\n          pointer++;\n        }\n        pointer++;\n      }\n    }\n    var nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;\n    var whitespaceRegex_ = /\\s/;\n    var linebreakRegex_ = /[\\r\\n]/;\n    var blanklineEndRegex_ = /\\n\\r?\\n$/;\n    var blanklineStartRegex_ = /^\\r?\\n\\r?\\n/;\n    function diff_cleanupSemanticLossless(diffs) {\n      function diff_cleanupSemanticScore_(one, two) {\n        if (!one || !two) {\n          return 6;\n        }\n        var char1 = one.charAt(one.length - 1);\n        var char2 = two.charAt(0);\n        var nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex_);\n        var nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex_);\n        var whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex_);\n        var whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex_);\n        var lineBreak1 = whitespace1 && char1.match(linebreakRegex_);\n        var lineBreak2 = whitespace2 && char2.match(linebreakRegex_);\n        var blankLine1 = lineBreak1 && one.match(blanklineEndRegex_);\n        var blankLine2 = lineBreak2 && two.match(blanklineStartRegex_);\n        if (blankLine1 || blankLine2) {\n          return 5;\n        } else if (lineBreak1 || lineBreak2) {\n          return 4;\n        } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {\n          return 3;\n        } else if (whitespace1 || whitespace2) {\n          return 2;\n        } else if (nonAlphaNumeric1 || nonAlphaNumeric2) {\n          return 1;\n        }\n        return 0;\n      }\n      var pointer = 1;\n      while (pointer < diffs.length - 1) {\n        if (diffs[pointer - 1][0] == DIFF_EQUAL && diffs[pointer + 1][0] == DIFF_EQUAL) {\n          var equality1 = diffs[pointer - 1][1];\n          var edit = diffs[pointer][1];\n          var equality2 = diffs[pointer + 1][1];\n          var commonOffset = diff_commonSuffix(equality1, edit);\n          if (commonOffset) {\n            var commonString = edit.substring(edit.length - commonOffset);\n            equality1 = equality1.substring(0, equality1.length - commonOffset);\n            edit = commonString + edit.substring(0, edit.length - commonOffset);\n            equality2 = commonString + equality2;\n          }\n          var bestEquality1 = equality1;\n          var bestEdit = edit;\n          var bestEquality2 = equality2;\n          var bestScore = diff_cleanupSemanticScore_(equality1, edit) + diff_cleanupSemanticScore_(edit, equality2);\n          while (edit.charAt(0) === equality2.charAt(0)) {\n            equality1 += edit.charAt(0);\n            edit = edit.substring(1) + equality2.charAt(0);\n            equality2 = equality2.substring(1);\n            var score = diff_cleanupSemanticScore_(equality1, edit) + diff_cleanupSemanticScore_(edit, equality2);\n            if (score >= bestScore) {\n              bestScore = score;\n              bestEquality1 = equality1;\n              bestEdit = edit;\n              bestEquality2 = equality2;\n            }\n          }\n          if (diffs[pointer - 1][1] != bestEquality1) {\n            if (bestEquality1) {\n              diffs[pointer - 1][1] = bestEquality1;\n            } else {\n              diffs.splice(pointer - 1, 1);\n              pointer--;\n            }\n            diffs[pointer][1] = bestEdit;\n            if (bestEquality2) {\n              diffs[pointer + 1][1] = bestEquality2;\n            } else {\n              diffs.splice(pointer + 1, 1);\n              pointer--;\n            }\n          }\n        }\n        pointer++;\n      }\n    }\n    function diff_cleanupMerge(diffs, fix_unicode) {\n      diffs.push([DIFF_EQUAL, \"\"]);\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            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              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(\n                  0,\n                  -1\n                );\n                text_delete = stray + text_delete;\n                text_insert = stray + text_insert;\n                if (!diffs[previous_equality][1]) {\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              diffs.splice(pointer, 1);\n              break;\n            }\n            if (text_delete.length > 0 || text_insert.length > 0) {\n              if (text_delete.length > 0 && text_insert.length > 0) {\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(\n                      0,\n                      commonlength\n                    );\n                  } else {\n                    diffs.splice(0, 0, [\n                      DIFF_EQUAL,\n                      text_insert.substring(0, commonlength)\n                    ]);\n                    pointer++;\n                  }\n                  text_insert = text_insert.substring(commonlength);\n                  text_delete = text_delete.substring(commonlength);\n                }\n                commonlength = diff_commonSuffix(text_insert, text_delete);\n                if (commonlength !== 0) {\n                  diffs[pointer][1] = text_insert.substring(text_insert.length - commonlength) + diffs[pointer][1];\n                  text_insert = text_insert.substring(\n                    0,\n                    text_insert.length - commonlength\n                  );\n                  text_delete = text_delete.substring(\n                    0,\n                    text_delete.length - commonlength\n                  );\n                }\n              }\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(\n                  pointer - n,\n                  n,\n                  [DIFF_DELETE, text_delete],\n                  [DIFF_INSERT, text_insert]\n                );\n                pointer = pointer - n + 2;\n              }\n            }\n            if (pointer !== 0 && diffs[pointer - 1][0] === DIFF_EQUAL) {\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();\n      }\n      var changes = false;\n      pointer = 1;\n      while (pointer < diffs.length - 1) {\n        if (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {\n          if (diffs[pointer][1].substring(\n            diffs[pointer][1].length - diffs[pointer - 1][1].length\n          ) === diffs[pointer - 1][1]) {\n            diffs[pointer][1] = diffs[pointer - 1][1] + diffs[pointer][1].substring(\n              0,\n              diffs[pointer][1].length - diffs[pointer - 1][1].length\n            );\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) == diffs[pointer + 1][1]) {\n            diffs[pointer - 1][1] += diffs[pointer + 1][1];\n            diffs[pointer][1] = diffs[pointer][1].substring(diffs[pointer + 1][1].length) + diffs[pointer + 1][1];\n            diffs.splice(pointer + 1, 1);\n            changes = true;\n          }\n        }\n        pointer++;\n      }\n      if (changes) {\n        diff_cleanupMerge(diffs, fix_unicode);\n      }\n    }\n    function is_surrogate_pair_start(charCode) {\n      return charCode >= 55296 && charCode <= 56319;\n    }\n    function is_surrogate_pair_end(charCode) {\n      return charCode >= 56320 && charCode <= 57343;\n    }\n    function starts_with_pair_end(str) {\n      return is_surrogate_pair_end(str.charCodeAt(0));\n    }\n    function ends_with_pair_start(str) {\n      return is_surrogate_pair_start(str.charCodeAt(str.length - 1));\n    }\n    function 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    function 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    function find_cursor_edit_diff(oldText, newText, cursor_pos) {\n      var oldRange = typeof cursor_pos === \"number\" ? { index: cursor_pos, length: 0 } : cursor_pos.oldRange;\n      var newRange = typeof cursor_pos === \"number\" ? null : cursor_pos.newRange;\n      var oldLength = oldText.length;\n      var newLength = newText.length;\n      if (oldRange.length === 0 && (newRange === null || newRange.length === 0)) {\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          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          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          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      return null;\n    }\n    function diff2(text1, text2, cursor_pos, cleanup) {\n      return diff_main(text1, text2, cursor_pos, cleanup, true);\n    }\n    diff2.INSERT = DIFF_INSERT;\n    diff2.DELETE = DIFF_DELETE;\n    diff2.EQUAL = DIFF_EQUAL;\n    module2.exports = diff2;\n  }\n});\n\n// dist/esm/Delta.js\nvar import_fast_diff = __toESM(require_diff());\n\n// dist/esm/cloneDeep.js\nfunction cloneDeep(obj) {\n  return JSON.parse(JSON.stringify(obj));\n}\nvar cloneDeep_default = cloneDeep;\n\n// dist/esm/deepEqual.js\nfunction deepEqual(obj1, obj2) {\n  if (obj1 === obj2)\n    return true;\n  if (isPrimitive(obj1) || isPrimitive(obj2))\n    return obj1 === obj2;\n  if (Object.keys(obj1).length !== Object.keys(obj2).length)\n    return false;\n  for (let key in obj1) {\n    if (!(key in obj2))\n      return false;\n    if (!deepEqual(obj1[key], obj2[key]))\n      return false;\n  }\n  return true;\n}\nfunction isPrimitive(obj) {\n  return obj !== Object(obj);\n}\nvar deepEqual_default = deepEqual;\n\n// dist/esm/AttributeMap.js\nvar AttributeMap;\n(function(AttributeMap2) {\n  function compose(a = {}, b = {}, keepNull = false) {\n    if (typeof a !== \"object\") {\n      a = {};\n    }\n    if (typeof b !== \"object\") {\n      b = {};\n    }\n    let attributes = cloneDeep_default(b);\n    if (!keepNull) {\n      attributes = Object.keys(attributes).reduce((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] !== void 0 && b[key] === void 0) {\n        attributes[key] = a[key];\n      }\n    }\n    return Object.keys(attributes).length > 0 ? attributes : void 0;\n  }\n  AttributeMap2.compose = compose;\n  function diff2(a = {}, b = {}) {\n    if (typeof a !== \"object\") {\n      a = {};\n    }\n    if (typeof b !== \"object\") {\n      b = {};\n    }\n    const attributes = Object.keys(a).concat(Object.keys(b)).reduce((attrs, key) => {\n      if (!deepEqual_default(a[key], b[key])) {\n        attrs[key] = b[key] === void 0 ? null : b[key];\n      }\n      return attrs;\n    }, {});\n    return Object.keys(attributes).length > 0 ? attributes : void 0;\n  }\n  AttributeMap2.diff = diff2;\n  function invert(attr = {}, base = {}) {\n    attr = attr || {};\n    const baseInverted = Object.keys(base).reduce((memo, key) => {\n      if (base[key] !== attr[key] && attr[key] !== void 0) {\n        memo[key] = base[key];\n      }\n      return memo;\n    }, {});\n    return Object.keys(attr).reduce((memo, key) => {\n      if (attr[key] !== base[key] && base[key] === void 0) {\n        memo[key] = null;\n      }\n      return memo;\n    }, baseInverted);\n  }\n  AttributeMap2.invert = invert;\n  function transform(a, b, priority = false) {\n    if (typeof a !== \"object\") {\n      return b;\n    }\n    if (typeof b !== \"object\") {\n      return void 0;\n    }\n    if (!priority) {\n      return b;\n    }\n    const attributes = Object.keys(b).reduce((attrs, key) => {\n      if (a[key] === void 0) {\n        attrs[key] = b[key];\n      }\n      return attrs;\n    }, {});\n    return Object.keys(attributes).length > 0 ? attributes : void 0;\n  }\n  AttributeMap2.transform = transform;\n})(AttributeMap || (AttributeMap = {}));\nvar AttributeMap_default = AttributeMap;\n\n// dist/esm/Op.js\nvar Op;\n(function(Op2) {\n  function length(op) {\n    if (typeof op.delete === \"number\") {\n      return op.delete;\n    } else if (typeof op.retain === \"number\") {\n      return op.retain;\n    } else if (typeof op.retain === \"object\" && op.retain !== null) {\n      return 1;\n    } else {\n      return typeof op.insert === \"string\" ? op.insert.length : 1;\n    }\n  }\n  Op2.length = length;\n})(Op || (Op = {}));\nvar Op_default = Op;\n\n// dist/esm/OpIterator.js\nvar Iterator = class {\n  ops;\n  index;\n  offset;\n  constructor(ops) {\n    this.ops = ops;\n    this.index = 0;\n    this.offset = 0;\n  }\n  hasNext() {\n    return this.peekLength() < Infinity;\n  }\n  next(length) {\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_default.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 = {};\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.retain === \"object\" && nextOp.retain !== null) {\n          retOp.retain = nextOp.retain;\n        } else if (typeof nextOp.insert === \"string\") {\n          retOp.insert = nextOp.insert.substr(offset, length);\n        } else {\n          retOp.insert = nextOp.insert;\n        }\n        return retOp;\n      }\n    } else {\n      return { retain: Infinity };\n    }\n  }\n  peek() {\n    return this.ops[this.index];\n  }\n  peekLength() {\n    if (this.ops[this.index]) {\n      return Op_default.length(this.ops[this.index]) - this.offset;\n    } else {\n      return Infinity;\n    }\n  }\n  peekType() {\n    const op = this.ops[this.index];\n    if (op) {\n      if (typeof op.delete === \"number\") {\n        return \"delete\";\n      } else if (typeof op.retain === \"number\" || typeof op.retain === \"object\" && op.retain !== null) {\n        return \"retain\";\n      } else {\n        return \"insert\";\n      }\n    }\n    return \"retain\";\n  }\n  rest() {\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\n// dist/esm/Delta.js\nvar NULL_CHARACTER = String.fromCharCode(0);\nvar getEmbedTypeAndData = (a, b) => {\n  if (typeof a !== \"object\" || a === null) {\n    throw new Error(`cannot retain a ${typeof a}`);\n  }\n  if (typeof b !== \"object\" || b === null) {\n    throw new Error(`cannot retain a ${typeof b}`);\n  }\n  const embedType = Object.keys(a)[0];\n  if (!embedType || embedType !== Object.keys(b)[0]) {\n    throw new Error(`embed types not matched: ${embedType} != ${Object.keys(b)[0]}`);\n  }\n  return [embedType, a[embedType], b[embedType]];\n};\nvar Delta = class _Delta {\n  static Op = Op_default;\n  static OpIterator = Iterator;\n  static AttributeMap = AttributeMap_default;\n  static handlers = {};\n  static registerEmbed(embedType, handler) {\n    this.handlers[embedType] = handler;\n  }\n  static unregisterEmbed(embedType) {\n    delete this.handlers[embedType];\n  }\n  static getHandler(embedType) {\n    const handler = this.handlers[embedType];\n    if (!handler) {\n      throw new Error(`no handlers for embed type \"${embedType}\"`);\n    }\n    return handler;\n  }\n  ops;\n  inverted;\n  constructor(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      this.inverted = ops.inverted;\n    } else {\n      this.ops = [];\n    }\n  }\n  insert(arg, attributes) {\n    const newOp = {};\n    if (typeof arg === \"string\" && arg.length === 0) {\n      return this;\n    }\n    newOp.insert = arg;\n    if (attributes != null && typeof attributes === \"object\" && Object.keys(attributes).length > 0) {\n      newOp.attributes = attributes;\n    }\n    return this.push(newOp);\n  }\n  delete(length) {\n    if (length <= 0) {\n      return this;\n    }\n    return this.push({ delete: length });\n  }\n  retain(length, attributes) {\n    if (typeof length === \"number\" && length <= 0) {\n      return this;\n    }\n    const newOp = { retain: length };\n    if (attributes != null && typeof attributes === \"object\" && Object.keys(attributes).length > 0) {\n      newOp.attributes = attributes;\n    }\n    return this.push(newOp);\n  }\n  push(newOp) {\n    let index = this.ops.length;\n    let lastOp = this.ops[index - 1];\n    newOp = cloneDeep_default(newOp);\n    if (typeof lastOp === \"object\") {\n      if (typeof newOp.delete === \"number\" && typeof lastOp.delete === \"number\") {\n        this.ops[index - 1] = { delete: lastOp.delete + newOp.delete };\n        return this;\n      }\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 (deepEqual_default(newOp.attributes, lastOp.attributes)) {\n        if (typeof newOp.insert === \"string\" && typeof lastOp.insert === \"string\") {\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 (typeof newOp.retain === \"number\" && typeof lastOp.retain === \"number\") {\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  chop() {\n    const lastOp = this.ops[this.ops.length - 1];\n    if (lastOp && typeof lastOp.retain === \"number\" && !lastOp.attributes) {\n      this.ops.pop();\n    }\n    return this;\n  }\n  filter(predicate) {\n    return this.ops.filter(predicate);\n  }\n  forEach(predicate) {\n    this.ops.forEach(predicate);\n  }\n  map(predicate) {\n    return this.ops.map(predicate);\n  }\n  partition(predicate) {\n    const passed = [];\n    const failed = [];\n    this.forEach((op) => {\n      const target = predicate(op) ? passed : failed;\n      target.push(op);\n    });\n    return [passed, failed];\n  }\n  reduce(predicate, initialValue) {\n    return this.ops.reduce(predicate, initialValue);\n  }\n  changeLength() {\n    return this.reduce((length, elem) => {\n      if (elem.insert) {\n        return length + Op_default.length(elem);\n      } else if (elem.delete) {\n        return length - elem.delete;\n      }\n      return length;\n    }, 0);\n  }\n  length() {\n    return this.reduce((length, elem) => {\n      return length + Op_default.length(elem);\n    }, 0);\n  }\n  slice(start = 0, end = Infinity) {\n    const ops = [];\n    const iter = new 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_default.length(nextOp);\n    }\n    return new _Delta(ops);\n  }\n  compose(other) {\n    const thisIter = new Iterator(this.ops);\n    const otherIter = new Iterator(other.ops);\n    const ops = [];\n    const firstOther = otherIter.peek();\n    if (firstOther != null && typeof firstOther.retain === \"number\" && firstOther.attributes == null) {\n      let firstLeft = firstOther.retain;\n      while (thisIter.peekType() === \"insert\" && thisIter.peekLength() <= firstLeft) {\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 (otherOp.retain) {\n          const newOp = {};\n          if (typeof thisOp.retain === \"number\") {\n            newOp.retain = typeof otherOp.retain === \"number\" ? length : otherOp.retain;\n          } else {\n            if (typeof otherOp.retain === \"number\") {\n              if (thisOp.retain == null) {\n                newOp.insert = thisOp.insert;\n              } else {\n                newOp.retain = thisOp.retain;\n              }\n            } else {\n              const action = thisOp.retain == null ? \"insert\" : \"retain\";\n              const [embedType, thisData, otherData] = getEmbedTypeAndData(thisOp[action], otherOp.retain);\n              const handler = _Delta.getHandler(embedType);\n              newOp[action] = {\n                [embedType]: handler.compose(thisData, otherData, action === \"retain\")\n              };\n            }\n          }\n          const attributes = AttributeMap_default.compose(thisOp.attributes, otherOp.attributes, typeof thisOp.retain === \"number\");\n          if (attributes) {\n            newOp.attributes = attributes;\n          }\n          delta.push(newOp);\n          if (!otherIter.hasNext() && deepEqual_default(delta.ops[delta.ops.length - 1], newOp)) {\n            const rest = new _Delta(thisIter.rest());\n            return delta.concat(rest).chop();\n          }\n        } else if (typeof otherOp.delete === \"number\" && (typeof thisOp.retain === \"number\" || typeof thisOp.retain === \"object\" && thisOp.retain !== null)) {\n          delta.push(otherOp);\n        }\n      }\n    }\n    return delta.chop();\n  }\n  concat(other) {\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  diff(other, cursor) {\n    if (this.ops === other.ops) {\n      return new _Delta();\n    }\n    const strings = [this, other].map((delta) => {\n      return delta.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      }).join(\"\");\n    });\n    const retDelta = new _Delta();\n    const diffResult = (0, import_fast_diff.default)(strings[0], strings[1], cursor, true);\n    const thisIter = new Iterator(this.ops);\n    const otherIter = new Iterator(other.ops);\n    diffResult.forEach((component) => {\n      let length = component[1].length;\n      while (length > 0) {\n        let opLength = 0;\n        switch (component[0]) {\n          case import_fast_diff.default.INSERT:\n            opLength = Math.min(otherIter.peekLength(), length);\n            retDelta.push(otherIter.next(opLength));\n            break;\n          case import_fast_diff.default.DELETE:\n            opLength = Math.min(length, thisIter.peekLength());\n            thisIter.next(opLength);\n            retDelta.delete(opLength);\n            break;\n          case import_fast_diff.default.EQUAL:\n            opLength = Math.min(thisIter.peekLength(), otherIter.peekLength(), length);\n            const thisOp = thisIter.next(opLength);\n            const otherOp = otherIter.next(opLength);\n            if (deepEqual_default(thisOp.insert, otherOp.insert)) {\n              retDelta.retain(opLength, AttributeMap_default.diff(thisOp.attributes, otherOp.attributes));\n            } else {\n              retDelta.push(otherOp).delete(opLength);\n            }\n            break;\n        }\n        length -= opLength;\n      }\n    });\n    return retDelta.chop();\n  }\n  eachLine(predicate, newline = \"\\n\") {\n    const iter = new 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_default.length(thisOp) - iter.peekLength();\n      const index = typeof thisOp.insert === \"string\" ? thisOp.insert.indexOf(newline, start) - start : -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  invert(base) {\n    const inverted = new _Delta();\n    this.reduce((baseIndex, op) => {\n      if (op.insert) {\n        inverted.delete(Op_default.length(op));\n      } else if (typeof op.retain === \"number\" && op.attributes == null) {\n        inverted.retain(op.retain);\n        return baseIndex + op.retain;\n      } else if (op.delete || typeof op.retain === \"number\") {\n        const length = op.delete || op.retain;\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(Op_default.length(baseOp), AttributeMap_default.invert(op.attributes, baseOp.attributes));\n          }\n        });\n        return baseIndex + length;\n      } else if (typeof op.retain === \"object\" && op.retain !== null) {\n        const slice = base.slice(baseIndex, baseIndex + 1);\n        const baseOp = new Iterator(slice.ops).next();\n        const [embedType, opData, baseOpData] = getEmbedTypeAndData(op.retain, baseOp.insert);\n        const handler = _Delta.getHandler(embedType);\n        inverted.retain({ [embedType]: handler.invert(opData, baseOpData) }, AttributeMap_default.invert(op.attributes, baseOp.attributes));\n        return baseIndex + 1;\n      }\n      return baseIndex;\n    }, 0);\n    return inverted.chop();\n  }\n  transform(arg, priority = false) {\n    priority = !!priority;\n    if (typeof arg === \"number\") {\n      return this.transformPosition(arg, priority);\n    }\n    const other = arg;\n    const thisIter = new Iterator(this.ops);\n    const otherIter = new Iterator(other.ops);\n    const delta = new _Delta();\n    while (thisIter.hasNext() || otherIter.hasNext()) {\n      if (thisIter.peekType() === \"insert\" && (priority || otherIter.peekType() !== \"insert\")) {\n        delta.retain(Op_default.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          continue;\n        } else if (otherOp.delete) {\n          delta.push(otherOp);\n        } else {\n          const thisData = thisOp.retain;\n          const otherData = otherOp.retain;\n          let transformedData = typeof otherData === \"object\" && otherData !== null ? otherData : length;\n          if (typeof thisData === \"object\" && thisData !== null && typeof otherData === \"object\" && otherData !== null) {\n            const embedType = Object.keys(thisData)[0];\n            if (embedType === Object.keys(otherData)[0]) {\n              const handler = _Delta.getHandler(embedType);\n              if (handler) {\n                transformedData = {\n                  [embedType]: handler.transform(thisData[embedType], otherData[embedType], priority)\n                };\n              }\n            }\n          }\n          delta.retain(transformedData, AttributeMap_default.transform(thisOp.attributes, otherOp.attributes, priority));\n        }\n      }\n    }\n    return delta.chop();\n  }\n  transformPosition(index, priority = false) {\n    priority = !!priority;\n    const thisIter = new 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};\nvar Delta_default = Delta;\nif (typeof module === \"object\") {\n  module.exports = Delta;\n  module.exports.default = Delta;\n}\nexport {\n  AttributeMap_default as AttributeMap,\n  Op_default as Op,\n  Iterator as OpIterator,\n  Delta_default as default\n};\n//# sourceMappingURL=index.mjs.map\n","enum Scope {\n  TYPE = (1 << 2) - 1, // 0011 Lower two bits\n  LEVEL = ((1 << 2) - 1) << 2, // 1100 Higher two bits\n\n  ATTRIBUTE = (1 << 0) | LEVEL, // 1101\n  BLOT = (1 << 1) | LEVEL, // 1110\n  INLINE = (1 << 2) | TYPE, // 0111\n  BLOCK = (1 << 3) | TYPE, // 1011\n\n  BLOCK_BLOT = BLOCK & BLOT, // 1010\n  INLINE_BLOT = INLINE & BLOT, // 0110\n  BLOCK_ATTRIBUTE = BLOCK & ATTRIBUTE, // 1001\n  INLINE_ATTRIBUTE = INLINE & ATTRIBUTE, // 0101\n\n  ANY = TYPE | LEVEL,\n}\n\nexport default Scope;\n","import Scope from '../scope.js';\n\nexport interface AttributorOptions {\n  scope?: Scope;\n  whitelist?: string[];\n}\n\nexport default class Attributor {\n  public static keys(node: HTMLElement): string[] {\n    return Array.from(node.attributes).map((item: Attr) => item.name);\n  }\n\n  public scope: Scope;\n  public whitelist: string[] | undefined;\n\n  constructor(\n    public readonly attrName: string,\n    public readonly keyName: string,\n    options: AttributorOptions = {},\n  ) {\n    const attributeBit = Scope.TYPE & Scope.ATTRIBUTE;\n    this.scope =\n      options.scope != null\n        ? // Ignore type bits, force attribute bit\n          (options.scope & Scope.LEVEL) | attributeBit\n        : Scope.ATTRIBUTE;\n    if (options.whitelist != null) {\n      this.whitelist = options.whitelist;\n    }\n  }\n\n  public add(node: HTMLElement, value: any): boolean {\n    if (!this.canAdd(node, value)) {\n      return false;\n    }\n    node.setAttribute(this.keyName, value);\n    return true;\n  }\n\n  public canAdd(_node: HTMLElement, value: any): boolean {\n    if (this.whitelist == null) {\n      return true;\n    }\n    if (typeof value === 'string') {\n      return this.whitelist.indexOf(value.replace(/[\"']/g, '')) > -1;\n    } else {\n      return this.whitelist.indexOf(value) > -1;\n    }\n  }\n\n  public remove(node: HTMLElement): void {\n    node.removeAttribute(this.keyName);\n  }\n\n  public value(node: HTMLElement): any {\n    const value = node.getAttribute(this.keyName);\n    if (this.canAdd(node, value) && value) {\n      return value;\n    }\n    return '';\n  }\n}\n","export default class ParchmentError extends Error {\n  public message: string;\n  public name: string;\n  public stack!: string;\n\n  constructor(message: string) {\n    message = '[Parchment] ' + message;\n    super(message);\n    this.message = message;\n    this.name = this.constructor.name;\n  }\n}\n","import Attributor from './attributor/attributor.js';\nimport {\n  type Blot,\n  type BlotConstructor,\n  type Root,\n} from './blot/abstract/blot.js';\nimport ParchmentError from './error.js';\nimport Scope from './scope.js';\n\nexport type RegistryDefinition = Attributor | BlotConstructor;\n\nexport interface RegistryInterface {\n  create(scroll: Root, input: Node | string | Scope, value?: any): Blot;\n  query(query: string | Node | Scope, scope: Scope): RegistryDefinition | null;\n  register(...definitions: any[]): any;\n}\n\nexport default class Registry implements RegistryInterface {\n  public static blots = new WeakMap<Node, Blot>();\n\n  public static find(node?: Node | null, bubble = false): Blot | null {\n    if (node == null) {\n      return null;\n    }\n    if (this.blots.has(node)) {\n      return this.blots.get(node) || null;\n    }\n    if (bubble) {\n      let parentNode: Node | null = null;\n      try {\n        parentNode = node.parentNode;\n      } catch (err) {\n        // Probably hit a permission denied error.\n        // A known case is in Firefox, event targets can be anonymous DIVs\n        // inside an input element.\n        // https://bugzilla.mozilla.org/show_bug.cgi?id=208427\n        return null;\n      }\n      return this.find(parentNode, bubble);\n    }\n    return null;\n  }\n\n  private attributes: { [key: string]: Attributor } = {};\n  private classes: { [key: string]: BlotConstructor } = {};\n  private tags: { [key: string]: BlotConstructor } = {};\n  private types: { [key: string]: RegistryDefinition } = {};\n\n  public create(scroll: Root, input: Node | string | Scope, value?: any): Blot {\n    const match = this.query(input);\n    if (match == null) {\n      throw new ParchmentError(`Unable to create ${input} blot`);\n    }\n    const blotClass = match as BlotConstructor;\n    const node =\n      // @ts-expect-error Fix me later\n      input instanceof Node || input.nodeType === Node.TEXT_NODE\n        ? input\n        : blotClass.create(value);\n\n    const blot = new blotClass(scroll, node as Node, value);\n    Registry.blots.set(blot.domNode, blot);\n    return blot;\n  }\n\n  public find(node: Node | null, bubble = false): Blot | null {\n    return Registry.find(node, bubble);\n  }\n\n  public query(\n    query: string | Node | Scope,\n    scope: Scope = Scope.ANY,\n  ): RegistryDefinition | null {\n    let match;\n    if (typeof query === 'string') {\n      match = this.types[query] || this.attributes[query];\n      // @ts-expect-error Fix me later\n    } else if (query instanceof Text || query.nodeType === Node.TEXT_NODE) {\n      match = this.types.text;\n    } else if (typeof query === 'number') {\n      if (query & Scope.LEVEL & Scope.BLOCK) {\n        match = this.types.block;\n      } else if (query & Scope.LEVEL & Scope.INLINE) {\n        match = this.types.inline;\n      }\n    } else if (query instanceof Element) {\n      const names = (query.getAttribute('class') || '').split(/\\s+/);\n      names.some((name) => {\n        match = this.classes[name];\n        if (match) {\n          return true;\n        }\n        return false;\n      });\n      match = match || this.tags[query.tagName];\n    }\n    if (match == null) {\n      return null;\n    }\n    if (\n      'scope' in match &&\n      scope & Scope.LEVEL & match.scope &&\n      scope & Scope.TYPE & match.scope\n    ) {\n      return match;\n    }\n    return null;\n  }\n\n  public register(...definitions: RegistryDefinition[]): RegistryDefinition[] {\n    return definitions.map((definition) => {\n      const isBlot = 'blotName' in definition;\n      const isAttr = 'attrName' in definition;\n      if (!isBlot && !isAttr) {\n        throw new ParchmentError('Invalid definition');\n      } else if (isBlot && definition.blotName === 'abstract') {\n        throw new ParchmentError('Cannot register abstract class');\n      }\n      const key = isBlot\n        ? definition.blotName\n        : isAttr\n          ? definition.attrName\n          : (undefined as never); // already handled by above checks\n      this.types[key] = definition;\n\n      if (isAttr) {\n        if (typeof definition.keyName === 'string') {\n          this.attributes[definition.keyName] = definition;\n        }\n      } else if (isBlot) {\n        if (definition.className) {\n          this.classes[definition.className] = definition;\n        }\n        if (definition.tagName) {\n          if (Array.isArray(definition.tagName)) {\n            definition.tagName = definition.tagName.map((tagName: string) => {\n              return tagName.toUpperCase();\n            });\n          } else {\n            definition.tagName = definition.tagName.toUpperCase();\n          }\n          const tagNames = Array.isArray(definition.tagName)\n            ? definition.tagName\n            : [definition.tagName];\n          tagNames.forEach((tag: string) => {\n            if (this.tags[tag] == null || definition.className == null) {\n              this.tags[tag] = definition;\n            }\n          });\n        }\n      }\n      return definition;\n    });\n  }\n}\n","import Attributor from './attributor.js';\n\nfunction match(node: HTMLElement, prefix: string): string[] {\n  const className = node.getAttribute('class') || '';\n  return className\n    .split(/\\s+/)\n    .filter((name) => name.indexOf(`${prefix}-`) === 0);\n}\n\nclass ClassAttributor extends Attributor {\n  public static keys(node: HTMLElement): string[] {\n    return (node.getAttribute('class') || '')\n      .split(/\\s+/)\n      .map((name) => name.split('-').slice(0, -1).join('-'));\n  }\n\n  public add(node: HTMLElement, value: any): boolean {\n    if (!this.canAdd(node, value)) {\n      return false;\n    }\n    this.remove(node);\n    node.classList.add(`${this.keyName}-${value}`);\n    return true;\n  }\n\n  public remove(node: HTMLElement): void {\n    const matches = match(node, this.keyName);\n    matches.forEach((name) => {\n      node.classList.remove(name);\n    });\n    if (node.classList.length === 0) {\n      node.removeAttribute('class');\n    }\n  }\n\n  public value(node: HTMLElement): any {\n    const result = match(node, this.keyName)[0] || '';\n    const value = result.slice(this.keyName.length + 1); // +1 for hyphen\n    return this.canAdd(node, value) ? value : '';\n  }\n}\n\nexport default ClassAttributor;\n","import Attributor from './attributor.js';\n\nfunction camelize(name: string): string {\n  const parts = name.split('-');\n  const rest = parts\n    .slice(1)\n    .map((part: string) => part[0].toUpperCase() + part.slice(1))\n    .join('');\n  return parts[0] + rest;\n}\n\nclass StyleAttributor extends Attributor {\n  public static keys(node: HTMLElement): string[] {\n    return (node.getAttribute('style') || '').split(';').map((value) => {\n      const arr = value.split(':');\n      return arr[0].trim();\n    });\n  }\n\n  public add(node: HTMLElement, value: any): boolean {\n    if (!this.canAdd(node, value)) {\n      return false;\n    }\n    // @ts-expect-error Fix me later\n    node.style[camelize(this.keyName)] = value;\n    return true;\n  }\n\n  public remove(node: HTMLElement): void {\n    // @ts-expect-error Fix me later\n    node.style[camelize(this.keyName)] = '';\n    if (!node.getAttribute('style')) {\n      node.removeAttribute('style');\n    }\n  }\n\n  public value(node: HTMLElement): any {\n    // @ts-expect-error Fix me later\n    const value = node.style[camelize(this.keyName)];\n    return this.canAdd(node, value) ? value : '';\n  }\n}\n\nexport default StyleAttributor;\n","import type { Formattable } from '../blot/abstract/blot.js';\nimport Registry from '../registry.js';\nimport Scope from '../scope.js';\nimport Attributor from './attributor.js';\nimport ClassAttributor from './class.js';\nimport StyleAttributor from './style.js';\n\nclass AttributorStore {\n  private attributes: { [key: string]: Attributor } = {};\n  private domNode: HTMLElement;\n\n  constructor(domNode: HTMLElement) {\n    this.domNode = domNode;\n    this.build();\n  }\n\n  public attribute(attribute: Attributor, value: any): void {\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        } else {\n          delete this.attributes[attribute.attrName];\n        }\n      }\n    } else {\n      attribute.remove(this.domNode);\n      delete this.attributes[attribute.attrName];\n    }\n  }\n\n  public build(): void {\n    this.attributes = {};\n    const blot = Registry.find(this.domNode);\n    if (blot == null) {\n      return;\n    }\n    const attributes = Attributor.keys(this.domNode);\n    const classes = ClassAttributor.keys(this.domNode);\n    const styles = StyleAttributor.keys(this.domNode);\n    attributes\n      .concat(classes)\n      .concat(styles)\n      .forEach((name) => {\n        const attr = blot.scroll.query(name, Scope.ATTRIBUTE);\n        if (attr instanceof Attributor) {\n          this.attributes[attr.attrName] = attr;\n        }\n      });\n  }\n\n  public copy(target: Formattable): void {\n    Object.keys(this.attributes).forEach((key) => {\n      const value = this.attributes[key].value(this.domNode);\n      target.format(key, value);\n    });\n  }\n\n  public move(target: Formattable): void {\n    this.copy(target);\n    Object.keys(this.attributes).forEach((key) => {\n      this.attributes[key].remove(this.domNode);\n    });\n    this.attributes = {};\n  }\n\n  public values(): { [key: string]: any } {\n    return Object.keys(this.attributes).reduce(\n      (attributes: { [key: string]: any }, name: string) => {\n        attributes[name] = this.attributes[name].value(this.domNode);\n        return attributes;\n      },\n      {},\n    );\n  }\n}\n\nexport default AttributorStore;\n","import ParchmentError from '../../error.js';\nimport Registry from '../../registry.js';\nimport Scope from '../../scope.js';\nimport type {\n  Blot,\n  BlotConstructor,\n  Formattable,\n  Parent,\n  Root,\n} from './blot.js';\n\nclass ShadowBlot implements Blot {\n  public static blotName = 'abstract';\n  public static className: string;\n  public static requiredContainer: BlotConstructor;\n  public static scope: Scope;\n  public static tagName: string | string[];\n\n  public static create(rawValue?: unknown): Node {\n    if (this.tagName == null) {\n      throw new ParchmentError('Blot definition missing tagName');\n    }\n    let node: HTMLElement;\n    let value: string | number | undefined;\n    if (Array.isArray(this.tagName)) {\n      if (typeof rawValue === 'string') {\n        value = rawValue.toUpperCase();\n        if (parseInt(value, 10).toString() === value) {\n          value = parseInt(value, 10);\n        }\n      } else if (typeof rawValue === 'number') {\n        value = rawValue;\n      }\n      if (typeof value === 'number') {\n        node = document.createElement(this.tagName[value - 1]);\n      } else if (value && this.tagName.indexOf(value) > -1) {\n        node = document.createElement(value);\n      } else {\n        node = document.createElement(this.tagName[0]);\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\n  public prev: Blot | null;\n  public next: Blot | null;\n  // @ts-expect-error Fix me later\n  public parent: Parent;\n\n  // Hack for accessing inherited static methods\n  get statics(): any {\n    return this.constructor;\n  }\n  constructor(\n    public scroll: Root,\n    public domNode: Node,\n  ) {\n    Registry.blots.set(domNode, this);\n    this.prev = null;\n    this.next = null;\n  }\n\n  public attach(): void {\n    // Nothing to do\n  }\n\n  public clone(): Blot {\n    const domNode = this.domNode.cloneNode(false);\n    return this.scroll.create(domNode);\n  }\n\n  public detach(): void {\n    if (this.parent != null) {\n      this.parent.removeChild(this);\n    }\n    Registry.blots.delete(this.domNode);\n  }\n\n  public deleteAt(index: number, length: number): void {\n    const blot = this.isolate(index, length);\n    blot.remove();\n  }\n\n  public formatAt(\n    index: number,\n    length: number,\n    name: string,\n    value: any,\n  ): void {\n    const blot = this.isolate(index, length);\n    if (this.scroll.query(name, Scope.BLOT) != null && value) {\n      blot.wrap(name, value);\n    } else if (this.scroll.query(name, Scope.ATTRIBUTE) != null) {\n      const parent = this.scroll.create(this.statics.scope) as Parent &\n        Formattable;\n      blot.wrap(parent);\n      parent.format(name, value);\n    }\n  }\n\n  public insertAt(index: number, value: string, def?: any): void {\n    const blot =\n      def == null\n        ? this.scroll.create('text', value)\n        : this.scroll.create(value, def);\n    const ref = this.split(index);\n    this.parent.insertBefore(blot, ref || undefined);\n  }\n\n  public isolate(index: number, length: number): Blot {\n    const target = this.split(index);\n    if (target == null) {\n      throw new Error('Attempt to isolate at end');\n    }\n    target.split(length);\n    return target;\n  }\n\n  public length(): number {\n    return 1;\n  }\n\n  public offset(root: Blot = this.parent): number {\n    if (this.parent == null || this === root) {\n      return 0;\n    }\n    return this.parent.children.offset(this) + this.parent.offset(root);\n  }\n\n  public optimize(_context?: { [key: string]: any }): void {\n    if (\n      this.statics.requiredContainer &&\n      !(this.parent instanceof this.statics.requiredContainer)\n    ) {\n      this.wrap(this.statics.requiredContainer.blotName);\n    }\n  }\n\n  public remove(): void {\n    if (this.domNode.parentNode != null) {\n      this.domNode.parentNode.removeChild(this.domNode);\n    }\n    this.detach();\n  }\n\n  public replaceWith(name: string | Blot, value?: any): Blot {\n    const replacement =\n      typeof name === 'string' ? this.scroll.create(name, value) : name;\n    if (this.parent != null) {\n      this.parent.insertBefore(replacement, this.next || undefined);\n      this.remove();\n    }\n    return replacement;\n  }\n\n  public split(index: number, _force?: boolean): Blot | null {\n    return index === 0 ? this : this.next;\n  }\n\n  public update(\n    _mutations: MutationRecord[],\n    _context: { [key: string]: any },\n  ): void {\n    // Nothing to do by default\n  }\n\n  public wrap(name: string | Parent, value?: any): Parent {\n    const wrapper =\n      typeof name === 'string'\n        ? (this.scroll.create(name, value) as Parent)\n        : name;\n    if (this.parent != null) {\n      this.parent.insertBefore(wrapper, this.next || undefined);\n    }\n    if (typeof wrapper.appendChild !== 'function') {\n      throw new ParchmentError(`Cannot wrap ${name}`);\n    }\n    wrapper.appendChild(this);\n    return wrapper;\n  }\n}\n\nexport default ShadowBlot;\n","import Scope from '../../scope.js';\nimport type { Leaf } from './blot.js';\nimport ShadowBlot from './shadow.js';\n\nclass LeafBlot extends ShadowBlot implements Leaf {\n  public static scope = Scope.INLINE_BLOT;\n\n  /**\n   * Returns the value represented by domNode if it is this Blot's type\n   * No checking that domNode can represent this Blot type is required so\n   * applications needing it should check externally before calling.\n   */\n  public static value(_domNode: Node): any {\n    return true;\n  }\n\n  /**\n   * Given location represented by node and offset from DOM Selection Range,\n   * return index to that location.\n   */\n  public index(node: Node, offset: number): number {\n    if (\n      this.domNode === node ||\n      this.domNode.compareDocumentPosition(node) &\n        Node.DOCUMENT_POSITION_CONTAINED_BY\n    ) {\n      return Math.min(offset, 1);\n    }\n    return -1;\n  }\n\n  /**\n   * Given index to location within blot, return node and offset representing\n   * that location, consumable by DOM Selection Range\n   */\n  public position(index: number, _inclusive?: boolean): [Node, number] {\n    const childNodes: Node[] = Array.from(this.parent.domNode.childNodes);\n    let offset = childNodes.indexOf(this.domNode);\n    if (index > 0) {\n      offset += 1;\n    }\n    return [this.parent.domNode, offset];\n  }\n\n  /**\n   * Return value represented by this blot\n   * Should not change without interaction from API or\n   * user change detectable by update()\n   */\n  public value(): any {\n    return {\n      [this.statics.blotName]: this.statics.value(this.domNode) || true,\n    };\n  }\n}\n\nexport default LeafBlot;\n","import type LinkedNode from './linked-node.js';\n\nclass LinkedList<T extends LinkedNode> {\n  public head: T | null;\n  public tail: T | null;\n  public length: number;\n\n  constructor() {\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  public append(...nodes: T[]): void {\n    this.insertBefore(nodes[0], null);\n    if (nodes.length > 1) {\n      const rest = nodes.slice(1);\n      this.append(...rest);\n    }\n  }\n\n  public at(index: number): T | null {\n    const next = this.iterator();\n    let cur = next();\n    while (cur && index > 0) {\n      index -= 1;\n      cur = next();\n    }\n    return cur;\n  }\n\n  public contains(node: T): boolean {\n    const next = this.iterator();\n    let cur = next();\n    while (cur) {\n      if (cur === node) {\n        return true;\n      }\n      cur = next();\n    }\n    return false;\n  }\n\n  public indexOf(node: T): number {\n    const next = this.iterator();\n    let cur = next();\n    let index = 0;\n    while (cur) {\n      if (cur === node) {\n        return index;\n      }\n      index += 1;\n      cur = next();\n    }\n    return -1;\n  }\n\n  public insertBefore(node: T | null, refNode: T | null): void {\n    if (node == null) {\n      return;\n    }\n    this.remove(node);\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    } else if (this.tail != null) {\n      this.tail.next = node;\n      node.prev = this.tail;\n      this.tail = node;\n    } else {\n      node.prev = null;\n      this.head = this.tail = node;\n    }\n    this.length += 1;\n  }\n\n  public offset(target: T): number {\n    let index = 0;\n    let cur = this.head;\n    while (cur != null) {\n      if (cur === target) {\n        return index;\n      }\n      index += cur.length();\n      cur = cur.next as T;\n    }\n    return -1;\n  }\n\n  public remove(node: T): void {\n    if (!this.contains(node)) {\n      return;\n    }\n    if (node.prev != null) {\n      node.prev.next = node.next;\n    }\n    if (node.next != null) {\n      node.next.prev = node.prev;\n    }\n    if (node === this.head) {\n      this.head = node.next as T;\n    }\n    if (node === this.tail) {\n      this.tail = node.prev as T;\n    }\n    this.length -= 1;\n  }\n\n  public iterator(curNode: T | null = this.head): () => T | null {\n    // TODO use yield when we can\n    return (): T | null => {\n      const ret = curNode;\n      if (curNode != null) {\n        curNode = curNode.next as T;\n      }\n      return ret;\n    };\n  }\n\n  public find(index: number, inclusive = false): [T | null, number] {\n    const next = this.iterator();\n    let cur = next();\n    while (cur) {\n      const length = cur.length();\n      if (\n        index < length ||\n        (inclusive &&\n          index === length &&\n          (cur.next == null || cur.next.length() !== 0))\n      ) {\n        return [cur, index];\n      }\n      index -= length;\n      cur = next();\n    }\n    return [null, 0];\n  }\n\n  public forEach(callback: (cur: T) => void): void {\n    const next = this.iterator();\n    let cur = next();\n    while (cur) {\n      callback(cur);\n      cur = next();\n    }\n  }\n\n  public forEachAt(\n    index: number,\n    length: number,\n    callback: (cur: T, offset: number, length: number) => void,\n  ): void {\n    if (length <= 0) {\n      return;\n    }\n    const [startNode, offset] = this.find(index);\n    let curIndex = index - offset;\n    const next = this.iterator(startNode);\n    let cur = next();\n    while (cur && curIndex < index + length) {\n      const curLength = cur.length();\n      if (index > curIndex) {\n        callback(\n          cur,\n          index - curIndex,\n          Math.min(length, curIndex + curLength - index),\n        );\n      } else {\n        callback(cur, 0, Math.min(curLength, index + length - curIndex));\n      }\n      curIndex += curLength;\n      cur = next();\n    }\n  }\n\n  public map(callback: (cur: T) => any): any[] {\n    return this.reduce((memo: T[], cur: T) => {\n      memo.push(callback(cur));\n      return memo;\n    }, []);\n  }\n\n  public reduce<M>(callback: (memo: M, cur: T) => M, memo: M): M {\n    const next = this.iterator();\n    let cur = next();\n    while (cur) {\n      memo = callback(memo, cur);\n      cur = next();\n    }\n    return memo;\n  }\n}\n\nexport default LinkedList;\n","import LinkedList from '../../collection/linked-list.js';\nimport ParchmentError from '../../error.js';\nimport Scope from '../../scope.js';\nimport type { Blot, BlotConstructor, Parent, Root } from './blot.js';\nimport ShadowBlot from './shadow.js';\n\nfunction makeAttachedBlot(node: Node, scroll: Root): Blot {\n  const found = scroll.find(node);\n  if (found) return found;\n  try {\n    return scroll.create(node);\n  } catch (e) {\n    const blot = scroll.create(Scope.INLINE);\n    Array.from(node.childNodes).forEach((child: Node) => {\n      blot.domNode.appendChild(child);\n    });\n    if (node.parentNode) {\n      node.parentNode.replaceChild(blot.domNode, node);\n    }\n    blot.attach();\n    return blot;\n  }\n}\n\nclass ParentBlot extends ShadowBlot implements Parent {\n  /**\n   * Whitelist array of Blots that can be direct children.\n   */\n  public static allowedChildren?: BlotConstructor[];\n\n  /**\n   * Default child blot to be inserted if this blot becomes empty.\n   */\n  public static defaultChild?: BlotConstructor;\n  public static uiClass = '';\n\n  public children!: LinkedList<Blot>;\n  public domNode!: HTMLElement;\n  public uiNode: HTMLElement | null = null;\n\n  constructor(scroll: Root, domNode: Node) {\n    super(scroll, domNode);\n    this.build();\n  }\n\n  public appendChild(other: Blot): void {\n    this.insertBefore(other);\n  }\n\n  public attach(): void {\n    super.attach();\n    this.children.forEach((child) => {\n      child.attach();\n    });\n  }\n\n  public attachUI(node: HTMLElement): void {\n    if (this.uiNode != null) {\n      this.uiNode.remove();\n    }\n    this.uiNode = node;\n    if (ParentBlot.uiClass) {\n      this.uiNode.classList.add(ParentBlot.uiClass);\n    }\n    this.uiNode.setAttribute('contenteditable', 'false');\n    this.domNode.insertBefore(this.uiNode, this.domNode.firstChild);\n  }\n\n  /**\n   * Called during construction, should fill its own children LinkedList.\n   */\n  public build(): void {\n    this.children = new LinkedList<Blot>();\n    // Need to be reversed for if DOM nodes already in order\n    Array.from(this.domNode.childNodes)\n      .filter((node: Node) => node !== this.uiNode)\n      .reverse()\n      .forEach((node: Node) => {\n        try {\n          const child = makeAttachedBlot(node, this.scroll);\n          this.insertBefore(child, this.children.head || undefined);\n        } catch (err) {\n          if (err instanceof ParchmentError) {\n            return;\n          } else {\n            throw err;\n          }\n        }\n      });\n  }\n\n  public deleteAt(index: number, length: number): void {\n    if (index === 0 && length === this.length()) {\n      return this.remove();\n    }\n    this.children.forEachAt(index, length, (child, offset, childLength) => {\n      child.deleteAt(offset, childLength);\n    });\n  }\n\n  public descendant<T extends Blot>(\n    criteria: new (...args: any[]) => T,\n    index: number,\n  ): [T | null, number];\n  public descendant(\n    criteria: (blot: Blot) => boolean,\n    index: number,\n  ): [Blot | null, number];\n  public descendant(criteria: any, index = 0): [Blot | null, number] {\n    const [child, offset] = this.children.find(index);\n    if (\n      (criteria.blotName == null && criteria(child)) ||\n      (criteria.blotName != null && child instanceof criteria)\n    ) {\n      return [child as any, offset];\n    } else if (child instanceof ParentBlot) {\n      return child.descendant(criteria, offset);\n    } else {\n      return [null, -1];\n    }\n  }\n\n  public descendants<T extends Blot>(\n    criteria: new (...args: any[]) => T,\n    index?: number,\n    length?: number,\n  ): T[];\n  public descendants(\n    criteria: (blot: Blot) => boolean,\n    index?: number,\n    length?: number,\n  ): Blot[];\n  public descendants(\n    criteria: any,\n    index = 0,\n    length: number = Number.MAX_VALUE,\n  ): Blot[] {\n    let descendants: Blot[] = [];\n    let lengthLeft = length;\n    this.children.forEachAt(\n      index,\n      length,\n      (child: Blot, childIndex: number, childLength: number) => {\n        if (\n          (criteria.blotName == null && criteria(child)) ||\n          (criteria.blotName != null && child instanceof criteria)\n        ) {\n          descendants.push(child);\n        }\n        if (child instanceof ParentBlot) {\n          descendants = descendants.concat(\n            child.descendants(criteria, childIndex, lengthLeft),\n          );\n        }\n        lengthLeft -= childLength;\n      },\n    );\n    return descendants;\n  }\n\n  public detach(): void {\n    this.children.forEach((child) => {\n      child.detach();\n    });\n    super.detach();\n  }\n\n  public enforceAllowedChildren(): void {\n    let done = false;\n    this.children.forEach((child: Blot) => {\n      if (done) {\n        return;\n      }\n      const allowed = this.statics.allowedChildren.some(\n        (def: BlotConstructor) => child instanceof def,\n      );\n      if (allowed) {\n        return;\n      }\n      if (child.statics.scope === Scope.BLOCK_BLOT) {\n        if (child.next != null) {\n          this.splitAfter(child);\n        }\n        if (child.prev != null) {\n          this.splitAfter(child.prev);\n        }\n        child.parent.unwrap();\n        done = true;\n      } else if (child instanceof ParentBlot) {\n        child.unwrap();\n      } else {\n        child.remove();\n      }\n    });\n  }\n\n  public formatAt(\n    index: number,\n    length: number,\n    name: string,\n    value: any,\n  ): void {\n    this.children.forEachAt(index, length, (child, offset, childLength) => {\n      child.formatAt(offset, childLength, name, value);\n    });\n  }\n\n  public insertAt(index: number, value: string, def?: any): void {\n    const [child, offset] = this.children.find(index);\n    if (child) {\n      child.insertAt(offset, value, def);\n    } else {\n      const blot =\n        def == null\n          ? this.scroll.create('text', value)\n          : this.scroll.create(value, def);\n      this.appendChild(blot);\n    }\n  }\n\n  public insertBefore(childBlot: Blot, refBlot?: Blot | null): void {\n    if (childBlot.parent != null) {\n      childBlot.parent.children.remove(childBlot);\n    }\n    let refDomNode: Node | null = null;\n    this.children.insertBefore(childBlot, refBlot || null);\n    childBlot.parent = this;\n    if (refBlot != null) {\n      refDomNode = refBlot.domNode;\n    }\n    if (\n      this.domNode.parentNode !== childBlot.domNode ||\n      this.domNode.nextSibling !== refDomNode\n    ) {\n      this.domNode.insertBefore(childBlot.domNode, refDomNode);\n    }\n    childBlot.attach();\n  }\n\n  public length(): number {\n    return this.children.reduce((memo, child) => {\n      return memo + child.length();\n    }, 0);\n  }\n\n  public moveChildren(targetParent: Parent, refNode?: Blot | null): void {\n    this.children.forEach((child) => {\n      targetParent.insertBefore(child, refNode);\n    });\n  }\n\n  public optimize(context?: { [key: string]: any }): void {\n    super.optimize(context);\n    this.enforceAllowedChildren();\n    if (this.uiNode != null && this.uiNode !== this.domNode.firstChild) {\n      this.domNode.insertBefore(this.uiNode, this.domNode.firstChild);\n    }\n    if (this.children.length === 0) {\n      if (this.statics.defaultChild != null) {\n        const child = this.scroll.create(this.statics.defaultChild.blotName);\n        this.appendChild(child);\n        // TODO double check if necessary\n        // child.optimize(context);\n      } else {\n        this.remove();\n      }\n    }\n  }\n\n  public path(index: number, inclusive = false): [Blot, number][] {\n    const [child, offset] = this.children.find(index, inclusive);\n    const position: [Blot, number][] = [[this, index]];\n    if (child instanceof ParentBlot) {\n      return position.concat(child.path(offset, inclusive));\n    } else if (child != null) {\n      position.push([child, offset]);\n    }\n    return position;\n  }\n\n  public removeChild(child: Blot): void {\n    this.children.remove(child);\n  }\n\n  public replaceWith(name: string | Blot, value?: any): Blot {\n    const replacement =\n      typeof name === 'string' ? this.scroll.create(name, value) : name;\n    if (replacement instanceof ParentBlot) {\n      this.moveChildren(replacement);\n    }\n    return super.replaceWith(replacement);\n  }\n\n  public split(index: number, force = false): Blot | null {\n    if (!force) {\n      if (index === 0) {\n        return this;\n      }\n      if (index === this.length()) {\n        return this.next;\n      }\n    }\n    const after = this.clone() as ParentBlot;\n    if (this.parent) {\n      this.parent.insertBefore(after, this.next || undefined);\n    }\n    this.children.forEachAt(index, this.length(), (child, offset, _length) => {\n      const split = child.split(offset, force);\n      if (split != null) {\n        after.appendChild(split);\n      }\n    });\n    return after;\n  }\n\n  public splitAfter(child: Blot): Parent {\n    const after = this.clone() as ParentBlot;\n    while (child.next != null) {\n      after.appendChild(child.next);\n    }\n    if (this.parent) {\n      this.parent.insertBefore(after, this.next || undefined);\n    }\n    return after;\n  }\n\n  public unwrap(): void {\n    if (this.parent) {\n      this.moveChildren(this.parent, this.next || undefined);\n    }\n    this.remove();\n  }\n\n  public update(\n    mutations: MutationRecord[],\n    _context: { [key: string]: any },\n  ): void {\n    const addedNodes: Node[] = [];\n    const removedNodes: Node[] = [];\n    mutations.forEach((mutation) => {\n      if (mutation.target === this.domNode && mutation.type === 'childList') {\n        addedNodes.push(...mutation.addedNodes);\n        removedNodes.push(...mutation.removedNodes);\n      }\n    });\n    removedNodes.forEach((node: 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 (\n        node.parentNode != null &&\n        // @ts-expect-error Fix me later\n        node.tagName !== 'IFRAME' &&\n        document.body.compareDocumentPosition(node) &\n          Node.DOCUMENT_POSITION_CONTAINED_BY\n      ) {\n        return;\n      }\n      const blot = this.scroll.find(node);\n      if (blot == null) {\n        return;\n      }\n      if (\n        blot.domNode.parentNode == null ||\n        blot.domNode.parentNode === this.domNode\n      ) {\n        blot.detach();\n      }\n    });\n    addedNodes\n      .filter((node) => {\n        return node.parentNode === this.domNode && node !== this.uiNode;\n      })\n      .sort((a, b) => {\n        if (a === b) {\n          return 0;\n        }\n        if (a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING) {\n          return 1;\n        }\n        return -1;\n      })\n      .forEach((node) => {\n        let refBlot: Blot | null = null;\n        if (node.nextSibling != null) {\n          refBlot = this.scroll.find(node.nextSibling);\n        }\n        const blot = makeAttachedBlot(node, this.scroll);\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    this.enforceAllowedChildren();\n  }\n}\n\nexport default ParentBlot;\n","import Attributor from '../attributor/attributor.js';\nimport AttributorStore from '../attributor/store.js';\nimport Scope from '../scope.js';\nimport type {\n  Blot,\n  BlotConstructor,\n  Formattable,\n  Parent,\n  Root,\n} from './abstract/blot.js';\nimport LeafBlot from './abstract/leaf.js';\nimport ParentBlot from './abstract/parent.js';\n\n// Shallow object comparison\nfunction isEqual(\n  obj1: Record<string, unknown>,\n  obj2: Record<string, unknown>,\n): boolean {\n  if (Object.keys(obj1).length !== Object.keys(obj2).length) {\n    return false;\n  }\n  for (const prop in obj1) {\n    if (obj1[prop] !== obj2[prop]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nclass InlineBlot extends ParentBlot implements Formattable {\n  public static allowedChildren: BlotConstructor[] = [InlineBlot, LeafBlot];\n  public static blotName = 'inline';\n  public static scope = Scope.INLINE_BLOT;\n  public static tagName: string | string[] = 'SPAN';\n\n  static create(value?: unknown) {\n    return super.create(value) as HTMLElement;\n  }\n\n  public static formats(domNode: HTMLElement, scroll: Root): any {\n    const match = scroll.query(InlineBlot.blotName);\n    if (\n      match != null &&\n      domNode.tagName === (match as BlotConstructor).tagName\n    ) {\n      return undefined;\n    } else if (typeof this.tagName === 'string') {\n      return true;\n    } else if (Array.isArray(this.tagName)) {\n      return domNode.tagName.toLowerCase();\n    }\n    return undefined;\n  }\n\n  protected attributes: AttributorStore;\n\n  constructor(scroll: Root, domNode: Node) {\n    super(scroll, domNode);\n    this.attributes = new AttributorStore(this.domNode);\n  }\n\n  public format(name: string, value: any): void {\n    if (name === this.statics.blotName && !value) {\n      this.children.forEach((child) => {\n        if (!(child instanceof InlineBlot)) {\n          child = child.wrap(InlineBlot.blotName, true);\n        }\n        this.attributes.copy(child as InlineBlot);\n      });\n      this.unwrap();\n    } else {\n      const format = this.scroll.query(name, Scope.INLINE);\n      if (format == null) {\n        return;\n      }\n      if (format instanceof Attributor) {\n        this.attributes.attribute(format, value);\n      } else if (\n        value &&\n        (name !== this.statics.blotName || this.formats()[name] !== value)\n      ) {\n        this.replaceWith(name, value);\n      }\n    }\n  }\n\n  public formats(): { [index: string]: any } {\n    const formats = this.attributes.values();\n    const format = this.statics.formats(this.domNode, this.scroll);\n    if (format != null) {\n      formats[this.statics.blotName] = format;\n    }\n    return formats;\n  }\n\n  public formatAt(\n    index: number,\n    length: number,\n    name: string,\n    value: any,\n  ): void {\n    if (\n      this.formats()[name] != null ||\n      this.scroll.query(name, Scope.ATTRIBUTE)\n    ) {\n      const blot = this.isolate(index, length) as InlineBlot;\n      blot.format(name, value);\n    } else {\n      super.formatAt(index, length, name, value);\n    }\n  }\n\n  public optimize(context: { [key: string]: any }): void {\n    super.optimize(context);\n    const formats = this.formats();\n    if (Object.keys(formats).length === 0) {\n      return this.unwrap(); // unformatted span\n    }\n    const next = this.next;\n    if (\n      next instanceof InlineBlot &&\n      next.prev === this &&\n      isEqual(formats, next.formats())\n    ) {\n      next.moveChildren(this);\n      next.remove();\n    }\n  }\n\n  public replaceWith(name: string | Blot, value?: any): Blot {\n    const replacement = super.replaceWith(name, value) as InlineBlot;\n    this.attributes.copy(replacement);\n    return replacement;\n  }\n\n  public update(\n    mutations: MutationRecord[],\n    context: { [key: string]: any },\n  ): void {\n    super.update(mutations, context);\n    const attributeChanged = mutations.some(\n      (mutation) =>\n        mutation.target === this.domNode && mutation.type === 'attributes',\n    );\n    if (attributeChanged) {\n      this.attributes.build();\n    }\n  }\n\n  public wrap(name: string | Parent, value?: any): Parent {\n    const wrapper = super.wrap(name, value);\n    if (wrapper instanceof InlineBlot) {\n      this.attributes.move(wrapper);\n    }\n    return wrapper;\n  }\n}\n\nexport default InlineBlot;\n","import Attributor from '../attributor/attributor.js';\nimport AttributorStore from '../attributor/store.js';\nimport Scope from '../scope.js';\nimport type {\n  Blot,\n  BlotConstructor,\n  Formattable,\n  Root,\n} from './abstract/blot.js';\nimport LeafBlot from './abstract/leaf.js';\nimport ParentBlot from './abstract/parent.js';\nimport InlineBlot from './inline.js';\n\nclass BlockBlot extends ParentBlot implements Formattable {\n  public static blotName = 'block';\n  public static scope = Scope.BLOCK_BLOT;\n  public static tagName: string | string[] = 'P';\n  public static allowedChildren: BlotConstructor[] = [\n    InlineBlot,\n    BlockBlot,\n    LeafBlot,\n  ];\n\n  static create(value?: unknown) {\n    return super.create(value) as HTMLElement;\n  }\n\n  public static formats(domNode: HTMLElement, scroll: Root): any {\n    const match = scroll.query(BlockBlot.blotName);\n    if (\n      match != null &&\n      domNode.tagName === (match as BlotConstructor).tagName\n    ) {\n      return undefined;\n    } else if (typeof this.tagName === 'string') {\n      return true;\n    } else if (Array.isArray(this.tagName)) {\n      return domNode.tagName.toLowerCase();\n    }\n  }\n\n  protected attributes: AttributorStore;\n\n  constructor(scroll: Root, domNode: Node) {\n    super(scroll, domNode);\n    this.attributes = new AttributorStore(this.domNode);\n  }\n\n  public format(name: string, value: any): void {\n    const format = this.scroll.query(name, Scope.BLOCK);\n    if (format == null) {\n      return;\n    } else if (format instanceof Attributor) {\n      this.attributes.attribute(format, value);\n    } else if (name === this.statics.blotName && !value) {\n      this.replaceWith(BlockBlot.blotName);\n    } else if (\n      value &&\n      (name !== this.statics.blotName || this.formats()[name] !== value)\n    ) {\n      this.replaceWith(name, value);\n    }\n  }\n\n  public formats(): { [index: string]: any } {\n    const formats = this.attributes.values();\n    const format = this.statics.formats(this.domNode, this.scroll);\n    if (format != null) {\n      formats[this.statics.blotName] = format;\n    }\n    return formats;\n  }\n\n  public formatAt(\n    index: number,\n    length: number,\n    name: string,\n    value: any,\n  ): void {\n    if (this.scroll.query(name, Scope.BLOCK) != null) {\n      this.format(name, value);\n    } else {\n      super.formatAt(index, length, name, value);\n    }\n  }\n\n  public insertAt(index: number, value: string, def?: any): void {\n    if (def == null || this.scroll.query(value, Scope.INLINE) != null) {\n      // Insert text or inline\n      super.insertAt(index, value, def);\n    } else {\n      const after = this.split(index);\n      if (after != null) {\n        const blot = this.scroll.create(value, def);\n        after.parent.insertBefore(blot, after);\n      } else {\n        throw new Error('Attempt to insertAt after block boundaries');\n      }\n    }\n  }\n\n  public replaceWith(name: string | Blot, value?: any): Blot {\n    const replacement = super.replaceWith(name, value) as BlockBlot;\n    this.attributes.copy(replacement);\n    return replacement;\n  }\n\n  public update(\n    mutations: MutationRecord[],\n    context: { [key: string]: any },\n  ): void {\n    super.update(mutations, context);\n    const attributeChanged = mutations.some(\n      (mutation) =>\n        mutation.target === this.domNode && mutation.type === 'attributes',\n    );\n    if (attributeChanged) {\n      this.attributes.build();\n    }\n  }\n}\n\nexport default BlockBlot;\n","import Scope from '../../scope.js';\nimport BlockBlot from '../block.js';\nimport ParentBlot from './parent.js';\n\nclass ContainerBlot extends ParentBlot {\n  public static blotName = 'container';\n  public static scope = Scope.BLOCK_BLOT;\n  public static tagName: string | string[];\n\n  public prev!: BlockBlot | ContainerBlot | null;\n  public next!: BlockBlot | ContainerBlot | null;\n\n  public checkMerge(): boolean {\n    return (\n      this.next !== null && this.next.statics.blotName === this.statics.blotName\n    );\n  }\n\n  public deleteAt(index: number, length: number): void {\n    super.deleteAt(index, length);\n    this.enforceAllowedChildren();\n  }\n\n  public formatAt(\n    index: number,\n    length: number,\n    name: string,\n    value: any,\n  ): void {\n    super.formatAt(index, length, name, value);\n    this.enforceAllowedChildren();\n  }\n\n  public insertAt(index: number, value: string, def?: any): void {\n    super.insertAt(index, value, def);\n    this.enforceAllowedChildren();\n  }\n\n  public optimize(context: { [key: string]: any }): void {\n    super.optimize(context);\n    if (this.children.length > 0 && this.next != null && this.checkMerge()) {\n      this.next.moveChildren(this);\n      this.next.remove();\n    }\n  }\n}\n\nexport default ContainerBlot;\n","import type { Formattable, Root } from './abstract/blot.js';\nimport LeafBlot from './abstract/leaf.js';\n\nclass EmbedBlot extends LeafBlot implements Formattable {\n  public static formats(_domNode: HTMLElement, _scroll: Root): any {\n    return undefined;\n  }\n\n  public format(name: string, value: any): void {\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.formatAt(0, this.length(), name, value);\n  }\n\n  public formatAt(\n    index: number,\n    length: number,\n    name: string,\n    value: any,\n  ): void {\n    if (index === 0 && length === this.length()) {\n      this.format(name, value);\n    } else {\n      super.formatAt(index, length, name, value);\n    }\n  }\n\n  public formats(): { [index: string]: any } {\n    return this.statics.formats(this.domNode, this.scroll);\n  }\n}\n\nexport default EmbedBlot;\n","import Registry, { type RegistryDefinition } from '../registry.js';\nimport Scope from '../scope.js';\nimport type { Blot, BlotConstructor, Root } from './abstract/blot.js';\nimport ContainerBlot from './abstract/container.js';\nimport ParentBlot from './abstract/parent.js';\nimport BlockBlot from './block.js';\n\nconst OBSERVER_CONFIG = {\n  attributes: true,\n  characterData: true,\n  characterDataOldValue: true,\n  childList: true,\n  subtree: true,\n};\n\nconst MAX_OPTIMIZE_ITERATIONS = 100;\n\nclass ScrollBlot extends ParentBlot implements Root {\n  public static blotName = 'scroll';\n  public static defaultChild = BlockBlot;\n  public static allowedChildren: BlotConstructor[] = [BlockBlot, ContainerBlot];\n  public static scope = Scope.BLOCK_BLOT;\n  public static tagName = 'DIV';\n\n  public observer: MutationObserver;\n\n  constructor(\n    public registry: Registry,\n    node: HTMLDivElement,\n  ) {\n    // @ts-expect-error scroll is the root with no parent\n    super(null, node);\n    this.scroll = this;\n    this.build();\n    this.observer = new MutationObserver((mutations: MutationRecord[]) => {\n      this.update(mutations);\n    });\n    this.observer.observe(this.domNode, OBSERVER_CONFIG);\n    this.attach();\n  }\n\n  public create(input: Node | string | Scope, value?: any): Blot {\n    return this.registry.create(this, input, value);\n  }\n\n  public find(node: Node | null, bubble = false): Blot | null {\n    const blot = this.registry.find(node, bubble);\n    if (!blot) {\n      return null;\n    }\n    if (blot.scroll === this) {\n      return blot;\n    }\n    return bubble ? this.find(blot.scroll.domNode.parentNode, true) : null;\n  }\n\n  public query(\n    query: string | Node | Scope,\n    scope: Scope = Scope.ANY,\n  ): RegistryDefinition | null {\n    return this.registry.query(query, scope);\n  }\n\n  public register(...definitions: RegistryDefinition[]) {\n    return this.registry.register(...definitions);\n  }\n\n  public build(): void {\n    if (this.scroll == null) {\n      return;\n    }\n    super.build();\n  }\n\n  public detach(): void {\n    super.detach();\n    this.observer.disconnect();\n  }\n\n  public deleteAt(index: number, length: number): void {\n    this.update();\n    if (index === 0 && length === this.length()) {\n      this.children.forEach((child) => {\n        child.remove();\n      });\n    } else {\n      super.deleteAt(index, length);\n    }\n  }\n\n  public formatAt(\n    index: number,\n    length: number,\n    name: string,\n    value: any,\n  ): void {\n    this.update();\n    super.formatAt(index, length, name, value);\n  }\n\n  public insertAt(index: number, value: string, def?: any): void {\n    this.update();\n    super.insertAt(index, value, def);\n  }\n\n  public optimize(context?: { [key: string]: any }): void;\n  public optimize(\n    mutations: MutationRecord[],\n    context: { [key: string]: any },\n  ): void;\n  public optimize(mutations: any = [], context: any = {}): void {\n    super.optimize(context);\n    const mutationsMap = context.mutationsMap || new WeakMap();\n    // We must modify mutations directly, cannot make copy and then modify\n    let records = Array.from(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    }\n    const mark = (blot: Blot | null, markParent = true): void => {\n      if (blot == null || blot === this) {\n        return;\n      }\n      if (blot.domNode.parentNode == null) {\n        return;\n      }\n      if (!mutationsMap.has(blot.domNode)) {\n        mutationsMap.set(blot.domNode, []);\n      }\n      if (markParent) {\n        mark(blot.parent);\n      }\n    };\n    const optimize = (blot: Blot): void => {\n      // Post-order traversal\n      if (!mutationsMap.has(blot.domNode)) {\n        return;\n      }\n      if (blot instanceof ParentBlot) {\n        blot.children.forEach(optimize);\n      }\n      mutationsMap.delete(blot.domNode);\n      blot.optimize(context);\n    };\n    let remaining = mutations;\n    for (let 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((mutation: MutationRecord) => {\n        const blot = this.find(mutation.target, true);\n        if (blot == null) {\n          return;\n        }\n        if (blot.domNode === mutation.target) {\n          if (mutation.type === 'childList') {\n            mark(this.find(mutation.previousSibling, false));\n            Array.from(mutation.addedNodes).forEach((node: Node) => {\n              const child = this.find(node, false);\n              mark(child, false);\n              if (child instanceof ParentBlot) {\n                child.children.forEach((grandChild: Blot) => {\n                  mark(grandChild, false);\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 = Array.from(this.observer.takeRecords());\n      records = remaining.slice();\n      while (records.length > 0) {\n        mutations.push(records.pop());\n      }\n    }\n  }\n\n  public update(\n    mutations?: MutationRecord[],\n    context: { [key: string]: any } = {},\n  ): void {\n    mutations = mutations || this.observer.takeRecords();\n    const mutationsMap = new WeakMap();\n    mutations\n      .map((mutation: MutationRecord) => {\n        const blot = this.find(mutation.target, true);\n        if (blot == null) {\n          return null;\n        }\n        if (mutationsMap.has(blot.domNode)) {\n          mutationsMap.get(blot.domNode).push(mutation);\n          return null;\n        } else {\n          mutationsMap.set(blot.domNode, [mutation]);\n          return blot;\n        }\n      })\n      .forEach((blot: Blot | null) => {\n        if (blot != null && blot !== this && mutationsMap.has(blot.domNode)) {\n          blot.update(mutationsMap.get(blot.domNode) || [], context);\n        }\n      });\n    context.mutationsMap = mutationsMap;\n    if (mutationsMap.has(this.domNode)) {\n      super.update(mutationsMap.get(this.domNode), context);\n    }\n    this.optimize(mutations, context);\n  }\n}\n\nexport default ScrollBlot;\n","import Scope from '../scope.js';\nimport type { Blot, Leaf, Root } from './abstract/blot.js';\nimport LeafBlot from './abstract/leaf.js';\n\nclass TextBlot extends LeafBlot implements Leaf {\n  public static readonly blotName = 'text';\n  public static scope = Scope.INLINE_BLOT;\n\n  public static create(value: string): Text {\n    return document.createTextNode(value);\n  }\n\n  public static value(domNode: Text): string {\n    return domNode.data;\n  }\n\n  public domNode!: Text;\n  protected text: string;\n\n  constructor(scroll: Root, node: Node) {\n    super(scroll, node);\n    this.text = this.statics.value(this.domNode);\n  }\n\n  public deleteAt(index: number, length: number): void {\n    this.domNode.data = this.text =\n      this.text.slice(0, index) + this.text.slice(index + length);\n  }\n\n  public index(node: Node, offset: number): number {\n    if (this.domNode === node) {\n      return offset;\n    }\n    return -1;\n  }\n\n  public insertAt(index: number, value: string, def?: any): void {\n    if (def == null) {\n      this.text = this.text.slice(0, index) + value + this.text.slice(index);\n      this.domNode.data = this.text;\n    } else {\n      super.insertAt(index, value, def);\n    }\n  }\n\n  public length(): number {\n    return this.text.length;\n  }\n\n  public optimize(context: { [key: string]: any }): void {\n    super.optimize(context);\n    this.text = this.statics.value(this.domNode);\n    if (this.text.length === 0) {\n      this.remove();\n    } else if (this.next instanceof TextBlot && this.next.prev === this) {\n      this.insertAt(this.length(), (this.next as TextBlot).value());\n      this.next.remove();\n    }\n  }\n\n  public position(index: number, _inclusive = false): [Node, number] {\n    return [this.domNode, index];\n  }\n\n  public split(index: number, force = false): Blot | null {\n    if (!force) {\n      if (index === 0) {\n        return this;\n      }\n      if (index === this.length()) {\n        return this.next;\n      }\n    }\n    const after = this.scroll.create(this.domNode.splitText(index));\n    this.parent.insertBefore(after, this.next || undefined);\n    this.text = this.statics.value(this.domNode);\n    return after;\n  }\n\n  public update(\n    mutations: MutationRecord[],\n    _context: { [key: string]: any },\n  ): void {\n    if (\n      mutations.some((mutation) => {\n        return (\n          mutation.type === 'characterData' && mutation.target === this.domNode\n        );\n      })\n    ) {\n      this.text = this.statics.value(this.domNode);\n    }\n  }\n\n  public value(): string {\n    return this.text;\n  }\n}\n\nexport default TextBlot;\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\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = function(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__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }","// define __esModule on exports\n__webpack_require__.r = function(exports) {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","import { ClassAttributor, Scope } from 'parchment';\n\nclass IndentAttributor extends ClassAttributor {\n  add(node: HTMLElement, value: string | number) {\n    let normalizedValue = 0;\n    if (value === '+1' || value === '-1') {\n      const indent = this.value(node) || 0;\n      normalizedValue = value === '+1' ? indent + 1 : indent - 1;\n    } else if (typeof value === 'number') {\n      normalizedValue = value;\n    }\n    if (normalizedValue === 0) {\n      this.remove(node);\n      return true;\n    }\n    return super.add(node, normalizedValue.toString());\n  }\n\n  canAdd(node: HTMLElement, value: string) {\n    return super.canAdd(node, value) || super.canAdd(node, parseInt(value, 10));\n  }\n\n  value(node: HTMLElement) {\n    return parseInt(super.value(node), 10) || undefined; // Don't return NaN\n  }\n}\n\nconst IndentClass = new IndentAttributor('indent', 'ql-indent', {\n  scope: Scope.BLOCK,\n  // @ts-expect-error\n  whitelist: [1, 2, 3, 4, 5, 6, 7, 8],\n});\n\nexport default IndentClass;\n","import Block from '../blots/block.js';\n\nclass Blockquote extends Block {\n  static blotName = 'blockquote';\n  static tagName = 'blockquote';\n}\n\nexport default Blockquote;\n","import Block from '../blots/block.js';\n\nclass Header extends Block {\n  static blotName = 'header';\n  static tagName = ['H1', 'H2', 'H3', 'H4', 'H5', 'H6'];\n\n  static formats(domNode: Element) {\n    return this.tagName.indexOf(domNode.tagName) + 1;\n  }\n}\n\nexport default Header;\n","import Block from '../blots/block.js';\nimport Container from '../blots/container.js';\nimport type Scroll from '../blots/scroll.js';\nimport Quill from '../core/quill.js';\n\nclass ListContainer extends Container {}\nListContainer.blotName = 'list-container';\nListContainer.tagName = 'OL';\n\nclass ListItem extends Block {\n  static create(value: string) {\n    const node = super.create() as HTMLElement;\n    node.setAttribute('data-list', value);\n    return node;\n  }\n\n  static formats(domNode: HTMLElement) {\n    return domNode.getAttribute('data-list') || undefined;\n  }\n\n  static register() {\n    Quill.register(ListContainer);\n  }\n\n  constructor(scroll: Scroll, domNode: HTMLElement) {\n    super(scroll, domNode);\n    const ui = domNode.ownerDocument.createElement('span');\n    const listEventHandler = (e: Event) => {\n      if (!scroll.isEnabled()) return;\n      const format = this.statics.formats(domNode, scroll);\n      if (format === 'checked') {\n        this.format('list', 'unchecked');\n        e.preventDefault();\n      } else if (format === 'unchecked') {\n        this.format('list', 'checked');\n        e.preventDefault();\n      }\n    };\n    ui.addEventListener('mousedown', listEventHandler);\n    ui.addEventListener('touchstart', listEventHandler);\n    this.attachUI(ui);\n  }\n\n  format(name: string, value: string) {\n    if (name === this.statics.blotName && value) {\n      this.domNode.setAttribute('data-list', value);\n    } else {\n      super.format(name, value);\n    }\n  }\n}\nListItem.blotName = 'list';\nListItem.tagName = 'LI';\n\nListContainer.allowedChildren = [ListItem];\nListItem.requiredContainer = ListContainer;\n\nexport { ListContainer, ListItem as default };\n","import Inline from '../blots/inline.js';\n\nclass Bold extends Inline {\n  static blotName = 'bold';\n  static tagName = ['STRONG', 'B'];\n\n  static create() {\n    return super.create();\n  }\n\n  static formats() {\n    return true;\n  }\n\n  optimize(context: { [key: string]: any }) {\n    super.optimize(context);\n    if (this.domNode.tagName !== this.statics.tagName[0]) {\n      this.replaceWith(this.statics.blotName);\n    }\n  }\n}\n\nexport default Bold;\n","import Inline from '../blots/inline.js';\n\nclass Link extends Inline {\n  static blotName = 'link';\n  static tagName = 'A';\n  static SANITIZED_URL = 'about:blank';\n  static PROTOCOL_WHITELIST = ['http', 'https', 'mailto', 'tel', 'sms'];\n\n  static create(value: string) {\n    const node = super.create(value) as HTMLElement;\n    node.setAttribute('href', this.sanitize(value));\n    node.setAttribute('rel', 'noopener noreferrer');\n    node.setAttribute('target', '_blank');\n    return node;\n  }\n\n  static formats(domNode: HTMLElement) {\n    return domNode.getAttribute('href');\n  }\n\n  static sanitize(url: string) {\n    return sanitize(url, this.PROTOCOL_WHITELIST) ? url : this.SANITIZED_URL;\n  }\n\n  format(name: string, value: unknown) {\n    if (name !== this.statics.blotName || !value) {\n      super.format(name, value);\n    } else {\n      // @ts-expect-error\n      this.domNode.setAttribute('href', this.constructor.sanitize(value));\n    }\n  }\n}\n\nfunction sanitize(url: string, protocols: string[]) {\n  const anchor = document.createElement('a');\n  anchor.href = url;\n  const protocol = anchor.href.slice(0, anchor.href.indexOf(':'));\n  return protocols.indexOf(protocol) > -1;\n}\n\nexport { Link as default, sanitize };\n","import Inline from '../blots/inline.js';\n\nclass Script extends Inline {\n  static blotName = 'script';\n  static tagName = ['SUB', 'SUP'];\n\n  static create(value: 'super' | 'sub' | (string & {})) {\n    if (value === 'super') {\n      return document.createElement('sup');\n    }\n    if (value === 'sub') {\n      return document.createElement('sub');\n    }\n    return super.create(value);\n  }\n\n  static formats(domNode: HTMLElement) {\n    if (domNode.tagName === 'SUB') return 'sub';\n    if (domNode.tagName === 'SUP') return 'super';\n    return undefined;\n  }\n}\n\nexport default Script;\n","import Inline from '../blots/inline.js';\n\nclass Underline extends Inline {\n  static blotName = 'underline';\n  static tagName = 'U';\n}\n\nexport default Underline;\n","import { EmbedBlot } from 'parchment';\nimport { sanitize } from './link.js';\n\nconst ATTRIBUTES = ['alt', 'height', 'width'];\n\nclass Image extends EmbedBlot {\n  static blotName = 'image';\n  static tagName = 'IMG';\n\n  static create(value: string) {\n    const node = super.create(value) as Element;\n    if (typeof value === 'string') {\n      node.setAttribute('src', this.sanitize(value));\n    }\n    return node;\n  }\n\n  static formats(domNode: Element) {\n    return ATTRIBUTES.reduce(\n      (formats: Record<string, string | null>, attribute) => {\n        if (domNode.hasAttribute(attribute)) {\n          formats[attribute] = domNode.getAttribute(attribute);\n        }\n        return formats;\n      },\n      {},\n    );\n  }\n\n  static match(url: string) {\n    return /\\.(jpe?g|gif|png)$/.test(url) || /^data:image\\/.+;base64/.test(url);\n  }\n\n  static sanitize(url: string) {\n    return sanitize(url, ['http', 'https', 'data']) ? url : '//:0';\n  }\n\n  static value(domNode: Element) {\n    return domNode.getAttribute('src');\n  }\n\n  domNode: HTMLImageElement;\n\n  format(name: string, value: string) {\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}\n\nexport default Image;\n","import { BlockEmbed } from '../blots/block.js';\nimport Link from './link.js';\n\nconst ATTRIBUTES = ['height', 'width'];\n\nclass Video extends BlockEmbed {\n  static blotName = 'video';\n  static className = 'ql-video';\n  static tagName = 'IFRAME';\n\n  static create(value: string) {\n    const node = super.create(value) as Element;\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: Element) {\n    return ATTRIBUTES.reduce(\n      (formats: Record<string, string | null>, attribute) => {\n        if (domNode.hasAttribute(attribute)) {\n          formats[attribute] = domNode.getAttribute(attribute);\n        }\n        return formats;\n      },\n      {},\n    );\n  }\n\n  static sanitize(url: string) {\n    return Link.sanitize(url);\n  }\n\n  static value(domNode: Element) {\n    return domNode.getAttribute('src');\n  }\n\n  domNode: HTMLVideoElement;\n\n  format(name: string, value: string) {\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\n  html() {\n    const { video } = this.value();\n    return `<a href=\"${video}\">${video}</a>`;\n  }\n}\n\nexport default Video;\n","import Delta from 'quill-delta-es';\nimport { EmbedBlot, Scope } from 'parchment';\nimport Quill from '../core/quill.js';\nimport logger from '../core/logger.js';\nimport Module from '../core/module.js';\nimport type { Range } from '../core/selection.js';\n\nconst debug = logger('quill:toolbar');\n\ntype Handler = (this: Toolbar, value: any) => void;\n\nexport type ToolbarConfig = Array<\n  string[] | Array<string | Record<string, unknown>>\n>;\nexport interface ToolbarProps {\n  container?: HTMLElement | ToolbarConfig | null;\n  handlers?: Record<string, Handler>;\n  option?: number;\n  module?: boolean;\n  theme?: boolean;\n}\n\nclass Toolbar extends Module<ToolbarProps> {\n  static DEFAULTS: ToolbarProps;\n\n  container?: HTMLElement | null;\n  controls: [string, HTMLElement][];\n  handlers: Record<string, Handler>;\n\n  constructor(quill: Quill, options: Partial<ToolbarProps>) {\n    super(quill, options);\n    if (Array.isArray(this.options.container)) {\n      const container = document.createElement('div');\n      container.setAttribute('role', 'toolbar');\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 = quill.container.getRootNode() as 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      debug.error('Container required for toolbar', this.options);\n      return;\n    }\n    this.container.classList.add('ql-toolbar');\n    this.controls = [];\n    this.handlers = {};\n    if (this.options.handlers) {\n      Object.keys(this.options.handlers).forEach((format) => {\n        const handler = this.options.handlers?.[format];\n        if (handler) {\n          this.addHandler(format, handler);\n        }\n      });\n    }\n    Array.from(this.container.querySelectorAll('button, select')).forEach(\n      (input) => {\n        // @ts-expect-error\n        this.attach(input);\n      },\n    );\n    this.quill.on(Quill.events.EDITOR_CHANGE, () => {\n      const [range] = this.quill.selection.getRange(); // quill.getSelection triggers update\n      this.update(range);\n    });\n  }\n\n  addHandler(format: string, handler: Handler) {\n    this.handlers[format] = handler;\n  }\n\n  attach(input: HTMLElement) {\n    let format = Array.from(input.classList).find((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 (\n      this.handlers[format] == null &&\n      this.quill.scroll.query(format) == null\n    ) {\n      debug.warn('ignoring attaching to nonexistent format', format, input);\n      return;\n    }\n    const eventName = input.tagName === 'SELECT' ? 'change' : 'click';\n    input.addEventListener(eventName, (e) => {\n      let value;\n      if (input.tagName === 'SELECT') {\n        // @ts-expect-error\n        if (input.selectedIndex < 0) return;\n        // @ts-expect-error\n        const 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          // @ts-expect-error\n          value = input.value || !input.hasAttribute('value');\n        }\n        e.preventDefault();\n      }\n      this.quill.focus();\n      const [range] = this.quill.selection.getRange();\n      if (this.handlers[format] != null) {\n        this.handlers[format].call(this, value);\n      } else if (\n        // @ts-expect-error\n        this.quill.scroll.query(format).prototype instanceof EmbedBlot\n      ) {\n        value = prompt(`Enter ${format}`); // eslint-disable-line no-alert\n        if (!value) return;\n        this.quill.updateContents(\n          new Delta()\n            // @ts-expect-error Fix me later\n            .retain(range.index)\n            // @ts-expect-error Fix me later\n            .delete(range.length)\n            .insert({ [format]: value }),\n          Quill.sources.USER,\n        );\n      } else {\n        this.quill.format(format, value, Quill.sources.USER);\n      }\n      this.update(range);\n    });\n    this.controls.push([format, input]);\n  }\n\n  update(range: Range | null) {\n    const formats = range == null ? {} : this.quill.getFormat(range);\n    this.controls.forEach((pair) => {\n      const [format, input] = pair;\n      if (input.tagName === 'SELECT') {\n        let option: HTMLOptionElement | null = null;\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          // @ts-expect-error TODO fix me later\n          input.value = ''; // TODO make configurable?\n          // @ts-expect-error TODO fix me later\n          input.selectedIndex = -1;\n        } else {\n          option.selected = true;\n        }\n      } else if (range == null) {\n        input.classList.remove('ql-active');\n        input.setAttribute('aria-pressed', 'false');\n      } else if (input.hasAttribute('value')) {\n        // both being null should match (default values)\n        // '1' should match with 1 (headers)\n        const value = formats[format] as boolean | number | string | object;\n        const isActive =\n          value === input.getAttribute('value') ||\n          (value != null && value.toString() === input.getAttribute('value')) ||\n          (value == null && !input.getAttribute('value'));\n        input.classList.toggle('ql-active', isActive);\n        input.setAttribute('aria-pressed', isActive.toString());\n      } else {\n        const isActive = formats[format] != null;\n        input.classList.toggle('ql-active', isActive);\n        input.setAttribute('aria-pressed', isActive.toString());\n      }\n    });\n  }\n}\nToolbar.DEFAULTS = {};\n\nfunction addButton(container: HTMLElement, format: string, value?: string) {\n  const input = document.createElement('button');\n  input.setAttribute('type', 'button');\n  input.classList.add(`ql-${format}`);\n  input.setAttribute('aria-pressed', 'false');\n  if (value != null) {\n    input.value = value;\n    input.setAttribute('aria-label', `${format}: ${value}`);\n  } else {\n    input.setAttribute('aria-label', format);\n  }\n  container.appendChild(input);\n}\n\nfunction addControls(\n  container: HTMLElement,\n  groups:\n    | (string | Record<string, unknown>)[][]\n    | (string | Record<string, unknown>)[],\n) {\n  if (!Array.isArray(groups[0])) {\n    // @ts-expect-error\n    groups = [groups];\n  }\n  groups.forEach((controls: any) => {\n    const group = document.createElement('span');\n    group.classList.add('ql-formats');\n    controls.forEach((control: any) => {\n      if (typeof control === 'string') {\n        addButton(group, control);\n      } else {\n        const format = Object.keys(control)[0];\n        const 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(\n  container: HTMLElement,\n  format: string,\n  values: Array<string | boolean>,\n) {\n  const input = document.createElement('select');\n  input.classList.add(`ql-${format}`);\n  values.forEach((value) => {\n    const option = document.createElement('option');\n    if (value !== false) {\n      option.setAttribute('value', String(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() {\n      const range = this.quill.getSelection();\n      if (range == null) return;\n      if (range.length === 0) {\n        const formats = this.quill.getFormat();\n        Object.keys(formats).forEach((name) => {\n          // Clean functionality in existing apps only clean inline formats\n          if (this.quill.scroll.query(name, Scope.INLINE) != null) {\n            this.quill.format(name, false, Quill.sources.USER);\n          }\n        });\n      } else {\n        this.quill.removeFormat(range.index, range.length, Quill.sources.USER);\n      }\n    },\n    direction(value) {\n      const { align } = this.quill.getFormat();\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(value) {\n      const range = this.quill.getSelection();\n      // @ts-expect-error\n      const formats = this.quill.getFormat(range);\n      // @ts-expect-error\n      const indent = parseInt(formats.indent || 0, 10);\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(value) {\n      if (value === true) {\n        value = prompt('Enter link URL:'); // eslint-disable-line no-alert\n      }\n      this.quill.format('link', value, Quill.sources.USER);\n    },\n    list(value) {\n      const range = this.quill.getSelection();\n      // @ts-expect-error\n      const 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\nexport { Toolbar as default, addControls };\n","import Quill from './core.js';\nimport type {\n  Bounds,\n  DebugLevel,\n  EmitterSource,\n  ExpandedQuillOptions,\n  QuillOptions,\n} from './core.js';\n\nimport { AlignClass, AlignStyle } from './formats/align.js';\nimport {\n  DirectionAttribute,\n  DirectionClass,\n  DirectionStyle,\n} from './formats/direction.js';\nimport Indent from './formats/indent.js';\n\nimport Blockquote from './formats/blockquote.js';\nimport Header from './formats/header.js';\nimport List from './formats/list.js';\n\nimport { BackgroundClass, BackgroundStyle } from './formats/background.js';\nimport { ColorClass, ColorStyle } from './formats/color.js';\nimport { FontClass, FontStyle } from './formats/font.js';\nimport { SizeClass, SizeStyle } from './formats/size.js';\n\nimport Bold from './formats/bold.js';\nimport Italic from './formats/italic.js';\nimport Link from './formats/link.js';\nimport Script from './formats/script.js';\nimport Strike from './formats/strike.js';\nimport Underline from './formats/underline.js';\n\n// import Formula from './formats/formula.js';\nimport Image from './formats/image.js';\nimport Video from './formats/video.js';\n\nimport CodeBlock, { Code as InlineCode } from './formats/code.js';\n\n// import Syntax from './modules/syntax.js';\n// import Table from './modules/table.js';\nimport Toolbar from './modules/toolbar.js';\n\n// import Icons from './ui/icons.js';\n// import Picker from './ui/picker.js';\n// import ColorPicker from './ui/color-picker.js';\n// import IconPicker from './ui/icon-picker.js';\n// import Tooltip from './ui/tooltip.js';\n\n// import BubbleTheme from './themes/bubble.js';\n// import SnowTheme from './themes/snow.js';\n\nQuill.register(\n  {\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  },\n  true,\n);\n\nQuill.register(\n  {\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/formula': Formula,\n    'formats/image': Image,\n    'formats/video': Video,\n\n    // 'modules/syntax': Syntax,\n    // 'modules/table': Table,\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  },\n  true,\n);\n\nexport {\n  AttributeMap,\n  Delta,\n  Module,\n  Op,\n  OpIterator,\n  Parchment,\n  Range,\n} from './core.js';\nexport type {\n  Bounds,\n  DebugLevel,\n  EmitterSource,\n  ExpandedQuillOptions,\n  QuillOptions,\n};\n\nexport default Quill;\n","import Bold from './bold.js';\n\nclass Italic extends Bold {\n  static blotName = 'italic';\n  static tagName = ['EM', 'I'];\n}\n\nexport default Italic;\n","import Bold from './bold.js';\n\nclass Strike extends Bold {\n  static blotName = 'strike';\n  static tagName = ['S', 'STRIKE'];\n}\n\nexport default Strike;\n"],"names":["root","factory","exports","module","define","amd","self","Block","BlockBlot","cache","delta","this","blot","filter","arguments","length","undefined","descendants","LeafBlot","reduce","leaf","insert","value","bubbleFormats","Delta","blockDelta","deleteAt","index","super","formatAt","name","scroll","query","Scope","BLOCK","format","Math","min","insertAt","def","lines","split","text","shift","children","tail","block","lineIndex","line","insertBefore","ref","head","Break","remove","moveChildren","target","optimize","context","path","removeChild","child","force","clone","parent","next","blotName","tagName","defaultChild","allowedChildren","Inline","EmbedBlot","TextBlot","BlockEmbed","attach","attributes","AttributorStore","domNode","formats","values","attribute","BLOCK_ATTRIBUTE","pop","blocks","map","create","forEach","statics","scope","BLOCK_BLOT","prev","Container","ContainerBlot","Cursor","static","constructor","selection","textNode","document","createTextNode","CONTENTS","appendChild","savedLength","detach","offset","node","position","data","restore","composing","range","getNativeRange","lastChild","parentNode","prevTextBlot","prevTextLength","nextTextBlot","nextText","newText","join","mergedTextBlot","newTextNode","remapOffset","start","end","startNode","startOffset","endNode","endOffset","update","mutations","some","mutation","type","isolate","unwrap","GUARD_TEXT","Embed","contentNode","createElement","setAttribute","Array","from","childNodes","childNode","leftGuard","rightGuard","prevLength","InlineBlot","Text","compare","other","selfIndex","order","indexOf","otherIndex","BLOT","wrap","entityMap","escapeText","replace","s","isLine","isUpdatable","updateContent","Scroll","ScrollBlot","registry","_ref","emitter","batch","enable","addEventListener","e","handleDragStart","batchStart","isArray","batchEnd","emitMount","emit","Emitter","events","SCROLL_BLOT_MOUNT","emitUnmount","SCROLL_BLOT_UNMOUNT","emitEmbedUpdate","change","SCROLL_EMBED_UPDATE","first","last","enabled","endsWith","slice","embed","INLINE_BLOT","wrapper","insertContents","renderBlocks","deltaToRenderBlocks","concat","shouldInsertNewlineChar","descendant","key","insertInlineContents","newlineCharLength","lineEndIndex","AttributeMap","diff","Object","keys","refBlot","refBlotOffset","find","renderBlock","createBlock","blockEmbed","isEnabled","getAttribute","Number","MAX_VALUE","getLines","blotIndex","blotLength","lengthLeft","forEachAt","childIndex","childLength","push","SCROLL_OPTIMIZE","source","sources","USER","observer","takeRecords","_ref2","SCROLL_BEFORE_UPDATE","SCROLL_UPDATE","updateEmbedAt","b","event","preventDefault","currentBlockDelta","op","splitted","INLINE","entries","_ref3","_ref4","inlineContents","Op","History","Module","delay","maxStack","userOnly","lastRecorded","ignoreChange","stack","undo","redo","currentRange","quill","options","on","Quill","EDITOR_CHANGE","eventName","oldValue","SELECTION_CHANGE","SILENT","TEXT_CHANGE","transform","record","transformRange","keyboard","addBinding","shortKey","bind","shiftKey","test","navigator","platform","inputType","dest","item","base","getContents","inverseDelta","invert","updateContents","restoreSelection","clear","cutoff","changeDelta","oldDelta","ops","undoDelta","undoRange","timestamp","Date","now","compose","transformStack","stackItem","setSelection","deleteLength","delete","changeIndex","lastOp","attr","endsWithNewlineChange","getLastChangeIndex","remoteDelta","i","oldItem","splice","transformPosition","Uploader","native","caretRangeFromPoint","clientX","clientY","caretPositionFromPoint","createRange","setStart","offsetNode","setEnd","normalized","normalizeNative","normalizedToRange","dataTransfer","files","upload","uploads","file","mimetypes","includes","handler","call","DEFAULTS","promises","Promise","resolve","reader","FileReader","onload","result","readAsDataURL","all","then","images","image","retain","INSERT_TYPES","Input","handleBeforeInput","userAgent","COMPOSITION_BEFORE_START","handleCompositionStart","deleteRange","replaceText","getFormat","composition","isComposing","defaultPrevented","staticRange","getTargetRanges","collapsed","types","getData","getPlainTextFromInputEvent","getSelection","isMac","UINode","isListening","selectionChangeDeadline","handleArrowKeys","handleNavigationShortcuts","ParentBlot","uiNode","isRTL","getComputedStyle","ctrlKey","canMoveCaretBeforeUINode","ensureListeningToSelectionChange","listener","handleSelectionChange","once","getRangeAt","startContainer","newRange","setStartAfter","setEndAfter","removeAllRanges","addRange","register","Clipboard","Keyboard","WrappedListener","EventEmitter","_events","_eventsCount","TypeError","wrappedListener","clearEvent","eventNames","Reflect","ownKeys","listeners","handlers","listenerCount","args","removeListener","wrappedListeners","removeAllListeners","off","addListener","debug","logger","EMITTERS","_len","_key","em","handleDOM","COMPOSITION_START","COMPOSITION_BEFORE_END","COMPOSITION_END","API","domListeners","error","connect","disconnect","_len2","_key2","log","_len3","_key3","composedPath","containsNode","getRootNode","contains","host","listenDOM","levels","level","method","console","namespace","ns","newLevel","ASCII","convertListHTML","items","lastIndent","endTag","getListType","indent","rest","tag","convertHTML","previousType","isRoot","html","replaceAll","match","repeat","list","parts","outerHTML","innerHTML","Element","combineFormats","combined","merged","combinedValue","normalizeDelta","normalizedDelta","shiftRange","amount","Range","getDelta","applyDelta","scrollLength","deleteDelta","splitOpLines","isImplicitNewlinePrepended","isImplicitNewlineAppended","assign","isInlineEmbed","prependedLength","addedLength","deleteText","formatLine","max","cloneDeep","formatText","leaves","lineFormats","leafFormats","blots","getHTML","lineOffset","lineLength","getText","contents","insertEmbed","insertText","isBlank","removeFormat","suffixLength","suffix","selectionInfo","textBlot","CursorBlot","oldText","relativeSelectionInfo","oldRange","isEqual","WeakMap","setupListeners","queueMicrotask","handleCompositionEnd","Node","getElementRect","element","rect","getBoundingClientRect","scaleX","abs","width","offsetWidth","scaleY","height","offsetHeight","top","right","left","clientWidth","bottom","clientHeight","paddingValueToInt","number","parseInt","isNaN","getScrollDistance","targetStart","targetEnd","scrollStart","scrollEnd","scrollPaddingStart","scrollPaddingEnd","CORE_FORMATS","globalRegistry","Parchment","uiClass","bounds","modules","clipboard","history","uploader","placeholder","readOnly","theme","parchment","Theme","limit","bubble","instances","get","import","imports","overwrite","attrName","warn","startsWith","container","containerOrSelector","resolveSelector","Error","quillModuleDefaults","quillDefaults","themeModuleDefaults","themeDefaults","userModuleOptions","expandModuleConfig","toolbar","config","omitUndefinedValuesFromOptions","createRegistryWithFormats","sourceRegistry","Registry","coreBlot","iterations","requiredContainer","modulesWithDefaults","moduleClass","expandConfig","trim","classList","add","set","addContainer","scrollBlotName","editor","Editor","Selection","Composition","addModule","init","toggle","lastRange","getRange","modify","convert","setContents","disable","allowReadOnlyEdits","refNode","className","blur","setRange","overload","editReadOnly","modifier","focus","preventScroll","scrollSelectionIntoView","hasFocus","rangeToNative","savedRange","setNativeRange","getBounds","containerBounds","getLength","getIndex","getLeaf","getLine","getModule","getSemanticHTML","scrollRectIntoView","targetRect","ownerDocument","current","isDocumentBody","body","bounding","window","visualViewport","documentElement","style","scrollDistanceX","scrollPaddingLeft","scrollPaddingRight","scrollDistanceY","scrollPaddingTop","scrollPaddingBottom","defaultView","scrollBy","scrollLeft","scrollTop","scrolledLeft","scrolledTop","parentElement","scrollIntoView","delete1","applied","delete2","setText","selector","querySelector","expanded","obj","fromEntries","entry","lengthOrSource","pos","getNativeSelection","rootNode","mouseDown","rootDocument","cursor","lastNative","handleComposition","handleDragging","setTimeout","triggeredByTyping","ignored","nativeRange","after","nextLine","side","anchorNode","getComposedRanges","ShadowRoot","info","isConnected","doc","activeElement","positions","indexes","endContainer","getPosition","inclusive","leafOffset","setBaseAndExtent","default","ModuleClass","JSON","parse","stringify","isPrimitive","obj1","obj2","whitelist","AlignAttribute","Attributor","AlignClass","ClassAttributor","AlignStyle","StyleAttributor","BackgroundClass","BackgroundStyle","ColorAttributor","CodeBlockContainer","code","innerText","CodeBlock","Code","component","toString","ColorClass","ColorStyle","DirectionAttribute","DirectionClass","DirectionStyle","FontClass","FontStyleAttributor","FontStyle","SizeClass","SizeStyle","normalWeightRegexp","blockTagNames","isBlockElement","ignoreRegexp","idRegexp","indentRegexp","NORMALIZERS","msoList","querySelectorAll","others","listItems","parseListItem","idMatch","id","indentMatch","typeRegexp","RegExp","typeMatch","parsed","childListItems","nextElementSibling","ul","listItem","li","replaceChild","normalizeListItem","fragment","createDocumentFragment","append","normalizeFontWeight","br","previousElementSibling","normalizeEmptyLines","CLIPBOARD_CONFIG","TEXT_NODE","isPre","isBetweenInlineElements","previousSibling","nextSibling","matchNewline","deltaEndsWith","ELEMENT_NODE","prototype","applyFormat","classes","styles","ATTRIBUTE","ATTRIBUTE_ATTRIBUTORS","keyName","STYLE_ATTRIBUTORS","newDelta","fontStyle","italic","textDecoration","underline","strike","fontWeight","bold","_ref5","parseFloat","textIndent","composed","checkedAttr","table","createMatchAlias","memo","matchers","onCaptureCopy","onCapturePaste","matcher","addMatcher","normalizeHTML","normalize","normalizeExternalHTML","DOMParser","parseFromString","nodeMatches","elementMatchers","textMatchers","prepareMatching","traverse","dangerouslyPasteHTML","paste","isCut","onCopy","clipboardData","setData","normalizeURIList","urlList","url","childElementCount","firstElementChild","onPaste","pastedDelta","pair","has","matches","endText","toLowerCase","preNodes","nodeType","childrenDelta","reducedDelta","_node","HTMLParagraphElement","firstChild","SHORTKEY","evt","binding","which","bindings","handleEnter","metaKey","altKey","handleBackspace","handleDelete","prefix","handleDeleteRange","listen","keyBinding","singleBinding","keyCode","leafStart","offsetStart","leafEnd","offsetEnd","prefixText","suffixText","curContext","empty","every","curFormats","prevFormats","formatDelta","nextFormats","defaultOptions","makeFormatHandler","outdent","makeCodeBlockHandler","tab","header","row","cell","getTable","_table","tableSide","blockquote","numLines","cur","makeEmbedArrowHandler","makeTableArrowHandler","TAB","textContent","up","targetRow","targetCell","targetLine","firstFormats","lastFormats","cb","mod","__create","__defProp","defineProperty","__getOwnPropDesc","getOwnPropertyDescriptor","__getOwnPropNames","getOwnPropertyNames","__getProtoOf","getPrototypeOf","__hasOwnProp","hasOwnProperty","import_fast_diff","isNodeMode","to","except","desc","__copyProps","enumerable","__esModule","__toESM","module2","DIFF_DELETE","diff_main","text1","text2","cursor_pos","cleanup","_fix_unicode","editdiff","oldLength","newLength","oldCursor","oldBefore","oldAfter","maybeNewCursor","newCursor","newBefore","newAfter","prefixLength","oldPrefix","newPrefix","make_edit_splice","oldSuffix","newSuffix","find_cursor_edit_diff","commonlength","diff_commonPrefix","commonprefix","substring","diff_commonSuffix","commonsuffix","diffs","longtext","shorttext","hm","diff_halfMatchI_","longtext2","shorttext2","best_longtext_a","best_longtext_b","best_shorttext_a","best_shorttext_b","seed","floor","j","best_common","text1_a","text1_b","text2_a","text2_b","hm1","ceil","hm2","diff_halfMatch_","mid_common","diffs_a","diffs_b","text1_length","text2_length","max_d","v_offset","v_length","v1","v2","x","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","changes","equalities","equalitiesLength","lastequality","pointer","length_insertions1","length_deletions1","length_insertions2","length_deletions2","diff_cleanupSemanticScore_","one","two","char1","char2","nonAlphaNumeric1","nonAlphaNumericRegex_","nonAlphaNumeric2","whitespace1","whitespaceRegex_","whitespace2","lineBreak1","linebreakRegex_","lineBreak2","blankLine1","blanklineEndRegex_","blankLine2","blanklineStartRegex_","equality1","edit","equality2","commonOffset","commonString","bestEquality1","bestEdit","bestEquality2","bestScore","score","diff_cleanupSemanticLossless","deletion","insertion","overlap_length1","diff_commonOverlap_","overlap_length2","diff_cleanupSemantic","y","text1a","text2a","text1b","text2b","diffsb","pointermin","pointermax","pointermid","pointerstart","is_surrogate_pair_start","charCodeAt","text_length","best","pattern","found","pointerend","is_surrogate_pair_end","fix_unicode","count_delete","count_insert","text_delete","text_insert","previous_equality","ends_with_pair_start","stray","k","starts_with_pair_end","n","charCode","str","before","oldMiddle","newMiddle","tuples","ret","remove_empty_tuples","diff2","INSERT","DELETE","EQUAL","cloneDeep_default","AttributeMap2","deepEqual_default","deepEqual","a","keepNull","copy","attrs","baseInverted","priority","AttributeMap_default","Op_default","Iterator","hasNext","peekLength","Infinity","nextOp","opLength","retOp","substr","peek","peekType","NULL_CHARACTER","String","fromCharCode","getEmbedTypeAndData","embedType","_Delta","registerEmbed","unregisterEmbed","getHandler","inverted","arg","newOp","chop","predicate","partition","passed","failed","initialValue","changeLength","elem","iter","thisIter","otherIter","firstOther","firstLeft","thisOp","otherOp","action","thisData","otherData","strings","retDelta","diffResult","eachLine","newline","baseIndex","baseOp","opData","baseOpData","transformedData","nextType","Delta_default","TYPE","LEVEL","INLINE_ATTRIBUTE","ANY","attributeBit","canAdd","removeAttribute","ParchmentError","message","tags","input","blotClass","inline","definitions","definition","isBlot","isAttr","toUpperCase","camelize","part","build","move","rawValue","cloneNode","_context","replaceWith","replacement","_force","_mutations","ShadowBlot","_domNode","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","_inclusive","LinkedList","nodes","at","iterator","curNode","callback","curIndex","curLength","makeAttachedBlot","attachUI","reverse","err","criteria","enforceAllowedChildren","done","splitAfter","childBlot","refDomNode","targetParent","_length","addedNodes","removedNodes","sort","DOCUMENT_POSITION_FOLLOWING","prop","checkMerge","_scroll","OBSERVER_CONFIG","characterData","characterDataOldValue","childList","subtree","MutationObserver","observe","mutationsMap","records","mark","markParent","remaining","grandChild","splitText","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","o","r","Symbol","toStringTag","IndentAttributor","normalizedValue","Blockquote","Header","ListContainer","ListItem","ui","listEventHandler","Bold","Link","sanitize","PROTOCOL_WHITELIST","SANITIZED_URL","protocols","anchor","href","protocol","Script","Underline","ATTRIBUTES","Image","hasAttribute","Video","video","Toolbar","groups","controls","group","control","addButton","option","addSelect","addControls","HTMLElement","addHandler","selectedIndex","selected","prompt","isActive","clean","direction","align","link","Indent","List","InlineCode"],"sourceRoot":""}