{"version":3,"file":"quill.js","mappings":"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","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/eventemitter3/index.mjs","webpack://Quill/./src/core/emitter.ts","webpack://Quill/./src/core/instances.ts","webpack://Quill/./src/core/logger.ts","webpack://Quill/./src/core/module.ts","webpack://Quill/./src/core/editor.ts","webpack://Quill/./src/core/composition.ts","webpack://Quill/./src/core/utils/scrollRectIntoView.ts","webpack://Quill/./src/core/quill.ts","webpack://Quill/./src/core/selection.ts","webpack://Quill/./src/core/theme.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/clipboard.ts","webpack://Quill/./src/modules/keyboard.ts","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/quill-delta/dist/AttributeMap.js","webpack://Quill/../../node_modules/quill-delta/dist/Delta.js","webpack://Quill/../../node_modules/quill-delta/dist/Op.js","webpack://Quill/../../node_modules/quill-delta/dist/OpIterator.js","webpack://Quill/./node_modules/eventemitter3/index.js","webpack://Quill/../../node_modules/lodash-es/_listCacheClear.js","webpack://Quill/../../node_modules/lodash-es/_assocIndexOf.js","webpack://Quill/../../node_modules/lodash-es/_listCacheDelete.js","webpack://Quill/../../node_modules/lodash-es/_ListCache.js","webpack://Quill/../../node_modules/lodash-es/_listCacheGet.js","webpack://Quill/../../node_modules/lodash-es/_listCacheHas.js","webpack://Quill/../../node_modules/lodash-es/_listCacheSet.js","webpack://Quill/../../node_modules/lodash-es/_Map.js","webpack://Quill/../../node_modules/lodash-es/_nativeCreate.js","webpack://Quill/../../node_modules/lodash-es/_hashGet.js","webpack://Quill/../../node_modules/lodash-es/_hashHas.js","webpack://Quill/../../node_modules/lodash-es/_Hash.js","webpack://Quill/../../node_modules/lodash-es/_hashClear.js","webpack://Quill/../../node_modules/lodash-es/_hashDelete.js","webpack://Quill/../../node_modules/lodash-es/_hashSet.js","webpack://Quill/../../node_modules/lodash-es/_getMapData.js","webpack://Quill/../../node_modules/lodash-es/_isKeyable.js","webpack://Quill/../../node_modules/lodash-es/_MapCache.js","webpack://Quill/../../node_modules/lodash-es/_mapCacheClear.js","webpack://Quill/../../node_modules/lodash-es/_mapCacheDelete.js","webpack://Quill/../../node_modules/lodash-es/_mapCacheGet.js","webpack://Quill/../../node_modules/lodash-es/_mapCacheHas.js","webpack://Quill/../../node_modules/lodash-es/_mapCacheSet.js","webpack://Quill/../../node_modules/lodash-es/_Stack.js","webpack://Quill/../../node_modules/lodash-es/_stackClear.js","webpack://Quill/../../node_modules/lodash-es/_stackDelete.js","webpack://Quill/../../node_modules/lodash-es/_stackGet.js","webpack://Quill/../../node_modules/lodash-es/_stackHas.js","webpack://Quill/../../node_modules/lodash-es/_stackSet.js","webpack://Quill/../../node_modules/lodash-es/_Symbol.js","webpack://Quill/../../node_modules/lodash-es/_Uint8Array.js","webpack://Quill/../../node_modules/lodash-es/_baseTimes.js","webpack://Quill/../../node_modules/lodash-es/_arrayLikeKeys.js","webpack://Quill/../../node_modules/lodash-es/_arrayPush.js","webpack://Quill/../../node_modules/lodash-es/_assignValue.js","webpack://Quill/../../node_modules/lodash-es/_baseAssignValue.js","webpack://Quill/../../node_modules/lodash-es/_baseGetAllKeys.js","webpack://Quill/../../node_modules/lodash-es/_getRawTag.js","webpack://Quill/../../node_modules/lodash-es/_objectToString.js","webpack://Quill/../../node_modules/lodash-es/_baseGetTag.js","webpack://Quill/../../node_modules/lodash-es/_baseUnary.js","webpack://Quill/../../node_modules/lodash-es/_cloneArrayBuffer.js","webpack://Quill/../../node_modules/lodash-es/_cloneBuffer.js","webpack://Quill/../../node_modules/lodash-es/_cloneTypedArray.js","webpack://Quill/../../node_modules/lodash-es/_copyArray.js","webpack://Quill/../../node_modules/lodash-es/_copyObject.js","webpack://Quill/../../node_modules/lodash-es/_defineProperty.js","webpack://Quill/../../node_modules/lodash-es/_freeGlobal.js","webpack://Quill/../../node_modules/lodash-es/_getAllKeys.js","webpack://Quill/../../node_modules/lodash-es/_isMasked.js","webpack://Quill/../../node_modules/lodash-es/_coreJsData.js","webpack://Quill/../../node_modules/lodash-es/_baseIsNative.js","webpack://Quill/../../node_modules/lodash-es/_getNative.js","webpack://Quill/../../node_modules/lodash-es/_getValue.js","webpack://Quill/../../node_modules/lodash-es/_getPrototype.js","webpack://Quill/../../node_modules/lodash-es/_arrayFilter.js","webpack://Quill/../../node_modules/lodash-es/_getSymbols.js","webpack://Quill/../../node_modules/lodash-es/_DataView.js","webpack://Quill/../../node_modules/lodash-es/_Promise.js","webpack://Quill/../../node_modules/lodash-es/_Set.js","webpack://Quill/../../node_modules/lodash-es/_WeakMap.js","webpack://Quill/../../node_modules/lodash-es/_getTag.js","webpack://Quill/../../node_modules/lodash-es/_baseCreate.js","webpack://Quill/../../node_modules/lodash-es/_initCloneObject.js","webpack://Quill/../../node_modules/lodash-es/_isIndex.js","webpack://Quill/../../node_modules/lodash-es/_isPrototype.js","webpack://Quill/../../node_modules/lodash-es/_nodeUtil.js","webpack://Quill/../../node_modules/lodash-es/_overArg.js","webpack://Quill/../../node_modules/lodash-es/_root.js","webpack://Quill/../../node_modules/lodash-es/_toSource.js","webpack://Quill/../../node_modules/lodash-es/_getSymbolsIn.js","webpack://Quill/../../node_modules/lodash-es/_getAllKeysIn.js","webpack://Quill/../../node_modules/lodash-es/_initCloneArray.js","webpack://Quill/../../node_modules/lodash-es/_cloneRegExp.js","webpack://Quill/../../node_modules/lodash-es/_cloneSymbol.js","webpack://Quill/../../node_modules/lodash-es/_initCloneByTag.js","webpack://Quill/../../node_modules/lodash-es/_cloneDataView.js","webpack://Quill/../../node_modules/lodash-es/isMap.js","webpack://Quill/../../node_modules/lodash-es/_baseIsMap.js","webpack://Quill/../../node_modules/lodash-es/isSet.js","webpack://Quill/../../node_modules/lodash-es/_baseIsSet.js","webpack://Quill/../../node_modules/lodash-es/_baseClone.js","webpack://Quill/../../node_modules/lodash-es/_copySymbolsIn.js","webpack://Quill/../../node_modules/lodash-es/_baseAssignIn.js","webpack://Quill/../../node_modules/lodash-es/_copySymbols.js","webpack://Quill/../../node_modules/lodash-es/_baseAssign.js","webpack://Quill/../../node_modules/lodash-es/_arrayEach.js","webpack://Quill/../../node_modules/lodash-es/cloneDeep.js","webpack://Quill/../../node_modules/lodash-es/eq.js","webpack://Quill/../../node_modules/lodash-es/_baseIsArguments.js","webpack://Quill/../../node_modules/lodash-es/isArguments.js","webpack://Quill/../../node_modules/lodash-es/isArray.js","webpack://Quill/../../node_modules/lodash-es/isArrayLike.js","webpack://Quill/../../node_modules/lodash-es/isBuffer.js","webpack://Quill/../../node_modules/lodash-es/stubFalse.js","webpack://Quill/../../node_modules/lodash-es/_SetCache.js","webpack://Quill/../../node_modules/lodash-es/_setCacheAdd.js","webpack://Quill/../../node_modules/lodash-es/_setCacheHas.js","webpack://Quill/../../node_modules/lodash-es/_arraySome.js","webpack://Quill/../../node_modules/lodash-es/_equalArrays.js","webpack://Quill/../../node_modules/lodash-es/_cacheHas.js","webpack://Quill/../../node_modules/lodash-es/_mapToArray.js","webpack://Quill/../../node_modules/lodash-es/_setToArray.js","webpack://Quill/../../node_modules/lodash-es/_equalByTag.js","webpack://Quill/../../node_modules/lodash-es/_equalObjects.js","webpack://Quill/../../node_modules/lodash-es/_baseIsEqualDeep.js","webpack://Quill/../../node_modules/lodash-es/_baseIsEqual.js","webpack://Quill/../../node_modules/lodash-es/isEqual.js","webpack://Quill/../../node_modules/lodash-es/isFunction.js","webpack://Quill/../../node_modules/lodash-es/isLength.js","webpack://Quill/../../node_modules/lodash-es/isObject.js","webpack://Quill/../../node_modules/lodash-es/isObjectLike.js","webpack://Quill/../../node_modules/lodash-es/_baseIsTypedArray.js","webpack://Quill/../../node_modules/lodash-es/isTypedArray.js","webpack://Quill/../../node_modules/lodash-es/_nativeKeys.js","webpack://Quill/../../node_modules/lodash-es/_baseKeys.js","webpack://Quill/../../node_modules/lodash-es/keys.js","webpack://Quill/../../node_modules/lodash-es/_baseKeysIn.js","webpack://Quill/../../node_modules/lodash-es/_nativeKeysIn.js","webpack://Quill/../../node_modules/lodash-es/keysIn.js","webpack://Quill/../../node_modules/lodash-es/_shortOut.js","webpack://Quill/../../node_modules/lodash-es/_createAssigner.js","webpack://Quill/../../node_modules/lodash-es/_assignMergeValue.js","webpack://Quill/../../node_modules/lodash-es/_baseFor.js","webpack://Quill/../../node_modules/lodash-es/_createBaseFor.js","webpack://Quill/../../node_modules/lodash-es/isPlainObject.js","webpack://Quill/../../node_modules/lodash-es/_safeGet.js","webpack://Quill/../../node_modules/lodash-es/_baseMergeDeep.js","webpack://Quill/../../node_modules/lodash-es/isArrayLikeObject.js","webpack://Quill/../../node_modules/lodash-es/toPlainObject.js","webpack://Quill/../../node_modules/lodash-es/_baseMerge.js","webpack://Quill/../../node_modules/lodash-es/identity.js","webpack://Quill/../../node_modules/lodash-es/_overRest.js","webpack://Quill/../../node_modules/lodash-es/_baseSetToString.js","webpack://Quill/../../node_modules/lodash-es/constant.js","webpack://Quill/../../node_modules/lodash-es/_setToString.js","webpack://Quill/../../node_modules/lodash-es/_baseRest.js","webpack://Quill/../../node_modules/lodash-es/_apply.js","webpack://Quill/../../node_modules/lodash-es/merge.js","webpack://Quill/../../node_modules/lodash-es/_isIterateeCall.js","webpack://Quill/../../node_modules/lodash-es/stubArray.js","webpack://Quill/../../node_modules/parchment/dist/parchment.mjs","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/make namespace object","webpack://Quill/webpack/runtime/node module decorator","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/formula.ts","webpack://Quill/./src/formats/image.ts","webpack://Quill/./src/formats/video.ts","webpack://Quill/./src/modules/syntax.ts","webpack://Quill/./src/formats/table.ts","webpack://Quill/./src/modules/table.ts","webpack://Quill/./src/modules/toolbar.ts","webpack://Quill/./src/ui/icons.ts","webpack://Quill/./src/ui/picker.ts","webpack://Quill/./src/ui/color-picker.ts","webpack://Quill/./src/ui/icon-picker.ts","webpack://Quill/./src/ui/tooltip.ts","webpack://Quill/./src/themes/base.ts","webpack://Quill/./src/themes/bubble.ts","webpack://Quill/./src/themes/snow.ts","webpack://Quill/./src/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';\nimport Break from './break';\nimport Inline from './inline';\nimport TextBlot from './text';\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    // @ts-expect-error Parchment types are wrong\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      // @ts-expect-error Fix me later\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      // @ts-expect-error Fix me later\n      this.parent.insertBefore(block, ref);\n    });\n    if (text) {\n      // @ts-expect-error Fix me later\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';\nimport TextBlot from './text';\nimport type { EmbedContextRange } from './embed';\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';\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        // @ts-expect-error Fix me later\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';\nimport Text from './text';\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\nfunction escapeText(text: string) {\n  return text.replace(/[&<>\"']/g, (s) => {\n    // https://lodash.com/docs#escape\n    const entityMap: Record<string, string> = {\n      '&': '&amp;',\n      '<': '&lt;',\n      '>': '&gt;',\n      '\"': '&quot;',\n      \"'\": '&#39;',\n    };\n    return entityMap[s];\n  });\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';\nimport Emitter from '../core/emitter';\nimport type { EmitterSource } from '../core/emitter';\nimport Block, { BlockEmbed } from './block';\nimport Break from './break';\nimport Container from './container';\nimport { bubbleFormats } from './block';\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) {\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';\nimport Module from '../core/module';\nimport Quill from '../core/quill';\nimport type Scroll from '../blots/scroll';\nimport type { Range } from '../core/selection';\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\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}\nHistory.DEFAULTS = {\n  delay: 1000,\n  maxStack: 100,\n  userOnly: false,\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';\nimport type Quill from '../core/quill';\nimport Emitter from '../core/emitter';\nimport Module from '../core/module';\nimport type { Range } from '../core/selection';\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    const promises = files.map((file) => {\n      return new Promise((resolve) => {\n        const reader = new FileReader();\n        reader.onload = (e) => {\n          // @ts-expect-error Fix me later\n          resolve(e.target.result);\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';\nimport Module from '../core/module';\nimport Quill from '../core/quill';\nimport type { Range } from '../core/selection';\nimport { deleteRange } from './keyboard';\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';\nimport Quill from '../core/quill';\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 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';\nimport Uploader from './modules/uploader';\nimport Delta, { Op, OpIterator, AttributeMap } from 'quill-delta';\nimport Input from './modules/input';\nimport UINode from './modules/uiNode';\n\nexport { Delta, Op, OpIterator, AttributeMap };\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","import EventEmitter from './index.js'\n\nexport { EventEmitter }\nexport default EventEmitter\n","import EventEmitter from 'eventemitter3';\nimport instances from './instances';\nimport logger from './logger';\n\nconst debug = logger('quill:events');\nconst EVENTS = ['selectionchange', 'mousedown', 'mouseup', 'click'];\n\nEVENTS.forEach((eventName) => {\n  document.addEventListener(eventName, (...args) => {\n    Array.from(document.querySelectorAll('.ql-container')).forEach((node) => {\n      const quill = instances.get(node);\n      if (quill && quill.emitter) {\n        quill.emitter.handleDOM(...args);\n      }\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  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    (this.domListeners[event.type] || []).forEach(({ node, handler }) => {\n      if (event.target === node || node.contains(event.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","import type Quill from '../core';\n\nexport default new WeakMap<Node, Quill>();\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';\n\nabstract class Module<T extends {} = {}> {\n  static DEFAULTS = {};\n\n  constructor(\n    protected quill: Quill,\n    protected options: Partial<T> = {},\n  ) {}\n}\n\nexport default Module;\n","import { cloneDeep, isEqual, merge } from 'lodash-es';\nimport { LeafBlot, EmbedBlot, Scope, ParentBlot } from 'parchment';\nimport type { Blot } from 'parchment';\nimport Delta, { AttributeMap, Op } from 'quill-delta';\nimport Block, { BlockEmbed, bubbleFormats } from '../blots/block';\nimport Break from '../blots/break';\nimport CursorBlot from '../blots/cursor';\nimport type Scroll from '../blots/scroll';\nimport TextBlot, { escapeText } from '../blots/text';\nimport { Range } from './selection';\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 = merge({}, bubbleFormats(line));\n          if (line instanceof Block) {\n            const [leaf] = line.descendant(LeafBlot, offset);\n            if (leaf) {\n              formats = merge(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 = merge({}, 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      if (line.length() >= lineOffset + length) {\n        const excludeOuterTag = !(lineOffset === 0 && length === lineLength);\n        return convertHTML(line, lineOffset, length, excludeOuterTag);\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  excludeOuterTag = 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    return escapeText(blot.value().slice(index, index + length));\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 (excludeOuterTag || 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 Embed from '../blots/embed';\nimport type Scroll from '../blots/scroll';\nimport Emitter from './emitter';\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 { cloneDeep, merge } from 'lodash-es';\nimport * as Parchment from 'parchment';\nimport type { Op } from 'quill-delta';\nimport Delta from 'quill-delta';\nimport type { BlockEmbed } from '../blots/block';\nimport type Block from '../blots/block';\nimport type Scroll from '../blots/scroll';\nimport type Clipboard from '../modules/clipboard';\nimport type History from '../modules/history';\nimport type Keyboard from '../modules/keyboard';\nimport type Uploader from '../modules/uploader';\nimport Editor from './editor';\nimport Emitter from './emitter';\nimport type { EmitterSource } from './emitter';\nimport instances from './instances';\nimport logger from './logger';\nimport type { DebugLevel } from './logger';\nimport Module from './module';\nimport Selection, { Range } from './selection';\nimport type { Bounds } from './selection';\nimport Composition from './composition';\nimport Theme from './theme';\nimport type { ThemeConstructor } from './theme';\nimport scrollRectIntoView from './utils/scrollRectIntoView';\nimport type { Rect } from './utils/scrollRectIntoView';\n\nconst debug = logger('quill');\n\nconst globalRegistry = new Parchment.Registry();\nParchment.ParentBlot.uiClass = 'ql-ui';\n\ninterface Options {\n  theme?: string;\n  debug?: DebugLevel | boolean;\n  registry?: Parchment.Registry;\n  readOnly?: boolean;\n  container?: HTMLElement | string;\n  placeholder?: string;\n  bounds?: HTMLElement | string | null;\n  modules?: Record<string, unknown>;\n}\n\ninterface ExpandedOptions extends Omit<Options, 'theme'> {\n  theme: ThemeConstructor;\n  registry: Parchment.Registry;\n  container: HTMLElement;\n  modules: Record<string, unknown>;\n  bounds?: HTMLElement | null;\n}\n\nclass Quill {\n  static DEFAULTS: Partial<Options> = {\n    bounds: null,\n    modules: {},\n    placeholder: '',\n    readOnly: false,\n    registry: globalRegistry,\n    theme: 'default',\n  };\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    path:\n      | string\n      | Parchment.BlotConstructor\n      | Parchment.Attributor\n      | Record<string, unknown>,\n    target?: Parchment.BlotConstructor | Parchment.Attributor | boolean,\n    overwrite = false,\n  ) {\n    if (typeof path !== 'string') {\n      const name = 'attrName' in path ? path.attrName : path.blotName;\n      if (typeof name === 'string') {\n        // register(Blot | Attributor, overwrite)\n        // @ts-expect-error\n        this.register(`formats/${name}`, path, target);\n      } else {\n        Object.keys(path).forEach((key) => {\n          // @ts-expect-error\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 (\n        (path.startsWith('blots/') || path.startsWith('formats/')) &&\n        target &&\n        typeof target !== 'boolean' &&\n        // @ts-expect-error\n        target.blotName !== 'abstract'\n      ) {\n        globalRegistry.register(target);\n      }\n      // @ts-expect-error\n      if (typeof target.register === 'function') {\n        // @ts-expect-error\n        target.register(globalRegistry);\n      }\n    }\n  }\n\n  container: HTMLElement;\n  root: HTMLDivElement;\n  scroll: Scroll;\n  emitter: Emitter;\n  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: ExpandedOptions;\n\n  constructor(container: HTMLElement | string, options: Options = {}) {\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        // @ts-expect-error\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  ) {\n    return modify.call(\n      this,\n      () => {\n        const range = this.getSelection(true);\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: { index: number; length: number },\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 | { index: number; length: number },\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        // @ts-expect-error\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?: { index: number; length: number }): {\n    [format: string]: unknown;\n  };\n  getFormat(\n    index: { index: number; length: number } | 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: { index: number; length: number }): (Block | BlockEmbed)[];\n  getLines(index?: number, length?: number): (Block | BlockEmbed)[];\n  getLines(\n    index: { index: number; length: number } | 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: { index: number; length: number }): string;\n  getSemanticHTML(index?: number, length?: number): string;\n  getSemanticHTML(\n    index: { index: number; length: number } | number = 0,\n    length?: number,\n  ) {\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?: { index: number; length: number }): string;\n  getText(index?: number, length?: number): string;\n  getText(\n    index: { index: number; length: number } | number = 0,\n    length?: number,\n  ): 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  ) {\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  // @ts-expect-error\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(...args: Parameters<typeof overload>) {\n    const [index, length, , source] = overload(...args);\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  ) {\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  ) {\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 expandConfig(\n  container: HTMLElement | string,\n  userConfig: Options,\n): ExpandedOptions {\n  // @ts-expect-error -- TODO fix this later\n  let expandedConfig: ExpandedOptions = merge(\n    {\n      container,\n      modules: {\n        clipboard: true,\n        keyboard: true,\n        history: true,\n        uploader: true,\n      },\n    },\n    userConfig,\n  );\n\n  // @ts-expect-error -- TODO fix this later\n  if (!expandedConfig.theme || expandedConfig.theme === Quill.DEFAULTS.theme) {\n    expandedConfig.theme = Theme;\n  } else {\n    expandedConfig.theme = Quill.import(`themes/${expandedConfig.theme}`);\n    if (expandedConfig.theme == null) {\n      throw new Error(\n        `Invalid theme ${expandedConfig.theme}. Did you register it?`,\n      );\n    }\n  }\n  // @ts-expect-error -- TODO fix this later\n  const themeConfig = cloneDeep(expandedConfig.theme.DEFAULTS);\n  [themeConfig, expandedConfig].forEach((config) => {\n    config.modules = config.modules || {};\n    Object.keys(config.modules).forEach((module) => {\n      if (config.modules[module] === true) {\n        config.modules[module] = {};\n      }\n    });\n  });\n  const moduleNames = Object.keys(themeConfig.modules).concat(\n    Object.keys(expandedConfig.modules),\n  );\n  const moduleConfig = moduleNames.reduce((config, name) => {\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    } else {\n      // @ts-expect-error\n      config[name] = moduleClass.DEFAULTS || {};\n    }\n    return config;\n  }, {});\n  // Special case toolbar shorthand\n  if (\n    expandedConfig.modules != null &&\n    expandedConfig.modules.toolbar &&\n    expandedConfig.modules.toolbar.constructor !== Object\n  ) {\n    expandedConfig.modules.toolbar = {\n      container: expandedConfig.modules.toolbar,\n    };\n  }\n  expandedConfig = merge(\n    {},\n    Quill.DEFAULTS,\n    { modules: moduleConfig },\n    themeConfig,\n    expandedConfig,\n  );\n  (['bounds', 'container'] as const).forEach((key) => {\n    const selector = expandedConfig[key];\n    if (typeof selector === 'string') {\n      // @ts-expect-error Handle null case\n      expandedConfig[key] = document.querySelector(selector) as HTMLElement;\n    }\n  });\n  expandedConfig.modules = Object.keys(expandedConfig.modules).reduce(\n    (config: Record<string, unknown>, name) => {\n      if (expandedConfig.modules[name]) {\n        config[name] = expandedConfig.modules[name];\n      }\n      return config;\n    },\n    {},\n  );\n  return expandedConfig;\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 { globalRegistry, expandConfig, overload, Quill as default };\n","import { LeafBlot, Scope } from 'parchment';\nimport { cloneDeep, isEqual } from 'lodash-es';\nimport Emitter from './emitter';\nimport type { EmitterSource } from './emitter';\nimport logger from './logger';\nimport type Cursor from '../blots/cursor';\nimport type Scroll from '../blots/scroll';\n\nconst debug = logger('quill:selection');\n\ntype NativeRange = AbstractRange;\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\nclass 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  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    // @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', 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, () => {\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        // @ts-expect-error Fix me later\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    [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    const selection = document.getSelection();\n    if (selection == null || selection.rangeCount <= 0) return null;\n    const nativeRange = selection.getRangeAt(0);\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    return (\n      document.activeElement === this.root ||\n      (document.activeElement != null &&\n        contains(this.root, document.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 = document.getSelection();\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        const range = document.createRange();\n        // @ts-expect-error Fix me later\n        range.setStart(startNode, startOffset);\n        // @ts-expect-error Fix me later\n        range.setEnd(endNode, endOffset);\n        selection.removeAllRanges();\n        selection.addRange(range);\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 { Range, Selection as default };\n","import type Quill from '../core';\nimport type Clipboard from '../modules/clipboard';\nimport type History from '../modules/history';\nimport type Keyboard from '../modules/keyboard';\nimport type { ToolbarProps } from '../modules/toolbar';\nimport type Uploader from '../modules/uploader';\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}\n\nexport default Theme;\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';\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';\nimport Break from '../blots/break';\nimport Cursor from '../blots/cursor';\nimport Inline from '../blots/inline';\nimport TextBlot, { escapeText } from '../blots/text';\nimport Container from '../blots/container';\nimport Quill from '../core/quill';\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","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';\nimport { BlockEmbed } from '../blots/block';\nimport type { EmitterSource } from '../core/emitter';\nimport logger from '../core/logger';\nimport Module from '../core/module';\nimport Quill from '../core/quill';\nimport type { Range } from '../core/selection';\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';\nimport { deleteRange } from './keyboard';\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', matchAlias.bind(matchAlias, 'bold')],\n  ['i', matchAlias.bind(matchAlias, 'italic')],\n  ['strike', matchAlias.bind(matchAlias, '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\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    // @ts-expect-error Fix me later\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  convertHTML(html: string) {\n    const doc = new DOMParser().parseFromString(html, 'text/html');\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  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    const text = e.clipboardData?.getData('text/plain');\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}\nClipboard.DEFAULTS = {\n  matchers: [],\n};\n\nfunction applyFormat(delta: Delta, formats: Record<string, unknown>): Delta;\nfunction applyFormat(delta: Delta, format: string, value: unknown): Delta;\nfunction applyFormat(\n  delta: Delta,\n  format: string | Record<string, unknown>,\n  value?: unknown,\n): Delta {\n  if (typeof format === 'object') {\n    return Object.keys(format).reduce((newDelta, key) => {\n      return applyFormat(newDelta, key, format[key]);\n    }, delta);\n  }\n  return delta.reduce((newDelta, op) => {\n    if (op.attributes && op.attributes[format]) {\n      return newDelta.push(op);\n    }\n    const formats = value ? { [format]: value } : {};\n    // @ts-expect-error Fix me later\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: Element) {\n  if (node.childNodes.length === 0) return false; // Exclude embed blocks\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\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 matchAlias(format: string, node: Element, delta: Delta) {\n  return applyFormat(delta, format, true);\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  if (Object.keys(formats).length > 0) {\n    return applyFormat(delta, formats);\n  }\n  return delta;\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    // @ts-expect-error\n    if (typeof match.formats === 'function') {\n      // @ts-expect-error\n      return applyFormat(delta, match.blotName, match.formats(node, scroll));\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  // @ts-expect-error\n  const language = match ? match.formats(node, scroll) : true;\n  return applyFormat(delta, 'code-block', language);\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.attributes && typeof op.attributes.indent === 'number') {\n      return composed.push(op);\n    }\n    // @ts-expect-error Fix me later\n    return composed.insert(op.insert, { indent, ...(op.attributes || {}) });\n  }, new Delta());\n}\n\nfunction matchList(node: Node, delta: Delta) {\n  // @ts-expect-error\n  const list = node.tagName === 'OL' ? 'ordered' : 'bullet';\n  return applyFormat(delta, 'list', list);\n}\n\nfunction matchNewline(node: Node, delta: Delta, scroll: ScrollBlot) {\n  if (!deltaEndsWith(delta, '\\n')) {\n    // @ts-expect-error\n    if (isLine(node)) {\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        // @ts-expect-error\n        if (isLine(nextSibling)) {\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) {\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  if (Object.keys(formats).length > 0) {\n    delta = applyFormat(delta, formats);\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(node: HTMLTableRowElement, delta: Delta) {\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);\n  }\n}\n\nfunction matchText(node: HTMLElement, delta: Delta) {\n  // @ts-expect-error\n  let text = node.data;\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 (text.trim().length === 0 && text.includes('\\n')) {\n      return delta;\n    }\n    const replacer = (collapse: unknown, match: string) => {\n      const replaced = match.replace(/[^\\u00a0]/g, ''); // \\u00a0 is nbsp;\n      return replaced.length < 1 && collapse ? ' ' : replaced;\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 (\n      (node.previousSibling == null &&\n        node.parentElement != null &&\n        isLine(node.parentElement)) ||\n      (node.previousSibling instanceof Element && isLine(node.previousSibling))\n    ) {\n      text = text.replace(/^\\s+/, replacer.bind(replacer, false));\n    }\n    if (\n      (node.nextSibling == null &&\n        node.parentElement != null &&\n        isLine(node.parentElement)) ||\n      (node.nextSibling instanceof Element && isLine(node.nextSibling))\n    ) {\n      text = text.replace(/\\s+$/, replacer.bind(replacer, false));\n    }\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 { cloneDeep, isEqual } from 'lodash-es';\nimport Delta, { AttributeMap } from 'quill-delta';\nimport { EmbedBlot, Scope, TextBlot } from 'parchment';\nimport type { Blot, BlockBlot } from 'parchment';\nimport Quill from '../core/quill';\nimport logger from '../core/logger';\nimport Module from '../core/module';\nimport type { BlockEmbed } from '../blots/block';\nimport type { Range } from '../core/selection';\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      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 = cloneDeep(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","/**\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 * 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 * 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 * @param {boolean} [cleanup] Apply semantic cleanup before returning.\n * @return {Array} Array of diff tuples.\n */\nfunction diff_main(text1, text2, cursor_pos, cleanup, _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  if (cleanup) {\n    diff_cleanupSemantic(diffs);\n  }\n  return diffs;\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 [\n      [DIFF_DELETE, text1],\n      [DIFF_INSERT, text2],\n    ];\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 * 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 &&\n        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 &&\n        y2 < text2_length &&\n        text1.charAt(text1_length - x2 - 1) ===\n          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 [\n    [DIFF_DELETE, text1],\n    [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 * 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 * Determine if the suffix of one string is the prefix of another.\n * @param {string} text1 First string.\n * @param {string} text2 Second string.\n * @return {number} The number of characters common to the end of the first\n *     string and the start of the second string.\n * @private\n */\nfunction diff_commonOverlap_(text1, text2) {\n  // Cache the text lengths to prevent multiple calls.\n  var text1_length = text1.length;\n  var text2_length = text2.length;\n  // Eliminate the null case.\n  if (text1_length == 0 || text2_length == 0) {\n    return 0;\n  }\n  // Truncate the longer string.\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  // Quick check for the worst case.\n  if (text1 == text2) {\n    return text_length;\n  }\n\n  // Start by looking for a single character match\n  // and increase length until no match is found.\n  // Performance analysis: http://neil.fraser.name/news/2010/11/04/\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 (\n      found == 0 ||\n      text1.substring(text_length - length) == text2.substring(0, length)\n    ) {\n      best = length;\n      length++;\n    }\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 * 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),\n        shorttext.substring(j)\n      );\n      var suffixLength = diff_commonSuffix(\n        longtext.substring(0, i),\n        shorttext.substring(0, j)\n      );\n      if (best_common.length < suffixLength + prefixLength) {\n        best_common =\n          shorttext.substring(j - suffixLength, j) +\n          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,\n        best_longtext_b,\n        best_shorttext_a,\n        best_shorttext_b,\n        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_(\n    longtext,\n    shorttext,\n    Math.ceil(longtext.length / 4)\n  );\n  // Check again based on the third quarter.\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    // 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 * Reduce the number of edits by eliminating semantically trivial equalities.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n */\nfunction diff_cleanupSemantic(diffs) {\n  var changes = false;\n  var equalities = []; // Stack of indices where equalities are found.\n  var equalitiesLength = 0; // Keeping our own length var is faster in JS.\n  /** @type {?string} */\n  var lastequality = null;\n  // Always equal to diffs[equalities[equalitiesLength - 1]][1]\n  var pointer = 0; // Index of current position.\n  // Number of characters that changed prior to the equality.\n  var length_insertions1 = 0;\n  var length_deletions1 = 0;\n  // Number of characters that changed after the equality.\n  var length_insertions2 = 0;\n  var length_deletions2 = 0;\n  while (pointer < diffs.length) {\n    if (diffs[pointer][0] == DIFF_EQUAL) {\n      // Equality found.\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      // An insertion or deletion.\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      // Eliminate an equality that is smaller or equal to the edits on both\n      // sides of it.\n      if (\n        lastequality &&\n        lastequality.length <=\n          Math.max(length_insertions1, length_deletions1) &&\n        lastequality.length <= Math.max(length_insertions2, length_deletions2)\n      ) {\n        // Duplicate record.\n        diffs.splice(equalities[equalitiesLength - 1], 0, [\n          DIFF_DELETE,\n          lastequality,\n        ]);\n        // Change second copy to insert.\n        diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;\n        // Throw away the equality we just deleted.\n        equalitiesLength--;\n        // Throw away the previous equality (it needs to be reevaluated).\n        equalitiesLength--;\n        pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;\n        length_insertions1 = 0; // Reset the counters.\n        length_deletions1 = 0;\n        length_insertions2 = 0;\n        length_deletions2 = 0;\n        lastequality = null;\n        changes = true;\n      }\n    }\n    pointer++;\n  }\n\n  // Normalize the diff.\n  if (changes) {\n    diff_cleanupMerge(diffs);\n  }\n  diff_cleanupSemanticLossless(diffs);\n\n  // Find any overlaps between deletions and insertions.\n  // e.g: <del>abcxxx</del><ins>xxxdef</ins>\n  //   -> <del>abc</del>xxx<ins>def</ins>\n  // e.g: <del>xxxabc</del><ins>defxxx</ins>\n  //   -> <ins>def</ins>xxx<del>abc</del>\n  // Only extract an overlap if it is as big as the edit ahead or behind it.\n  pointer = 1;\n  while (pointer < diffs.length) {\n    if (\n      diffs[pointer - 1][0] == DIFF_DELETE &&\n      diffs[pointer][0] == DIFF_INSERT\n    ) {\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 (\n          overlap_length1 >= deletion.length / 2 ||\n          overlap_length1 >= insertion.length / 2\n        ) {\n          // Overlap found.  Insert an equality and trim the surrounding edits.\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 (\n          overlap_length2 >= deletion.length / 2 ||\n          overlap_length2 >= insertion.length / 2\n        ) {\n          // Reverse overlap found.\n          // Insert an equality and swap and trim the surrounding edits.\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\nvar nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;\nvar whitespaceRegex_ = /\\s/;\nvar linebreakRegex_ = /[\\r\\n]/;\nvar blanklineEndRegex_ = /\\n\\r?\\n$/;\nvar blanklineStartRegex_ = /^\\r?\\n\\r?\\n/;\n\n/**\n * Look for single edits surrounded on both sides by equalities\n * which can be shifted sideways to align the edit to a word boundary.\n * e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.\n * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n */\nfunction diff_cleanupSemanticLossless(diffs) {\n  /**\n   * Given two strings, compute a score representing whether the internal\n   * boundary falls on logical boundaries.\n   * Scores range from 6 (best) to 0 (worst).\n   * Closure, but does not reference any external variables.\n   * @param {string} one First string.\n   * @param {string} two Second string.\n   * @return {number} The score.\n   * @private\n   */\n  function diff_cleanupSemanticScore_(one, two) {\n    if (!one || !two) {\n      // Edges are the best.\n      return 6;\n    }\n\n    // Each port of this function behaves slightly differently due to\n    // subtle differences in each language's definition of things like\n    // 'whitespace'.  Since this function's purpose is largely cosmetic,\n    // the choice has been made to use each language's native features\n    // rather than force total conformity.\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\n    if (blankLine1 || blankLine2) {\n      // Five points for blank lines.\n      return 5;\n    } else if (lineBreak1 || lineBreak2) {\n      // Four points for line breaks.\n      return 4;\n    } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {\n      // Three points for end of sentences.\n      return 3;\n    } else if (whitespace1 || whitespace2) {\n      // Two points for whitespace.\n      return 2;\n    } else if (nonAlphaNumeric1 || nonAlphaNumeric2) {\n      // One point for non-alphanumeric.\n      return 1;\n    }\n    return 0;\n  }\n\n  var pointer = 1;\n  // Intentionally ignore the first and last element (don't need checking).\n  while (pointer < diffs.length - 1) {\n    if (\n      diffs[pointer - 1][0] == DIFF_EQUAL &&\n      diffs[pointer + 1][0] == DIFF_EQUAL\n    ) {\n      // This is a single edit surrounded by equalities.\n      var equality1 = diffs[pointer - 1][1];\n      var edit = diffs[pointer][1];\n      var equality2 = diffs[pointer + 1][1];\n\n      // First, shift the edit as far left as possible.\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\n      // Second, step character by character right, looking for the best fit.\n      var bestEquality1 = equality1;\n      var bestEdit = edit;\n      var bestEquality2 = equality2;\n      var bestScore =\n        diff_cleanupSemanticScore_(equality1, edit) +\n        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 =\n          diff_cleanupSemanticScore_(equality1, edit) +\n          diff_cleanupSemanticScore_(edit, equality2);\n        // The >= encourages trailing rather than leading whitespace on edits.\n        if (score >= bestScore) {\n          bestScore = score;\n          bestEquality1 = equality1;\n          bestEdit = edit;\n          bestEquality2 = equality2;\n        }\n      }\n\n      if (diffs[pointer - 1][1] != bestEquality1) {\n        // We have an improvement, save it back to the diff.\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\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        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 (\n            previous_equality >= 0 &&\n            ends_with_pair_start(diffs[previous_equality][1])\n          ) {\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              // 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(\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            // 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) +\n                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          // 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(\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          // 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 (\n      diffs[pointer - 1][0] === DIFF_EQUAL &&\n      diffs[pointer + 1][0] === DIFF_EQUAL\n    ) {\n      // This is a single edit surrounded by equalities.\n      if (\n        diffs[pointer][1].substring(\n          diffs[pointer][1].length - diffs[pointer - 1][1].length\n        ) === diffs[pointer - 1][1]\n      ) {\n        // Shift the edit over the previous equality.\n        diffs[pointer][1] =\n          diffs[pointer - 1][1] +\n          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 (\n        diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==\n        diffs[pointer + 1][1]\n      ) {\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 =\n    typeof cursor_pos === \"number\"\n      ? { index: cursor_pos, length: 0 }\n      : cursor_pos.oldRange;\n  var newRange = typeof cursor_pos === \"number\" ? 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, cleanup) {\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, cleanup, 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","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst cloneDeep = require(\"lodash.clonedeep\");\nconst isEqual = require(\"lodash.isequal\");\nvar AttributeMap;\n(function (AttributeMap) {\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(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] !== undefined && b[key] === undefined) {\n                attributes[key] = a[key];\n            }\n        }\n        return Object.keys(attributes).length > 0 ? attributes : undefined;\n    }\n    AttributeMap.compose = compose;\n    function diff(a = {}, b = {}) {\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((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    AttributeMap.diff = diff;\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] !== undefined) {\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] === undefined) {\n                memo[key] = null;\n            }\n            return memo;\n        }, baseInverted);\n    }\n    AttributeMap.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 undefined;\n        }\n        if (!priority) {\n            return b; // b simply overwrites us without priority\n        }\n        const attributes = Object.keys(b).reduce((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    AttributeMap.transform = transform;\n})(AttributeMap || (AttributeMap = {}));\nexports.default = AttributeMap;\n//# sourceMappingURL=AttributeMap.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AttributeMap = exports.OpIterator = exports.Op = void 0;\nconst diff = require(\"fast-diff\");\nconst cloneDeep = require(\"lodash.clonedeep\");\nconst isEqual = require(\"lodash.isequal\");\nconst AttributeMap_1 = require(\"./AttributeMap\");\nexports.AttributeMap = AttributeMap_1.default;\nconst Op_1 = require(\"./Op\");\nexports.Op = Op_1.default;\nconst OpIterator_1 = require(\"./OpIterator\");\nexports.OpIterator = OpIterator_1.default;\nconst NULL_CHARACTER = String.fromCharCode(0); // Placeholder char for embed in diff()\nconst 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};\nclass Delta {\n    constructor(ops) {\n        // Assume we are given a well formed ops\n        if (Array.isArray(ops)) {\n            this.ops = ops;\n        }\n        else if (ops != null && Array.isArray(ops.ops)) {\n            this.ops = ops.ops;\n        }\n        else {\n            this.ops = [];\n        }\n    }\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    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 &&\n            typeof attributes === 'object' &&\n            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 &&\n            typeof attributes === 'object' &&\n            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(newOp);\n        if (typeof lastOp === 'object') {\n            if (typeof newOp.delete === 'number' &&\n                typeof lastOp.delete === 'number') {\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 (typeof newOp.insert === 'string' &&\n                    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                }\n                else if (typeof newOp.retain === 'number' &&\n                    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        }\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_1.default.length(elem);\n            }\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_1.default.length(elem);\n        }, 0);\n    }\n    slice(start = 0, end = Infinity) {\n        const ops = [];\n        const iter = new OpIterator_1.default(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            }\n            else {\n                nextOp = iter.next(end - index);\n                ops.push(nextOp);\n            }\n            index += Op_1.default.length(nextOp);\n        }\n        return new Delta(ops);\n    }\n    compose(other) {\n        const thisIter = new OpIterator_1.default(this.ops);\n        const otherIter = new OpIterator_1.default(other.ops);\n        const ops = [];\n        const firstOther = otherIter.peek();\n        if (firstOther != null &&\n            typeof firstOther.retain === 'number' &&\n            firstOther.attributes == null) {\n            let firstLeft = firstOther.retain;\n            while (thisIter.peekType() === 'insert' &&\n                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            }\n            else if (thisIter.peekType() === 'delete') {\n                delta.push(thisIter.next());\n            }\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 =\n                            typeof otherOp.retain === 'number' ? length : otherOp.retain;\n                    }\n                    else {\n                        if (typeof otherOp.retain === 'number') {\n                            if (thisOp.retain == null) {\n                                newOp.insert = thisOp.insert;\n                            }\n                            else {\n                                newOp.retain = thisOp.retain;\n                            }\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                    // Preserve null when composing with a retain, otherwise remove it for inserts\n                    const attributes = AttributeMap_1.default.compose(thisOp.attributes, otherOp.attributes, typeof thisOp.retain === 'number');\n                    if (attributes) {\n                        newOp.attributes = attributes;\n                    }\n                    delta.push(newOp);\n                    // Optimization if rest of other is just retain\n                    if (!otherIter.hasNext() &&\n                        isEqual(delta.ops[delta.ops.length - 1], newOp)) {\n                        const rest = new Delta(thisIter.rest());\n                        return delta.concat(rest).chop();\n                    }\n                    // Other op should be delete, we could be an insert or retain\n                    // Insert + delete cancels out\n                }\n                else if (typeof otherOp.delete === 'number' &&\n                    (typeof thisOp.retain === 'number' ||\n                        (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\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, true);\n        const thisIter = new OpIterator_1.default(this.ops);\n        const otherIter = new OpIterator_1.default(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 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(thisIter.peekLength(), otherIter.peekLength(), length);\n                        const thisOp = thisIter.next(opLength);\n                        const otherOp = otherIter.next(opLength);\n                        if (isEqual(thisOp.insert, otherOp.insert)) {\n                            retDelta.retain(opLength, AttributeMap_1.default.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    eachLine(predicate, newline = '\\n') {\n        const iter = new OpIterator_1.default(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_1.default.length(thisOp) - iter.peekLength();\n            const index = typeof thisOp.insert === 'string'\n                ? thisOp.insert.indexOf(newline, start) - start\n                : -1;\n            if (index < 0) {\n                line.push(iter.next());\n            }\n            else if (index > 0) {\n                line.push(iter.next(index));\n            }\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_1.default.length(op));\n            }\n            else if (typeof op.retain === 'number' && op.attributes == null) {\n                inverted.retain(op.retain);\n                return baseIndex + op.retain;\n            }\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                    }\n                    else if (op.retain && op.attributes) {\n                        inverted.retain(Op_1.default.length(baseOp), AttributeMap_1.default.invert(op.attributes, baseOp.attributes));\n                    }\n                });\n                return baseIndex + length;\n            }\n            else if (typeof op.retain === 'object' && op.retain !== null) {\n                const slice = base.slice(baseIndex, baseIndex + 1);\n                const baseOp = new OpIterator_1.default(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_1.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 OpIterator_1.default(this.ops);\n        const otherIter = new OpIterator_1.default(other.ops);\n        const delta = new Delta();\n        while (thisIter.hasNext() || otherIter.hasNext()) {\n            if (thisIter.peekType() === 'insert' &&\n                (priority || otherIter.peekType() !== 'insert')) {\n                delta.retain(Op_1.default.length(thisIter.next()));\n            }\n            else if (otherIter.peekType() === 'insert') {\n                delta.push(otherIter.next());\n            }\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                }\n                else if (otherOp.delete) {\n                    delta.push(otherOp);\n                }\n                else {\n                    const thisData = thisOp.retain;\n                    const otherData = otherOp.retain;\n                    let transformedData = typeof otherData === 'object' && otherData !== null\n                        ? otherData\n                        : length;\n                    if (typeof thisData === 'object' &&\n                        thisData !== null &&\n                        typeof otherData === 'object' &&\n                        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                    // We retain either their retain or insert\n                    delta.retain(transformedData, AttributeMap_1.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 OpIterator_1.default(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            }\n            else if (nextType === 'insert' && (offset < index || !priority)) {\n                index += length;\n            }\n            offset += length;\n        }\n        return index;\n    }\n}\nDelta.Op = Op_1.default;\nDelta.OpIterator = OpIterator_1.default;\nDelta.AttributeMap = AttributeMap_1.default;\nDelta.handlers = {};\nexports.default = Delta;\nif (typeof module === 'object') {\n    module.exports = Delta;\n    module.exports.default = Delta;\n}\n//# sourceMappingURL=Delta.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Op;\n(function (Op) {\n    function length(op) {\n        if (typeof op.delete === 'number') {\n            return op.delete;\n        }\n        else if (typeof op.retain === 'number') {\n            return op.retain;\n        }\n        else if (typeof op.retain === 'object' && op.retain !== null) {\n            return 1;\n        }\n        else {\n            return typeof op.insert === 'string' ? op.insert.length : 1;\n        }\n    }\n    Op.length = length;\n})(Op || (Op = {}));\nexports.default = Op;\n//# sourceMappingURL=Op.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst Op_1 = require(\"./Op\");\nclass Iterator {\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_1.default.length(nextOp);\n            if (length >= opLength - offset) {\n                length = opLength - offset;\n                this.index += 1;\n                this.offset = 0;\n            }\n            else {\n                this.offset += length;\n            }\n            if (typeof nextOp.delete === 'number') {\n                return { delete: length };\n            }\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                }\n                else if (typeof nextOp.retain === 'object' &&\n                    nextOp.retain !== null) {\n                    // offset should === 0, length should === 1\n                    retOp.retain = nextOp.retain;\n                }\n                else if (typeof nextOp.insert === 'string') {\n                    retOp.insert = nextOp.insert.substr(offset, length);\n                }\n                else {\n                    // offset should === 0, length should === 1\n                    retOp.insert = nextOp.insert;\n                }\n                return retOp;\n            }\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            // Should never return 0 if our index is being managed correctly\n            return Op_1.default.length(this.ops[this.index]) - this.offset;\n        }\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            }\n            else if (typeof op.retain === 'number' ||\n                (typeof op.retain === 'object' && op.retain !== null)) {\n                return 'retain';\n            }\n            else {\n                return 'insert';\n            }\n        }\n        return 'retain';\n    }\n    rest() {\n        if (!this.hasNext()) {\n            return [];\n        }\n        else if (this.offset === 0) {\n            return this.ops.slice(this.index);\n        }\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}\nexports.default = Iterator;\n//# sourceMappingURL=OpIterator.js.map","'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 * @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 {*} 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 * @private\n */\nfunction EE(fn, context, once) {\n  this.fn = fn;\n  this.context = context;\n  this.once = once || false;\n}\n\n/**\n * Add a listener for a given event.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} once Specify if the listener is a one-time listener.\n * @returns {EventEmitter}\n * @private\n */\nfunction addListener(emitter, event, fn, context, once) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('The listener must be a function');\n  }\n\n  var listener = new EE(fn, context || emitter, once)\n    , evt = prefix ? prefix + event : event;\n\n  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;\n  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);\n  else emitter._events[evt] = [emitter._events[evt], listener];\n\n  return emitter;\n}\n\n/**\n * Clear event by name.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} evt The Event name.\n * @private\n */\nfunction clearEvent(emitter, evt) {\n  if (--emitter._eventsCount === 0) emitter._events = new Events();\n  else delete emitter._events[evt];\n}\n\n/**\n * Minimal `EventEmitter` interface that is molded against the Node.js\n * `EventEmitter` interface.\n *\n * @constructor\n * @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 * @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 * @returns {Array} The registered listeners.\n * @public\n */\nEventEmitter.prototype.listeners = function listeners(event) {\n  var evt = prefix ? prefix + event : event\n    , handlers = this._events[evt];\n\n  if (!handlers) return [];\n  if (handlers.fn) return [handlers.fn];\n\n  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {\n    ee[i] = handlers[i].fn;\n  }\n\n  return ee;\n};\n\n/**\n * Return the number of listeners listening to a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Number} The number of listeners.\n * @public\n */\nEventEmitter.prototype.listenerCount = function listenerCount(event) {\n  var evt = prefix ? prefix + event : event\n    , listeners = this._events[evt];\n\n  if (!listeners) return 0;\n  if (listeners.fn) return 1;\n  return listeners.length;\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 * @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 {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.on = function on(event, fn, context) {\n  return addListener(this, event, fn, context, false);\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 {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.once = function once(event, fn, context) {\n  return addListener(this, event, fn, context, true);\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 {*} context Only remove the listeners that have this context.\n * @param {Boolean} once Only remove one-time listeners.\n * @returns {EventEmitter} `this`.\n * @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    clearEvent(this, 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      clearEvent(this, 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 clearEvent(this, 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 * @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]) clearEvent(this, evt);\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// 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 * 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\nexport default listCacheClear;\n","import eq from './eq.js';\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\nexport default assocIndexOf;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\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\nexport default listCacheDelete;\n","import listCacheClear from './_listCacheClear.js';\nimport listCacheDelete from './_listCacheDelete.js';\nimport listCacheGet from './_listCacheGet.js';\nimport listCacheHas from './_listCacheHas.js';\nimport listCacheSet from './_listCacheSet.js';\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// 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\nexport default ListCache;\n","import assocIndexOf from './_assocIndexOf.js';\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\nexport default listCacheGet;\n","import assocIndexOf from './_assocIndexOf.js';\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\nexport default listCacheHas;\n","import assocIndexOf from './_assocIndexOf.js';\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\nexport default listCacheSet;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nexport default Map;\n","import getNative from './_getNative.js';\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nexport default nativeCreate;\n","import nativeCreate from './_nativeCreate.js';\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\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\nexport default hashGet;\n","import nativeCreate from './_nativeCreate.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\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\nexport default hashHas;\n","import hashClear from './_hashClear.js';\nimport hashDelete from './_hashDelete.js';\nimport hashGet from './_hashGet.js';\nimport hashHas from './_hashHas.js';\nimport hashSet from './_hashSet.js';\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// 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\nexport default Hash;\n","import nativeCreate from './_nativeCreate.js';\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\nexport default hashClear;\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\nexport default hashDelete;\n","import nativeCreate from './_nativeCreate.js';\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\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\nexport default hashSet;\n","import isKeyable from './_isKeyable.js';\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\nexport default getMapData;\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\nexport default isKeyable;\n","import mapCacheClear from './_mapCacheClear.js';\nimport mapCacheDelete from './_mapCacheDelete.js';\nimport mapCacheGet from './_mapCacheGet.js';\nimport mapCacheHas from './_mapCacheHas.js';\nimport mapCacheSet from './_mapCacheSet.js';\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// 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\nexport default MapCache;\n","import Hash from './_Hash.js';\nimport ListCache from './_ListCache.js';\nimport Map from './_Map.js';\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\nexport default mapCacheClear;\n","import getMapData from './_getMapData.js';\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\nexport default mapCacheDelete;\n","import getMapData from './_getMapData.js';\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\nexport default mapCacheGet;\n","import getMapData from './_getMapData.js';\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\nexport default mapCacheHas;\n","import getMapData from './_getMapData.js';\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\nexport default mapCacheSet;\n","import ListCache from './_ListCache.js';\nimport stackClear from './_stackClear.js';\nimport stackDelete from './_stackDelete.js';\nimport stackGet from './_stackGet.js';\nimport stackHas from './_stackHas.js';\nimport stackSet from './_stackSet.js';\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// 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\nexport default Stack;\n","import ListCache from './_ListCache.js';\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\nexport default stackClear;\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\nexport default stackDelete;\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\nexport default stackGet;\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\nexport default stackHas;\n","import ListCache from './_ListCache.js';\nimport Map from './_Map.js';\nimport MapCache from './_MapCache.js';\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\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\nexport default stackSet;\n","import root from './_root.js';\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nexport default Symbol;\n","import root from './_root.js';\n\n/** Built-in value references. */\nvar Uint8Array = root.Uint8Array;\n\nexport default Uint8Array;\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\nexport default baseTimes;\n","import baseTimes from './_baseTimes.js';\nimport isArguments from './isArguments.js';\nimport isArray from './isArray.js';\nimport isBuffer from './isBuffer.js';\nimport isIndex from './_isIndex.js';\nimport isTypedArray from './isTypedArray.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\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\nexport default arrayLikeKeys;\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\nexport default arrayPush;\n","import baseAssignValue from './_baseAssignValue.js';\nimport eq from './eq.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\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\nexport default assignValue;\n","import defineProperty from './_defineProperty.js';\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\nexport default baseAssignValue;\n","import arrayPush from './_arrayPush.js';\nimport isArray from './isArray.js';\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\nexport default baseGetAllKeys;\n","import Symbol from './_Symbol.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\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 nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\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\nexport default getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\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/**\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\nexport default objectToString;\n","import Symbol from './_Symbol.js';\nimport getRawTag from './_getRawTag.js';\nimport objectToString from './_objectToString.js';\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\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\nexport default baseGetTag;\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\nexport default baseUnary;\n","import Uint8Array from './_Uint8Array.js';\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\nexport default cloneArrayBuffer;\n","import root from './_root.js';\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/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;\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\nexport default cloneBuffer;\n","import cloneArrayBuffer from './_cloneArrayBuffer.js';\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\nexport default cloneTypedArray;\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\nexport default copyArray;\n","import assignValue from './_assignValue.js';\nimport baseAssignValue from './_baseAssignValue.js';\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\nexport default copyObject;\n","import getNative from './_getNative.js';\n\nvar defineProperty = (function() {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\nexport default defineProperty;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nexport default freeGlobal;\n","import baseGetAllKeys from './_baseGetAllKeys.js';\nimport getSymbols from './_getSymbols.js';\nimport keys from './keys.js';\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\nexport default getAllKeys;\n","import coreJsData from './_coreJsData.js';\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 * 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\nexport default isMasked;\n","import root from './_root.js';\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nexport default coreJsData;\n","import isFunction from './isFunction.js';\nimport isMasked from './_isMasked.js';\nimport isObject from './isObject.js';\nimport toSource from './_toSource.js';\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 for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\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 if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\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\nexport default baseIsNative;\n","import baseIsNative from './_baseIsNative.js';\nimport getValue from './_getValue.js';\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\nexport default getNative;\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\nexport default getValue;\n","import overArg from './_overArg.js';\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nexport default getPrototype;\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\nexport default arrayFilter;\n","import arrayFilter from './_arrayFilter.js';\nimport stubArray from './stubArray.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\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\nexport default getSymbols;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView');\n\nexport default DataView;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar Promise = getNative(root, 'Promise');\n\nexport default Promise;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar Set = getNative(root, 'Set');\n\nexport default Set;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar WeakMap = getNative(root, 'WeakMap');\n\nexport default WeakMap;\n","import DataView from './_DataView.js';\nimport Map from './_Map.js';\nimport Promise from './_Promise.js';\nimport Set from './_Set.js';\nimport WeakMap from './_WeakMap.js';\nimport baseGetTag from './_baseGetTag.js';\nimport toSource from './_toSource.js';\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]',\n    objectTag = '[object Object]',\n    promiseTag = '[object Promise]',\n    setTag = '[object Set]',\n    weakMapTag = '[object WeakMap]';\n\nvar dataViewTag = '[object DataView]';\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/**\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\nexport default getTag;\n","import isObject from './isObject.js';\n\n/** Built-in value references. */\nvar objectCreate = 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\nexport default baseCreate;\n","import baseCreate from './_baseCreate.js';\nimport getPrototype from './_getPrototype.js';\nimport isPrototype from './_isPrototype.js';\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\nexport default initCloneObject;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\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\nexport default isIndex;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\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\nexport default isPrototype;\n","import freeGlobal from './_freeGlobal.js';\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\nexport default nodeUtil;\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\nexport default overArg;\n","import freeGlobal from './_freeGlobal.js';\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\nexport default root;\n","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\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\nexport default toSource;\n","import arrayPush from './_arrayPush.js';\nimport getPrototype from './_getPrototype.js';\nimport getSymbols from './_getSymbols.js';\nimport stubArray from './stubArray.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own and inherited 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 getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n  var result = [];\n  while (object) {\n    arrayPush(result, getSymbols(object));\n    object = getPrototype(object);\n  }\n  return result;\n};\n\nexport default getSymbolsIn;\n","import baseGetAllKeys from './_baseGetAllKeys.js';\nimport getSymbolsIn from './_getSymbolsIn.js';\nimport keysIn from './keysIn.js';\n\n/**\n * Creates an array of own and inherited enumerable property names and\n * 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 getAllKeysIn(object) {\n  return baseGetAllKeys(object, keysIn, getSymbolsIn);\n}\n\nexport default getAllKeysIn;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\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 = new 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\nexport default initCloneArray;\n","/** Used to match `RegExp` flags from their coerced string values. */\nvar reFlags = /\\w*$/;\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\nexport default cloneRegExp;\n","import Symbol from './_Symbol.js';\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 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\nexport default cloneSymbol;\n","import cloneArrayBuffer from './_cloneArrayBuffer.js';\nimport cloneDataView from './_cloneDataView.js';\nimport cloneRegExp from './_cloneRegExp.js';\nimport cloneSymbol from './_cloneSymbol.js';\nimport cloneTypedArray from './_cloneTypedArray.js';\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]';\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 * Initializes an object clone based on its `toStringTag`.\n *\n * **Note:** This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, 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 {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneByTag(object, tag, 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 new Ctor;\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 new Ctor;\n\n    case symbolTag:\n      return cloneSymbol(object);\n  }\n}\n\nexport default initCloneByTag;\n","import cloneArrayBuffer from './_cloneArrayBuffer.js';\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\nexport default cloneDataView;\n","import baseIsMap from './_baseIsMap.js';\nimport baseUnary from './_baseUnary.js';\nimport nodeUtil from './_nodeUtil.js';\n\n/* Node.js helper references. */\nvar nodeIsMap = nodeUtil && nodeUtil.isMap;\n\n/**\n * Checks if `value` is classified as a `Map` object.\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 map, else `false`.\n * @example\n *\n * _.isMap(new Map);\n * // => true\n *\n * _.isMap(new WeakMap);\n * // => false\n */\nvar isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n\nexport default isMap;\n","import getTag from './_getTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]';\n\n/**\n * The base implementation of `_.isMap` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n */\nfunction baseIsMap(value) {\n  return isObjectLike(value) && getTag(value) == mapTag;\n}\n\nexport default baseIsMap;\n","import baseIsSet from './_baseIsSet.js';\nimport baseUnary from './_baseUnary.js';\nimport nodeUtil from './_nodeUtil.js';\n\n/* Node.js helper references. */\nvar nodeIsSet = nodeUtil && nodeUtil.isSet;\n\n/**\n * Checks if `value` is classified as a `Set` object.\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 set, else `false`.\n * @example\n *\n * _.isSet(new Set);\n * // => true\n *\n * _.isSet(new WeakSet);\n * // => false\n */\nvar isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n\nexport default isSet;\n","import getTag from './_getTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar setTag = '[object Set]';\n\n/**\n * The base implementation of `_.isSet` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n */\nfunction baseIsSet(value) {\n  return isObjectLike(value) && getTag(value) == setTag;\n}\n\nexport default baseIsSet;\n","import Stack from './_Stack.js';\nimport arrayEach from './_arrayEach.js';\nimport assignValue from './_assignValue.js';\nimport baseAssign from './_baseAssign.js';\nimport baseAssignIn from './_baseAssignIn.js';\nimport cloneBuffer from './_cloneBuffer.js';\nimport copyArray from './_copyArray.js';\nimport copySymbols from './_copySymbols.js';\nimport copySymbolsIn from './_copySymbolsIn.js';\nimport getAllKeys from './_getAllKeys.js';\nimport getAllKeysIn from './_getAllKeysIn.js';\nimport getTag from './_getTag.js';\nimport initCloneArray from './_initCloneArray.js';\nimport initCloneByTag from './_initCloneByTag.js';\nimport initCloneObject from './_initCloneObject.js';\nimport isArray from './isArray.js';\nimport isBuffer from './isBuffer.js';\nimport isMap from './isMap.js';\nimport isObject from './isObject.js';\nimport isSet from './isSet.js';\nimport keys from './keys.js';\nimport keysIn from './keysIn.js';\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n    CLONE_FLAT_FLAG = 2,\n    CLONE_SYMBOLS_FLAG = 4;\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    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/** 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/**\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} bitmask The bitmask flags.\n *  1 - Deep clone\n *  2 - Flatten inherited properties\n *  4 - Clone 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, bitmask, customizer, key, object, stack) {\n  var result,\n      isDeep = bitmask & CLONE_DEEP_FLAG,\n      isFlat = bitmask & CLONE_FLAT_FLAG,\n      isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\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      result = (isFlat || isFunc) ? {} : initCloneObject(value);\n      if (!isDeep) {\n        return isFlat\n          ? copySymbolsIn(value, baseAssignIn(result, value))\n          : copySymbols(value, baseAssign(result, value));\n      }\n    } else {\n      if (!cloneableTags[tag]) {\n        return object ? value : {};\n      }\n      result = initCloneByTag(value, tag, 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 (isSet(value)) {\n    value.forEach(function(subValue) {\n      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));\n    });\n  } else if (isMap(value)) {\n    value.forEach(function(subValue, key) {\n      result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));\n    });\n  }\n\n  var keysFunc = isFull\n    ? (isFlat ? getAllKeysIn : getAllKeys)\n    : (isFlat ? keysIn : keys);\n\n  var props = isArr ? undefined : keysFunc(value);\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, bitmask, customizer, key, value, stack));\n  });\n  return result;\n}\n\nexport default baseClone;\n","import copyObject from './_copyObject.js';\nimport getSymbolsIn from './_getSymbolsIn.js';\n\n/**\n * Copies own and inherited symbols 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 copySymbolsIn(source, object) {\n  return copyObject(source, getSymbolsIn(source), object);\n}\n\nexport default copySymbolsIn;\n","import copyObject from './_copyObject.js';\nimport keysIn from './keysIn.js';\n\n/**\n * The base implementation of `_.assignIn` 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 baseAssignIn(object, source) {\n  return object && copyObject(source, keysIn(source), object);\n}\n\nexport default baseAssignIn;\n","import copyObject from './_copyObject.js';\nimport getSymbols from './_getSymbols.js';\n\n/**\n * Copies own symbols 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\nexport default copySymbols;\n","import copyObject from './_copyObject.js';\nimport keys from './keys.js';\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\nexport default baseAssign;\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 == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (iteratee(array[index], index, array) === false) {\n      break;\n    }\n  }\n  return array;\n}\n\nexport default arrayEach;\n","import baseClone from './_baseClone.js';\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n    CLONE_SYMBOLS_FLAG = 4;\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, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n}\n\nexport default cloneDeep;\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\nexport default eq;\n","import baseGetTag from './_baseGetTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\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\nexport default baseIsArguments;\n","import baseIsArguments from './_baseIsArguments.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\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\nexport default isArguments;\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\nexport default isArray;\n","import isFunction from './isFunction.js';\nimport isLength from './isLength.js';\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\nexport default isArrayLike;\n","import root from './_root.js';\nimport stubFalse from './stubFalse.js';\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/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\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\nexport default isBuffer;\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\nexport default stubFalse;\n","import MapCache from './_MapCache.js';\nimport setCacheAdd from './_setCacheAdd.js';\nimport setCacheHas from './_setCacheHas.js';\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// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\nexport default SetCache;\n","/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\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\nexport default setCacheAdd;\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\nexport default setCacheHas;\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\nexport default arraySome;\n","import SetCache from './_SetCache.js';\nimport arraySome from './_arraySome.js';\nimport cacheHas from './_cacheHas.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\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  // Check that cyclic values are equal.\n  var arrStacked = stack.get(array);\n  var othStacked = stack.get(other);\n  if (arrStacked && othStacked) {\n    return arrStacked == other && othStacked == array;\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\nexport default equalArrays;\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\nexport default cacheHas;\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\nexport default mapToArray;\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\nexport default setToArray;\n","import Symbol from './_Symbol.js';\nimport Uint8Array from './_Uint8Array.js';\nimport eq from './eq.js';\nimport equalArrays from './_equalArrays.js';\nimport mapToArray from './_mapToArray.js';\nimport setToArray from './_setToArray.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]';\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 * 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\nexport default equalByTag;\n","import getAllKeys from './_getAllKeys.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\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  // Check that cyclic values are equal.\n  var objStacked = stack.get(object);\n  var othStacked = stack.get(other);\n  if (objStacked && othStacked) {\n    return objStacked == other && othStacked == object;\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\nexport default equalObjects;\n","import Stack from './_Stack.js';\nimport equalArrays from './_equalArrays.js';\nimport equalByTag from './_equalByTag.js';\nimport equalObjects from './_equalObjects.js';\nimport getTag from './_getTag.js';\nimport isArray from './isArray.js';\nimport isBuffer from './isBuffer.js';\nimport isTypedArray from './isTypedArray.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\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\nexport default baseIsEqualDeep;\n","import baseIsEqualDeep from './_baseIsEqualDeep.js';\nimport isObjectLike from './isObjectLike.js';\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\nexport default baseIsEqual;\n","import baseIsEqual from './_baseIsEqual.js';\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\nexport default isEqual;\n","import baseGetTag from './_baseGetTag.js';\nimport isObject from './isObject.js';\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\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\nexport default isFunction;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\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\nexport default isLength;\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\nexport default isObject;\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\nexport default isObjectLike;\n","import baseGetTag from './_baseGetTag.js';\nimport isLength from './isLength.js';\nimport isObjectLike from './isObjectLike.js';\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    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\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/** 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/**\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\nexport default baseIsTypedArray;\n","import baseIsTypedArray from './_baseIsTypedArray.js';\nimport baseUnary from './_baseUnary.js';\nimport nodeUtil from './_nodeUtil.js';\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\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\nexport default isTypedArray;\n","import overArg from './_overArg.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object);\n\nexport default nativeKeys;\n","import isPrototype from './_isPrototype.js';\nimport nativeKeys from './_nativeKeys.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\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\nexport default baseKeys;\n","import arrayLikeKeys from './_arrayLikeKeys.js';\nimport baseKeys from './_baseKeys.js';\nimport isArrayLike from './isArrayLike.js';\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\nexport default keys;\n","import isObject from './isObject.js';\nimport isPrototype from './_isPrototype.js';\nimport nativeKeysIn from './_nativeKeysIn.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\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\nexport default baseKeysIn;\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\nexport default nativeKeysIn;\n","import arrayLikeKeys from './_arrayLikeKeys.js';\nimport baseKeysIn from './_baseKeysIn.js';\nimport isArrayLike from './isArrayLike.js';\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\nexport default keysIn;\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/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeNow = Date.now;\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\nexport default shortOut;\n","import baseRest from './_baseRest.js';\nimport isIterateeCall from './_isIterateeCall.js';\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\nexport default createAssigner;\n","import baseAssignValue from './_baseAssignValue.js';\nimport eq from './eq.js';\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\nexport default assignMergeValue;\n","import createBaseFor from './_createBaseFor.js';\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\nexport default baseFor;\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\nexport default createBaseFor;\n","import baseGetTag from './_baseGetTag.js';\nimport getPrototype from './_getPrototype.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\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 infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\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\nexport default isPlainObject;\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\nexport default safeGet;\n","import assignMergeValue from './_assignMergeValue.js';\nimport cloneBuffer from './_cloneBuffer.js';\nimport cloneTypedArray from './_cloneTypedArray.js';\nimport copyArray from './_copyArray.js';\nimport initCloneObject from './_initCloneObject.js';\nimport isArguments from './isArguments.js';\nimport isArray from './isArray.js';\nimport isArrayLikeObject from './isArrayLikeObject.js';\nimport isBuffer from './isBuffer.js';\nimport isFunction from './isFunction.js';\nimport isObject from './isObject.js';\nimport isPlainObject from './isPlainObject.js';\nimport isTypedArray from './isTypedArray.js';\nimport safeGet from './_safeGet.js';\nimport toPlainObject from './toPlainObject.js';\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\nexport default baseMergeDeep;\n","import isArrayLike from './isArrayLike.js';\nimport isObjectLike from './isObjectLike.js';\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\nexport default isArrayLikeObject;\n","import copyObject from './_copyObject.js';\nimport keysIn from './keysIn.js';\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\nexport default toPlainObject;\n","import Stack from './_Stack.js';\nimport assignMergeValue from './_assignMergeValue.js';\nimport baseFor from './_baseFor.js';\nimport baseMergeDeep from './_baseMergeDeep.js';\nimport isObject from './isObject.js';\nimport keysIn from './keysIn.js';\nimport safeGet from './_safeGet.js';\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\nexport default baseMerge;\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\nexport default identity;\n","import apply from './_apply.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\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\nexport default overRest;\n","import constant from './constant.js';\nimport defineProperty from './_defineProperty.js';\nimport identity from './identity.js';\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\nexport default baseSetToString;\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\nexport default constant;\n","import baseSetToString from './_baseSetToString.js';\nimport shortOut from './_shortOut.js';\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\nexport default setToString;\n","import identity from './identity.js';\nimport overRest from './_overRest.js';\nimport setToString from './_setToString.js';\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\nexport default baseRest;\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\nexport default apply;\n","import baseMerge from './_baseMerge.js';\nimport createAssigner from './_createAssigner.js';\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\nexport default merge;\n","import eq from './eq.js';\nimport isArrayLike from './isArrayLike.js';\nimport isIndex from './_isIndex.js';\nimport isObject from './isObject.js';\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\nexport default isIterateeCall;\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\nexport default stubArray;\n","var l = /* @__PURE__ */ ((a) => (a[a.TYPE = 3] = \"TYPE\", a[a.LEVEL = 12] = \"LEVEL\", a[a.ATTRIBUTE = 13] = \"ATTRIBUTE\", a[a.BLOT = 14] = \"BLOT\", a[a.INLINE = 7] = \"INLINE\", a[a.BLOCK = 11] = \"BLOCK\", a[a.BLOCK_BLOT = 10] = \"BLOCK_BLOT\", a[a.INLINE_BLOT = 6] = \"INLINE_BLOT\", a[a.BLOCK_ATTRIBUTE = 9] = \"BLOCK_ATTRIBUTE\", a[a.INLINE_ATTRIBUTE = 5] = \"INLINE_ATTRIBUTE\", a[a.ANY = 15] = \"ANY\", a))(l || {});\nclass b {\n  constructor(t, e, s = {}) {\n    this.attrName = t, this.keyName = e;\n    const r = l.TYPE & l.ATTRIBUTE;\n    this.scope = s.scope != null ? (\n      // Ignore type bits, force attribute bit\n      s.scope & l.LEVEL | r\n    ) : l.ATTRIBUTE, s.whitelist != null && (this.whitelist = s.whitelist);\n  }\n  static keys(t) {\n    return Array.from(t.attributes).map((e) => e.name);\n  }\n  add(t, e) {\n    return this.canAdd(t, e) ? (t.setAttribute(this.keyName, e), !0) : !1;\n  }\n  canAdd(t, e) {\n    return this.whitelist == null ? !0 : typeof e == \"string\" ? this.whitelist.indexOf(e.replace(/[\"']/g, \"\")) > -1 : this.whitelist.indexOf(e) > -1;\n  }\n  remove(t) {\n    t.removeAttribute(this.keyName);\n  }\n  value(t) {\n    const e = t.getAttribute(this.keyName);\n    return this.canAdd(t, e) && e ? e : \"\";\n  }\n}\nclass N extends Error {\n  constructor(t) {\n    t = \"[Parchment] \" + t, super(t), this.message = t, this.name = this.constructor.name;\n  }\n}\nconst g = class g {\n  constructor() {\n    this.attributes = {}, this.classes = {}, this.tags = {}, this.types = {};\n  }\n  static find(t, e = !1) {\n    if (t == null)\n      return null;\n    if (this.blots.has(t))\n      return this.blots.get(t) || null;\n    if (e) {\n      let s = null;\n      try {\n        s = t.parentNode;\n      } catch {\n        return null;\n      }\n      return this.find(s, e);\n    }\n    return null;\n  }\n  create(t, e, s) {\n    const r = this.query(e);\n    if (r == null)\n      throw new N(`Unable to create ${e} blot`);\n    const i = r, h = (\n      // @ts-expect-error Fix me later\n      e instanceof Node || e.nodeType === Node.TEXT_NODE ? e : i.create(s)\n    ), n = new i(t, h, s);\n    return g.blots.set(n.domNode, n), n;\n  }\n  find(t, e = !1) {\n    return g.find(t, e);\n  }\n  query(t, e = l.ANY) {\n    let s;\n    return typeof t == \"string\" ? s = this.types[t] || this.attributes[t] : t instanceof Text || t.nodeType === Node.TEXT_NODE ? s = this.types.text : typeof t == \"number\" ? t & l.LEVEL & l.BLOCK ? s = this.types.block : t & l.LEVEL & l.INLINE && (s = this.types.inline) : t instanceof Element && ((t.getAttribute(\"class\") || \"\").split(/\\s+/).some((i) => (s = this.classes[i], !!s)), s = s || this.tags[t.tagName]), s == null ? null : \"scope\" in s && e & l.LEVEL & s.scope && e & l.TYPE & s.scope ? s : null;\n  }\n  register(...t) {\n    return t.map((e) => {\n      const s = \"blotName\" in e, r = \"attrName\" in e;\n      if (!s && !r)\n        throw new N(\"Invalid definition\");\n      if (s && e.blotName === \"abstract\")\n        throw new N(\"Cannot register abstract class\");\n      const i = s ? e.blotName : r ? e.attrName : void 0;\n      return this.types[i] = e, r ? typeof e.keyName == \"string\" && (this.attributes[e.keyName] = e) : s && (e.className && (this.classes[e.className] = e), e.tagName && (Array.isArray(e.tagName) ? e.tagName = e.tagName.map((n) => n.toUpperCase()) : e.tagName = e.tagName.toUpperCase(), (Array.isArray(e.tagName) ? e.tagName : [e.tagName]).forEach((n) => {\n        (this.tags[n] == null || e.className == null) && (this.tags[n] = e);\n      }))), e;\n    });\n  }\n};\ng.blots = /* @__PURE__ */ new WeakMap();\nlet y = g;\nfunction M(a, t) {\n  return (a.getAttribute(\"class\") || \"\").split(/\\s+/).filter((s) => s.indexOf(`${t}-`) === 0);\n}\nclass K extends b {\n  static keys(t) {\n    return (t.getAttribute(\"class\") || \"\").split(/\\s+/).map((e) => e.split(\"-\").slice(0, -1).join(\"-\"));\n  }\n  add(t, e) {\n    return this.canAdd(t, e) ? (this.remove(t), t.classList.add(`${this.keyName}-${e}`), !0) : !1;\n  }\n  remove(t) {\n    M(t, this.keyName).forEach((s) => {\n      t.classList.remove(s);\n    }), t.classList.length === 0 && t.removeAttribute(\"class\");\n  }\n  value(t) {\n    const s = (M(t, this.keyName)[0] || \"\").slice(this.keyName.length + 1);\n    return this.canAdd(t, s) ? s : \"\";\n  }\n}\nfunction x(a) {\n  const t = a.split(\"-\"), e = t.slice(1).map((s) => s[0].toUpperCase() + s.slice(1)).join(\"\");\n  return t[0] + e;\n}\nclass Y extends b {\n  static keys(t) {\n    return (t.getAttribute(\"style\") || \"\").split(\";\").map((e) => e.split(\":\")[0].trim());\n  }\n  add(t, e) {\n    return this.canAdd(t, e) ? (t.style[x(this.keyName)] = e, !0) : !1;\n  }\n  remove(t) {\n    t.style[x(this.keyName)] = \"\", t.getAttribute(\"style\") || t.removeAttribute(\"style\");\n  }\n  value(t) {\n    const e = t.style[x(this.keyName)];\n    return this.canAdd(t, e) ? e : \"\";\n  }\n}\nclass D {\n  constructor(t) {\n    this.attributes = {}, this.domNode = t, this.build();\n  }\n  attribute(t, e) {\n    e ? t.add(this.domNode, e) && (t.value(this.domNode) != null ? this.attributes[t.attrName] = t : delete this.attributes[t.attrName]) : (t.remove(this.domNode), delete this.attributes[t.attrName]);\n  }\n  build() {\n    this.attributes = {};\n    const t = y.find(this.domNode);\n    if (t == null)\n      return;\n    const e = b.keys(this.domNode), s = K.keys(this.domNode), r = Y.keys(this.domNode);\n    e.concat(s).concat(r).forEach((i) => {\n      const h = t.scroll.query(i, l.ATTRIBUTE);\n      h instanceof b && (this.attributes[h.attrName] = h);\n    });\n  }\n  copy(t) {\n    Object.keys(this.attributes).forEach((e) => {\n      const s = this.attributes[e].value(this.domNode);\n      t.format(e, s);\n    });\n  }\n  move(t) {\n    this.copy(t), Object.keys(this.attributes).forEach((e) => {\n      this.attributes[e].remove(this.domNode);\n    }), this.attributes = {};\n  }\n  values() {\n    return Object.keys(this.attributes).reduce(\n      (t, e) => (t[e] = this.attributes[e].value(this.domNode), t),\n      {}\n    );\n  }\n}\nconst k = class k {\n  constructor(t, e) {\n    this.scroll = t, this.domNode = e, y.blots.set(e, this), this.prev = null, this.next = null;\n  }\n  static create(t) {\n    if (this.tagName == null)\n      throw new N(\"Blot definition missing tagName\");\n    let e, s;\n    return Array.isArray(this.tagName) ? (typeof t == \"string\" ? (s = t.toUpperCase(), parseInt(s, 10).toString() === s && (s = parseInt(s, 10))) : typeof t == \"number\" && (s = t), typeof s == \"number\" ? e = document.createElement(this.tagName[s - 1]) : s && this.tagName.indexOf(s) > -1 ? e = document.createElement(s) : e = document.createElement(this.tagName[0])) : e = document.createElement(this.tagName), this.className && e.classList.add(this.className), e;\n  }\n  // Hack for accessing inherited static methods\n  get statics() {\n    return this.constructor;\n  }\n  attach() {\n  }\n  clone() {\n    const t = this.domNode.cloneNode(!1);\n    return this.scroll.create(t);\n  }\n  detach() {\n    this.parent != null && this.parent.removeChild(this), y.blots.delete(this.domNode);\n  }\n  deleteAt(t, e) {\n    this.isolate(t, e).remove();\n  }\n  formatAt(t, e, s, r) {\n    const i = this.isolate(t, e);\n    if (this.scroll.query(s, l.BLOT) != null && r)\n      i.wrap(s, r);\n    else if (this.scroll.query(s, l.ATTRIBUTE) != null) {\n      const h = this.scroll.create(this.statics.scope);\n      i.wrap(h), h.format(s, r);\n    }\n  }\n  insertAt(t, e, s) {\n    const r = s == null ? this.scroll.create(\"text\", e) : this.scroll.create(e, s), i = this.split(t);\n    this.parent.insertBefore(r, i || void 0);\n  }\n  isolate(t, e) {\n    const s = this.split(t);\n    if (s == null)\n      throw new Error(\"Attempt to isolate at end\");\n    return s.split(e), s;\n  }\n  length() {\n    return 1;\n  }\n  offset(t = this.parent) {\n    return this.parent == null || this === t ? 0 : this.parent.children.offset(this) + this.parent.offset(t);\n  }\n  optimize(t) {\n    this.statics.requiredContainer && !(this.parent instanceof this.statics.requiredContainer) && this.wrap(this.statics.requiredContainer.blotName);\n  }\n  remove() {\n    this.domNode.parentNode != null && this.domNode.parentNode.removeChild(this.domNode), this.detach();\n  }\n  replaceWith(t, e) {\n    const s = typeof t == \"string\" ? this.scroll.create(t, e) : t;\n    return this.parent != null && (this.parent.insertBefore(s, this.next || void 0), this.remove()), s;\n  }\n  split(t, e) {\n    return t === 0 ? this : this.next;\n  }\n  update(t, e) {\n  }\n  wrap(t, e) {\n    const s = typeof t == \"string\" ? this.scroll.create(t, e) : t;\n    if (this.parent != null && this.parent.insertBefore(s, this.next || void 0), typeof s.appendChild != \"function\")\n      throw new N(`Cannot wrap ${t}`);\n    return s.appendChild(this), s;\n  }\n};\nk.blotName = \"abstract\";\nlet C = k;\nconst B = class B extends C {\n  static value(t) {\n    return !0;\n  }\n  index(t, e) {\n    return this.domNode === t || this.domNode.compareDocumentPosition(t) & Node.DOCUMENT_POSITION_CONTAINED_BY ? Math.min(e, 1) : -1;\n  }\n  position(t, e) {\n    let r = Array.from(this.parent.domNode.childNodes).indexOf(this.domNode);\n    return t > 0 && (r += 1), [this.parent.domNode, r];\n  }\n  value() {\n    return {\n      [this.statics.blotName]: this.statics.value(this.domNode) || !0\n    };\n  }\n};\nB.scope = l.INLINE_BLOT;\nlet A = B;\nclass q {\n  constructor() {\n    this.head = null, this.tail = null, this.length = 0;\n  }\n  append(...t) {\n    if (this.insertBefore(t[0], null), t.length > 1) {\n      const e = t.slice(1);\n      this.append(...e);\n    }\n  }\n  at(t) {\n    const e = this.iterator();\n    let s = e();\n    for (; s && t > 0; )\n      t -= 1, s = e();\n    return s;\n  }\n  contains(t) {\n    const e = this.iterator();\n    let s = e();\n    for (; s; ) {\n      if (s === t)\n        return !0;\n      s = e();\n    }\n    return !1;\n  }\n  indexOf(t) {\n    const e = this.iterator();\n    let s = e(), r = 0;\n    for (; s; ) {\n      if (s === t)\n        return r;\n      r += 1, s = e();\n    }\n    return -1;\n  }\n  insertBefore(t, e) {\n    t != null && (this.remove(t), t.next = e, e != null ? (t.prev = e.prev, e.prev != null && (e.prev.next = t), e.prev = t, e === this.head && (this.head = t)) : this.tail != null ? (this.tail.next = t, t.prev = this.tail, this.tail = t) : (t.prev = null, this.head = this.tail = t), this.length += 1);\n  }\n  offset(t) {\n    let e = 0, s = this.head;\n    for (; s != null; ) {\n      if (s === t)\n        return e;\n      e += s.length(), s = s.next;\n    }\n    return -1;\n  }\n  remove(t) {\n    this.contains(t) && (t.prev != null && (t.prev.next = t.next), t.next != null && (t.next.prev = t.prev), t === this.head && (this.head = t.next), t === this.tail && (this.tail = t.prev), this.length -= 1);\n  }\n  iterator(t = this.head) {\n    return () => {\n      const e = t;\n      return t != null && (t = t.next), e;\n    };\n  }\n  find(t, e = !1) {\n    const s = this.iterator();\n    let r = s();\n    for (; r; ) {\n      const i = r.length();\n      if (t < i || e && t === i && (r.next == null || r.next.length() !== 0))\n        return [r, t];\n      t -= i, r = s();\n    }\n    return [null, 0];\n  }\n  forEach(t) {\n    const e = this.iterator();\n    let s = e();\n    for (; s; )\n      t(s), s = e();\n  }\n  forEachAt(t, e, s) {\n    if (e <= 0)\n      return;\n    const [r, i] = this.find(t);\n    let h = t - i;\n    const n = this.iterator(r);\n    let o = n();\n    for (; o && h < t + e; ) {\n      const c = o.length();\n      t > h ? s(\n        o,\n        t - h,\n        Math.min(e, h + c - t)\n      ) : s(o, 0, Math.min(c, t + e - h)), h += c, o = n();\n    }\n  }\n  map(t) {\n    return this.reduce((e, s) => (e.push(t(s)), e), []);\n  }\n  reduce(t, e) {\n    const s = this.iterator();\n    let r = s();\n    for (; r; )\n      e = t(e, r), r = s();\n    return e;\n  }\n}\nfunction U(a, t) {\n  const e = t.find(a);\n  if (e)\n    return e;\n  try {\n    return t.create(a);\n  } catch {\n    const r = t.create(l.INLINE);\n    return Array.from(a.childNodes).forEach((i) => {\n      r.domNode.appendChild(i);\n    }), a.parentNode && a.parentNode.replaceChild(r.domNode, a), r.attach(), r;\n  }\n}\nconst f = class f extends C {\n  constructor(t, e) {\n    super(t, e), this.uiNode = null, this.build();\n  }\n  appendChild(t) {\n    this.insertBefore(t);\n  }\n  attach() {\n    super.attach(), this.children.forEach((t) => {\n      t.attach();\n    });\n  }\n  attachUI(t) {\n    this.uiNode != null && this.uiNode.remove(), this.uiNode = t, f.uiClass && this.uiNode.classList.add(f.uiClass), this.uiNode.setAttribute(\"contenteditable\", \"false\"), this.domNode.insertBefore(this.uiNode, this.domNode.firstChild);\n  }\n  build() {\n    this.children = new q(), Array.from(this.domNode.childNodes).filter((t) => t !== this.uiNode).reverse().forEach((t) => {\n      try {\n        const e = U(t, this.scroll);\n        this.insertBefore(e, this.children.head || void 0);\n      } catch (e) {\n        if (e instanceof N)\n          return;\n        throw e;\n      }\n    });\n  }\n  deleteAt(t, e) {\n    if (t === 0 && e === this.length())\n      return this.remove();\n    this.children.forEachAt(t, e, (s, r, i) => {\n      s.deleteAt(r, i);\n    });\n  }\n  descendant(t, e = 0) {\n    const [s, r] = this.children.find(e);\n    return t.blotName == null && t(s) || t.blotName != null && s instanceof t ? [s, r] : s instanceof f ? s.descendant(t, r) : [null, -1];\n  }\n  descendants(t, e = 0, s = Number.MAX_VALUE) {\n    let r = [], i = s;\n    return this.children.forEachAt(\n      e,\n      s,\n      (h, n, o) => {\n        (t.blotName == null && t(h) || t.blotName != null && h instanceof t) && r.push(h), h instanceof f && (r = r.concat(\n          h.descendants(t, n, i)\n        )), i -= o;\n      }\n    ), r;\n  }\n  detach() {\n    this.children.forEach((t) => {\n      t.detach();\n    }), super.detach();\n  }\n  enforceAllowedChildren() {\n    let t = !1;\n    this.children.forEach((e) => {\n      t || this.statics.allowedChildren.some(\n        (r) => e instanceof r\n      ) || (e.statics.scope === l.BLOCK_BLOT ? (e.next != null && this.splitAfter(e), e.prev != null && this.splitAfter(e.prev), e.parent.unwrap(), t = !0) : e instanceof f ? e.unwrap() : e.remove());\n    });\n  }\n  formatAt(t, e, s, r) {\n    this.children.forEachAt(t, e, (i, h, n) => {\n      i.formatAt(h, n, s, r);\n    });\n  }\n  insertAt(t, e, s) {\n    const [r, i] = this.children.find(t);\n    if (r)\n      r.insertAt(i, e, s);\n    else {\n      const h = s == null ? this.scroll.create(\"text\", e) : this.scroll.create(e, s);\n      this.appendChild(h);\n    }\n  }\n  insertBefore(t, e) {\n    t.parent != null && t.parent.children.remove(t);\n    let s = null;\n    this.children.insertBefore(t, e || null), t.parent = this, e != null && (s = e.domNode), (this.domNode.parentNode !== t.domNode || this.domNode.nextSibling !== s) && this.domNode.insertBefore(t.domNode, s), t.attach();\n  }\n  length() {\n    return this.children.reduce((t, e) => t + e.length(), 0);\n  }\n  moveChildren(t, e) {\n    this.children.forEach((s) => {\n      t.insertBefore(s, e);\n    });\n  }\n  optimize(t) {\n    if (super.optimize(t), this.enforceAllowedChildren(), this.uiNode != null && this.uiNode !== this.domNode.firstChild && this.domNode.insertBefore(this.uiNode, this.domNode.firstChild), this.children.length === 0)\n      if (this.statics.defaultChild != null) {\n        const e = this.scroll.create(this.statics.defaultChild.blotName);\n        this.appendChild(e);\n      } else\n        this.remove();\n  }\n  path(t, e = !1) {\n    const [s, r] = this.children.find(t, e), i = [[this, t]];\n    return s instanceof f ? i.concat(s.path(r, e)) : (s != null && i.push([s, r]), i);\n  }\n  removeChild(t) {\n    this.children.remove(t);\n  }\n  replaceWith(t, e) {\n    const s = typeof t == \"string\" ? this.scroll.create(t, e) : t;\n    return s instanceof f && this.moveChildren(s), super.replaceWith(s);\n  }\n  split(t, e = !1) {\n    if (!e) {\n      if (t === 0)\n        return this;\n      if (t === this.length())\n        return this.next;\n    }\n    const s = this.clone();\n    return this.parent && this.parent.insertBefore(s, this.next || void 0), this.children.forEachAt(t, this.length(), (r, i, h) => {\n      const n = r.split(i, e);\n      n != null && s.appendChild(n);\n    }), s;\n  }\n  splitAfter(t) {\n    const e = this.clone();\n    for (; t.next != null; )\n      e.appendChild(t.next);\n    return this.parent && this.parent.insertBefore(e, this.next || void 0), e;\n  }\n  unwrap() {\n    this.parent && this.moveChildren(this.parent, this.next || void 0), this.remove();\n  }\n  update(t, e) {\n    const s = [], r = [];\n    t.forEach((i) => {\n      i.target === this.domNode && i.type === \"childList\" && (s.push(...i.addedNodes), r.push(...i.removedNodes));\n    }), r.forEach((i) => {\n      if (i.parentNode != null && // @ts-expect-error Fix me later\n      i.tagName !== \"IFRAME\" && document.body.compareDocumentPosition(i) & Node.DOCUMENT_POSITION_CONTAINED_BY)\n        return;\n      const h = this.scroll.find(i);\n      h != null && (h.domNode.parentNode == null || h.domNode.parentNode === this.domNode) && h.detach();\n    }), s.filter((i) => i.parentNode === this.domNode && i !== this.uiNode).sort((i, h) => i === h ? 0 : i.compareDocumentPosition(h) & Node.DOCUMENT_POSITION_FOLLOWING ? 1 : -1).forEach((i) => {\n      let h = null;\n      i.nextSibling != null && (h = this.scroll.find(i.nextSibling));\n      const n = U(i, this.scroll);\n      (n.next !== h || n.next == null) && (n.parent != null && n.parent.removeChild(this), this.insertBefore(n, h || void 0));\n    }), this.enforceAllowedChildren();\n  }\n};\nf.uiClass = \"\";\nlet m = f;\nfunction V(a, t) {\n  if (Object.keys(a).length !== Object.keys(t).length)\n    return !1;\n  for (const e in a)\n    if (a[e] !== t[e])\n      return !1;\n  return !0;\n}\nconst u = class u extends m {\n  constructor(t, e) {\n    super(t, e), this.attributes = new D(this.domNode);\n  }\n  static create(t) {\n    return super.create(t);\n  }\n  static formats(t, e) {\n    const s = e.query(u.blotName);\n    if (!(s != null && t.tagName === s.tagName)) {\n      if (typeof this.tagName == \"string\")\n        return !0;\n      if (Array.isArray(this.tagName))\n        return t.tagName.toLowerCase();\n    }\n  }\n  format(t, e) {\n    if (t === this.statics.blotName && !e)\n      this.children.forEach((s) => {\n        s instanceof u || (s = s.wrap(u.blotName, !0)), this.attributes.copy(s);\n      }), this.unwrap();\n    else {\n      const s = this.scroll.query(t, l.INLINE);\n      if (s == null)\n        return;\n      s instanceof b ? this.attributes.attribute(s, e) : e && (t !== this.statics.blotName || this.formats()[t] !== e) && this.replaceWith(t, e);\n    }\n  }\n  formats() {\n    const t = this.attributes.values(), e = this.statics.formats(this.domNode, this.scroll);\n    return e != null && (t[this.statics.blotName] = e), t;\n  }\n  formatAt(t, e, s, r) {\n    this.formats()[s] != null || this.scroll.query(s, l.ATTRIBUTE) ? this.isolate(t, e).format(s, r) : super.formatAt(t, e, s, r);\n  }\n  optimize(t) {\n    super.optimize(t);\n    const e = this.formats();\n    if (Object.keys(e).length === 0)\n      return this.unwrap();\n    const s = this.next;\n    s instanceof u && s.prev === this && V(e, s.formats()) && (s.moveChildren(this), s.remove());\n  }\n  replaceWith(t, e) {\n    const s = super.replaceWith(t, e);\n    return this.attributes.copy(s), s;\n  }\n  update(t, e) {\n    super.update(t, e), t.some(\n      (r) => r.target === this.domNode && r.type === \"attributes\"\n    ) && this.attributes.build();\n  }\n  wrap(t, e) {\n    const s = super.wrap(t, e);\n    return s instanceof u && this.attributes.move(s), s;\n  }\n};\nu.allowedChildren = [u, A], u.blotName = \"inline\", u.scope = l.INLINE_BLOT, u.tagName = \"SPAN\";\nlet O = u;\nconst d = class d extends m {\n  constructor(t, e) {\n    super(t, e), this.attributes = new D(this.domNode);\n  }\n  static create(t) {\n    return super.create(t);\n  }\n  static formats(t, e) {\n    const s = e.query(d.blotName);\n    if (!(s != null && t.tagName === s.tagName)) {\n      if (typeof this.tagName == \"string\")\n        return !0;\n      if (Array.isArray(this.tagName))\n        return t.tagName.toLowerCase();\n    }\n  }\n  format(t, e) {\n    const s = this.scroll.query(t, l.BLOCK);\n    s != null && (s instanceof b ? this.attributes.attribute(s, e) : t === this.statics.blotName && !e ? this.replaceWith(d.blotName) : e && (t !== this.statics.blotName || this.formats()[t] !== e) && this.replaceWith(t, e));\n  }\n  formats() {\n    const t = this.attributes.values(), e = this.statics.formats(this.domNode, this.scroll);\n    return e != null && (t[this.statics.blotName] = e), t;\n  }\n  formatAt(t, e, s, r) {\n    this.scroll.query(s, l.BLOCK) != null ? this.format(s, r) : super.formatAt(t, e, s, r);\n  }\n  insertAt(t, e, s) {\n    if (s == null || this.scroll.query(e, l.INLINE) != null)\n      super.insertAt(t, e, s);\n    else {\n      const r = this.split(t);\n      if (r != null) {\n        const i = this.scroll.create(e, s);\n        r.parent.insertBefore(i, r);\n      } else\n        throw new Error(\"Attempt to insertAt after block boundaries\");\n    }\n  }\n  replaceWith(t, e) {\n    const s = super.replaceWith(t, e);\n    return this.attributes.copy(s), s;\n  }\n  update(t, e) {\n    super.update(t, e), t.some(\n      (r) => r.target === this.domNode && r.type === \"attributes\"\n    ) && this.attributes.build();\n  }\n};\nd.blotName = \"block\", d.scope = l.BLOCK_BLOT, d.tagName = \"P\", d.allowedChildren = [\n  O,\n  d,\n  A\n];\nlet T = d;\nconst L = class L extends m {\n  checkMerge() {\n    return this.next !== null && this.next.statics.blotName === this.statics.blotName;\n  }\n  deleteAt(t, e) {\n    super.deleteAt(t, e), this.enforceAllowedChildren();\n  }\n  formatAt(t, e, s, r) {\n    super.formatAt(t, e, s, r), this.enforceAllowedChildren();\n  }\n  insertAt(t, e, s) {\n    super.insertAt(t, e, s), this.enforceAllowedChildren();\n  }\n  optimize(t) {\n    super.optimize(t), this.children.length > 0 && this.next != null && this.checkMerge() && (this.next.moveChildren(this), this.next.remove());\n  }\n};\nL.blotName = \"container\", L.scope = l.BLOCK_BLOT;\nlet I = L;\nclass X extends A {\n  static formats(t, e) {\n  }\n  format(t, e) {\n    super.formatAt(0, this.length(), t, e);\n  }\n  formatAt(t, e, s, r) {\n    t === 0 && e === this.length() ? this.format(s, r) : super.formatAt(t, e, s, r);\n  }\n  formats() {\n    return this.statics.formats(this.domNode, this.scroll);\n  }\n}\nconst j = {\n  attributes: !0,\n  characterData: !0,\n  characterDataOldValue: !0,\n  childList: !0,\n  subtree: !0\n}, $ = 100, p = class p extends m {\n  constructor(t, e) {\n    super(null, e), this.registry = t, this.scroll = this, this.build(), this.observer = new MutationObserver((s) => {\n      this.update(s);\n    }), this.observer.observe(this.domNode, j), this.attach();\n  }\n  create(t, e) {\n    return this.registry.create(this, t, e);\n  }\n  find(t, e = !1) {\n    const s = this.registry.find(t, e);\n    return s ? s.scroll === this ? s : e ? this.find(s.scroll.domNode.parentNode, !0) : null : null;\n  }\n  query(t, e = l.ANY) {\n    return this.registry.query(t, e);\n  }\n  register(...t) {\n    return this.registry.register(...t);\n  }\n  build() {\n    this.scroll != null && super.build();\n  }\n  detach() {\n    super.detach(), this.observer.disconnect();\n  }\n  deleteAt(t, e) {\n    this.update(), t === 0 && e === this.length() ? this.children.forEach((s) => {\n      s.remove();\n    }) : super.deleteAt(t, e);\n  }\n  formatAt(t, e, s, r) {\n    this.update(), super.formatAt(t, e, s, r);\n  }\n  insertAt(t, e, s) {\n    this.update(), super.insertAt(t, e, s);\n  }\n  optimize(t = [], e = {}) {\n    super.optimize(e);\n    const s = e.mutationsMap || /* @__PURE__ */ new WeakMap();\n    let r = Array.from(this.observer.takeRecords());\n    for (; r.length > 0; )\n      t.push(r.pop());\n    const i = (o, c = !0) => {\n      o == null || o === this || o.domNode.parentNode != null && (s.has(o.domNode) || s.set(o.domNode, []), c && i(o.parent));\n    }, h = (o) => {\n      s.has(o.domNode) && (o instanceof m && o.children.forEach(h), s.delete(o.domNode), o.optimize(e));\n    };\n    let n = t;\n    for (let o = 0; n.length > 0; o += 1) {\n      if (o >= $)\n        throw new Error(\"[Parchment] Maximum optimize iterations reached\");\n      for (n.forEach((c) => {\n        const v = this.find(c.target, !0);\n        v != null && (v.domNode === c.target && (c.type === \"childList\" ? (i(this.find(c.previousSibling, !1)), Array.from(c.addedNodes).forEach((P) => {\n          const w = this.find(P, !1);\n          i(w, !1), w instanceof m && w.children.forEach((W) => {\n            i(W, !1);\n          });\n        })) : c.type === \"attributes\" && i(v.prev)), i(v));\n      }), this.children.forEach(h), n = Array.from(this.observer.takeRecords()), r = n.slice(); r.length > 0; )\n        t.push(r.pop());\n    }\n  }\n  update(t, e = {}) {\n    t = t || this.observer.takeRecords();\n    const s = /* @__PURE__ */ new WeakMap();\n    t.map((r) => {\n      const i = this.find(r.target, !0);\n      return i == null ? null : s.has(i.domNode) ? (s.get(i.domNode).push(r), null) : (s.set(i.domNode, [r]), i);\n    }).forEach((r) => {\n      r != null && r !== this && s.has(r.domNode) && r.update(s.get(r.domNode) || [], e);\n    }), e.mutationsMap = s, s.has(this.domNode) && super.update(s.get(this.domNode), e), this.optimize(t, e);\n  }\n};\np.blotName = \"scroll\", p.defaultChild = T, p.allowedChildren = [T, I], p.scope = l.BLOCK_BLOT, p.tagName = \"DIV\";\nlet z = p;\nconst E = class E extends A {\n  constructor(t, e) {\n    super(t, e), this.text = this.statics.value(this.domNode);\n  }\n  static create(t) {\n    return document.createTextNode(t);\n  }\n  static value(t) {\n    return t.data;\n  }\n  deleteAt(t, e) {\n    this.domNode.data = this.text = this.text.slice(0, t) + this.text.slice(t + e);\n  }\n  index(t, e) {\n    return this.domNode === t ? e : -1;\n  }\n  insertAt(t, e, s) {\n    s == null ? (this.text = this.text.slice(0, t) + e + this.text.slice(t), this.domNode.data = this.text) : super.insertAt(t, e, s);\n  }\n  length() {\n    return this.text.length;\n  }\n  optimize(t) {\n    super.optimize(t), this.text = this.statics.value(this.domNode), this.text.length === 0 ? this.remove() : this.next instanceof E && this.next.prev === this && (this.insertAt(this.length(), this.next.value()), this.next.remove());\n  }\n  position(t, e = !1) {\n    return [this.domNode, t];\n  }\n  split(t, e = !1) {\n    if (!e) {\n      if (t === 0)\n        return this;\n      if (t === this.length())\n        return this.next;\n    }\n    const s = this.scroll.create(this.domNode.splitText(t));\n    return this.parent.insertBefore(s, this.next || void 0), this.text = this.statics.value(this.domNode), s;\n  }\n  update(t, e) {\n    t.some((s) => s.type === \"characterData\" && s.target === this.domNode) && (this.text = this.statics.value(this.domNode));\n  }\n  value() {\n    return this.text;\n  }\n};\nE.blotName = \"text\", E.scope = l.INLINE_BLOT;\nlet R = E;\nexport {\n  b as Attributor,\n  D as AttributorStore,\n  T as BlockBlot,\n  K as ClassAttributor,\n  I as ContainerBlot,\n  X as EmbedBlot,\n  O as InlineBlot,\n  A as LeafBlot,\n  m as ParentBlot,\n  y as Registry,\n  l as Scope,\n  z as ScrollBlot,\n  Y as StyleAttributor,\n  R as TextBlot\n};\n//# sourceMappingURL=parchment.mjs.map\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](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 = function(module) {\n\tvar getter = module && module.__esModule ?\n\t\tfunction() { return module['default']; } :\n\t\tfunction() { return module; };\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\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__.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 = 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};","__webpack_require__.nmd = function(module) {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\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';\n\nclass Blockquote extends Block {\n  static blotName = 'blockquote';\n  static tagName = 'blockquote';\n}\n\nexport default Blockquote;\n","import Block from '../blots/block';\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';\nimport Container from '../blots/container';\nimport type Scroll from '../blots/scroll';\nimport Quill from '../core/quill';\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';\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';\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';\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';\n\nclass Underline extends Inline {\n  static blotName = 'underline';\n  static tagName = 'U';\n}\n\nexport default Underline;\n","import Embed from '../blots/embed';\n\nclass Formula extends Embed {\n  static blotName = 'formula';\n  static className = 'ql-formula';\n  static tagName = 'SPAN';\n\n  static create(value: string) {\n    // @ts-expect-error\n    if (window.katex == null) {\n      throw new Error('Formula module requires KaTeX.');\n    }\n    const node = super.create(value) as Element;\n    if (typeof value === 'string') {\n      // @ts-expect-error\n      window.katex.render(value, node, {\n        throwOnError: false,\n        errorColor: '#f00',\n      });\n      node.setAttribute('data-value', value);\n    }\n    return node;\n  }\n\n  static value(domNode: Element) {\n    return domNode.getAttribute('data-value');\n  }\n\n  html() {\n    const { formula } = this.value();\n    return `<span>${formula}</span>`;\n  }\n}\n\nexport default Formula;\n","import { EmbedBlot } from 'parchment';\nimport { sanitize } from './link';\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 register() {\n    if (/Firefox/i.test(navigator.userAgent)) {\n      setTimeout(() => {\n        // Disable image resizing in Firefox\n        // @ts-expect-error\n        document.execCommand('enableObjectResizing', false, false);\n      }, 1);\n    }\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';\nimport Link from './link';\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';\nimport { ClassAttributor, Scope } from 'parchment';\nimport type { Blot, ScrollBlot } from 'parchment';\nimport Inline from '../blots/inline';\nimport Quill from '../core/quill';\nimport Module from '../core/module';\nimport { blockDelta } from '../blots/block';\nimport BreakBlot from '../blots/break';\nimport CursorBlot from '../blots/cursor';\nimport TextBlot, { escapeText } from '../blots/text';\nimport CodeBlock, { CodeBlockContainer } from '../formats/code';\nimport { traverse } from './clipboard';\n\nconst TokenAttributor = new ClassAttributor('code-token', 'hljs', {\n  scope: Scope.INLINE,\n});\nclass CodeToken extends Inline {\n  static formats(node: Element, scroll: ScrollBlot) {\n    while (node != null && node !== scroll.domNode) {\n      if (node.classList && node.classList.contains(CodeBlock.className)) {\n        // @ts-expect-error\n        return super.formats(node, scroll);\n      }\n      // @ts-expect-error\n      node = node.parentNode;\n    }\n    return undefined;\n  }\n\n  constructor(scroll: ScrollBlot, domNode: Node, value: unknown) {\n    // @ts-expect-error\n    super(scroll, domNode, value);\n    TokenAttributor.add(this.domNode, value);\n  }\n\n  format(format: string, value: unknown) {\n    if (format !== CodeToken.blotName) {\n      super.format(format, value);\n    } else if (value) {\n      TokenAttributor.add(this.domNode, value);\n    } else {\n      TokenAttributor.remove(this.domNode);\n      this.domNode.classList.remove(this.statics.className);\n    }\n  }\n\n  optimize(...args: unknown[]) {\n    // @ts-expect-error\n    super.optimize(...args);\n    if (!TokenAttributor.value(this.domNode)) {\n      this.unwrap();\n    }\n  }\n}\nCodeToken.blotName = 'code-token';\nCodeToken.className = 'ql-token';\n\nclass SyntaxCodeBlock extends CodeBlock {\n  static create(value: unknown) {\n    const domNode = super.create(value);\n    if (typeof value === 'string') {\n      domNode.setAttribute('data-language', value);\n    }\n    return domNode;\n  }\n\n  static formats(domNode: Node) {\n    // @ts-expect-error\n    return domNode.getAttribute('data-language') || 'plain';\n  }\n\n  static register() {} // Syntax module will register\n\n  format(name: string, value: unknown) {\n    if (name === this.statics.blotName && value) {\n      // @ts-expect-error\n      this.domNode.setAttribute('data-language', value);\n    } else {\n      super.format(name, value);\n    }\n  }\n\n  replaceWith(name: string, value: unknown) {\n    this.formatAt(0, this.length(), CodeToken.blotName, false);\n    return super.replaceWith(name, value);\n  }\n}\n\nclass SyntaxCodeBlockContainer extends CodeBlockContainer {\n  forceNext?: boolean;\n  cachedText?: string | null;\n\n  attach() {\n    super.attach();\n    this.forceNext = false;\n    // @ts-expect-error\n    this.scroll.emitMount(this);\n  }\n\n  format(name: string, value: unknown) {\n    if (name === SyntaxCodeBlock.blotName) {\n      this.forceNext = true;\n      this.children.forEach((child) => {\n        // @ts-expect-error\n        child.format(name, value);\n      });\n    }\n  }\n\n  formatAt(index: number, length: number, name: string, value: unknown) {\n    if (name === SyntaxCodeBlock.blotName) {\n      this.forceNext = true;\n    }\n    super.formatAt(index, length, name, value);\n  }\n\n  highlight(\n    highlight: (text: string, language: string) => Delta,\n    forced = false,\n  ) {\n    if (this.children.head == null) return;\n    const nodes = Array.from(this.domNode.childNodes).filter(\n      (node) => node !== this.uiNode,\n    );\n    const text = `${nodes.map((node) => node.textContent).join('\\n')}\\n`;\n    const language = SyntaxCodeBlock.formats(this.children.head.domNode);\n    if (forced || this.forceNext || this.cachedText !== text) {\n      if (text.trim().length > 0 || this.cachedText == null) {\n        const oldDelta = this.children.reduce((delta, child) => {\n          // @ts-expect-error\n          return delta.concat(blockDelta(child, false));\n        }, new Delta());\n        const delta = highlight(text, language);\n        oldDelta.diff(delta).reduce((index, { retain, attributes }) => {\n          // Should be all retains\n          if (!retain) return index;\n          if (attributes) {\n            Object.keys(attributes).forEach((format) => {\n              if (\n                [SyntaxCodeBlock.blotName, CodeToken.blotName].includes(format)\n              ) {\n                // @ts-expect-error\n                this.formatAt(index, retain, format, attributes[format]);\n              }\n            });\n          }\n          // @ts-expect-error\n          return index + retain;\n        }, 0);\n      }\n      this.cachedText = text;\n      this.forceNext = false;\n    }\n  }\n\n  html(index: number, length: number) {\n    const [codeBlock] = this.children.find(index);\n    const language = codeBlock\n      ? SyntaxCodeBlock.formats(codeBlock.domNode)\n      : 'plain';\n\n    return `<pre data-language=\"${language}\">\\n${escapeText(\n      this.code(index, length),\n    )}\\n</pre>`;\n  }\n\n  optimize(context: Record<string, any>) {\n    super.optimize(context);\n    if (\n      this.parent != null &&\n      this.children.head != null &&\n      this.uiNode != null\n    ) {\n      const language = SyntaxCodeBlock.formats(this.children.head.domNode);\n      // @ts-expect-error\n      if (language !== this.uiNode.value) {\n        // @ts-expect-error\n        this.uiNode.value = language;\n      }\n    }\n  }\n}\n// @ts-expect-error\nSyntaxCodeBlockContainer.allowedChildren = [SyntaxCodeBlock];\nSyntaxCodeBlock.requiredContainer = SyntaxCodeBlockContainer;\nSyntaxCodeBlock.allowedChildren = [CodeToken, CursorBlot, TextBlot, BreakBlot];\n\ninterface SyntaxOptions {\n  interval: number;\n  languages: { key: string; label: string }[];\n}\n\nclass Syntax extends Module<SyntaxOptions> {\n  static DEFAULTS: SyntaxOptions & { hljs: any };\n\n  static register() {\n    Quill.register(CodeToken, true);\n    // @ts-expect-error\n    Quill.register(SyntaxCodeBlock, true);\n    Quill.register(SyntaxCodeBlockContainer, true);\n  }\n\n  languages: Record<string, true>;\n\n  constructor(quill: Quill, options: Partial<SyntaxOptions>) {\n    super(quill, options);\n    // @ts-expect-error\n    if (this.options.hljs == null) {\n      throw new Error(\n        'Syntax module requires highlight.js. Please include the library on the page before Quill.',\n      );\n    }\n    // @ts-expect-error Fix me later\n    this.languages = this.options.languages.reduce(\n      (memo: Record<string, unknown>, { key }) => {\n        memo[key] = true;\n        return memo;\n      },\n      {},\n    );\n    this.highlightBlot = this.highlightBlot.bind(this);\n    this.initListener();\n    this.initTimer();\n  }\n\n  initListener() {\n    this.quill.on(Quill.events.SCROLL_BLOT_MOUNT, (blot: Blot) => {\n      if (!(blot instanceof SyntaxCodeBlockContainer)) return;\n      const select = this.quill.root.ownerDocument.createElement('select');\n      // @ts-expect-error Fix me later\n      this.options.languages.forEach(({ key, label }) => {\n        const option = select.ownerDocument.createElement('option');\n        option.textContent = label;\n        option.setAttribute('value', key);\n        select.appendChild(option);\n      });\n      select.addEventListener('change', () => {\n        blot.format(SyntaxCodeBlock.blotName, select.value);\n        this.quill.root.focus(); // Prevent scrolling\n        this.highlight(blot, true);\n      });\n      if (blot.uiNode == null) {\n        blot.attachUI(select);\n        if (blot.children.head) {\n          select.value = SyntaxCodeBlock.formats(blot.children.head.domNode);\n        }\n      }\n    });\n  }\n\n  initTimer() {\n    let timer: ReturnType<typeof setTimeout> | null = null;\n    this.quill.on(Quill.events.SCROLL_OPTIMIZE, () => {\n      if (timer) {\n        clearTimeout(timer);\n      }\n      timer = setTimeout(() => {\n        this.highlight();\n        timer = null;\n      }, this.options.interval);\n    });\n  }\n\n  highlight(blot: SyntaxCodeBlockContainer | null = null, force = false) {\n    if (this.quill.selection.composing) return;\n    this.quill.update(Quill.sources.USER);\n    const range = this.quill.getSelection();\n    const blots =\n      blot == null\n        ? this.quill.scroll.descendants(SyntaxCodeBlockContainer)\n        : [blot];\n    blots.forEach((container) => {\n      container.highlight(this.highlightBlot, force);\n    });\n    this.quill.update(Quill.sources.SILENT);\n    if (range != null) {\n      this.quill.setSelection(range, Quill.sources.SILENT);\n    }\n  }\n\n  highlightBlot(text: string, language = 'plain') {\n    language = this.languages[language] ? language : 'plain';\n    if (language === 'plain') {\n      return escapeText(text)\n        .split('\\n')\n        .reduce((delta, line, i) => {\n          if (i !== 0) {\n            delta.insert('\\n', { [CodeBlock.blotName]: language });\n          }\n          return delta.insert(line);\n        }, new Delta());\n    }\n    const container = this.quill.root.ownerDocument.createElement('div');\n    container.classList.add(CodeBlock.className);\n    // @ts-expect-error\n    container.innerHTML = this.options.hljs.highlight(language, text).value;\n    return traverse(\n      this.quill.scroll,\n      container,\n      [\n        (node, delta) => {\n          // @ts-expect-error\n          const value = TokenAttributor.value(node);\n          if (value) {\n            return delta.compose(\n              new Delta().retain(delta.length(), {\n                [CodeToken.blotName]: value,\n              }),\n            );\n          }\n          return delta;\n        },\n      ],\n      [\n        (node, delta) => {\n          // @ts-expect-error\n          return node.data.split('\\n').reduce((memo, nodeText, i) => {\n            if (i !== 0) memo.insert('\\n', { [CodeBlock.blotName]: language });\n            return memo.insert(nodeText);\n          }, delta);\n        },\n      ],\n      new WeakMap(),\n    );\n  }\n}\nSyntax.DEFAULTS = {\n  hljs: (() => {\n    return window.hljs;\n  })(),\n  interval: 1000,\n  languages: [\n    { key: 'plain', label: 'Plain' },\n    { key: 'bash', label: 'Bash' },\n    { key: 'cpp', label: 'C++' },\n    { key: 'cs', label: 'C#' },\n    { key: 'css', label: 'CSS' },\n    { key: 'diff', label: 'Diff' },\n    { key: 'xml', label: 'HTML/XML' },\n    { key: 'java', label: 'Java' },\n    { key: 'javascript', label: 'JavaScript' },\n    { key: 'markdown', label: 'Markdown' },\n    { key: 'php', label: 'PHP' },\n    { key: 'python', label: 'Python' },\n    { key: 'ruby', label: 'Ruby' },\n    { key: 'sql', label: 'SQL' },\n  ],\n};\n\nexport { SyntaxCodeBlock as CodeBlock, CodeToken, Syntax as default };\n","import type { LinkedList } from 'parchment';\nimport Block from '../blots/block';\nimport Container from '../blots/container';\n\nclass TableCell extends Block {\n  static blotName = 'table';\n  static tagName = 'TD';\n\n  static create(value: string) {\n    const node = super.create() as HTMLElement;\n    if (value) {\n      node.setAttribute('data-row', value);\n    } else {\n      node.setAttribute('data-row', tableId());\n    }\n    return node;\n  }\n\n  static formats(domNode: HTMLElement) {\n    if (domNode.hasAttribute('data-row')) {\n      return domNode.getAttribute('data-row');\n    }\n    return undefined;\n  }\n\n  next: this | null;\n\n  cellOffset() {\n    if (this.parent) {\n      return this.parent.children.indexOf(this);\n    }\n    return -1;\n  }\n\n  format(name: string, value: string) {\n    if (name === TableCell.blotName && value) {\n      this.domNode.setAttribute('data-row', value);\n    } else {\n      super.format(name, value);\n    }\n  }\n\n  row(): TableRow {\n    return this.parent as TableRow;\n  }\n\n  rowOffset() {\n    if (this.row()) {\n      return this.row().rowOffset();\n    }\n    return -1;\n  }\n\n  table() {\n    return this.row() && this.row().table();\n  }\n}\n\nclass TableRow extends Container {\n  static blotName = 'table-row';\n  static tagName = 'TR';\n\n  children: LinkedList<TableCell>;\n  next: this | null;\n\n  checkMerge() {\n    // @ts-expect-error\n    if (super.checkMerge() && this.next.children.head != null) {\n      // @ts-expect-error\n      const thisHead = this.children.head.formats();\n      // @ts-expect-error\n      const thisTail = this.children.tail.formats();\n      // @ts-expect-error\n      const nextHead = this.next.children.head.formats();\n      // @ts-expect-error\n      const nextTail = this.next.children.tail.formats();\n      return (\n        thisHead.table === thisTail.table &&\n        thisHead.table === nextHead.table &&\n        thisHead.table === nextTail.table\n      );\n    }\n    return false;\n  }\n\n  optimize(context: { [key: string]: any }) {\n    super.optimize(context);\n    this.children.forEach((child) => {\n      if (child.next == null) return;\n      const childFormats = child.formats();\n      const nextFormats = child.next.formats();\n      if (childFormats.table !== nextFormats.table) {\n        const next = this.splitAfter(child);\n        if (next) {\n          // @ts-expect-error TODO: parameters of optimize() should be a optional\n          next.optimize();\n        }\n        // We might be able to merge with prev now\n        if (this.prev) {\n          // @ts-expect-error TODO: parameters of optimize() should be a optional\n          this.prev.optimize();\n        }\n      }\n    });\n  }\n\n  rowOffset() {\n    if (this.parent) {\n      return this.parent.children.indexOf(this);\n    }\n    return -1;\n  }\n\n  table() {\n    return this.parent && this.parent.parent;\n  }\n}\n\nclass TableBody extends Container {\n  static blotName = 'table-body';\n  static tagName = 'TBODY';\n\n  children: LinkedList<TableRow>;\n}\n\nclass TableContainer extends Container {\n  static blotName = 'table-container';\n  static tagName = 'TABLE';\n\n  children: LinkedList<TableBody>;\n\n  balanceCells() {\n    const rows = this.descendants(TableRow);\n    const maxColumns = rows.reduce((max, row) => {\n      return Math.max(row.children.length, max);\n    }, 0);\n    rows.forEach((row) => {\n      new Array(maxColumns - row.children.length).fill(0).forEach(() => {\n        let value;\n        if (row.children.head != null) {\n          value = TableCell.formats(row.children.head.domNode);\n        }\n        const blot = this.scroll.create(TableCell.blotName, value);\n        row.appendChild(blot);\n        // @ts-expect-error TODO: parameters of optimize() should be a optional\n        blot.optimize(); // Add break blot\n      });\n    });\n  }\n\n  cells(column: number) {\n    return this.rows().map((row) => row.children.at(column));\n  }\n\n  deleteColumn(index: number) {\n    // @ts-expect-error\n    const [body] = this.descendant(TableBody) as TableBody[];\n    if (body == null || body.children.head == null) return;\n    body.children.forEach((row) => {\n      const cell = row.children.at(index);\n      if (cell != null) {\n        cell.remove();\n      }\n    });\n  }\n\n  insertColumn(index: number) {\n    // @ts-expect-error\n    const [body] = this.descendant(TableBody) as TableBody[];\n    if (body == null || body.children.head == null) return;\n    body.children.forEach((row) => {\n      const ref = row.children.at(index);\n      // @ts-expect-error\n      const value = TableCell.formats(row.children.head.domNode);\n      const cell = this.scroll.create(TableCell.blotName, value);\n      row.insertBefore(cell, ref);\n    });\n  }\n\n  insertRow(index: number) {\n    // @ts-expect-error\n    const [body] = this.descendant(TableBody) as TableBody[];\n    if (body == null || body.children.head == null) return;\n    const id = tableId();\n    const row = this.scroll.create(TableRow.blotName) as TableRow;\n    body.children.head.children.forEach(() => {\n      const cell = this.scroll.create(TableCell.blotName, id);\n      row.appendChild(cell);\n    });\n    const ref = body.children.at(index);\n    body.insertBefore(row, ref);\n  }\n\n  rows() {\n    const body = this.children.head;\n    if (body == null) return [];\n    return body.children.map((row) => row);\n  }\n}\n\nTableContainer.allowedChildren = [TableBody];\nTableBody.requiredContainer = TableContainer;\n\nTableBody.allowedChildren = [TableRow];\nTableRow.requiredContainer = TableBody;\n\nTableRow.allowedChildren = [TableCell];\nTableCell.requiredContainer = TableRow;\n\nfunction tableId() {\n  const id = Math.random().toString(36).slice(2, 6);\n  return `row-${id}`;\n}\n\nexport { TableCell, TableRow, TableBody, TableContainer, tableId };\n","import Delta from 'quill-delta';\nimport Quill from '../core/quill';\nimport Module from '../core/module';\nimport {\n  TableCell,\n  TableRow,\n  TableBody,\n  TableContainer,\n  tableId,\n} from '../formats/table';\n\nclass Table extends Module {\n  static register() {\n    Quill.register(TableCell);\n    Quill.register(TableRow);\n    Quill.register(TableBody);\n    Quill.register(TableContainer);\n  }\n\n  constructor(...args: ConstructorParameters<typeof Module>) {\n    super(...args);\n    this.listenBalanceCells();\n  }\n\n  balanceTables() {\n    this.quill.scroll.descendants(TableContainer).forEach((table) => {\n      table.balanceCells();\n    });\n  }\n\n  deleteColumn() {\n    const [table, , cell] = this.getTable();\n    if (cell == null) return;\n    // @ts-expect-error\n    table.deleteColumn(cell.cellOffset());\n    this.quill.update(Quill.sources.USER);\n  }\n\n  deleteRow() {\n    const [, row] = this.getTable();\n    if (row == null) return;\n    row.remove();\n    this.quill.update(Quill.sources.USER);\n  }\n\n  deleteTable() {\n    const [table] = this.getTable();\n    if (table == null) return;\n    // @ts-expect-error\n    const offset = table.offset();\n    // @ts-expect-error\n    table.remove();\n    this.quill.update(Quill.sources.USER);\n    this.quill.setSelection(offset, Quill.sources.SILENT);\n  }\n\n  getTable(\n    range = this.quill.getSelection(),\n  ): [null, null, null, -1] | [Table, TableRow, TableCell, number] {\n    if (range == null) return [null, null, null, -1];\n    const [cell, offset] = this.quill.getLine(range.index);\n    if (cell == null || cell.statics.blotName !== TableCell.blotName) {\n      return [null, null, null, -1];\n    }\n    const row = cell.parent;\n    const table = row.parent.parent;\n    // @ts-expect-error\n    return [table, row, cell, offset];\n  }\n\n  insertColumn(offset: number) {\n    const range = this.quill.getSelection();\n    if (!range) return;\n    const [table, row, cell] = this.getTable(range);\n    if (cell == null) return;\n    const column = cell.cellOffset();\n    table.insertColumn(column + offset);\n    this.quill.update(Quill.sources.USER);\n    let shift = row.rowOffset();\n    if (offset === 0) {\n      shift += 1;\n    }\n    this.quill.setSelection(\n      range.index + shift,\n      range.length,\n      Quill.sources.SILENT,\n    );\n  }\n\n  insertColumnLeft() {\n    this.insertColumn(0);\n  }\n\n  insertColumnRight() {\n    this.insertColumn(1);\n  }\n\n  insertRow(offset: number) {\n    const range = this.quill.getSelection();\n    if (!range) return;\n    const [table, row, cell] = this.getTable(range);\n    if (cell == null) return;\n    const index = row.rowOffset();\n    table.insertRow(index + offset);\n    this.quill.update(Quill.sources.USER);\n    if (offset > 0) {\n      this.quill.setSelection(range, Quill.sources.SILENT);\n    } else {\n      this.quill.setSelection(\n        range.index + row.children.length,\n        range.length,\n        Quill.sources.SILENT,\n      );\n    }\n  }\n\n  insertRowAbove() {\n    this.insertRow(0);\n  }\n\n  insertRowBelow() {\n    this.insertRow(1);\n  }\n\n  insertTable(rows: number, columns: number) {\n    const range = this.quill.getSelection();\n    if (range == null) return;\n    const delta = new Array(rows).fill(0).reduce((memo) => {\n      const text = new Array(columns).fill('\\n').join('');\n      return memo.insert(text, { table: tableId() });\n    }, new Delta().retain(range.index));\n    this.quill.updateContents(delta, Quill.sources.USER);\n    this.quill.setSelection(range.index, Quill.sources.SILENT);\n    this.balanceTables();\n  }\n\n  listenBalanceCells() {\n    this.quill.on(\n      Quill.events.SCROLL_OPTIMIZE,\n      (mutations: MutationRecord[]) => {\n        mutations.some((mutation) => {\n          if (\n            ['TD', 'TR', 'TBODY', 'TABLE'].includes(\n              (mutation.target as HTMLElement).tagName,\n            )\n          ) {\n            this.quill.once(Quill.events.TEXT_CHANGE, (delta, old, source) => {\n              if (source !== Quill.sources.USER) return;\n              this.balanceTables();\n            });\n            return true;\n          }\n          return false;\n        });\n      },\n    );\n  }\n}\n\nexport default Table;\n","import Delta from 'quill-delta';\nimport { EmbedBlot, Scope } from 'parchment';\nimport Quill from '../core/quill';\nimport logger from '../core/logger';\nimport Module from '../core/module';\nimport type { Range } from '../core/selection';\n\nconst debug = logger('quill:toolbar');\n\ntype Handler = (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      this.container = document.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, (type, range) => {\n      if (type === Quill.events.SELECTION_CHANGE) {\n        this.update(range as Range);\n      }\n    });\n    this.quill.on(Quill.events.SCROLL_OPTIMIZE, () => {\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      // @ts-expect-error Fix me later\n      if (this.handlers[format] != null) {\n        // @ts-expect-error Fix me later\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            // @ts-expect-error Fix me later\n            .insert({ [format]: value }),\n          Quill.sources.USER,\n        );\n      } else {\n        // @ts-expect-error Fix me later\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, 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      const formats = this.quill.getFormat(range);\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      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 alignLeftIcon from '../assets/icons/align-left.svg';\nimport alignCenterIcon from '../assets/icons/align-center.svg';\nimport alignRightIcon from '../assets/icons/align-right.svg';\nimport alignJustifyIcon from '../assets/icons/align-justify.svg';\nimport backgroundIcon from '../assets/icons/background.svg';\nimport blockquoteIcon from '../assets/icons/blockquote.svg';\nimport boldIcon from '../assets/icons/bold.svg';\nimport cleanIcon from '../assets/icons/clean.svg';\nimport codeIcon from '../assets/icons/code.svg';\nimport colorIcon from '../assets/icons/color.svg';\nimport directionLeftToRightIcon from '../assets/icons/direction-ltr.svg';\nimport directionRightToLeftIcon from '../assets/icons/direction-rtl.svg';\nimport formulaIcon from '../assets/icons/formula.svg';\nimport headerIcon from '../assets/icons/header.svg';\nimport header2Icon from '../assets/icons/header-2.svg';\nimport italicIcon from '../assets/icons/italic.svg';\nimport imageIcon from '../assets/icons/image.svg';\nimport indentIcon from '../assets/icons/indent.svg';\nimport outdentIcon from '../assets/icons/outdent.svg';\nimport linkIcon from '../assets/icons/link.svg';\nimport listBulletIcon from '../assets/icons/list-bullet.svg';\nimport listCheckIcon from '../assets/icons/list-check.svg';\nimport listOrderedIcon from '../assets/icons/list-ordered.svg';\nimport subscriptIcon from '../assets/icons/subscript.svg';\nimport superscriptIcon from '../assets/icons/superscript.svg';\nimport strikeIcon from '../assets/icons/strike.svg';\nimport tableIcon from '../assets/icons/table.svg';\nimport underlineIcon from '../assets/icons/underline.svg';\nimport videoIcon from '../assets/icons/video.svg';\n\nexport default {\n  align: {\n    '': alignLeftIcon,\n    center: alignCenterIcon,\n    right: alignRightIcon,\n    justify: alignJustifyIcon,\n  },\n  background: backgroundIcon,\n  blockquote: blockquoteIcon,\n  bold: boldIcon,\n  clean: cleanIcon,\n  code: codeIcon,\n  'code-block': codeIcon,\n  color: colorIcon,\n  direction: {\n    '': directionLeftToRightIcon,\n    rtl: directionRightToLeftIcon,\n  },\n  formula: formulaIcon,\n  header: {\n    '1': headerIcon,\n    '2': header2Icon,\n  },\n  italic: italicIcon,\n  image: imageIcon,\n  indent: {\n    '+1': indentIcon,\n    '-1': outdentIcon,\n  },\n  link: linkIcon,\n  list: {\n    bullet: listBulletIcon,\n    check: listCheckIcon,\n    ordered: listOrderedIcon,\n  },\n  script: {\n    sub: subscriptIcon,\n    super: superscriptIcon,\n  },\n  strike: strikeIcon,\n  table: tableIcon,\n  underline: underlineIcon,\n  video: videoIcon,\n};\n","import DropdownIcon from '../assets/icons/dropdown.svg';\n\nlet optionsCounter = 0;\n\nfunction toggleAriaAttribute(element: HTMLElement, attribute: string) {\n  element.setAttribute(\n    attribute,\n    `${!(element.getAttribute(attribute) === 'true')}`,\n  );\n}\n\nclass Picker {\n  select: HTMLSelectElement;\n  container: HTMLElement;\n  label: HTMLElement;\n\n  constructor(select: HTMLSelectElement) {\n    this.select = select;\n    this.container = document.createElement('span');\n    this.buildPicker();\n    this.select.style.display = 'none';\n    // @ts-expect-error Fix me later\n    this.select.parentNode.insertBefore(this.container, this.select);\n\n    this.label.addEventListener('mousedown', () => {\n      this.togglePicker();\n    });\n    this.label.addEventListener('keydown', (event) => {\n      switch (event.key) {\n        case 'Enter':\n          this.togglePicker();\n          break;\n        case 'Escape':\n          this.escape();\n          event.preventDefault();\n          break;\n        default:\n      }\n    });\n    this.select.addEventListener('change', this.update.bind(this));\n  }\n\n  togglePicker() {\n    this.container.classList.toggle('ql-expanded');\n    // Toggle aria-expanded and aria-hidden to make the picker accessible\n    toggleAriaAttribute(this.label, 'aria-expanded');\n    // @ts-expect-error\n    toggleAriaAttribute(this.options, 'aria-hidden');\n  }\n\n  buildItem(option: HTMLOptionElement) {\n    const item = document.createElement('span');\n    // @ts-expect-error\n    item.tabIndex = '0';\n    item.setAttribute('role', 'button');\n    item.classList.add('ql-picker-item');\n    const value = option.getAttribute('value');\n    if (value) {\n      item.setAttribute('data-value', value);\n    }\n    if (option.textContent) {\n      item.setAttribute('data-label', option.textContent);\n    }\n    item.addEventListener('click', () => {\n      this.selectItem(item, true);\n    });\n    item.addEventListener('keydown', (event) => {\n      switch (event.key) {\n        case 'Enter':\n          this.selectItem(item, true);\n          event.preventDefault();\n          break;\n        case 'Escape':\n          this.escape();\n          event.preventDefault();\n          break;\n        default:\n      }\n    });\n\n    return item;\n  }\n\n  buildLabel() {\n    const label = document.createElement('span');\n    label.classList.add('ql-picker-label');\n    label.innerHTML = DropdownIcon;\n    // @ts-expect-error\n    label.tabIndex = '0';\n    label.setAttribute('role', 'button');\n    label.setAttribute('aria-expanded', 'false');\n    this.container.appendChild(label);\n    return label;\n  }\n\n  buildOptions() {\n    const options = document.createElement('span');\n    options.classList.add('ql-picker-options');\n\n    // Don't want screen readers to read this until options are visible\n    options.setAttribute('aria-hidden', 'true');\n    // @ts-expect-error\n    options.tabIndex = '-1';\n\n    // Need a unique id for aria-controls\n    options.id = `ql-picker-options-${optionsCounter}`;\n    optionsCounter += 1;\n    this.label.setAttribute('aria-controls', options.id);\n\n    // @ts-expect-error\n    this.options = options;\n\n    Array.from(this.select.options).forEach((option) => {\n      const item = this.buildItem(option);\n      options.appendChild(item);\n      if (option.selected === true) {\n        this.selectItem(item);\n      }\n    });\n    this.container.appendChild(options);\n  }\n\n  buildPicker() {\n    Array.from(this.select.attributes).forEach((item) => {\n      this.container.setAttribute(item.name, item.value);\n    });\n    this.container.classList.add('ql-picker');\n    this.label = this.buildLabel();\n    this.buildOptions();\n  }\n\n  escape() {\n    // Close menu and return focus to trigger label\n    this.close();\n    // Need setTimeout for accessibility to ensure that the browser executes\n    // focus on the next process thread and after any DOM content changes\n    setTimeout(() => this.label.focus(), 1);\n  }\n\n  close() {\n    this.container.classList.remove('ql-expanded');\n    this.label.setAttribute('aria-expanded', 'false');\n    // @ts-expect-error\n    this.options.setAttribute('aria-hidden', 'true');\n  }\n\n  selectItem(item: HTMLElement | null, trigger = false) {\n    const selected = this.container.querySelector('.ql-selected');\n    if (item === selected) return;\n    if (selected != null) {\n      selected.classList.remove('ql-selected');\n    }\n    if (item == null) return;\n    item.classList.add('ql-selected');\n    // @ts-expect-error Fix me later\n    this.select.selectedIndex = Array.from(item.parentNode.children).indexOf(\n      item,\n    );\n    if (item.hasAttribute('data-value')) {\n      // @ts-expect-error Fix me later\n      this.label.setAttribute('data-value', item.getAttribute('data-value'));\n    } else {\n      this.label.removeAttribute('data-value');\n    }\n    if (item.hasAttribute('data-label')) {\n      // @ts-expect-error Fix me later\n      this.label.setAttribute('data-label', item.getAttribute('data-label'));\n    } else {\n      this.label.removeAttribute('data-label');\n    }\n    if (trigger) {\n      this.select.dispatchEvent(new Event('change'));\n      this.close();\n    }\n  }\n\n  update() {\n    let option;\n    if (this.select.selectedIndex > -1) {\n      const item =\n        // @ts-expect-error Fix me later\n        this.container.querySelector('.ql-picker-options').children[\n          this.select.selectedIndex\n        ];\n      option = this.select.options[this.select.selectedIndex];\n      // @ts-expect-error\n      this.selectItem(item);\n    } else {\n      this.selectItem(null);\n    }\n    const isActive =\n      option != null &&\n      option !== this.select.querySelector('option[selected]');\n    this.label.classList.toggle('ql-active', isActive);\n  }\n}\n\nexport default Picker;\n","import Picker from './picker';\n\nclass ColorPicker extends Picker {\n  constructor(select: HTMLSelectElement, label: string) {\n    super(select);\n    this.label.innerHTML = label;\n    this.container.classList.add('ql-color-picker');\n    Array.from(this.container.querySelectorAll('.ql-picker-item'))\n      .slice(0, 7)\n      .forEach((item) => {\n        item.classList.add('ql-primary');\n      });\n  }\n\n  buildItem(option: HTMLOptionElement) {\n    const item = super.buildItem(option);\n    item.style.backgroundColor = option.getAttribute('value') || '';\n    return item;\n  }\n\n  selectItem(item: HTMLElement | null, trigger?: boolean) {\n    super.selectItem(item, trigger);\n    const colorLabel = this.label.querySelector<HTMLElement>('.ql-color-label');\n    const value = item ? item.getAttribute('data-value') || '' : '';\n    if (colorLabel) {\n      if (colorLabel.tagName === 'line') {\n        colorLabel.style.stroke = value;\n      } else {\n        colorLabel.style.fill = value;\n      }\n    }\n  }\n}\n\nexport default ColorPicker;\n","import Picker from './picker';\n\nclass IconPicker extends Picker {\n  defaultItem: HTMLElement | null;\n\n  constructor(select: HTMLSelectElement, icons: Record<string, string>) {\n    super(select);\n    this.container.classList.add('ql-icon-picker');\n    Array.from(this.container.querySelectorAll('.ql-picker-item')).forEach(\n      (item) => {\n        item.innerHTML = icons[item.getAttribute('data-value') || ''];\n      },\n    );\n    this.defaultItem = this.container.querySelector('.ql-selected');\n    this.selectItem(this.defaultItem);\n  }\n\n  selectItem(target: HTMLElement | null, trigger?: boolean) {\n    super.selectItem(target, trigger);\n    const item = target || this.defaultItem;\n    if (item != null) {\n      if (this.label.innerHTML === item.innerHTML) return;\n      this.label.innerHTML = item.innerHTML;\n    }\n  }\n}\n\nexport default IconPicker;\n","import type Quill from '../core';\nimport type { Bounds } from '../core/selection';\n\nconst isScrollable = (el: Element) => {\n  const { overflowY } = getComputedStyle(el, null);\n  return overflowY !== 'visible' && overflowY !== 'clip';\n};\n\nclass Tooltip {\n  quill: Quill;\n  boundsContainer: HTMLElement;\n  root: HTMLDivElement;\n\n  constructor(quill: Quill, boundsContainer?: HTMLElement) {\n    this.quill = quill;\n    this.boundsContainer = boundsContainer || document.body;\n    this.root = quill.addContainer('ql-tooltip');\n    // @ts-expect-error\n    this.root.innerHTML = this.constructor.TEMPLATE;\n    if (isScrollable(this.quill.root)) {\n      this.quill.root.addEventListener('scroll', () => {\n        this.root.style.marginTop = `${-1 * this.quill.root.scrollTop}px`;\n      });\n    }\n    this.hide();\n  }\n\n  hide() {\n    this.root.classList.add('ql-hidden');\n  }\n\n  position(reference: Bounds) {\n    const left =\n      reference.left + reference.width / 2 - this.root.offsetWidth / 2;\n    // root.scrollTop should be 0 if scrollContainer !== root\n    const top = reference.bottom + this.quill.root.scrollTop;\n    this.root.style.left = `${left}px`;\n    this.root.style.top = `${top}px`;\n    this.root.classList.remove('ql-flip');\n    const containerBounds = this.boundsContainer.getBoundingClientRect();\n    const rootBounds = this.root.getBoundingClientRect();\n    let shift = 0;\n    if (rootBounds.right > containerBounds.right) {\n      shift = containerBounds.right - rootBounds.right;\n      this.root.style.left = `${left + shift}px`;\n    }\n    if (rootBounds.left < containerBounds.left) {\n      shift = containerBounds.left - rootBounds.left;\n      this.root.style.left = `${left + shift}px`;\n    }\n    if (rootBounds.bottom > containerBounds.bottom) {\n      const height = rootBounds.bottom - rootBounds.top;\n      const verticalShift = reference.bottom - reference.top + height;\n      this.root.style.top = `${top - verticalShift}px`;\n      this.root.classList.add('ql-flip');\n    }\n    return shift;\n  }\n\n  show() {\n    this.root.classList.remove('ql-editing');\n    this.root.classList.remove('ql-hidden');\n  }\n}\n\nexport default Tooltip;\n","import { merge } from 'lodash-es';\nimport type Quill from '../core/quill';\nimport Emitter from '../core/emitter';\nimport Theme from '../core/theme';\nimport type { ThemeOptions } from '../core/theme';\nimport ColorPicker from '../ui/color-picker';\nimport IconPicker from '../ui/icon-picker';\nimport Picker from '../ui/picker';\nimport Tooltip from '../ui/tooltip';\nimport type { Range } from '../core/selection';\nimport type Clipboard from '../modules/clipboard';\nimport type History from '../modules/history';\nimport type Keyboard from '../modules/keyboard';\nimport type Uploader from '../modules/uploader';\nimport type Selection from '../core/selection';\n\nconst ALIGNS = [false, 'center', 'right', 'justify'];\n\nconst COLORS = [\n  '#000000',\n  '#e60000',\n  '#ff9900',\n  '#ffff00',\n  '#008a00',\n  '#0066cc',\n  '#9933ff',\n  '#ffffff',\n  '#facccc',\n  '#ffebcc',\n  '#ffffcc',\n  '#cce8cc',\n  '#cce0f5',\n  '#ebd6ff',\n  '#bbbbbb',\n  '#f06666',\n  '#ffc266',\n  '#ffff66',\n  '#66b966',\n  '#66a3e0',\n  '#c285ff',\n  '#888888',\n  '#a10000',\n  '#b26b00',\n  '#b2b200',\n  '#006100',\n  '#0047b2',\n  '#6b24b2',\n  '#444444',\n  '#5c0000',\n  '#663d00',\n  '#666600',\n  '#003700',\n  '#002966',\n  '#3d1466',\n];\n\nconst FONTS = [false, 'serif', 'monospace'];\n\nconst HEADERS = ['1', '2', '3', false];\n\nconst SIZES = ['small', false, 'large', 'huge'];\n\nclass BaseTheme extends Theme {\n  pickers: Picker[];\n  tooltip?: Tooltip;\n\n  constructor(quill: Quill, options: ThemeOptions) {\n    super(quill, options);\n    const listener = (e: MouseEvent) => {\n      if (!document.body.contains(quill.root)) {\n        document.body.removeEventListener('click', listener);\n        return;\n      }\n      if (\n        this.tooltip != null &&\n        // @ts-expect-error\n        !this.tooltip.root.contains(e.target) &&\n        // @ts-expect-error\n        document.activeElement !== this.tooltip.textbox &&\n        !this.quill.hasFocus()\n      ) {\n        this.tooltip.hide();\n      }\n      if (this.pickers != null) {\n        this.pickers.forEach((picker) => {\n          // @ts-expect-error\n          if (!picker.container.contains(e.target)) {\n            picker.close();\n          }\n        });\n      }\n    };\n    quill.emitter.listenDOM('click', document.body, listener);\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: 'selection'): Selection;\n  addModule(name: string): unknown;\n  addModule(name: string) {\n    const module = super.addModule(name);\n    if (name === 'toolbar') {\n      // @ts-expect-error\n      this.extendToolbar(module);\n    }\n    return module;\n  }\n\n  buildButtons(\n    buttons: NodeListOf<HTMLElement>,\n    icons: Record<string, Record<string, string> | string>,\n  ) {\n    Array.from(buttons).forEach((button) => {\n      const className = button.getAttribute('class') || '';\n      className.split(/\\s+/).forEach((name) => {\n        if (!name.startsWith('ql-')) return;\n        name = name.slice('ql-'.length);\n        if (icons[name] == null) return;\n        if (name === 'direction') {\n          // @ts-expect-error\n          button.innerHTML = icons[name][''] + icons[name].rtl;\n        } else if (typeof icons[name] === 'string') {\n          // @ts-expect-error\n          button.innerHTML = icons[name];\n        } else {\n          // @ts-expect-error\n          const value = button.value || '';\n          // @ts-expect-error\n          if (value != null && icons[name][value]) {\n            // @ts-expect-error\n            button.innerHTML = icons[name][value];\n          }\n        }\n      });\n    });\n  }\n\n  buildPickers(\n    selects: NodeListOf<HTMLSelectElement>,\n    icons: Record<string, string | Record<string, string>>,\n  ) {\n    this.pickers = Array.from(selects).map((select) => {\n      if (select.classList.contains('ql-align')) {\n        if (select.querySelector('option') == null) {\n          fillSelect(select, ALIGNS);\n        }\n        if (typeof icons.align === 'object') {\n          return new IconPicker(select, icons.align);\n        }\n      }\n      if (\n        select.classList.contains('ql-background') ||\n        select.classList.contains('ql-color')\n      ) {\n        const format = select.classList.contains('ql-background')\n          ? 'background'\n          : 'color';\n        if (select.querySelector('option') == null) {\n          fillSelect(\n            select,\n            COLORS,\n            format === 'background' ? '#ffffff' : '#000000',\n          );\n        }\n        return new ColorPicker(select, icons[format] as string);\n      }\n      if (select.querySelector('option') == null) {\n        if (select.classList.contains('ql-font')) {\n          fillSelect(select, FONTS);\n        } else if (select.classList.contains('ql-header')) {\n          fillSelect(select, HEADERS);\n        } else if (select.classList.contains('ql-size')) {\n          fillSelect(select, SIZES);\n        }\n      }\n      return new Picker(select);\n    });\n    const update = () => {\n      this.pickers.forEach((picker) => {\n        picker.update();\n      });\n    };\n    this.quill.on(Emitter.events.EDITOR_CHANGE, update);\n  }\n}\nBaseTheme.DEFAULTS = merge({}, Theme.DEFAULTS, {\n  modules: {\n    toolbar: {\n      handlers: {\n        formula() {\n          this.quill.theme.tooltip.edit('formula');\n        },\n        image() {\n          let fileInput = this.container.querySelector(\n            'input.ql-image[type=file]',\n          );\n          if (fileInput == null) {\n            fileInput = document.createElement('input');\n            fileInput.setAttribute('type', 'file');\n            fileInput.setAttribute(\n              'accept',\n              this.quill.uploader.options.mimetypes.join(', '),\n            );\n            fileInput.classList.add('ql-image');\n            fileInput.addEventListener('change', () => {\n              const range = this.quill.getSelection(true);\n              this.quill.uploader.upload(range, fileInput.files);\n              fileInput.value = '';\n            });\n            this.container.appendChild(fileInput);\n          }\n          fileInput.click();\n        },\n        video() {\n          this.quill.theme.tooltip.edit('video');\n        },\n      },\n    },\n  },\n});\n\nclass BaseTooltip extends Tooltip {\n  textbox: HTMLInputElement | null;\n  linkRange?: Range;\n\n  constructor(quill: Quill, boundsContainer?: HTMLElement) {\n    super(quill, boundsContainer);\n    this.textbox = this.root.querySelector('input[type=\"text\"]');\n    this.listen();\n  }\n\n  listen() {\n    // @ts-expect-error Fix me later\n    this.textbox.addEventListener('keydown', (event) => {\n      if (event.key === 'Enter') {\n        this.save();\n        event.preventDefault();\n      } else if (event.key === 'Escape') {\n        this.cancel();\n        event.preventDefault();\n      }\n    });\n  }\n\n  cancel() {\n    this.hide();\n    this.restoreFocus();\n  }\n\n  edit(mode = 'link', preview: string | null = null) {\n    this.root.classList.remove('ql-hidden');\n    this.root.classList.add('ql-editing');\n    if (this.textbox == null) return;\n\n    if (preview != null) {\n      this.textbox.value = preview;\n    } else if (mode !== this.root.getAttribute('data-mode')) {\n      this.textbox.value = '';\n    }\n    const bounds = this.quill.getBounds(this.quill.selection.savedRange);\n    if (bounds != null) {\n      this.position(bounds);\n    }\n    this.textbox.select();\n    this.textbox.setAttribute(\n      'placeholder',\n      this.textbox.getAttribute(`data-${mode}`) || '',\n    );\n    this.root.setAttribute('data-mode', mode);\n  }\n\n  restoreFocus() {\n    this.quill.focus({ preventScroll: true });\n  }\n\n  save() {\n    // @ts-expect-error Fix me later\n    let { value } = this.textbox;\n    switch (this.root.getAttribute('data-mode')) {\n      case 'link': {\n        const { scrollTop } = this.quill.root;\n        if (this.linkRange) {\n          this.quill.formatText(\n            this.linkRange,\n            'link',\n            value,\n            Emitter.sources.USER,\n          );\n          delete this.linkRange;\n        } else {\n          this.restoreFocus();\n          this.quill.format('link', value, Emitter.sources.USER);\n        }\n        this.quill.root.scrollTop = scrollTop;\n        break;\n      }\n      case 'video': {\n        value = extractVideoUrl(value);\n      } // eslint-disable-next-line no-fallthrough\n      case 'formula': {\n        if (!value) break;\n        const range = this.quill.getSelection(true);\n        if (range != null) {\n          const index = range.index + range.length;\n          this.quill.insertEmbed(\n            index,\n            // @ts-expect-error Fix me later\n            this.root.getAttribute('data-mode'),\n            value,\n            Emitter.sources.USER,\n          );\n          if (this.root.getAttribute('data-mode') === 'formula') {\n            this.quill.insertText(index + 1, ' ', Emitter.sources.USER);\n          }\n          this.quill.setSelection(index + 2, Emitter.sources.USER);\n        }\n        break;\n      }\n      default:\n    }\n    // @ts-expect-error Fix me later\n    this.textbox.value = '';\n    this.hide();\n  }\n}\n\nfunction extractVideoUrl(url: string) {\n  let match =\n    url.match(\n      /^(?:(https?):\\/\\/)?(?:(?:www|m)\\.)?youtube\\.com\\/watch.*v=([a-zA-Z0-9_-]+)/,\n    ) ||\n    url.match(/^(?:(https?):\\/\\/)?(?:(?:www|m)\\.)?youtu\\.be\\/([a-zA-Z0-9_-]+)/);\n  if (match) {\n    return `${match[1] || 'https'}://www.youtube.com/embed/${\n      match[2]\n    }?showinfo=0`;\n  }\n  // eslint-disable-next-line no-cond-assign\n  if ((match = url.match(/^(?:(https?):\\/\\/)?(?:www\\.)?vimeo\\.com\\/(\\d+)/))) {\n    return `${match[1] || 'https'}://player.vimeo.com/video/${match[2]}/`;\n  }\n  return url;\n}\n\nfunction fillSelect(\n  select: HTMLSelectElement,\n  values: Array<string | boolean>,\n  defaultValue: unknown = false,\n) {\n  values.forEach((value) => {\n    const option = document.createElement('option');\n    if (value === defaultValue) {\n      option.setAttribute('selected', 'selected');\n    } else {\n      option.setAttribute('value', String(value));\n    }\n    select.appendChild(option);\n  });\n}\n\nexport { BaseTooltip, BaseTheme as default };\n","import { merge } from 'lodash-es';\nimport Emitter from '../core/emitter';\nimport BaseTheme, { BaseTooltip } from './base';\nimport { Range } from '../core/selection';\nimport type { Bounds } from '../core/selection';\nimport icons from '../ui/icons';\nimport type Quill from '../core';\nimport type { ThemeOptions } from '../core/theme';\nimport type Toolbar from '../modules/toolbar';\nimport type { ToolbarConfig } from '../modules/toolbar';\n\nconst TOOLBAR_CONFIG: ToolbarConfig = [\n  ['bold', 'italic', 'link'],\n  [{ header: 1 }, { header: 2 }, 'blockquote'],\n];\n\nclass BubbleTooltip extends BaseTooltip {\n  static TEMPLATE = [\n    '<span class=\"ql-tooltip-arrow\"></span>',\n    '<div class=\"ql-tooltip-editor\">',\n    '<input type=\"text\" data-formula=\"e=mc^2\" data-link=\"https://quilljs.com\" data-video=\"Embed URL\">',\n    '<a class=\"ql-close\"></a>',\n    '</div>',\n  ].join('');\n\n  constructor(quill: Quill, bounds?: HTMLElement) {\n    super(quill, bounds);\n    this.quill.on(\n      Emitter.events.EDITOR_CHANGE,\n      (type, range, oldRange, source) => {\n        if (type !== Emitter.events.SELECTION_CHANGE) return;\n        if (\n          range != null &&\n          range.length > 0 &&\n          source === Emitter.sources.USER\n        ) {\n          this.show();\n          // Lock our width so we will expand beyond our offsetParent boundaries\n          this.root.style.left = '0px';\n          this.root.style.width = '';\n          this.root.style.width = `${this.root.offsetWidth}px`;\n          const lines = this.quill.getLines(range.index, range.length);\n          if (lines.length === 1) {\n            const bounds = this.quill.getBounds(range);\n            if (bounds != null) {\n              this.position(bounds);\n            }\n          } else {\n            const lastLine = lines[lines.length - 1];\n            const index = this.quill.getIndex(lastLine);\n            const length = Math.min(\n              lastLine.length() - 1,\n              range.index + range.length - index,\n            );\n            const indexBounds = this.quill.getBounds(new Range(index, length));\n            if (indexBounds != null) {\n              this.position(indexBounds);\n            }\n          }\n        } else if (\n          document.activeElement !== this.textbox &&\n          this.quill.hasFocus()\n        ) {\n          this.hide();\n        }\n      },\n    );\n  }\n\n  listen() {\n    super.listen();\n    // @ts-expect-error Fix me later\n    this.root.querySelector('.ql-close').addEventListener('click', () => {\n      this.root.classList.remove('ql-editing');\n    });\n    this.quill.on(Emitter.events.SCROLL_OPTIMIZE, () => {\n      // Let selection be restored by toolbar handlers before repositioning\n      setTimeout(() => {\n        if (this.root.classList.contains('ql-hidden')) return;\n        const range = this.quill.getSelection();\n        if (range != null) {\n          const bounds = this.quill.getBounds(range);\n          if (bounds != null) {\n            this.position(bounds);\n          }\n        }\n      }, 1);\n    });\n  }\n\n  cancel() {\n    this.show();\n  }\n\n  position(reference: Bounds) {\n    const shift = super.position(reference);\n    const arrow = this.root.querySelector('.ql-tooltip-arrow');\n    // @ts-expect-error\n    arrow.style.marginLeft = '';\n    if (shift !== 0) {\n      // @ts-expect-error\n      arrow.style.marginLeft = `${-1 * shift - arrow.offsetWidth / 2}px`;\n    }\n    return shift;\n  }\n}\n\nclass BubbleTheme extends BaseTheme {\n  constructor(quill: Quill, options: ThemeOptions) {\n    if (\n      options.modules.toolbar != null &&\n      options.modules.toolbar.container == null\n    ) {\n      options.modules.toolbar.container = TOOLBAR_CONFIG;\n    }\n    super(quill, options);\n    this.quill.container.classList.add('ql-bubble');\n  }\n\n  extendToolbar(toolbar: Toolbar) {\n    // @ts-expect-error\n    this.tooltip = new BubbleTooltip(this.quill, this.options.bounds);\n    if (toolbar.container != null) {\n      this.tooltip.root.appendChild<HTMLElement>(toolbar.container);\n      this.buildButtons(toolbar.container.querySelectorAll('button'), icons);\n      this.buildPickers(toolbar.container.querySelectorAll('select'), icons);\n    }\n  }\n}\nBubbleTheme.DEFAULTS = merge({}, BaseTheme.DEFAULTS, {\n  modules: {\n    toolbar: {\n      handlers: {\n        link(value: string) {\n          if (!value) {\n            this.quill.format('link', false);\n          } else {\n            this.quill.theme.tooltip.edit();\n          }\n        },\n      },\n    },\n  },\n});\n\nexport { BubbleTooltip, BubbleTheme as default };\n","import { merge } from 'lodash-es';\nimport Emitter from '../core/emitter';\nimport BaseTheme, { BaseTooltip } from './base';\nimport LinkBlot from '../formats/link';\nimport { Range } from '../core/selection';\nimport icons from '../ui/icons';\nimport type Quill from '../core';\nimport type { Context } from '../modules/keyboard';\nimport type Toolbar from '../modules/toolbar';\nimport type { ToolbarConfig } from '../modules/toolbar';\nimport type { ThemeOptions } from '../core/theme';\n\nconst TOOLBAR_CONFIG: ToolbarConfig = [\n  [{ header: ['1', '2', '3', false] }],\n  ['bold', 'italic', 'underline', 'link'],\n  [{ list: 'ordered' }, { list: 'bullet' }],\n  ['clean'],\n];\n\nclass SnowTooltip extends BaseTooltip {\n  static TEMPLATE = [\n    '<a class=\"ql-preview\" rel=\"noopener noreferrer\" target=\"_blank\" href=\"about:blank\"></a>',\n    '<input type=\"text\" data-formula=\"e=mc^2\" data-link=\"https://quilljs.com\" data-video=\"Embed URL\">',\n    '<a class=\"ql-action\"></a>',\n    '<a class=\"ql-remove\"></a>',\n  ].join('');\n\n  preview = this.root.querySelector('a.ql-preview');\n\n  listen() {\n    super.listen();\n    // @ts-expect-error Fix me later\n    this.root\n      .querySelector('a.ql-action')\n      .addEventListener('click', (event) => {\n        if (this.root.classList.contains('ql-editing')) {\n          this.save();\n        } else {\n          // @ts-expect-error Fix me later\n          this.edit('link', this.preview.textContent);\n        }\n        event.preventDefault();\n      });\n    // @ts-expect-error Fix me later\n    this.root\n      .querySelector('a.ql-remove')\n      .addEventListener('click', (event) => {\n        if (this.linkRange != null) {\n          const range = this.linkRange;\n          this.restoreFocus();\n          this.quill.formatText(range, 'link', false, Emitter.sources.USER);\n          delete this.linkRange;\n        }\n        event.preventDefault();\n        this.hide();\n      });\n    this.quill.on(\n      Emitter.events.SELECTION_CHANGE,\n      (range, oldRange, source) => {\n        if (range == null) return;\n        if (range.length === 0 && source === Emitter.sources.USER) {\n          const [link, offset] = this.quill.scroll.descendant(\n            LinkBlot,\n            range.index,\n          );\n          if (link != null) {\n            this.linkRange = new Range(range.index - offset, link.length());\n            const preview = LinkBlot.formats(link.domNode);\n            // @ts-expect-error Fix me later\n            this.preview.textContent = preview;\n            // @ts-expect-error Fix me later\n            this.preview.setAttribute('href', preview);\n            this.show();\n            const bounds = this.quill.getBounds(this.linkRange);\n            if (bounds != null) {\n              this.position(bounds);\n            }\n            return;\n          }\n        } else {\n          delete this.linkRange;\n        }\n        this.hide();\n      },\n    );\n  }\n\n  show() {\n    super.show();\n    this.root.removeAttribute('data-mode');\n  }\n}\n\nclass SnowTheme extends BaseTheme {\n  constructor(quill: Quill, options: ThemeOptions) {\n    if (\n      options.modules.toolbar != null &&\n      options.modules.toolbar.container == null\n    ) {\n      options.modules.toolbar.container = TOOLBAR_CONFIG;\n    }\n    super(quill, options);\n    this.quill.container.classList.add('ql-snow');\n  }\n\n  extendToolbar(toolbar: Toolbar) {\n    if (toolbar.container != null) {\n      toolbar.container.classList.add('ql-snow');\n      this.buildButtons(toolbar.container.querySelectorAll('button'), icons);\n      this.buildPickers(toolbar.container.querySelectorAll('select'), icons);\n      // @ts-expect-error\n      this.tooltip = new SnowTooltip(this.quill, this.options.bounds);\n      if (toolbar.container.querySelector('.ql-link')) {\n        this.quill.keyboard.addBinding(\n          { key: 'k', shortKey: true },\n          (_range: Range, context: Context) => {\n            toolbar.handlers.link.call(toolbar, !context.format.link);\n          },\n        );\n      }\n    }\n  }\n}\nSnowTheme.DEFAULTS = merge({}, BaseTheme.DEFAULTS, {\n  modules: {\n    toolbar: {\n      handlers: {\n        link(value: string) {\n          if (value) {\n            const range = this.quill.getSelection();\n            if (range == null || range.length === 0) return;\n            let preview = this.quill.getText(range);\n            if (\n              /^\\S+@\\S+\\.\\S+$/.test(preview) &&\n              preview.indexOf('mailto:') !== 0\n            ) {\n              preview = `mailto:${preview}`;\n            }\n            const { tooltip } = this.quill.theme;\n            tooltip.edit('link', preview);\n          } else {\n            this.quill.format('link', false);\n          }\n        },\n      },\n    },\n  },\n});\n\nexport default SnowTheme;\n","import Quill from './core';\n\nimport { AlignClass, AlignStyle } from './formats/align';\nimport {\n  DirectionAttribute,\n  DirectionClass,\n  DirectionStyle,\n} from './formats/direction';\nimport Indent from './formats/indent';\n\nimport Blockquote from './formats/blockquote';\nimport Header from './formats/header';\nimport List 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 Formula from './formats/formula';\nimport Image from './formats/image';\nimport Video from './formats/video';\n\nimport CodeBlock, { Code as InlineCode } from './formats/code';\n\nimport Syntax from './modules/syntax';\nimport Table from './modules/table';\nimport Toolbar from './modules/toolbar';\n\nimport Icons from './ui/icons';\nimport Picker from './ui/picker';\nimport ColorPicker from './ui/color-picker';\nimport IconPicker from './ui/icon-picker';\nimport Tooltip from './ui/tooltip';\n\nimport BubbleTheme from './themes/bubble';\nimport SnowTheme from './themes/snow';\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 default Quill;\n","import Bold from './bold';\n\nclass Italic extends Bold {\n  static blotName = 'italic';\n  static tagName = ['EM', 'I'];\n}\n\nexport default Italic;\n","import Bold from './bold';\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","blockDelta","deleteAt","index","length","super","formatAt","name","value","scroll","query","Scope","BLOCK","format","Math","min","insertAt","def","lines","split","text","shift","children","tail","block","reduce","lineIndex","line","insertBefore","blot","ref","head","Break","remove","moveChildren","target","optimize","context","path","removeChild","child","force","arguments","undefined","clone","parent","next","blotName","tagName","defaultChild","allowedChildren","Inline","EmbedBlot","TextBlot","BlockEmbed","attach","attributes","AttributorStore","domNode","Delta","insert","formats","values","attribute","BLOCK_ATTRIBUTE","pop","blocks","map","create","forEach","filter","descendants","LeafBlot","leaf","bubbleFormats","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","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","lastRecorded","ignoreChange","stack","undo","redo","currentRange","quill","options","on","Quill","EDITOR_CHANGE","eventName","oldValue","SELECTION_CHANGE","SILENT","TEXT_CHANGE","userOnly","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","delay","compose","maxStack","transformStack","stackItem","setSelection","deleteLength","delete","changeIndex","lastOp","attr","endsWithNewlineChange","getLastChangeIndex","remoteDelta","i","oldItem","splice","transformPosition","DEFAULTS","Uploader","native","caretRangeFromPoint","clientX","clientY","caretPositionFromPoint","createRange","setStart","offsetNode","setEnd","normalized","normalizeNative","normalizedToRange","dataTransfer","files","upload","uploads","file","mimetypes","includes","handler","call","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","debug","logger","_len","args","_key","querySelectorAll","instances","get","handleDOM","EventEmitter","COMPOSITION_START","COMPOSITION_BEFORE_END","COMPOSITION_END","API","domListeners","error","_len2","_key2","log","_len3","_key3","contains","listenDOM","WeakMap","levels","level","method","console","namespace","ns","newLevel","ASCII","convertListHTML","items","lastIndent","endTag","getListType","indent","rest","tag","convertHTML","previousType","excludeOuterTag","html","list","parts","outerHTML","innerHTML","Element","combineFormats","combined","merged","combinedValue","normalizeDelta","normalizedDelta","shiftRange","amount","Range","getDelta","applyDelta","scrollLength","deleteDelta","splitOpLines","isImplicitNewlinePrepended","isImplicitNewlineAppended","merge","isInlineEmbed","prependedLength","addedLength","deleteText","formatLine","max","cloneDeep","formatText","leaves","lineFormats","leafFormats","blots","getHTML","lineOffset","lineLength","getText","contents","insertEmbed","insertText","isBlank","removeFormat","suffixLength","suffix","selectionInfo","match","textBlot","CursorBlot","oldText","relativeSelectionInfo","oldRange","isEqual","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","globalRegistry","Parchment","uiClass","bounds","modules","placeholder","readOnly","theme","parchment","Theme","limit","bubble","import","imports","overwrite","attrName","warn","startsWith","container","userConfig","expandedConfig","clipboard","history","uploader","Error","themeConfig","config","moduleConfig","moduleClass","toolbar","selector","querySelector","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","getBounds","containerBounds","getLength","getIndex","getLeaf","getLine","getModule","getSemanticHTML","hasFocus","off","scrollRectIntoView","targetRect","ownerDocument","current","isDocumentBody","body","bounding","window","visualViewport","documentElement","style","scrollDistanceX","scrollPaddingLeft","scrollPaddingRight","scrollDistanceY","scrollPaddingTop","scrollPaddingBottom","defaultView","scrollBy","scrollLeft","scrollTop","scrolledLeft","scrolledTop","parentElement","getRootNode","host","scrollIntoView","delete1","applied","delete2","setText","lengthOrSource","pos","mouseDown","cursor","savedRange","lastNative","handleComposition","handleDragging","setTimeout","setNativeRange","triggeredByTyping","ignored","nativeRange","after","side","rangeCount","info","isConnected","activeElement","positions","indexes","endContainer","rangeToNative","getPosition","inclusive","leafOffset","default","ModuleClass","whitelist","AlignAttribute","Attributor","AlignClass","ClassAttributor","AlignStyle","StyleAttributor","BackgroundClass","BackgroundStyle","ColorAttributor","CodeBlockContainer","code","innerText","CodeBlock","Code","requiredContainer","component","toString","ColorClass","ColorStyle","DirectionAttribute","DirectionClass","DirectionStyle","FontClass","FontStyleAttributor","FontStyle","SizeClass","SizeStyle","CLIPBOARD_CONFIG","TEXT_NODE","isPre","replacer","collapse","replaced","previousSibling","nextSibling","matchNewline","deltaEndsWith","ELEMENT_NODE","prototype","applyFormat","classes","styles","ATTRIBUTE","ATTRIBUTE_ATTRIBUTORS","keyName","STYLE_ATTRIBUTORS","fontStyle","italic","textDecoration","underline","strike","fontWeight","bold","parseFloat","textIndent","composed","table","matchAlias","memo","onCaptureCopy","onCapturePaste","matchers","matcher","addMatcher","DOMParser","parseFromString","nodeMatches","elementMatchers","textMatchers","prepareMatching","traverse","dangerouslyPasteHTML","paste","isCut","onCopy","clipboardData","setData","doc","childElementCount","firstElementChild","onPaste","pastedDelta","pair","has","matches","newDelta","endText","toLowerCase","preNodes","nodeType","childrenDelta","reducedDelta","firstChild","SHORTKEY","evt","binding","which","bindings","handleEnter","metaKey","altKey","handleBackspace","handleDelete","prefix","handleDeleteRange","listen","keyBinding","normalize","singleBinding","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","DIFF_DELETE","DIFF_INSERT","DIFF_EQUAL","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_","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","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","freeModule","moduleExports","addMapEntry","addSetEntry","arrayReduce","array","iteratee","accumulator","initAccum","isHostObject","mapToArray","size","overArg","func","arg","setToArray","uid","arrayProto","funcProto","objectProto","coreJsData","maskSrcKey","exec","IE_PROTO","funcToString","hasOwnProperty","objectToString","reIsNative","RegExp","Buffer","Symbol","Uint8Array","getPrototype","getPrototypeOf","objectCreate","propertyIsEnumerable","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","isBuffer","nativeKeys","DataView","getNative","Map","Set","nativeCreate","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","valueOf","Hash","entry","ListCache","MapCache","Stack","__data__","assignValue","object","objValue","eq","assocIndexOf","baseClone","isDeep","isFull","customizer","isObject","isArr","input","initCloneArray","copyArray","getTag","isFunc","buffer","copy","cloneBuffer","isPrototype","proto","initCloneObject","copyObject","getSymbols","copySymbols","baseAssign","cloneFunc","symbol","Ctor","cloneArrayBuffer","dataView","byteOffset","byteLength","cloneDataView","typedArray","cloneTypedArray","cloneMap","regexp","lastIndex","cloneRegExp","cloneSet","initCloneByTag","stacked","props","keysFunc","symbolsFunc","arrayPush","baseGetAllKeys","getAllKeys","arrayEach","subValue","arrayBuffer","newValue","getMapData","getValue","isFunction","baseIsNative","pairs","LARGE_ARRAY_SIZE","isIndex","ArrayBuffer","ctorString","isArrayLike","isLength","inherited","isObjectLike","isArrayLikeObject","isArguments","baseTimes","String","skipIndexes","arrayLikeKeys","baseKeys","COMPARE_PARTIAL_FLAG","COMPARE_UNORDERED_FLAG","arrayTag","asyncTag","errorTag","nullTag","proxyTag","undefinedTag","typedArrayTags","freeProcess","process","nodeUtil","nodeIsTypedArray","isTypedArray","arraySome","predicate","nativeObjectToString","symToStringTag","toStringTag","SetCache","baseGetTag","isOwn","unmasked","getRawTag","baseIsArguments","baseIsEqual","bitmask","equalFunc","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","equalArrays","message","isPartial","equalByTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","objProps","objLength","skipCtor","othValue","compared","objCtor","othCtor","equalObjects","baseIsEqualDeep","arrLength","othLength","seen","arrValue","othIndex","isMasked","resIndex","arrayFilter","baseUnary","isArg","isBuff","isType","defineProperty","a","keepNull","attrs","baseInverted","priority","OpIterator","AttributeMap_1","Op_1","OpIterator_1","NULL_CHARACTER","fromCharCode","getEmbedTypeAndData","embedType","registerEmbed","handlers","unregisterEmbed","getHandler","newOp","chop","partition","passed","failed","initialValue","changeLength","elem","Infinity","iter","hasNext","nextOp","thisIter","otherIter","firstOther","peek","firstLeft","peekType","peekLength","thisOp","otherOp","action","thisData","otherData","strings","retDelta","diffResult","opLength","eachLine","newline","inverted","baseIndex","baseOp","opData","baseOpData","transformedData","nextType","retOp","substr","Events","EE","fn","addListener","TypeError","_events","_eventsCount","clearEvent","__proto__","eventNames","names","listeners","l","ee","listenerCount","a1","a2","a3","a4","a5","len","removeListener","apply","removeAllListeners","prefixed","allocUnsafe","isNew","global","stubArray","require","keysIn","nodeIsMap","isMap","nodeIsSet","isSet","isFlat","arrStacked","othStacked","objStacked","isProto","count","lastCalled","assigner","iterable","objectCtorString","srcIndex","mergeFunc","srcValue","isCommon","isTyped","baseMerge","nativeMax","string","nativeNow","stamp","remaining","otherArgs","thisArg","guard","TYPE","LEVEL","INLINE_ATTRIBUTE","ANY","t","r","canAdd","removeAttribute","N","tags","h","inline","toUpperCase","M","K","Y","D","build","move","cloneNode","replaceWith","C","B","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","A","q","append","at","iterator","o","c","U","replaceChild","f","attachUI","reverse","enforceAllowedChildren","splitAfter","addedNodes","removedNodes","sort","DOCUMENT_POSITION_FOLLOWING","m","u","V","O","T","L","checkMerge","I","X","characterData","characterDataOldValue","childList","subtree","p","MutationObserver","observe","disconnect","mutationsMap","v","P","w","W","z","E","splitText","R","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","id","loaded","__webpack_modules__","getter","__esModule","definition","enumerable","globalThis","obj","prop","nmd","paths","IndentAttributor","normalizedValue","Blockquote","Header","ListContainer","ListItem","ui","listEventHandler","Bold","Link","sanitize","url","PROTOCOL_WHITELIST","SANITIZED_URL","protocols","anchor","href","protocol","Script","Underline","Formula","katex","render","throwOnError","errorColor","formula","ATTRIBUTES","Image","hasAttribute","execCommand","Video","video","TokenAttributor","CodeToken","SyntaxCodeBlock","SyntaxCodeBlockContainer","forceNext","highlight","forced","language","cachedText","codeBlock","BreakBlot","Syntax","hljs","languages","highlightBlot","initListener","initTimer","select","label","option","timer","clearTimeout","interval","nodeText","TableCell","tableId","cellOffset","rowOffset","TableRow","thisHead","thisTail","nextHead","nextTail","childFormats","TableBody","TableContainer","balanceCells","rows","maxColumns","fill","cells","column","deleteColumn","insertColumn","insertRow","random","Table","listenBalanceCells","balanceTables","deleteRow","deleteTable","insertColumnLeft","insertColumnRight","insertRowAbove","insertRowBelow","insertTable","columns","old","Toolbar","groups","controls","group","control","addButton","addSelect","addControls","HTMLElement","addHandler","selectedIndex","selected","prompt","isActive","clean","direction","align","link","center","justify","background","codeIcon","color","rtl","bullet","check","ordered","script","sub","optionsCounter","toggleAriaAttribute","buildPicker","display","togglePicker","escape","buildItem","tabIndex","selectItem","buildLabel","buildOptions","close","trigger","dispatchEvent","Event","Picker","backgroundColor","colorLabel","stroke","icons","defaultItem","boundsContainer","TEMPLATE","el","overflowY","isScrollable","marginTop","hide","reference","rootBounds","verticalShift","show","ALIGNS","COLORS","FONTS","HEADERS","SIZES","BaseTheme","tooltip","textbox","pickers","picker","removeEventListener","extendToolbar","buildButtons","buttons","button","buildPickers","selects","fillSelect","IconPicker","ColorPicker","fileInput","click","BaseTooltip","Tooltip","save","cancel","restoreFocus","mode","preview","linkRange","extractVideoUrl","defaultValue","TOOLBAR_CONFIG","BubbleTooltip","lastLine","indexBounds","arrow","marginLeft","BubbleTheme","SnowTooltip","LinkBlot","SnowTheme","_range","Indent","List","InlineCode","Icons"],"sourceRoot":""}