{"version":3,"sources":["webpack:///static/scripts/2-8d5f19f821570cc42ca9.js","webpack:///./src/modules/ProposalEditor/index.js","webpack:///./node_modules/draft-js/node_modules/immutable/dist/immutable.js","webpack:///./node_modules/fbjs/lib/invariant.js","webpack:///./node_modules/draft-js/lib/EditorState.js","webpack:///./node_modules/draft-js/lib/DraftModifier.js","webpack:///./node_modules/draft-js/lib/CharacterMetadata.js","webpack:///./node_modules/draft-js/lib/ContentBlockNode.js","webpack:///./node_modules/fbjs/lib/nullthrows.js","webpack:///./node_modules/fbjs/lib/UserAgent.js","webpack:///./node_modules/draft-js/lib/generateRandomKey.js","webpack:///./node_modules/draft-js/lib/DraftFeatureFlags.js","webpack:///./node_modules/draft-js/lib/ContentBlock.js","webpack:///./node_modules/fbjs/lib/UnicodeUtils.js","webpack:///./node_modules/draft-js/lib/SelectionState.js","webpack:///./node_modules/fbjs/lib/cx.js","webpack:///./src/utils/responsive.js","webpack:///./node_modules/draft-js/lib/BlockMapBuilder.js","webpack:///./node_modules/draft-js/lib/findRangesImmutable.js","webpack:///./node_modules/draft-js/lib/isEventHandled.js","webpack:///./node_modules/draft-js/lib/removeTextWithStrategy.js","webpack:///./src/components/Preview/preview-style.css?fe85","webpack:///./node_modules/draft-js/lib/getContentStateFragment.js","webpack:///./node_modules/draft-js/lib/DraftEntity.js","webpack:///./node_modules/draft-js/lib/DraftOffsetKey.js","webpack:///./src/modules/Form/defaultErrors.js","webpack:///./src/components/Preview/VotesIndicator/VotesIndicator.js","webpack:///./node_modules/fbjs/lib/emptyFunction.js","webpack:///./node_modules/draft-js/lib/ContentState.js","webpack:///./node_modules/draft-js/lib/sanitizeDraftText.js","webpack:///./node_modules/fbjs/lib/UnicodeBidiDirection.js","webpack:///./node_modules/draft-js/lib/DefaultDraftBlockRenderMap.js","webpack:///./node_modules/fbjs/lib/Keys.js","webpack:///./node_modules/draft-js/lib/getEntityKeyForSelection.js","webpack:///./node_modules/fbjs/lib/containsNode.js","webpack:///./node_modules/fbjs/lib/Style.js","webpack:///./node_modules/fbjs/lib/getScrollPosition.js","webpack:///./node_modules/draft-js/lib/findAncestorOffsetKey.js","webpack:///./node_modules/draft-js/lib/KeyBindingUtil.js","webpack:///./node_modules/draft-js/lib/moveSelectionBackward.js","webpack:///./node_modules/draft-js/lib/Draft.js","webpack:///./node_modules/draft-js/lib/randomizeBlockMapKeys.js","webpack:///./node_modules/draft-js/lib/removeEntitiesAtEdges.js","webpack:///./node_modules/draft-js/lib/insertIntoList.js","webpack:///./node_modules/draft-js/lib/getNextDelimiterBlockKey.js","webpack:///./node_modules/draft-js/lib/BlockTree.js","webpack:///./node_modules/draft-js/lib/DraftEntityInstance.js","webpack:///./node_modules/fbjs/lib/UnicodeBidi.js","webpack:///./node_modules/draft-js/lib/DefaultDraftInlineStyle.js","webpack:///./node_modules/draft-js/lib/isSelectionAtLeafStart.js","webpack:///./node_modules/draft-js/lib/DraftEditorBlock.react.js","webpack:///./node_modules/fbjs/lib/getActiveElement.js","webpack:///./node_modules/fbjs/lib/Scroll.js","webpack:///./node_modules/fbjs/lib/DataTransfer.js","webpack:///./node_modules/draft-js/lib/getSelectionOffsetKeyForNode.js","webpack:///./node_modules/draft-js/lib/getTextContentFromFiles.js","webpack:///./node_modules/draft-js/lib/getUpdatedSelectionState.js","webpack:///./node_modules/draft-js/lib/getFragmentFromSelection.js","webpack:///./node_modules/draft-js/lib/getRangeClientRects.js","webpack:///./node_modules/draft-js/lib/getDraftEditorSelectionWithNodes.js","webpack:///./node_modules/draft-js/lib/DraftRemovableWord.js","webpack:///./node_modules/draft-js/lib/moveSelectionForward.js","webpack:///./node_modules/draft-js/lib/convertFromHTMLToContentBlocks.js","webpack:///./node_modules/draft-js/lib/getSafeBodyFromHTML.js","webpack:///./node_modules/draft-js/lib/RichTextEditorUtil.js","webpack:///./node_modules/draft-js/lib/getDefaultKeyBinding.js","webpack:///./node_modules/draft-js/lib/DraftStringKey.js","webpack:///./node_modules/immutable/dist/immutable.js","webpack:///./src/components/ConditionsLabel/ConditionsLabel.js","webpack:///./src/modules/ProposalEditor/ProposalEditor.js","webpack:///./node_modules/draft-js/lib/AtomicBlockUtils.js","webpack:///./node_modules/draft-js/lib/DraftFeatureFlags-core.js","webpack:///./node_modules/draft-js/lib/ContentStateInlineStyle.js","webpack:///./node_modules/draft-js/lib/applyEntityToContentState.js","webpack:///./node_modules/draft-js/lib/applyEntityToContentBlock.js","webpack:///./node_modules/draft-js/lib/getCharacterRemovalRange.js","webpack:///./node_modules/draft-js/lib/DraftEntitySegments.js","webpack:///./node_modules/draft-js/lib/getRangesForDraftEntity.js","webpack:///./node_modules/draft-js/lib/insertFragmentIntoContentState.js","webpack:///./node_modules/draft-js/lib/insertTextIntoContentState.js","webpack:///./node_modules/draft-js/lib/modifyBlockForContentState.js","webpack:///./node_modules/draft-js/lib/removeRangeFromContentState.js","webpack:///./node_modules/draft-js/lib/splitBlockInContentState.js","webpack:///./node_modules/draft-js/lib/EditorBidiService.js","webpack:///./node_modules/fbjs/lib/UnicodeBidiService.js","webpack:///./node_modules/draft-js/lib/moveBlockInContentState.js","webpack:///./node_modules/draft-js/lib/CompositeDraftDecorator.js","webpack:///./node_modules/draft-js/lib/DraftEditor.react.js","webpack:///./node_modules/draft-js/lib/DraftEditorCompositionHandler.js","webpack:///./node_modules/draft-js/lib/DraftEditorContents.react.js","webpack:///./node_modules/draft-js/lib/DraftEditorContents-core.react.js","webpack:///./node_modules/draft-js/lib/DraftEditorLeaf.react.js","webpack:///./node_modules/draft-js/lib/DraftEditorTextNode.react.js","webpack:///./node_modules/fbjs/lib/UserAgentData.js","webpack:///./node_modules/fbjs/node_modules/ua-parser-js/src/ua-parser.js","webpack:///(webpack)/buildin/amd-options.js","webpack:///./node_modules/fbjs/lib/VersionRange.js","webpack:///./node_modules/fbjs/lib/mapObject.js","webpack:///./node_modules/fbjs/lib/memoizeStringOnly.js","webpack:///./node_modules/draft-js/lib/setDraftEditorSelection.js","webpack:///./node_modules/draft-js/lib/DraftJsDebugLogging.js","webpack:///./node_modules/fbjs/lib/isTextNode.js","webpack:///./node_modules/fbjs/lib/isNode.js","webpack:///./node_modules/fbjs/lib/getStyleProperty.js","webpack:///./node_modules/fbjs/lib/camelize.js","webpack:///./node_modules/fbjs/lib/hyphenate.js","webpack:///./node_modules/fbjs/lib/getElementPosition.js","webpack:///./node_modules/fbjs/lib/getElementRect.js","webpack:///./node_modules/fbjs/lib/getDocumentScrollElement.js","webpack:///./node_modules/fbjs/lib/getUnboundedScrollPosition.js","webpack:///./node_modules/fbjs/lib/getViewportDimensions.js","webpack:///./node_modules/fbjs/lib/joinClasses.js","webpack:///./node_modules/draft-js/lib/DraftEditorDragHandler.js","webpack:///./node_modules/fbjs/lib/PhotosMimeType.js","webpack:///./node_modules/fbjs/lib/createArrayFromMixed.js","webpack:///./node_modules/draft-js/lib/DraftEditorEditHandler.js","webpack:///./node_modules/draft-js/lib/editOnBeforeInput.js","webpack:///./node_modules/fbjs/lib/setImmediate.js","webpack:///./node_modules/setimmediate/setImmediate.js","webpack:///./node_modules/draft-js/lib/editOnBlur.js","webpack:///./node_modules/draft-js/lib/editOnCompositionStart.js","webpack:///./node_modules/draft-js/lib/editOnCopy.js","webpack:///./node_modules/draft-js/lib/editOnCut.js","webpack:///./node_modules/draft-js/lib/editOnDragOver.js","webpack:///./node_modules/draft-js/lib/editOnDragStart.js","webpack:///./node_modules/draft-js/lib/editOnFocus.js","webpack:///./node_modules/draft-js/lib/editOnInput.js","webpack:///./node_modules/draft-js/lib/editOnKeyDown.js","webpack:///./node_modules/draft-js/lib/SecondaryClipboard.js","webpack:///./node_modules/draft-js/lib/keyCommandBackspaceToStartOfLine.js","webpack:///./node_modules/draft-js/lib/expandRangeToStartOfLine.js","webpack:///./node_modules/draft-js/lib/keyCommandBackspaceWord.js","webpack:///./node_modules/fbjs/lib/TokenizeUtil.js","webpack:///./node_modules/draft-js/lib/keyCommandDeleteWord.js","webpack:///./node_modules/draft-js/lib/keyCommandInsertNewline.js","webpack:///./node_modules/draft-js/lib/keyCommandMoveSelectionToEndOfBlock.js","webpack:///./node_modules/draft-js/lib/keyCommandMoveSelectionToStartOfBlock.js","webpack:///./node_modules/draft-js/lib/keyCommandPlainBackspace.js","webpack:///./node_modules/draft-js/lib/keyCommandPlainDelete.js","webpack:///./node_modules/draft-js/lib/keyCommandTransposeCharacters.js","webpack:///./node_modules/draft-js/lib/keyCommandUndo.js","webpack:///./node_modules/draft-js/lib/editOnPaste.js","webpack:///./node_modules/draft-js/lib/DraftPasteProcessor.js","webpack:///./node_modules/fbjs/lib/URI.js","webpack:///./node_modules/draft-js/lib/adjustBlockDepthForContentState.js","webpack:///./node_modules/draft-js/lib/splitTextIntoTextBlocks.js","webpack:///./node_modules/draft-js/lib/editOnSelect.js","webpack:///./node_modules/draft-js/lib/getDraftEditorSelection.js","webpack:///./node_modules/draft-js/lib/DraftEditorPlaceholder.react.js","webpack:///./node_modules/draft-js/lib/convertFromDraftStateToRaw.js","webpack:///./node_modules/draft-js/lib/encodeEntityRanges.js","webpack:///./node_modules/draft-js/lib/encodeInlineStyleRanges.js","webpack:///./node_modules/draft-js/lib/convertFromRawToDraftState.js","webpack:///./node_modules/draft-js/lib/DraftTreeAdapter.js","webpack:///./node_modules/draft-js/lib/createCharacterList.js","webpack:///./node_modules/draft-js/lib/decodeEntityRanges.js","webpack:///./node_modules/draft-js/lib/decodeInlineStyleRanges.js","webpack:///./node_modules/draft-js/lib/getVisibleSelectionRect.js","webpack:///./node_modules/draft-js/lib/getRangeBoundingClientRect.js","webpack:///./src/components/MyEditor/MyEditor.js","webpack:///./src/components/MyEditor/myEditor-style.css?5152","webpack:///./src/components/AuthorInfo/AuthorInfo.js","webpack:///./src/components/AuthorInfo/authorInfo-style.css?30be","webpack:///./src/components/TopBar/TopBar.js","webpack:///./src/components/ConditionsLabel/conditionslabel-style.css?69d9","webpack:///./src/components/TopBar/topBar-style.css?4ef6","webpack:///./src/components/ProposalStats/ProposalStats.js","webpack:///./src/components/ProposalStats/proposalStats-style.css?99d8","webpack:///./src/modules/ProposalEditor/proposalEditor.defaultProps.js"],"names":["webpackJsonp","Array","concat","module","__webpack_exports__","__webpack_require__","ONLY_SERVER","exports","global","factory","this","createClass","ctor","superClass","prototype","Object","create","constructor","Iterable","value","isIterable","Seq","KeyedIterable","isKeyed","KeyedSeq","IndexedIterable","isIndexed","IndexedSeq","SetIterable","isAssociative","SetSeq","maybeIterable","IS_ITERABLE_SENTINEL","maybeKeyed","IS_KEYED_SENTINEL","maybeIndexed","IS_INDEXED_SENTINEL","maybeAssociative","isOrdered","maybeOrdered","IS_ORDERED_SENTINEL","MakeRef","ref","SetRef","OwnerID","arrCopy","arr","offset","len","Math","max","length","newArr","ii","ensureSize","iter","undefined","size","__iterate","returnTrue","wrapIndex","index","uint32Index","NaN","wholeSlice","begin","end","resolveBegin","resolveIndex","resolveEnd","defaultIndex","min","Iterator","next","iteratorValue","type","k","v","iteratorResult","done","iteratorDone","hasIterator","getIteratorFn","isIterator","maybeIterator","getIterator","iterable","iteratorFn","call","REAL_ITERATOR_SYMBOL","FAUX_ITERATOR_SYMBOL","isArrayLike","emptySequence","toSeq","seqFromValue","toKeyedSeq","fromEntrySeq","keyedSeqFromValue","entrySeq","toIndexedSeq","indexedSeqFromValue","toSetSeq","ArraySeq","array","_array","ObjectSeq","object","keys","_object","_keys","IterableSeq","_iterable","IteratorSeq","iterator","_iterator","_iteratorCache","isSeq","maybeSeq","IS_SEQ_SENTINEL","EMPTY_SEQ","seq","isArray","TypeError","maybeIndexedSeqFromValue","seqIterate","fn","reverse","useKeys","cache","_cache","maxIndex","entry","__iterateUncached","seqIterator","__iteratorUncached","fromJS","json","converter","fromJSWith","fromJSDefault","key","parentJSON","map","isPlainObj","toList","toMap","is","valueA","valueB","valueOf","equals","deepEqual","a","b","__hash","notAssociative","entries","every","flipped","cacheResult","_","allEqual","bSize","has","get","NOT_SET","Repeat","times","_value","Infinity","EMPTY_REPEAT","invariant","condition","error","Error","Range","start","step","abs","_start","_end","_step","ceil","EMPTY_RANGE","Collection","KeyedCollection","IndexedCollection","SetCollection","smi","i32","hash","o","h","STRING_HASH_CACHE_MIN_STRLEN","cachedHashString","hashString","hashCode","hashJSObj","toString","string","stringHashCache","STRING_HASH_CACHE_SIZE","STRING_HASH_CACHE_MAX_SIZE","charCodeAt","obj","usingWeakMap","weakMap","UID_HASH_KEY","canDefineProperty","propertyIsEnumerable","getIENodeHash","objHashUID","set","isExtensible","defineProperty","apply","arguments","nodeType","node","uniqueID","documentElement","assertNotInfinite","Map","emptyMap","isMap","withMutations","forEach","maybeMap","IS_MAP_SENTINEL","ArrayMapNode","ownerID","BitmapIndexedNode","bitmap","nodes","HashArrayMapNode","count","HashCollisionNode","keyHash","ValueNode","MapIterator","_type","_reverse","_stack","_root","mapIteratorFrame","mapIteratorValue","prev","__prev","makeMap","root","MapPrototype","__ownerID","__altered","EMPTY_MAP","updateMap","newRoot","newSize","didChangeSize","CHANGE_LENGTH","didAlter","DID_ALTER","updateNode","shift","update","isLeafNode","mergeIntoNode","newNode","idx1","MASK","idx2","SHIFT","createNodes","packNodes","excluding","packedII","packedNodes","bit","expandNodes","including","expandedNodes","SIZE","mergeIntoMapWith","merger","iterables","iters","push","mergeIntoCollectionWith","deepMerger","existing","mergeDeep","deepMergerWith","mergeDeepWith","nextValue","collection","filter","x","mergeIntoMap","updateInDeepMap","keyPathIter","notSetValue","updater","isNotSet","existingValue","newValue","nextExisting","nextUpdated","remove","popCount","setIn","idx","val","canEdit","newArray","spliceIn","newLen","after","spliceOut","pop","List","empty","emptyList","isList","makeList","VNode","toArray","list","setSize","i","maybeList","IS_LIST_SENTINEL","iterateList","iterateNodeOrLeaf","level","iterateLeaf","iterateNode","tailPos","tail","from","left","to","right","DONE","values","_origin","_capacity","getTailOffset","_tail","_level","origin","capacity","ListPrototype","EMPTY_LIST","updateList","setListBounds","newTail","updateVNode","nodeHas","lowerNode","newLowerNode","editableVNode","slice","listNodeFor","rawIndex","owner","oldOrigin","oldCapacity","newOrigin","newCapacity","clear","newLevel","offsetShift","oldTailOffset","newTailOffset","oldTail","removeAfter","removeBefore","beginIndex","mergeIntoListWith","maxSize","OrderedMap","emptyOrderedMap","isOrderedMap","maybeOrderedMap","makeOrderedMap","omap","_map","_list","EMPTY_ORDERED_MAP","updateOrderedMap","newMap","newList","flip","ToKeyedSequence","indexed","_iter","_useKeys","ToIndexedSequence","ToSetSequence","FromEntriesSequence","flipFactory","flipSequence","makeSequence","reversedSequence","includes","cacheResultThrough","this$0","ITERATE_ENTRIES","__iterator","ITERATE_VALUES","ITERATE_KEYS","mapFactory","mapper","context","mappedSequence","c","reverseFactory","filterFactory","predicate","filterSequence","iterations","countByFactory","grouper","groups","asMutable","asImmutable","groupByFactory","isKeyedIter","coerce","iterableClass","reify","sliceFactory","originalSize","resolvedBegin","resolvedEnd","sliceSize","resolvedSize","sliceSeq","skipped","isSkipping","takeWhileFactory","takeSequence","iterating","skipWhileFactory","skipSequence","skipping","concatFactory","isKeyedIterable","singleton","concatSeq","flatten","reduce","sum","flattenFactory","depth","flatSequence","flatDeep","currentDepth","stopped","stack","flatMapFactory","interposeFactory","separator","interposedSequence","sortFactory","comparator","defaultComparator","sort","maxFactory","maxCompare","comp","zipWithFactory","keyIter","zipper","zipSequence","iterators","isDone","steps","some","s","validateEntry","resolveSize","forceIterator","keyPath","Record","defaultValues","name","hasInitialized","RecordType","setProps","RecordTypePrototype","_name","_defaultValues","RecordPrototype","makeRecord","likeRecord","record","getPrototypeOf","recordName","names","setProp","bind","Set","emptySet","isSet","add","maybeSet","IS_SET_SENTINEL","updateSet","__empty","__make","makeSet","SetPrototype","EMPTY_SET","OrderedSet","emptyOrderedSet","isOrderedSet","maybeOrderedSet","makeOrderedSet","OrderedSetPrototype","EMPTY_ORDERED_SET","Stack","emptyStack","isStack","unshiftAll","maybeStack","IS_STACK_SENTINEL","makeStack","head","StackPrototype","_head","EMPTY_STACK","mixin","methods","keyCopier","getOwnPropertySymbols","keyMapper","entryMapper","not","neg","quoteString","JSON","stringify","defaultZipper","defaultNegComparator","hashIterable","ordered","keyed","murmurHashOfSize","hashMerge","imul","SLICE$0","Keyed","Indexed","Symbol","ITERATOR_SYMBOL","KEYS","VALUES","ENTRIES","inspect","toSource","of","__toString","hasOwnProperty","searchValue","indexOf","lastIndexOf","other","possibleIndex","floor","offsetValue","d","e","WeakMap","updateIn","deleteIn","updatedValue","merge","mergeWith","mergeIn","m","mergeDeepIn","sortBy","mutable","wasAltered","__ensureOwner","iterate","removeIn","removed","exists","MAX_ARRAY_MAP_SIZE","isEditable","newEntries","keyHashFrag","MAX_BITMAP_INDEXED_SIZE","newBitmap","newNodes","newCount","MIN_HASH_ARRAY_MAP_SIZE","keyMatch","subNode","splice","insert","oldSize","unshift","originIndex","newChild","removingFirst","oldChild","editable","sizeIndex","valueSeq","indexedIterable","defaultVal","_empty","fromKeys","keySeq","union","intersect","originalSet","subtract","peek","pushAll","toJS","__toJS","toJSON","toObject","toOrderedMap","toOrderedSet","toSet","toStack","__toStringMapper","join","returnValue","find","findEntry","found","findLastEntry","sideEffect","joined","isFirst","reducer","initialReduction","reduction","useFirst","reduceRight","reversed","butLast","isEmpty","countBy","entriesSequence","filterNot","findLast","first","flatMap","searchKey","getIn","searchKeyPath","nested","groupBy","hasIn","isSubset","isSuperset","last","maxBy","minBy","rest","skip","amount","skipLast","skipWhile","skipUntil","take","takeLast","takeWhile","takeUntil","IterablePrototype","chain","contains","noLengthWarning","console","warn","findKey","findLastKey","keyOf","lastKeyOf","mapEntries","mapKeys","KeyedIterablePrototype","findIndex","removeNum","numArgs","spliced","findLastIndex","interpose","interleave","zipped","interleaved","zip","zipWith","format","f","validateFormat","args","argIndex","replace","framesToPop","_classCallCheck","instance","Constructor","updateSelection","editorState","selection","forceSelection","EditorState","nativelyRenderedContent","inlineStyleOverride","generateNewTreeMap","contentState","decorator","getBlockMap","block","BlockTree","generate","regenerateTreeForNewBlocks","newBlockMap","newEntityMap","getCurrentContent","prevBlockMap","getImmutable","regenerateTreeForNewDecorator","content","blockMap","previousTreeMap","existingDecorator","getDecorations","mustBecomeBoundary","changeType","getLastChangeType","getInlineStyleForCollapsedSelection","startKey","getStartKey","startOffset","getStartOffset","startBlock","getBlockForKey","getInlineStyleAt","getLength","lookUpwardForInlineStyle","getInlineStyleForNonCollapsedSelection","fromKey","lastNonEmpty","_assign","_extends","target","source","ContentState","EditorBidiService","Immutable","SelectionState","defaultRecord","allowUndo","currentContent","directionMap","inCompositionMode","lastChangeType","redoStack","treeMap","undoStack","EditorStateRecord","immutable","_immutable","createEmpty","createWithContent","createFromText","firstKey","getKey","config","recordConfig","getDirectionMap","put","state","newContent","newTreeMap","getEntityMap","getAllowUndo","getUndoStack","getRedoStack","getSelection","getDecorator","isInCompositionMode","mustForceSelection","getNativelyRenderedContent","getInlineStyleOverride","setInlineStyleOverride","getCurrentInlineStyle","override","isCollapsed","getBlockTree","blockKey","isSelectionAtStartOfContent","hasEdgeWithin","isSelectionAtEndOfContent","acceptSelection","getHasFocus","moveSelectionToEnd","lastBlock","getLastBlock","lastKey","anchorKey","anchorOffset","focusKey","focusOffset","isBackward","moveFocusToEnd","afterSelectionMove","getSelectionAfter","getSelectionBefore","editorStateChanges","undo","newCurrentContent","redo","CharacterMetadata","ContentStateInlineStyle","DraftFeatureFlags","applyEntityToContentState","getCharacterRemovalRange","getContentStateFragment","insertFragmentIntoContentState","insertTextIntoContentState","modifyBlockForContentState","removeEntitiesAtEdges","removeRangeFromContentState","splitBlockInContentState","DraftModifier","replaceText","rangeToReplace","text","inlineStyle","entityKey","withoutEntities","withoutText","character","style","entity","insertText","targetRange","moveText","removalRange","movedFragment","afterRemoval","removeRange","replaceWithFragment","fragment","rangeToRemove","removalDirection","endKey","endBlock","getIsBackward","getFocusKey","getFocusOffset","getAnchorKey","getAnchorOffset","endOffset","getEndOffset","startEntityKey","getEntityAt","endEntityKey","_adjustedRemovalRange","adjustedRemovalRange","draft_segmented_entities_behavior","splitBlock","selectionState","applyInlineStyle","removeInlineStyle","setBlockType","blockType","setBlockData","blockData","data","mergeBlockData","getData","applyEntity","_possibleConstructorReturn","self","ReferenceError","_inherits","subClass","enumerable","writable","configurable","setPrototypeOf","__proto__","_require","CharacterMetadataRecord","_CharacterMetadataRec","getStyle","getEntity","hasStyle","applyStyle","withStyle","removeStyle","withoutStyle","withEntity","EMPTY","defaultConfig","configMap","pool","newCharacter","findRangesImmutable","parent","characterList","children","prevSibling","nextSibling","haveEqualStyle","charA","charB","haveEqualEntity","decorateCharacterList","ContentBlockNode","_Record","props","getType","getText","getCharacterList","getDepth","getChildKeys","getParentKey","getPrevSiblingKey","getNextSiblingKey","findStyleRanges","filterFn","callback","findEntityRanges","nullthrows","compare","version","query","normalizer","startsWith","range","VersionRange","normalizePlatformVersion","UserAgentData","platformName","mapObject","memoizeStringOnly","UserAgent","isBrowser","browserName","browserFullVersion","isBrowserArchitecture","browserArchitecture","isDevice","deviceName","isEngine","engineName","engineVersion","isPlatform","platformFullVersion","isPlatformArchitecture","platformArchitecture","generateRandomKey","seenKeys","isNaN","random","MULTIPLIER","pow","ContentBlockRecord","ContentBlock","_ContentBlockRecord","isCodeUnitInSurrogateRange","codeUnit","SURROGATE_HIGH_START","SURROGATE_LOW_END","isSurrogatePair","str","second","SURROGATE_HIGH_END","SURROGATE_LOW_START","hasSurrogateUnit","SURROGATE_UNITS_REGEX","test","getUTF16Length","pos","strlen","substr","posA","posB","substring","getCodePoints","codePoints","codePointAt","UnicodeUtils","hasFocus","SelectionStateRecord","_SelectionStateRecord","serialize","String","selectionStart","offsetToCheck","getEndKey","cx","classNames","className","isMobile","window","innerWidth","DESKTOP_MIN_WIDTH","DEFAULT_MODE_DESKTOP","isDesktop","MOBILE_MAX_WIDTH","defaultWidth","desktopWidth","mobileWidth","BlockMapBuilder","createFromArray","blocks","haystack","areEqualFn","foundFn","cursor","nextIndex","isEventHandled","removeTextWithStrategy","strategy","direction","randomizeBlockMapKeys","contentWithoutEdgeEntities","blockKeys","startIndex","endIndex","chars","logWarning","oldMethodCall","newMethodCall","DraftEntityInstance","instances","instanceKey","DraftEntity","getLastCreatedEntityKey","__getLastCreatedEntityKey","mutability","__create","__add","__get","mergeData","toMerge","__mergeData","replaceData","newData","__replaceData","newInstance","DraftOffsetKey","encode","decoratorKey","leafKey","decode","offsetKey","_offsetKey$split","split","parseInt","errorType","errorMessage","VotesIndicator","votes","votesLimit","progress","styles","progressContainer","width","getWidth","defaultProps","limit","sqrt","displayName","makeEmptyFunction","arg","emptyFunction","thatReturns","thatReturnsFalse","thatReturnsTrue","thatReturnsNull","thatReturnsThis","thatReturnsArgument","sanitizeDraftText","experimentalTreeDataSupport","draft_tree_data_support","entityMap","selectionBefore","selectionAfter","ContentBlockNodeRecord","ContentStateRecord","_ContentStateRecord","getKeyBefore","getKeyAfter","getBlockAfter","getBlockBefore","getBlocksAsArray","getFirstBlock","getPlainText","delimiter","hasText","createEntity","mergeEntityData","replaceEntityData","addEntity","createFromBlockArray","theBlocks","contentBlocks","strings","input","REGEX_BLOCK_DELIMITER","RegExp","isStrong","dir","LTR","RTL","getHTMLDir","getHTMLDirIfDifferent","otherDir","setGlobalDir","globalDir","initGlobalDir","getGlobalDir","UnicodeBidiDirection","NEUTRAL","React","UL_WRAP","createElement","OL_WRAP","PRE_WRAP","DefaultDraftBlockRenderMap","element","wrapper","blockquote","atomic","unstyled","aliasedElements","BACKSPACE","TAB","RETURN","ALT","ESC","SPACE","PAGE_UP","PAGE_DOWN","END","HOME","LEFT","UP","RIGHT","DOWN","DELETE","COMMA","PERIOD","A","Z","ZERO","NUMPAD_0","NUMPAD_9","getEntityKeyForSelection","targetSelection","filterKey","getMutability","containsNode","outerNode","innerNode","isTextNode","parentNode","compareDocumentPosition","_isNodeScrollable","overflow","Style","getStyleProperty","getScrollParent","ownerDocument","body","defaultView","parentWindow","getScrollPosition","scrollable","documentScrollElement","getDocumentScrollElement","document","Window","scrollPosition","getUnboundedScrollPosition","viewport","xMax","scrollWidth","clientWidth","yMax","scrollHeight","clientHeight","y","findAncestorOffsetKey","searchNode","getSelectionOffsetKeyForNode","isOSX","KeyBindingUtil","isCtrlKeyCommand","ctrlKey","altKey","isOptionKeyCommand","hasCommandModifier","metaKey","moveSelectionBackward","maxDistance","keyBefore","AtomicBlockUtils","CompositeDraftDecorator","DefaultDraftInlineStyle","DraftEditor","DraftEditorBlock","RichTextEditorUtil","convertFromDraftStateToRaw","convertFromHTMLToContentBlocks","convertFromRawToDraftState","getDefaultKeyBinding","getVisibleSelectionRect","DraftPublic","Editor","EditorBlock","CompositeDecorator","Entity","EntityInstance","Modifier","RichUtils","convertFromHTML","convertFromRaw","convertToRaw","genKey","randomizeContentBlockNodeKeys","newKeysRef","lastRootBlock","blockMapState","oldKey","nextKey","prevKey","childrenKeys","parentKey","parentBlock","parentChildrenList","childKey","child","randomizeContentBlockKeys","updatedBlocks","updatedStart","removeForBlock","updatedEnd","getRemovalRange","characters","charBefore","charAfter","entityBeforeCursor","entityAfterCursor","current","_getRemovalRange","insertIntoList","targetList","toInsert","getNextDelimiterBlockKey","nextSiblingKey","nextNonDescendantBlock","generateLeaves","leaves","inlineStyles","areEqual","LeafRange","defaultLeafRange","defaultDecoratorRange","DecoratorRange","textLength","leafSets","decorations","getFingerprint","tree","leafSet","DraftEntityInstanceRecord","_DraftEntityInstanceR","firstStrongChar","match","REGEX_STRONG","exec","firstStrongCharDir","strongChar","REGEX_RTL","resolveBlockDir","fallback","blockDir","getDirection","strongFallback","isDirectionLTR","isDirectionRTL","RANGE_BY_BIDI_TYPE","L","R","AL","UnicodeBidi","BOLD","fontWeight","CODE","fontFamily","wordWrap","ITALIC","fontStyle","STRIKETHROUGH","textDecoration","UNDERLINE","isSelectionAtLeafStart","blockTree","isAtStart","leaf","leafStart","DraftEditorLeaf","ReactDOM","Scroll","getElementPosition","getViewportDimensions","isBlockOnSelectionEdge","_React$Component","shouldComponentUpdate","nextProps","componentDidMount","blockNode","findDOMNode","scrollParent","scrollDelta","nodePosition","height","scrollTo","HTMLElement","offsetHeight","offsetTop","setTop","getTop","_renderChildren","_this2","lastLeafSet","hasSelection","leavesForLeafSet","lastLeaf","jj","styleSet","customStyleMap","customStyleFn","isLast","DecoratorComponent","getComponentForKey","decoratorProps","getPropsForKey","decoratorOffsetKey","decoratedText","render","_props","Component","getActiveElement","doc","activeElement","_isViewportScrollElement","scrollTop","newTop","getLeft","scrollLeft","setLeft","newLeft","getFileFromDataTransfer","item","kind","getAsFile","PhotosMimeType","createArrayFromMixed","CR_LF_REGEX","RICH_TEXT_TYPES","DataTransfer","types","isRichText","getHTML","isImage","isLink","getLink","items","getFiles","getCount","mozItemCount","files","hasFiles","Element","getAttribute","childNodes","childOffsetKey","getTextContentFromFiles","readCount","results","file","readFile","TEXT_SIZE_UPPER_BOUND","FileReader","TEXT_TYPES","contents","TEXT_CLIPPING_REGEX","reader","onload","result","onerror","readAsText","getUpdatedSelectionState","anchorPath","anchorBlockKey","anchorLeaf","focusPath","focusBlockKey","focusLeaf","anchorLeafStart","focusLeafStart","anchorBlockOffset","focusBlockOffset","anchorLeafEnd","focusLeafEnd","getFragmentFromSelection","getRangeClientRectsChrome","tempRange","cloneRange","clientRects","ancestor","endContainer","atCommonAncestor","commonAncestorContainer","setStart","startContainer","rects","getClientRects","_ref","setEndBefore","isChrome","getRangeClientRects","getDraftEditorSelectionWithNodes","anchorNode","focusNode","anchorIsTextNode","Node","TEXT_NODE","focusIsTextNode","needsRecovery","anchorPoint","focusPoint","getPointForNonTextNode","firstChild","nodeName","getFirstLeaf","getLastLeaf","lastChild","editorRoot","startNode","childOffset","firstLeaf","nodeBeforeCursor","getTextContentLength","textContent","getRemovableWord","matches","BACKSPACE_REGEX","DELETE_REGEX","TokenizeUtil","punctuation","getPunctuation","WHITESPACE_AND_PUNCTUATION","DELETE_STRING","BACKSPACE_STRING","DraftRemovableWord","getBackward","getForward","moveSelectionForward","_defineProperty","_knownListItemDepthCl","URI","getSafeBodyFromHTML","REGEX_CR","REGEX_LF","REGEX_NBSP","REGEX_CARRIAGE","REGEX_ZWS","boldValues","notBoldValues","inlineTags","code","del","em","strike","strong","u","knownListItemDepthClasses","anchorAttr","imgAttr","EMPTY_CHUNK","inlines","entities","EMPTY_BLOCK","getListBlockType","tag","lastList","getBlockMapSupportedTags","blockRenderMap","unstyledElement","tags","draftBlock","getMultiMatchedType","multiMatchExtractor","matchType","getBlockTypeForTag","matchedTypes","alias","processInlineTag","currentStyle","styleToCheck","htmlElement","joinChunks","B","experimentalHasNestedBlocks","lastInA","firstInB","containsSemanticBlockMarkup","html","blockTags","hasValidLinkText","link","HTMLAnchorElement","protocol","getWhitespaceChunk","inEntity","getSoftNewlineChunk","getChunkedBlock","getBlockDividerChunk","getListItemDepth","depthClass","classList","genFragment","inBlock","lastLastBlock","toLowerCase","nextBlockType","newBlock","inBlockType","chunk","newChunk","_text","nodeTextContent","trim","parentElement","parentNodeName","fill","HTMLImageElement","attributes","getNamedItem","image","entityConfig","attr","imageAttribute","inListBlock","inBlockOrHasNestedBlocks","entityId","href","anchor","anchorAttribute","url","_genFragment","generatedChunk","maybeUpdatedEntityMap","sibling","getChunkForHTML","DOMBuilder","supportedBlockTags","safeBody","workingBlocks","convertChunkToContentBlocks","initialState","cacheRef","rawBlocks","rawInlines","rawEntities","BlockNodeRecord","acc","textBlock","parentTextNodeKey","parentIndex","parentRecord","parentCharacterList","parentText","textNode","convertFromHTMLtoContentBlocks","chunkData","isOldIE","implementation","createHTMLDocument","innerHTML","getElementsByTagName","adjustBlockDepthForContentState","currentBlockContainsLink","getCurrentBlockType","getDataObjectForLinkURL","uri","handleKeyCommand","command","toggleInlineStyle","toggleCode","onBackspace","onDelete","insertSoftNewline","newEditorState","blockBefore","withoutAtomicBlock","withoutBlockStyle","tryToRemoveBlockStyle","blockAfter","atomicBlockTarget","onTab","event","maxDepth","preventDefault","blockAbove","typeAbove","shiftKey","withAdjustment","toggleBlockType","typeToSet","toggleLink","withoutLink","firstBlock","shouldRemoveWord","getZCommand","getDeleteCommand","isWindows","getBackspaceCommand","keyCode","Keys","shouldFixFirefoxMovement","DraftStringKey","unstringify","keyValues","ConditionsLabel","label","scrollToCondition","el","querySelector","scrollIntoView","behavior","inline","container","role","onClick","_asyncToGenerator","gen","Promise","resolve","reject","info","then","err","__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator__","__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default","n","__WEBPACK_IMPORTED_MODULE_1_react__","__WEBPACK_IMPORTED_MODULE_1_react___default","__WEBPACK_IMPORTED_MODULE_2_draft_js__","__WEBPACK_IMPORTED_MODULE_3_immutable__","__WEBPACK_IMPORTED_MODULE_4_classnames__","__WEBPACK_IMPORTED_MODULE_4_classnames___default","__WEBPACK_IMPORTED_MODULE_5_lodash_throttle__","__WEBPACK_IMPORTED_MODULE_5_lodash_throttle___default","__WEBPACK_IMPORTED_MODULE_6__utils_responsive__","__WEBPACK_IMPORTED_MODULE_7_react_modal__","__WEBPACK_IMPORTED_MODULE_7_react_modal___default","__WEBPACK_IMPORTED_MODULE_8__components_MyEditor_MyEditor__","__WEBPACK_IMPORTED_MODULE_9__components_AuthorInfo_AuthorInfo__","__WEBPACK_IMPORTED_MODULE_10__components_TopBar_TopBar__","__WEBPACK_IMPORTED_MODULE_11__components_BaseButton_BaseButton__","__WEBPACK_IMPORTED_MODULE_12__components_ConditionsLabel_ConditionsLabel__","__WEBPACK_IMPORTED_MODULE_13__components_ProposalStats_ProposalStats__","__WEBPACK_IMPORTED_MODULE_14__components_ErrorMessage_ErrorMessage__","__WEBPACK_IMPORTED_MODULE_15__proposalEditor_style_css__","__WEBPACK_IMPORTED_MODULE_15__proposalEditor_style_css___default","__WEBPACK_IMPORTED_MODULE_16__Form_Form_style_css__","__WEBPACK_IMPORTED_MODULE_16__Form_Form_style_css___default","__WEBPACK_IMPORTED_MODULE_17__components_Modal_modal_style_css__","__WEBPACK_IMPORTED_MODULE_17__components_Modal_modal_style_css___default","__WEBPACK_IMPORTED_MODULE_18__components_RichText_RichText__","__WEBPACK_IMPORTED_MODULE_19__proposalEditor_defaultProps__","__WEBPACK_IMPORTED_MODULE_20__utils_request__","__WEBPACK_IMPORTED_MODULE_21__components_ReadAloudPopover_ReadAloudPopover__","__WEBPACK_IMPORTED_MODULE_22__components_ReadAloudButton_ReadAloudButton__","_createClass","defineProperties","descriptor","protoProps","staticProps","ProposalEditor","_temp","_this","_ret","_len","_key","showConfirm","handleScroll","setState","showTopBar","pageYOffset","validateFields","loadProposal","proposal","proposalCreationViewModel","draft","section","author","coAuthors","validateProposal","_ref2","mark","pageStructure","defaultErrors","errors","title","checkTitle","validTitle","maxLength","totalChars","isValid","_x","_x2","checkTitleApi","checkingTitle","request","method","headers","credentials","response","catch","handleSave","_ref3","displayStatus","hasErrors","focusInputOnError","isSubmitting","formatProposal","submitApi","api","location","_x3","handleBlur","_ref4","proposalErrors","_x4","_x5","onFormChange","_ref5","_x6","_x7","handleConfirm","_ref6","_x8","_Component","autosave","setInterval","addEventListener","throttle","clearInterval","p","form","refSelector","handleFocus","completeProposalHintSection","titleSection","proposalContentSection","remarksSection","overlaySection","conditionsHtml","conditionsHint","externalId","proposalSupportersAcceptThreshold","back","voteButton","readAloud","preview","proposalEditor","data-readaloud-ancestor","show","responsive","marginBottom","primary","fullwidth","data-readaloud","readOnly","titleEditor","id","handleChange","onBlur","checkingValue","proposalId","Fragment","proposalContent","proposalContentEditor","minHeight","remarks","remarksEditor","fontSize","hint","description","buttonGroup","handleGoBack","flat","icon","expands","loading","isOpen","contentLabel","appElement","overlayClassName","base","modalStyles","overlay","afterOpen","overlayAfteropen","beforeClose","modalContent","onRequestClose","handleToggle","marginTop","overlayTitle","formStyles","moveBlockInContentState","insertAtomicBlock","afterSplit","insertionTarget","asAtomicBlock","charData","atomicBlockConfig","atomicDividerBlockConfig","fragmentArray","withAtomicBlock","moveAtomicBlock","atomicBlock","insertionMode","withMovedAtomicBlock","targetBlock","selectionAfterRemoval","_targetBlock","selectionAfterSplit","_targetBlock2","draft_killswitch_allow_nontextnodes","draft_handlebeforeinput_composed_text","modifyInlineStyle","addOrRemove","newBlocks","sliceStart","sliceEnd","applyEntityToContentBlock","contentBlock","newSelectionState","getEntityRemovalRange","startSelectionState","endSelectionState","_startSelectionState","_endSelectionState","isEntireSelectionWithinEntity","isEntityAtStart","sideToConsider","entityRanges","getRangesForDraftEntity","entityRange","DraftEntitySegments","selectionEnd","entityStart","segments","segment","segmentEnd","segmentStart","removalStart","removalEnd","entityEnd","atStart","atEnd","ranges","updateExistingBlock","fragmentBlock","targetKey","targetOffset","finalKey","finalOffset","updateHead","headText","headCharacters","appendToHead","updateTail","blockSize","tailText","tailCharacters","prependToTail","getRootBlocks","headKey","rootBlock","rootBlocks","lastSiblingKey","updateBlockMapLinks","originalBlockMap","fragmentHeadBlock","targetNextKey","targetParentKey","fragmentRootBlocks","lastRootFragmentBlockKey","targetParent","originalTargetParentChildKeys","targetBlockIndex","insertionIndex","newChildrenKeysArray","insertFragment","isTreeBasedBlockMap","newBlockArr","fragmentSize","shouldNotUpdateFromFragmentBlock","updatedBlockMap","fragmentBlockMap","characterMetadata","blockText","newOffset","operation","transformBlock","func","getAncestorsKeys","parents","getNextDelimitersBlockKeys","nextDelimiters","nextDelimiter","_block","getNextValidSibling","nextValidSiblingKey","getPrevValidSibling","prevValidSiblingKey","delimiterKey","isExperimentalTreeBlock","parentAncestors","endBlockchildrenKeys","endBlockAncestors","removeFromList","modifiedStart","originalBlock","belowBlock","originalBlockKey","belowBlockKey","newChildrenArray","blockToSplit","keyBelow","blockBelow","blocksBefore","blocksAfter","bidiService","UnicodeBidiService","prevBidiMap","reset","nextBidi","bidiMap","defaultDir","_defaultDir","_lastDir","originalBlockToBeMoved","originalTargetBlock","isInsertedAfterTarget","originalTargetKey","originalParentKey","originalNextSiblingKey","originalPrevSiblingKey","newParentKey","newNextSiblingKey","newPrevSiblingKey","newParentChildrenList","blockToBeMoved","blocksToBeMoved","blockMapWithoutBlocksToBeMoved","nextDelimiterBlockKey","isBlockToBeMoved","hasNextSiblingAndIsNotNextSibling","doesNotHaveNextSiblingAndIsNotDelimiter","slicedBlocks","canOccupySlice","occupySlice","targetArr","componentKey","decorators","_decorators","counter","component","DraftEditorCompositionHandler","DraftEditorContents","DraftEditorDragHandler","DraftEditorEditHandler","DraftEditorPlaceholder","isIE","allowSpellCheck","handlerMap","edit","composite","drag","cut","focus","alreadyHasFocus","editorNode","editor","blur","setMode","mode","_handler","exitCurrentMode","restoreEditorDOM","contentsKey","setClipboard","clipboard","_clipboard","getClipboard","_latestEditorState","onChange","onDragEnter","_dragCount","onDragLeave","_blockSelectEvents","_editorKey","editorKey","_placeholderAccessibilityID","_latestCommittedEditorState","_onBeforeInput","_buildHandler","_onBlur","_onCharacterData","_onCompositionEnd","_onCompositionStart","_onCopy","_onCut","_onDragEnd","_onDragOver","_onDragStart","_onDrop","_onInput","_onFocus","_onKeyDown","_onKeyPress","_onKeyUp","_onMouseDown","_onMouseUp","_onPaste","_onSelect","getEditorKey","eventName","_showPlaceholder","placeholder","_renderPlaceholder","placeHolderProps","textAlignment","accessibilityID","_this3","blockRendererFn","blockStyleFn","textDirectionality","rootClass","contentStyle","outline","userSelect","WebkitUserSelect","whiteSpace","ariaRole","ariaExpanded","editorContentsProps","editorContainer","ariaActiveDescendantID","ariaAutoComplete","ariaControls","ariaDescribedBy","ariaLabel","ariaLabelledBy","ariaMultiline","autoCapitalize","autoComplete","autoCorrect","notranslate","contentEditable","webDriverTestID","onBeforeInput","onCompositionEnd","onCompositionStart","onCopy","onCut","onDragEnd","onDragOver","onDragStart","onDrop","onFocus","onInput","onKeyDown","onKeyPress","onKeyUp","onMouseUp","onPaste","onSelect","spellCheck","suppressContentEditableWarning","tabIndex","execCommand","componentWillUpdate","componentDidUpdate","keyBindingFn","stripPastedStyles","resolved","stillComposing","textInputData","setTimeout","resolveComposition","which","composedChars","mustReset","handleBeforeInput","joinClasses","getListItemClasses","shouldResetCount","prevEditorState","nextEditorState","nextNativeContent","wasComposing","nowComposing","prevContent","nextContent","prevDecorator","nextDecorator","blocksAsArray","processedBlocks","lastWrapperTemplate","customRenderer","CustomComponent","customProps","customEditable","componentProps","blockProps","configForType","wrapperTemplate","childProps","outputBlocks","_ii","wrapperElement","cloneElement","DraftEditorTextNode","setDraftEditorSelection","_setSelection","targetNode","tagName","leafNode","endsWith","_props2","styleObj","styleName","mergedStyles","newStyles","isNewline","useNewlineChar","NEWLINE_A","NEWLINE_B","_forceFlag","shouldBeNewline","UAParser","UNKNOWN","PLATFORM_MAP","parser","getResult","browserVersionData","major","minor","parts","browser","uaData","cpu","architecture","browserMinorVersion","browserVersion","device","model","engine","os","platformVersion","MODEL","NAME","TYPE","VENDOR","VERSION","MOBILE","TABLET","SMARTTV","extend","regexes","extensions","mergedRegexes","enumerize","enums","toUpperCase","str1","str2","lowerize","majorize","rgxMapper","ua","arrays","j","q","regex","strMapper","oldSafariMap","windowsVersionMap","OPERA","FIREFOX","SAMSUNG","CHROME","APPLE","EDGE","_navigator","navigator","_ua","userAgent","_uach","userAgentData","_rgxmap","_isSelfNav","getBrowser","_browser","brave","isBrave","getCPU","_cpu","getDevice","_device","mobile","standalone","maxTouchPoints","getEngine","_engine","getOS","_os","platform","getUA","setUA","BROWSER","CPU","DEVICE","ENGINE","OS","$","jQuery","Zepto","prop","__webpack_amd_options__","checkOrExpression","expressions","orRegex","checkRangeExpression","rangeRegex","checkSimpleExpression","startVersion","endVersion","isSimpleVersion","versionComponents","componentRegex","_getModifierAndCompon","getModifierAndComponents","modifier","rangeComponents","checkLessThan","checkLessThanOrEqual","checkGreaterThanOrEqual","checkGreaterThan","checkApproximateVersion","checkEqual","compareComponents","lowerBound","upperBound","lastIndex","numeric","isNumber","modifierRegex","number","isFinite","zeroPad","normalizeVersions","compareNumeric","aPrefix","numericRegex","bPrefix","aNumeric","bNumeric","_normalizeVersions","aNormalized","bNormalized","getAnonymizedDOM","getNodeLabels","anonymized","anonymizeTextWithin","outerHTML","labels","createTextNode","clone","cloneNode","setAttribute","appendChild","getAnonymizedEditorDOM","currentNode","hasAttribute","getNodeLength","nodeValue","nodeStart","nodeEnd","tempKey","tempOffset","hasAnchor","removeAllRanges","addPointToSelection","addFocusToSelection","storedFocusNode","storedFocusOffset","DraftJsDebugLogging","logSelectionStateFailure","anonymizedDom","extraParams","nodeWasFocus","activeElementName","nodeIsFocus","selectionRangeCount","rangeCount","selectionAnchorNodeName","selectionAnchorOffset","selectionFocusNodeName","selectionFocusOffset","message","getRangeAt","setEnd","addRange","createRange","isNode","asString","computedStyle","getComputedStyle","getPropertyValue","hyphenate","cssFloat","styleFloat","camelize","_hyphenPattern","_uppercasePattern","rect","getElementRect","top","bottom","elem","docElem","getBoundingClientRect","round","clientLeft","clientTop","scrollingElement","isWebkit","compatMode","pageXOffset","getViewportWidth","getViewportHeight","innerHeight","withoutScrollbars","nextClass","argLength","getSelectionForEvent","caretRangeFromPoint","dropRange","rangeParent","rangeOffset","newContentState","insertTextAtSelection","nativeEvent","dataTransfer","dropSelection","handleDroppedFiles","fileText","dragType","_internalDrag","handleDrop","getParts","mimeString","isJpeg","callee","ret","hasArrayNature","mustPreventDefaultForCharacter","isFirefox","FF_QUICKFIND_CHAR","FF_QUICKFIND_LINK_CHAR","editOnBeforeInput","_pendingStateFromBeforeInput","mustPreventNative","nativeSelection","setImmediate","Function","task","tasksByHandle","nextHandle","registerImmediate","clearImmediate","handle","run","runIfPresent","currentlyRunningATask","attachTo","process","nextTick","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","messagePrefix","onGlobalMessage","attachEvent","MessageChannel","channel","port1","port2","script","onreadystatechange","removeChild","editOnBlur","_selection","currentSelection","editOnCompositionStart","editOnCopy","editOnCut","removeFragment","editOnDragOver","editOnDragStart","editOnFocus","editOnInput","domSelection","isNotTextNode","isNotTextOrElementNode","ELEMENT_NODE","previousSibling","span","domText","_DraftOffsetKey$decod","_editorState$getBlock","modelText","DOUBLE_NEWLINE","entityType","preserveEntity","isGecko","charDelta","contentWithAdjustedDOMSelection","onKeyCommand","keyCommandPlainDelete","keyCommandDeleteWord","keyCommandPlainBackspace","keyCommandBackspaceWord","keyCommandBackspaceToStartOfLine","keyCommandInsertNewline","keyCommandTransposeCharacters","keyCommandMoveSelectionToStartOfBlock","keyCommandMoveSelectionToEndOfBlock","SecondaryClipboard","paste","editOnKeyDown","handleReturn","onEscape","onUpArrow","onRightArrow","onDownArrow","onLeftArrow","keyCommandUndo","newState","blockEnd","strategyState","expandRangeToStartOfLine","getLineHeightPx","computed","div","lineHeight","position","documentBody","areRectsOnOneLine","minTop","minBottom","maxTop","maxBottom","DOCUMENT_TYPE_NODE","PROCESSING_INSTRUCTION_NODE","COMMENT_NODE","collapsed","containingElement","bestContainer","bestOffset","setStartBefore","display","currentContainer","maxIndexToConsider","toRemove","charBehind","charAhead","finalSelection","afterInsert","updateFn","undoneState","editOnPaste","clipboardData","defaultFileText","handlePastedFiles","splitTextIntoTextBlocks","currentBlockType","DraftPasteProcessor","processText","withInsertedText","textBlocks","handlePastedText","internalClipboard","areTextBlocksAndClipboardEqual","htmlFragment","processHTML","htmlMap","textFragment","textMap","textLine","blockNodeConfig","prevSiblingIndex","previousBlock","_uri","adjustment","NEWLINE_REGEX","editOnSelect","documentSelection","getDraftEditorSelection","updatedSelectionState","encodeEntityRanges","encodeInlineStyleRanges","createRawBlock","entityStorageMap","inlineStyleRanges","insertRawBlock","blockCacheRef","rawBlock","encodeRawBlocks","rawState","entityCacheRef","entityStorageKey","stringifiedEntityKey","encodeRawEntityMap","rawEntityMap","rawDraftContentState","storageMap","encoded","Number","getEncodedInlinesForType","styleList","styleToEncode","filteredInlines","isTruthy","EMPTY_ARRAY","DraftTreeAdapter","createCharacterList","decodeEntityRanges","decodeInlineStyleRanges","decodeBlockNodeConfig","decodeCharacterList","rawEntityRanges","rawInlineStyleRanges","addKeyIfMissing","updateNodeStack","parentRef","nodesWithParentRef","decodeContentBlockNodes","contentBlockNode","siblings","_index","isValidBlock","_children","_contentBlockNode","decodeContentBlocks","decodeRawBlocks","isTreeRawBlock","fromRawStateToRawTreeState","fromRawTreeStateToRawState","decodeRawEntityMap","rawEntityKey","_rawEntityMap$rawEnti","traverseInDepthOrder","isListBlock","addDepthToChildren","draftTreeState","transformedBlocks","draftState","lastListDepthCacheRef","treeBlock","characterArray","boundingRect","getRangeBoundingClientRect","_rects$","_rects$2","__WEBPACK_IMPORTED_MODULE_0_react__","__WEBPACK_IMPORTED_MODULE_0_react___default","__WEBPACK_IMPORTED_MODULE_1_immutable__","__WEBPACK_IMPORTED_MODULE_2_format_number__","__WEBPACK_IMPORTED_MODULE_2_format_number___default","__WEBPACK_IMPORTED_MODULE_3_classnames__","__WEBPACK_IMPORTED_MODULE_3_classnames___default","__WEBPACK_IMPORTED_MODULE_4_draft_js__","__WEBPACK_IMPORTED_MODULE_5__Spinner__","__WEBPACK_IMPORTED_MODULE_6__myEditor_style_css__","__WEBPACK_IMPORTED_MODULE_6__myEditor_style_css___default","__WEBPACK_IMPORTED_MODULE_7__modules_ProposalEditor_proposalEditor_style_css__","__WEBPACK_IMPORTED_MODULE_7__modules_ProposalEditor_proposalEditor_style_css___default","MyEditor","inFocus","charsLeft","getChars","errorMessages","setEditorRef","DomEditor","getBlockRenderMap","handleClick","showError","handleMouseEnter","isHovering","handleMouseLeave","removeEventListener","integerSeparator","myEditor","onMouseEnter","onMouseLeave","editorTitle","displayTitle","editorBlock","errorStyles","AuthorInfo","authorInfo","header","email","phoneNumber","sp","TopBar","defaultStyle","spring","topBar","transform","minWidth","ProposalStats","startDate","endDate","formattedVotes","proposalStats","supporters"],"mappings":"AAAAA,cAAc,GAAGC,MAAM,IAAIC,QAErB,SAAUC,EAAQC,EAAqBC,GAE7C,YCJA,gJAMO,IAAMC,IAAc,GDYnB,CACA,CACA,CACA,CAEF,SAAUH,EAAQI,EAASF,IEdhC,SAAUG,EAAQC,GAC8CN,EAAOI,QAAUE,KAGhFC,EAAM,WAAc,YAEpB,SAASC,GAAYC,EAAMC,GACrBA,IACFD,EAAKE,UAAYC,OAAOC,OAAOH,EAAWC,YAE5CF,EAAKE,UAAUG,YAAcL,EAG/B,QAASM,GAASC,GACd,MAAOC,GAAWD,GAASA,EAAQE,EAAIF,GAKzC,QAASG,GAAcH,GACrB,MAAOI,GAAQJ,GAASA,EAAQK,EAASL,GAK3C,QAASM,GAAgBN,GACvB,MAAOO,GAAUP,GAASA,EAAQQ,EAAWR,GAK/C,QAASS,GAAYT,GACnB,MAAOC,GAAWD,KAAWU,EAAcV,GAASA,EAAQW,EAAOX,GAKvE,QAASC,GAAWW,GAClB,SAAUA,IAAiBA,EAAcC,KAG3C,QAAST,GAAQU,GACf,SAAUA,IAAcA,EAAWC,KAGrC,QAASR,GAAUS,GACjB,SAAUA,IAAgBA,EAAaC,KAGzC,QAASP,GAAcQ,GACrB,MAAOd,GAAQc,IAAqBX,EAAUW,GAGhD,QAASC,GAAUC,GACjB,SAAUA,IAAgBA,EAAaC,KAmCzC,QAASC,GAAQC,GAEf,MADAA,GAAIvB,OAAQ,EACLuB,EAGT,QAASC,GAAOD,GACdA,IAAQA,EAAIvB,OAAQ,GAMtB,QAASyB,MAGT,QAASC,GAAQC,EAAKC,GACpBA,EAASA,GAAU,CAGnB,KAAK,GAFDC,GAAMC,KAAKC,IAAI,EAAGJ,EAAIK,OAASJ,GAC/BK,EAAS,GAAInD,OAAM+C,GACdK,EAAK,EAAGA,EAAKL,EAAKK,IACzBD,EAAOC,GAAMP,EAAIO,EAAKN,EAExB,OAAOK,GAGT,QAASE,GAAWC,GAIlB,WAHkBC,KAAdD,EAAKE,OACPF,EAAKE,KAAOF,EAAKG,UAAUC,IAEtBJ,EAAKE,KAGd,QAASG,GAAUL,EAAMM,GAQvB,GAAqB,gBAAVA,GAAoB,CAC7B,GAAIC,GAAcD,IAAU,CAC5B,IAAI,GAAKC,IAAgBD,GAAyB,aAAhBC,EAChC,MAAOC,IAETF,GAAQC,EAEV,MAAOD,GAAQ,EAAIP,EAAWC,GAAQM,EAAQA,EAGhD,QAASF,KACP,OAAO,EAGT,QAASK,GAAWC,EAAOC,EAAKT,GAC9B,OAAkB,IAAVQ,OAAyBT,KAATC,GAAsBQ,IAAUR,SAC7CD,KAARU,OAA+BV,KAATC,GAAsBS,GAAOT,GAGxD,QAASU,GAAaF,EAAOR,GAC3B,MAAOW,GAAaH,EAAOR,EAAM,GAGnC,QAASY,GAAWH,EAAKT,GACvB,MAAOW,GAAaF,EAAKT,EAAMA,GAGjC,QAASW,GAAaP,EAAOJ,EAAMa,GACjC,WAAiBd,KAAVK,EACLS,EACAT,EAAQ,EACNZ,KAAKC,IAAI,EAAGO,EAAOI,OACVL,KAATC,EACEI,EACAZ,KAAKsB,IAAId,EAAMI,GAevB,QAASW,GAASC,GACd/D,KAAK+D,KAAOA,EAmBhB,QAASC,GAAcC,EAAMC,EAAGC,EAAGC,GACjC,GAAI3D,GAAiB,IAATwD,EAAaC,EAAa,IAATD,EAAaE,GAAKD,EAAGC,EAIlD,OAHAC,GAAkBA,EAAe3D,MAAQA,EAAU2D,GACjD3D,MAAOA,EAAO4D,MAAM,GAEfD,EAGT,QAASE,KACP,OAAS7D,UAAOqC,GAAWuB,MAAM,GAGnC,QAASE,GAAYlD,GACnB,QAASmD,EAAcnD,GAGzB,QAASoD,GAAWC,GAClB,MAAOA,IAA+C,kBAAvBA,GAAcX,KAG/C,QAASY,GAAYC,GACnB,GAAIC,GAAaL,EAAcI,EAC/B,OAAOC,IAAcA,EAAWC,KAAKF,GAGvC,QAASJ,GAAcI,GACrB,GAAIC,GAAaD,IACdG,IAAwBH,EAASG,KAClCH,EAASI,IAEX,IAA0B,kBAAfH,GACT,MAAOA,GAIX,QAASI,GAAYxE,GACnB,MAAOA,IAAiC,gBAAjBA,GAAMgC,OAI7B,QAAS9B,GAAIF,GACX,MAAiB,QAAVA,OAA4BqC,KAAVrC,EAAsByE,IAC7CxE,EAAWD,GAASA,EAAM0E,QAAUC,EAAa3E,GAsCrD,QAASK,GAASL,GAChB,MAAiB,QAAVA,OAA4BqC,KAAVrC,EACvByE,IAAgBG,aAChB3E,EAAWD,GACRI,EAAQJ,GAASA,EAAM0E,QAAU1E,EAAM6E,eACxCC,EAAkB9E,GAUxB,QAASQ,GAAWR,GAClB,MAAiB,QAAVA,OAA4BqC,KAAVrC,EAAsByE,IAC5CxE,EAAWD,GACZI,EAAQJ,GAASA,EAAM+E,WAAa/E,EAAMgF,eADrBC,EAAoBjF,GA2B7C,QAASW,GAAOX,GACd,OACY,OAAVA,OAA4BqC,KAAVrC,EAAsByE,IACvCxE,EAAWD,GACZI,EAAQJ,GAASA,EAAM+E,WAAa/E,EADfiF,EAAoBjF,IAEzCkF,WAyBJ,QAASC,GAASC,GAChB7F,KAAK8F,OAASD,EACd7F,KAAK+C,KAAO8C,EAAMpD,OAgCpB,QAASsD,GAAUC,GACjB,GAAIC,GAAO5F,OAAO4F,KAAKD,EACvBhG,MAAKkG,QAAUF,EACfhG,KAAKmG,MAAQF,EACbjG,KAAK+C,KAAOkD,EAAKxD,OA4CnB,QAAS2D,GAAYxB,GACnB5E,KAAKqG,UAAYzB,EACjB5E,KAAK+C,KAAO6B,EAASnC,QAAUmC,EAAS7B,KAwC1C,QAASuD,GAAYC,GACnBvG,KAAKwG,UAAYD,EACjBvG,KAAKyG,kBAkDT,QAASC,GAAMC,GACb,SAAUA,IAAYA,EAASC,KAKjC,QAAS1B,KACP,MAAO2B,MAAcA,GAAY,GAAIjB,QAGvC,QAASL,GAAkB9E,GACzB,GAAIqG,GACFvH,MAAMwH,QAAQtG,GAAS,GAAImF,GAASnF,GAAO6E,eAC3Cb,EAAWhE,GAAS,GAAI6F,GAAY7F,GAAO6E,eAC3Cf,EAAY9D,GAAS,GAAI2F,GAAY3F,GAAO6E,eAC3B,gBAAV7E,GAAqB,GAAIsF,GAAUtF,OAC1CqC,EACF,KAAKgE,EACH,KAAM,IAAIE,WACR,yEACsBvG,EAG1B,OAAOqG,GAGT,QAASpB,GAAoBjF,GAC3B,GAAIqG,GAAMG,EAAyBxG,EACnC,KAAKqG,EACH,KAAM,IAAIE,WACR,gDAAkDvG,EAGtD,OAAOqG,GAGT,QAAS1B,GAAa3E,GACpB,GAAIqG,GAAMG,EAAyBxG,IACf,gBAAVA,IAAsB,GAAIsF,GAAUtF,EAC9C,KAAKqG,EACH,KAAM,IAAIE,WACR,iEAAmEvG,EAGvE,OAAOqG,GAGT,QAASG,GAAyBxG,GAChC,MACEwE,GAAYxE,GAAS,GAAImF,GAASnF,GAClCgE,EAAWhE,GAAS,GAAI6F,GAAY7F,GACpC8D,EAAY9D,GAAS,GAAI2F,GAAY3F,OACrCqC,GAIJ,QAASoE,GAAWJ,EAAKK,EAAIC,EAASC,GACpC,GAAIC,GAAQR,EAAIS,MAChB,IAAID,EAAO,CAET,IAAK,GADDE,GAAWF,EAAM7E,OAAS,EACrBE,EAAK,EAAGA,GAAM6E,EAAU7E,IAAM,CACrC,GAAI8E,GAAQH,EAAMF,EAAUI,EAAW7E,EAAKA,EAC5C,KAAmD,IAA/CwE,EAAGM,EAAM,GAAIJ,EAAUI,EAAM,GAAK9E,EAAImE,GACxC,MAAOnE,GAAK,EAGhB,MAAOA,GAET,MAAOmE,GAAIY,kBAAkBP,EAAIC,GAGnC,QAASO,GAAYb,EAAK7C,EAAMmD,EAASC,GACvC,GAAIC,GAAQR,EAAIS,MAChB,IAAID,EAAO,CACT,GAAIE,GAAWF,EAAM7E,OAAS,EAC1BE,EAAK,CACT,OAAO,IAAImB,GAAS,WAClB,GAAI2D,GAAQH,EAAMF,EAAUI,EAAW7E,EAAKA,EAC5C,OAAOA,KAAO6E,EACZlD,IACAN,EAAcC,EAAMoD,EAAUI,EAAM,GAAK9E,EAAK,EAAG8E,EAAM,MAG7D,MAAOX,GAAIc,mBAAmB3D,EAAMmD,GAGtC,QAASS,GAAOC,EAAMC,GACpB,MAAOA,GACLC,EAAWD,EAAWD,EAAM,IAAK,GAAIA,IACrCG,EAAcH,GAGlB,QAASE,GAAWD,EAAWD,EAAMI,EAAKC,GACxC,MAAI5I,OAAMwH,QAAQe,GACTC,EAAUjD,KAAKqD,EAAYD,EAAKjH,EAAW6G,GAAMM,IAAI,SAASjE,EAAGD,GAAK,MAAO8D,GAAWD,EAAW5D,EAAGD,EAAG4D,MAE9GO,EAAWP,GACNC,EAAUjD,KAAKqD,EAAYD,EAAKpH,EAASgH,GAAMM,IAAI,SAASjE,EAAGD,GAAK,MAAO8D,GAAWD,EAAW5D,EAAGD,EAAG4D,MAEzGA,EAGT,QAASG,GAAcH,GACrB,MAAIvI,OAAMwH,QAAQe,GACT7G,EAAW6G,GAAMM,IAAIH,GAAeK,SAEzCD,EAAWP,GACNhH,EAASgH,GAAMM,IAAIH,GAAeM,QAEpCT,EAGT,QAASO,GAAW5H,GAClB,MAAOA,KAAUA,EAAMF,cAAgBF,YAAgCyC,KAAtBrC,EAAMF,aAyDzD,QAASiI,GAAGC,EAAQC,GAClB,GAAID,IAAWC,GAAWD,IAAWA,GAAUC,IAAWA,EACxD,OAAO,CAET,KAAKD,IAAWC,EACd,OAAO,CAET,IAA8B,kBAAnBD,GAAOE,SACY,kBAAnBD,GAAOC,QAAwB,CAGxC,GAFAF,EAASA,EAAOE,UAChBD,EAASA,EAAOC,UACZF,IAAWC,GAAWD,IAAWA,GAAUC,IAAWA,EACxD,OAAO,CAET,KAAKD,IAAWC,EACd,OAAO,EAGX,QAA6B,kBAAlBD,GAAOG,QACW,kBAAlBF,GAAOE,SACdH,EAAOG,OAAOF,IAMpB,QAASG,GAAUC,EAAGC,GACpB,GAAID,IAAMC,EACR,OAAO,CAGT,KACGrI,EAAWqI,QACDjG,KAAXgG,EAAE/F,UAAiCD,KAAXiG,EAAEhG,MAAsB+F,EAAE/F,OAASgG,EAAEhG,UAChDD,KAAbgG,EAAEE,YAAqClG,KAAbiG,EAAEC,QAAwBF,EAAEE,SAAWD,EAAEC,QACnEnI,EAAQiI,KAAOjI,EAAQkI,IACvB/H,EAAU8H,KAAO9H,EAAU+H,IAC3BnH,EAAUkH,KAAOlH,EAAUmH,GAE3B,OAAO,CAGT,IAAe,IAAXD,EAAE/F,MAAyB,IAAXgG,EAAEhG,KACpB,OAAO,CAGT,IAAIkG,IAAkB9H,EAAc2H,EAEpC,IAAIlH,EAAUkH,GAAI,CAChB,GAAII,GAAUJ,EAAEI,SAChB,OAAOH,GAAEI,MAAM,SAAShF,EAAGD,GACzB,GAAIuD,GAAQyB,EAAQnF,OAAOtD,KAC3B,OAAOgH,IAASe,EAAGf,EAAM,GAAItD,KAAO8E,GAAkBT,EAAGf,EAAM,GAAIvD,OAC/DgF,EAAQnF,OAAOM,KAGvB,GAAI+E,IAAU,CAEd,QAAetG,KAAXgG,EAAE/F,KACJ,OAAeD,KAAXiG,EAAEhG,KACyB,kBAAlB+F,GAAEO,aACXP,EAAEO,kBAEC,CACLD,GAAU,CACV,IAAIE,GAAIR,CACRA,GAAIC,EACJA,EAAIO,EAIR,GAAIC,IAAW,EACXC,EAAQT,EAAE/F,UAAU,SAASmB,EAAGD,GAClC,GAAI+E,GAAkBH,EAAEW,IAAItF,GACxBiF,GAAWZ,EAAGrE,EAAG2E,EAAEY,IAAIxF,EAAGyF,MAAanB,EAAGM,EAAEY,IAAIxF,EAAGyF,IAAUxF,GAE/D,MADAoF,IAAW,GACJ,GAIX,OAAOA,IAAYT,EAAE/F,OAASyG,EAK9B,QAASI,GAAOnJ,EAAOoJ,GACrB,KAAM7J,eAAgB4J,IACpB,MAAO,IAAIA,GAAOnJ,EAAOoJ,EAI3B,IAFA7J,KAAK8J,OAASrJ,EACdT,KAAK+C,SAAiBD,KAAV+G,EAAsBE,IAAWxH,KAAKC,IAAI,EAAGqH,GACvC,IAAd7J,KAAK+C,KAAY,CACnB,GAAIiH,GACF,MAAOA,GAETA,IAAehK,MAoErB,QAASiK,GAAUC,EAAWC,GAC5B,IAAKD,EAAW,KAAM,IAAIE,OAAMD,GAKhC,QAASE,GAAMC,EAAO9G,EAAK+G,GACzB,KAAMvK,eAAgBqK,IACpB,MAAO,IAAIA,GAAMC,EAAO9G,EAAK+G,EAe/B,IAbAN,EAAmB,IAATM,EAAY,4BACtBD,EAAQA,GAAS,MACLxH,KAARU,IACFA,EAAMuG,KAERQ,MAAgBzH,KAATyH,EAAqB,EAAIhI,KAAKiI,IAAID,GACrC/G,EAAM8G,IACRC,GAAQA,GAEVvK,KAAKyK,OAASH,EACdtK,KAAK0K,KAAOlH,EACZxD,KAAK2K,MAAQJ,EACbvK,KAAK+C,KAAOR,KAAKC,IAAI,EAAGD,KAAKqI,MAAMpH,EAAM8G,GAASC,EAAO,GAAK,GAC5C,IAAdvK,KAAK+C,KAAY,CACnB,GAAI8H,GACF,MAAOA,GAETA,IAAc7K,MA2FlB,QAAS8K,MACP,KAAM9D,WAAU,YAIqB,QAAS+D,OAEP,QAASC,OAEb,QAASC,OAuBhD,QAASC,IAAIC,GACX,MAASA,KAAQ,EAAK,WAAqB,WAANA,EAGvC,QAASC,IAAKC,GACZ,IAAU,IAANA,GAAqB,OAANA,OAAoBvI,KAANuI,EAC/B,MAAO,EAET,IAAyB,kBAAdA,GAAE1C,WAED,KADV0C,EAAIA,EAAE1C,YACmB,OAAN0C,OAAoBvI,KAANuI,GAC/B,MAAO,EAGX,KAAU,IAANA,EACF,MAAO,EAET,IAAIpH,SAAcoH,EAClB,IAAa,WAATpH,EAAmB,CACrB,GAAIqH,GAAQ,EAAJD,CAIR,KAHIC,IAAMD,IACRC,GAAS,WAAJD,GAEAA,EAAI,YACTA,GAAK,WACLC,GAAKD,CAEP,OAAOH,IAAII,GAEb,GAAa,WAATrH,EACF,MAAOoH,GAAE5I,OAAS8I,GAA+BC,GAAiBH,GAAKI,GAAWJ,EAEpF,IAA0B,kBAAfA,GAAEK,SACX,MAAOL,GAAEK,UAEX,IAAa,WAATzH,EACF,MAAO0H,IAAUN,EAEnB,IAA0B,kBAAfA,GAAEO,SACX,MAAOH,IAAWJ,EAAEO,WAEtB,MAAM,IAAIxB,OAAM,cAAgBnG,EAAO,sBAGzC,QAASuH,IAAiBK,GACxB,GAAIT,GAAOU,GAAgBD,EAU3B,YATa/I,KAATsI,IACFA,EAAOK,GAAWI,GACdE,KAA2BC,KAC7BD,GAAyB,EACzBD,OAEFC,KACAD,GAAgBD,GAAUT,GAErBA,EAIT,QAASK,IAAWI,GAQlB,IAAK,GADDT,GAAO,EACFzI,EAAK,EAAGA,EAAKkJ,EAAOpJ,OAAQE,IACnCyI,EAAO,GAAKA,EAAOS,EAAOI,WAAWtJ,GAAM,CAE7C,OAAOuI,IAAIE,GAGb,QAASO,IAAUO,GACjB,GAAId,EACJ,IAAIe,QAEWrJ,MADbsI,EAAOgB,GAAQ1C,IAAIwC,IAEjB,MAAOd,EAKX,QAAatI,MADbsI,EAAOc,EAAIG,KAET,MAAOjB,EAGT,KAAKkB,GAAmB,CAEtB,OAAaxJ,MADbsI,EAAOc,EAAIK,sBAAwBL,EAAIK,qBAAqBF,KAE1D,MAAOjB,EAIT,QAAatI,MADbsI,EAAOoB,GAAcN,IAEnB,MAAOd,GASX,GALAA,IAASqB,GACQ,WAAbA,KACFA,GAAa,GAGXN,GACFC,GAAQM,IAAIR,EAAKd,OACZ,QAAqBtI,KAAjB6J,KAAoD,IAAtBA,GAAaT,GACpD,KAAM,IAAI9B,OAAM,kDACX,IAAIkC,GACTjM,OAAOuM,eAAeV,EAAKG,IACzB,YAAc,EACd,cAAgB,EAChB,UAAY,EACZ,MAASjB,QAEN,QAAiCtI,KAA7BoJ,EAAIK,sBACJL,EAAIK,uBAAyBL,EAAI3L,YAAYH,UAAUmM,qBAKhEL,EAAIK,qBAAuB,WACzB,MAAOvM,MAAKO,YAAYH,UAAUmM,qBAAqBM,MAAM7M,KAAM8M,YAErEZ,EAAIK,qBAAqBF,IAAgBjB,MACpC,QAAqBtI,KAAjBoJ,EAAIa,SAOb,KAAM,IAAI3C,OAAM,qDAFhB8B,GAAIG,IAAgBjB,GAKtB,MAAOA,GAkBT,QAASoB,IAAcQ,GACrB,GAAIA,GAAQA,EAAKD,SAAW,EAC1B,OAAQC,EAAKD,UACX,IAAK,GACH,MAAOC,GAAKC,QACd,KAAK,GACH,MAAOD,GAAKE,iBAAmBF,EAAKE,gBAAgBD,UAwB5D,QAASE,IAAkBpK,GACzBkH,EACElH,IAASgH,IACT,qDAQF,QAASqD,IAAI3M,GACX,MAAiB,QAAVA,OAA4BqC,KAAVrC,EAAsB4M,KAC7CC,GAAM7M,KAAWmB,EAAUnB,GAASA,EACpC4M,KAAWE,cAAc,SAASnF,GAChC,GAAIvF,GAAOjC,EAAcH,EACzB0M,IAAkBtK,EAAKE,MACvBF,EAAK2K,QAAQ,SAASrJ,EAAGD,GAAK,MAAOkE,GAAIsE,IAAIxI,EAAGC,OAkKxD,QAASmJ,IAAMG,GACb,SAAUA,IAAYA,EAASC,KAiB/B,QAASC,IAAaC,EAAS1E,GAC7BlJ,KAAK4N,QAAUA,EACf5N,KAAKkJ,QAAUA,EAgEjB,QAAS2E,IAAkBD,EAASE,EAAQC,GAC1C/N,KAAK4N,QAAUA,EACf5N,KAAK8N,OAASA,EACd9N,KAAK+N,MAAQA,EAkEf,QAASC,IAAiBJ,EAASK,EAAOF,GACxC/N,KAAK4N,QAAUA,EACf5N,KAAKiO,MAAQA,EACbjO,KAAK+N,MAAQA,EAuDf,QAASG,IAAkBN,EAASO,EAASjF,GAC3ClJ,KAAK4N,QAAUA,EACf5N,KAAKmO,QAAUA,EACfnO,KAAKkJ,QAAUA,EAyEjB,QAASkF,IAAUR,EAASO,EAAS1G,GACnCzH,KAAK4N,QAAUA,EACf5N,KAAKmO,QAAUA,EACfnO,KAAKyH,MAAQA,EAgEf,QAAS4G,IAAYjG,EAAKnE,EAAMmD,GAC9BpH,KAAKsO,MAAQrK,EACbjE,KAAKuO,SAAWnH,EAChBpH,KAAKwO,OAASpG,EAAIqG,OAASC,GAAiBtG,EAAIqG,OAsCpD,QAASE,IAAiB1K,EAAMwD,GAC9B,MAAOzD,GAAcC,EAAMwD,EAAM,GAAIA,EAAM,IAG7C,QAASiH,IAAiB1B,EAAM4B,GAC9B,OACE5B,KAAMA,EACN7J,MAAO,EACP0L,OAAQD,GAIZ,QAASE,IAAQ/L,EAAMgM,EAAMnB,EAASxC,GACpC,GAAIhD,GAAM/H,OAAOC,OAAO0O,GAMxB,OALA5G,GAAIrF,KAAOA,EACXqF,EAAIqG,MAAQM,EACZ3G,EAAI6G,UAAYrB,EAChBxF,EAAIY,OAASoC,EACbhD,EAAI8G,WAAY,EACT9G,EAIT,QAASiF,MACP,MAAO8B,MAAcA,GAAYL,GAAQ,IAG3C,QAASM,IAAUhH,EAAKlE,EAAGC,GACzB,GAAIkL,GACAC,CACJ,IAAKlH,EAAIqG,MAMF,CACL,GAAIc,GAAgBxN,EAAQyN,IACxBC,EAAW1N,EAAQ2N,GAEvB,IADAL,EAAUM,GAAWvH,EAAIqG,MAAOrG,EAAI6G,UAAW,MAAGnM,GAAWoB,EAAGC,EAAGoL,EAAeE,IAC7EA,EAAShP,MACZ,MAAO2H,EAETkH,GAAUlH,EAAIrF,MAAQwM,EAAc9O,MAAQ0D,IAAMwF,IAAW,EAAI,EAAI,OAbvD,CACd,GAAIxF,IAAMwF,GACR,MAAOvB,EAETkH,GAAU,EACVD,EAAU,GAAI1B,IAAavF,EAAI6G,YAAa/K,EAAGC,KAUjD,MAAIiE,GAAI6G,WACN7G,EAAIrF,KAAOuM,EACXlH,EAAIqG,MAAQY,EACZjH,EAAIY,WAASlG,GACbsF,EAAI8G,WAAY,EACT9G,GAEFiH,EAAUP,GAAQQ,EAASD,GAAWhC,KAG/C,QAASsC,IAAW3C,EAAMY,EAASgC,EAAOzB,EAASjG,EAAKzH,EAAO8O,EAAeE,GAC5E,MAAKzC,GAQEA,EAAK6C,OAAOjC,EAASgC,EAAOzB,EAASjG,EAAKzH,EAAO8O,EAAeE,GAPjEhP,IAAUkJ,GACLqD,GAET/K,EAAOwN,GACPxN,EAAOsN,GACA,GAAInB,IAAUR,EAASO,GAAUjG,EAAKzH,KAKjD,QAASqP,IAAW9C,GAClB,MAAOA,GAAKzM,cAAgB6N,IAAapB,EAAKzM,cAAgB2N,GAGhE,QAAS6B,IAAc/C,EAAMY,EAASgC,EAAOzB,EAAS1G,GACpD,GAAIuF,EAAKmB,UAAYA,EACnB,MAAO,IAAID,IAAkBN,EAASO,GAAUnB,EAAKvF,MAAOA,GAG9D,IAGIuI,GAHAC,GAAkB,IAAVL,EAAc5C,EAAKmB,QAAUnB,EAAKmB,UAAYyB,GAASM,GAC/DC,GAAkB,IAAVP,EAAczB,EAAUA,IAAYyB,GAASM,EAOzD,OAAO,IAAIrC,IAAkBD,EAAU,GAAKqC,EAAS,GAAKE,EAJ9CF,IAASE,GAClBJ,GAAc/C,EAAMY,EAASgC,EAAQQ,GAAOjC,EAAS1G,KACpDuI,EAAU,GAAI5B,IAAUR,EAASO,EAAS1G,GAASwI,EAAOE,GAAQnD,EAAMgD,IAAYA,EAAShD,KAKnG,QAASqD,IAAYzC,EAAS1E,EAAShB,EAAKzH,GACrCmN,IACHA,EAAU,GAAI1L,GAGhB,KAAK,GADD8K,GAAO,GAAIoB,IAAUR,EAASxC,GAAKlD,IAAOA,EAAKzH,IAC1CkC,EAAK,EAAGA,EAAKuG,EAAQzG,OAAQE,IAAM,CAC1C,GAAI8E,GAAQyB,EAAQvG,EACpBqK,GAAOA,EAAK6C,OAAOjC,EAAS,MAAG9K,GAAW2E,EAAM,GAAIA,EAAM,IAE5D,MAAOuF,GAGT,QAASsD,IAAU1C,EAASG,EAAOE,EAAOsC,GAIxC,IAAK,GAHDzC,GAAS,EACT0C,EAAW,EACXC,EAAc,GAAIlR,OAAM0O,GACnBtL,EAAK,EAAG+N,EAAM,EAAGpO,EAAMyL,EAAMtL,OAAQE,EAAKL,EAAKK,IAAM+N,IAAQ,EAAG,CACvE,GAAI1D,GAAOe,EAAMpL,OACJG,KAATkK,GAAsBrK,IAAO4N,IAC/BzC,GAAU4C,EACVD,EAAYD,KAAcxD,GAG9B,MAAO,IAAIa,IAAkBD,EAASE,EAAQ2C,GAGhD,QAASE,IAAY/C,EAASG,EAAOD,EAAQ8C,EAAW5D,GAGtD,IAAK,GAFDiB,GAAQ,EACR4C,EAAgB,GAAItR,OAAMuR,IACrBnO,EAAK,EAAc,IAAXmL,EAAcnL,IAAMmL,KAAY,EAC/C+C,EAAclO,GAAe,EAATmL,EAAaC,EAAME,SAAWnL,EAGpD,OADA+N,GAAcD,GAAa5D,EACpB,GAAIgB,IAAiBJ,EAASK,EAAQ,EAAG4C,GAGlD,QAASE,IAAiB3I,EAAK4I,EAAQC,GAErC,IAAK,GADDC,MACKvO,EAAK,EAAGA,EAAKsO,EAAUxO,OAAQE,IAAM,CAC5C,GAAIlC,GAAQwQ,EAAUtO,GAClBE,EAAOjC,EAAcH,EACpBC,GAAWD,KACdoC,EAAOA,EAAKuF,IAAI,SAASjE,GAAK,MAAO0D,GAAO1D,MAE9C+M,EAAMC,KAAKtO,GAEb,MAAOuO,IAAwBhJ,EAAK4I,EAAQE,GAG9C,QAASG,IAAWC,EAAU7Q,EAAOyH,GACnC,MAAOoJ,IAAYA,EAASC,WAAa7Q,EAAWD,GAClD6Q,EAASC,UAAU9Q,GACnB+H,EAAG8I,EAAU7Q,GAAS6Q,EAAW7Q,EAGrC,QAAS+Q,IAAeR,GACtB,MAAO,UAASM,EAAU7Q,EAAOyH,GAC/B,GAAIoJ,GAAYA,EAASG,eAAiB/Q,EAAWD,GACnD,MAAO6Q,GAASG,cAAcT,EAAQvQ,EAExC,IAAIiR,GAAYV,EAAOM,EAAU7Q,EAAOyH,EACxC,OAAOM,GAAG8I,EAAUI,GAAaJ,EAAWI,GAIhD,QAASN,IAAwBO,EAAYX,EAAQE,GAEnD,MADAA,GAAQA,EAAMU,OAAO,SAASC,GAAK,MAAkB,KAAXA,EAAE9O,OACvB,IAAjBmO,EAAMzO,OACDkP,EAEe,IAApBA,EAAW5O,MAAe4O,EAAW1C,WAA8B,IAAjBiC,EAAMzO,OAGrDkP,EAAWpE,cAAc,SAASoE,GAUvC,IAAK,GATDG,GAAed,EACjB,SAASvQ,EAAOyH,GACdyJ,EAAW9B,OAAO3H,EAAKyB,GAAS,SAAS2H,GACtC,MAAOA,KAAa3H,GAAUlJ,EAAQuQ,EAAOM,EAAU7Q,EAAOyH,MAGnE,SAASzH,EAAOyH,GACdyJ,EAAWjF,IAAIxE,EAAKzH,IAEfkC,EAAK,EAAGA,EAAKuO,EAAMzO,OAAQE,IAClCuO,EAAMvO,GAAI6K,QAAQsE,KAbbH,EAAWpR,YAAY2Q,EAAM,IAkBxC,QAASa,IAAgBT,EAAUU,EAAaC,EAAaC,GAC3D,GAAIC,GAAWb,IAAa3H,GACxBY,EAAOyH,EAAYjO,MACvB,IAAIwG,EAAKlG,KAAM,CACb,GAAI+N,GAAgBD,EAAWF,EAAcX,EACzCe,EAAWH,EAAQE,EACvB,OAAOC,KAAaD,EAAgBd,EAAWe,EAEjDpI,EACEkI,GAAab,GAAYA,EAAS5E,IAClC,kBAEF,IAAIxE,GAAMqC,EAAK9J,MACX6R,EAAeH,EAAWxI,GAAU2H,EAAS5H,IAAIxB,EAAKyB,IACtD4I,EAAcR,GAChBO,EACAN,EACAC,EACAC,EAEF,OAAOK,KAAgBD,EAAehB,EACpCiB,IAAgB5I,GAAU2H,EAASkB,OAAOtK,IACzCiK,EAAW9E,KAAaiE,GAAU5E,IAAIxE,EAAKqK,GAGhD,QAASE,IAASZ,GAMhB,MALAA,IAAUA,GAAK,EAAK,WACpBA,GAAS,UAAJA,IAAoBA,GAAK,EAAK,WACnCA,EAAKA,GAAKA,GAAK,GAAM,UACrBA,GAASA,GAAK,EAEH,KADXA,GAASA,GAAK,IAIhB,QAASa,IAAM7M,EAAO8M,EAAKC,EAAKC,GAC9B,GAAIC,GAAWD,EAAUhN,EAAQ1D,EAAQ0D,EAEzC,OADAiN,GAASH,GAAOC,EACTE,EAGT,QAASC,IAASlN,EAAO8M,EAAKC,EAAKC,GACjC,GAAIG,GAASnN,EAAMpD,OAAS,CAC5B,IAAIoQ,GAAWF,EAAM,IAAMK,EAEzB,MADAnN,GAAM8M,GAAOC,EACN/M,CAIT,KAAK,GAFDiN,GAAW,GAAIvT,OAAMyT,GACrBC,EAAQ,EACHtQ,EAAK,EAAGA,EAAKqQ,EAAQrQ,IACxBA,IAAOgQ,GACTG,EAASnQ,GAAMiQ,EACfK,GAAS,GAETH,EAASnQ,GAAMkD,EAAMlD,EAAKsQ,EAG9B,OAAOH,GAGT,QAASI,IAAUrN,EAAO8M,EAAKE,GAC7B,GAAIG,GAASnN,EAAMpD,OAAS,CAC5B,IAAIoQ,GAAWF,IAAQK,EAErB,MADAnN,GAAMsN,MACCtN,CAIT,KAAK,GAFDiN,GAAW,GAAIvT,OAAMyT,GACrBC,EAAQ,EACHtQ,EAAK,EAAGA,EAAKqQ,EAAQrQ,IACxBA,IAAOgQ,IACTM,EAAQ,GAEVH,EAASnQ,GAAMkD,EAAMlD,EAAKsQ,EAE5B,OAAOH,GAWP,QAASM,IAAK3S,GACZ,GAAI4S,GAAQC,IACZ,IAAc,OAAV7S,OAA4BqC,KAAVrC,EACpB,MAAO4S,EAET,IAAIE,GAAO9S,GACT,MAAOA,EAET,IAAIoC,GAAO9B,EAAgBN,GACvBsC,EAAOF,EAAKE,IAChB,OAAa,KAATA,EACKsQ,GAETlG,GAAkBpK,GACdA,EAAO,GAAKA,EAAO+N,GACd0C,GAAS,EAAGzQ,EAAMqN,GAAO,KAAM,GAAIqD,IAAM5Q,EAAK6Q,YAEhDL,EAAM9F,cAAc,SAASoG,GAClCA,EAAKC,QAAQ7Q,GACbF,EAAK2K,QAAQ,SAASrJ,EAAG0P,GAAK,MAAOF,GAAKjH,IAAImH,EAAG1P,QA4JvD,QAASoP,IAAOO,GACd,SAAUA,IAAaA,EAAUC,KAwBjC,QAASN,IAAM5N,EAAO+H,GACpB5N,KAAK6F,MAAQA,EACb7F,KAAK4N,QAAUA,EAmEnB,QAASoG,IAAYL,EAAMvM,GAQzB,QAAS6M,GAAkBjH,EAAMkH,EAAO7R,GACtC,MAAiB,KAAV6R,EACLC,EAAYnH,EAAM3K,GAClB+R,EAAYpH,EAAMkH,EAAO7R,GAG7B,QAAS8R,GAAYnH,EAAM3K,GACzB,GAAIwD,GAAQxD,IAAWgS,EAAUC,GAAQA,EAAKzO,MAAQmH,GAAQA,EAAKnH,MAC/D0O,EAAOlS,EAASmS,EAAO,EAAIA,EAAOnS,EAClCoS,EAAKC,EAAQrS,CAIjB,OAHIoS,GAAK3D,KACP2D,EAAK3D,IAEA,WACL,GAAIyD,IAASE,EACX,MAAOE,GAET,IAAIhC,GAAMvL,IAAYqN,EAAKF,GAC3B,OAAO1O,IAASA,EAAM8M,IAI1B,QAASyB,GAAYpH,EAAMkH,EAAO7R,GAChC,GAAIuS,GACA/O,EAAQmH,GAAQA,EAAKnH,MACrB0O,EAAOlS,EAASmS,EAAO,EAAKA,EAAOnS,GAAW6R,EAC9CO,EAAmC,GAA5BC,EAAQrS,GAAW6R,EAI9B,OAHIO,GAAK3D,KACP2D,EAAK3D,IAEA,WACL,OAAG,CACD,GAAI8D,EAAQ,CACV,GAAInU,GAAQmU,GACZ,IAAInU,IAAUkU,GACZ,MAAOlU,EAETmU,GAAS,KAEX,GAAIL,IAASE,EACX,MAAOE,GAET,IAAIhC,GAAMvL,IAAYqN,EAAKF,GAC3BK,GAASX,EACPpO,GAASA,EAAM8M,GAAMuB,EAAQ9D,GAAO/N,GAAUsQ,GAAOuB,MAnD7D,GAAIM,GAAOb,EAAKkB,QACZH,EAAQf,EAAKmB,UACbT,EAAUU,GAAcL,GACxBJ,EAAOX,EAAKqB,KAEhB,OAAOf,GAAkBN,EAAKlF,MAAOkF,EAAKsB,OAAQ,GAqDpD,QAASzB,IAAS0B,EAAQC,EAAUjB,EAAOnF,EAAMuF,EAAM1G,EAASxC,GAC9D,GAAIuI,GAAOtT,OAAOC,OAAO8U,GAUzB,OATAzB,GAAK5Q,KAAOoS,EAAWD,EACvBvB,EAAKkB,QAAUK,EACfvB,EAAKmB,UAAYK,EACjBxB,EAAKsB,OAASf,EACdP,EAAKlF,MAAQM,EACb4E,EAAKqB,MAAQV,EACbX,EAAK1E,UAAYrB,EACjB+F,EAAK3K,OAASoC,EACduI,EAAKzE,WAAY,EACVyE,EAIT,QAASL,MACP,MAAO+B,MAAeA,GAAa7B,GAAS,EAAG,EAAGpD,KAGpD,QAASkF,IAAW3B,EAAMxQ,EAAO1C,GAG/B,IAFA0C,EAAQD,EAAUyQ,EAAMxQ,MAEVA,EACZ,MAAOwQ,EAGT,IAAIxQ,GAASwQ,EAAK5Q,MAAQI,EAAQ,EAChC,MAAOwQ,GAAKpG,cAAc,SAASoG,GACjCxQ,EAAQ,EACNoS,GAAc5B,EAAMxQ,GAAOuJ,IAAI,EAAGjM,GAClC8U,GAAc5B,EAAM,EAAGxQ,EAAQ,GAAGuJ,IAAIvJ,EAAO1C,IAInD0C,IAASwQ,EAAKkB,OAEd,IAAIW,GAAU7B,EAAKqB,MACf3F,EAAUsE,EAAKlF,MACfgB,EAAW1N,EAAQ2N,GAOvB,OANIvM,IAAS4R,GAAcpB,EAAKmB,WAC9BU,EAAUC,GAAYD,EAAS7B,EAAK1E,UAAW,EAAG9L,EAAO1C,EAAOgP,GAEhEJ,EAAUoG,GAAYpG,EAASsE,EAAK1E,UAAW0E,EAAKsB,OAAQ9R,EAAO1C,EAAOgP,GAGvEA,EAAShP,MAIVkT,EAAK1E,WACP0E,EAAKlF,MAAQY,EACbsE,EAAKqB,MAAQQ,EACb7B,EAAK3K,WAASlG,GACd6Q,EAAKzE,WAAY,EACVyE,GAEFH,GAASG,EAAKkB,QAASlB,EAAKmB,UAAWnB,EAAKsB,OAAQ5F,EAASmG,GAV3D7B,EAaX,QAAS8B,IAAYzI,EAAMY,EAASsG,EAAO/Q,EAAO1C,EAAOgP,GACvD,GAAIkD,GAAOxP,IAAU+Q,EAAShE,GAC1BwF,EAAU1I,GAAQ2F,EAAM3F,EAAKnH,MAAMpD,MACvC,KAAKiT,OAAqB5S,KAAVrC,EACd,MAAOuM,EAGT,IAAIgD,EAEJ,IAAIkE,EAAQ,EAAG,CACb,GAAIyB,GAAY3I,GAAQA,EAAKnH,MAAM8M,GAC/BiD,EAAeH,GAAYE,EAAW/H,EAASsG,EAAQ9D,GAAOjN,EAAO1C,EAAOgP,EAChF,OAAImG,KAAiBD,EACZ3I,GAETgD,EAAU6F,GAAc7I,EAAMY,GAC9BoC,EAAQnK,MAAM8M,GAAOiD,EACd5F,GAGT,MAAI0F,IAAW1I,EAAKnH,MAAM8M,KAASlS,EAC1BuM,GAGT/K,EAAOwN,GAEPO,EAAU6F,GAAc7I,EAAMY,OAChB9K,KAAVrC,GAAuBkS,IAAQ3C,EAAQnK,MAAMpD,OAAS,EACxDuN,EAAQnK,MAAMsN,MAEdnD,EAAQnK,MAAM8M,GAAOlS,EAEhBuP,GAGT,QAAS6F,IAAc7I,EAAMY,GAC3B,MAAIA,IAAWZ,GAAQY,IAAYZ,EAAKY,QAC/BZ,EAEF,GAAIyG,IAAMzG,EAAOA,EAAKnH,MAAMiQ,WAAclI,GAGnD,QAASmI,IAAYpC,EAAMqC,GACzB,GAAIA,GAAYjB,GAAcpB,EAAKmB,WACjC,MAAOnB,GAAKqB,KAEd,IAAIgB,EAAW,GAAMrC,EAAKsB,OAAS7E,GAAQ,CAGzC,IAFA,GAAIpD,GAAO2G,EAAKlF,MACZyF,EAAQP,EAAKsB,OACVjI,GAAQkH,EAAQ,GACrBlH,EAAOA,EAAKnH,MAAOmQ,IAAa9B,EAAShE,IACzCgE,GAAS9D,EAEX,OAAOpD,IAIX,QAASuI,IAAc5B,EAAMpQ,EAAOC,OAGpBV,KAAVS,IACFA,GAAgB,OAENT,KAARU,IACFA,GAAY,EAEd,IAAIyS,GAAQtC,EAAK1E,WAAa,GAAI/M,GAC9BgU,EAAYvC,EAAKkB,QACjBsB,EAAcxC,EAAKmB,UACnBsB,EAAYF,EAAY3S,EACxB8S,MAAsBvT,KAARU,EAAoB2S,EAAc3S,EAAM,EAAI2S,EAAc3S,EAAM0S,EAAY1S,CAC9F,IAAI4S,IAAcF,GAAaG,IAAgBF,EAC7C,MAAOxC,EAIT,IAAIyC,GAAaC,EACf,MAAO1C,GAAK2C,OAQd,KALA,GAAIC,GAAW5C,EAAKsB,OAChB5F,EAAUsE,EAAKlF,MAGf+H,EAAc,EACXJ,EAAYI,EAAc,GAC/BnH,EAAU,GAAIoE,IAAMpE,GAAWA,EAAQxJ,MAAMpD,YAAUK,GAAWuM,MAAe4G,GACjFM,GAAYnG,GACZoG,GAAe,GAAKD,CAElBC,KACFJ,GAAaI,EACbN,GAAaM,EACbH,GAAeG,EACfL,GAAeK,EAOjB,KAJA,GAAIC,GAAgB1B,GAAcoB,GAC9BO,EAAgB3B,GAAcsB,GAG3BK,GAAiB,GAAMH,EAAWnG,IACvCf,EAAU,GAAIoE,IAAMpE,GAAWA,EAAQxJ,MAAMpD,QAAU4M,MAAe4G,GACtEM,GAAYnG,EAId,IAAIuG,GAAUhD,EAAKqB,MACfQ,EAAUkB,EAAgBD,EAC5BV,GAAYpC,EAAM0C,EAAc,GAChCK,EAAgBD,EAAgB,GAAIhD,OAAUwC,GAASU,CAGzD,IAAIA,GAAWD,EAAgBD,GAAiBL,EAAYD,GAAeQ,EAAQ9Q,MAAMpD,OAAQ,CAC/F4M,EAAUwG,GAAcxG,EAAS4G,EAEjC,KAAK,GADDjJ,GAAOqC,EACF6E,EAAQqC,EAAUrC,EAAQ9D,GAAO8D,GAAS9D,GAAO,CACxD,GAAIuC,GAAO8D,IAAkBvC,EAAShE,EACtClD,GAAOA,EAAKnH,MAAM8M,GAAOkD,GAAc7I,EAAKnH,MAAM8M,GAAMsD,GAE1DjJ,EAAKnH,MAAO4Q,IAAkBrG,GAASF,IAAQyG,EASjD,GALIN,EAAcF,IAChBX,EAAUA,GAAWA,EAAQoB,YAAYX,EAAO,EAAGI,IAIjDD,GAAaM,EACfN,GAAaM,EACbL,GAAeK,EACfH,EAAWnG,GACXf,EAAU,KACVmG,EAAUA,GAAWA,EAAQqB,aAAaZ,EAAO,EAAGG,OAG/C,IAAIA,EAAYF,GAAaQ,EAAgBD,EAAe,CAIjE,IAHAD,EAAc,EAGPnH,GAAS,CACd,GAAIyH,GAAcV,IAAcG,EAAYrG,EAC5C,IAAI4G,IAAgBJ,IAAkBH,EAAYrG,GAChD,KAEE4G,KACFN,IAAgB,GAAKD,GAAYO,GAEnCP,GAAYnG,GACZf,EAAUA,EAAQxJ,MAAMiR,GAItBzH,GAAW+G,EAAYF,IACzB7G,EAAUA,EAAQwH,aAAaZ,EAAOM,EAAUH,EAAYI,IAE1DnH,GAAWqH,EAAgBD,IAC7BpH,EAAUA,EAAQuH,YAAYX,EAAOM,EAAUG,EAAgBF,IAE7DA,IACFJ,GAAaI,EACbH,GAAeG,GAInB,MAAI7C,GAAK1E,WACP0E,EAAK5Q,KAAOsT,EAAcD,EAC1BzC,EAAKkB,QAAUuB,EACfzC,EAAKmB,UAAYuB,EACjB1C,EAAKsB,OAASsB,EACd5C,EAAKlF,MAAQY,EACbsE,EAAKqB,MAAQQ,EACb7B,EAAK3K,WAASlG,GACd6Q,EAAKzE,WAAY,EACVyE,GAEFH,GAAS4C,EAAWC,EAAaE,EAAUlH,EAASmG,GAG7D,QAASuB,IAAkBpD,EAAM3C,EAAQC,GAGvC,IAAK,GAFDC,MACA8F,EAAU,EACLrU,EAAK,EAAGA,EAAKsO,EAAUxO,OAAQE,IAAM,CAC5C,GAAIlC,GAAQwQ,EAAUtO,GAClBE,EAAO9B,EAAgBN,EACvBoC,GAAKE,KAAOiU,IACdA,EAAUnU,EAAKE,MAEZrC,EAAWD,KACdoC,EAAOA,EAAKuF,IAAI,SAASjE,GAAK,MAAO0D,GAAO1D,MAE9C+M,EAAMC,KAAKtO,GAKb,MAHImU,GAAUrD,EAAK5Q,OACjB4Q,EAAOA,EAAKC,QAAQoD,IAEf5F,GAAwBuC,EAAM3C,EAAQE,GAG/C,QAAS6D,IAAchS,GACrB,MAAOA,GAAO+N,GAAO,EAAO/N,EAAO,IAAOqN,IAAUA,GAOpD,QAAS6G,IAAWxW,GAClB,MAAiB,QAAVA,OAA4BqC,KAAVrC,EAAsByW,KAC7CC,GAAa1W,GAASA,EACtByW,KAAkB3J,cAAc,SAASnF,GACvC,GAAIvF,GAAOjC,EAAcH,EACzB0M,IAAkBtK,EAAKE,MACvBF,EAAK2K,QAAQ,SAASrJ,EAAGD,GAAK,MAAOkE,GAAIsE,IAAIxI,EAAGC,OAyExD,QAASgT,IAAaC,GACpB,MAAO9J,IAAM8J,IAAoBxV,EAAUwV,GAU7C,QAASC,IAAejP,EAAKuL,EAAM/F,EAASxC,GAC1C,GAAIkM,GAAOjX,OAAOC,OAAO2W,GAAW7W,UAMpC,OALAkX,GAAKvU,KAAOqF,EAAMA,EAAIrF,KAAO,EAC7BuU,EAAKC,KAAOnP,EACZkP,EAAKE,MAAQ7D,EACb2D,EAAKrI,UAAYrB,EACjB0J,EAAKtO,OAASoC,EACPkM,EAIT,QAASJ,MACP,MAAOO,MAAsBA,GAAoBJ,GAAehK,KAAYiG,OAG9E,QAASoE,IAAiBJ,EAAMpT,EAAGC,GACjC,GAIIwT,GACAC,EALAxP,EAAMkP,EAAKC,KACX5D,EAAO2D,EAAKE,MACZ3D,EAAIzL,EAAIsB,IAAIxF,GACZuF,MAAY3G,KAAN+Q,CAGV,IAAI1P,IAAMwF,GAAS,CACjB,IAAKF,EACH,MAAO6N,EAEL3D,GAAK5Q,MAAQ+N,IAAQ6C,EAAK5Q,MAAmB,EAAXqF,EAAIrF,MACxC6U,EAAUjE,EAAK/B,OAAO,SAASnK,EAAOkL,GAAO,WAAiB7P,KAAV2E,GAAuBoM,IAAMlB,IACjFgF,EAASC,EAAQvS,aAAa+C,IAAI,SAASX,GAAS,MAAOA,GAAM,KAAKoQ,OAAOtP,QACzE+O,EAAKrI,YACP0I,EAAO1I,UAAY2I,EAAQ3I,UAAYqI,EAAKrI,aAG9C0I,EAASvP,EAAIoK,OAAOtO,GACpB0T,EAAU/D,IAAMF,EAAK5Q,KAAO,EAAI4Q,EAAKR,MAAQQ,EAAKjH,IAAImH,MAAG/Q,SAG3D,IAAI2G,EAAK,CACP,GAAItF,IAAMwP,EAAKjK,IAAImK,GAAG,GACpB,MAAOyD,EAETK,GAASvP,EACTwP,EAAUjE,EAAKjH,IAAImH,GAAI3P,EAAGC,QAE1BwT,GAASvP,EAAIsE,IAAIxI,EAAGyP,EAAK5Q,MACzB6U,EAAUjE,EAAKjH,IAAIiH,EAAK5Q,MAAOmB,EAAGC,GAGtC,OAAImT,GAAKrI,WACPqI,EAAKvU,KAAO4U,EAAO5U,KACnBuU,EAAKC,KAAOI,EACZL,EAAKE,MAAQI,EACbN,EAAKtO,WAASlG,GACPwU,GAEFD,GAAeM,EAAQC,GAI9B,QAASE,IAAgBC,EAAS1Q,GAChCrH,KAAKgY,MAAQD,EACb/X,KAAKiY,SAAW5Q,EAChBrH,KAAK+C,KAAOgV,EAAQhV,KA2DtB,QAASmV,IAAkBrV,GACzB7C,KAAKgY,MAAQnV,EACb7C,KAAK+C,KAAOF,EAAKE,KAyBnB,QAASoV,IAActV,GACrB7C,KAAKgY,MAAQnV,EACb7C,KAAK+C,KAAOF,EAAKE,KAuBnB,QAASqV,IAAoBlP,GAC3BlJ,KAAKgY,MAAQ9O,EACblJ,KAAK+C,KAAOmG,EAAQnG,KAwDxB,QAASsV,IAAYzT,GACnB,GAAI0T,GAAeC,GAAa3T,EAiChC,OAhCA0T,GAAaN,MAAQpT,EACrB0T,EAAavV,KAAO6B,EAAS7B,KAC7BuV,EAAaT,KAAO,WAAa,MAAOjT,IACxC0T,EAAalR,QAAU,WACrB,GAAIoR,GAAmB5T,EAASwC,QAAQyF,MAAM7M,KAE9C,OADAwY,GAAiBX,KAAO,WAAa,MAAOjT,GAASwC,WAC9CoR,GAETF,EAAa7O,IAAM,SAASvB,GAAO,MAAOtD,GAAS6T,SAASvQ,IAC5DoQ,EAAaG,SAAW,SAASvQ,GAAO,MAAOtD,GAAS6E,IAAIvB,IAC5DoQ,EAAajP,YAAcqP,GAC3BJ,EAAa5Q,kBAAoB,SAAUP,EAAIC,GAAU,GAAIuR,GAAS3Y,IACpE,OAAO4E,GAAS5B,UAAU,SAASmB,EAAGD,GAAK,OAA4B,IAArBiD,EAAGjD,EAAGC,EAAGwU,IAAoBvR,IAEjFkR,EAAa1Q,mBAAqB,SAAS3D,EAAMmD,GAC/C,GAAInD,IAAS2U,GAAiB,CAC5B,GAAIrS,GAAW3B,EAASiU,WAAW5U,EAAMmD,EACzC,OAAO,IAAItD,GAAS,WAClB,GAAIyG,GAAOhE,EAASxC,MACpB,KAAKwG,EAAKlG,KAAM,CACd,GAAIH,GAAIqG,EAAK9J,MAAM,EACnB8J,GAAK9J,MAAM,GAAK8J,EAAK9J,MAAM,GAC3B8J,EAAK9J,MAAM,GAAKyD,EAElB,MAAOqG,KAGX,MAAO3F,GAASiU,WACd5U,IAAS6U,GAAiBC,GAAeD,GACzC1R,IAGGkR,EAIT,QAASU,IAAWpU,EAAUqU,EAAQC,GACpC,GAAIC,GAAiBZ,GAAa3T,EAgClC,OA/BAuU,GAAepW,KAAO6B,EAAS7B,KAC/BoW,EAAe1P,IAAM,SAASvB,GAAO,MAAOtD,GAAS6E,IAAIvB,IACzDiR,EAAezP,IAAM,SAASxB,EAAK+J,GACjC,GAAI9N,GAAIS,EAAS8E,IAAIxB,EAAKyB,GAC1B,OAAOxF,KAAMwF,GACXsI,EACAgH,EAAOnU,KAAKoU,EAAS/U,EAAG+D,EAAKtD,IAEjCuU,EAAezR,kBAAoB,SAAUP,EAAIC,GAAU,GAAIuR,GAAS3Y,IACtE,OAAO4E,GAAS5B,UACd,SAASmB,EAAGD,EAAGkV,GAAK,OAAwD,IAAjDjS,EAAG8R,EAAOnU,KAAKoU,EAAS/U,EAAGD,EAAGkV,GAAIlV,EAAGyU,IAChEvR,IAGJ+R,EAAevR,mBAAqB,SAAU3D,EAAMmD,GAClD,GAAIb,GAAW3B,EAASiU,WAAWD,GAAiBxR,EACpD,OAAO,IAAItD,GAAS,WAClB,GAAIyG,GAAOhE,EAASxC,MACpB,IAAIwG,EAAKlG,KACP,MAAOkG,EAET,IAAI9C,GAAQ8C,EAAK9J,MACbyH,EAAMT,EAAM,EAChB,OAAOzD,GACLC,EACAiE,EACA+Q,EAAOnU,KAAKoU,EAASzR,EAAM,GAAIS,EAAKtD,GACpC2F,MAIC4O,EAIT,QAASE,IAAezU,EAAUyC,GAChC,GAAImR,GAAmBD,GAAa3T,EAsBpC,OArBA4T,GAAiBR,MAAQpT,EACzB4T,EAAiBzV,KAAO6B,EAAS7B,KACjCyV,EAAiBpR,QAAU,WAAa,MAAOxC,IAC3CA,EAASiT,OACXW,EAAiBX,KAAO,WACtB,GAAIS,GAAeD,GAAYzT,EAE/B,OADA0T,GAAalR,QAAU,WAAa,MAAOxC,GAASiT,QAC7CS,IAGXE,EAAiB9O,IAAM,SAASxB,EAAK+J,GAClC,MAAOrN,GAAS8E,IAAIrC,EAAUa,GAAO,EAAIA,EAAK+J,IACjDuG,EAAiB/O,IAAM,SAASvB,GAC7B,MAAOtD,GAAS6E,IAAIpC,EAAUa,GAAO,EAAIA,IAC5CsQ,EAAiBC,SAAW,SAAShY,GAAS,MAAOmE,GAAS6T,SAAShY,IACvE+X,EAAiBnP,YAAcqP,GAC/BF,EAAiBxV,UAAY,SAAUmE,EAAIC,GAAU,GAAIuR,GAAS3Y,IAChE,OAAO4E,GAAS5B,UAAU,SAASmB,EAAGD,GAAK,MAAOiD,GAAGhD,EAAGD,EAAGyU,KAAWvR,IAExEoR,EAAiBK,WACf,SAAS5U,EAAMmD,GAAW,MAAOxC,GAASiU,WAAW5U,GAAOmD,IACvDoR,EAIT,QAASc,IAAc1U,EAAU2U,EAAWL,EAAS7R,GACnD,GAAImS,GAAiBjB,GAAa3T,EAwClC,OAvCIyC,KACFmS,EAAe/P,IAAM,SAASvB,GAC5B,GAAI/D,GAAIS,EAAS8E,IAAIxB,EAAKyB,GAC1B,OAAOxF,KAAMwF,MAAa4P,EAAUzU,KAAKoU,EAAS/U,EAAG+D,EAAKtD,IAE5D4U,EAAe9P,IAAM,SAASxB,EAAK+J,GACjC,GAAI9N,GAAIS,EAAS8E,IAAIxB,EAAKyB,GAC1B,OAAOxF,KAAMwF,IAAW4P,EAAUzU,KAAKoU,EAAS/U,EAAG+D,EAAKtD,GACtDT,EAAI8N,IAGVuH,EAAe9R,kBAAoB,SAAUP,EAAIC,GAAU,GAAIuR,GAAS3Y,KAClEyZ,EAAa,CAOjB,OANA7U,GAAS5B,UAAU,SAASmB,EAAGD,EAAGkV,GAChC,GAAIG,EAAUzU,KAAKoU,EAAS/U,EAAGD,EAAGkV,GAEhC,MADAK,KACOtS,EAAGhD,EAAGkD,EAAUnD,EAAIuV,EAAa,EAAGd,IAE5CvR,GACIqS,GAETD,EAAe5R,mBAAqB,SAAU3D,EAAMmD,GAClD,GAAIb,GAAW3B,EAASiU,WAAWD,GAAiBxR,GAChDqS,EAAa,CACjB,OAAO,IAAI3V,GAAS,WAClB,OAAa,CACX,GAAIyG,GAAOhE,EAASxC,MACpB,IAAIwG,EAAKlG,KACP,MAAOkG,EAET,IAAI9C,GAAQ8C,EAAK9J,MACbyH,EAAMT,EAAM,GACZhH,EAAQgH,EAAM,EAClB,IAAI8R,EAAUzU,KAAKoU,EAASzY,EAAOyH,EAAKtD,GACtC,MAAOZ,GAAcC,EAAMoD,EAAUa,EAAMuR,IAAchZ,EAAO8J,OAKjEiP,EAIT,QAASE,IAAe9U,EAAU+U,EAAST,GACzC,GAAIU,GAASxM,KAAMyM,WAQnB,OAPAjV,GAAS5B,UAAU,SAASmB,EAAGD,GAC7B0V,EAAO/J,OACL8J,EAAQ7U,KAAKoU,EAAS/U,EAAGD,EAAGU,GAC5B,EACA,SAASkE,GAAK,MAAOA,GAAI,MAGtB8Q,EAAOE,cAIhB,QAASC,IAAenV,EAAU+U,EAAST,GACzC,GAAIc,GAAcnZ,EAAQ+D,GACtBgV,GAAUhY,EAAUgD,GAAYqS,KAAe7J,MAAOyM,WAC1DjV,GAAS5B,UAAU,SAASmB,EAAGD,GAC7B0V,EAAO/J,OACL8J,EAAQ7U,KAAKoU,EAAS/U,EAAGD,EAAGU,GAC5B,SAASkE,GAAK,MAAQA,GAAIA,MAASA,EAAEqI,KAAK6I,GAAe9V,EAAGC,GAAKA,GAAI2E,KAGzE,IAAImR,GAASC,GAActV,EAC3B,OAAOgV,GAAOxR,IAAI,SAAShG,GAAO,MAAO+X,IAAMvV,EAAUqV,EAAO7X,MAIlE,QAASgY,IAAaxV,EAAUrB,EAAOC,EAAK6D,GAC1C,GAAIgT,GAAezV,EAAS7B,IAW5B,QAPcD,KAAVS,IACFA,GAAgB,OAENT,KAARU,IACFA,GAAY,GAGVF,EAAWC,EAAOC,EAAK6W,GACzB,MAAOzV,EAGT,IAAI0V,GAAgB7W,EAAaF,EAAO8W,GACpCE,EAAc5W,EAAWH,EAAK6W,EAKlC,IAAIC,IAAkBA,GAAiBC,IAAgBA,EACrD,MAAOH,IAAaxV,EAASO,QAAQkE,cAAe9F,EAAOC,EAAK6D,EAOlE,IACImT,GADAC,EAAeF,EAAcD,CAE7BG,KAAiBA,IACnBD,EAAYC,EAAe,EAAI,EAAIA,EAGrC,IAAIC,GAAWnC,GAAa3T,EA6D5B,OAzDA8V,GAAS3X,KAAqB,IAAdyX,EAAkBA,EAAY5V,EAAS7B,MAAQyX,OAAa1X,IAEvEuE,GAAWX,EAAM9B,IAAa4V,GAAa,IAC9CE,EAAShR,IAAM,SAAUvG,EAAO8O,GAE9B,MADA9O,GAAQD,EAAUlD,KAAMmD,GACjBA,GAAS,GAAKA,EAAQqX,EAC3B5V,EAAS8E,IAAIvG,EAAQmX,EAAerI,GACpCA,IAINyI,EAAShT,kBAAoB,SAASP,EAAIC,GAAU,GAAIuR,GAAS3Y,IAC/D,IAAkB,IAAdwa,EACF,MAAO,EAET,IAAIpT,EACF,MAAOpH,MAAKqJ,cAAcrG,UAAUmE,EAAIC,EAE1C,IAAIuT,GAAU,EACVC,GAAa,EACbnB,EAAa,CAQjB,OAPA7U,GAAS5B,UAAU,SAASmB,EAAGD,GAC7B,IAAM0W,KAAeA,EAAaD,IAAYL,GAE5C,MADAb,MACuD,IAAhDtS,EAAGhD,EAAGkD,EAAUnD,EAAIuV,EAAa,EAAGd,IACpCc,IAAee,IAGnBf,GAGTiB,EAAS9S,mBAAqB,SAAS3D,EAAMmD,GAC3C,GAAkB,IAAdoT,GAAmBpT,EACrB,MAAOpH,MAAKqJ,cAAcwP,WAAW5U,EAAMmD,EAG7C,IAAIb,GAAyB,IAAdiU,GAAmB5V,EAASiU,WAAW5U,EAAMmD,GACxDuT,EAAU,EACVlB,EAAa,CACjB,OAAO,IAAI3V,GAAS,WAClB,KAAO6W,IAAYL,GACjB/T,EAASxC,MAEX,MAAM0V,EAAae,EACjB,MAAOlW,IAET,IAAIiG,GAAOhE,EAASxC,MACpB,OAAIsD,IAAWpD,IAAS6U,GACfvO,EACEtG,IAAS8U,GACX/U,EAAcC,EAAMwV,EAAa,MAAG3W,GAAWyH,GAE/CvG,EAAcC,EAAMwV,EAAa,EAAGlP,EAAK9J,MAAM,GAAI8J,MAKzDmQ,EAIT,QAASG,IAAiBjW,EAAU2U,EAAWL,GAC7C,GAAI4B,GAAevC,GAAa3T,EAoChC,OAnCAkW,GAAapT,kBAAoB,SAASP,EAAIC,GAAU,GAAIuR,GAAS3Y,IACnE,IAAIoH,EACF,MAAOpH,MAAKqJ,cAAcrG,UAAUmE,EAAIC,EAE1C,IAAIqS,GAAa,CAIjB,OAHA7U,GAAS5B,UAAU,SAASmB,EAAGD,EAAGkV,GAC/B,MAAOG,GAAUzU,KAAKoU,EAAS/U,EAAGD,EAAGkV,MAAQK,GAActS,EAAGhD,EAAGD,EAAGyU,KAEhEc,GAETqB,EAAalT,mBAAqB,SAAS3D,EAAMmD,GAAU,GAAIuR,GAAS3Y,IACtE,IAAIoH,EACF,MAAOpH,MAAKqJ,cAAcwP,WAAW5U,EAAMmD,EAE7C,IAAIb,GAAW3B,EAASiU,WAAWD,GAAiBxR,GAChD2T,GAAY,CAChB,OAAO,IAAIjX,GAAS,WAClB,IAAKiX,EACH,MAAOzW,IAET,IAAIiG,GAAOhE,EAASxC,MACpB,IAAIwG,EAAKlG,KACP,MAAOkG,EAET,IAAI9C,GAAQ8C,EAAK9J,MACbyD,EAAIuD,EAAM,GACVtD,EAAIsD,EAAM,EACd,OAAK8R,GAAUzU,KAAKoU,EAAS/U,EAAGD,EAAGyU,GAI5B1U,IAAS2U,GAAkBrO,EAChCvG,EAAcC,EAAMC,EAAGC,EAAGoG,IAJ1BwQ,GAAY,EACLzW,QAMNwW,EAIT,QAASE,IAAiBpW,EAAU2U,EAAWL,EAAS7R,GACtD,GAAI4T,GAAe1C,GAAa3T,EA4ChC,OA3CAqW,GAAavT,kBAAoB,SAAUP,EAAIC,GAAU,GAAIuR,GAAS3Y,IACpE,IAAIoH,EACF,MAAOpH,MAAKqJ,cAAcrG,UAAUmE,EAAIC,EAE1C,IAAIwT,IAAa,EACbnB,EAAa,CAOjB,OANA7U,GAAS5B,UAAU,SAASmB,EAAGD,EAAGkV,GAChC,IAAMwB,KAAeA,EAAarB,EAAUzU,KAAKoU,EAAS/U,EAAGD,EAAGkV,IAE9D,MADAK,KACOtS,EAAGhD,EAAGkD,EAAUnD,EAAIuV,EAAa,EAAGd,KAGxCc,GAETwB,EAAarT,mBAAqB,SAAS3D,EAAMmD,GAAU,GAAIuR,GAAS3Y,IACtE,IAAIoH,EACF,MAAOpH,MAAKqJ,cAAcwP,WAAW5U,EAAMmD,EAE7C,IAAIb,GAAW3B,EAASiU,WAAWD,GAAiBxR,GAChD8T,GAAW,EACXzB,EAAa,CACjB,OAAO,IAAI3V,GAAS,WAClB,GAAIyG,GAAMrG,EAAGC,CACb,GAAG,CAED,GADAoG,EAAOhE,EAASxC,OACZwG,EAAKlG,KACP,MAAIgD,IAAWpD,IAAS6U,GACfvO,EACEtG,IAAS8U,GACX/U,EAAcC,EAAMwV,QAAc3W,GAAWyH,GAE7CvG,EAAcC,EAAMwV,IAAclP,EAAK9J,MAAM,GAAI8J,EAG5D,IAAI9C,GAAQ8C,EAAK9J,KACjByD,GAAIuD,EAAM,GACVtD,EAAIsD,EAAM,GACVyT,IAAaA,EAAW3B,EAAUzU,KAAKoU,EAAS/U,EAAGD,EAAGyU,UAC/CuC,EACT,OAAOjX,KAAS2U,GAAkBrO,EAChCvG,EAAcC,EAAMC,EAAGC,EAAGoG,MAGzB0Q,EAIT,QAASE,IAAcvW,EAAUgQ,GAC/B,GAAIwG,GAAkBva,EAAQ+D,GAC1BsM,GAAStM,GAAUpF,OAAOoV,GAAQxM,IAAI,SAASjE,GAQjD,MAPKzD,GAAWyD,GAILiX,IACTjX,EAAIvD,EAAcuD,IAJlBA,EAAIiX,EACF7V,EAAkBpB,GAClBuB,EAAoBnG,MAAMwH,QAAQ5C,GAAKA,GAAKA,IAIzCA,IACNyN,OAAO,SAASzN,GAAK,MAAkB,KAAXA,EAAEpB,MAEjC,IAAqB,IAAjBmO,EAAMzO,OACR,MAAOmC,EAGT,IAAqB,IAAjBsM,EAAMzO,OAAc,CACtB,GAAI4Y,GAAYnK,EAAM,EACtB,IAAImK,IAAczW,GACdwW,GAAmBva,EAAQwa,IAC3Bra,EAAU4D,IAAa5D,EAAUqa,GACnC,MAAOA,GAIX,GAAIC,GAAY,GAAI1V,GAASsL,EAkB7B,OAjBIkK,GACFE,EAAYA,EAAUjW,aACZrE,EAAU4D,KACpB0W,EAAYA,EAAU3V,YAExB2V,EAAYA,EAAUC,SAAQ,GAC9BD,EAAUvY,KAAOmO,EAAMsK,OACrB,SAASC,EAAK3U,GACZ,OAAYhE,KAAR2Y,EAAmB,CACrB,GAAI1Y,GAAO+D,EAAI/D,IACf,QAAaD,KAATC,EACF,MAAO0Y,GAAM1Y,IAInB,GAEKuY,EAIT,QAASI,IAAe9W,EAAU+W,EAAOtU,GACvC,GAAIuU,GAAerD,GAAa3T,EA0ChC,OAzCAgX,GAAalU,kBAAoB,SAASP,EAAIC,GAG5C,QAASyU,GAAShZ,EAAMiZ,GAAe,GAAInD,GAAS3Y,IAClD6C,GAAKG,UAAU,SAASmB,EAAGD,GAMzB,QALMyX,GAASG,EAAeH,IAAUjb,EAAWyD,GACjD0X,EAAS1X,EAAG2X,EAAe,IAC4B,IAA9C3U,EAAGhD,EAAGkD,EAAUnD,EAAIuV,IAAcd,KAC3CoD,GAAU,IAEJA,GACP3U,GAVL,GAAIqS,GAAa,EACbsC,GAAU,CAYd,OADAF,GAASjX,EAAU,GACZ6U,GAETmC,EAAahU,mBAAqB,SAAS3D,EAAMmD,GAC/C,GAAIb,GAAW3B,EAASiU,WAAW5U,EAAMmD,GACrC4U,KACAvC,EAAa,CACjB,OAAO,IAAI3V,GAAS,WAClB,KAAOyC,GAAU,CACf,GAAIgE,GAAOhE,EAASxC,MACpB,KAAkB,IAAdwG,EAAKlG,KAAT,CAIA,GAAIF,GAAIoG,EAAK9J,KAIb,IAHIwD,IAAS2U,KACXzU,EAAIA,EAAE,IAEFwX,KAASK,EAAMvZ,OAASkZ,KAAUjb,EAAWyD,GAIjD,MAAOkD,GAAUkD,EAAOvG,EAAcC,EAAMwV,IAActV,EAAGoG,EAH7DyR,GAAM7K,KAAK5K,GACXA,EAAWpC,EAAE0U,WAAW5U,EAAMmD,OAT9Bb,GAAWyV,EAAM7I,MAcrB,MAAO7O,QAGJsX,EAIT,QAASK,IAAerX,EAAUqU,EAAQC,GACxC,GAAIe,GAASC,GAActV,EAC3B,OAAOA,GAASO,QAAQiD,IACtB,SAASjE,EAAGD,GAAK,MAAO+V,GAAOhB,EAAOnU,KAAKoU,EAAS/U,EAAGD,EAAGU,MAC1D2W,SAAQ,GAIZ,QAASW,IAAiBtX,EAAUuX,GAClC,GAAIC,GAAqB7D,GAAa3T,EA2BtC,OA1BAwX,GAAmBrZ,KAAO6B,EAAS7B,MAAwB,EAAhB6B,EAAS7B,KAAU,EAC9DqZ,EAAmB1U,kBAAoB,SAASP,EAAIC,GAAU,GAAIuR,GAAS3Y,KACrEyZ,EAAa,CAMjB,OALA7U,GAAS5B,UAAU,SAASmB,EAAGD,GAC5B,QAASuV,IAAsD,IAAxCtS,EAAGgV,EAAW1C,IAAcd,MACpB,IAAhCxR,EAAGhD,EAAGsV,IAAcd,IACpBvR,GAEKqS,GAET2C,EAAmBxU,mBAAqB,SAAS3D,EAAMmD,GACrD,GAEImD,GAFAhE,EAAW3B,EAASiU,WAAWC,GAAgB1R,GAC/CqS,EAAa,CAEjB,OAAO,IAAI3V,GAAS,WAClB,QAAKyG,GAAQkP,EAAa,KACxBlP,EAAOhE,EAASxC,OACZwG,EAAKlG,MACAkG,EAGJkP,EAAa,EAClBzV,EAAcC,EAAMwV,IAAc0C,GAClCnY,EAAcC,EAAMwV,IAAclP,EAAK9J,MAAO8J,MAG7C6R,EAIT,QAASC,IAAYzX,EAAU0X,EAAYrD,GACpCqD,IACHA,EAAaC,GAEf,IAAInB,GAAkBva,EAAQ+D,GAC1BzB,EAAQ,EACR+F,EAAUtE,EAASO,QAAQiD,IAC7B,SAASjE,EAAGD,GAAK,OAAQA,EAAGC,EAAGhB,IAAS8V,EAASA,EAAO9U,EAAGD,EAAGU,GAAYT,KAC1EuP,SAMF,OALAxK,GAAQsT,KAAK,SAAS1T,EAAGC,GAAK,MAAOuT,GAAWxT,EAAE,GAAIC,EAAE,KAAOD,EAAE,GAAKC,EAAE,KAAKyE,QAC3E4N,EACA,SAASjX,EAAG0P,GAAM3K,EAAQ2K,GAAGpR,OAAS,GACtC,SAAS0B,EAAG0P,GAAM3K,EAAQ2K,GAAK1P,EAAE,KAE5BiX,EAAkBta,EAASoI,GAChClI,EAAU4D,GAAY3D,EAAWiI,GACjC9H,EAAO8H,GAIX,QAASuT,IAAW7X,EAAU0X,EAAYrD,GAIxC,GAHKqD,IACHA,EAAaC,IAEXtD,EAAQ,CACV,GAAIxR,GAAQ7C,EAASO,QAClBiD,IAAI,SAASjE,EAAGD,GAAK,OAAQC,EAAG8U,EAAO9U,EAAGD,EAAGU,MAC7C4W,OAAO,SAAS1S,EAAGC,GAAK,MAAO2T,IAAWJ,EAAYxT,EAAE,GAAIC,EAAE,IAAMA,EAAID,GAC3E,OAAOrB,IAASA,EAAM,GAEtB,MAAO7C,GAAS4W,OAAO,SAAS1S,EAAGC,GAAK,MAAO2T,IAAWJ,EAAYxT,EAAGC,GAAKA,EAAID,IAItF,QAAS4T,IAAWJ,EAAYxT,EAAGC,GACjC,GAAI4T,GAAOL,EAAWvT,EAAGD,EAGzB,OAAiB,KAAT6T,GAAc5T,IAAMD,QAAYhG,KAANiG,GAAyB,OAANA,GAAcA,IAAMA,IAAO4T,EAAO,EAIzF,QAASC,IAAeC,EAASC,EAAQ5L,GACvC,GAAI6L,GAAcxE,GAAasE,EAkD/B,OAjDAE,GAAYha,KAAO,GAAI6C,GAASsL,GAAO9I,IAAI,SAASyL,GAAK,MAAOA,GAAE9Q,OAAOc,MAGzEkZ,EAAY/Z,UAAY,SAASmE,EAAIC,GAiBnC,IAHA,GACImD,GADAhE,EAAWvG,KAAK6Y,WAAWC,GAAgB1R,GAE3CqS,EAAa,IACRlP,EAAOhE,EAASxC,QAAQM,OACY,IAAvC8C,EAAGoD,EAAK9J,MAAOgZ,IAAczZ,QAInC,MAAOyZ,IAETsD,EAAYnV,mBAAqB,SAAS3D,EAAMmD,GAC9C,GAAI4V,GAAY9L,EAAM9I,IAAI,SAASyL,GAChC,MAAQA,GAAIrT,EAASqT,GAAIlP,EAAYyC,EAAUyM,EAAEzM,UAAYyM,KAE5D4F,EAAa,EACbwD,GAAS,CACb,OAAO,IAAInZ,GAAS,WAClB,GAAIoZ,EAKJ,OAJKD,KACHC,EAAQF,EAAU5U,IAAI,SAASyL,GAAK,MAAOA,GAAE9P,SAC7CkZ,EAASC,EAAMC,KAAK,SAASC,GAAK,MAAOA,GAAE/Y,QAEzC4Y,EACK3Y,IAEFN,EACLC,EACAwV,IACAqD,EAAOjQ,MAAM,KAAMqQ,EAAM9U,IAAI,SAASgV,GAAK,MAAOA,GAAE3c,aAInDsc,EAMT,QAAS5C,IAAMtX,EAAMiE,GACnB,MAAOJ,GAAM7D,GAAQiE,EAAMjE,EAAKtC,YAAYuG,GAG9C,QAASuW,IAAc5V,GACrB,GAAIA,IAAUpH,OAAOoH,GACnB,KAAM,IAAIT,WAAU,0BAA4BS,GAIpD,QAAS6V,IAAYza,GAEnB,MADAsK,IAAkBtK,EAAKE,MAChBH,EAAWC,GAGpB,QAASqX,IAActV,GACrB,MAAO/D,GAAQ+D,GAAYhE,EACzBI,EAAU4D,GAAY7D,EACtBG,EAGJ,QAASqX,IAAa3T,GACpB,MAAOvE,QAAOC,QAEVO,EAAQ+D,GAAY9D,EACpBE,EAAU4D,GAAY3D,EACtBG,GACAhB,WAIN,QAASsY,MACP,MAAI1Y,MAAKgY,MAAM3O,aACbrJ,KAAKgY,MAAM3O,cACXrJ,KAAK+C,KAAO/C,KAAKgY,MAAMjV,KAChB/C,MAEAW,EAAIP,UAAUiJ,YAAYvE,KAAK9E,MAI1C,QAASuc,IAAkBzT,EAAGC,GAC5B,MAAOD,GAAIC,EAAI,EAAID,EAAIC,GAAK,EAAI,EAGlC,QAASwU,IAAcC,GACrB,GAAI3a,GAAO8B,EAAY6Y,EACvB,KAAK3a,EAAM,CAGT,IAAKoC,EAAYuY,GACf,KAAM,IAAIxW,WAAU,oCAAsCwW,EAE5D3a,GAAO8B,EAAYnE,EAASgd,IAE9B,MAAO3a,GAKP,QAAS4a,IAAOC,EAAeC,GAC7B,GAAIC,GAEAC,EAAa,SAAgBjJ,GAC/B,GAAIA,YAAkBiJ,GACpB,MAAOjJ,EAET,MAAM5U,eAAgB6d,IACpB,MAAO,IAAIA,GAAWjJ,EAExB,KAAKgJ,EAAgB,CACnBA,GAAiB,CACjB,IAAI3X,GAAO5F,OAAO4F,KAAKyX,EACvBI,IAASC,EAAqB9X,GAC9B8X,EAAoBhb,KAAOkD,EAAKxD,OAChCsb,EAAoBC,MAAQL,EAC5BI,EAAoB5X,MAAQF,EAC5B8X,EAAoBE,eAAiBP,EAEvC1d,KAAKuX,KAAOnK,GAAIwH,IAGdmJ,EAAsBF,EAAWzd,UAAYC,OAAOC,OAAO4d,GAG/D,OAFAH,GAAoBxd,YAAcsd,EAE3BA,EAkGX,QAASM,IAAWC,EAAYhW,EAAKwF,GACnC,GAAIyQ,GAAShe,OAAOC,OAAOD,OAAOie,eAAeF,GAGjD,OAFAC,GAAO9G,KAAOnP,EACdiW,EAAOpP,UAAYrB,EACZyQ,EAGT,QAASE,IAAWF,GAClB,MAAOA,GAAOL,OAASK,EAAO9d,YAAYod,MAAQ,SAGpD,QAASG,IAAS1d,EAAWoe,GAC3B,IACEA,EAAMhR,QAAQiR,GAAQC,SAAK5b,GAAW1C,IACtC,MAAO+J,KAKX,QAASsU,IAAQre,EAAWud,GAC1Btd,OAAOuM,eAAexM,EAAWud,GAC/BjU,IAAK,WACH,MAAO1J,MAAK0J,IAAIiU,IAElBjR,IAAK,SAASjM,GACZwJ,EAAUjK,KAAKiP,UAAW,sCAC1BjP,KAAK0M,IAAIiR,EAAMld,MASnB,QAASke,IAAIle,GACX,MAAiB,QAAVA,OAA4BqC,KAAVrC,EAAsBme,KAC7CC,GAAMpe,KAAWmB,EAAUnB,GAASA,EACpCme,KAAWrR,cAAc,SAASb,GAChC,GAAI7J,GAAO3B,EAAYT,EACvB0M,IAAkBtK,EAAKE,MACvBF,EAAK2K,QAAQ,SAASrJ,GAAK,MAAOuI,GAAIoS,IAAI3a,OA+HlD,QAAS0a,IAAME,GACb,SAAUA,IAAYA,EAASC,KAmBjC,QAASC,IAAUvS,EAAKiL,GACtB,MAAIjL,GAAIuC,WACNvC,EAAI3J,KAAO4U,EAAO5U,KAClB2J,EAAI6K,KAAOI,EACJjL,GAEFiL,IAAWjL,EAAI6K,KAAO7K,EACX,IAAhBiL,EAAO5U,KAAa2J,EAAIwS,UACxBxS,EAAIyS,OAAOxH,GAGf,QAASyH,IAAQhX,EAAKwF,GACpB,GAAIlB,GAAMrM,OAAOC,OAAO+e,GAIxB,OAHA3S,GAAI3J,KAAOqF,EAAMA,EAAIrF,KAAO,EAC5B2J,EAAI6K,KAAOnP,EACXsE,EAAIuC,UAAYrB,EACTlB,EAIT,QAASkS,MACP,MAAOU,MAAcA,GAAYF,GAAQ/R,OAOzC,QAASkS,IAAW9e,GAClB,MAAiB,QAAVA,OAA4BqC,KAAVrC,EAAsB+e,KAC7CC,GAAahf,GAASA,EACtB+e,KAAkBjS,cAAc,SAASb,GACvC,GAAI7J,GAAO3B,EAAYT,EACvB0M,IAAkBtK,EAAKE,MACvBF,EAAK2K,QAAQ,SAASrJ,GAAK,MAAOuI,GAAIoS,IAAI3a,OAiBlD,QAASsb,IAAaC,GACpB,MAAOb,IAAMa,IAAoB9d,EAAU8d,GAW7C,QAASC,IAAevX,EAAKwF,GAC3B,GAAIlB,GAAMrM,OAAOC,OAAOsf,GAIxB,OAHAlT,GAAI3J,KAAOqF,EAAMA,EAAIrF,KAAO,EAC5B2J,EAAI6K,KAAOnP,EACXsE,EAAIuC,UAAYrB,EACTlB,EAIT,QAAS8S,MACP,MAAOK,MAAsBA,GAAoBF,GAAezI,OAOhE,QAAS4I,IAAMrf,GACb,MAAiB,QAAVA,OAA4BqC,KAAVrC,EAAsBsf,KAC7CC,GAAQvf,GAASA,EACjBsf,KAAaE,WAAWxf,GAkL9B,QAASuf,IAAQE,GACf,SAAUA,IAAcA,EAAWC,KAerC,QAASC,IAAUrd,EAAMsd,EAAMzS,EAASxC,GACtC,GAAIhD,GAAM/H,OAAOC,OAAOggB,GAMxB,OALAlY,GAAIrF,KAAOA,EACXqF,EAAImY,MAAQF,EACZjY,EAAI6G,UAAYrB,EAChBxF,EAAIY,OAASoC,EACbhD,EAAI8G,WAAY,EACT9G,EAIT,QAAS2X,MACP,MAAOS,MAAgBA,GAAcJ,GAAU,IAMjD,QAASK,IAAMvgB,EAAMwgB,GACnB,GAAIC,GAAY,SAASzY,GAAQhI,EAAKE,UAAU8H,GAAOwY,EAAQxY,GAI/D,OAHA7H,QAAO4F,KAAKya,GAASlT,QAAQmT,GAC7BtgB,OAAOugB,uBACLvgB,OAAOugB,sBAAsBF,GAASlT,QAAQmT,GACzCzgB,EA4pBT,QAAS2gB,IAAU1c,EAAGD,GACpB,MAAOA,GAGT,QAAS4c,IAAY3c,EAAGD,GACtB,OAAQA,EAAGC,GAGb,QAAS4c,IAAIxH,GACX,MAAO,YACL,OAAQA,EAAU1M,MAAM7M,KAAM8M,YAIlC,QAASkU,IAAIzH,GACX,MAAO,YACL,OAAQA,EAAU1M,MAAM7M,KAAM8M,YAIlC,QAASmU,IAAYxgB,GACnB,MAAwB,gBAAVA,GAAqBygB,KAAKC,UAAU1gB,GAASA,EAG7D,QAAS2gB,MACP,MAAOjf,GAAQ2K,WAGjB,QAASuU,IAAqBvY,EAAGC,GAC/B,MAAOD,GAAIC,EAAI,EAAID,EAAIC,GAAK,EAAI,EAGlC,QAASuY,IAAa1c,GACpB,GAAIA,EAAS7B,OAASgH,IACpB,MAAO,EAET,IAAIwX,GAAU3f,EAAUgD,GACpB4c,EAAQ3gB,EAAQ+D,GAChB0G,EAAIiW,EAAU,EAAI,CAUtB,OAAOE,IATI7c,EAAS5B,UAClBwe,EACED,EACE,SAASpd,EAAGD,GAAMoH,EAAI,GAAKA,EAAIoW,GAAUtW,GAAKjH,GAAIiH,GAAKlH,IAAM,GAC7D,SAASC,EAAGD,GAAMoH,EAAIA,EAAIoW,GAAUtW,GAAKjH,GAAIiH,GAAKlH,IAAM,GAC1Dqd,EACE,SAASpd,GAAMmH,EAAI,GAAKA,EAAIF,GAAKjH,GAAK,GACtC,SAASA,GAAMmH,EAAIA,EAAIF,GAAKjH,GAAK,IAETmH,GAGhC,QAASmW,IAAiB1e,EAAMuI,GAQ9B,MAPAA,GAAIqW,GAAKrW,EAAG,YACZA,EAAIqW,GAAKrW,GAAK,GAAKA,KAAO,GAAI,WAC9BA,EAAIqW,GAAKrW,GAAK,GAAKA,KAAO,GAAI,GAC9BA,GAAKA,EAAI,WAAa,GAAKvI,EAC3BuI,EAAIqW,GAAKrW,EAAIA,IAAM,GAAI,YACvBA,EAAIqW,GAAKrW,EAAIA,IAAM,GAAI,YACvBA,EAAIJ,GAAII,EAAIA,IAAM,IAIpB,QAASoW,IAAU5Y,EAAGC,GACpB,MAAOD,GAAIC,EAAI,YAAcD,GAAK,IAAMA,GAAK,GAAK,EA70JnB,GAAI8Y,IAAUriB,MAAMa,UAAU0V,KAc/D7V,GAAYW,EAAeJ,GAM3BP,EAAYc,EAAiBP,GAM7BP,EAAYiB,EAAaV,GA2BzBA,EAASE,WAAaA,EACtBF,EAASK,QAAUA,EACnBL,EAASQ,UAAYA,EACrBR,EAASW,cAAgBA,EACzBX,EAASoB,UAAYA,EAErBpB,EAASqhB,MAAQjhB,EACjBJ,EAASshB,QAAU/gB,EACnBP,EAASme,IAAMzd,CAGf,IAAII,IAAuB,6BACvBE,GAAoB,0BACpBE,GAAsB,4BACtBI,GAAsB,4BAMtBsO,GAAQ,EACRU,GAAO,GAAKV,GACZF,GAAOY,GAAO,EAIdnH,MAGA6F,IAAkB/O,OAAO,GACzBiP,IAAcjP,OAAO,GAiFrBsY,GAAe,EACfD,GAAiB,EACjBF,GAAkB,EAElB7T,GAAyC,kBAAXgd,SAAyBA,OAAOxb,SAC9DvB,GAAuB,aAEvBgd,GAAkBjd,IAAwBC,EAO5ClB,GAAS1D,UAAUwL,SAAW,WAC5B,MAAO,cAIX9H,EAASme,KAAOlJ,GAChBjV,EAASoe,OAASpJ,GAClBhV,EAASqe,QAAUvJ,GAEnB9U,EAAS1D,UAAUgiB,QACnBte,EAAS1D,UAAUiiB,SAAW,WAAc,MAAOriB,MAAK4L,YACxD9H,EAAS1D,UAAU4hB,IAAmB,WACpC,MAAOhiB,OA2CTC,EAAYU,EAAKH,GAMfG,EAAI2hB,GAAK,WACP,MAAO3hB,GAAImM,YAGbnM,EAAIP,UAAU+E,MAAQ,WACpB,MAAOnF,OAGTW,EAAIP,UAAUwL,SAAW,WACvB,MAAO5L,MAAKuiB,WAAW,QAAS,MAGlC5hB,EAAIP,UAAUiJ,YAAc,WAK1B,OAJKrJ,KAAKuH,QAAUvH,KAAK0H,oBACvB1H,KAAKuH,OAASvH,KAAKwF,WAAWkO,UAC9B1T,KAAK+C,KAAO/C,KAAKuH,OAAO9E,QAEnBzC,MAKTW,EAAIP,UAAU4C,UAAY,SAASmE,EAAIC,GACrC,MAAOF,GAAWlH,KAAMmH,EAAIC,GAAS,IAKvCzG,EAAIP,UAAUyY,WAAa,SAAS5U,EAAMmD,GACxC,MAAOO,GAAY3H,KAAMiE,EAAMmD,GAAS,IAK5CnH,EAAYa,EAAUH,GASpBG,EAASV,UAAUiF,WAAa,WAC9B,MAAOrF,OAKXC,EAAYgB,EAAYN,GAOtBM,EAAWqhB,GAAK,WACd,MAAOrhB,GAAW6L,YAGpB7L,EAAWb,UAAUqF,aAAe,WAClC,MAAOzF,OAGTiB,EAAWb,UAAUwL,SAAW,WAC9B,MAAO5L,MAAKuiB,WAAW,QAAS,MAGlCthB,EAAWb,UAAU4C,UAAY,SAASmE,EAAIC,GAC5C,MAAOF,GAAWlH,KAAMmH,EAAIC,GAAS,IAGvCnG,EAAWb,UAAUyY,WAAa,SAAS5U,EAAMmD,GAC/C,MAAOO,GAAY3H,KAAMiE,EAAMmD,GAAS,IAK5CnH,EAAYmB,EAAQT,GASlBS,EAAOkhB,GAAK,WACV,MAAOlhB,GAAO0L,YAGhB1L,EAAOhB,UAAUuF,SAAW,WAC1B,MAAO3F,OAKXW,EAAI+F,MAAQA,EACZ/F,EAAIkhB,MAAQ/gB,EACZH,EAAIge,IAAMvd,EACVT,EAAImhB,QAAU7gB,CAEd,IAAI2F,IAAkB,uBAEtBjG,GAAIP,UAAUwG,KAAmB,EAIjC3G,EAAY2F,EAAU3E,GAMpB2E,EAASxF,UAAUsJ,IAAM,SAASvG,EAAO8O,GACvC,MAAOjS,MAAKyJ,IAAItG,GAASnD,KAAK8F,OAAO5C,EAAUlD,KAAMmD,IAAU8O,GAGjErM,EAASxF,UAAU4C,UAAY,SAASmE,EAAIC,GAG1C,IAAK,GAFDvB,GAAQ7F,KAAK8F,OACb0B,EAAW3B,EAAMpD,OAAS,EACrBE,EAAK,EAAGA,GAAM6E,EAAU7E,IAC/B,IAA0D,IAAtDwE,EAAGtB,EAAMuB,EAAUI,EAAW7E,EAAKA,GAAKA,EAAI3C,MAC9C,MAAO2C,GAAK,CAGhB,OAAOA,IAGTiD,EAASxF,UAAUyY,WAAa,SAAS5U,EAAMmD,GAC7C,GAAIvB,GAAQ7F,KAAK8F,OACb0B,EAAW3B,EAAMpD,OAAS,EAC1BE,EAAK,CACT,OAAO,IAAImB,GAAS,WACjB,MAAOnB,GAAK6E,EACXlD,IACAN,EAAcC,EAAMtB,EAAIkD,EAAMuB,EAAUI,EAAW7E,IAAOA,SAMlE1C,EAAY8F,EAAWjF,GAQrBiF,EAAU3F,UAAUsJ,IAAM,SAASxB,EAAK+J,GACtC,WAAoBnP,KAAhBmP,GAA8BjS,KAAKyJ,IAAIvB,GAGpClI,KAAKkG,QAAQgC,GAFX+J,GAKXlM,EAAU3F,UAAUqJ,IAAM,SAASvB,GACjC,MAAOlI,MAAKkG,QAAQsc,eAAeta,IAGrCnC,EAAU3F,UAAU4C,UAAY,SAASmE,EAAIC,GAI3C,IAAK,GAHDpB,GAAShG,KAAKkG,QACdD,EAAOjG,KAAKmG,MACZqB,EAAWvB,EAAKxD,OAAS,EACpBE,EAAK,EAAGA,GAAM6E,EAAU7E,IAAM,CACrC,GAAIuF,GAAMjC,EAAKmB,EAAUI,EAAW7E,EAAKA,EACzC,KAAmC,IAA/BwE,EAAGnB,EAAOkC,GAAMA,EAAKlI,MACvB,MAAO2C,GAAK,EAGhB,MAAOA,IAGToD,EAAU3F,UAAUyY,WAAa,SAAS5U,EAAMmD,GAC9C,GAAIpB,GAAShG,KAAKkG,QACdD,EAAOjG,KAAKmG,MACZqB,EAAWvB,EAAKxD,OAAS,EACzBE,EAAK,CACT,OAAO,IAAImB,GAAS,WAClB,GAAIoE,GAAMjC,EAAKmB,EAAUI,EAAW7E,EAAKA,EACzC,OAAOA,KAAO6E,EACZlD,IACAN,EAAcC,EAAMiE,EAAKlC,EAAOkC,OAIxCnC,EAAU3F,UAAU0B,KAAuB,EAG3C7B,EAAYmG,EAAanF,GAMvBmF,EAAYhG,UAAUsH,kBAAoB,SAASP,EAAIC,GACrD,GAAIA,EACF,MAAOpH,MAAKqJ,cAAcrG,UAAUmE,EAAIC,EAE1C,IAAIxC,GAAW5E,KAAKqG,UAChBE,EAAW5B,EAAYC,GACvB6U,EAAa,CACjB,IAAIhV,EAAW8B,GAEb,IADA,GAAIgE,KACKA,EAAOhE,EAASxC,QAAQM,OACY,IAAvC8C,EAAGoD,EAAK9J,MAAOgZ,IAAczZ,QAKrC,MAAOyZ,IAGTrT,EAAYhG,UAAUwH,mBAAqB,SAAS3D,EAAMmD,GACxD,GAAIA,EACF,MAAOpH,MAAKqJ,cAAcwP,WAAW5U,EAAMmD,EAE7C,IAAIxC,GAAW5E,KAAKqG,UAChBE,EAAW5B,EAAYC,EAC3B,KAAKH,EAAW8B,GACd,MAAO,IAAIzC,GAASQ,EAEtB,IAAImV,GAAa,CACjB,OAAO,IAAI3V,GAAS,WAClB,GAAIyG,GAAOhE,EAASxC,MACpB,OAAOwG,GAAKlG,KAAOkG,EAAOvG,EAAcC,EAAMwV,IAAclP,EAAK9J,UAMvER,EAAYqG,EAAarF,GAMvBqF,EAAYlG,UAAUsH,kBAAoB,SAASP,EAAIC,GACrD,GAAIA,EACF,MAAOpH,MAAKqJ,cAAcrG,UAAUmE,EAAIC,EAK1C,KAHA,GAAIb,GAAWvG,KAAKwG,UAChBc,EAAQtH,KAAKyG,eACbgT,EAAa,EACVA,EAAanS,EAAM7E,QACxB,IAAkD,IAA9C0E,EAAGG,EAAMmS,GAAaA,IAAczZ,MACtC,MAAOyZ,EAIX,KADA,GAAIlP,KACKA,EAAOhE,EAASxC,QAAQM,MAAM,CACrC,GAAIuO,GAAMrI,EAAK9J,KAEf,IADA6G,EAAMmS,GAAc7G,GACgB,IAAhCzL,EAAGyL,EAAK6G,IAAczZ,MACxB,MAGJ,MAAOyZ,IAGTnT,EAAYlG,UAAUwH,mBAAqB,SAAS3D,EAAMmD,GACxD,GAAIA,EACF,MAAOpH,MAAKqJ,cAAcwP,WAAW5U,EAAMmD,EAE7C,IAAIb,GAAWvG,KAAKwG,UAChBc,EAAQtH,KAAKyG,eACbgT,EAAa,CACjB,OAAO,IAAI3V,GAAS,WAClB,GAAI2V,GAAcnS,EAAM7E,OAAQ,CAC9B,GAAI8H,GAAOhE,EAASxC,MACpB,IAAIwG,EAAKlG,KACP,MAAOkG,EAETjD,GAAMmS,GAAclP,EAAK9J,MAE3B,MAAOuD,GAAcC,EAAMwV,EAAYnS,EAAMmS,QAanD,IAAI5S,GAyPJ5G,GAAY2J,EAAQ3I,GAgBlB2I,EAAOxJ,UAAUwL,SAAW,WAC1B,MAAkB,KAAd5L,KAAK+C,KACA,YAEF,YAAc/C,KAAK8J,OAAS,IAAM9J,KAAK+C,KAAO,YAGvD6G,EAAOxJ,UAAUsJ,IAAM,SAASvG,EAAO8O,GACrC,MAAOjS,MAAKyJ,IAAItG,GAASnD,KAAK8J,OAASmI,GAGzCrI,EAAOxJ,UAAUqY,SAAW,SAASgK,GACnC,MAAOja,GAAGxI,KAAK8J,OAAQ2Y,IAGzB7Y,EAAOxJ,UAAU0V,MAAQ,SAASvS,EAAOC,GACvC,GAAIT,GAAO/C,KAAK+C,IAChB,OAAOO,GAAWC,EAAOC,EAAKT,GAAQ/C,KACpC,GAAI4J,GAAO5J,KAAK8J,OAAQnG,EAAWH,EAAKT,GAAQU,EAAaF,EAAOR,KAGxE6G,EAAOxJ,UAAUgH,QAAU,WACzB,MAAOpH,OAGT4J,EAAOxJ,UAAUsiB,QAAU,SAASD,GAClC,MAAIja,GAAGxI,KAAK8J,OAAQ2Y,GACX,GAED,GAGV7Y,EAAOxJ,UAAUuiB,YAAc,SAASF,GACtC,MAAIja,GAAGxI,KAAK8J,OAAQ2Y,GACXziB,KAAK+C,MAEN,GAGV6G,EAAOxJ,UAAU4C,UAAY,SAASmE,EAAIC,GACxC,IAAK,GAAIzE,GAAK,EAAGA,EAAK3C,KAAK+C,KAAMJ,IAC/B,IAAkC,IAA9BwE,EAAGnH,KAAK8J,OAAQnH,EAAI3C,MACtB,MAAO2C,GAAK,CAGhB,OAAOA,IAGTiH,EAAOxJ,UAAUyY,WAAa,SAAS5U,EAAMmD,GAAU,GAAIuR,GAAS3Y,KAC9D2C,EAAK,CACT,OAAO,IAAImB,GAAS,WACjB,MAAOnB,GAAKgW,EAAO5V,KAAOiB,EAAcC,EAAMtB,IAAMgW,EAAO7O,QAAUxF,OAI1EsF,EAAOxJ,UAAUwI,OAAS,SAASga,GACjC,MAAOA,aAAiBhZ,GACtBpB,EAAGxI,KAAK8J,OAAQ8Y,EAAM9Y,QACtBjB,EAAU+Z,GAIhB,IAAI5Y,GAMJ/J,GAAYoK,EAAOpJ,GA2BjBoJ,EAAMjK,UAAUwL,SAAW,WACzB,MAAkB,KAAd5L,KAAK+C,KACA,WAEF,WACL/C,KAAKyK,OAAS,MAAQzK,KAAK0K,MAC1B1K,KAAK2K,MAAQ,EAAI,OAAS3K,KAAK2K,MAAQ,IAC1C,MAGFN,EAAMjK,UAAUsJ,IAAM,SAASvG,EAAO8O,GACpC,MAAOjS,MAAKyJ,IAAItG,GACdnD,KAAKyK,OAASvH,EAAUlD,KAAMmD,GAASnD,KAAK2K,MAC5CsH,GAGJ5H,EAAMjK,UAAUqY,SAAW,SAASgK,GAClC,GAAII,IAAiBJ,EAAcziB,KAAKyK,QAAUzK,KAAK2K,KACvD,OAAOkY,IAAiB,GACtBA,EAAgB7iB,KAAK+C,MACrB8f,IAAkBtgB,KAAKugB,MAAMD,IAGjCxY,EAAMjK,UAAU0V,MAAQ,SAASvS,EAAOC,GACtC,MAAIF,GAAWC,EAAOC,EAAKxD,KAAK+C,MACvB/C,MAETuD,EAAQE,EAAaF,EAAOvD,KAAK+C,MACjCS,EAAMG,EAAWH,EAAKxD,KAAK+C,MACvBS,GAAOD,EACF,GAAI8G,GAAM,EAAG,GAEf,GAAIA,GAAMrK,KAAK0J,IAAInG,EAAOvD,KAAK0K,MAAO1K,KAAK0J,IAAIlG,EAAKxD,KAAK0K,MAAO1K,KAAK2K,SAG9EN,EAAMjK,UAAUsiB,QAAU,SAASD,GACjC,GAAIM,GAAcN,EAAcziB,KAAKyK,MACrC,IAAIsY,EAAc/iB,KAAK2K,OAAU,EAAG,CAClC,GAAIxH,GAAQ4f,EAAc/iB,KAAK2K,KAC/B,IAAIxH,GAAS,GAAKA,EAAQnD,KAAK+C,KAC7B,MAAOI,GAGX,OAAQ,GAGVkH,EAAMjK,UAAUuiB,YAAc,SAASF,GACrC,MAAOziB,MAAK0iB,QAAQD,IAGtBpY,EAAMjK,UAAU4C,UAAY,SAASmE,EAAIC,GAIvC,IAAK,GAHDI,GAAWxH,KAAK+C,KAAO,EACvBwH,EAAOvK,KAAK2K,MACZlK,EAAQ2G,EAAUpH,KAAKyK,OAASjD,EAAW+C,EAAOvK,KAAKyK,OAClD9H,EAAK,EAAGA,GAAM6E,EAAU7E,IAAM,CACrC,IAA4B,IAAxBwE,EAAG1G,EAAOkC,EAAI3C,MAChB,MAAO2C,GAAK,CAEdlC,IAAS2G,GAAWmD,EAAOA,EAE7B,MAAO5H,IAGT0H,EAAMjK,UAAUyY,WAAa,SAAS5U,EAAMmD,GAC1C,GAAII,GAAWxH,KAAK+C,KAAO,EACvBwH,EAAOvK,KAAK2K,MACZlK,EAAQ2G,EAAUpH,KAAKyK,OAASjD,EAAW+C,EAAOvK,KAAKyK,OACvD9H,EAAK,CACT,OAAO,IAAImB,GAAS,WAClB,GAAIK,GAAI1D,CAER,OADAA,IAAS2G,GAAWmD,EAAOA,EACpB5H,EAAK6E,EAAWlD,IAAiBN,EAAcC,EAAMtB,IAAMwB,MAItEkG,EAAMjK,UAAUwI,OAAS,SAASga,GAChC,MAAOA,aAAiBvY,GACtBrK,KAAKyK,SAAWmY,EAAMnY,QACtBzK,KAAK0K,OAASkY,EAAMlY,MACpB1K,KAAK2K,QAAUiY,EAAMjY,MACrB9B,EAAU7I,KAAM4iB,GAItB,IAAI/X,GAEJ5K,GAAY6K,GAAYtK,GAMxBP,EAAY8K,GAAiBD,IAE7B7K,EAAY+K,GAAmBF,IAE/B7K,EAAYgL,GAAeH,IAG3BA,GAAW+W,MAAQ9W,GACnBD,GAAWgX,QAAU9W,GACrBF,GAAW6T,IAAM1T,EAEjB,IAsLImB,IAtLAuV,GACmB,kBAAdpf,MAAKof,OAAqD,IAA9Bpf,KAAKof,KAAK,WAAY,GACzDpf,KAAKof,KACL,SAAc7Y,EAAGC,GACfD,GAAQ,EACRC,GAAQ,CACR,IAAIqQ,GAAQ,MAAJtQ,EACJka,EAAQ,MAAJja,CAER,OAAQqQ,GAAI4J,IAASla,IAAM,IAAMka,EAAI5J,GAAKrQ,IAAM,KAAQ,KAAQ,GAAK,GAkJrE4D,GAAetM,OAAOsM,aAGtBL,GAAqB,WACvB,IAEE,MADAjM,QAAOuM,kBAAmB,SACnB,EACP,MAAOqW,GACP,OAAO,MAkBP9W,GAAkC,kBAAZ+W,QAEtB/W,MACFC,GAAU,GAAI8W,SAGhB,IAAIzW,IAAa,EAEbJ,GAAe,mBACG,mBAAX0V,UACT1V,GAAe0V,OAAO1V,IAGxB,IAAId,IAA+B,GAC/BS,GAA6B,IAC7BD,GAAyB,EACzBD,KASJ7L,GAAYmN,GAAKrC,IAcfqC,GAAIhN,UAAUwL,SAAW,WACvB,MAAO5L,MAAKuiB,WAAW,QAAS,MAKlCnV,GAAIhN,UAAUsJ,IAAM,SAASxF,EAAG+N,GAC9B,MAAOjS,MAAKyO,MACVzO,KAAKyO,MAAM/E,IAAI,MAAG5G,GAAWoB,EAAG+N,GAChCA,GAKJ7E,GAAIhN,UAAUsM,IAAM,SAASxI,EAAGC,GAC9B,MAAOiL,IAAUpP,KAAMkE,EAAGC,IAG5BiJ,GAAIhN,UAAUsS,MAAQ,SAAS8K,EAASrZ,GACtC,MAAOnE,MAAKmjB,SAAS3F,EAAS7T,GAAS,WAAa,MAAOxF,MAG7DiJ,GAAIhN,UAAUoS,OAAS,SAAStO,GAC9B,MAAOkL,IAAUpP,KAAMkE,EAAGyF,KAG5ByD,GAAIhN,UAAUgjB,SAAW,SAAS5F,GAChC,MAAOxd,MAAKmjB,SAAS3F,EAAS,WAAa,MAAO7T,OAGpDyD,GAAIhN,UAAUyP,OAAS,SAAS3L,EAAG+N,EAAaC,GAC9C,MAA4B,KAArBpF,UAAUrK,OACfyB,EAAElE,MACFA,KAAKmjB,UAAUjf,GAAI+N,EAAaC,IAGpC9E,GAAIhN,UAAU+iB,SAAW,SAAS3F,EAASvL,EAAaC,GACjDA,IACHA,EAAUD,EACVA,MAAcnP,GAEhB,IAAIugB,GAAetR,GACjB/R,KACAud,GAAcC,GACdvL,EACAC,EAEF,OAAOmR,KAAiB1Z,OAAU7G,GAAYugB,GAGhDjW,GAAIhN,UAAUkW,MAAQ,WACpB,MAAkB,KAAdtW,KAAK+C,KACA/C,KAELA,KAAKiP,WACPjP,KAAK+C,KAAO,EACZ/C,KAAKyO,MAAQ,KACbzO,KAAKgJ,WAASlG,GACd9C,KAAKkP,WAAY,EACVlP,MAEFqN,MAKTD,GAAIhN,UAAUkjB,MAAQ,WACpB,MAAOvS,IAAiB/Q,SAAM8C,GAAWgK,YAG3CM,GAAIhN,UAAUmjB,UAAY,SAASvS,GACjC,MAAOD,IAAiB/Q,KAAMgR,EADwB4Q,GAAQ9c,KAAKgI,UAAW,KAIhFM,GAAIhN,UAAUojB,QAAU,SAAShG,GAAU,GAAItM,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EAC7E,OAAO9M,MAAKmjB,SACV3F,EACAnQ,KACA,SAASoW,GAAK,MAA0B,kBAAZA,GAAEH,MAC5BG,EAAEH,MAAMzW,MAAM4W,EAAGvS,GACjBA,EAAMA,EAAMzO,OAAS,MAI3B2K,GAAIhN,UAAUmR,UAAY,WACxB,MAAOR,IAAiB/Q,KAAMqR,GAAYvE,YAG5CM,GAAIhN,UAAUqR,cAAgB,SAAST,GAAS,GAAIE,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EAClF,OAAOiE,IAAiB/Q,KAAMwR,GAAeR,GAASE,IAGxD9D,GAAIhN,UAAUsjB,YAAc,SAASlG,GAAU,GAAItM,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EACjF,OAAO9M,MAAKmjB,SACV3F,EACAnQ,KACA,SAASoW,GAAK,MAA8B,kBAAhBA,GAAElS,UAC5BkS,EAAElS,UAAU1E,MAAM4W,EAAGvS,GACrBA,EAAMA,EAAMzO,OAAS,MAI3B2K,GAAIhN,UAAUoc,KAAO,SAASF,GAE5B,MAAOrF,IAAWoF,GAAYrc,KAAMsc,KAGtClP,GAAIhN,UAAUujB,OAAS,SAAS1K,EAAQqD,GAEtC,MAAOrF,IAAWoF,GAAYrc,KAAMsc,EAAYrD,KAKlD7L,GAAIhN,UAAUmN,cAAgB,SAASpG,GACrC,GAAIyc,GAAU5jB,KAAK6Z,WAEnB,OADA1S,GAAGyc,GACIA,EAAQC,aAAeD,EAAQE,cAAc9jB,KAAKiP,WAAajP,MAGxEoN,GAAIhN,UAAUyZ,UAAY,WACxB,MAAO7Z,MAAKiP,UAAYjP,KAAOA,KAAK8jB,cAAc,GAAI5hB,KAGxDkL,GAAIhN,UAAU0Z,YAAc,WAC1B,MAAO9Z,MAAK8jB,iBAGd1W,GAAIhN,UAAUyjB,WAAa,WACzB,MAAO7jB,MAAKkP,WAGd9B,GAAIhN,UAAUyY,WAAa,SAAS5U,EAAMmD,GACxC,MAAO,IAAIiH,IAAYrO,KAAMiE,EAAMmD,IAGrCgG,GAAIhN,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GAAIuR,GAAS3Y,KACxDyZ,EAAa,CAKjB,OAJAzZ,MAAKyO,OAASzO,KAAKyO,MAAMsV,QAAQ,SAAStc,GAExC,MADAgS,KACOtS,EAAGM,EAAM,GAAIA,EAAM,GAAIkR,IAC7BvR,GACIqS,GAGTrM,GAAIhN,UAAU0jB,cAAgB,SAASlW,GACrC,MAAIA,KAAY5N,KAAKiP,UACZjP,KAEJ4N,EAKEkB,GAAQ9O,KAAK+C,KAAM/C,KAAKyO,MAAOb,EAAS5N,KAAKgJ,SAJlDhJ,KAAKiP,UAAYrB,EACjB5N,KAAKkP,WAAY,EACVlP,OAUboN,GAAIE,MAAQA,EAEZ,IAAII,IAAkB,wBAElBsB,GAAe5B,GAAIhN,SACvB4O,IAAatB,KAAmB,EAChCsB,GAAmB,OAAIA,GAAawD,OACpCxD,GAAagV,SAAWhV,GAAaoU,SAYnCzV,GAAavN,UAAUsJ,IAAM,SAASkG,EAAOzB,EAASjG,EAAK+J,GAEzD,IAAK,GADD/I,GAAUlJ,KAAKkJ,QACVvG,EAAK,EAAGL,EAAM4G,EAAQzG,OAAQE,EAAKL,EAAKK,IAC/C,GAAI6F,EAAGN,EAAKgB,EAAQvG,GAAI,IACtB,MAAOuG,GAAQvG,GAAI,EAGvB,OAAOsP,IAGTtE,GAAavN,UAAUyP,OAAS,SAASjC,EAASgC,EAAOzB,EAASjG,EAAKzH,EAAO8O,EAAeE,GAK3F,IAAK,GAJDwU,GAAUxjB,IAAUkJ,GAEpBT,EAAUlJ,KAAKkJ,QACfyJ,EAAM,EACDrQ,EAAM4G,EAAQzG,OAAQkQ,EAAMrQ,IAC/BkG,EAAGN,EAAKgB,EAAQyJ,GAAK,IADeA,KAK1C,GAAIuR,GAASvR,EAAMrQ,CAEnB,IAAI4hB,EAAShb,EAAQyJ,GAAK,KAAOlS,EAAQwjB,EACvC,MAAOjkB,KAMT,IAHAiC,EAAOwN,IACNwU,IAAYC,IAAWjiB,EAAOsN,IAE3B0U,GAA8B,IAAnB/a,EAAQzG,OAAvB,CAIA,IAAKyhB,IAAWD,GAAW/a,EAAQzG,QAAU0hB,GAC3C,MAAO9T,IAAYzC,EAAS1E,EAAShB,EAAKzH,EAG5C,IAAI2jB,GAAaxW,GAAWA,IAAY5N,KAAK4N,QACzCyW,EAAaD,EAAalb,EAAU/G,EAAQ+G,EAYhD,OAVIgb,GACED,EACFtR,IAAQrQ,EAAM,EAAI+hB,EAAWlR,MAASkR,EAAW1R,GAAO0R,EAAWlR,MAEnEkR,EAAW1R,IAAQzK,EAAKzH,GAG1B4jB,EAAWlT,MAAMjJ,EAAKzH,IAGpB2jB,GACFpkB,KAAKkJ,QAAUmb,EACRrkB,MAGF,GAAI2N,IAAaC,EAASyW,KAYnCxW,GAAkBzN,UAAUsJ,IAAM,SAASkG,EAAOzB,EAASjG,EAAK+J,OAC9CnP,KAAZqL,IACFA,EAAU/C,GAAKlD,GAEjB,IAAIwI,GAAO,KAAiB,IAAVd,EAAczB,EAAUA,IAAYyB,GAASM,IAC3DpC,EAAS9N,KAAK8N,MAClB,OAA0B,KAAlBA,EAAS4C,GAAauB,EAC5BjS,KAAK+N,MAAM0E,GAAS3E,EAAU4C,EAAM,IAAKhH,IAAIkG,EAAQQ,GAAOjC,EAASjG,EAAK+J,IAG9EpE,GAAkBzN,UAAUyP,OAAS,SAASjC,EAASgC,EAAOzB,EAASjG,EAAKzH,EAAO8O,EAAeE,OAChF3M,KAAZqL,IACFA,EAAU/C,GAAKlD,GAEjB,IAAIoc,IAAyB,IAAV1U,EAAczB,EAAUA,IAAYyB,GAASM,GAC5DQ,EAAM,GAAK4T,EACXxW,EAAS9N,KAAK8N,OACdoW,EAA4B,IAAlBpW,EAAS4C,EAEvB,KAAKwT,GAAUzjB,IAAUkJ,GACvB,MAAO3J,KAGT,IAAI2S,GAAMF,GAAS3E,EAAU4C,EAAM,GAC/B3C,EAAQ/N,KAAK+N,MACbf,EAAOkX,EAASnW,EAAM4E,OAAO7P,GAC7BkN,EAAUL,GAAW3C,EAAMY,EAASgC,EAAQQ,GAAOjC,EAASjG,EAAKzH,EAAO8O,EAAeE,EAE3F,IAAIO,IAAYhD,EACd,MAAOhN,KAGT,KAAKkkB,GAAUlU,GAAWjC,EAAMtL,QAAU8hB,GACxC,MAAO5T,IAAY/C,EAASG,EAAOD,EAAQwW,EAAatU,EAG1D,IAAIkU,IAAWlU,GAA4B,IAAjBjC,EAAMtL,QAAgBqN,GAAW/B,EAAY,EAAN4E,IAC/D,MAAO5E,GAAY,EAAN4E,EAGf,IAAIuR,GAAUlU,GAA4B,IAAjBjC,EAAMtL,QAAgBqN,GAAWE,GACxD,MAAOA,EAGT,IAAIoU,GAAaxW,GAAWA,IAAY5N,KAAK4N,QACzC4W,EAAYN,EAASlU,EAAUlC,EAASA,EAAS4C,EAAM5C,EAAS4C,EAChE+T,EAAWP,EAASlU,EACtB0C,GAAM3E,EAAO4E,EAAK3C,EAASoU,GAC3BlR,GAAUnF,EAAO4E,EAAKyR,GACtBrR,GAAShF,EAAO4E,EAAK3C,EAASoU,EAEhC,OAAIA,IACFpkB,KAAK8N,OAAS0W,EACdxkB,KAAK+N,MAAQ0W,EACNzkB,MAGF,GAAI6N,IAAkBD,EAAS4W,EAAWC,IAYnDzW,GAAiB5N,UAAUsJ,IAAM,SAASkG,EAAOzB,EAASjG,EAAK+J,OAC7CnP,KAAZqL,IACFA,EAAU/C,GAAKlD,GAEjB,IAAIyK,IAAiB,IAAV/C,EAAczB,EAAUA,IAAYyB,GAASM,GACpDlD,EAAOhN,KAAK+N,MAAM4E,EACtB,OAAO3F,GAAOA,EAAKtD,IAAIkG,EAAQQ,GAAOjC,EAASjG,EAAK+J,GAAeA,GAGrEjE,GAAiB5N,UAAUyP,OAAS,SAASjC,EAASgC,EAAOzB,EAASjG,EAAKzH,EAAO8O,EAAeE,OAC/E3M,KAAZqL,IACFA,EAAU/C,GAAKlD,GAEjB,IAAIyK,IAAiB,IAAV/C,EAAczB,EAAUA,IAAYyB,GAASM,GACpD+T,EAAUxjB,IAAUkJ,GACpBoE,EAAQ/N,KAAK+N,MACbf,EAAOe,EAAM4E,EAEjB,IAAIsR,IAAYjX,EACd,MAAOhN,KAGT,IAAIgQ,GAAUL,GAAW3C,EAAMY,EAASgC,EAAQQ,GAAOjC,EAASjG,EAAKzH,EAAO8O,EAAeE,EAC3F,IAAIO,IAAYhD,EACd,MAAOhN,KAGT,IAAI0kB,GAAW1kB,KAAKiO,KACpB,IAAKjB,GAEE,IAAKgD,KACV0U,EACeC,GACb,MAAOrU,IAAU1C,EAASG,EAAO2W,EAAU/R,OAJ7C+R,IAQF,IAAIN,GAAaxW,GAAWA,IAAY5N,KAAK4N,QACzC6W,EAAW/R,GAAM3E,EAAO4E,EAAK3C,EAASoU,EAE1C,OAAIA,IACFpkB,KAAKiO,MAAQyW,EACb1kB,KAAK+N,MAAQ0W,EACNzkB,MAGF,GAAIgO,IAAiBJ,EAAS8W,EAAUD,IAYjDvW,GAAkB9N,UAAUsJ,IAAM,SAASkG,EAAOzB,EAASjG,EAAK+J,GAE9D,IAAK,GADD/I,GAAUlJ,KAAKkJ,QACVvG,EAAK,EAAGL,EAAM4G,EAAQzG,OAAQE,EAAKL,EAAKK,IAC/C,GAAI6F,EAAGN,EAAKgB,EAAQvG,GAAI,IACtB,MAAOuG,GAAQvG,GAAI,EAGvB,OAAOsP,IAGT/D,GAAkB9N,UAAUyP,OAAS,SAASjC,EAASgC,EAAOzB,EAASjG,EAAKzH,EAAO8O,EAAeE,OAChF3M,KAAZqL,IACFA,EAAU/C,GAAKlD,GAGjB,IAAI+b,GAAUxjB,IAAUkJ,EAExB,IAAIwE,IAAYnO,KAAKmO,QACnB,MAAI8V,GACKjkB,MAETiC,EAAOwN,GACPxN,EAAOsN,GACAQ,GAAc/P,KAAM4N,EAASgC,EAAOzB,GAAUjG,EAAKzH,IAK5D,KAAK,GAFDyI,GAAUlJ,KAAKkJ,QACfyJ,EAAM,EACDrQ,EAAM4G,EAAQzG,OAAQkQ,EAAMrQ,IAC/BkG,EAAGN,EAAKgB,EAAQyJ,GAAK,IADeA,KAK1C,GAAIuR,GAASvR,EAAMrQ,CAEnB,IAAI4hB,EAAShb,EAAQyJ,GAAK,KAAOlS,EAAQwjB,EACvC,MAAOjkB,KAMT,IAHAiC,EAAOwN,IACNwU,IAAYC,IAAWjiB,EAAOsN,GAE3B0U,GAAmB,IAAR3hB,EACb,MAAO,IAAI8L,IAAUR,EAAS5N,KAAKmO,QAASjF,EAAc,EAANyJ,GAGtD,IAAIyR,GAAaxW,GAAWA,IAAY5N,KAAK4N,QACzCyW,EAAaD,EAAalb,EAAU/G,EAAQ+G,EAYhD,OAVIgb,GACED,EACFtR,IAAQrQ,EAAM,EAAI+hB,EAAWlR,MAASkR,EAAW1R,GAAO0R,EAAWlR,MAEnEkR,EAAW1R,IAAQzK,EAAKzH,GAG1B4jB,EAAWlT,MAAMjJ,EAAKzH,IAGpB2jB,GACFpkB,KAAKkJ,QAAUmb,EACRrkB,MAGF,GAAIkO,IAAkBN,EAAS5N,KAAKmO,QAASkW,IAYtDjW,GAAUhO,UAAUsJ,IAAM,SAASkG,EAAOzB,EAASjG,EAAK+J,GACtD,MAAOzJ,GAAGN,EAAKlI,KAAKyH,MAAM,IAAMzH,KAAKyH,MAAM,GAAKwK,GAGlD7D,GAAUhO,UAAUyP,OAAS,SAASjC,EAASgC,EAAOzB,EAASjG,EAAKzH,EAAO8O,EAAeE,GACxF,GAAIwU,GAAUxjB,IAAUkJ,GACpBib,EAAWpc,EAAGN,EAAKlI,KAAKyH,MAAM,GAClC,QAAImd,EAAWnkB,IAAUT,KAAKyH,MAAM,GAAKwc,GAChCjkB,MAGTiC,EAAOwN,GAEHwU,MACFhiB,GAAOsN,GAILqV,EACEhX,GAAWA,IAAY5N,KAAK4N,SAC9B5N,KAAKyH,MAAM,GAAKhH,EACTT,MAEF,GAAIoO,IAAUR,EAAS5N,KAAKmO,SAAUjG,EAAKzH,KAGpDwB,EAAOsN,GACAQ,GAAc/P,KAAM4N,EAASgC,EAAOxE,GAAKlD,IAAOA,EAAKzH,OAOhEkN,GAAavN,UAAU2jB,QACvB7V,GAAkB9N,UAAU2jB,QAAU,SAAU5c,EAAIC,GAElD,IAAK,GADD8B,GAAUlJ,KAAKkJ,QACVvG,EAAK,EAAG6E,EAAW0B,EAAQzG,OAAS,EAAGE,GAAM6E,EAAU7E,IAC9D,IAAkD,IAA9CwE,EAAG+B,EAAQ9B,EAAUI,EAAW7E,EAAKA,IACvC,OAAO,GAKbkL,GAAkBzN,UAAU2jB,QAC5B/V,GAAiB5N,UAAU2jB,QAAU,SAAU5c,EAAIC,GAEjD,IAAK,GADD2G,GAAQ/N,KAAK+N,MACRpL,EAAK,EAAG6E,EAAWuG,EAAMtL,OAAS,EAAGE,GAAM6E,EAAU7E,IAAM,CAClE,GAAIqK,GAAOe,EAAM3G,EAAUI,EAAW7E,EAAKA,EAC3C,IAAIqK,IAAsC,IAA9BA,EAAK+W,QAAQ5c,EAAIC,GAC3B,OAAO,IAKbgH,GAAUhO,UAAU2jB,QAAU,SAAU5c,EAAIC,GAC1C,MAAOD,GAAGnH,KAAKyH,QAGjBxH,EAAYoO,GAAavK,GAQvBuK,GAAYjO,UAAU2D,KAAO,WAG3B,IAFA,GAAIE,GAAOjE,KAAKsO,MACZ0N,EAAQhc,KAAKwO,OACVwN,GAAO,CACZ,GAEIxU,GAFAwF,EAAOgP,EAAMhP,KACb7J,EAAQ6Y,EAAM7Y,OAElB,IAAI6J,EAAKvF,OACP,GAAc,IAAVtE,EACF,MAAOwL,IAAiB1K,EAAM+I,EAAKvF,WAEhC,IAAIuF,EAAK9D,SAEd,GADA1B,EAAWwF,EAAK9D,QAAQzG,OAAS,EAC7BU,GAASqE,EACX,MAAOmH,IAAiB1K,EAAM+I,EAAK9D,QAAQlJ,KAAKuO,SAAW/G,EAAWrE,EAAQA,QAIhF,IADAqE,EAAWwF,EAAKe,MAAMtL,OAAS,EAC3BU,GAASqE,EAAU,CACrB,GAAIqd,GAAU7X,EAAKe,MAAM/N,KAAKuO,SAAW/G,EAAWrE,EAAQA,EAC5D,IAAI0hB,EAAS,CACX,GAAIA,EAAQpd,MACV,MAAOkH,IAAiB1K,EAAM4gB,EAAQpd,MAExCuU,GAAQhc,KAAKwO,OAASE,GAAiBmW,EAAS7I,GAElD,SAGJA,EAAQhc,KAAKwO,OAASxO,KAAKwO,OAAOK,OAEpC,MAAOvK,KA0BX,IAAI6K,IAsOAgV,GAAqBrT,GAAO,EAC5ByT,GAA0BzT,GAAO,EACjC6T,GAA0B7T,GAAO,CAErC7Q,GAAYmT,GAAMpI,IA2BhBoI,GAAKkP,GAAK,WACR,MAAOtiB,MAAK8M,YAGdsG,GAAKhT,UAAUwL,SAAW,WACxB,MAAO5L,MAAKuiB,WAAW,SAAU,MAKnCnP,GAAKhT,UAAUsJ,IAAM,SAASvG,EAAO8O,GAEnC,IADA9O,EAAQD,EAAUlD,KAAMmD,KACX,GAAKA,EAAQnD,KAAK+C,KAAM,CACnCI,GAASnD,KAAK6U,OACd,IAAI7H,GAAO+I,GAAY/V,KAAMmD,EAC7B,OAAO6J,IAAQA,EAAKnH,MAAM1C,EAAQ+M,IAEpC,MAAO+B,IAKTmB,GAAKhT,UAAUsM,IAAM,SAASvJ,EAAO1C,GACnC,MAAO6U,IAAWtV,KAAMmD,EAAO1C,IAGjC2S,GAAKhT,UAAUoS,OAAS,SAASrP,GAC/B,MAAQnD,MAAKyJ,IAAItG,GACL,IAAVA,EAAcnD,KAAK4P,QACnBzM,IAAUnD,KAAK+C,KAAO,EAAI/C,KAAKmT,MAC/BnT,KAAK8kB,OAAO3hB,EAAO,GAHKnD,MAM5BoT,GAAKhT,UAAU2kB,OAAS,SAAS5hB,EAAO1C,GACtC,MAAOT,MAAK8kB,OAAO3hB,EAAO,EAAG1C,IAG/B2S,GAAKhT,UAAUkW,MAAQ,WACrB,MAAkB,KAAdtW,KAAK+C,KACA/C,KAELA,KAAKiP,WACPjP,KAAK+C,KAAO/C,KAAK6U,QAAU7U,KAAK8U,UAAY,EAC5C9U,KAAKiV,OAAS7E,GACdpQ,KAAKyO,MAAQzO,KAAKgV,MAAQ,KAC1BhV,KAAKgJ,WAASlG,GACd9C,KAAKkP,WAAY,EACVlP,MAEFsT,MAGTF,GAAKhT,UAAU+Q,KAAO,WACpB,GAAIyD,GAAS9H,UACTkY,EAAUhlB,KAAK+C,IACnB,OAAO/C,MAAKuN,cAAc,SAASoG,GACjC4B,GAAc5B,EAAM,EAAGqR,EAAUpQ,EAAOnS,OACxC,KAAK,GAAIE,GAAK,EAAGA,EAAKiS,EAAOnS,OAAQE,IACnCgR,EAAKjH,IAAIsY,EAAUriB,EAAIiS,EAAOjS,OAKpCyQ,GAAKhT,UAAU+S,IAAM,WACnB,MAAOoC,IAAcvV,KAAM,GAAI,IAGjCoT,GAAKhT,UAAU6kB,QAAU,WACvB,GAAIrQ,GAAS9H,SACb,OAAO9M,MAAKuN,cAAc,SAASoG,GACjC4B,GAAc5B,GAAOiB,EAAOnS,OAC5B,KAAK,GAAIE,GAAK,EAAGA,EAAKiS,EAAOnS,OAAQE,IACnCgR,EAAKjH,IAAI/J,EAAIiS,EAAOjS,OAK1ByQ,GAAKhT,UAAUwP,MAAQ,WACrB,MAAO2F,IAAcvV,KAAM,IAK7BoT,GAAKhT,UAAUkjB,MAAQ,WACrB,MAAOvM,IAAkB/W,SAAM8C,GAAWgK,YAG5CsG,GAAKhT,UAAUmjB,UAAY,SAASvS,GAClC,MAAO+F,IAAkB/W,KAAMgR,EADwB4Q,GAAQ9c,KAAKgI,UAAW,KAIjFsG,GAAKhT,UAAUmR,UAAY,WACzB,MAAOwF,IAAkB/W,KAAMqR,GAAYvE,YAG7CsG,GAAKhT,UAAUqR,cAAgB,SAAST,GAAS,GAAIE,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EACnF,OAAOiK,IAAkB/W,KAAMwR,GAAeR,GAASE,IAGzDkC,GAAKhT,UAAUwT,QAAU,SAAS7Q,GAChC,MAAOwS,IAAcvV,KAAM,EAAG+C,IAKhCqQ,GAAKhT,UAAU0V,MAAQ,SAASvS,EAAOC,GACrC,GAAIT,GAAO/C,KAAK+C,IAChB,OAAIO,GAAWC,EAAOC,EAAKT,GAClB/C,KAEFuV,GACLvV,KACAyD,EAAaF,EAAOR,GACpBY,EAAWH,EAAKT,KAIpBqQ,GAAKhT,UAAUyY,WAAa,SAAS5U,EAAMmD,GACzC,GAAIjE,GAAQ,EACRyR,EAASZ,GAAYhU,KAAMoH,EAC/B,OAAO,IAAItD,GAAS,WAClB,GAAIrD,GAAQmU,GACZ,OAAOnU,KAAUkU,GACfrQ,IACAN,EAAcC,EAAMd,IAAS1C,MAInC2S,GAAKhT,UAAU4C,UAAY,SAASmE,EAAIC,GAItC,IAHA,GAEI3G,GAFA0C,EAAQ,EACRyR,EAASZ,GAAYhU,KAAMoH,IAEvB3G,EAAQmU,OAAcD,KACK,IAA7BxN,EAAG1G,EAAO0C,IAASnD,QAIzB,MAAOmD,IAGTiQ,GAAKhT,UAAU0jB,cAAgB,SAASlW,GACtC,MAAIA,KAAY5N,KAAKiP,UACZjP,KAEJ4N,EAIE4F,GAASxT,KAAK6U,QAAS7U,KAAK8U,UAAW9U,KAAKiV,OAAQjV,KAAKyO,MAAOzO,KAAKgV,MAAOpH,EAAS5N,KAAKgJ,SAH/FhJ,KAAKiP,UAAYrB,EACV5N,OAUboT,GAAKG,OAASA,EAEd,IAAIQ,IAAmB,yBAEnBqB,GAAgBhC,GAAKhT,SACzBgV,IAAcrB,KAAoB,EAClCqB,GAAoB,OAAIA,GAAc5C,OACtC4C,GAAc1C,MAAQ1D,GAAa0D,MACnC0C,GAAcgO,SACdhO,GAAc4O,SAAWhV,GAAagV,SACtC5O,GAAcvF,OAASb,GAAaa,OACpCuF,GAAc+N,SAAWnU,GAAamU,SACtC/N,GAAcoO,QAAUxU,GAAawU,QACrCpO,GAAcsO,YAAc1U,GAAa0U,YACzCtO,GAAc7H,cAAgByB,GAAazB,cAC3C6H,GAAcyE,UAAY7K,GAAa6K,UACvCzE,GAAc0E,YAAc9K,GAAa8K,YACzC1E,GAAcyO,WAAa7U,GAAa6U,WAWtCpQ,GAAMrT,UAAUyW,aAAe,SAASjJ,EAASsG,EAAO/Q,GACtD,GAAIA,IAAU+Q,EAAQ,GAAKA,EAAmC,IAAtBlU,KAAK6F,MAAMpD,OACjD,MAAOzC,KAET,IAAIklB,GAAe/hB,IAAU+Q,EAAShE,EACtC,IAAIgV,GAAellB,KAAK6F,MAAMpD,OAC5B,MAAO,IAAIgR,OAAU7F,EAEvB,IACIuX,GADAC,EAAgC,IAAhBF,CAEpB,IAAIhR,EAAQ,EAAG,CACb,GAAImR,GAAWrlB,KAAK6F,MAAMqf,EAE1B,KADAC,EAAWE,GAAYA,EAASxO,aAAajJ,EAASsG,EAAQ9D,GAAOjN,MACpDkiB,GAAYD,EAC3B,MAAOplB,MAGX,GAAIolB,IAAkBD,EACpB,MAAOnlB,KAET,IAAIslB,GAAWzP,GAAc7V,KAAM4N,EACnC,KAAKwX,EACH,IAAK,GAAIziB,GAAK,EAAGA,EAAKuiB,EAAaviB,IACjC2iB,EAASzf,MAAMlD,OAAMG,EAMzB,OAHIqiB,KACFG,EAASzf,MAAMqf,GAAeC,GAEzBG,GAGT7R,GAAMrT,UAAUwW,YAAc,SAAShJ,EAASsG,EAAO/Q,GACrD,GAAIA,KAAW+Q,EAAQ,GAAKA,EAAQ,IAA4B,IAAtBlU,KAAK6F,MAAMpD,OACnD,MAAOzC,KAET,IAAIulB,GAAcpiB,EAAQ,IAAO+Q,EAAShE,EAC1C,IAAIqV,GAAavlB,KAAK6F,MAAMpD,OAC1B,MAAOzC,KAGT,IAAImlB,EACJ,IAAIjR,EAAQ,EAAG,CACb,GAAImR,GAAWrlB,KAAK6F,MAAM0f,EAE1B,KADAJ,EAAWE,GAAYA,EAASzO,YAAYhJ,EAASsG,EAAQ9D,GAAOjN,MACnDkiB,GAAYE,IAAcvlB,KAAK6F,MAAMpD,OAAS,EAC7D,MAAOzC,MAIX,GAAIslB,GAAWzP,GAAc7V,KAAM4N,EAKnC,OAJA0X,GAASzf,MAAMif,OAAOS,EAAY,GAC9BJ,IACFG,EAASzf,MAAM0f,GAAaJ,GAEvBG,EAKX,IA2EIjQ,IA3EAV,KAoUJ1U,GAAYgX,GAAY7J,IActB6J,GAAWqL,GAAK,WACd,MAAOtiB,MAAK8M,YAGdmK,GAAW7W,UAAUwL,SAAW,WAC9B,MAAO5L,MAAKuiB,WAAW,eAAgB,MAKzCtL,GAAW7W,UAAUsJ,IAAM,SAASxF,EAAG+N,GACrC,GAAI9O,GAAQnD,KAAKuX,KAAK7N,IAAIxF,EAC1B,YAAiBpB,KAAVK,EAAsBnD,KAAKwX,MAAM9N,IAAIvG,GAAO,GAAK8O,GAK1DgF,GAAW7W,UAAUkW,MAAQ,WAC3B,MAAkB,KAAdtW,KAAK+C,KACA/C,KAELA,KAAKiP,WACPjP,KAAK+C,KAAO,EACZ/C,KAAKuX,KAAKjB,QACVtW,KAAKwX,MAAMlB,QACJtW,MAEFkX,MAGTD,GAAW7W,UAAUsM,IAAM,SAASxI,EAAGC,GACrC,MAAOuT,IAAiB1X,KAAMkE,EAAGC,IAGnC8S,GAAW7W,UAAUoS,OAAS,SAAStO,GACrC,MAAOwT,IAAiB1X,KAAMkE,EAAGyF,KAGnCsN,GAAW7W,UAAUyjB,WAAa,WAChC,MAAO7jB,MAAKuX,KAAKsM,cAAgB7jB,KAAKwX,MAAMqM,cAG9C5M,GAAW7W,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GAAIuR,GAAS3Y,IACnE,OAAOA,MAAKwX,MAAMxU,UAChB,SAASyE,GAAS,MAAOA,IAASN,EAAGM,EAAM,GAAIA,EAAM,GAAIkR,IACzDvR,IAIJ6P,GAAW7W,UAAUyY,WAAa,SAAS5U,EAAMmD,GAC/C,MAAOpH,MAAKwX,MAAMlS,eAAeuT,WAAW5U,EAAMmD,IAGpD6P,GAAW7W,UAAU0jB,cAAgB,SAASlW,GAC5C,GAAIA,IAAY5N,KAAKiP,UACnB,MAAOjP,KAET,IAAI2X,GAAS3X,KAAKuX,KAAKuM,cAAclW,GACjCgK,EAAU5X,KAAKwX,MAAMsM,cAAclW,EACvC,OAAKA,GAMEyJ,GAAeM,EAAQC,EAAShK,EAAS5N,KAAKgJ,SALnDhJ,KAAKiP,UAAYrB,EACjB5N,KAAKuX,KAAOI,EACZ3X,KAAKwX,MAAQI,EACN5X,OAUbiX,GAAWE,aAAeA,GAE1BF,GAAW7W,UAAU0B,KAAuB,EAC5CmV,GAAW7W,UAAgB,OAAI6W,GAAW7W,UAAUoS,MAcpD,IAAIiF,GAgDJxX,GAAY6X,GAAiBhX,GAO3BgX,GAAgB1X,UAAUsJ,IAAM,SAASxB,EAAK+J,GAC5C,MAAOjS,MAAKgY,MAAMtO,IAAIxB,EAAK+J,IAG7B6F,GAAgB1X,UAAUqJ,IAAM,SAASvB,GACvC,MAAOlI,MAAKgY,MAAMvO,IAAIvB,IAGxB4P,GAAgB1X,UAAUolB,SAAW,WACnC,MAAOxlB,MAAKgY,MAAMwN,YAGpB1N,GAAgB1X,UAAUgH,QAAU,WAAY,GAAIuR,GAAS3Y,KACvDwY,EAAmBa,GAAerZ,MAAM,EAI5C,OAHKA,MAAKiY,WACRO,EAAiBgN,SAAW,WAAa,MAAO7M,GAAOX,MAAM7S,QAAQiC,YAEhEoR,GAGTV,GAAgB1X,UAAUgI,IAAM,SAAS6Q,EAAQC,GAAU,GAAIP,GAAS3Y,KAClEmZ,EAAiBH,GAAWhZ,KAAMiZ,EAAQC,EAI9C,OAHKlZ,MAAKiY,WACRkB,EAAeqM,SAAW,WAAa,MAAO7M,GAAOX,MAAM7S,QAAQiD,IAAI6Q,EAAQC,KAE1EC,GAGTrB,GAAgB1X,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GACvDzE,GAD2DgW,EAAS3Y,IAExE,OAAOA,MAAKgY,MAAMhV,UAChBhD,KAAKiY,SACH,SAAS9T,EAAGD,GAAK,MAAOiD,GAAGhD,EAAGD,EAAGyU,KAC/BhW,EAAKyE,EAAUkW,GAAYtd,MAAQ,EACnC,SAASmE,GAAK,MAAOgD,GAAGhD,EAAGiD,IAAYzE,EAAKA,IAAMgW,KACtDvR,IAIJ0Q,GAAgB1X,UAAUyY,WAAa,SAAS5U,EAAMmD,GACpD,GAAIpH,KAAKiY,SACP,MAAOjY,MAAKgY,MAAMa,WAAW5U,EAAMmD,EAErC,IAAIb,GAAWvG,KAAKgY,MAAMa,WAAWC,GAAgB1R,GACjDzE,EAAKyE,EAAUkW,GAAYtd,MAAQ,CACvC,OAAO,IAAI8D,GAAS,WAClB,GAAIyG,GAAOhE,EAASxC,MACpB,OAAOwG,GAAKlG,KAAOkG,EACjBvG,EAAcC,EAAMmD,IAAYzE,EAAKA,IAAM4H,EAAK9J,MAAO8J,MAI/DuN,GAAgB1X,UAAU0B,KAAuB,EAGjD7B,EAAYiY,GAAmBjX,GAM7BiX,GAAkB9X,UAAUqY,SAAW,SAAShY,GAC9C,MAAOT,MAAKgY,MAAMS,SAAShY,IAG7ByX,GAAkB9X,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GAAIuR,GAAS3Y,KACtEyZ,EAAa,CACjB,OAAOzZ,MAAKgY,MAAMhV,UAAU,SAASmB,GAAK,MAAOgD,GAAGhD,EAAGsV,IAAcd,IAAUvR,IAGjF8Q,GAAkB9X,UAAUyY,WAAa,SAAS5U,EAAMmD,GACtD,GAAIb,GAAWvG,KAAKgY,MAAMa,WAAWC,GAAgB1R,GACjDqS,EAAa,CACjB,OAAO,IAAI3V,GAAS,WAClB,GAAIyG,GAAOhE,EAASxC,MACpB,OAAOwG,GAAKlG,KAAOkG,EACjBvG,EAAcC,EAAMwV,IAAclP,EAAK9J,MAAO8J,MAMtDtK,EAAYkY,GAAe/W,GAMzB+W,GAAc/X,UAAUqJ,IAAM,SAASvB,GACrC,MAAOlI,MAAKgY,MAAMS,SAASvQ,IAG7BiQ,GAAc/X,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GAAIuR,GAAS3Y,IACtE,OAAOA,MAAKgY,MAAMhV,UAAU,SAASmB,GAAK,MAAOgD,GAAGhD,EAAGA,EAAGwU,IAAUvR,IAGtE+Q,GAAc/X,UAAUyY,WAAa,SAAS5U,EAAMmD,GAClD,GAAIb,GAAWvG,KAAKgY,MAAMa,WAAWC,GAAgB1R,EACrD,OAAO,IAAItD,GAAS,WAClB,GAAIyG,GAAOhE,EAASxC,MACpB,OAAOwG,GAAKlG,KAAOkG,EACjBvG,EAAcC,EAAMsG,EAAK9J,MAAO8J,EAAK9J,MAAO8J,MAMpDtK,EAAYmY,GAAqBtX,GAM/BsX,GAAoBhY,UAAUoF,SAAW,WACvC,MAAOxF,MAAKgY,MAAM7S,SAGpBiT,GAAoBhY,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GAAIuR,GAAS3Y,IAC5E,OAAOA,MAAKgY,MAAMhV,UAAU,SAASyE,GAGnC,GAAIA,EAAO,CACT4V,GAAc5V,EACd,IAAIge,GAAkB/kB,EAAW+G,EACjC,OAAON,GACLse,EAAkBhe,EAAMiC,IAAI,GAAKjC,EAAM,GACvCge,EAAkBhe,EAAMiC,IAAI,GAAKjC,EAAM,GACvCkR,KAGHvR,IAGLgR,GAAoBhY,UAAUyY,WAAa,SAAS5U,EAAMmD,GACxD,GAAIb,GAAWvG,KAAKgY,MAAMa,WAAWC,GAAgB1R,EACrD,OAAO,IAAItD,GAAS,WAClB,OAAa,CACX,GAAIyG,GAAOhE,EAASxC,MACpB,IAAIwG,EAAKlG,KACP,MAAOkG,EAET,IAAI9C,GAAQ8C,EAAK9J,KAGjB,IAAIgH,EAAO,CACT4V,GAAc5V,EACd,IAAIge,GAAkB/kB,EAAW+G,EACjC,OAAOzD,GACLC,EACAwhB,EAAkBhe,EAAMiC,IAAI,GAAKjC,EAAM,GACvCge,EAAkBhe,EAAMiC,IAAI,GAAKjC,EAAM,GACvC8C,QAQZ2N,GAAkB9X,UAAUiJ,YAC5ByO,GAAgB1X,UAAUiJ,YAC1B8O,GAAc/X,UAAUiJ,YACxB+O,GAAoBhY,UAAUiJ,YAC5BqP,GAopBFzY,EAAYwd,GAAQ1S,IA8BlB0S,GAAOrd,UAAUwL,SAAW,WAC1B,MAAO5L,MAAKuiB,WAAWhE,GAAWve,MAAQ,KAAM,MAKlDyd,GAAOrd,UAAUqJ,IAAM,SAASvF,GAC9B,MAAOlE,MAAKie,eAAeuE,eAAete,IAG5CuZ,GAAOrd,UAAUsJ,IAAM,SAASxF,EAAG+N,GACjC,IAAKjS,KAAKyJ,IAAIvF,GACZ,MAAO+N,EAET,IAAIyT,GAAa1lB,KAAKie,eAAe/Z,EACrC,OAAOlE,MAAKuX,KAAOvX,KAAKuX,KAAK7N,IAAIxF,EAAGwhB,GAAcA,GAKpDjI,GAAOrd,UAAUkW,MAAQ,WACvB,GAAItW,KAAKiP,UAEP,MADAjP,MAAKuX,MAAQvX,KAAKuX,KAAKjB,QAChBtW,IAET,IAAI6d,GAAa7d,KAAKO,WACtB,OAAOsd,GAAW8H,SAAW9H,EAAW8H,OAASxH,GAAWne,KAAMqN,QAGpEoQ,GAAOrd,UAAUsM,IAAM,SAASxI,EAAGC,GACjC,IAAKnE,KAAKyJ,IAAIvF,GACZ,KAAM,IAAIkG,OAAM,2BAA6BlG,EAAI,QAAUqa,GAAWve,MAExE,IAAI2X,GAAS3X,KAAKuX,MAAQvX,KAAKuX,KAAK7K,IAAIxI,EAAGC,EAC3C,OAAInE,MAAKiP,WAAa0I,IAAW3X,KAAKuX,KAC7BvX,KAEFme,GAAWne,KAAM2X,IAG1B8F,GAAOrd,UAAUoS,OAAS,SAAStO,GACjC,IAAKlE,KAAKyJ,IAAIvF,GACZ,MAAOlE,KAET,IAAI2X,GAAS3X,KAAKuX,MAAQvX,KAAKuX,KAAK/E,OAAOtO,EAC3C,OAAIlE,MAAKiP,WAAa0I,IAAW3X,KAAKuX,KAC7BvX,KAEFme,GAAWne,KAAM2X,IAG1B8F,GAAOrd,UAAUyjB,WAAa,WAC5B,MAAO7jB,MAAKuX,KAAKsM,cAGnBpG,GAAOrd,UAAUyY,WAAa,SAAS5U,EAAMmD,GAAU,GAAIuR,GAAS3Y,IAClE,OAAOY,GAAcZ,KAAKie,gBAAgB7V,IAAI,SAASkB,EAAGpF,GAAK,MAAOyU,GAAOjP,IAAIxF,KAAK2U,WAAW5U,EAAMmD,IAGzGqW,GAAOrd,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GAAIuR,GAAS3Y,IAC/D,OAAOY,GAAcZ,KAAKie,gBAAgB7V,IAAI,SAASkB,EAAGpF,GAAK,MAAOyU,GAAOjP,IAAIxF,KAAKlB,UAAUmE,EAAIC,IAGtGqW,GAAOrd,UAAU0jB,cAAgB,SAASlW,GACxC,GAAIA,IAAY5N,KAAKiP,UACnB,MAAOjP,KAET,IAAI2X,GAAS3X,KAAKuX,MAAQvX,KAAKuX,KAAKuM,cAAclW,EAClD,OAAKA,GAKEuQ,GAAWne,KAAM2X,EAAQ/J,IAJ9B5N,KAAKiP,UAAYrB,EACjB5N,KAAKuX,KAAOI,EACL3X,MAMb,IAAIke,IAAkBT,GAAOrd,SAC7B8d,IAAsB,OAAIA,GAAgB1L,OAC1C0L,GAAgBkF,SAChBlF,GAAgB8F,SAAWhV,GAAagV,SACxC9F,GAAgBoF,MAAQtU,GAAasU,MACrCpF,GAAgBqF,UAAYvU,GAAauU,UACzCrF,GAAgBsF,QAAUxU,GAAawU,QACvCtF,GAAgB3M,UAAYvC,GAAauC,UACzC2M,GAAgBzM,cAAgBzC,GAAayC,cAC7CyM,GAAgBwF,YAAc1U,GAAa0U,YAC3CxF,GAAgBxL,MAAQ1D,GAAa0D,MACrCwL,GAAgBrO,OAASb,GAAaa,OACtCqO,GAAgBiF,SAAWnU,GAAamU,SACxCjF,GAAgB3Q,cAAgByB,GAAazB,cAC7C2Q,GAAgBrE,UAAY7K,GAAa6K,UACzCqE,GAAgBpE,YAAc9K,GAAa8K,YAkC3C7Z,EAAY0e,GAAK1T,IAcf0T,GAAI2D,GAAK,WACP,MAAOtiB,MAAK8M,YAGd6R,GAAIiH,SAAW,SAASnlB,GACtB,MAAOT,MAAKY,EAAcH,GAAOolB,WAGnClH,GAAIve,UAAUwL,SAAW,WACvB,MAAO5L,MAAKuiB,WAAW,QAAS,MAKlC5D,GAAIve,UAAUqJ,IAAM,SAAShJ,GAC3B,MAAOT,MAAKuX,KAAK9N,IAAIhJ,IAKvBke,GAAIve,UAAU0e,IAAM,SAASre,GAC3B,MAAOwe,IAAUjf,KAAMA,KAAKuX,KAAK7K,IAAIjM,GAAO,KAG9Cke,GAAIve,UAAUoS,OAAS,SAAS/R,GAC9B,MAAOwe,IAAUjf,KAAMA,KAAKuX,KAAK/E,OAAO/R,KAG1Cke,GAAIve,UAAUkW,MAAQ,WACpB,MAAO2I,IAAUjf,KAAMA,KAAKuX,KAAKjB,UAKnCqI,GAAIve,UAAU0lB,MAAQ,WAAY,GAAI5U,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EAEpE,OADAoE,GAAQA,EAAMU,OAAO,SAASC,GAAK,MAAkB,KAAXA,EAAE9O,OACvB,IAAjBmO,EAAMzO,OACDzC,KAES,IAAdA,KAAK+C,MAAe/C,KAAKiP,WAA8B,IAAjBiC,EAAMzO,OAGzCzC,KAAKuN,cAAc,SAASb,GACjC,IAAK,GAAI/J,GAAK,EAAGA,EAAKuO,EAAMzO,OAAQE,IAClCzB,EAAYgQ,EAAMvO,IAAK6K,QAAQ,SAAS/M,GAAS,MAAOiM,GAAIoS,IAAIre,OAJ3DT,KAAKO,YAAY2Q,EAAM,KASlCyN,GAAIve,UAAU2lB,UAAY,WAAY,GAAI7U,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EACxE,IAAqB,IAAjBoE,EAAMzO,OACR,MAAOzC,KAETkR,GAAQA,EAAM9I,IAAI,SAASvF,GAAQ,MAAO3B,GAAY2B,IACtD,IAAImjB,GAAchmB,IAClB,OAAOA,MAAKuN,cAAc,SAASb,GACjCsZ,EAAYxY,QAAQ,SAAS/M,GACtByQ,EAAM/H,MAAM,SAAStG,GAAQ,MAAOA,GAAK4V,SAAShY,MACrDiM,EAAI8F,OAAO/R,QAMnBke,GAAIve,UAAU6lB,SAAW,WAAY,GAAI/U,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EACvE,IAAqB,IAAjBoE,EAAMzO,OACR,MAAOzC,KAETkR,GAAQA,EAAM9I,IAAI,SAASvF,GAAQ,MAAO3B,GAAY2B,IACtD,IAAImjB,GAAchmB,IAClB,OAAOA,MAAKuN,cAAc,SAASb,GACjCsZ,EAAYxY,QAAQ,SAAS/M,GACvByQ,EAAMiM,KAAK,SAASta,GAAQ,MAAOA,GAAK4V,SAAShY,MACnDiM,EAAI8F,OAAO/R,QAMnBke,GAAIve,UAAUkjB,MAAQ,WACpB,MAAOtjB,MAAK8lB,MAAMjZ,MAAM7M,KAAM8M,YAGhC6R,GAAIve,UAAUmjB,UAAY,SAASvS,GAAS,GAAIE,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EAC9E,OAAO9M,MAAK8lB,MAAMjZ,MAAM7M,KAAMkR,IAGhCyN,GAAIve,UAAUoc,KAAO,SAASF,GAE5B,MAAOiD,IAAWlD,GAAYrc,KAAMsc,KAGtCqC,GAAIve,UAAUujB,OAAS,SAAS1K,EAAQqD,GAEtC,MAAOiD,IAAWlD,GAAYrc,KAAMsc,EAAYrD,KAGlD0F,GAAIve,UAAUyjB,WAAa,WACzB,MAAO7jB,MAAKuX,KAAKsM,cAGnBlF,GAAIve,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GAAIuR,GAAS3Y,IAC5D,OAAOA,MAAKuX,KAAKvU,UAAU,SAASsG,EAAGpF,GAAK,MAAOiD,GAAGjD,EAAGA,EAAGyU,IAAUvR,IAGxEuX,GAAIve,UAAUyY,WAAa,SAAS5U,EAAMmD,GACxC,MAAOpH,MAAKuX,KAAKnP,IAAI,SAASkB,EAAGpF,GAAK,MAAOA,KAAI2U,WAAW5U,EAAMmD,IAGpEuX,GAAIve,UAAU0jB,cAAgB,SAASlW,GACrC,GAAIA,IAAY5N,KAAKiP,UACnB,MAAOjP,KAET,IAAI2X,GAAS3X,KAAKuX,KAAKuM,cAAclW,EACrC,OAAKA,GAKE5N,KAAKmf,OAAOxH,EAAQ/J,IAJzB5N,KAAKiP,UAAYrB,EACjB5N,KAAKuX,KAAOI,EACL3X,OAUb2e,GAAIE,MAAQA,EAEZ,IAAIG,IAAkB,wBAElBK,GAAeV,GAAIve,SACvBif,IAAaL,KAAmB,EAChCK,GAAmB,OAAIA,GAAa7M,OACpC6M,GAAa9N,UAAY8N,GAAaiE,MACtCjE,GAAa5N,cAAgB4N,GAAakE,UAC1ClE,GAAa9R,cAAgByB,GAAazB,cAC1C8R,GAAaxF,UAAY7K,GAAa6K,UACtCwF,GAAavF,YAAc9K,GAAa8K,YAExCuF,GAAaH,QAAUN,GACvBS,GAAaF,OAASC,EAqBtB,IAAIE,GAKJrf,GAAYsf,GAAYZ,IActBY,GAAW+C,GAAK,WACd,MAAOtiB,MAAK8M,YAGdyS,GAAWqG,SAAW,SAASnlB,GAC7B,MAAOT,MAAKY,EAAcH,GAAOolB,WAGnCtG,GAAWnf,UAAUwL,SAAW,WAC9B,MAAO5L,MAAKuiB,WAAW,eAAgB,MAQ3ChD,GAAWE,aAAeA,EAE1B,IAAIG,IAAsBL,GAAWnf,SACrCwf,IAAoB9d,KAAuB,EAE3C8d,GAAoBV,QAAUM,GAC9BI,GAAoBT,OAASQ,EAU7B,IAAIE,GAKJ5f,GAAY6f,GAAO9U,IAUjB8U,GAAMwC,GAAK,WACT,MAAOtiB,MAAK8M,YAGdgT,GAAM1f,UAAUwL,SAAW,WACzB,MAAO5L,MAAKuiB,WAAW,UAAW,MAKpCzC,GAAM1f,UAAUsJ,IAAM,SAASvG,EAAO8O,GACpC,GAAIoO,GAAOrgB,KAAKugB,KAEhB,KADApd,EAAQD,EAAUlD,KAAMmD,GACjBkd,GAAQld,KACbkd,EAAOA,EAAKtc,IAEd,OAAOsc,GAAOA,EAAK5f,MAAQwR,GAG7B6N,GAAM1f,UAAU8lB,KAAO,WACrB,MAAOlmB,MAAKugB,OAASvgB,KAAKugB,MAAM9f,OAKlCqf,GAAM1f,UAAU+Q,KAAO,WACrB,GAAyB,IAArBrE,UAAUrK,OACZ,MAAOzC,KAIT,KAAK,GAFDsP,GAAUtP,KAAK+C,KAAO+J,UAAUrK,OAChC4d,EAAOrgB,KAAKugB,MACP5d,EAAKmK,UAAUrK,OAAS,EAAGE,GAAM,EAAGA,IAC3C0d,GACE5f,MAAOqM,UAAUnK,GACjBoB,KAAMsc,EAGV,OAAIrgB,MAAKiP,WACPjP,KAAK+C,KAAOuM,EACZtP,KAAKugB,MAAQF,EACbrgB,KAAKgJ,WAASlG,GACd9C,KAAKkP,WAAY,EACVlP,MAEFogB,GAAU9Q,EAAS+Q,IAG5BP,GAAM1f,UAAU+lB,QAAU,SAAStjB,GAEjC,GADAA,EAAO9B,EAAgB8B,GACL,IAAdA,EAAKE,KACP,MAAO/C,KAETmN,IAAkBtK,EAAKE,KACvB,IAAIuM,GAAUtP,KAAK+C,KACfsd,EAAOrgB,KAAKugB,KAQhB,OAPA1d,GAAKuE,UAAUoG,QAAQ,SAAS/M,GAC9B6O,IACA+Q,GACE5f,MAAOA,EACPsD,KAAMsc,KAGNrgB,KAAKiP,WACPjP,KAAK+C,KAAOuM,EACZtP,KAAKugB,MAAQF,EACbrgB,KAAKgJ,WAASlG,GACd9C,KAAKkP,WAAY,EACVlP,MAEFogB,GAAU9Q,EAAS+Q,IAG5BP,GAAM1f,UAAU+S,IAAM,WACpB,MAAOnT,MAAK8V,MAAM,IAGpBgK,GAAM1f,UAAU6kB,QAAU,WACxB,MAAOjlB,MAAKmR,KAAKtE,MAAM7M,KAAM8M,YAG/BgT,GAAM1f,UAAU6f,WAAa,SAASpd,GACpC,MAAO7C,MAAKmmB,QAAQtjB,IAGtBid,GAAM1f,UAAUwP,MAAQ,WACtB,MAAO5P,MAAKmT,IAAItG,MAAM7M,KAAM8M,YAG9BgT,GAAM1f,UAAUkW,MAAQ,WACtB,MAAkB,KAAdtW,KAAK+C,KACA/C,KAELA,KAAKiP,WACPjP,KAAK+C,KAAO,EACZ/C,KAAKugB,UAAQzd,GACb9C,KAAKgJ,WAASlG,GACd9C,KAAKkP,WAAY,EACVlP,MAEF+f,MAGTD,GAAM1f,UAAU0V,MAAQ,SAASvS,EAAOC,GACtC,GAAIF,EAAWC,EAAOC,EAAKxD,KAAK+C,MAC9B,MAAO/C,KAET,IAAIsa,GAAgB7W,EAAaF,EAAOvD,KAAK+C,KAE7C,IADkBY,EAAWH,EAAKxD,KAAK+C,QACnB/C,KAAK+C,KAEvB,MAAOiI,IAAkB5K,UAAU0V,MAAMhR,KAAK9E,KAAMuD,EAAOC,EAI7D,KAFA,GAAI8L,GAAUtP,KAAK+C,KAAOuX,EACtB+F,EAAOrgB,KAAKugB,MACTjG,KACL+F,EAAOA,EAAKtc,IAEd,OAAI/D,MAAKiP,WACPjP,KAAK+C,KAAOuM,EACZtP,KAAKugB,MAAQF,EACbrgB,KAAKgJ,WAASlG,GACd9C,KAAKkP,WAAY,EACVlP,MAEFogB,GAAU9Q,EAAS+Q,IAK5BP,GAAM1f,UAAU0jB,cAAgB,SAASlW,GACvC,MAAIA,KAAY5N,KAAKiP,UACZjP,KAEJ4N,EAKEwS,GAAUpgB,KAAK+C,KAAM/C,KAAKugB,MAAO3S,EAAS5N,KAAKgJ,SAJpDhJ,KAAKiP,UAAYrB,EACjB5N,KAAKkP,WAAY,EACVlP,OAOX8f,GAAM1f,UAAU4C,UAAY,SAASmE,EAAIC,GACvC,GAAIA,EACF,MAAOpH,MAAKoH,UAAUpE,UAAUmE,EAIlC,KAFA,GAAIsS,GAAa,EACbzM,EAAOhN,KAAKugB,MACTvT,IACsC,IAAvC7F,EAAG6F,EAAKvM,MAAOgZ,IAAczZ,OAGjCgN,EAAOA,EAAKjJ,IAEd,OAAO0V,IAGTqG,GAAM1f,UAAUyY,WAAa,SAAS5U,EAAMmD,GAC1C,GAAIA,EACF,MAAOpH,MAAKoH,UAAUyR,WAAW5U,EAEnC,IAAIwV,GAAa,EACbzM,EAAOhN,KAAKugB,KAChB,OAAO,IAAIzc,GAAS,WAClB,GAAIkJ,EAAM,CACR,GAAIvM,GAAQuM,EAAKvM,KAEjB,OADAuM,GAAOA,EAAKjJ,KACLC,EAAcC,EAAMwV,IAAchZ,GAE3C,MAAO6D,QASbwb,GAAME,QAAUA,EAEhB,IAAIG,IAAoB,0BAEpBG,GAAiBR,GAAM1f,SAC3BkgB,IAAeH,KAAqB,EACpCG,GAAe/S,cAAgByB,GAAazB,cAC5C+S,GAAezG,UAAY7K,GAAa6K,UACxCyG,GAAexG,YAAc9K,GAAa8K,YAC1CwG,GAAeuD,WAAa7U,GAAa6U,UAazC,IAAIrD,GAgBJhgB,GAASsD,SAAWA,EAEpB2c,GAAMjgB,GAIJkT,QAAS,WACPvG,GAAkBnN,KAAK+C,KACvB,IAAI8C,GAAQ,GAAItG,OAAMS,KAAK+C,MAAQ,EAEnC,OADA/C,MAAKwlB,WAAWxiB,UAAU,SAASmB,EAAG0P,GAAMhO,EAAMgO,GAAK1P,IAChD0B,GAGTJ,aAAc,WACZ,MAAO,IAAIyS,IAAkBlY,OAG/BomB,KAAM,WACJ,MAAOpmB,MAAKmF,QAAQiD,IAClB,SAAS3H,GAAS,MAAOA,IAA+B,kBAAfA,GAAM2lB,KAAsB3lB,EAAM2lB,OAAS3lB,IACpF4lB,UAGJC,OAAQ,WACN,MAAOtmB,MAAKmF,QAAQiD,IAClB,SAAS3H,GAAS,MAAOA,IAAiC,kBAAjBA,GAAM6lB,OAAwB7lB,EAAM6lB,SAAW7lB,IACxF4lB,UAGJhhB,WAAY,WACV,MAAO,IAAIyS,IAAgB9X,MAAM,IAGnCuI,MAAO,WAEL,MAAO6E,IAAIpN,KAAKqF,eAGlBkhB,SAAU,WACRpZ,GAAkBnN,KAAK+C,KACvB,IAAIiD,KAEJ,OADAhG,MAAKgD,UAAU,SAASmB,EAAGD,GAAM8B,EAAO9B,GAAKC,IACtC6B,GAGTwgB,aAAc,WAEZ,MAAOvP,IAAWjX,KAAKqF,eAGzBohB,aAAc,WAEZ,MAAOlH,IAAW1e,EAAQb,MAAQA,KAAKwlB,WAAaxlB,OAGtD0mB,MAAO,WAEL,MAAO/H,IAAI9d,EAAQb,MAAQA,KAAKwlB,WAAaxlB,OAG/C2F,SAAU,WACR,MAAO,IAAIwS,IAAcnY,OAG3BmF,MAAO,WACL,MAAOnE,GAAUhB,MAAQA,KAAKyF,eAC5B5E,EAAQb,MAAQA,KAAKqF,aACrBrF,KAAK2F,YAGTghB,QAAS,WAEP,MAAO7G,IAAMjf,EAAQb,MAAQA,KAAKwlB,WAAaxlB,OAGjDsI,OAAQ,WAEN,MAAO8K,IAAKvS,EAAQb,MAAQA,KAAKwlB,WAAaxlB,OAMhD4L,SAAU,WACR,MAAO,cAGT2W,WAAY,SAASlC,EAAM/L,GACzB,MAAkB,KAAdtU,KAAK+C,KACAsd,EAAO/L,EAET+L,EAAO,IAAMrgB,KAAKmF,QAAQiD,IAAIpI,KAAK4mB,kBAAkBC,KAAK,MAAQ,IAAMvS,GAMjF9U,OAAQ,WACN,MAAO2a,IAAMna,KAAMmb,GAAcnb,KADF4hB,GAAQ9c,KAAKgI,UAAW,MAIzD2L,SAAU,SAASgK,GACjB,MAAOziB,MAAKmd,KAAK,SAAS1c,GAAS,MAAO+H,GAAG/H,EAAOgiB,MAGtDvZ,QAAS,WACP,MAAOlJ,MAAK6Y,WAAWD,KAGzBzP,MAAO,SAASoQ,EAAWL,GACzB/L,GAAkBnN,KAAK+C,KACvB,IAAI+jB,IAAc,CAOlB,OANA9mB,MAAKgD,UAAU,SAASmB,EAAGD,EAAGkV,GAC5B,IAAKG,EAAUzU,KAAKoU,EAAS/U,EAAGD,EAAGkV,GAEjC,MADA0N,IAAc,GACP,IAGJA,GAGTlV,OAAQ,SAAS2H,EAAWL,GAC1B,MAAOiB,IAAMna,KAAMsZ,GAActZ,KAAMuZ,EAAWL,GAAS,KAG7D6N,KAAM,SAASxN,EAAWL,EAASjH,GACjC,GAAIxK,GAAQzH,KAAKgnB,UAAUzN,EAAWL,EACtC,OAAOzR,GAAQA,EAAM,GAAKwK,GAG5B+U,UAAW,SAASzN,EAAWL,GAC7B,GAAI+N,EAOJ,OANAjnB,MAAKgD,UAAU,SAASmB,EAAGD,EAAGkV,GAC5B,GAAIG,EAAUzU,KAAKoU,EAAS/U,EAAGD,EAAGkV,GAEhC,MADA6N,IAAS/iB,EAAGC,IACL,IAGJ8iB,GAGTC,cAAe,SAAS3N,EAAWL,GACjC,MAAOlZ,MAAKmF,QAAQiC,UAAU4f,UAAUzN,EAAWL,IAGrD1L,QAAS,SAAS2Z,EAAYjO,GAE5B,MADA/L,IAAkBnN,KAAK+C,MAChB/C,KAAKgD,UAAUkW,EAAUiO,EAAWzI,KAAKxF,GAAWiO,IAG7DN,KAAM,SAAS1K,GACbhP,GAAkBnN,KAAK+C,MACvBoZ,MAA0BrZ,KAAdqZ,EAA0B,GAAKA,EAAY,GACvD,IAAIiL,GAAS,GACTC,GAAU,CAKd,OAJArnB,MAAKgD,UAAU,SAASmB,GACtBkjB,EAAWA,GAAU,EAAUD,GAAUjL,EACzCiL,GAAgB,OAANjjB,OAAoBrB,KAANqB,EAAkBA,EAAEyH,WAAa,KAEpDwb,GAGTnhB,KAAM,WACJ,MAAOjG,MAAK6Y,WAAWE,KAGzB3Q,IAAK,SAAS6Q,EAAQC,GACpB,MAAOiB,IAAMna,KAAMgZ,GAAWhZ,KAAMiZ,EAAQC,KAG9CsC,OAAQ,SAAS8L,EAASC,EAAkBrO,GAC1C/L,GAAkBnN,KAAK+C,KACvB,IAAIykB,GACAC,CAcJ,OAbI3a,WAAUrK,OAAS,EACrBglB,GAAW,EAEXD,EAAYD,EAEdvnB,KAAKgD,UAAU,SAASmB,EAAGD,EAAGkV,GACxBqO,GACFA,GAAW,EACXD,EAAYrjB,GAEZqjB,EAAYF,EAAQxiB,KAAKoU,EAASsO,EAAWrjB,EAAGD,EAAGkV,KAGhDoO,GAGTE,YAAa,SAASJ,EAASC,EAAkBrO,GAC/C,GAAIyO,GAAW3nB,KAAKqF,aAAa+B,SACjC,OAAOugB,GAASnM,OAAO3O,MAAM8a,EAAU7a,YAGzC1F,QAAS,WACP,MAAO+S,IAAMna,KAAMqZ,GAAerZ,MAAM,KAG1C8V,MAAO,SAASvS,EAAOC,GACrB,MAAO2W,IAAMna,KAAMoa,GAAapa,KAAMuD,EAAOC,GAAK,KAGpD2Z,KAAM,SAAS5D,EAAWL,GACxB,OAAQlZ,KAAKmJ,MAAM4X,GAAIxH,GAAYL,IAGrCsD,KAAM,SAASF,GACb,MAAOnC,IAAMna,KAAMqc,GAAYrc,KAAMsc,KAGvC1H,OAAQ,WACN,MAAO5U,MAAK6Y,WAAWC,KAMzB8O,QAAS,WACP,MAAO5nB,MAAK8V,MAAM,GAAI,IAGxB+R,QAAS,WACP,WAAqB/kB,KAAd9C,KAAK+C,KAAmC,IAAd/C,KAAK+C,MAAc/C,KAAKmd,KAAK,WAAa,OAAO,KAGpFlP,MAAO,SAASsL,EAAWL,GACzB,MAAOtW,GACL2W,EAAYvZ,KAAKmF,QAAQyM,OAAO2H,EAAWL,GAAWlZ,OAI1D8nB,QAAS,SAASnO,EAAST,GACzB,MAAOQ,IAAe1Z,KAAM2Z,EAAST,IAGvCtQ,OAAQ,SAASga,GACf,MAAO/Z,GAAU7I,KAAM4iB,IAGzBpd,SAAU,WACR,GAAIZ,GAAW5E,IACf,IAAI4E,EAAS2C,OAEX,MAAO,IAAI3B,GAAShB,EAAS2C,OAE/B,IAAIwgB,GAAkBnjB,EAASO,QAAQiD,IAAI0Y,IAAarb,cAExD,OADAsiB,GAAgBziB,aAAe,WAAa,MAAOV,GAASO,SACrD4iB,GAGTC,UAAW,SAASzO,EAAWL,GAC7B,MAAOlZ,MAAK4R,OAAOmP,GAAIxH,GAAYL,IAGrC+O,SAAU,SAAS1O,EAAWL,EAASjH,GACrC,MAAOjS,MAAKqF,aAAa+B,UAAU2f,KAAKxN,EAAWL,EAASjH,IAG9DiW,MAAO,WACL,MAAOloB,MAAK+mB,KAAK9jB,IAGnBklB,QAAS,SAASlP,EAAQC,GACxB,MAAOiB,IAAMna,KAAMic,GAAejc,KAAMiZ,EAAQC,KAGlDqC,QAAS,SAASI,GAChB,MAAOxB,IAAMna,KAAM0b,GAAe1b,KAAM2b,GAAO,KAGjDrW,aAAc,WACZ,MAAO,IAAI8S,IAAoBpY,OAGjC0J,IAAK,SAAS0e,EAAWnW,GACvB,MAAOjS,MAAK+mB,KAAK,SAASzd,EAAGpB,GAAO,MAAOM,GAAGN,EAAKkgB,QAAatlB,GAAWmP,IAG7EoW,MAAO,SAASC,EAAerW,GAM7B,IALA,GAII1H,GAJAge,EAASvoB,KAGT6C,EAAO0a,GAAc+K,KAEhB/d,EAAO1H,EAAKkB,QAAQM,MAAM,CACjC,GAAI6D,GAAMqC,EAAK9J,KAEf,KADA8nB,EAASA,GAAUA,EAAO7e,IAAM6e,EAAO7e,IAAIxB,EAAKyB,IAAWA,MAC5CA,GACb,MAAOsI,GAGX,MAAOsW,IAGTC,QAAS,SAAS7O,EAAST,GACzB,MAAOa,IAAe/Z,KAAM2Z,EAAST,IAGvCzP,IAAK,SAAS2e,GACZ,MAAOpoB,MAAK0J,IAAI0e,EAAWze,MAAaA,IAG1C8e,MAAO,SAASH,GACd,MAAOtoB,MAAKqoB,MAAMC,EAAe3e,MAAaA,IAGhD+e,SAAU,SAAS7lB,GAEjB,MADAA,GAAgC,kBAAlBA,GAAK4V,SAA0B5V,EAAOrC,EAASqC,GACtD7C,KAAKmJ,MAAM,SAAS1I,GAAS,MAAOoC,GAAK4V,SAAShY,MAG3DkoB,WAAY,SAAS9lB,GAEnB,MADAA,GAAgC,kBAAlBA,GAAK6lB,SAA0B7lB,EAAOrC,EAASqC,GACtDA,EAAK6lB,SAAS1oB,OAGvB6lB,OAAQ,WACN,MAAO7lB,MAAKmF,QAAQiD,IAAIyY,IAAWpb,gBAGrCmjB,KAAM,WACJ,MAAO5oB,MAAKmF,QAAQiC,UAAU8gB,SAGhC1lB,IAAK,SAAS8Z,GACZ,MAAOG,IAAWzc,KAAMsc,IAG1BuM,MAAO,SAAS5P,EAAQqD,GACtB,MAAOG,IAAWzc,KAAMsc,EAAYrD,IAGtCpV,IAAK,SAASyY,GACZ,MAAOG,IAAWzc,KAAMsc,EAAa0E,GAAI1E,GAAc+E,KAGzDyH,MAAO,SAAS7P,EAAQqD,GACtB,MAAOG,IAAWzc,KAAMsc,EAAa0E,GAAI1E,GAAc+E,GAAsBpI,IAG/E8P,KAAM,WACJ,MAAO/oB,MAAK8V,MAAM,IAGpBkT,KAAM,SAASC,GACb,MAAOjpB,MAAK8V,MAAMvT,KAAKC,IAAI,EAAGymB,KAGhCC,SAAU,SAASD,GACjB,MAAO9O,IAAMna,KAAMA,KAAKmF,QAAQiC,UAAU4hB,KAAKC,GAAQ7hB,YAGzD+hB,UAAW,SAAS5P,EAAWL,GAC7B,MAAOiB,IAAMna,KAAMgb,GAAiBhb,KAAMuZ,EAAWL,GAAS,KAGhEkQ,UAAW,SAAS7P,EAAWL,GAC7B,MAAOlZ,MAAKmpB,UAAUpI,GAAIxH,GAAYL,IAGxCyK,OAAQ,SAAS1K,EAAQqD,GACvB,MAAOnC,IAAMna,KAAMqc,GAAYrc,KAAMsc,EAAYrD,KAGnDoQ,KAAM,SAASJ,GACb,MAAOjpB,MAAK8V,MAAM,EAAGvT,KAAKC,IAAI,EAAGymB,KAGnCK,SAAU,SAASL,GACjB,MAAO9O,IAAMna,KAAMA,KAAKmF,QAAQiC,UAAUiiB,KAAKJ,GAAQ7hB,YAGzDmiB,UAAW,SAAShQ,EAAWL,GAC7B,MAAOiB,IAAMna,KAAM6a,GAAiB7a,KAAMuZ,EAAWL,KAGvDsQ,UAAW,SAASjQ,EAAWL,GAC7B,MAAOlZ,MAAKupB,UAAUxI,GAAIxH,GAAYL,IAGxCsM,SAAU,WACR,MAAOxlB,MAAKyF,gBAMdiG,SAAU,WACR,MAAO1L,MAAKgJ,SAAWhJ,KAAKgJ,OAASsY,GAAathB,SAgBtD,IAAIypB,IAAoBjpB,EAASJ,SACjCqpB,IAAkBnoB,KAAwB,EAC1CmoB,GAAkBzH,IAAmByH,GAAkB7U,OACvD6U,GAAkBpD,OAASoD,GAAkB/V,QAC7C+V,GAAkB7C,iBAAmB3F,GACrCwI,GAAkBrH,QAClBqH,GAAkBpH,SAAW,WAAa,MAAOriB,MAAK4L,YACtD6d,GAAkBC,MAAQD,GAAkBtB,QAC5CsB,GAAkBE,SAAWF,GAAkBhR,SAG/C,WACE,IACEpY,OAAOuM,eAAe6c,GAAmB,UACvC/f,IAAK,WACH,IAAKlJ,EAASopB,gBAAiB,CAC7B,GAAI5N,EACJ,KACE,KAAM,IAAI5R,OACV,MAAOD,GACP6R,EAAQ7R,EAAM6R,MAEhB,IAAsC,IAAlCA,EAAM0G,QAAQ,eAOhB,MANAmH,UAAWA,QAAQC,MAAQD,QAAQC,KACjC,4IAGA9N,GAEKhc,KAAK+C,SAKpB,MAAOkgB,QAKXxC,GAAM7f,GAIJiX,KAAM,WACJ,MAAOsC,IAAMna,KAAMqY,GAAYrY,QAGjC+pB,QAAS,SAASxQ,EAAWL,GAC3B,GAAIzR,GAAQzH,KAAKgnB,UAAUzN,EAAWL,EACtC,OAAOzR,IAASA,EAAM,IAGxBuiB,YAAa,SAASzQ,EAAWL,GAC/B,MAAOlZ,MAAKmF,QAAQiC,UAAU2iB,QAAQxQ,EAAWL,IAGnD+Q,MAAO,SAASxH,GACd,MAAOziB,MAAK+pB,QAAQ,SAAStpB,GAAS,MAAO+H,GAAG/H,EAAOgiB,MAGzDyH,UAAW,SAASzH,GAClB,MAAOziB,MAAKgqB,YAAY,SAASvpB,GAAS,MAAO+H,GAAG/H,EAAOgiB,MAG7D0H,WAAY,SAASlR,EAAQC,GAAU,GAAIP,GAAS3Y,KAC9CyZ,EAAa,CACjB,OAAOU,IAAMna,KACXA,KAAKmF,QAAQiD,IACX,SAASjE,EAAGD,GAAK,MAAO+U,GAAOnU,KAAKoU,GAAUhV,EAAGC,GAAIsV,IAAcd,KACnErT,iBAIN8kB,QAAS,SAASnR,EAAQC,GAAU,GAAIP,GAAS3Y,IAC/C,OAAOma,IAAMna,KACXA,KAAKmF,QAAQ0S,OAAOzP,IAClB,SAASlE,EAAGC,GAAK,MAAO8U,GAAOnU,KAAKoU,EAAShV,EAAGC,EAAGwU,KACnDd,UAMR,IAAIwS,IAAyBzpB,EAAcR,SAyQ3C,OAxQAiqB,IAAuB7oB,KAAqB,EAC5C6oB,GAAuBrI,IAAmByH,GAAkBvgB,QAC5DmhB,GAAuBhE,OAASoD,GAAkBlD,SAClD8D,GAAuBzD,iBAAmB,SAASziB,EAAGD,GAAK,MAAOgd,MAAKC,UAAUjd,GAAK,KAAO+c,GAAY9c,IAIzGsc,GAAM1f,GAIJsE,WAAY,WACV,MAAO,IAAIyS,IAAgB9X,MAAM,IAMnC4R,OAAQ,SAAS2H,EAAWL,GAC1B,MAAOiB,IAAMna,KAAMsZ,GAActZ,KAAMuZ,EAAWL,GAAS,KAG7DoR,UAAW,SAAS/Q,EAAWL,GAC7B,GAAIzR,GAAQzH,KAAKgnB,UAAUzN,EAAWL,EACtC,OAAOzR,GAAQA,EAAM,IAAM,GAG7Bib,QAAS,SAASD,GAChB,GAAIva,GAAMlI,KAAKqF,aAAa4kB,MAAMxH,EAClC,YAAe3f,KAARoF,GAAqB,EAAIA,GAGlCya,YAAa,SAASF,GACpB,GAAIva,GAAMlI,KAAKqF,aAAa+B,UAAU6iB,MAAMxH,EAC5C,YAAe3f,KAARoF,GAAqB,EAAIA,GAMlCd,QAAS,WACP,MAAO+S,IAAMna,KAAMqZ,GAAerZ,MAAM,KAG1C8V,MAAO,SAASvS,EAAOC,GACrB,MAAO2W,IAAMna,KAAMoa,GAAapa,KAAMuD,EAAOC,GAAK,KAGpDshB,OAAQ,SAAS3hB,EAAOonB,GACtB,GAAIC,GAAU1d,UAAUrK,MAExB,IADA8nB,EAAYhoB,KAAKC,IAAgB,EAAZ+nB,EAAe,GACpB,IAAZC,GAA8B,IAAZA,IAAkBD,EACtC,MAAOvqB,KAKTmD,GAAQM,EAAaN,EAAOA,EAAQ,EAAInD,KAAKiO,QAAUjO,KAAK+C,KAC5D,IAAI0nB,GAAUzqB,KAAK8V,MAAM,EAAG3S,EAC5B,OAAOgX,IACLna,KACY,IAAZwqB,EACEC,EACAA,EAAQjrB,OAAO2C,EAAQ2K,UAAW,GAAI9M,KAAK8V,MAAM3S,EAAQonB,MAO/DG,cAAe,SAASnR,EAAWL,GACjC,GAAIhR,GAAMlI,KAAKqF,aAAa2kB,YAAYzQ,EAAWL,EACnD,YAAepW,KAARoF,GAAqB,EAAIA,GAGlCggB,MAAO,WACL,MAAOloB,MAAK0J,IAAI,IAGlB6R,QAAS,SAASI,GAChB,MAAOxB,IAAMna,KAAM0b,GAAe1b,KAAM2b,GAAO,KAGjDjS,IAAK,SAASvG,EAAO8O,GAEnB,MADA9O,GAAQD,EAAUlD,KAAMmD,GAChBA,EAAQ,GAAMnD,KAAK+C,OAASgH,SACjBjH,KAAd9C,KAAK+C,MAAsBI,EAAQnD,KAAK+C,KAC3CkP,EACAjS,KAAK+mB,KAAK,SAASzd,EAAGpB,GAAO,MAAOA,KAAQ/E,OAAQL,GAAWmP,IAGnExI,IAAK,SAAStG,GAEZ,OADAA,EAAQD,EAAUlD,KAAMmD,KACR,QAAoBL,KAAd9C,KAAK+C,KACzB/C,KAAK+C,OAASgH,KAAY5G,EAAQnD,KAAK+C,MACd,IAAzB/C,KAAK0iB,QAAQvf,KAIjBwnB,UAAW,SAASxO,GAClB,MAAOhC,IAAMna,KAAMkc,GAAiBlc,KAAMmc,KAG5CyO,WAAY,WACV,GAAI3Z,IAAajR,MAAMR,OAAO2C,EAAQ2K,YAClC+d,EAASjO,GAAe5c,KAAKmF,QAASlE,EAAWqhB,GAAIrR,GACrD6Z,EAAcD,EAAOtP,SAAQ,EAIjC,OAHIsP,GAAO9nB,OACT+nB,EAAY/nB,KAAO8nB,EAAO9nB,KAAOkO,EAAUxO,QAEtC0X,GAAMna,KAAM8qB,IAGrBlC,KAAM,WACJ,MAAO5oB,MAAK0J,KAAK,IAGnByf,UAAW,SAAS5P,EAAWL,GAC7B,MAAOiB,IAAMna,KAAMgb,GAAiBhb,KAAMuZ,EAAWL,GAAS,KAGhE6R,IAAK,WAEH,MAAO5Q,IAAMna,KAAM4c,GAAe5c,KAAMohB,IADvBphB,MAAMR,OAAO2C,EAAQ2K,eAIxCke,QAAS,SAASlO,GAChB,GAAI7L,GAAY9O,EAAQ2K,UAExB,OADAmE,GAAU,GAAKjR,KACRma,GAAMna,KAAM4c,GAAe5c,KAAM8c,EAAQ7L,OAKpDlQ,EAAgBX,UAAUsB,KAAuB,EACjDX,EAAgBX,UAAU0B,KAAuB,EAIjD2e,GAAMvf,GAIJwI,IAAK,SAASjJ,EAAOwR,GACnB,MAAOjS,MAAKyJ,IAAIhJ,GAASA,EAAQwR,GAGnCwG,SAAU,SAAShY,GACjB,MAAOT,MAAKyJ,IAAIhJ,IAMlBolB,OAAQ,WACN,MAAO7lB,MAAKwlB,cAKhBtkB,EAAYd,UAAUqJ,IAAMggB,GAAkBhR,SAK9CgI,GAAM3f,EAAUF,EAAcR,WAC9BqgB,GAAMxf,EAAYF,EAAgBX,WAClCqgB,GAAMrf,EAAQF,EAAYd,WAE1BqgB,GAAM1V,GAAiBnK,EAAcR,WACrCqgB,GAAMzV,GAAmBjK,EAAgBX,WACzCqgB,GAAMxV,GAAe/J,EAAYd,YAyE/BI,SAAUA,EAEVG,IAAKA,EACLmK,WAAYA,GACZsC,IAAKA,GACL6J,WAAYA,GACZ7D,KAAMA,GACN0M,MAAOA,GACPnB,IAAKA,GACLY,WAAYA,GAEZ9B,OAAQA,GACRpT,MAAOA,EACPT,OAAQA,EAERpB,GAAIA,EACJX,OAAQA,MFmCN,SAAUpI,EAAQI,EAASF,GAEjC,YGr3JA,SAASsK,GAAUC,EAAW+gB,EAAQniB,EAAGC,EAAGqQ,EAAG4J,EAAGC,EAAGiI,GAGnD,GAFAC,EAAeF,IAEV/gB,EAAW,CACd,GAAIC,EACJ,QAAerH,KAAXmoB,EACF9gB,EAAQ,GAAIC,OAAM,qIACb,CACL,GAAIghB,IAAQtiB,EAAGC,EAAGqQ,EAAG4J,EAAGC,EAAGiI,GACvBG,EAAW,CACflhB,GAAQ,GAAIC,OAAM6gB,EAAOK,QAAQ,MAAO,WACtC,MAAOF,GAAKC,QAEdlhB,EAAMwT,KAAO,sBAIf,KADAxT,GAAMohB,YAAc,EACdphB,GA3BV,GAAIghB,GAAiB,SAAwBF,IA+B7CxrB,GAAOI,QAAUoK,GHy5JX,SAAUxK,EAAQI,EAASF,GAEjC,YI57JA,SAAS6rB,GAAgBC,EAAUC,GAAe,KAAMD,YAAoBC,IAAgB,KAAM,IAAI1kB,WAAU,qCA4ahH,QAAS2kB,GAAgBC,EAAaC,EAAWC,GAC/C,MAAOC,GAAYrf,IAAIkf,GACrBC,UAAWA,EACXC,eAAgBA,EAChBE,wBAAyB,KACzBC,oBAAqB,OAQzB,QAASC,GAAmBC,EAAcC,GACxC,MAAOD,GAAaE,cAAcjkB,IAAI,SAAUkkB,GAC9C,MAAOC,GAAUC,SAASL,EAAcG,EAAOF,KAC9C5F,eAQL,QAASiG,GAA2Bb,EAAac,EAAaC,EAAcP,GAC1E,GAAID,GAAeP,EAAYgB,oBAAoBlgB,IAAI,YAAaigB,GAChEE,EAAeV,EAAaE,aAEhC,OADkBT,GAAYkB,eAAepjB,IAAI,WAC9B4Z,MAAMoJ,EAAYvnB,QAAQyM,OAAO,SAAU0a,EAAOpkB,GACnE,MAAOokB,KAAUO,EAAanjB,IAAIxB,KACjCE,IAAI,SAAUkkB,GACf,MAAOC,GAAUC,SAASL,EAAcG,EAAOF,MAYnD,QAASW,GAA8BC,EAASC,EAAUC,EAAiBd,EAAWe,GACpF,MAAOD,GAAgB5J,MAAM2J,EAAS9nB,QAAQyM,OAAO,SAAU0a,GAC7D,MAAOF,GAAUgB,eAAed,EAAOU,KAAaG,EAAkBC,eAAed,EAAOU,KAC3F5kB,IAAI,SAAUkkB,GACf,MAAOC,GAAUC,SAASQ,EAASV,EAAOF,MAS9C,QAASiB,GAAmBzB,EAAa0B,GAEvC,MAAOA,KADc1B,EAAY2B,qBACsB,sBAAfD,GAAqD,wBAAfA,GAAuD,qBAAfA,EAGxH,QAASE,GAAoCR,EAASnB,GACpD,GAAI4B,GAAW5B,EAAU6B,cACrBC,EAAc9B,EAAU+B,iBACxBC,EAAab,EAAQc,eAAeL,EAIxC,OAAIE,GAAc,EACTE,EAAWE,iBAAiBJ,EAAc,GAK/CE,EAAWG,YACNH,EAAWE,iBAAiB,GAI9BE,EAAyBjB,EAASS,GAG3C,QAASS,GAAuClB,EAASnB,GACvD,GAAI4B,GAAW5B,EAAU6B,cACrBC,EAAc9B,EAAU+B,iBACxBC,EAAab,EAAQc,eAAeL,EAGxC,OAAIE,GAAcE,EAAWG,YACpBH,EAAWE,iBAAiBJ,GAKjCA,EAAc,EACTE,EAAWE,iBAAiBJ,EAAc,GAI5CM,EAAyBjB,EAASS,GAG3C,QAASQ,GAAyBjB,EAASmB,GACzC,GAAIC,GAAepB,EAAQX,cAAcjlB,UAAUgiB,UAAU,SAAU9f,EAAGpF,GACxE,MAAOA,KAAMiqB,IACZnF,KAAK,GAAGI,UAAU,SAAUkD,EAAOhjB,GACpC,MAAOgjB,GAAM0B,cACZ9F,OAEH,OAAIkG,GAAqBA,EAAaL,iBAAiBK,EAAaJ,YAAc,GAC3EzO,IA9hBT,GAAI8O,GAAU,EAAQ,GAElBC,EAAWD,GAAW,SAAUE,GAAU,IAAK,GAAI1a,GAAI,EAAGA,EAAI/G,UAAUrK,OAAQoR,IAAK,CAAE,GAAI2a,GAAS1hB,UAAU+G,EAAI,KAAK,GAAI3L,KAAOsmB,GAAcnuB,OAAOD,UAAUoiB,eAAe1d,KAAK0pB,EAAQtmB,KAAQqmB,EAAOrmB,GAAOsmB,EAAOtmB,IAAY,MAAOqmB,IAI7OhC,EAAY,EAAQ,KACpBkC,EAAe,EAAQ,KACvBC,EAAoB,EAAQ,KAC5BC,EAAY,EAAQ,IACpBC,EAAiB,EAAQ,IAEzBrP,EAAaoP,EAAUpP,WACvB9B,EAASkR,EAAUlR,OACnBqC,EAAQ6O,EAAU7O,MAGlB+O,GACFC,WAAW,EACXC,eAAgB,KAChB3C,UAAW,KACX4C,aAAc,KACdlD,gBAAgB,EAChBmD,mBAAmB,EACnBhD,oBAAqB,KACrBiD,eAAgB,KAChBlD,wBAAyB,KACzBmD,UAAWrP,IACX+L,UAAW,KACXuD,QAAS,KACTC,UAAWvP,KAGTwP,EAAoB7R,EAAOoR,GAE3B9C,EAAc,WAqXhB,QAASA,GAAYwD,GACnB/D,EAAgBxrB,KAAM+rB,GAEtB/rB,KAAKwvB,WAAaD,EAYpB,MAnYAxD,GAAY0D,YAAc,SAAqBrD,GAC7C,MAAOL,GAAY2D,kBAAkBjB,EAAakB,eAAe,IAAKvD,IAGxEL,EAAY2D,kBAAoB,SAA2BvD,EAAcC,GACvE,GAAIwD,GAAWzD,EAAaE,cAAcnE,QAAQ2H,QAClD,OAAO9D,GAAYzrB,QACjByuB,eAAgB5C,EAChBkD,UAAWvP,IACXqP,UAAWrP,IACXsM,UAAWA,GAAa,KACxBP,UAAW+C,EAAea,YAAYG,MAI1C7D,EAAYzrB,OAAS,SAAgBwvB,GACnC,GAAIf,GAAiBe,EAAOf,eACxB3C,EAAY0D,EAAO1D,UAEnB2D,EAAezB,KAAawB,GAC9BV,QAASlD,EAAmB6C,EAAgB3C,GAC5C4C,aAAcN,EAAkBsB,gBAAgBjB,IAElD,OAAO,IAAIhD,GAAY,GAAIuD,GAAkBS,KAG/ChE,EAAYrf,IAAM,SAAakf,EAAaqE,GAqC1C,MAAO,IAAIlE,GApCDH,EAAYkB,eAAevf,cAAc,SAAU2iB,GAC3D,GAAI/C,GAAoB+C,EAAMxmB,IAAI,aAC9B0iB,EAAYe,CACM,QAAlB8C,EAAI7D,UACNA,EAAY,KACH6D,EAAI7D,YACbA,EAAY6D,EAAI7D,UAGlB,IAAI+D,GAAaF,EAAIlB,gBAAkBnD,EAAYgB,mBAEnD,IAAIR,IAAce,EAAmB,CACnC,GACIiD,GADAhB,EAAUc,EAAMxmB,IAAI,UAaxB,OAVE0mB,GADEhE,GAAae,EACFJ,EAA8BoD,EAAYA,EAAW9D,cAAe+C,EAAShD,EAAWe,GAExFjB,EAAmBiE,EAAY/D,OAG9C8D,GAAM5M,OACJ8I,UAAWA,EACXgD,QAASgB,EACTpE,wBAAyB,OAMzBmE,IADkBvE,EAAYgB,qBAEhCsD,EAAMxjB,IAAI,UAAW+f,EAA2Bb,EAAauE,EAAW9D,cAAe8D,EAAWE,eAAgBjE,IAGpH8D,EAAM5M,MAAM2M,OAMhBlE,EAAY3rB,UAAUgmB,KAAO,WAC3B,MAAOpmB,MAAK8sB,eAAe1G,QAG7B2F,EAAY3rB,UAAUkwB,aAAe,WACnC,MAAOtwB,MAAK8sB,eAAepjB,IAAI,cAGjCqiB,EAAY3rB,UAAUwsB,kBAAoB,WACxC,MAAO5sB,MAAK8sB,eAAepjB,IAAI,mBAGjCqiB,EAAY3rB,UAAUmwB,aAAe,WACnC,MAAOvwB,MAAK8sB,eAAepjB,IAAI,cAGjCqiB,EAAY3rB,UAAUowB,aAAe,WACnC,MAAOxwB,MAAK8sB,eAAepjB,IAAI,cAGjCqiB,EAAY3rB,UAAUqwB,aAAe,WACnC,MAAOzwB,MAAK8sB,eAAepjB,IAAI,cAGjCqiB,EAAY3rB,UAAUswB,aAAe,WACnC,MAAO1wB,MAAK8sB,eAAepjB,IAAI,cAGjCqiB,EAAY3rB,UAAUuwB,oBAAsB,WAC1C,MAAO3wB,MAAK8sB,eAAepjB,IAAI,sBAGjCqiB,EAAY3rB,UAAUwwB,mBAAqB,WACzC,MAAO5wB,MAAK8sB,eAAepjB,IAAI,mBAGjCqiB,EAAY3rB,UAAUywB,2BAA6B,WACjD,MAAO7wB,MAAK8sB,eAAepjB,IAAI,4BAGjCqiB,EAAY3rB,UAAUmtB,kBAAoB,WACxC,MAAOvtB,MAAK8sB,eAAepjB,IAAI,mBAajCqiB,EAAY3rB,UAAU0wB,uBAAyB,WAC7C,MAAO9wB,MAAK8sB,eAAepjB,IAAI,wBAGjCqiB,EAAYgF,uBAAyB,SAAgCnF,EAAaK,GAChF,MAAOF,GAAYrf,IAAIkf,GAAeK,oBAAqBA,KAU7DF,EAAY3rB,UAAU4wB,sBAAwB,WAC5C,GAAIC,GAAWjxB,KAAK8wB,wBACpB,IAAgB,MAAZG,EACF,MAAOA,EAGT,IAAIjE,GAAUhtB,KAAK4sB,oBACff,EAAY7rB,KAAKywB,cAErB,OAAI5E,GAAUqF,cACL1D,EAAoCR,EAASnB,GAG/CqC,EAAuClB,EAASnB,IAGzDE,EAAY3rB,UAAU+wB,aAAe,SAAsBC,GACzD,MAAOpxB,MAAK8sB,eAAezE,OAAO,UAAW+I,KAG/CrF,EAAY3rB,UAAUixB,4BAA8B,WAClD,GAAIzB,GAAW5vB,KAAK4sB,oBAAoBP,cAAcnE,QAAQ2H,QAC9D,OAAO7vB,MAAKywB,eAAea,cAAc1B,EAAU,EAAG,IAGxD7D,EAAY3rB,UAAUmxB,0BAA4B,WAChD,GAAIvE,GAAUhtB,KAAK4sB,oBACfK,EAAWD,EAAQX,cACnBzD,EAAOqE,EAASrE,OAChBplB,EAAMolB,EAAKoF,WACf,OAAOhuB,MAAKywB,eAAea,cAAc1I,EAAKiH,SAAUrsB,EAAKA,IAG/DuoB,EAAY3rB,UAAU4vB,gBAAkB,WACtC,MAAOhwB,MAAK8sB,eAAepjB,IAAI,iBAajCqiB,EAAYyF,gBAAkB,SAAyB5F,EAAaC,GAClE,MAAOF,GAAgBC,EAAaC,GAAW,IAiBjDE,EAAYD,eAAiB,SAAwBF,EAAaC,GAIhE,MAHKA,GAAU4F,gBACb5F,EAAYA,EAAUnf,IAAI,YAAY,IAEjCif,EAAgBC,EAAaC,GAAW,IAQjDE,EAAY2F,mBAAqB,SAA4B9F,GAC3D,GAAIoB,GAAUpB,EAAYgB,oBACtB+E,EAAY3E,EAAQ4E,eACpBC,EAAUF,EAAU9B,SACpBptB,EAASkvB,EAAU3D,WAEvB,OAAOjC,GAAYyF,gBAAgB5F,EAAa,GAAIgD,IAClDkD,UAAWD,EACXE,aAActvB,EACduvB,SAAUH,EACVI,YAAaxvB,EACbyvB,YAAY,MAWhBnG,EAAYoG,eAAiB,SAAwBvG,GACnD,GAAIwG,GAAqBrG,EAAY2F,mBAAmB9F,EACxD,OAAOG,GAAYD,eAAesG,EAAoBA,EAAmB3B,iBAU3E1E,EAAY5a,KAAO,SAAcya,EAAaO,EAAcmB,GAC1D,GAAI1B,EAAYgB,sBAAwBT,EACtC,MAAOP,EAGT,IAAIE,GAAgC,sBAAfwB,EACjB0B,EAAeN,EAAkBsB,gBAAgB7D,EAAcP,EAAYoE,kBAE/E,KAAKpE,EAAY0E,eACf,MAAOvE,GAAYrf,IAAIkf,GACrBmD,eAAgB5C,EAChB6C,aAAcA,EACdE,eAAgB5B,EAChBzB,UAAWM,EAAakG,oBACxBvG,eAAgBA,EAChBG,oBAAqB,MAIzB,IAAIJ,GAAYD,EAAY6E,eACxB1B,EAAiBnD,EAAYgB,oBAC7ByC,EAAYzD,EAAY2E,eACxBJ,EAAahE,CAEbN,KAAckD,EAAesD,qBAAuBhF,EAAmBzB,EAAa0B,IACtF+B,EAAYA,EAAUle,KAAK4d,GAC3BoB,EAAaA,EAAWzjB,IAAI,kBAAmBmf,IACvB,sBAAfyB,GAAqD,wBAAfA,GAAuD,qBAAfA,IAEvF6C,EAAaA,EAAWzjB,IAAI,kBAAmBqiB,EAAeuD,sBAGhE,IAAIrG,GAAsBL,EAAYkF,0BAKW,KAFtB,eAAgB,oBAAqB,eAExCpO,QAAQ4K,KAC9BrB,EAAsB,KAGxB,IAAIsG,IACFxD,eAAgBoB,EAChBnB,aAAcA,EACdK,UAAWA,EACXF,UAAWrP,IACXoP,eAAgB5B,EAChBzB,UAAWM,EAAakG,oBACxBvG,eAAgBA,EAChBG,oBAAqBA,EAGvB,OAAOF,GAAYrf,IAAIkf,EAAa2G,IAStCxG,EAAYyG,KAAO,SAAc5G,GAC/B,IAAKA,EAAY0E,eACf,MAAO1E,EAGT,IAAIyD,GAAYzD,EAAY2E,eACxBkC,EAAoBpD,EAAUnJ,MAClC,KAAKuM,EACH,MAAO7G,EAGT,IAAImD,GAAiBnD,EAAYgB,oBAC7BoC,EAAeN,EAAkBsB,gBAAgByC,EAAmB7G,EAAYoE,kBAEpF,OAAOjE,GAAYrf,IAAIkf,GACrBmD,eAAgB0D,EAChBzD,aAAcA,EACdK,UAAWA,EAAUzf,QACrBuf,UAAWvD,EAAY4E,eAAerf,KAAK4d,GAC3CjD,gBAAgB,EAChBG,oBAAqB,KACrBiD,eAAgB,OAChBlD,wBAAyB,KACzBH,UAAWkD,EAAeuD,wBAU9BvG,EAAY2G,KAAO,SAAc9G,GAC/B,IAAKA,EAAY0E,eACf,MAAO1E,EAGT,IAAIuD,GAAYvD,EAAY4E,eACxBiC,EAAoBtD,EAAUjJ,MAClC,KAAKuM,EACH,MAAO7G,EAGT,IAAImD,GAAiBnD,EAAYgB,oBAC7BoC,EAAeN,EAAkBsB,gBAAgByC,EAAmB7G,EAAYoE,kBAEpF,OAAOjE,GAAYrf,IAAIkf,GACrBmD,eAAgB0D,EAChBzD,aAAcA,EACdK,UAAWzD,EAAY2E,eAAepf,KAAK4d,GAC3CI,UAAWA,EAAUvf,QACrBkc,gBAAgB,EAChBG,oBAAqB,KACrBiD,eAAgB,OAChBlD,wBAAyB,KACzBH,UAAW4G,EAAkBJ,uBAoBjCtG,EAAY3rB,UAAU0sB,aAAe,WACnC,MAAO9sB,MAAKwvB,YAGPzD,IA0HTtsB,GAAOI,QAAUksB,GJm9JT,CACA,CAEF,SAAUtsB,EAAQI,EAASF,GAEjC,YKz/KA,IAAIgzB,GAAoB,EAAQ,IAC5BC,EAA0B,EAAQ,KAClCC,EAAoB,EAAQ,IAC5BlE,EAAY,EAAQ,IAEpBmE,EAA4B,EAAQ,KACpCC,EAA2B,EAAQ,KACnCC,EAA0B,EAAQ,KAClCC,EAAiC,EAAQ,KACzCC,EAA6B,EAAQ,KACrCjpB,EAAY,EAAQ,IACpBkpB,EAA6B,EAAQ,KACrCC,EAAwB,EAAQ,KAChCC,EAA8B,EAAQ,KACtCC,EAA2B,EAAQ,KAEnC/T,EAAaoP,EAAUpP,WAavBgU,GACFC,YAAa,SAAqBrH,EAAcsH,EAAgBC,EAAMC,EAAaC,GACjF,GAAIC,GAAkBT,EAAsBjH,EAAcsH,GACtDK,EAAcT,EAA4BQ,EAAiBJ,GAE3DM,EAAYpB,EAAkBryB,QAChC0zB,MAAOL,GAAepU,IACtB0U,OAAQL,GAAa,MAGvB,OAAOV,GAA2BY,EAAaA,EAAYzB,oBAAqBqB,EAAMK,IAGxFG,WAAY,SAAoB/H,EAAcgI,EAAaT,EAAMC,EAAaC,GAE5E,MADCO,GAAYjD,eAA+HjnB,GAAU,GAC/IspB,EAAcC,YAAYrH,EAAcgI,EAAaT,EAAMC,EAAaC,IAGjFQ,SAAU,SAAkBjI,EAAckI,EAAcF,GACtD,GAAIG,GAAgBtB,EAAwB7G,EAAckI,GAEtDE,EAAehB,EAAciB,YAAYrI,EAAckI,EAAc,WAEzE,OAAOd,GAAckB,oBAAoBF,EAAcJ,EAAaG,IAGtEG,oBAAqB,SAA6BtI,EAAcgI,EAAaO,GAC3E,GAAIb,GAAkBT,EAAsBjH,EAAcgI,GACtDL,EAAcT,EAA4BQ,EAAiBM,EAE/D,OAAOlB,GAA+Ba,EAAaA,EAAYzB,oBAAqBqC,IAGtFF,YAAa,SAAqBrI,EAAcwI,EAAeC,GAC7D,GAAInH,OAAW,GACXoH,MAAS,GACThH,MAAa,GACbiH,MAAW,EACXH,GAAcI,kBAChBJ,EAAgBA,EAAcrR,OAC5BwO,UAAW6C,EAAcK,cACzBjD,aAAc4C,EAAcM,iBAC5BjD,SAAU2C,EAAcO,eACxBjD,YAAa0C,EAAcQ,kBAC3BjD,YAAY,KAGhBzE,EAAWkH,EAAcO,eACzBL,EAASF,EAAcK,cACvBnH,EAAa1B,EAAa2B,eAAeL,GACzCqH,EAAW3I,EAAa2B,eAAe+G,EACvC,IAAIlH,GAAcgH,EAAc/G,iBAC5BwH,EAAYT,EAAcU,eAE1BC,EAAiBzH,EAAW0H,YAAY5H,GACxC6H,EAAeV,EAASS,YAAYH,EAAY,EAIpD,IAAI3H,IAAaoH,GACXS,GAAkBA,IAAmBE,EAAc,CACrD,GAAIC,GAAwB1C,EAAyB5G,EAAakE,eAAgBxC,EAAYiH,EAAUH,EAAeC,EACvH,OAAOvB,GAA4BlH,EAAcsJ,GAGrD,GAAIC,GAAuBf,CACvB9B,GAAkB8C,oCAGpBD,EAAuB3C,EAAyB5G,EAAakE,eAAgBxC,EAAYiH,EAAUH,EAAeC,GAGpH,IAAIf,GAAkBT,EAAsBjH,EAAcuJ,EAC1D,OAAOrC,GAA4BQ,EAAiB6B,IAGtDE,WAAY,SAAoBzJ,EAAc0J,GAC5C,GAAIhC,GAAkBT,EAAsBjH,EAAc0J,GACtD/B,EAAcT,EAA4BQ,EAAiBgC,EAE/D,OAAOvC,GAAyBQ,EAAaA,EAAYzB,sBAG3DyD,iBAAkB,SAA0B3J,EAAc0J,EAAgBlC,GACxE,MAAOf,GAAwB9T,IAAIqN,EAAc0J,EAAgBlC,IAGnEoC,kBAAmB,SAA2B5J,EAAc0J,EAAgBlC,GAC1E,MAAOf,GAAwBpgB,OAAO2Z,EAAc0J,EAAgBlC,IAGtEqC,aAAc,SAAsB7J,EAAc0J,EAAgBI,GAChE,MAAO9C,GAA2BhH,EAAc0J,EAAgB,SAAUvJ,GACxE,MAAOA,GAAMhJ,OAAQrf,KAAMgyB,EAAWta,MAAO,OAIjDua,aAAc,SAAsB/J,EAAc0J,EAAgBM,GAChE,MAAOhD,GAA2BhH,EAAc0J,EAAgB,SAAUvJ,GACxE,MAAOA,GAAMhJ,OAAQ8S,KAAMD,OAI/BE,eAAgB,SAAwBlK,EAAc0J,EAAgBM,GACpE,MAAOhD,GAA2BhH,EAAc0J,EAAgB,SAAUvJ,GACxE,MAAOA,GAAMhJ,OAAQ8S,KAAM9J,EAAMgK,UAAUhT,MAAM6S,QAIrDI,YAAa,SAAqBpK,EAAc0J,EAAgBjC,GAC9D,GAAIC,GAAkBT,EAAsBjH,EAAc0J,EAC1D,OAAO/C,GAA0Be,EAAiBgC,EAAgBjC,IAItEn0B,GAAOI,QAAU0zB,GL6gLX,SAAU9zB,EAAQI,EAASF,GAEjC,YM/pLA,SAAS6rB,GAAgBC,EAAUC,GAAe,KAAMD,YAAoBC,IAAgB,KAAM,IAAI1kB,WAAU,qCAEhH,QAASwvB,GAA2BC,EAAM3xB,GAAQ,IAAK2xB,EAAQ,KAAM,IAAIC,gBAAe,4DAAgE,QAAO5xB,GAAyB,gBAATA,IAAqC,kBAATA,GAA8B2xB,EAAP3xB,EAElO,QAAS6xB,GAAUC,EAAUz2B,GAAc,GAA0B,kBAAfA,IAA4C,OAAfA,EAAuB,KAAM,IAAI6G,WAAU,iEAAoE7G,GAAey2B,GAASx2B,UAAYC,OAAOC,OAAOH,GAAcA,EAAWC,WAAaG,aAAeE,MAAOm2B,EAAUC,YAAY,EAAOC,UAAU,EAAMC,cAAc,KAAe52B,IAAYE,OAAO22B,eAAiB32B,OAAO22B,eAAeJ,EAAUz2B,GAAcy2B,EAASK,UAAY92B,GAEje,GAAI+2B,GAAW,EAAQ,IACnB9pB,EAAM8pB,EAAS9pB,IACfmS,EAAa2X,EAAS3X,WACtB9B,EAASyZ,EAASzZ,OAMlB6B,EAAYC,IAEZsP,GACFmF,MAAO1U,EACP2U,OAAQ,MAGNkD,EAA0B1Z,EAAOoR,GAEjC8D,EAAoB,SAAUyE,GAGhC,QAASzE,KAGP,MAFAnH,GAAgBxrB,KAAM2yB,GAEf6D,EAA2Bx2B,KAAMo3B,EAAsBvqB,MAAM7M,KAAM8M,YA6D5E,MAlEA6pB,GAAUhE,EAAmByE,GAQ7BzE,EAAkBvyB,UAAUi3B,SAAW,WACrC,MAAOr3B,MAAK0J,IAAI,UAGlBipB,EAAkBvyB,UAAUk3B,UAAY,WACtC,MAAOt3B,MAAK0J,IAAI,WAGlBipB,EAAkBvyB,UAAUm3B,SAAW,SAAkBvD,GACvD,MAAOh0B,MAAKq3B,WAAW5e,SAASub,IAGlCrB,EAAkB6E,WAAa,SAAoBnZ,EAAQ2V,GACzD,GAAIyD,GAAYpZ,EAAO3R,IAAI,QAAS2R,EAAOgZ,WAAWvY,IAAIkV,GAC1D,OAAOrB,GAAkBryB,OAAOm3B,IAGlC9E,EAAkB+E,YAAc,SAAqBrZ,EAAQ2V,GAC3D,GAAI2D,GAAetZ,EAAO3R,IAAI,QAAS2R,EAAOgZ,WAAW7kB,OAAOwhB,GAChE,OAAOrB,GAAkBryB,OAAOq3B,IAGlChF,EAAkB4D,YAAc,SAAqBlY,EAAQuV,GAC3D,GAAIgE,GAAavZ,EAAOiZ,cAAgB1D,EAAYvV,EAASA,EAAO3R,IAAI,SAAUknB,EAClF,OAAOjB,GAAkBryB,OAAOs3B,IAWlCjF,EAAkBryB,OAAS,SAAgBwvB,GACzC,IAAKA,EACH,MAAO+H,EAGT,IAAIC,IACF9D,MAAO1U,EACP2U,OAAQ,MAIN8D,EAAY3qB,EAAI0qB,GAAexU,MAAMwM,GAErCxe,EAAW0mB,EAAKtuB,IAAIquB,EACxB,IAAIzmB,EACF,MAAOA,EAGT,IAAI2mB,GAAe,GAAItF,GAAkBoF,EAEzC,OADAC,GAAOA,EAAKtrB,IAAIqrB,EAAWE,GACpBA,GAGFtF,GACPwE,GAEEU,EAAQ,GAAIlF,GACZqF,EAAO5qB,IAAMA,EAAIyhB,GAAgBgJ,IAErClF,GAAkBkF,MAAQA,EAE1Bp4B,EAAOI,QAAU8yB,GNmrLX,SAAUlzB,EAAQI,EAASF,GAEjC,YOlxLA,SAAS6rB,GAAgBC,EAAUC,GAAe,KAAMD,YAAoBC,IAAgB,KAAM,IAAI1kB,WAAU,qCAEhH,QAASwvB,GAA2BC,EAAM3xB,GAAQ,IAAK2xB,EAAQ,KAAM,IAAIC,gBAAe,4DAAgE,QAAO5xB,GAAyB,gBAATA,IAAqC,kBAATA,GAA8B2xB,EAAP3xB,EAElO,QAAS6xB,GAAUC,EAAUz2B,GAAc,GAA0B,kBAAfA,IAA4C,OAAfA,EAAuB,KAAM,IAAI6G,WAAU,iEAAoE7G,GAAey2B,GAASx2B,UAAYC,OAAOC,OAAOH,GAAcA,EAAWC,WAAaG,aAAeE,MAAOm2B,EAAUC,YAAY,EAAOC,UAAU,EAAMC,cAAc,KAAe52B,IAAYE,OAAO22B,eAAiB32B,OAAO22B,eAAeJ,EAAUz2B,GAAcy2B,EAASK,UAAY92B,GAEje,GAAIwyB,GAAoB,EAAQ,IAC5BhE,EAAY,EAAQ,IAEpBuJ,EAAsB,EAAQ,IAE9B9kB,EAAOub,EAAUvb,KACjBhG,EAAMuhB,EAAUvhB,IAChBmS,EAAaoP,EAAUpP,WACvB9B,EAASkR,EAAUlR,OACnB7T,EAAS+kB,EAAU/kB,OAGnB0V,EAAYC,IAEZsP,GACFsJ,OAAQ,KACRC,cAAehlB,IACfgjB,KAAMhpB,IACNuO,MAAO,EACPzT,IAAK,GACLwrB,KAAM,GACNzvB,KAAM,WACNo0B,SAAUjlB,IACVklB,YAAa,KACbC,YAAa,MAGXC,EAAiB,SAAwBC,EAAOC,GAClD,MAAOD,GAAMpB,aAAeqB,EAAMrB,YAGhCsB,EAAkB,SAAyBF,EAAOC,GACpD,MAAOD,GAAMnB,cAAgBoB,EAAMpB,aAGjCsB,EAAwB,SAA+B9I,GACzD,IAAKA,EACH,MAAOA,EAGT,IAAIsI,GAAgBtI,EAAOsI,cACvB1E,EAAO5D,EAAO4D,IAOlB,OAJIA,KAAS0E,IACXtI,EAAOsI,cAAgBhlB,EAAKxJ,EAAO+oB,EAAkBkF,MAAOnE,EAAKjxB,UAG5DqtB,GAGL+I,EAAmB,SAAUC,GAG/B,QAASD,KACP,GAAIE,GAAQjsB,UAAUrK,OAAS,OAAsBK,KAAjBgK,UAAU,GAAmBA,UAAU,GAAK+hB,CAIhF,OAFArD,GAAgBxrB,KAAM64B,GAEfrC,EAA2Bx2B,KAAM84B,EAAQh0B,KAAK9E,KAAM44B,EAAsBG,KAiEnF,MAxEApC,GAAUkC,EAAkBC,GAU5BD,EAAiBz4B,UAAUyvB,OAAS,WAClC,MAAO7vB,MAAK0J,IAAI,QAGlBmvB,EAAiBz4B,UAAU44B,QAAU,WACnC,MAAOh5B,MAAK0J,IAAI,SAGlBmvB,EAAiBz4B,UAAU64B,QAAU,WACnC,MAAOj5B,MAAK0J,IAAI,SAGlBmvB,EAAiBz4B,UAAU84B,iBAAmB,WAC5C,MAAOl5B,MAAK0J,IAAI,kBAGlBmvB,EAAiBz4B,UAAU4tB,UAAY,WACrC,MAAOhuB,MAAKi5B,UAAUx2B,QAGxBo2B,EAAiBz4B,UAAU+4B,SAAW,WACpC,MAAOn5B,MAAK0J,IAAI,UAGlBmvB,EAAiBz4B,UAAUk2B,QAAU,WACnC,MAAOt2B,MAAK0J,IAAI,SAGlBmvB,EAAiBz4B,UAAU2tB,iBAAmB,SAA0B1rB,GACtE,GAAI0xB,GAAY/zB,KAAKk5B,mBAAmBxvB,IAAIrH,EAC5C,OAAO0xB,GAAYA,EAAUsD,WAAa/X,GAG5CuZ,EAAiBz4B,UAAUm1B,YAAc,SAAqBlzB,GAC5D,GAAI0xB,GAAY/zB,KAAKk5B,mBAAmBxvB,IAAIrH,EAC5C,OAAO0xB,GAAYA,EAAUuD,YAAc,MAG7CuB,EAAiBz4B,UAAUg5B,aAAe,WACxC,MAAOp5B,MAAK0J,IAAI,aAGlBmvB,EAAiBz4B,UAAUi5B,aAAe,WACxC,MAAOr5B,MAAK0J,IAAI,WAGlBmvB,EAAiBz4B,UAAUk5B,kBAAoB,WAC7C,MAAOt5B,MAAK0J,IAAI,gBAGlBmvB,EAAiBz4B,UAAUm5B,kBAAoB,WAC7C,MAAOv5B,MAAK0J,IAAI,gBAGlBmvB,EAAiBz4B,UAAUo5B,gBAAkB,SAAyBC,EAAUC,GAC9ExB,EAAoBl4B,KAAKk5B,mBAAoBV,EAAgBiB,EAAUC,IAGzEb,EAAiBz4B,UAAUu5B,iBAAmB,SAA0BF,EAAUC,GAChFxB,EAAoBl4B,KAAKk5B,mBAAoBP,EAAiBc,EAAUC,IAGnEb,GACPpb,EAAOoR,GAETpvB,GAAOI,QAAUg5B,GP4yLX,SAAUp5B,EAAQI,EAASF,GAEjC,YQ77LA,IAAIi6B,GAAa,SAAoB/nB,GACnC,GAAS,MAALA,EACF,MAAOA,EAET,MAAM,IAAIzH,OAAM,oCAGlB3K,GAAOI,QAAU+5B,GR48LT,CAEF,SAAUn6B,EAAQI,EAASF,GAEjC,YSz8LA,SAASk6B,GAAQlc,EAAMmc,EAASC,EAAOC,GAErC,GAAIrc,IAASoc,EACX,OAAO,CAIT,KAAKA,EAAME,WAAWtc,GACpB,OAAO,CAIT,IAAIuc,GAAQH,EAAMjkB,MAAM6H,EAAKlb,OAC7B,SAAIq3B,IACFI,EAAQF,EAAaA,EAAWE,GAASA,EAClCC,EAAaxQ,SAASuQ,EAAOJ,IAexC,QAASM,GAAyBN,GAChC,MAAmC,YAA/BO,EAAcC,aACTR,EAAQxO,QAAQ,SAAU,IAG5BwO,EAlDT,GAAIO,GAAgB,EAAQ,KACxBF,EAAe,EAAQ,KAEvBI,EAAY,EAAQ,KACpBC,EAAoB,EAAQ,KAqD5BC,GA4CFC,UAAW,SAAmBX,GAC5B,MAAOF,GAAQQ,EAAcM,YAAaN,EAAcO,mBAAoBb,IAY9Ec,sBAAuB,SAA+Bd,GACpD,MAAOF,GAAQQ,EAAcS,oBAAqB,KAAMf,IA4B1DgB,SAAU,SAAkBhB,GAC1B,MAAOF,GAAQQ,EAAcW,WAAY,KAAMjB,IA0BjDkB,SAAU,SAAkBlB,GAC1B,MAAOF,GAAQQ,EAAca,WAAYb,EAAcc,cAAepB,IAuCxEqB,WAAY,SAAoBrB,GAC9B,MAAOF,GAAQQ,EAAcC,aAAcD,EAAcgB,oBAAqBtB,EAAOK,IAYvFkB,uBAAwB,SAAgCvB,GACtD,MAAOF,GAAQQ,EAAckB,qBAAsB,KAAMxB,IAI7Dt6B,GAAOI,QAAU06B,EAAUE,EAAWD,ITs+L9B,CACA,CAEF,SAAU/6B,EAAQI,EAASF,GAEjC,YUvsMA,SAAS67B,KAEP,IADA,GAAItzB,OAAM,OACKpF,KAARoF,GAAqBuzB,EAASjZ,eAAeta,KAASwzB,OAAOxzB,IAClEA,EAAM3F,KAAKugB,MAAMvgB,KAAKo5B,SAAWC,GAAYhwB,SAAS,GAGxD,OADA6vB,GAASvzB,IAAO,EACTA,EATT,GAAIuzB,MACAG,EAAar5B,KAAKs5B,IAAI,EAAG,GAW7Bp8B,GAAOI,QAAU27B,GV8tMX,SAAU/7B,EAAQI,EAASF,GAEjC,YW5uMA,IAAIkzB,GAAoB,EAAQ,IAEhCpzB,GAAOI,QAAUgzB,GX+vMT,CACA,CACA,CACA,CAEF,SAAUpzB,EAAQI,EAASF,GAEjC,YYxwMA,SAAS6rB,GAAgBC,EAAUC,GAAe,KAAMD,YAAoBC,IAAgB,KAAM,IAAI1kB,WAAU,qCAEhH,QAASwvB,GAA2BC,EAAM3xB,GAAQ,IAAK2xB,EAAQ,KAAM,IAAIC,gBAAe,4DAAgE,QAAO5xB,GAAyB,gBAATA,IAAqC,kBAATA,GAA8B2xB,EAAP3xB,EAElO,QAAS6xB,GAAUC,EAAUz2B,GAAc,GAA0B,kBAAfA,IAA4C,OAAfA,EAAuB,KAAM,IAAI6G,WAAU,iEAAoE7G,GAAey2B,GAASx2B,UAAYC,OAAOC,OAAOH,GAAcA,EAAWC,WAAaG,aAAeE,MAAOm2B,EAAUC,YAAY,EAAOC,UAAU,EAAMC,cAAc,KAAe52B,IAAYE,OAAO22B,eAAiB32B,OAAO22B,eAAeJ,EAAUz2B,GAAcy2B,EAASK,UAAY92B,GA+Gje,QAASq4B,GAAeC,EAAOC,GAC7B,MAAOD,GAAMpB,aAAeqB,EAAMrB,WAGpC,QAASsB,GAAgBF,EAAOC,GAC9B,MAAOD,GAAMnB,cAAgBoB,EAAMpB,YAlHrC,GAAI3E,GAAoB,EAAQ,IAC5BhE,EAAY,EAAQ,IAEpBuJ,EAAsB,EAAQ,IAE9B9kB,EAAOub,EAAUvb,KACjBhG,EAAMuhB,EAAUvhB,IAChBmS,EAAaoP,EAAUpP,WACvB9B,EAASkR,EAAUlR,OACnB7T,EAAS+kB,EAAU/kB,OAGnB0V,EAAYC,IAEZsP,GACF3mB,IAAK,GACLjE,KAAM,WACNyvB,KAAM,GACN0E,cAAehlB,IACfuI,MAAO,EACPya,KAAMhpB,KAGJ0uB,EAAqBre,EAAOoR,GAE5B+J,EAAwB,SAA+B9I,GACzD,IAAKA,EACH,MAAOA,EAGT,IAAIsI,GAAgBtI,EAAOsI,cACvB1E,EAAO5D,EAAO4D,IAOlB,OAJIA,KAAS0E,IACXtI,EAAOsI,cAAgBhlB,EAAKxJ,EAAO+oB,EAAkBkF,MAAOnE,EAAKjxB,UAG5DqtB,GAGLiM,EAAe,SAAUC,GAG3B,QAASD,GAAajM,GAGpB,MAFAtE,GAAgBxrB,KAAM+7B,GAEfvF,EAA2Bx2B,KAAMg8B,EAAoBl3B,KAAK9E,KAAM44B,EAAsB9I,KA2D/F,MAhEA6G,GAAUoF,EAAcC,GAQxBD,EAAa37B,UAAUyvB,OAAS,WAC9B,MAAO7vB,MAAK0J,IAAI,QAGlBqyB,EAAa37B,UAAU44B,QAAU,WAC/B,MAAOh5B,MAAK0J,IAAI,SAGlBqyB,EAAa37B,UAAU64B,QAAU,WAC/B,MAAOj5B,MAAK0J,IAAI,SAGlBqyB,EAAa37B,UAAU84B,iBAAmB,WACxC,MAAOl5B,MAAK0J,IAAI,kBAGlBqyB,EAAa37B,UAAU4tB,UAAY,WACjC,MAAOhuB,MAAKi5B,UAAUx2B,QAGxBs5B,EAAa37B,UAAU+4B,SAAW,WAChC,MAAOn5B,MAAK0J,IAAI,UAGlBqyB,EAAa37B,UAAUk2B,QAAU,WAC/B,MAAOt2B,MAAK0J,IAAI,SAGlBqyB,EAAa37B,UAAU2tB,iBAAmB,SAA0B1rB,GAClE,GAAI0xB,GAAY/zB,KAAKk5B,mBAAmBxvB,IAAIrH,EAC5C,OAAO0xB,GAAYA,EAAUsD,WAAa/X,GAG5Cyc,EAAa37B,UAAUm1B,YAAc,SAAqBlzB,GACxD,GAAI0xB,GAAY/zB,KAAKk5B,mBAAmBxvB,IAAIrH,EAC5C,OAAO0xB,GAAYA,EAAUuD,YAAc,MAQ7CyE,EAAa37B,UAAUo5B,gBAAkB,SAAyBC,EAAUC,GAC1ExB,EAAoBl4B,KAAKk5B,mBAAoBV,EAAgBiB,EAAUC,IAQzEqC,EAAa37B,UAAUu5B,iBAAmB,SAA0BF,EAAUC,GAC5ExB,EAAoBl4B,KAAKk5B,mBAAoBP,EAAiBc,EAAUC,IAGnEqC,GACPD,EAUFr8B,GAAOI,QAAUk8B,GZ4xMX,SAAUt8B,EAAQI,EAASF,GAEjC,Yap4MA,SAASs8B,GAA2BC,GAClC,MAAOC,IAAwBD,GAAYA,GAAYE,EAYzD,QAASC,GAAgBC,EAAKn5B,GAE5B,GADE,GAAKA,GAASA,EAAQm5B,EAAI75B,QAAmJwH,GAAU,GACrL9G,EAAQ,IAAMm5B,EAAI75B,OACpB,OAAO,CAET,IAAIylB,GAAQoU,EAAIrwB,WAAW9I,GACvBo5B,EAASD,EAAIrwB,WAAW9I,EAAQ,EACpC,OAAOg5B,IAAwBjU,GAASA,GAASsU,GAAsBC,GAAuBF,GAAUA,GAAUH,EAOpH,QAASM,GAAiBJ,GACxB,MAAOK,GAAsBC,KAAKN,GAqBpC,QAASO,GAAeP,EAAKQ,GAC3B,MAAO,GAAIb,EAA2BK,EAAIrwB,WAAW6wB,IASvD,QAASC,GAAOT,GAEd,IAAKI,EAAiBJ,GACpB,MAAOA,GAAI75B,MAIb,KAAK,GADDH,GAAM,EACDw6B,EAAM,EAAGA,EAAMR,EAAI75B,OAAQq6B,GAAOD,EAAeP,EAAKQ,GAC7Dx6B,GAEF,OAAOA,GAYT,QAAS06B,GAAOV,EAAKhyB,EAAO7H,GAK1B,GAJA6H,EAAQA,GAAS,EACjB7H,MAAoBK,KAAXL,EAAuBsH,IAAWtH,GAAU,GAGhDi6B,EAAiBJ,GACpB,MAAOA,GAAIU,OAAO1yB,EAAO7H,EAI3B,IAAIM,GAAOu5B,EAAI75B,MACf,IAAIM,GAAQ,GAAKuH,EAAQvH,GAAQN,GAAU,EACzC,MAAO,EAIT,IAAIw6B,GAAO,CACX,IAAI3yB,EAAQ,EAAG,CACb,KAAOA,EAAQ,GAAK2yB,EAAOl6B,EAAMuH,IAC/B2yB,GAAQJ,EAAeP,EAAKW,EAE9B,IAAIA,GAAQl6B,EACV,MAAO,OAEJ,IAAIuH,EAAQ,EAAG,CACpB,IAAK2yB,EAAOl6B,EAAMuH,EAAQ,GAAK,EAAI2yB,EAAM3yB,IACvC2yB,GAAQJ,EAAeP,EAAKW,EAAO,EAEjCA,GAAO,IACTA,EAAO,GAKX,GAAIC,GAAOn6B,CACX,IAAIN,EAASM,EACX,IAAKm6B,EAAOD,EAAMx6B,EAAS,GAAKy6B,EAAOn6B,EAAMN,IAC3Cy6B,GAAQL,EAAeP,EAAKY,EAIhC,OAAOZ,GAAIa,UAAUF,EAAMC,GAY7B,QAASC,GAAUb,EAAKhyB,EAAO9G,GAC7B8G,EAAQA,GAAS,EACjB9G,MAAcV,KAARU,EAAoBuG,IAAWvG,GAAO,EAExC8G,EAAQ,IACVA,EAAQ,GAEN9G,EAAM,IACRA,EAAM,EAGR,IAAIf,GAASF,KAAKiI,IAAIhH,EAAM8G,EAE5B,OADAA,GAAQA,EAAQ9G,EAAM8G,EAAQ9G,EACvBw5B,EAAOV,EAAKhyB,EAAO7H,GAS5B,QAAS26B,GAAcd,GAErB,IAAK,GADDe,MACKP,EAAM,EAAGA,EAAMR,EAAI75B,OAAQq6B,GAAOD,EAAeP,EAAKQ,GAC7DO,EAAWlsB,KAAKmrB,EAAIgB,YAAYR,GAElC,OAAOO,GA/KT,GAAIpzB,GAAY,EAAQ,IAIpBkyB,EAAuB,MACvBK,EAAqB,MACrBC,EAAsB,MACtBL,EAAoB,MACpBO,EAAwB,kBA0KxBY,GACFH,cAAeA,EACfP,eAAgBA,EAChBH,iBAAkBA,EAClBT,2BAA4BA,EAC5BI,gBAAiBA,EACjBU,OAAQA,EACRI,UAAWA,EACXH,OAAQA,EAGVv9B,GAAOI,QAAU09B,Gb46MT,CACA,CACA,CACA,CACA,CAEF,SAAU99B,EAAQI,EAASF,GAEjC,YcxnNA,SAAS6rB,GAAgBC,EAAUC,GAAe,KAAMD,YAAoBC,IAAgB,KAAM,IAAI1kB,WAAU,qCAEhH,QAASwvB,GAA2BC,EAAM3xB,GAAQ,IAAK2xB,EAAQ,KAAM,IAAIC,gBAAe,4DAAgE,QAAO5xB,GAAyB,gBAATA,IAAqC,kBAATA,GAA8B2xB,EAAP3xB,EAElO,QAAS6xB,GAAUC,EAAUz2B,GAAc,GAA0B,kBAAfA,IAA4C,OAAfA,EAAuB,KAAM,IAAI6G,WAAU,iEAAoE7G,GAAey2B,GAASx2B,UAAYC,OAAOC,OAAOH,GAAcA,EAAWC,WAAaG,aAAeE,MAAOm2B,EAAUC,YAAY,EAAOC,UAAU,EAAMC,cAAc,KAAe52B,IAAYE,OAAO22B,eAAiB32B,OAAO22B,eAAeJ,EAAUz2B,GAAcy2B,EAASK,UAAY92B,GAEje,GAAIwuB,GAAY,EAAQ,IAEpBlR,EAASkR,EAAUlR,OAGnBoR,GACFiD,UAAW,GACXC,aAAc,EACdC,SAAU,GACVC,YAAa,EACbC,YAAY,EACZsL,UAAU,GAGRC,EAAuBhgB,EAAOoR,GAE9BD,EAAiB,SAAU8O,GAG7B,QAAS9O,KAGP,MAFApD,GAAgBxrB,KAAM4uB,GAEf4H,EAA2Bx2B,KAAM09B,EAAsB7wB,MAAM7M,KAAM8M,YAuF5E,MA5FA6pB,GAAU/H,EAAgB8O,GAQ1B9O,EAAexuB,UAAUu9B,UAAY,WACnC,MAAO,WAAa39B,KAAKk1B,eAAiB,IAAMl1B,KAAKm1B,kBAAoB,YAAmBn1B,KAAKg1B,cAAgB,IAAMh1B,KAAKi1B,iBAAmB,kBAAyB2I,OAAO59B,KAAK+0B,iBAAmB,gBAAuB6I,OAAO59B,KAAKyxB,gBAG5O7C,EAAexuB,UAAU80B,aAAe,WACtC,MAAOl1B,MAAK0J,IAAI,cAGlBklB,EAAexuB,UAAU+0B,gBAAkB,WACzC,MAAOn1B,MAAK0J,IAAI,iBAGlBklB,EAAexuB,UAAU40B,YAAc,WACrC,MAAOh1B,MAAK0J,IAAI,aAGlBklB,EAAexuB,UAAU60B,eAAiB,WACxC,MAAOj1B,MAAK0J,IAAI,gBAGlBklB,EAAexuB,UAAU20B,cAAgB,WACvC,MAAO/0B,MAAK0J,IAAI,eAGlBklB,EAAexuB,UAAUqxB,YAAc,WACrC,MAAOzxB,MAAK0J,IAAI,aASlBklB,EAAexuB,UAAUkxB,cAAgB,SAAuBF,EAAU9mB,EAAO9G,GAC/E,GAAIsuB,GAAY9xB,KAAKk1B,eACjBlD,EAAWhyB,KAAKg1B,aAEpB,IAAIlD,IAAcE,GAAYF,IAAcV,EAAU,CACpD,GAAIyM,GAAiB79B,KAAK4tB,gBAE1B,OAAOtjB,IADYtK,KAAKq1B,gBACQwI,GAAkBr6B,EAGpD,GAAI4tB,IAAaU,GAAaV,IAAaY,EACzC,OAAO,CAGT,IAAI8L,GAAgB1M,IAAaU,EAAY9xB,KAAKm1B,kBAAoBn1B,KAAKi1B,gBAE3E,OAAO3qB,IAASwzB,GAAiBt6B,GAAOs6B,GAG1ClP,EAAexuB,UAAU8wB,YAAc,WACrC,MAAOlxB,MAAKk1B,iBAAmBl1B,KAAKg1B,eAAiBh1B,KAAKm1B,oBAAsBn1B,KAAKi1B,kBAGvFrG,EAAexuB,UAAUstB,YAAc,WACrC,MAAO1tB,MAAK+0B,gBAAkB/0B,KAAKg1B,cAAgBh1B,KAAKk1B,gBAG1DtG,EAAexuB,UAAUwtB,eAAiB,WACxC,MAAO5tB,MAAK+0B,gBAAkB/0B,KAAKi1B,iBAAmBj1B,KAAKm1B,mBAG7DvG,EAAexuB,UAAU29B,UAAY,WACnC,MAAO/9B,MAAK+0B,gBAAkB/0B,KAAKk1B,eAAiBl1B,KAAKg1B,eAG3DpG,EAAexuB,UAAUi1B,aAAe,WACtC,MAAOr1B,MAAK+0B,gBAAkB/0B,KAAKm1B,kBAAoBn1B,KAAKi1B,kBAG9DrG,EAAea,YAAc,SAAqBvnB,GAChD,MAAO,IAAI0mB,IACTkD,UAAW5pB,EACX6pB,aAAc,EACdC,SAAU9pB,EACV+pB,YAAa,EACbC,YAAY,EACZsL,UAAU,KAIP5O,GACP6O,EAEFh+B,GAAOI,QAAU+uB,Gd4oNX,SAAUnvB,EAAQI,EAASF,GAEjC,Ye1vNA,SAASq+B,GAAGC,GACV,MAAyB,gBAAdA,GACF59B,OAAO4F,KAAKg4B,GAAYrsB,OAAO,SAAUssB,GAC9C,MAAOD,GAAWC,KACjB91B,IAAIkjB,GAASzE,KAAK,KAEhBtnB,MAAMa,UAAUgI,IAAItD,KAAKgI,UAAWwe,GAASzE,KAAK,KAG3D,QAASyE,GAAQgR,GACf,MAAOA,GAAIhR,QAAQ,MAAO,KAG5B7rB,EAAOI,QAAUm+B,GfwxNX,SAAUv+B,EAAQC,EAAqBC,GAE7C,cgBh0NA,YAKA,QAASw+B,KACP,MAAKr+B,GAAOs+B,OACLA,OAAOC,WAAaC,GADCC,EAG9B,QAASC,KACP,MAAK1+B,GAAOs+B,OACLA,OAAOC,WAAaI,EADAF,EAV7B,GAAMA,IAAuB,EACvBE,EAAmB,IACnBH,EAAoB,GAYX,MACbI,aAZoB,IAapBC,aAAcL,EACdM,YAAaH,EACbD,YACAL,chBm0N2Br5B,KAAKpF,EAAqBC,EAAoB,KAGnE,CACA,CACA,CACA,CACA,CAEF,SAAUF,EAAQI,EAASF,GAEjC,YiBl1NA,IAAIgvB,GAAY,EAAQ,IAEpB1X,EAAa0X,EAAU1X,WAGvB4nB,GACFC,gBAAiB,SAAyBC,GACxC,MAAO9nB,GAAW8nB,EAAO32B,IAAI,SAAUkkB,GACrC,OAAQA,EAAMuD,SAAUvD,OAK9B7sB,GAAOI,QAAUg/B,GjBs2NX,SAAUp/B,EAAQI,EAASF,GAEjC,YkB92NA,SAASu4B,GAAoB8G,EAAUC,EAAYxF,EAAUyF,GAC3D,GAAKF,EAASj8B,KAAd,CAIA,GAAIo8B,GAAS,CAEbH,GAASxjB,OAAO,SAAU/a,EAAOiR,EAAW0tB,GAO1C,MANKH,GAAWx+B,EAAOiR,KACjB+nB,EAASh5B,IACXy+B,EAAQC,EAAQC,GAElBD,EAASC,GAEJ1tB,IAGT+nB,EAASuF,EAASpW,SAAWsW,EAAQC,EAAQH,EAAS/wB,UAGxDxO,EAAOI,QAAUq4B,GlBy4NX,SAAUz4B,EAAQI,EAASF,GAEjC,YmBl6NA,SAAS0/B,GAAe5+B,GACtB,MAAiB,YAAVA,IAAiC,IAAVA,EAGhChB,EAAOI,QAAUw/B,GnB07NX,SAAU5/B,EAAQI,EAASF,GAEjC,YoB97NA,SAAS2/B,GAAuB1T,EAAa2T,EAAUC,GACrD,GAAI3T,GAAYD,EAAY6E,eACxBzD,EAAUpB,EAAYgB,oBACtB2B,EAAS1C,CACb,IAAIA,EAAUqF,cAAe,CAC3B,GAAkB,YAAdsO,GACF,GAAI5T,EAAY2F,4BACd,MAAOvE,OAEJ,IAAIpB,EAAYyF,8BACrB,MAAOrE,EAIT,KADAuB,EAASgR,EAAS3T,MACHC,EACb,MAAOmB,GAGX,MAAOuG,GAAciB,YAAYxH,EAASuB,EAAQiR,GAxBpD,GAAIjM,GAAgB,EAAQ,GA2B5B9zB,GAAOI,QAAUy/B,GpBu9NT,CACA,CACA,CACA,CACA,CACC,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CAEH,SAAU7/B,EAAQI,GqBnhOxBJ,EAAOI,SAAW,QAAU,SAAS,KAAO,SAAS,OAAS,UAAU,MAAQ,SAAS,MAAQ,UAAU,KAAO,UAAU,kBAAoB,SAAS,SAAW,UAAU,SAAW,YrB0hOnL,SAAUJ,EAAQI,EAASF,GAEjC,YsB9gOA,IAAI8/B,GAAwB,EAAQ,KAChCrM,EAAwB,EAAQ,KAEhCJ,EAA0B,SAAiC7G,EAAc0J,GAC3E,GAAIpI,GAAWoI,EAAenI,cAC1BC,EAAckI,EAAejI,iBAC7BiH,EAASgB,EAAekI,YACxB3I,EAAYS,EAAeR,eAK3BqK,EAA6BtM,EAAsBjH,EAAc0J,GAEjE5I,EAAWyS,EAA2BrT,cACtCsT,EAAY1S,EAASpH,SACrB+Z,EAAaD,EAAUjd,QAAQ+K,GAC/BoS,EAAWF,EAAUjd,QAAQmS,GAAU,CAE3C,OAAO4K,GAAsBxS,EAASnX,MAAM8pB,EAAYC,GAAUz3B,IAAI,SAAUkkB,EAAO8E,GACrF,GAAIsC,GAAOpH,EAAM2M,UACb6G,EAAQxT,EAAM4M,kBAElB,OAAIzL,KAAaoH,EACRvI,EAAMhJ,OACXoQ,KAAMA,EAAK5d,MAAM6X,EAAayH,GAC9BgD,cAAe0H,EAAMhqB,MAAM6X,EAAayH,KAIxChE,IAAa3D,EACRnB,EAAMhJ,OACXoQ,KAAMA,EAAK5d,MAAM6X,GACjByK,cAAe0H,EAAMhqB,MAAM6X,KAI3ByD,IAAayD,EACRvI,EAAMhJ,OACXoQ,KAAMA,EAAK5d,MAAM,EAAGsf,GACpBgD,cAAe0H,EAAMhqB,MAAM,EAAGsf,KAI3B9I,KAIX7sB,GAAOI,QAAUmzB,GtBkiOX,SAAUvzB,EAAQI,EAASF,GAEjC,YuBlkOA,SAASogC,GAAWC,EAAeC,GACjCpW,QAAQC,KAAK,YAAckW,EAAgB,0CAA4CC,EAAgB,cAhCzG,GAAI5R,GAAU,EAAQ,GAElBC,EAAWD,GAAW,SAAUE,GAAU,IAAK,GAAI1a,GAAI,EAAGA,EAAI/G,UAAUrK,OAAQoR,IAAK,CAAE,GAAI2a,GAAS1hB,UAAU+G,EAAI,KAAK,GAAI3L,KAAOsmB,GAAcnuB,OAAOD,UAAUoiB,eAAe1d,KAAK0pB,EAAQtmB,KAAQqmB,EAAOrmB,GAAOsmB,EAAOtmB,IAAY,MAAOqmB,IAe7O2R,EAAsB,EAAQ,KAC9BvR,EAAY,EAAQ,IAEpB1kB,EAAY,EAAQ,IAEpBmD,EAAMuhB,EAAUvhB,IAGhB+yB,EAAY/yB,IACZgzB,EAAc,EAsBdC,GASFC,wBAAyB,WAEvB,MADAP,GAAW,sCAAuC,wCAC3CM,EAAYE,6BAarBjgC,OAAQ,SAAgB2D,EAAMu8B,EAAYpK,GAExC,MADA2J,GAAW,qBAAsB,6BAC1BM,EAAYI,SAASx8B,EAAMu8B,EAAYpK,IAUhDtX,IAAK,SAAa2M,GAEhB,MADAsU,GAAW,kBAAmB,0BACvBM,EAAYK,MAAMjV,IAS3B/hB,IAAK,SAAaxB,GAEhB,MADA63B,GAAW,kBAAmB,0BACvBM,EAAYM,MAAMz4B,IAW3B04B,UAAW,SAAmB14B,EAAK24B,GAEjC,MADAd,GAAW,wBAAyB,gCAC7BM,EAAYS,YAAY54B,EAAK24B,IAStCE,YAAa,SAAqB74B,EAAK84B,GAErC,MADAjB,GAAW,0BAA2B,kCAC/BM,EAAYY,cAAc/4B,EAAK84B,IAYxCT,0BAA2B,WACzB,MAAO,GAAKH,GAUdK,SAAU,SAAkBx8B,EAAMu8B,EAAYpK,GAC5C,MAAOiK,GAAYK,MAAM,GAAIR,IAAsBj8B,KAAMA,EAAMu8B,WAAYA,EAAYpK,KAAMA,UAO/FsK,MAAO,SAAejV,GACpB,GAAIvjB,GAAM,MAAOk4B,CAEjB,OADAD,GAAYA,EAAUzzB,IAAIxE,EAAKujB,GACxBvjB,GAMTy4B,MAAO,SAAez4B,GACpB,GAAIujB,GAAW0U,EAAUz2B,IAAIxB,EAE7B,OADGujB,IAA2GxhB,GAAU,GACjHwhB,GAQTqV,YAAa,SAAqB54B,EAAK24B,GACrC,GAAIpV,GAAW4U,EAAYM,MAAMz4B,GAC7B84B,EAAU1S,KAAa7C,EAAS6K,UAAWuK,GAC3CK,EAAczV,EAAS/e,IAAI,OAAQs0B,EAEvC,OADAb,GAAYA,EAAUzzB,IAAIxE,EAAKg5B,GACxBA,GAMTD,cAAe,SAAuB/4B,EAAK84B,GACzC,GAAIvV,GAAW4U,EAAYM,MAAMz4B,GAC7Bg5B,EAAczV,EAAS/e,IAAI,OAAQs0B,EAEvC,OADAb,GAAYA,EAAUzzB,IAAIxE,EAAKg5B,GACxBA,GAIXzhC,GAAOI,QAAUwgC,GvBwmOX,SAAU5gC,EAAQI,EAASF,GAEjC,YwB5xOA,IAEIwhC,IACFC,OAAQ,SAAgBhQ,EAAUiQ,EAAcC,GAC9C,MAAOlQ,GAJS,IAIkBiQ,EAJlB,IAIiDC,GAGnEC,OAAQ,SAAgBC,GACtB,GAAIC,GAAmBD,EAAUE,MARjB,KASZtQ,EAAWqQ,EAAiB,GAC5BJ,EAAeI,EAAiB,GAChCH,EAAUG,EAAiB,EAE/B,QACErQ,SAAUA,EACViQ,aAAcM,SAASN,EAAc,IACrCC,QAASK,SAASL,EAAS,MAKjC7hC,GAAOI,QAAUshC,GxB+yOR,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CAEH,SAAU1hC,EAAQC,EAAqBC,GAE7C,YyB72Oe,OAEXiiC,UAAW,kBACXC,aAAc,6BAGdD,UAAW,oBACXC,aAAc,gCAGdD,UAAW,sBACXC,aAAc,iCAGdD,UAAW,mBACXC,aAAc,6BAGdD,UAAW,kBACXC,aAAc,qBAGdD,UAAW,kBACXC,aAAc,4BAGdD,UAAW,qBACXC,aAAc,kCzB22OT,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CAEH,SAAUpiC,EAAQC,EAAqBC,GAE7C,Y0B33OA,SAASmiC,GAAT,GAAuD,QAA7BC,YAA6B,OAArB,MAAqB,EAAdC,EAAc,EAAdA,WACjCC,EAAWN,SAASI,EAAO,GACjC,OACE,0BAAK7D,UAAWgE,IAAOC,mBACrB,yBACEjE,UAAWgE,IAAOD,SAClBjO,OAASoO,MAAUC,EAASJ,EAAUD,GAA7B,QAlCjB,sCAUMM,GACJP,MAAO,IACPC,WAAY,KAGRK,EAAW,SAACN,EAAOQ,GAKvB,MAAIR,GAAQQ,EAAQ,KAAO,EAAUhgC,KAAKigC,KAAKT,GAASx/B,KAAKigC,KAAKD,GAAS,GACvER,EAAQQ,EAAQ,KAAO,GAAWhgC,KAAKigC,KAAKT,GAASx/B,KAAKigC,KAAKD,GAAS,GAIrER,EAAQQ,EAAQ,IAezBT,GAAeW,YAAc,iBAE7BX,EAAeQ,aAAeA,EAEfR,O1B+5OT,SAAUriC,EAAQI,EAASF,GAEjC,Y2Bl8OA,SAAS+iC,GAAkBC,GACzB,MAAO,YACL,MAAOA,IASX,GAAIC,GAAgB,YAEpBA,GAAcC,YAAcH,EAC5BE,EAAcE,iBAAmBJ,GAAkB,GACnDE,EAAcG,gBAAkBL,GAAkB,GAClDE,EAAcI,gBAAkBN,EAAkB,MAClDE,EAAcK,gBAAkB,WAC9B,MAAOjjC,OAET4iC,EAAcM,oBAAsB,SAAUP,GAC5C,MAAOA,IAGTljC,EAAOI,QAAU+iC,G3Bk9OX,SAAUnjC,EAAQI,EAASF,GAEjC,Y4Bx+OA,SAAS6rB,GAAgBC,EAAUC,GAAe,KAAMD,YAAoBC,IAAgB,KAAM,IAAI1kB,WAAU,qCAEhH,QAASwvB,GAA2BC,EAAM3xB,GAAQ,IAAK2xB,EAAQ,KAAM,IAAIC,gBAAe,4DAAgE,QAAO5xB,GAAyB,gBAATA,IAAqC,kBAATA,GAA8B2xB,EAAP3xB,EAElO,QAAS6xB,GAAUC,EAAUz2B,GAAc,GAA0B,kBAAfA,IAA4C,OAAfA,EAAuB,KAAM,IAAI6G,WAAU,iEAAoE7G,GAAey2B,GAASx2B,UAAYC,OAAOC,OAAOH,GAAcA,EAAWC,WAAaG,aAAeE,MAAOm2B,EAAUC,YAAY,EAAOC,UAAU,EAAMC,cAAc,KAAe52B,IAAYE,OAAO22B,eAAiB32B,OAAO22B,eAAeJ,EAAUz2B,GAAcy2B,EAASK,UAAY92B,GAEje,GAAI0+B,GAAkB,EAAQ,IAC1BlM,EAAoB,EAAQ,IAC5BoJ,EAAe,EAAQ,IACvBlD,EAAmB,EAAQ,IAC3BwH,EAAc,EAAQ,KACtBxN,EAAoB,EAAQ,IAC5BlE,EAAY,EAAQ,IACpBC,EAAiB,EAAQ,IAEzB4M,EAAoB,EAAQ,IAC5B2H,EAAoB,EAAQ,KAE5B/vB,EAAOub,EAAUvb,KACjBqK,EAASkR,EAAUlR,OACnB7T,EAAS+kB,EAAU/kB,OAGnBw5B,EAA8BvQ,EAAkBwQ,wBAEhDxU,GACFyU,UAAW,KACXrW,SAAU,KACVsW,gBAAiB,KACjBC,eAAgB,MAGdC,EAAyBL,EAA8BvK,EAAmBkD,EAE1E2H,EAAqBjmB,EAAOoR,GAE5BJ,EAAe,SAAUkV,GAG3B,QAASlV,KAGP,MAFAjD,GAAgBxrB,KAAMyuB,GAEf+H,EAA2Bx2B,KAAM2jC,EAAoB92B,MAAM7M,KAAM8M,YAyI1E,MA9IA6pB,GAAUlI,EAAckV,GAQxBlV,EAAaruB,UAAUiwB,aAAe,WAEpC,MAAOgQ,IAGT5R,EAAaruB,UAAUisB,YAAc,WACnC,MAAOrsB,MAAK0J,IAAI,aAGlB+kB,EAAaruB,UAAUkyB,mBAAqB,WAC1C,MAAOtyB,MAAK0J,IAAI,oBAGlB+kB,EAAaruB,UAAUiyB,kBAAoB,WACzC,MAAOryB,MAAK0J,IAAI,mBAGlB+kB,EAAaruB,UAAU0tB,eAAiB,SAAwB5lB,GAE9D,MADYlI,MAAKqsB,cAAc3iB,IAAIxB,IAIrCumB,EAAaruB,UAAUwjC,aAAe,SAAsB17B,GAC1D,MAAOlI,MAAKqsB,cAAcjlB,UAAUye,SAASuD,UAAU,SAAUjlB,GAC/D,MAAOA,KAAM+D,IACZ8gB,KAAK,GAAGd,SAGbuG,EAAaruB,UAAUyjC,YAAc,SAAqB37B,GACxD,MAAOlI,MAAKqsB,cAAcxG,SAASuD,UAAU,SAAUjlB,GACrD,MAAOA,KAAM+D,IACZ8gB,KAAK,GAAGd,SAGbuG,EAAaruB,UAAU0jC,cAAgB,SAAuB57B,GAC5D,MAAOlI,MAAKqsB,cAAcjD,UAAU,SAAU9f,EAAGpF,GAC/C,MAAOA,KAAMgE,IACZ8gB,KAAK,GAAGd,SAGbuG,EAAaruB,UAAU2jC,eAAiB,SAAwB77B,GAC9D,MAAOlI,MAAKqsB,cAAcjlB,UAAUgiB,UAAU,SAAU9f,EAAGpF,GACzD,MAAOA,KAAMgE,IACZ8gB,KAAK,GAAGd,SAGbuG,EAAaruB,UAAU4jC,iBAAmB,WACxC,MAAOhkC,MAAKqsB,cAAc3Y,WAG5B+a,EAAaruB,UAAU6jC,cAAgB,WACrC,MAAOjkC,MAAKqsB,cAAcnE,SAG5BuG,EAAaruB,UAAUwxB,aAAe,WACpC,MAAO5xB,MAAKqsB,cAAczD,QAG5B6F,EAAaruB,UAAU8jC,aAAe,SAAsBC,GAC1D,MAAOnkC,MAAKqsB,cAAcjkB,IAAI,SAAUkkB,GACtC,MAAOA,GAAQA,EAAM2M,UAAY,KAChCpS,KAAKsd,GAAa,OAGvB1V,EAAaruB,UAAUkgC,wBAA0B,WAE/C,MAAOD,GAAYE,6BAGrB9R,EAAaruB,UAAUgkC,QAAU,WAC/B,GAAInX,GAAWjtB,KAAKqsB,aACpB,OAAOY,GAASlqB,KAAO,GAAKkqB,EAAS/E,QAAQ8F,YAAc,GAG7DS,EAAaruB,UAAUikC,aAAe,SAAsBpgC,EAAMu8B,EAAYpK,GAG5E,MADAiK,GAAYI,SAASx8B,EAAMu8B,EAAYpK,GAChCp2B,MAGTyuB,EAAaruB,UAAUkkC,gBAAkB,SAAyBp8B,EAAK24B,GAGrE,MADAR,GAAYS,YAAY54B,EAAK24B,GACtB7gC,MAGTyuB,EAAaruB,UAAUmkC,kBAAoB,SAA2Br8B,EAAK84B,GAGzE,MADAX,GAAYY,cAAc/4B,EAAK84B,GACxBhhC,MAGTyuB,EAAaruB,UAAUokC,UAAY,SAAmB/Y,GAGpD,MADA4U,GAAYK,MAAMjV,GACXzrB,MAGTyuB,EAAaruB,UAAUk3B,UAAY,SAAmBpvB,GAEpD,MAAOm4B,GAAYM,MAAMz4B,IAG3BumB,EAAagW,qBAAuB,SAEpC1F,EAAQuE,GAEN,GAAIoB,GAAYnlC,MAAMwH,QAAQg4B,GAAUA,EAASA,EAAO4F,cACpD1X,EAAW4R,EAAgBC,gBAAgB4F,GAC3C7O,EAAiB5I,EAASpF,UAAY,GAAI+G,GAAmBA,EAAea,YAAYxC,EAAS/E,QAAQ2H,SAC7G,OAAO,IAAIpB,IACTxB,SAAUA,EACVqW,UAAWA,GAAajD,EACxBkD,gBAAiB1N,EACjB2N,eAAgB3N,KAIpBpH,EAAakB,eAAiB,SAAwB+D,GACpD,GAAIyQ,GAAYr3B,UAAUrK,OAAS,OAAsBK,KAAjBgK,UAAU,GAAmBA,UAAU,GAAK,YAEhF83B,EAAUlR,EAAKgO,MAAMyC,GACrBpF,EAAS6F,EAAQx8B,IAAI,SAAUkkB,GAEjC,MADAA,GAAQ6W,EAAkB7W,GACnB,GAAImX,IACTv7B,IAAKszB,IACL9H,KAAMpH,EACNroB,KAAM,WACNm0B,cAAehlB,EAAKxJ,EAAO+oB,EAAkBkF,MAAOvL,EAAM7pB,YAG9D,OAAOgsB,GAAagW,qBAAqB1F,IAGpCtQ,GACPiV,EAEFjkC,GAAOI,QAAU4uB,G5B4/OX,SAAUhvB,EAAQI,EAASF,GAEjC,Y6BlrPA,SAASwjC,GAAkB0B,GACzB,MAAOA,GAAMvZ,QAAQwZ,EAAuB,IAH9C,GAAIA,GAAwB,GAAIC,QAAO,KAAM,IAM7CtlC,GAAOI,QAAUsjC,G7BwsPX,SAAU1jC,EAAQI,EAASF,GAEjC,Y8BxrPA,SAASqlC,GAASC,GAChB,MAAOA,KAAQC,GAAOD,IAAQE,EAOhC,QAASC,GAAWH,GAElB,MADCD,GAASC,IAAwIh7B,GAAU,GACrJg7B,IAAQC,EAAM,MAAQ,MAQ/B,QAASG,GAAsBJ,EAAKK,GAGlC,MAFCN,GAASC,IAAwIh7B,GAAU,GAC3J+6B,EAASM,IAAkJr7B,GAAU,GAC/Jg7B,IAAQK,EAAW,KAAOF,EAAWH,GAQ9C,QAASM,GAAaN,GACpBO,EAAYP,EAMd,QAASQ,KACPF,EAAaL,GAMf,QAASQ,KAKP,MAJKF,IACHxlC,KAAKylC,gBAEND,GAAoGv7B,GAAU,GACxGu7B,EA7DT,GAAIv7B,GAAY,EAAQ,IAGpBi7B,EAAM,MACNC,EAAM,MAENK,EAAY,KA0DZG,GAEFC,QAhEY,UAiEZV,IAAKA,EACLC,IAAKA,EAELH,SAAUA,EACVI,WAAYA,EACZC,sBAAuBA,EAEvBE,aAAcA,EACdE,cAAeA,EACfC,aAAcA,EAGhBjmC,GAAOI,QAAU8lC,G9BouPX,SAAUlmC,EAAQI,EAASF,GAEjC,Y+Bh0PA,IAAIu3B,GAAW,EAAQ,IACnB9pB,EAAM8pB,EAAS9pB,IAEfy4B,EAAQ,EAAQ,GAEhB7H,EAAK,EAAQ,IAEb8H,EAAUD,EAAME,cAAc,MAAQ7H,UAAWF,EAAG,iCACpDgI,EAAUH,EAAME,cAAc,MAAQ7H,UAAWF,EAAG,iCACpDiI,EAAWJ,EAAME,cAAc,OAAS7H,UAAWF,EAAG,kCAEtDkI,EAA6B94B,GAC/B,cACE+4B,QAAS,MAEX,cACEA,QAAS,MAEX,gBACEA,QAAS,MAEX,eACEA,QAAS,MAEX,eACEA,QAAS,MAEX,cACEA,QAAS,MAEX,uBACEA,QAAS,KACTC,QAASN,GAEX,qBACEK,QAAS,KACTC,QAASJ,GAEXK,YACEF,QAAS,cAEXG,QACEH,QAAS,UAEX,cACEA,QAAS,MACTC,QAASH,GAEXM,UACEJ,QAAS,MACTK,iBAAkB,OAItB/mC,GAAOI,QAAUqmC,G/Bo1PX,SAAUzmC,EAAQI,EAASF,GAEjC,YgCj5PAF,GAAOI,SACL4mC,UAAW,EACXC,IAAK,EACLC,OAAQ,GACRC,IAAK,GACLC,IAAK,GACLC,MAAO,GACPC,QAAS,GACTC,UAAW,GACXC,IAAK,GACLC,KAAM,GACNC,KAAM,GACNC,GAAI,GACJC,MAAO,GACPC,KAAM,GACNC,OAAQ,GACRC,MAAO,IACPC,OAAQ,IACRC,EAAG,GACHC,EAAG,GACHC,KAAM,GACNC,SAAU,GACVC,SAAU,MhCi6PN,SAAUroC,EAAQI,EAASF,GAEjC,YiC/6PA,SAASooC,GAAyB5b,EAAc6b,GAC9C,GAAIpU,EAEJ,IAAIoU,EAAgB9W,cAAe,CACjC,GAAIhpB,GAAM8/B,EAAgB9S,eACtB7yB,EAAS2lC,EAAgB7S,iBAC7B,OAAI9yB,GAAS,GACXuxB,EAAYzH,EAAa2B,eAAe5lB,GAAKqtB,YAAYlzB,EAAS,GAC9DuxB,IAAczH,EAAa2B,eAAe5lB,GAAKqtB,YAAYlzB,GACtD,KAEF4lC,EAAU9b,EAAakE,eAAgBuD,IAEzC,KAGT,GAAInG,GAAWua,EAAgBta,cAC3BC,EAAcqa,EAAgBpa,iBAC9BC,EAAa1B,EAAa2B,eAAeL,EAI7C,OAFAmG,GAAYjG,IAAgBE,EAAWG,YAAc,KAAOH,EAAW0H,YAAY5H,GAE5Esa,EAAU9b,EAAakE,eAAgBuD,GAOhD,QAASqU,GAAU3E,EAAW1P,GAC5B,GAAIA,EAAW,CAEb,MAAkC,YADrB0P,EAAU3C,MAAM/M,GACfsU,gBAAgCtU,EAAY,KAE5D,MAAO,MAGTn0B,EAAOI,QAAUkoC,GjCw8PX,SAAUtoC,EAAQI,EAASF,GAEjC,YkCj/PA,SAASwoC,GAAaC,EAAWC,GAC/B,SAAKD,IAAcC,KAERD,IAAcC,IAEdC,EAAWF,KAEXE,EAAWD,GACbF,EAAaC,EAAWC,EAAUE,YAChC,YAAcH,GAChBA,EAAUze,SAAS0e,KACjBD,EAAUI,4BACsC,GAA/CJ,EAAUI,wBAAwBH,MAnBhD,GAAIC,GAAa,EAAQ,IAyBzB7oC,GAAOI,QAAUsoC,GlCwgQX,SAAU1oC,EAAQI,EAASF,GAEjC,YmC5hQA,SAAS8oC,GAAkBtC,EAASxoB,GAClC,GAAI+qB,GAAWC,EAAMj/B,IAAIy8B,EAASxoB,EAClC,OAAoB,SAAb+qB,GAAoC,WAAbA,EAThC,GAAIE,GAAmB,EAAQ,KAe3BD,GASFj/B,IAAKk/B,EAULC,gBAAiB,SAAyB77B,GACxC,IAAKA,EACH,MAAO,KAGT,KADA,GAAI87B,GAAgB97B,EAAK87B,cAClB97B,GAAQA,IAAS87B,EAAcC,MAAM,CAC1C,GAAIN,EAAkBz7B,EAAM,aAAey7B,EAAkBz7B,EAAM,cAAgBy7B,EAAkBz7B,EAAM,aACzG,MAAOA,EAETA,GAAOA,EAAKu7B,WAEd,MAAOO,GAAcE,aAAeF,EAAcG,cAKtDxpC,GAAOI,QAAU8oC,GnCmjQX,SAAUlpC,EAAQI,EAASF,GAEjC,YoCxlQA,SAASupC,GAAkBC,GACzB,GAAIC,GAAwBC,EAAyBF,EAAWL,eAAiBK,EAAWG,SACxFH,GAAWI,QAAUJ,YAAsBA,GAAWI,SACxDJ,EAAaC,EAEf,IAAII,GAAiBC,EAA2BN,GAE5CO,EAAWP,IAAeC,EAAwBD,EAAWL,cAAc57B,gBAAkBi8B,EAE7FQ,EAAOR,EAAWS,YAAcF,EAASG,YACzCC,EAAOX,EAAWY,aAAeL,EAASM,YAK9C,OAHAR,GAAe33B,EAAItP,KAAKC,IAAI,EAAGD,KAAKsB,IAAI2lC,EAAe33B,EAAG83B,IAC1DH,EAAeS,EAAI1nC,KAAKC,IAAI,EAAGD,KAAKsB,IAAI2lC,EAAeS,EAAGH,IAEnDN,EA9BT,GAAIH,GAA2B,EAAQ,KACnCI,EAA6B,EAAQ,IAgCzChqC,GAAOI,QAAUqpC,GpCunQX,SAAUzpC,EAAQI,EAASF,GAEjC,YqCjpQA,SAASuqC,GAAsBl9B,GAE7B,IADA,GAAIm9B,GAAan9B,EACVm9B,GAAcA,IAAeb,SAASp8B,iBAAiB,CAC5D,GAAIhF,GAAMkiC,EAA6BD,EACvC,IAAW,MAAPjiC,EACF,MAAOA,EAETiiC,GAAaA,EAAW5B,WAE1B,MAAO,MAdT,GAAI6B,GAA+B,EAAQ,IAiB3C3qC,GAAOI,QAAUqqC,GrC0qQX,SAAUzqC,EAAQI,EAASF,GAEjC,YsC7rQA,IAAI86B,GAAY,EAAQ,IAEpB4P,EAAQ5P,EAAUW,WAAW,YAE7BkP,GAMFC,iBAAkB,SAA0BtnB,GAC1C,QAASA,EAAEunB,UAAYvnB,EAAEwnB,QAG3BC,mBAAoB,SAA4BznB,GAC9C,MAAOonB,IAASpnB,EAAEwnB,QAGpBE,mBAAoB,SAA4B1nB,GAC9C,MAAOonB,KAAUpnB,EAAE2nB,UAAY3nB,EAAEwnB,OAASH,EAAeC,iBAAiBtnB,IAI9ExjB,GAAOI,QAAUyqC,GtCitQX,SAAU7qC,EAAQI,EAASF,GAEjC,YuCluQA,SAASkrC,GAAsBjf,EAAakf,GAC1C,GAAIjf,GAAYD,EAAY6E,eACxBzD,EAAUpB,EAAYgB,oBACtB1kB,EAAM2jB,EAAU6B,cAChBrrB,EAASwpB,EAAU+B,iBAEnBoE,EAAW9pB,EACX+pB,EAAc,CAElB,IAAI6Y,EAAczoC,EAAQ,CACxB,GAAI0oC,GAAY/d,EAAQ4W,aAAa17B,EACrC,IAAiB,MAAb6iC,EACF/Y,EAAW9pB,MACN,CACL8pB,EAAW+Y,CAEX9Y,GADkBjF,EAAQc,eAAeid,GACf9R,UAAUx2B,YAGtCwvB,GAAc5vB,EAASyoC,CAGzB,OAAOjf,GAAUvI,OACf0O,SAAUA,EACVC,YAAaA,EACbC,YAAY,IAIhBzyB,EAAOI,QAAUgrC,GvC6vQR,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CAEH,SAAUprC,EAAQI,EAASF,GAEjC,YwCr1QA,IAAIqrC,GAAmB,EAAQ,KAC3BnM,EAAkB,EAAQ,IAC1BlM,EAAoB,EAAQ,IAC5BsY,EAA0B,EAAQ,KAClClP,EAAe,EAAQ,IACvBtN,EAAe,EAAQ,KACvByX,EAA6B,EAAQ,KACrCgF,EAA0B,EAAQ,KAClCC,EAAc,EAAQ,KACtBC,EAAmB,EAAQ,KAC3B/K,EAAc,EAAQ,KACtB9M,EAAgB,EAAQ,IACxB2M,EAAsB,EAAQ,KAC9BnU,EAAc,EAAQ,IACtBue,EAAiB,EAAQ,KACzBe,EAAqB,EAAQ,KAC7Bzc,EAAiB,EAAQ,IAEzB0c,EAA6B,EAAQ,KACrCC,EAAiC,EAAQ,KACzCC,EAA6B,EAAQ,KACrChQ,EAAoB,EAAQ,IAC5BiQ,EAAuB,EAAQ,KAC/BC,EAA0B,EAAQ,KAElCC,GACFC,OAAQT,EACRU,YAAaT,EACbrf,YAAaA,EAEb+f,mBAAoBb,EACpBc,OAAQ1L,EACR2L,eAAgB9L,EAEhBrB,gBAAiBA,EACjBlM,kBAAmBA,EACnBoJ,aAAcA,EACdtN,aAAcA,EACdG,eAAgBA,EAEhBoc,iBAAkBA,EAClBV,eAAgBA,EAChB2B,SAAU1Y,EACV2Y,UAAWb,EAEXnF,2BAA4BA,EAC5BgF,wBAAyBA,EAEzBiB,gBAAiBZ,EACjBa,eAAgBZ,EAChBa,aAAcf,EACdgB,OAAQ9Q,EACRiQ,qBAAsBA,EACtBC,wBAAyBA,EAG3BjsC,GAAOI,QAAU8rC,GxCy2QX,SAAUlsC,EAAQI,EAASF,GAEjC,YyCn6QA,IAAIk5B,GAAmB,EAAQ,IAC3BlK,EAAY,EAAQ,IAEpB6M,EAAoB,EAAQ,IAE5BvkB,EAAa0X,EAAU1X,WAGvBs1B,EAAgC,SAAuCtf,GACzE,GAAIuf,MAGAC,MAAgB,EAEpB,OAAOx1B,GAAWgW,EAAS1f,cAAc,SAAUm/B,GACjDA,EAAcl/B,QAAQ,SAAU8e,EAAOnpB,GACrC,GAAIwpC,GAASrgB,EAAMuD,SACf+c,EAAUtgB,EAAMiN,oBAChBsT,EAAUvgB,EAAMgN,oBAChBwT,EAAexgB,EAAM8M,eACrB2T,EAAYzgB,EAAM+M,eAGlBnxB,EAAMszB,GAKV,IAFAgR,EAAWG,GAAUzkC,EAEjB0kC,EAAS,CACKF,EAAchjC,IAAIkjC,GAEhCF,EAAch6B,OAAOk6B,EAAS,eAAgB1kC,GAG9CwkC,EAAch6B,OAAOi6B,EAAQ,eAAgB,MAIjD,GAAIE,EAAS,CACKH,EAAchjC,IAAImjC,GAEhCH,EAAch6B,OAAOm6B,EAAS,eAAgB3kC,GAG9CwkC,EAAch6B,OAAOi6B,EAAQ,eAAgB,MAIjD,GAAII,GAAaL,EAAchjC,IAAIqjC,GAAY,CAC7C,GAAIC,GAAcN,EAAchjC,IAAIqjC,GAChCE,EAAqBD,EAAY5T,cACrCsT,GAAch6B,OAAOq6B,EAAW,YAAaE,EAAmBvgC,IAAIugC,EAAmBvqB,QAAQ4J,EAAMuD,UAAW3nB,QAGhHwkC,GAAch6B,OAAOi6B,EAAQ,UAAW,MAEpCF,IACFC,EAAch6B,OAAO+5B,EAAc5c,SAAU,eAAgB3nB,GAC7DwkC,EAAch6B,OAAOi6B,EAAQ,eAAgBH,EAAWC,EAAc5c,YAGxE4c,EAAgBC,EAAchjC,IAAIijC,EAGpCG,GAAat/B,QAAQ,SAAU0/B,GACZR,EAAchjC,IAAIwjC,GAEjCR,EAAch6B,OAAOw6B,EAAU,UAAWhlC,GAE1CwkC,EAAch6B,OAAOi6B,EAAQ,YAAargB,EAAM8M,eAAexnB,OAAO,SAAUu7B,GAC9E,MAAOA,KAAUD,WAKxBx5B,UAAUtL,IAAI,SAAUkkB,GACzB,OAAQkgB,EAAWlgB,EAAMuD,UAAWvD,EAAM5f,IAAI,MAAO8/B,EAAWlgB,EAAMuD,gBAItEud,EAA4B,SAAmCngB,GACjE,MAAOhW,GAAWgW,EAASvZ,UAAUtL,IAAI,SAAUkkB,GACjD,GAAIpkB,GAAMszB,GACV,QAAQtzB,EAAKokB,EAAM5f,IAAI,MAAOxE,QAI9Bu3B,EAAwB,SAA+BxS,GAGzD,MAF0BA,GAAS/E,iBAAmB2Q,GAM/C0T,EAA8Btf,GAH5BmgB,EAA0BngB,GAMrCxtB,GAAOI,QAAU4/B,GzCu7QX,SAAUhgC,EAAQI,EAASF,GAEjC,Y0CrhRA,SAASyzB,GAAsBjH,EAAc0J,GAC3C,GAAI5I,GAAWd,EAAaE,cACxBiX,EAAYnX,EAAakE,eAEzBgd,KAEA5f,EAAWoI,EAAenI,cAC1BC,EAAckI,EAAejI,iBAC7BC,EAAaZ,EAASvjB,IAAI+jB,GAC1B6f,EAAeC,EAAejK,EAAWzV,EAAYF,EAErD2f,KAAiBzf,IACnBwf,EAAc5f,GAAY6f,EAG5B,IAAIzY,GAASgB,EAAekI,YACxB3I,EAAYS,EAAeR,eAC3BP,EAAW7H,EAASvjB,IAAImrB,EACxBpH,KAAaoH,IACfC,EAAWwY,EAGb,IAAIE,GAAaD,EAAejK,EAAWxO,EAAUM,EAMrD,OAJIoY,KAAe1Y,IACjBuY,EAAcxY,GAAU2Y,GAGrBntC,OAAO4F,KAAKonC,GAAe5qC,OAIzB0pB,EAAa7I,OAClB2J,SAAUA,EAAS3J,MAAM+pB,GACzB7J,eAAgB3N,IALT1J,EAAazf,IAAI,iBAAkBmpB,GAS9C,QAAS4X,GAAgBC,EAAYxlC,EAAK7F,GACxC,GAAIgyB,EAWJ,OAVA6D,GAAoBwV,EAAY,SAAU5kC,EAAGC,GAC3C,MAAOD,GAAEwuB,cAAgBvuB,EAAEuuB,aAC1B,SAAU6O,GACX,MAAOA,GAAQ7O,cAAgBpvB,GAC9B,SAAUoC,EAAO9G,GACd8G,GAASjI,GAAUmB,GAAOnB,IAC5BgyB,GAAiB/pB,MAAOA,EAAO9G,IAAKA,MAGd,gBAAjB6wB,IAA2IpqB,GAAU,GACvJoqB,EAGT,QAASkZ,GAAejK,EAAWhX,EAAOjqB,GACxC,GAAIy9B,GAAQxT,EAAM4M,mBACdyU,EAAatrC,EAAS,EAAIy9B,EAAMp2B,IAAIrH,EAAS,OAAKS,GAClD8qC,EAAYvrC,EAASy9B,EAAM7xB,QAAU6xB,EAAMp2B,IAAIrH,OAAUS,GACzD+qC,EAAqBF,EAAaA,EAAWrW,gBAAcx0B,GAC3DgrC,EAAoBF,EAAYA,EAAUtW,gBAAcx0B,EAE5D,IAAIgrC,GAAqBA,IAAsBD,EAAoB,CAEjE,GAA+B,YADlBvK,EAAU3C,MAAMmN,GAClB5F,gBAA+B,CAMxC,IALA,GAII6F,GAJAC,EAAmBP,EAAgB3N,EAAOgO,EAAmBzrC,GAC7DiI,EAAQ0jC,EAAiB1jC,MACzB9G,EAAMwqC,EAAiBxqC,IAGpB8G,EAAQ9G,GACbuqC,EAAUjO,EAAMp2B,IAAIY,GACpBw1B,EAAQA,EAAMpzB,IAAIpC,EAAOqoB,EAAkB4D,YAAYwX,EAAS,OAChEzjC,GAEF,OAAOgiB,GAAM5f,IAAI,gBAAiBozB,IAItC,MAAOxT,GAlFT,GAAIqG,GAAoB,EAAQ,IAE5BuF,EAAsB,EAAQ,IAC9BjuB,EAAY,EAAQ,GAkFxBxK,GAAOI,QAAUuzB,G1C8iRX,SAAU3zB,EAAQI,EAASF,GAEjC,Y2CloRA,SAASsuC,GAAeC,EAAYC,EAAU9rC,GAC5C,GAAIA,IAAW6rC,EAAWjgC,QACxBkgC,EAAS3gC,QAAQ,SAAU4L,GACzB80B,EAAaA,EAAW/8B,KAAKiI,SAE1B,IAAe,IAAX/W,EACT8rC,EAAS/mC,UAAUoG,QAAQ,SAAU4L,GACnC80B,EAAaA,EAAWjpB,QAAQ7L,SAE7B,CACL,GAAIiH,GAAO6tB,EAAWp4B,MAAM,EAAGzT,GAC3BiS,EAAO45B,EAAWp4B,MAAMzT,EAC5B6rC,GAAa7tB,EAAK7gB,OAAO2uC,EAAU75B,GAAMhM,SAE3C,MAAO4lC,GAGTzuC,EAAOI,QAAUouC,G3CypRX,SAAUxuC,EAAQI,EAASF,GAEjC,Y4C5qRA,IAAIk5B,GAAmB,EAAQ,IAE3BuV,EAA2B,SAAkC9hB,EAAOW,GAGtE,KAF8BX,YAAiBuM,IAG7C,MAAO,KAGT,IAAIwV,GAAiB/hB,EAAMiN,mBAE3B,IAAI8U,EACF,MAAOA,EAGT,IAAIlW,GAAS7L,EAAM+M,cAEnB,KAAKlB,EACH,MAAO,KAIT,KADA,GAAImW,GAAyBrhB,EAASvjB,IAAIyuB,GACnCmW,IAA2BA,EAAuB/U,qBAAqB,CAC5E,GAAIwT,GAAYuB,EAAuBjV,cACvCiV,GAAyBvB,EAAY9f,EAASvjB,IAAIqjC,GAAa,KAGjE,MAAKuB,GAIEA,EAAuB/U,oBAHrB,KAMX95B,GAAOI,QAAUuuC,G5CmsRX,SAAU3uC,EAAQI,EAASF,GAEjC,Y6C3pRA,SAAS4uC,GAAeb,EAAYrrC,GAClC,GAAImsC,MACAC,EAAef,EAAWtlC,IAAI,SAAUgR,GAC1C,MAAOA,GAAEie,aACR/uB,QAOH,OANA4vB,GAAoBuW,EAAcC,EAAUzrC,EAAY,SAAUqH,EAAO9G,GACvEgrC,EAAOr9B,KAAK,GAAIw9B,IACdrkC,MAAOA,EAAQjI,EACfmB,IAAKA,EAAMnB,OAGR+Q,EAAKo7B,GAGd,QAASE,GAAS5lC,EAAGC,GACnB,MAAOD,KAAMC,EA9Ff,GAAI4lB,GAAY,EAAQ,IAEpBiU,EAAgB,EAAQ,KACxB1K,EAAsB,EAAQ,IAE9B9kB,EAAOub,EAAUvb,KACjBxJ,EAAS+kB,EAAU/kB,OACnB6T,EAASkR,EAAUlR,OAGnBxa,EAAa2/B,EAAcG,gBAI3B6L,GACFtkC,MAAO,KACP9G,IAAK,MAGHmrC,EAAYlxB,EAAOmxB,GAEnBC,GACFvkC,MAAO,KACP9G,IAAK,KACL69B,aAAc,KACdmN,OAAQ,MAGNM,EAAiBrxB,EAAOoxB,GAExBtiB,GAIFC,SAAU,SAAkBL,EAAcG,EAAOF,GAC/C,GAAI2iB,GAAaziB,EAAM0B,WACvB,KAAK+gB,EACH,MAAO37B,GAAKkP,GAAG,GAAIwsB,IACjBxkC,MAAO,EACP9G,IAAK,EACL69B,aAAc,KACdmN,OAAQp7B,EAAKkP,GAAG,GAAIqsB,IAAYrkC,MAAO,EAAG9G,IAAK,OAInD,IAAIwrC,MACAC,EAAc7iB,EAAYA,EAAUgB,eAAed,EAAOH,GAAgB/Y,EAAKxJ,EAAO,KAAMmlC,IAE5FjP,EAAQxT,EAAM4M,kBAWlB,OATAhB,GAAoB+W,EAAaP,EAAUzrC,EAAY,SAAUqH,EAAO9G,GACtEwrC,EAAS79B,KAAK,GAAI29B,IAChBxkC,MAAOA,EACP9G,IAAKA,EACL69B,aAAc4N,EAAYvlC,IAAIY,GAC9BkkC,OAAQD,EAAezO,EAAMhqB,MAAMxL,EAAO9G,GAAK8E,SAAUgC,QAItD8I,EAAK47B,IAQdE,eAAgB,SAAwBC,GACtC,MAAOA,GAAK/mC,IAAI,SAAUgnC,GACxB,GAAI/N,GAAe+N,EAAQ1lC,IAAI,eAE/B,QADyC,OAAjB23B,EAAwBA,EAAe,KAAO+N,EAAQ1lC,IAAI,OAAS0lC,EAAQ1lC,IAAI,UAAY,IACnF,IAAM0lC,EAAQ1lC,IAAI,UAAU3G,OAC3D8jB,KA5DqB,MAqF5BpnB,GAAOI,QAAU0sB,G7C8vRX,SAAU9sB,EAAQI,EAASF,GAEjC,Y8Ch2RA,SAAS6rB,GAAgBC,EAAUC,GAAe,KAAMD,YAAoBC,IAAgB,KAAM,IAAI1kB,WAAU,qCAEhH,QAASwvB,GAA2BC,EAAM3xB,GAAQ,IAAK2xB,EAAQ,KAAM,IAAIC,gBAAe,4DAAgE,QAAO5xB,GAAyB,gBAATA,IAAqC,kBAATA,GAA8B2xB,EAAP3xB,EAElO,QAAS6xB,GAAUC,EAAUz2B,GAAc,GAA0B,kBAAfA,IAA4C,OAAfA,EAAuB,KAAM,IAAI6G,WAAU,iEAAoE7G,GAAey2B,GAASx2B,UAAYC,OAAOC,OAAOH,GAAcA,EAAWC,WAAaG,aAAeE,MAAOm2B,EAAUC,YAAY,EAAOC,UAAU,EAAMC,cAAc,KAAe52B,IAAYE,OAAO22B,eAAiB32B,OAAO22B,eAAeJ,EAAUz2B,GAAcy2B,EAASK,UAAY92B,GAEje,GAAIwuB,GAAY,EAAQ,IAEpBlR,EAASkR,EAAUlR,OAGnB4xB,EAA4B5xB,GAC9BxZ,KAAM,QACNu8B,WAAY,YACZpK,KAAM/1B,SAeJ6/B,EAAsB,SAAUoP,GAGlC,QAASpP,KAGP,MAFA1U,GAAgBxrB,KAAMkgC,GAEf1J,EAA2Bx2B,KAAMsvC,EAAsBziC,MAAM7M,KAAM8M,YAe5E,MApBA6pB,GAAUuJ,EAAqBoP,GAQ/BpP,EAAoB9/B,UAAU44B,QAAU,WACtC,MAAOh5B,MAAK0J,IAAI,SAGlBw2B,EAAoB9/B,UAAU8nC,cAAgB,WAC5C,MAAOloC,MAAK0J,IAAI,eAGlBw2B,EAAoB9/B,UAAUk2B,QAAU,WACtC,MAAOt2B,MAAK0J,IAAI,SAGXw2B,GACPmP,EAEF5vC,GAAOI,QAAUqgC,G9Cq3RX,SAAUzgC,EAAQI,EAASF,GAEjC,Y+Cx4RA,SAAS4vC,GAAgBjT,GACvB,GAAIkT,GAAQC,EAAaC,KAAKpT,EAC9B,OAAgB,OAATkT,EAAgB,KAAOA,EAAM,GAUtC,QAASG,GAAmBrT,GAC1B,GAAIsT,GAAaL,EAAgBjT,EACjC,OAAkB,OAAdsT,EACKjK,EAAqBC,QAEvBiK,EAAUH,KAAKE,GAAcjK,EAAqBR,IAAMQ,EAAqBT,IAgBtF,QAAS4K,GAAgBxT,EAAKyT,GAE5B,GADAA,EAAWA,GAAYpK,EAAqBC,SACvCtJ,EAAI75B,OACP,MAAOstC,EAET,IAAIC,GAAWL,EAAmBrT,EAClC,OAAO0T,KAAarK,EAAqBC,QAAUmK,EAAWC,EAqBhE,QAASC,GAAa3T,EAAK4T,GAKzB,MAJKA,KACHA,EAAiBvK,EAAqBD,gBAEvCC,EAAqBX,SAASkL,IAA8HjmC,GAAU,GAChK6lC,EAAgBxT,EAAK4T,GAW9B,QAASC,GAAe7T,EAAK4T,GAC3B,MAAOD,GAAa3T,EAAK4T,KAAoBvK,EAAqBT,IAWpE,QAASkL,GAAe9T,EAAK4T,GAC3B,MAAOD,GAAa3T,EAAK4T,KAAoBvK,EAAqBR,IAzHpE,GAAIQ,GAAuB,EAAQ,KAE/B17B,EAAY,EAAQ,IAUpBomC,GAEFC,EAAG,0iDAEHC,EAAG,wFAEHC,GAAI,+GAIFf,EAAe,GAAI1K,QAAO,IAAMsL,EAAmBC,EAAID,EAAmBE,EAAIF,EAAmBG,GAAK,KAEtGX,EAAY,GAAI9K,QAAO,IAAMsL,EAAmBE,EAAIF,EAAmBG,GAAK,KAoG5EC,GACFlB,gBAAiBA,EACjBI,mBAAoBA,EACpBG,gBAAiBA,EACjBG,aAAcA,EACdE,eAAgBA,EAChBC,eAAgBA,EAGlB3wC,GAAOI,QAAU4wC,G/Ci8RX,SAAUhxC,EAAQI,EAASF,GAEjC,YgD7kSAF,GAAOI,SACL6wC,MACEC,WAAY,QAGdC,MACEC,WAAY,YACZC,SAAU,cAGZC,QACEC,UAAW,UAGbC,eACEC,eAAgB,gBAGlBC,WACED,eAAgB,ehDmmSd,SAAUzxC,EAAQI,EAASF,GAEjC,YiDxnSA,SAASyxC,GAAuBxlB,GAC9B,GAAIC,GAAYD,EAAY6E,eACxBqB,EAAYjG,EAAUqJ,eACtBmc,EAAYzlB,EAAYuF,aAAaW,GACrCzvB,EAASwpB,EAAU+B,iBAEnB0jB,GAAY,CAuBhB,OArBAD,GAAUl0B,KAAK,SAAUiyB,GACvB,MAAI/sC,KAAW+sC,EAAQ1lC,IAAI,UACzB4nC,GAAY,GACL,GAGLjvC,EAAS+sC,EAAQ1lC,IAAI,QAChB0lC,EAAQ1lC,IAAI,UAAUyT,KAAK,SAAUo0B,GAC1C,GAAIC,GAAYD,EAAK7nC,IAAI,QACzB,OAAIrH,KAAWmvC,IACbF,GAAY,GACL,OAURA,EAGT7xC,EAAOI,QAAUuxC,GjD4oSX,SAAU3xC,EAAQI,EAASF,GAEjC,YkD1qSA,SAAS6rB,GAAgBC,EAAUC,GAAe,KAAMD,YAAoBC,IAAgB,KAAM,IAAI1kB,WAAU,qCAEhH,QAASwvB,GAA2BC,EAAM3xB,GAAQ,IAAK2xB,EAAQ,KAAM,IAAIC,gBAAe,4DAAgE,QAAO5xB,GAAyB,gBAATA,IAAqC,kBAATA,GAA8B2xB,EAAP3xB,EAElO,QAAS6xB,GAAUC,EAAUz2B,GAAc,GAA0B,kBAAfA,IAA4C,OAAfA,EAAuB,KAAM,IAAI6G,WAAU,iEAAoE7G,GAAey2B,GAASx2B,UAAYC,OAAOC,OAAOH,GAAcA,EAAWC,WAAaG,aAAeE,MAAOm2B,EAAUC,YAAY,EAAOC,UAAU,EAAMC,cAAc,KAAe52B,IAAYE,OAAO22B,eAAiB32B,OAAO22B,eAAeJ,EAAUz2B,GAAcy2B,EAASK,UAAY92B,GARje,GAAIkuB,GAAU,EAAQ,GAElBC,EAAWD,GAAW,SAAUE,GAAU,IAAK,GAAI1a,GAAI,EAAGA,EAAI/G,UAAUrK,OAAQoR,IAAK,CAAE,GAAI2a,GAAS1hB,UAAU+G,EAAI,KAAK,GAAI3L,KAAOsmB,GAAcnuB,OAAOD,UAAUoiB,eAAe1d,KAAK0pB,EAAQtmB,KAAQqmB,EAAOrmB,GAAOsmB,EAAOtmB,IAAY,MAAOqmB,IAQ7OkjB,EAAkB,EAAQ,KAC1BtQ,EAAiB,EAAQ,KACzB0E,EAAQ,EAAQ,GAChB6L,EAAW,EAAQ,GACnBC,EAAS,EAAQ,KACjBhJ,EAAQ,EAAQ,KAChB8H,EAAc,EAAQ,KACtB9K,EAAuB,EAAQ,KAE/B3H,EAAK,EAAQ,IACb4T,EAAqB,EAAQ,KAC7B1I,EAAoB,EAAQ,KAC5B2I,EAAwB,EAAQ,KAChC5nC,EAAY,EAAQ,IACpB2vB,EAAa,EAAQ,IAOrBkY,EAAyB,SAAgCjmB,EAAW3jB,GACtE,MAAO2jB,GAAUqJ,iBAAmBhtB,GAAO2jB,EAAUmJ,gBAAkB9sB,GAUrEkjC,EAAmB,SAAU2G,GAG/B,QAAS3G,KAGP,MAFA5f,GAAgBxrB,KAAMorC,GAEf5U,EAA2Bx2B,KAAM+xC,EAAiBllC,MAAM7M,KAAM8M,YA2IvE,MAhJA6pB,GAAUyU,EAAkB2G,GAQ5B3G,EAAiBhrC,UAAU4xC,sBAAwB,SAA+BC,GAChF,MAAOjyC,MAAK+4B,MAAMzM,QAAU2lB,EAAU3lB,OAAStsB,KAAK+4B,MAAMoW,OAAS8C,EAAU9C,MAAQnvC,KAAK+4B,MAAMyG,YAAcyS,EAAUzS,WAAasS,EAAuBG,EAAUpmB,UAAWomB,EAAU3lB,MAAMuD,WAAaoiB,EAAUnmB,gBAiB1Nsf,EAAiBhrC,UAAU8xC,kBAAoB,WAC7C,GAAIrmB,GAAY7rB,KAAK+4B,MAAMlN,UACvBgJ,EAAShJ,EAAUkS,WACvB,IAAKlS,EAAU4F,eAAiBoD,IAAW70B,KAAK+4B,MAAMzM,MAAMuD,SAA5D,CAIA,GAAIsiB,GAAYT,EAASU,YAAYpyC,MACjCqyC,EAAe1J,EAAME,gBAAgBsJ,GACrC3I,EAAiBN,EAAkBmJ,GACnCC,MAAc,EAElB,IAAID,IAAiBjU,OAAQ,CAC3B,GAAImU,GAAeX,EAAmBO,EAGtCG,GAFiBC,EAAatI,EAAIsI,EAAaC,OAC1BX,IAAwBW,OAEzCF,EAAc,GAChBlU,OAAOqU,SAASjJ,EAAe33B,EAAG23B,EAAeS,EAAIqI,EA7DzC,QA+DT,CACHH,YAAqBO,cAA6GzoC,GAAU,EAG9IqoC,GAFkBH,EAAUQ,aAAeR,EAAUS,WAClCP,EAAaM,aAAenJ,EAAeS,GAE1DqI,EAAc,GAChBX,EAAOkB,OAAOR,EAAcV,EAAOmB,OAAOT,GAAgBC,EArE9C,OA0ElBlH,EAAiBhrC,UAAU2yC,gBAAkB,WAC3C,GAAIC,GAAShzC,KAETssB,EAAQtsB,KAAK+4B,MAAMzM,MACnB8E,EAAW9E,EAAMuD,SACjB6D,EAAOpH,EAAM2M,UACbga,EAAcjzC,KAAK+4B,MAAMoW,KAAKpsC,KAAO,EACrCmwC,EAAepB,EAAuB9xC,KAAK+4B,MAAMlN,UAAWuF,EAEhE,OAAOpxB,MAAK+4B,MAAMoW,KAAK/mC,IAAI,SAAUgnC,EAASzsC,GAC5C,GAAIwwC,GAAmB/D,EAAQ1lC,IAAI,UAC/B0pC,EAAWD,EAAiBpwC,KAAO,EACnCyrC,EAAS2E,EAAiB/qC,IAAI,SAAUmpC,EAAM8B,GAChD,GAAI7R,GAAYL,EAAeC,OAAOhQ,EAAUzuB,EAAI0wC,GAChD/oC,EAAQinC,EAAK7nC,IAAI,SACjBlG,EAAM+tC,EAAK7nC,IAAI,MACnB,OAAOm8B,GAAME,cAAc0L,GACzBvpC,IAAKs5B,EACLA,UAAWA,EACXlV,MAAOA,EACPhiB,MAAOA,EACPuhB,UAAWqnB,EAAeF,EAAOja,MAAMlN,UAAY,KACnDC,eAAgBknB,EAAOja,MAAMjN,eAC7B4H,KAAMA,EAAK5d,MAAMxL,EAAO9G,GACxB8vC,SAAUhnB,EAAMyB,iBAAiBzjB,GACjCipC,eAAgBP,EAAOja,MAAMwa,eAC7BC,cAAeR,EAAOja,MAAMya,cAC5BC,OAAQ9wC,IAAOswC,GAAeI,IAAOD,MAEtC1/B,UAEC2tB,EAAe+N,EAAQ1lC,IAAI,eAC/B,IAAoB,MAAhB23B,EACF,MAAOmN,EAGT,KAAKwE,EAAOja,MAAM3M,UAChB,MAAOoiB,EAGT,IAAIpiB,GAAYwN,EAAWoZ,EAAOja,MAAM3M,WAEpCsnB,EAAqBtnB,EAAUunB,mBAAmBtS,EACtD,KAAKqS,EACH,MAAOlF,EAGT,IAAIoF,GAAiBxnB,EAAUynB,eAAexS,GAC1CyS,EAAqB3S,EAAeC,OAAOhQ,EAAUzuB,EAAI,GACzDoxC,EAAgBrgB,EAAK5d,MAAMq9B,EAAiBjrB,QAAQxe,IAAI,SAAUypC,EAAiBvqB,OAAOlf,IAAI,QAI9Fu7B,EAAMU,EAAqBN,sBAAsBoL,EAAYR,aAAa8D,GAAgBf,EAAOja,MAAMyG,UAE3G,OAAOqG,GAAME,cACX2N,EACAplB,KAAaslB,GACXznB,aAAc6mB,EAAOja,MAAM5M,aAC3B4nB,cAAeA,EACf9O,IAAKA,EACL/8B,IAAK4rC,EACLlgB,UAAWtH,EAAMiJ,YAAY6Z,EAAQ1lC,IAAI,UACzC83B,UAAWsS,IACbtF,KAED96B,WAGL03B,EAAiBhrC,UAAU4zC,OAAS,WAClC,GAAIC,GAASj0C,KAAK+4B,MACdyG,EAAYyU,EAAOzU,UACnBgC,EAAYyS,EAAOzS,UAEnBtD,EAAYF,GACd,kCAAkC,EAClC,+BAA8C,QAAdwB,EAChC,+BAA8C,QAAdA,GAGlC,OAAOqG,GAAME,cACX,OACE,kBAAmBvE,EAAWtD,UAAWA,GAC3Cl+B,KAAK+yC,oBAIF3H,GACPvF,EAAMqO,UAERz0C,GAAOI,QAAUurC,GlDksSX,SAAU3rC,EAAQI,EAASF,GAEjC,YmD13SA,SAASw0C,GAAiBC,GAExB,OAAmB,MADnBA,EAAMA,IAA4B,mBAAb9K,UAA2BA,aAAWxmC,KAEzD,MAAO,KAET,KACE,MAAOsxC,GAAIC,eAAiBD,EAAIrL,KAChC,MAAO9lB,GACP,MAAOmxB,GAAIrL,MAIftpC,EAAOI,QAAUs0C,GnDs5SX,SAAU10C,EAAQI,EAASF,GAEjC,YoD56SA,SAAS20C,GAAyBnO,EAASiO,GACzC,QAASA,IAAQjO,IAAYiO,EAAIlnC,iBAAmBi5B,IAAYiO,EAAIrL,MAgBtE,GAAI4I,IAKFmB,OAAQ,SAAgB3M,GACtB,GAAIiO,GAAMjO,EAAQ2C,aAClB,OAAOwL,GAAyBnO,EAASiO,GAIzCA,EAAIrL,KAAKwL,WAAaH,EAAIlnC,gBAAgBqnC,UAAYpO,EAAQoO,WAOhE1B,OAAQ,SAAgB1M,EAASqO,GAC/B,GAAIJ,GAAMjO,EAAQ2C,aACdwL,GAAyBnO,EAASiO,GACpCA,EAAIrL,KAAKwL,UAAYH,EAAIlnC,gBAAgBqnC,UAAYC,EAErDrO,EAAQoO,UAAYC,GAQxBC,QAAS,SAAiBtO,GACxB,GAAIiO,GAAMjO,EAAQ2C,aAClB,OAAOwL,GAAyBnO,EAASiO,GAAOA,EAAIrL,KAAK2L,YAAcN,EAAIlnC,gBAAgBwnC,WAAavO,EAAQuO,YAOlHC,QAAS,SAAiBxO,EAASyO,GACjC,GAAIR,GAAMjO,EAAQ2C,aACdwL,GAAyBnO,EAASiO,GACpCA,EAAIrL,KAAK2L,WAAaN,EAAIlnC,gBAAgBwnC,WAAaE,EAEvDzO,EAAQuO,WAAaE,GAK3Bn1C,GAAOI,QAAU8xC,GpDg8SX,SAAUlyC,EAAQI,EAASF,GAEjC,YqDlhTA,SAAS6rB,GAAgBC,EAAUC,GAAe,KAAMD,YAAoBC,IAAgB,KAAM,IAAI1kB,WAAU,qCA8BhH,QAAS6tC,GAAwBC,GAC/B,GAAiB,QAAbA,EAAKC,KACP,MAAOD,GAAKE,YArBhB,GAAIC,GAAiB,EAAQ,KAEzBC,EAAuB,EAAQ,KAC/BtS,EAAgB,EAAQ,KAExBuS,EAAc,GAAIpQ,QAAO,OAAQ,KAGjCqQ,GACF,WAAY,EACZ,YAAa,GAeXC,EAAe,WAIjB,QAASA,GAAajf,GACpB5K,EAAgBxrB,KAAMq1C,GAEtBr1C,KAAKo2B,KAAOA,EAGZp2B,KAAKs1C,MAAQlf,EAAKkf,MAAQJ,EAAqB9e,EAAKkf,UAuKtD,MA7JAD,GAAaj1C,UAAUm1C,WAAa,WAKlC,SAAIv1C,KAAKw1C,YAAax1C,KAAKi5B,aAMvBj5B,KAAKy1C,WAIFz1C,KAAKs1C,MAAMn4B,KAAK,SAAUlZ,GAC/B,MAAOmxC,GAAgBnxC,MAW3BoxC,EAAaj1C,UAAU64B,QAAU,WAC/B,GAAIvF,EAQJ,OAPI1zB,MAAKo2B,KAAKE,UACPt2B,KAAKs1C,MAAM7yC,QAEgC,GAArCzC,KAAKs1C,MAAM5yB,QAAQ,gBAC5BgR,EAAO1zB,KAAKo2B,KAAKE,QAAQ,eAFzB5C,EAAO1zB,KAAKo2B,KAAKE,QAAQ,SAKtB5C,EAAOA,EAAKpI,QAAQ6pB,EA3EjB,MA2EyC,MAUrDE,EAAaj1C,UAAUo1C,QAAU,WAC/B,GAAIx1C,KAAKo2B,KAAKE,QAAS,CACrB,IAAKt2B,KAAKs1C,MAAM7yC,OACd,MAAOzC,MAAKo2B,KAAKE,QAAQ,OACpB,KAAwC,GAApCt2B,KAAKs1C,MAAM5yB,QAAQ,aAC5B,MAAO1iB,MAAKo2B,KAAKE,QAAQ,eAY/B+e,EAAaj1C,UAAUs1C,OAAS,WAC9B,MAAO11C,MAAKs1C,MAAMn4B,KAAK,SAAUlZ,GAC/B,OAA+B,GAAxBA,EAAKye,QAAQ,SAAkD,GAAlCze,EAAKye,QAAQ,kBAA0Bze,EAAKye,QAAQ,qBAW5F2yB,EAAaj1C,UAAUu1C,QAAU,WAC/B,GAAI31C,KAAKo2B,KAAKE,QAAS,CACrB,IAA6C,GAAzCt2B,KAAKs1C,MAAM5yB,QAAQ,kBAAyB,CAE9C,MADU1iB,MAAKo2B,KAAKE,QAAQ,kBAAkBoL,MAAM,MACzC,GAEb,OAA+C,GAAxC1hC,KAAKs1C,MAAM5yB,QAAQ,iBAAyB1iB,KAAKo2B,KAAKE,QAAQ,iBAAmBt2B,KAAKo2B,KAAKE,QAAQ,OAG5G,MAAO,OAUT+e,EAAaj1C,UAAUq1C,QAAU,WAO/B,GANcz1C,KAAKs1C,MAAMn4B,KAAK,SAAUlZ,GAGtC,OAAkD,GAA3CA,EAAKye,QAAQ,4BAIpB,OAAO,CAIT,KAAK,GADDkzB,GAAQ51C,KAAK61C,WACRhiC,EAAI,EAAGA,EAAI+hC,EAAMnzC,OAAQoR,IAAK,CACrC,GAAI5P,GAAO2xC,EAAM/hC,GAAG5P,IACpB,KAAKgxC,EAAeQ,QAAQxxC,GAC1B,OAAO,EAIX,OAAO,GAGToxC,EAAaj1C,UAAU01C,SAAW,WAChC,MAAI91C,MAAKo2B,KAAK5T,eAAe,SACpBxiB,KAAKo2B,KAAKwf,MAAMnzC,OACdzC,KAAKo2B,KAAK5T,eAAe,gBAC3BxiB,KAAKo2B,KAAK2f,aACR/1C,KAAKo2B,KAAK4f,MACZh2C,KAAKo2B,KAAK4f,MAAMvzC,OAElB,MAUT4yC,EAAaj1C,UAAUy1C,SAAW,WAChC,MAAI71C,MAAKo2B,KAAKwf,MAELr2C,MAAMa,UAAU0V,MAAMhR,KAAK9E,KAAKo2B,KAAKwf,OAAOxtC,IAAIysC,GAAyBjjC,OAAOgxB,EAAcM,qBAC5FljC,KAAKo2B,KAAK4f,MACZz2C,MAAMa,UAAU0V,MAAMhR,KAAK9E,KAAKo2B,KAAK4f,WAahDX,EAAaj1C,UAAU61C,SAAW,WAChC,MAAOj2C,MAAK61C,WAAWpzC,OAAS,GAG3B4yC,IAGT51C,GAAOI,QAAUw1C,GrDyhTX,SAAU51C,EAAQI,EAASF,GAEjC,YsDjuTA,SAASyqC,GAA6Bp9B,GACpC,GAAIA,YAAgBkpC,SAAS,CAC3B,GAAI1U,GAAYx0B,EAAKmpC,aAAa,kBAClC,IAAI3U,EACF,MAAOA,EAET,KAAK,GAAI7+B,GAAK,EAAGA,EAAKqK,EAAKopC,WAAW3zC,OAAQE,IAAM,CAClD,GAAI0zC,GAAiBjM,EAA6Bp9B,EAAKopC,WAAWzzC,GAClE,IAAI0zC,EACF,MAAOA,IAIb,MAAO,MAGT52C,EAAOI,QAAUuqC,GtD0vTX,SAAU3qC,EAAQI,EAASF,GAEjC,cuDhyTA,YA+BA,QAAS22C,GAAwBN,EAAOtc,GACtC,GAAI6c,GAAY,EACZC,IACJR,GAAMxoC,QAAQ,SAAmBipC,GAC/BC,EAASD,EAAM,SAAqB/iB,GAClC6iB,IACA7iB,GAAQ8iB,EAAQrlC,KAAKuiB,EAAK5d,MAAM,EAAG6gC,IAC/BJ,GAAaP,EAAMvzC,QACrBi3B,EAAS8c,EAAQ3vB,KAAK,WAS9B,QAAS6vB,GAASD,EAAM/c,GACtB,IAAK55B,EAAO82C,YAAcH,EAAKxyC,QAAUwyC,EAAKxyC,OAAQ4yC,IAEpD,WADAnd,GAAS,GAIX,IAAkB,KAAd+c,EAAKxyC,KAAa,CACpB,GAAI6yC,GAAW,EASf,OAJIC,GAAoBna,KAAK6Z,EAAK94B,QAChCm5B,EAAWL,EAAK94B,KAAK2N,QAAQyrB,EAAqB,SAEpDrd,GAASod,GAIX,GAAIE,GAAS,GAAIJ,WACjBI,GAAOC,OAAS,WACd,GAAIC,GAASF,EAAOE,MACA,iBAAXA,IAAyJjtC,GAAU,GAC5KyvB,EAASwd,IAEXF,EAAOG,QAAU,WACfzd,EAAS,KAEXsd,EAAOI,WAAWX,GA7DpB,GAAIxsC,GAAY,EAAQ,IAEpB8sC,EAAsB,kBAEtBF,GACF,cAAc,EACd,aAAa,EACb,YAAY,GAIVF,EAAwB,GAqD5Bl3C,GAAOI,QAAUy2C,IvDkyTYxxC,KAAKjF,EAASF,EAAoB,KAIzD,SAAUF,EAAQI,EAASF,GAEjC,YwDp2TA,SAAS03C,GAAyBzrB,EAAakG,EAAWC,EAAcC,EAAUC,GAChF,GAAIpG,GAAY+N,EAAWhO,EAAY6E,gBAUnC6mB,EAAanW,EAAeI,OAAOzP,GACnCylB,EAAiBD,EAAWlmB,SAC5BomB,EAAa5rB,EAAYuF,aAAaomB,GAAgBlvB,OAAOivB,EAAWjW,aAAc,SAAUiW,EAAWhW,UAE3GmW,EAAYtW,EAAeI,OAAOvP,GAClC0lB,EAAgBD,EAAUrmB,SAC1BumB,EAAY/rB,EAAYuF,aAAaumB,GAAervB,OAAOovB,EAAUpW,aAAc,SAAUoW,EAAUnW,UAEvGsW,EAAkBJ,EAAW9tC,IAAI,SACjCmuC,EAAiBF,EAAUjuC,IAAI,SAE/BouC,EAAoBN,EAAaI,EAAkB7lB,EAAe,KAClEgmB,EAAmBJ,EAAYE,EAAiB5lB,EAAc,IAIlE,IAFepG,EAAUqJ,iBAAmBqiB,GAAkB1rB,EAAUsJ,oBAAsB2iB,GAAqBjsB,EAAUmJ,gBAAkB0iB,GAAiB7rB,EAAUoJ,mBAAqB8iB,EAG7L,MAAOlsB,EAGT,IAAIqG,IAAa,CACjB,IAAIqlB,IAAmBG,EAAe,CACpC,GAAIM,GAAgBR,EAAW9tC,IAAI,OAC/BuuC,EAAeN,EAAUjuC,IAAI,MAE/BwoB,GADE2lB,IAAmBD,GAAmBK,IAAiBD,EAC5C/lB,EAAcF,EAEd8lB,EAAiBD,MAE3B,CAIL1lB,EAHetG,EAAYgB,oBAAoBP,cAAcxG,SAASuD,UAAU,SAAUjlB,GACxF,MAAOA,KAAMozC,GAAkBpzC,IAAMuzC,IACpCxvB,UACuBwvB,EAG5B,MAAO7rB,GAAUvI,OACfwO,UAAWylB,EACXxlB,aAAc+lB,EACd9lB,SAAU0lB,EACVzlB,YAAa8lB,EACb7lB,WAAYA,IAxDhB,GAAIiP,GAAiB,EAAQ,KAEzBvH,EAAa,EAAQ,GA0DzBn6B,GAAOI,QAAUw3C,GxD43TX,SAAU53C,EAAQI,EAASF,GAEjC,YyDx7TA,SAASu4C,GAAyBtsB,GAChC,GAAIiK,GAAiBjK,EAAY6E,cAEjC,OAAIoF,GAAe3E,cACV,KAGF8B,EAAwBpH,EAAYgB,oBAAqBiJ,GATlE,GAAI7C,GAA0B,EAAQ,IAYtCvzB,GAAOI,QAAUq4C,GzD88TX,SAAUz4C,EAAQI,EAASF,GAEjC,Y0Dh9TA,SAASw4C,GAA0Bje,GAIjC,IAAK,GAHDke,GAAYle,EAAMme,aAClBC,KAEKC,EAAWre,EAAMse,aAA0B,MAAZD,EAAkBA,EAAWA,EAAShQ,WAAY,CAGxF,GAAIkQ,GAAmBF,IAAare,EAAMwe,uBACtCD,GACFL,EAAUO,SAASze,EAAM0e,eAAgB1e,EAAMvM,aAE/CyqB,EAAUO,SAASP,EAAUI,aAAc,EAE7C,IAAIK,GAAQt5C,MAAMgV,KAAK6jC,EAAUU,iBAEjC,IADAR,EAAYnnC,KAAK0nC,GACbJ,EAAkB,CACpB,GAAIM,EAGJ,OADAT,GAAYlxC,WACJ2xC,MAAWv5C,OAAOqN,MAAMksC,EAAMT,GAExCF,EAAUY,aAAaT,GAGoHtuC,GAAU,GApCzJ,GAAIwwB,GAAY,EAAQ,IAEpBxwB,EAAY,EAAQ,IAEpBgvC,EAAWxe,EAAUC,UAAU,UAuC/Bwe,EAAsBD,EAAWd,EAA4B,SAAUje,GACzE,MAAO36B,OAAMgV,KAAK2lB,EAAM4e,kBAG1Br5C,GAAOI,QAAUq5C,G1Dg/TX,SAAUz5C,EAAQI,EAASF,GAEjC,Y2DvhUA,SAASw5C,GAAiCvtB,EAAa7c,EAAMqqC,EAAYrnB,EAAcsnB,EAAWpnB,GAChG,GAAIqnB,GAAmBF,EAAWrsC,WAAawsC,KAAKC,UAChDC,EAAkBJ,EAAUtsC,WAAawsC,KAAKC,SAKlD,IAAIF,GAAoBG,EACtB,OACE5jB,eAAgBwhB,EAAyBzrB,EAAagO,EAAWsQ,EAAsBkP,IAAcrnB,EAAc6H,EAAWsQ,EAAsBmP,IAAapnB,GACjKynB,eAAe,EAInB,IAAIC,GAAc,KACdC,EAAa,KACbF,GAAgB,CA6CpB,OAzBIJ,IACFK,GACEzxC,IAAK0xB,EAAWsQ,EAAsBkP,IACtC/2C,OAAQ0vB,GAEV6nB,EAAaC,EAAuB9qC,EAAMsqC,EAAWpnB,IAC5CwnB,GACTG,GACE1xC,IAAK0xB,EAAWsQ,EAAsBmP,IACtCh3C,OAAQ4vB,GAEV0nB,EAAcE,EAAuB9qC,EAAMqqC,EAAYrnB,KAEvD4nB,EAAcE,EAAuB9qC,EAAMqqC,EAAYrnB,GACvD6nB,EAAaC,EAAuB9qC,EAAMsqC,EAAWpnB,GAMjDmnB,IAAeC,GAAatnB,IAAiBE,IAC/CynB,IAAkBN,EAAWU,YAAiD,OAAnCV,EAAWU,WAAWC,YAKnElkB,eAAgBwhB,EAAyBzrB,EAAa+tB,EAAYzxC,IAAKyxC,EAAYt3C,OAAQu3C,EAAW1xC,IAAK0xC,EAAWv3C,QACtHq3C,cAAeA,GAOnB,QAASM,GAAahtC,GACpB,KAAOA,EAAK8sC,aAEZ9sC,EAAK8sC,qBAAsB5D,UAA2D,SAAhDlpC,EAAK8sC,WAAW3D,aAAa,gBAA6B/L,EAA6Bp9B,EAAK8sC,cAChI9sC,EAAOA,EAAK8sC,UAEd,OAAO9sC,GAMT,QAASitC,GAAYjtC,GACnB,KAAOA,EAAKktC,YAEZltC,EAAKktC,oBAAqBhE,UAA0D,SAA/ClpC,EAAKktC,UAAU/D,aAAa,gBAA6B/L,EAA6Bp9B,EAAKktC,aAC9HltC,EAAOA,EAAKktC,SAEd,OAAOltC,GAGT,QAAS6sC,GAAuBM,EAAYC,EAAWC,GACrD,GAAIrtC,GAAOotC,EACP5Y,EAAY0I,EAAsBl9B,EAkBtC,IAhBe,MAAbw0B,GAAqB2Y,IAAeA,IAAentC,GAAQmtC,EAAWL,aAAe9sC,IAAwG/C,GAAU,GAIrMkwC,IAAentC,IACjBA,EAAOA,EAAK8sC,WACV9sC,YAAgBkpC,UAAkD,SAAvClpC,EAAKmpC,aAAa,kBAAoIlsC,GAAU,GACzLowC,EAAc,IAChBA,EAAcrtC,EAAKopC,WAAW3zC,SAQd,IAAhB43C,EAAmB,CACrB,GAAInyC,GAAM,IACV,IAAiB,MAAbs5B,EACFt5B,EAAMs5B,MACD,CACL,GAAI8Y,GAAYN,EAAahtC,EAC7B9E,GAAM0xB,EAAWwQ,EAA6BkQ,IAEhD,OAASpyC,IAAKA,EAAK7F,OAAQ,GAG7B,GAAIk4C,GAAmBvtC,EAAKopC,WAAWiE,EAAc,GACjD/Y,EAAU,KACVyN,EAAa,IAEjB,IAAK3E,EAA6BmQ,GAM3B,CAGL,GAAInH,GAAW6G,EAAYM,EAC3BjZ,GAAU1H,EAAWwQ,EAA6BgJ,IAClDrE,EAAayL,EAAqBpH,OAPlC9R,GAAU1H,EAAW4H,GACrBuN,EAAayL,EAAqBD,EASpC,QACEryC,IAAKo5B,EACLj/B,OAAQ0sC,GAUZ,QAASyL,GAAqBxtC,GAC5B,GAAIytC,GAAcztC,EAAKytC,WACvB,OAAuB,OAAhBA,EAAuB,EAAIA,EAAYh4C,OApKhD,GAAIynC,GAAwB,EAAQ,KAChCE,EAA+B,EAAQ,KACvCiN,EAA2B,EAAQ,KACnCptC,EAAY,EAAQ,IACpB2vB,EAAa,EAAQ,GAmKzBn6B,GAAOI,QAAUs5C,G3DqjUX,SAAU15C,EAAQI,EAASF,GAEjC,Y4D1sUA,SAAS+6C,GAAiBhnB,EAAMxB,GAC9B,GAAIyoB,GAAUzoB,EAAa0oB,EAAgBlL,KAAKhc,GAAQmnB,EAAanL,KAAKhc,EAC1E,OAAOinB,GAAUA,EAAQ,GAAKjnB,EAtBhC,GAAIonB,GAAe,EAAQ,KAEvBC,EAAcD,EAAaE,iBAU3BC,EAA6B,cAAgBF,EAE7CG,EAAgB,OAAcD,EAA6B,iBAA0CA,EAA6B,aAAoBA,EAA6B,MACnLJ,EAAe,GAAI9V,QAAOmW,GAE1BC,EAAmB,SAAWF,EAA6B,kBAA2CA,EAA6B,UAAiBA,EAA6B,MACjLL,EAAkB,GAAI7V,QAAOoW,GAO7BC,GACFC,YAAa,SAAqB3nB,GAChC,MAAOgnB,GAAiBhnB,GAAM,IAGhC4nB,WAAY,SAAoB5nB,GAC9B,MAAOgnB,GAAiBhnB,GAAM,IAIlCj0B,GAAOI,QAAUu7C,G5DkvUX,SAAU37C,EAAQI,EAASF,GAEjC,Y6D/wUA,SAAS47C,GAAqB3vB,EAAakf,GACzC,GAMI7Y,GANApG,EAAYD,EAAY6E,eACxBvoB,EAAM2jB,EAAU6B,cAChBrrB,EAASwpB,EAAU+B,iBACnBZ,EAAUpB,EAAYgB,oBAEtBoF,EAAW9pB,CAYf,OAPI4iC,GAFQ9d,EAAQc,eAAe5lB,GAEX+wB,UAAUx2B,OAASJ,GACzC2vB,EAAWhF,EAAQ6W,YAAY37B,GAC/B+pB,EAAc,GAEdA,EAAc5vB,EAASyoC,EAGlBjf,EAAUvI,OAAQ0O,SAAUA,EAAUC,YAAaA,IAG5DxyB,EAAOI,QAAU07C,G7D2yUX,SAAU97C,EAAQI,EAASF,GAEjC,Y8Dr0UA,SAAS67C,GAAgBtvC,EAAKhE,EAAKzH,GAAiK,MAApJyH,KAAOgE,GAAO7L,OAAOuM,eAAeV,EAAKhE,GAAOzH,MAAOA,EAAOo2B,YAAY,EAAME,cAAc,EAAMD,UAAU,IAAkB5qB,EAAIhE,GAAOzH,EAAgByL,EAL3M,GAEIuvC,GAFAntB,EAAWD,GAAW,SAAUE,GAAU,IAAK,GAAI1a,GAAI,EAAGA,EAAI/G,UAAUrK,OAAQoR,IAAK,CAAE,GAAI2a,GAAS1hB,UAAU+G,EAAI,KAAK,GAAI3L,KAAOsmB,GAAcnuB,OAAOD,UAAUoiB,eAAe1d,KAAK0pB,EAAQtmB,KAAQqmB,EAAOrmB,GAAOsmB,EAAOtmB,IAAY,MAAOqmB,IAG7OF,EAAU,EAAQ,GAIlBsE,EAAoB,EAAQ,IAC5BoJ,EAAe,EAAQ,IACvBlD,EAAmB,EAAQ,IAC3BqN,EAA6B,EAAQ,KACrC7F,EAAc,EAAQ,KACtBxN,EAAoB,EAAQ,IAC5BlE,EAAY,EAAQ,IAEpBuI,EAAW,EAAQ,IACnBvY,EAAMuY,EAASvY,IAEf+8B,EAAM,EAAQ,KAEd1d,EAAK,EAAQ,IACbxC,EAAoB,EAAQ,IAC5BmgB,EAAsB,EAAQ,KAC9B1xC,EAAY,EAAQ,IACpBk5B,EAAoB,EAAQ,KAE5BC,EAA8BvQ,EAAkBwQ,wBAEhDjwB,EAAOub,EAAUvb,KACjBmM,EAAaoP,EAAUpP,WAUvBq8B,EAAW,GAAI7W,QAAO,KAAM,KAC5B8W,EAAW,GAAI9W,QAAO,KAAM,KAC5B+W,EAAa,GAAI/W,QATV,SASuB,KAC9BgX,EAAiB,GAAIhX,QAAO,SAAU,KACtCiX,EAAY,GAAIjX,QAAO,WAAY,KAGnCkX,GAAc,OAAQ,SAAU,MAAO,MAAO,MAAO,MAAO,OAC5DC,GAAiB,QAAS,UAAW,MAAO,MAAO,MAAO,OAI1DC,GACFpzC,EAAG,OACHqzC,KAAM,OACNC,IAAK,gBACLC,GAAI,SACJzoC,EAAG,SACHuJ,EAAG,gBACHm/B,OAAQ,gBACRC,OAAQ,OACRC,EAAG,aAGDC,GAA6BjB,KAA4BD,EAAgBC,EAAuBzd,EAAG,mCAAoC,GAAIwd,EAAgBC,EAAuBzd,EAAG,mCAAoC,GAAIwd,EAAgBC,EAAuBzd,EAAG,mCAAoC,GAAIwd,EAAgBC,EAAuBzd,EAAG,mCAAoC,GAAIwd,EAAgBC,EAAuBzd,EAAG,mCAAoC,GAAIyd,GAEndkB,GAAc,YAAa,OAAQ,MAAO,SAAU,SAEpDC,GAAW,MAAO,YAAa,SAAU,MAAO,SAEhDjrB,MAAY,GAEZkrB,GACFnpB,KAAM,GACNopB,WACAC,YACAhe,WAGEie,GACF3kB,SAAUjlB,IACVuI,MAAO,EACPzT,IAAK,GACLjE,KAAM,IAGJg5C,EAAmB,SAA0BC,EAAKC,GACpD,MAAY,OAARD,EACkB,OAAbC,EAAoB,oBAAsB,sBAE5C,MAGLC,EAA2B,SAAkCC,GAC/D,GAAIC,GAAkBD,EAAe3zC,IAAI,YAAYy8B,QACjDoX,EAAO5+B,KAYX,OAVA0+B,GAAe7vC,QAAQ,SAAUgwC,GAC3BA,EAAWhX,iBACbgX,EAAWhX,gBAAgBh5B,QAAQ,SAAU0vC,GAC3CK,EAAOA,EAAKz+B,IAAIo+B,KAIpBK,EAAOA,EAAKz+B,IAAI0+B,EAAWrX,WAGtBoX,EAAK3rC,OAAO,SAAUsrC,GAC3B,MAAOA,IAAOA,IAAQI,IACrB5pC,UAAU8I,QAIXihC,EAAsB,SAA6BP,EAAKC,EAAUO,GACpE,IAAK,GAAI/6C,GAAK,EAAGA,EAAK+6C,EAAoBj7C,OAAQE,IAAM,CACtD,GAAIg7C,GAAYD,EAAoB/6C,GAAIu6C,EAAKC,EAC7C,IAAIQ,EACF,MAAOA,GAGX,MAAO,OAGLC,EAAqB,SAA4BV,EAAKC,EAAUE,GAClE,GAAIQ,GAAeR,EAAezrC,OAAO,SAAU4rC,GACjD,MAAOA,GAAWrX,UAAY+W,GAAOM,EAAWpX,UAAY8W,GAAOM,EAAWhX,iBAAmBgX,EAAWhX,gBAAgBrpB,KAAK,SAAU2gC,GACzI,MAAOA,KAAUZ,MAElBr3B,SAASa,QAAQhT,UAAU8I,MAK9B,QAAQqhC,EAAap7C,QACnB,IAAK,GACH,MAAO,UACT,KAAK,GACH,MAAOo7C,GAAa,EACtB,SACE,MAAOJ,GAAoBP,EAAKC,GAAWF,KAAsB,aAInEc,EAAmB,SAA0Bb,EAAKlwC,EAAMgxC,GAC1D,GAAIC,GAAe9B,EAAWe,EAC9B,IAAIe,EACFD,EAAeA,EAAal/B,IAAIm/B,GAAcx3B,mBACzC,IAAIzZ,YAAgB0lC,aAAa,CACtC,GAAIwL,GAAclxC,CAClBgxC,GAAeA,EAAazwC,cAAc,SAAUymB,GAClD,GAAI2c,GAAauN,EAAYlqB,MAAM2c,WAC/BK,EAAYkN,EAAYlqB,MAAMgd,UAC9BE,EAAiBgN,EAAYlqB,MAAMkd,cAEnC+K,GAAWv5B,QAAQiuB,IAAe,EACpC3c,EAAMlV,IAAI,QACDo9B,EAAcx5B,QAAQiuB,IAAe,GAC9C3c,EAAMxhB,OAAO,QAGG,WAAdw+B,EACFhd,EAAMlV,IAAI,UACa,WAAdkyB,GACThd,EAAMxhB,OAAO,UAGQ,cAAnB0+B,GACFld,EAAMlV,IAAI,aAEW,iBAAnBoyB,GACFld,EAAMlV,IAAI,iBAEW,SAAnBoyB,IACFld,EAAMxhB,OAAO,aACbwhB,EAAMxhB,OAAO,oBAEdiU,eAEL,MAAOu3B,IAGLG,EAAa,SAAoBzW,EAAG0W,EAAGC,GAGzC,GAAIC,GAAU5W,EAAEhU,KAAK5d,OAAO,GACxByoC,EAAWH,EAAE1qB,KAAK5d,MAAM,EAAG,EAU/B,IARgB,OAAZwoC,GAAiC,OAAbC,GAAsBF,IAC5C3W,EAAEhU,KAAOgU,EAAEhU,KAAK5d,MAAM,GAAI,GAC1B4xB,EAAEoV,QAAQ3pC,MACVu0B,EAAEqV,SAAS5pC,MACXu0B,EAAE3I,OAAO5rB,OAIK,OAAZmrC,EAAkB,CACpB,GAlKQ,MAkKJF,EAAE1qB,MAA6B,OAAX0qB,EAAE1qB,KACxB,MAAOgU,EAnKD,OAoKG6W,GAAmC,OAAbA,IAC/BH,EAAE1qB,KAAO0qB,EAAE1qB,KAAK5d,MAAM,GACtBsoC,EAAEtB,QAAQltC,QACVwuC,EAAErB,SAASntC,SAIf,OACE8jB,KAAMgU,EAAEhU,KAAO0qB,EAAE1qB,KACjBopB,QAASpV,EAAEoV,QAAQt9C,OAAO4+C,EAAEtB,SAC5BC,SAAUrV,EAAEqV,SAASv9C,OAAO4+C,EAAErB,UAC9Bhe,OAAQ2I,EAAE3I,OAAOv/B,OAAO4+C,EAAErf,UAS1Byf,EAA8B,SAAqCC,EAAMC,GAC3E,MAAOA,GAAUvhC,KAAK,SAAU+/B,GAC9B,OAAoC,IAA7BuB,EAAK/7B,QAAQ,IAAMw6B,MAI1ByB,EAAmB,SAA0BC,GAC7CA,YAAgBC,oBAAsH50C,GAAU,EAClJ,IAAI60C,GAAWF,EAAKE,QACpB,OAAoB,UAAbA,GAAqC,WAAbA,GAAsC,YAAbA,GAGtDC,EAAqB,SAA4BC,GACnD,GAAIjC,GAAW,GAAIx9C,OAAM,EAIzB,OAHIy/C,KACFjC,EAAS,GAAKiC,GAET1wB,KAAauuB,GAClBnpB,KA1MQ,IA2MRopB,SAAUv9B,KACVw9B,SAAUA,KAIVkC,EAAsB,WACxB,MAAO3wB,MAAauuB,GAClBnpB,KAAM,KACNopB,SAAUv9B,KACVw9B,SAAU,GAAIx9C,OAAM,MAIpB2/C,EAAkB,WACpB,GAAInmB,GAAQjsB,UAAUrK,OAAS,OAAsBK,KAAjBgK,UAAU,GAAmBA,UAAU,KAE3E,OAAOwhB,MAAa0uB,EAAajkB,IAG/BomB,EAAuB,SAA8B7yB,EAAO3Q,GAC9D,GAAIoxB,GAAYjgC,UAAUrK,OAAS,OAAsBK,KAAjBgK,UAAU,GAAmBA,UAAU,GAAK,IAEpF,QACE4mB,KAAM,KACNopB,SAAUv9B,KACVw9B,SAAU,GAAIx9C,OAAM,GACpBw/B,QAASmgB,GACP/mB,OAAQ4U,EACR7kC,IAAKszB,IACLv3B,KAAMqoB,EACN3Q,MAAOpZ,KAAKC,IAAI,EAAGD,KAAKsB,IAtOd,EAsO6B8X,SASzCyjC,EAAmB,SAA0BpyC,GAC/C,GAAI2O,GAAQ7O,UAAUrK,OAAS,OAAsBK,KAAjBgK,UAAU,GAAmBA,UAAU,GAAK,CAOhF,OALAzM,QAAO4F,KAAKy2C,GAA2Bv/B,KAAK,SAAUkiC,GAChDryC,EAAKsyC,UAAU31B,SAAS01B,KAC1B1jC,EAAQ+gC,EAA0B2C,MAG/B1jC,GAGL4jC,EAAc,QAASA,GAAYjc,EAAWt2B,EAAM2mB,EAAawpB,EAAUqC,EAASd,EAAW/iC,EAAO0hC,EAAgB2B,EAAUjS,GAClI,GAAI0S,GAAgB9tB,EAChBooB,EAAW/sC,EAAK+sC,SAAS2F,cACzB/yB,EAAe2W,EACfqc,EAAgB,WAChBC,GAAW,EACXC,EAAcL,GAAW5B,EAAmB4B,EAASrC,EAAUE,GAC/DyC,EAAQxxB,KAAauuB,GACrBkD,EAAW,KACX3uB,MAAW,EAGf,IAAiB,UAAb2oB,EAAsB,CACxB,GAAIiG,GAAQhzC,EAAKytC,YACbwF,EAAkBD,EAAME,MAI5B,IAAI/C,GAAgC,KAApB8C,GAA0BjzC,EAAKmzC,cAAe,CAC5D,GAAIC,GAAiBpzC,EAAKmzC,cAAcpG,SAAS2F,aACjD,IAAuB,OAAnBU,GAA8C,OAAnBA,EAC7B,OAASN,MAAOxxB,KAAauuB,GAAcvZ,UAAWA,GAI1D,MAAwB,KAApB2c,GAAsC,QAAZT,GACnBM,MAAOf,EAAmBC,GAAW1b,UAAWA,IAE3C,QAAZkc,IAEFQ,EAAQA,EAAM10B,QAAQuwB,EA3RhB,MA+RRlqB,EAAYooB,GAGV+F,OACEpsB,KAAMssB,EACNlD,QAASv9C,MAAMygD,EAAMv9C,QAAQ49C,KAAK1sB,GAClCopB,SAAUx9C,MAAMygD,EAAMv9C,QAAQ49C,KAAKrB,GACnCjgB,WAEFuE,UAAWA,IAQf,GAHA3R,EAAYooB,EAGK,OAAbA,EACF,MAAsB,OAAlB0F,GAA4BD,GAA2B,aAAhBK,GAMlCC,MAAOb,IAAuB3b,UAAWA,IAJ9Cwc,MAAOX,EAAqB,WAAYxjC,EAAOoxB,GAC/CzJ,UAAWA,EAOjB,IAAiB,QAAbyW,GAAsB/sC,YAAgBszC,mBAAoBtzC,EAAKuzC,WAAWC,aAAa,QAAUxzC,EAAKuzC,WAAWC,aAAa,OAAO//C,MAAO,CAC9I,GAAIggD,GAAQzzC,EACR0zC,IAEJ9D,GAAQpvC,QAAQ,SAAUmzC,GACxB,GAAIC,GAAiBH,EAAMtK,aAAawK,EACpCC,KACFF,EAAaC,GAAQC,KAQzB5zC,EAAKytC,YAAc,KAGnBuE,EAAW3e,EAAYI,SAAS,QAAS,UAAWigB,OAItD/sB,EAAcoqB,EAAiBhE,EAAU/sC,EAAM2mB,GAG9B,OAAbomB,GAAkC,OAAbA,IACnBoD,IACFxhC,GAAS,GAEXwhC,EAAWpD,IAGR3W,GAA4C,OAAb2W,GAAqB/sC,YAAgB0lC,eACvE/2B,EAAQyjC,EAAiBpyC,EAAM2O,GAGjC,IAAIsa,GAAY2nB,EAAmB7D,EAAUoD,EAAUE,GACnDwD,EAAc1D,GAAwB,OAAZqC,GAAiC,OAAbzF,EAC9C+G,IAA6BtB,GAAWpc,KAAiE,IAAjCsb,EAAUh8B,QAAQq3B,IAG1F8G,GAAeC,KACjBhB,EAAQX,EAAqBlpB,EAAWta,EAAOoxB,GAC/C3b,EAAW0uB,EAAM/gB,OAAO,GAAG72B,IAC3Bs3C,EAAUzF,EACV6F,GAAYxc,GAIVyd,IACFlB,EAA6B,OAAbxC,EAAoB,sBAAwB,oBAI9D,IAAIhQ,GAAQngC,EAAK8sC,UACJ,OAAT3M,IACF4M,EAAW5M,EAAM4M,SAAS2F,cAK5B,KAFA,GAAIqB,GAAW,KAER5T,GAAO,CACRA,YAAiB0R,oBAAqB1R,EAAM6T,MAAQrC,EAAiBxR,GACvE,WACE,GAAI8T,GAAS9T,EACTuT,IAEJ/D,GAAWnvC,QAAQ,SAAUmzC,GAC3B,GAAIO,GAAkBD,EAAO9K,aAAawK,EACtCO,KACFR,EAAaC,GAAQO,KAIzBR,EAAaS,IAAM,GAAIzF,GAAIuF,EAAOD,MAAMp1C,WAExCm1C,EAAW1gB,EAAYI,SAAS,OAAQ,UAAWigB,UAGrDK,MAAWj+C,EAGb,IAAIs+C,GAAe7B,EAAY5yB,EAAcwgB,EAAOxZ,EAAawpB,EAAUqC,EAASd,EAAW/iC,EAAO0hC,EAAgB0D,GAAY/B,EAAU5b,EAA8BhS,EAAW,MACjLiwB,EAAiBD,EAAatB,MAC9BwB,EAAwBF,EAAa9d,SAEzCyc,GAAWsB,EACX10B,EAAe20B,EAEfxB,EAAQ3B,EAAW2B,EAAOC,EAAU3c,EACpC,IAAIme,GAAUpU,EAAM5U,aAGfwU,GAAawU,GAAW7C,EAAUh8B,QAAQq3B,IAAa,GAAKyF,IAC/DM,EAAQ3B,EAAW2B,EAAOb,MAExBsC,IACFxH,EAAWwH,EAAQxH,SAAS2F,eAE9BvS,EAAQoU,EAOV,MAJI3B,KACFE,EAAQ3B,EAAW2B,EAAOX,EAAqBQ,EAAehkC,EAAOoxB,MAG9D+S,MAAOA,EAAOxc,UAAW3W,IAGhC60B,EAAkB,SAAyB/C,EAAMgD,EAAYpE,EAAgB/Z,GAC/Emb,EAAOA,EAAKyB,OAAO50B,QAAQswB,EAAU,IAAItwB,QAAQwwB,EAzavC,KAya0DxwB,QAAQywB,EAAgB,IAAIzwB,QAAQ0wB,EAAW,GAEnH,IAAI0F,GAAqBtE,EAAyBC,GAE9CsE,EAAWF,EAAWhD,EAC1B,KAAKkD,EACH,MAAO,KAEThwB,GAAY,IAKZ,IAAIiwB,GAAgBpD,EAA4BC,EAAMiD,GAAsBA,GAAsB,OAI9FhtB,EAAW6qB,EAAYjc,EAAWqe,EAAUpiC,IAAc,KAAM,KAAMqiC,GAAgB,EAAGvE,GAEzFyC,EAAQprB,EAASorB,MACjBnzB,EAAe+H,EAAS4O,SAmC5B,OAhCiC,KAA7Bwc,EAAMpsB,KAAKhR,QAAQ,QACrBo9B,GACEpsB,KAAMosB,EAAMpsB,KAAK5d,MAAM,GACvBgnC,QAASgD,EAAMhD,QAAQhnC,MAAM,GAC7BinC,SAAU+C,EAAM/C,SAASjnC,MAAM,GAC/BipB,OAAQ+gB,EAAM/gB,SAKW,OAAzB+gB,EAAMpsB,KAAK5d,OAAO,KACpBgqC,EAAMpsB,KAAOosB,EAAMpsB,KAAK5d,MAAM,GAAI,GAClCgqC,EAAMhD,QAAUgD,EAAMhD,QAAQhnC,MAAM,GAAI,GACxCgqC,EAAM/C,SAAW+C,EAAM/C,SAASjnC,MAAM,GAAI,GAC1CgqC,EAAM/gB,OAAO5rB,OAIa,IAAxB2sC,EAAM/gB,OAAOt8B,QACfq9C,EAAM/gB,OAAO5tB,KAAKmd,KAAauuB,GAC7B54C,KAAM,WACN0X,MAAO,KAOPmkC,EAAMpsB,KAAKgO,MAAM,MAAMj/B,SAAWq9C,EAAM/gB,OAAOt8B,OAAS,GAC1Dq9C,EAAM/gB,OAAO9Z,SAAUhhB,KAAM,WAAY0X,MAAO,KAGzCmkC,MAAOA,EAAOxc,UAAW3W,IAGhCk1B,GAA8B,SAAqC/B,GACrE,IAAKA,IAAUA,EAAMpsB,OAASn0B,MAAMwH,QAAQ+4C,EAAM/gB,QAChD,MAAO,KAGT,IAAI+iB,IACFC,YACApd,kBAGEr6B,EAAQ,EAER03C,EAAYlC,EAAM/gB,OAClBkjB,EAAanC,EAAMhD,QACnBoF,EAAcpC,EAAM/C,SAGpBoF,EAAkB/e,EAA8BvK,EAAmBkD,CAEvE,OAAO+jB,GAAMpsB,KAAKgO,MAAM,MAAMlmB,OAAO,SAAU4mC,EAAKC,EAAWl/C,GAE7Dk/C,EAAYlf,EAAkBkf,EAE9B,IAAI/1B,GAAQ01B,EAAU7+C,GAClBK,EAAM8G,EAAQ+3C,EAAU5/C,OACxBq6C,EAAUmF,EAAWnsC,MAAMxL,EAAO9G,GAClCu5C,EAAWmF,EAAYpsC,MAAMxL,EAAO9G,GACpC40B,EAAgBhlB,EAAK0pC,EAAQ10C,IAAI,SAAU4rB,EAAO7wB,GACpD,GAAIizB,IAASpC,MAAOA,EAAOC,OAAQ,KAInC,OAHI8oB,GAAS55C,KACXizB,EAAKnC,OAAS8oB,EAAS55C,IAElBwvB,EAAkBryB,OAAO81B,KAElC9rB,GAAQ9G,EAAM,CAEd,IAAImY,GAAQ2Q,EAAM3Q,MACd1X,EAAOqoB,EAAMroB,KACbk0B,EAAS7L,EAAM6L,OAGfjwB,EAAMokB,EAAMpkB,KAAOszB,IACnB8mB,EAAoB,IAGxB,IAAInqB,EAAQ,CACV,GAAIoqB,GAAcH,EAAIL,SAAS5pB,GAC3BqqB,EAAeJ,EAAIzd,cAAc4d,EAGrC,IAAIC,EAAappB,eAAevR,WAAa26B,EAAavpB,UAAW,CACnE,GAAIwpB,GAAsBD,EAAatpB,mBACnCwpB,EAAaF,EAAavpB,SAC9BqpB,GAAoB9mB,GAEpB,IAAImnB,GAAW,GAAI9pB,IACjB3wB,IAAKo6C,EACL5uB,KAAMgvB,EACNtqB,cAAeqqB,EACftqB,OAAQA,EACRI,YAAarwB,GAGfk6C,GAAIzd,cAAcxzB,KAAKwxC,GAEvBH,EAAeA,EAAaj1C,cAAc,SAAU+e,GAClDA,EAAM5f,IAAI,gBAAiB0G,KAAQ1G,IAAI,OAAQ,IAAIA,IAAI,WAAY81C,EAAanqB,SAASlnB,KAAKwxC,EAAS9yB,aAI3GuyB,EAAIzd,cAAc4d,GAAeC,EAAa91C,IAAI,WAAY81C,EAAanqB,SAASlnB,KAAKjJ,IAG3F,GAAIiqC,GAAY,GAAIgQ,IAClBj6C,IAAKA,EACLiwB,OAAQA,EACRl0B,KAAMA,EACN0X,MAAOA,EACP+X,KAAM2uB,EACNjqB,cAAeA,EACfE,YAAagqB,IAAgC,IAAVn/C,GAAe6+C,EAAU7+C,EAAQ,GAAGg1B,SAAWA,EAAS,KAAO6pB,EAAU7+C,EAAQ,GAAG+E,KACvHqwB,YAAap1B,IAAU6+C,EAAUv/C,OAAS,GAAKu/C,EAAU7+C,EAAQ,GAAGg1B,SAAWA,EAAS,KAAO6pB,EAAU7+C,EAAQ,GAAG+E,KAStH,OALAk6C,GAAIzd,cAAcxzB,KAAKghC,GAGvBiQ,EAAIL,SAAS5P,EAAUjqC,KAAO/E,EAEvBi/C,GACNN,GAAcnd,eAGfie,GAAiC,SAAwCnE,GAC3E,GAAIgD,GAAa30C,UAAUrK,OAAS,OAAsBK,KAAjBgK,UAAU,GAAmBA,UAAU,GAAK6uC,EACjF0B,EAAiBvwC,UAAUrK,OAAS,OAAsBK,KAAjBgK,UAAU,GAAmBA,UAAU,GAAKo5B,EAOrF2c,EAAYrB,EAAgB/C,EAAMgD,EAAYpE,EAAgBhd,EAElE,IAAiB,MAAbwiB,EACF,MAAO,KAGT,IAAI/C,GAAQ+C,EAAU/C,MAClBxc,EAAYuf,EAAUvf,SAI1B,QACEqB,cAHkBkd,GAA4B/B,GAI9Cxc,UAAWA,GAIf7jC,GAAOI,QAAU+iD,I9D81UX,SAAUnjD,EAAQI,EAASF,GAEjC,Y+Dl9VA,SAASg8C,GAAoB8C,GAC3B,GAAIrK,GACArlC,EAAO,IAQX,QANK+zC,GAAWxZ,SAASyZ,gBAAkBzZ,SAASyZ,eAAeC,qBACjE5O,EAAM9K,SAASyZ,eAAeC,mBAAmB,OAChD5O,EAAIlnC,iBAA4GjD,GAAU,GAC3HmqC,EAAIlnC,gBAAgB+1C,UAAYxE,EAChC1vC,EAAOqlC,EAAI8O,qBAAqB,QAAQ,IAEnCn0C,EApBT,GAAI0rB,GAAY,EAAQ,IAEpBxwB,EAAY,EAAQ,IAEpB64C,EAAUroB,EAAUC,UAAU,UAmBlCj7B,GAAOI,QAAU87C,G/Dg/VX,SAAUl8C,EAAQI,EAASF,GAEjC,YgEzgWA,IAAI4zB,GAAgB,EAAQ,IACxBxH,EAAc,EAAQ,IAGtBo3B,GAFiB,EAAQ,IAES,EAAQ,MAC1CvpB,EAAa,EAAQ,IAErByR,GACF+X,yBAA0B,SAAkCx3B,GAC1D,GAAIC,GAAYD,EAAY6E,eACxBtE,EAAeP,EAAYgB,oBAC3B0W,EAAYnX,EAAakE,cAC7B,OAAOlE,GAAa2B,eAAejC,EAAUqJ,gBAAgBgE,mBAAmBpjB,MAAM+V,EAAU+B,iBAAkB/B,EAAUwJ,gBAAgBlY,KAAK,SAAUhZ,GACzJ,GAAI8vB,GAAS9vB,EAAEmzB,WACf,SAASrD,GAAgD,SAAtCqP,EAAU3C,MAAM1M,GAAQ+E,aAI/CqqB,oBAAqB,SAA6Bz3B,GAChD,GAAIC,GAAYD,EAAY6E,cAC5B,OAAO7E,GAAYgB,oBAAoBkB,eAAejC,EAAU6B,eAAesL,WAGjFsqB,wBAAyB,SAAiCC,GACxD,OAASpC,IAAKoC,EAAI33C,aAGpB43C,iBAAkB,SAA0B53B,EAAa63B,GACvD,OAAQA,GACN,IAAK,OACH,MAAOpY,GAAmBqY,kBAAkB93B,EAAa,OAC3D,KAAK,SACH,MAAOyf,GAAmBqY,kBAAkB93B,EAAa,SAC3D,KAAK,YACH,MAAOyf,GAAmBqY,kBAAkB93B,EAAa,YAC3D,KAAK,OACH,MAAOyf,GAAmBsY,WAAW/3B,EACvC,KAAK,YACL,IAAK,iBACL,IAAK,6BACH,MAAOyf,GAAmBuY,YAAYh4B,EACxC,KAAK,SACL,IAAK,cACL,IAAK,yBACH,MAAOyf,GAAmBwY,SAASj4B,EACrC,SAEE,MAAO,QAIbk4B,kBAAmB,SAA2Bl4B,GAC5C,GAAIO,GAAeoH,EAAcW,WAAWtI,EAAYgB,oBAAqBhB,EAAY6E,eAAgB,KAAM7E,EAAYoF,wBAAyB,MAEhJ+yB,EAAiBh4B,EAAY5a,KAAKya,EAAaO,EAAc,oBAEjE,OAAOJ,GAAYD,eAAei4B,EAAgB53B,EAAakG,sBAOjEuxB,YAAa,SAAqBh4B,GAChC,GAAIC,GAAYD,EAAY6E,cAC5B,KAAK5E,EAAUqF,eAAiBrF,EAAUsJ,mBAAqBtJ,EAAUoJ,iBACvE,MAAO,KAIT,IAAIjI,GAAUpB,EAAYgB,oBACtBa,EAAW5B,EAAU6B,cACrBs2B,EAAch3B,EAAQ+W,eAAetW,EAEzC,IAAIu2B,GAAyC,WAA1BA,EAAYhrB,UAAwB,CACrD,GAAI/L,GAAWD,EAAQX,cAAsB,OAAE23B,EAAYn0B,UACvDo0B,EAAqBj3B,EAAQ1J,OAC/B2J,SAAUA,EACVuW,eAAgB3X,GAElB,IAAIo4B,IAAuBj3B,EACzB,MAAOjB,GAAY5a,KAAKya,EAAaq4B,EAAoB,gBAK7D,GAAIC,GAAoB7Y,EAAmB8Y,sBAAsBv4B,EAEjE,OAAIs4B,GACKn4B,EAAY5a,KAAKya,EAAas4B,EAAmB,qBAGnD,MAGTL,SAAU,SAAkBj4B,GAC1B,GAAIC,GAAYD,EAAY6E,cAC5B,KAAK5E,EAAUqF,cACb,MAAO,KAGT,IAAIlE,GAAUpB,EAAYgB,oBACtBa,EAAW5B,EAAU6B,cACrBpB,EAAQU,EAAQc,eAAeL,GAC/BhrB,EAAS6pB,EAAM0B,WAGnB,IAAInC,EAAU+B,iBAAmBnrB,EAC/B,MAAO,KAGT,IAAI2hD,GAAap3B,EAAQ8W,cAAcrW,EAEvC,KAAK22B,GAAuC,WAAzBA,EAAWprB,UAC5B,MAAO,KAGT,IAAIqrB,GAAoBx4B,EAAUvI,OAChC0O,SAAUoyB,EAAWv0B,SACrBoC,YAAamyB,EAAWp2B,cAGtBi2B,EAAqB1wB,EAAciB,YAAYxH,EAASq3B,EAAmB,UAE/E,OAAIJ,KAAuBj3B,EAClBjB,EAAY5a,KAAKya,EAAaq4B,EAAoB,gBAGpD,MAGTK,MAAO,SAAeC,EAAO34B,EAAa44B,GACxC,GAAI34B,GAAYD,EAAY6E,eACxBvoB,EAAM2jB,EAAUqJ,cACpB,IAAIhtB,IAAQ2jB,EAAUmJ,cACpB,MAAOpJ,EAGT,IAAIoB,GAAUpB,EAAYgB,oBACtBN,EAAQU,EAAQc,eAAe5lB,GAC/BjE,EAAOqoB,EAAM0M,SACjB,IAAa,wBAAT/0B,GAA2C,sBAATA,EACpC,MAAO2nB,EAGT24B,GAAME,gBAIN,IAAIC,GAAa13B,EAAQ+W,eAAe77B,EACxC,KAAKw8C,EACH,MAAO94B,EAGT,IAAI+4B,GAAYD,EAAW1rB,SAC3B,IAAkB,wBAAd2rB,GAAqD,sBAAdA,EACzC,MAAO/4B,EAGT,IAAIjQ,GAAQ2Q,EAAM6M,UAClB,KAAKorB,EAAMK,UAAYjpC,IAAU6oC,EAC/B,MAAO54B,EAGT44B,GAAWjiD,KAAKsB,IAAI6gD,EAAWvrB,WAAa,EAAGqrB,EAE/C,IAAIK,GAAiB1B,EAAgCn2B,EAASnB,EAAW04B,EAAMK,UAAY,EAAI,EAAGJ,EAElG,OAAOz4B,GAAY5a,KAAKya,EAAai5B,EAAgB,iBAGvDC,gBAAiB,SAAyBl5B,EAAaqK,GACrD,GAAIpK,GAAYD,EAAY6E,eACxBhD,EAAW5B,EAAU6B,cACrBmH,EAAShJ,EAAUkS,YACnB/Q,EAAUpB,EAAYgB,oBACtB2B,EAAS1C,CAMb,IAAI4B,IAAaoH,GAAuC,IAA7BhJ,EAAUwJ,eAAsB,CACzD,GAAI2uB,GAAcpqB,EAAW5M,EAAQ+W,eAAelP,GACpDA,GAASmvB,EAAYn0B,SACrBtB,EAASA,EAAOjL,OACdwO,UAAWrE,EACXsE,aAAclG,EAAU+B,iBACxBoE,SAAU6C,EACV5C,YAAa+xB,EAAYh2B,YACzBkE,YAAY,IAYhB,GARqBlF,EAAQX,cAAclD,UAAU,SAAU7f,EAAGpF,GAChE,MAAOA,KAAMupB,IACZrmB,UAAU+hB,UAAU,SAAU7f,EAAGpF,GAClC,MAAOA,KAAM2wB,IACZ1X,KAAK,SAAUhZ,GAChB,MAAuB,WAAhBA,EAAE60B,YAIT,MAAOpN,EAGT,IAAIm5B,GAAY/3B,EAAQc,eAAeL,GAAUuL,YAAc/C,EAAY,WAAaA,CAExF,OAAOlK,GAAY5a,KAAKya,EAAa2H,EAAcyC,aAAahJ,EAASuB,EAAQw2B,GAAY,sBAG/FpB,WAAY,SAAoB/3B,GAC9B,GAAIC,GAAYD,EAAY6E,eACxBqB,EAAYjG,EAAUqJ,eACtBlD,EAAWnG,EAAUmJ,aAEzB,OAAInJ,GAAUqF,eAAiBY,IAAcE,EACpCqZ,EAAmByZ,gBAAgBl5B,EAAa,cAGlDyf,EAAmBqY,kBAAkB93B,EAAa,SAS3D83B,kBAAmB,SAA2B93B,EAAa+H,GACzD,GAAI9H,GAAYD,EAAY6E,eACxButB,EAAepyB,EAAYoF,uBAK/B,IAAInF,EAAUqF,cACZ,MAAOnF,GAAYgF,uBAAuBnF,EAAaoyB,EAAav0C,IAAIkqB,GAAeqqB,EAAaxrC,OAAOmhB,GAAeqqB,EAAal/B,IAAI6U,GAK7I,IACIxD,GADAnD,EAAUpB,EAAYgB,mBAW1B,OALEuD,GADE6tB,EAAav0C,IAAIkqB,GACNJ,EAAcwC,kBAAkB/I,EAASnB,EAAW8H,GAEpDJ,EAAcuC,iBAAiB9I,EAASnB,EAAW8H,GAG3D5H,EAAY5a,KAAKya,EAAauE,EAAY,wBAGnD60B,WAAY,SAAoBp5B,EAAaoc,EAAiBpU,GAC5D,GAAIqxB,GAAc1xB,EAAcgD,YAAY3K,EAAYgB,oBAAqBob,EAAiBpU,EAE9F,OAAO7H,GAAY5a,KAAKya,EAAaq5B,EAAa,iBAQpDd,sBAAuB,SAA+Bv4B,GACpD,GAAIC,GAAYD,EAAY6E,eACxBpuB,EAASwpB,EAAUsJ,iBACvB,IAAItJ,EAAUqF,eAA4B,IAAX7uB,EAAc,CAC3C,GAAI6F,GAAM2jB,EAAUqJ,eAChBlI,EAAUpB,EAAYgB,oBACtBN,EAAQU,EAAQc,eAAe5lB,GAE/Bg9C,EAAal4B,EAAQiX,eACzB,IAAI3X,EAAM0B,YAAc,GAAK1B,IAAU44B,EACrC,MAAO,KAGT,IAAIjhD,GAAOqoB,EAAM0M,UACbgrB,EAAch3B,EAAQ+W,eAAe77B,EACzC,IAAa,eAATjE,GAAyB+/C,GAAyC,eAA1BA,EAAYhrB,WAA0D,IAA5BgrB,EAAYh2B,YAChG,MAAO,KAGT,IAAa,aAAT/pB,EACF,MAAOsvB,GAAcyC,aAAahJ,EAASnB,EAAW,YAG1D,MAAO,OAIXpsB,GAAOI,QAAUwrC,GhE6hWX,SAAU5rC,EAAQI,EAASF,GAEjC,YiErzWA,SAASwlD,GAAiBliC,GACxB,MAAOonB,IAASpnB,EAAEwnB,QAAUF,EAAiBtnB,GAM/C,QAASmiC,GAAYniC,GACnB,MAAK0nB,GAAmB1nB,GAGjBA,EAAE2hC,SAAW,OAAS,OAFpB,KAKX,QAASS,GAAiBpiC,GAExB,MAAIqiC,IAAariC,EAAE2hC,SACV,KAEFO,EAAiBliC,GAAK,cAAgB,SAG/C,QAASsiC,GAAoBtiC,GAC3B,MAAI0nB,GAAmB1nB,IAAMonB,EACpB,6BAEF8a,EAAiBliC,GAAK,iBAAmB,YAMlD,QAASwoB,GAAqBxoB,GAC5B,OAAQA,EAAEuiC,SACR,IAAK,IAEH,MAAO7a,GAAmB1nB,GAAK,OAAS,IAC1C,KAAK,IAEH,MAAOsnB,GAAiBtnB,GAAK,SAAW,IAC1C,KAAK,IAEH,MAAOsnB,GAAiBtnB,GAAK,YAAc,IAC7C,KAAK,IAEH,MAAO0nB,GAAmB1nB,GAAK,SAAW,IAC5C,KAAK,IAEH,MAAO0nB,GAAmB1nB,GAAK,OAAS,IAC1C,KAAK,IAEH,OAAQqiC,GAAa/a,EAAiBtnB,GAAK,gBAAkB,IAC/D,KAAK,IAGL,IAAK,IAEH,MAAOsnB,GAAiBtnB,GAAK,cAAgB,IAC/C,KAAK,IAEH,MAAOonB,IAASE,EAAiBtnB,GAAK,uBAAyB,IACjE,KAAK,IAEH,MAAO0nB,GAAmB1nB,GAAK,YAAc,IAC/C,KAAK,IAEH,MAAOonB,IAASE,EAAiBtnB,GAAK,iBAAmB,IAC3D,KAAK,IAEH,MAAIsnB,GAAiBtnB,GACZqiC,EAAY,OAAS,kBAEvB,IACT,KAAK,IAEH,MAAOF,GAAYniC,IAAM,IAC3B,KAAKwiC,GAAK9e,OACR,MAAO,aACT,KAAK8e,GAAKle,OACR,MAAO8d,GAAiBpiC,EAC1B,KAAKwiC,GAAKhf,UACR,MAAO8e,GAAoBtiC,EAE7B,KAAKwiC,GAAKte,KACR,MAAOue,IAA4B/a,EAAmB1nB,GAAK,mCAAqC,IAClG,KAAKwiC,GAAKpe,MACR,MAAOqe,IAA4B/a,EAAmB1nB,GAAK,iCAAmC,IAChG,SACE,MAAO,OAxGb,GAAIqnB,GAAiB,EAAQ,KACzBmb,EAAO,EAAQ,KACfhrB,EAAY,EAAQ,IAEpB4P,EAAQ5P,EAAUW,WAAW,YAC7BkqB,EAAY7qB,EAAUW,WAAW,WAKjCsqB,EAA2Brb,GAAS5P,EAAUC,UAAU,gBAExDiQ,EAAqBL,EAAeK,mBACpCJ,EAAmBD,EAAeC,gBA+FtC9qC,GAAOI,QAAU4rC,GjEy1WX,SAAUhsC,EAAQI,EAASF,GAEjC,YkEv8WA,IAAIgmD,IACFxkC,UAAW,SAAmBjZ,GAC5B,MAAO,IAAM01B,OAAO11B,IAGtB09C,YAAa,SAAqB19C,GAChC,MAAOA,GAAI4N,MAAM,IAIrBrW,GAAOI,QAAU8lD,GlE29WX,SAAUlmD,EAAQI,EAASF,ImE7+WhC,SAAUG,EAAQC,GAC8CN,EAAOI,QAAUE,KAGhFC,EAAM,WAAc,YAEpB,SAASC,GAAYC,EAAMC,GACrBA,IACFD,EAAKE,UAAYC,OAAOC,OAAOH,EAAWC,YAE5CF,EAAKE,UAAUG,YAAcL,EAG/B,QAASM,GAASC,GACd,MAAOC,GAAWD,GAASA,EAAQE,EAAIF,GAKzC,QAASG,GAAcH,GACrB,MAAOI,GAAQJ,GAASA,EAAQK,EAASL,GAK3C,QAASM,GAAgBN,GACvB,MAAOO,GAAUP,GAASA,EAAQQ,EAAWR,GAK/C,QAASS,GAAYT,GACnB,MAAOC,GAAWD,KAAWU,EAAcV,GAASA,EAAQW,EAAOX,GAKvE,QAASC,GAAWW,GAClB,SAAUA,IAAiBA,EAAcC,KAG3C,QAAST,GAAQU,GACf,SAAUA,IAAcA,EAAWC,KAGrC,QAASR,GAAUS,GACjB,SAAUA,IAAgBA,EAAaC,KAGzC,QAASP,GAAcQ,GACrB,MAAOd,GAAQc,IAAqBX,EAAUW,GAGhD,QAASC,GAAUC,GACjB,SAAUA,IAAgBA,EAAaC,KAmCzC,QAASC,GAAQC,GAEf,MADAA,GAAIvB,OAAQ,EACLuB,EAGT,QAASC,GAAOD,GACdA,IAAQA,EAAIvB,OAAQ,GAMtB,QAASyB,MAGT,QAASC,GAAQC,EAAKC,GACpBA,EAASA,GAAU,CAGnB,KAAK,GAFDC,GAAMC,KAAKC,IAAI,EAAGJ,EAAIK,OAASJ,GAC/BK,EAAS,GAAInD,OAAM+C,GACdK,EAAK,EAAGA,EAAKL,EAAKK,IACzBD,EAAOC,GAAMP,EAAIO,EAAKN,EAExB,OAAOK,GAGT,QAASE,GAAWC,GAIlB,WAHkBC,KAAdD,EAAKE,OACPF,EAAKE,KAAOF,EAAKG,UAAUC,IAEtBJ,EAAKE,KAGd,QAASG,GAAUL,EAAMM,GAQvB,GAAqB,gBAAVA,GAAoB,CAC7B,GAAIC,GAAcD,IAAU,CAC5B,IAAI,GAAKC,IAAgBD,GAAyB,aAAhBC,EAChC,MAAOC,IAETF,GAAQC,EAEV,MAAOD,GAAQ,EAAIP,EAAWC,GAAQM,EAAQA,EAGhD,QAASF,KACP,OAAO,EAGT,QAASK,GAAWC,EAAOC,EAAKT,GAC9B,OAAkB,IAAVQ,OAAyBT,KAATC,GAAsBQ,IAAUR,SAC7CD,KAARU,OAA+BV,KAATC,GAAsBS,GAAOT,GAGxD,QAASU,GAAaF,EAAOR,GAC3B,MAAOW,GAAaH,EAAOR,EAAM,GAGnC,QAASY,GAAWH,EAAKT,GACvB,MAAOW,GAAaF,EAAKT,EAAMA,GAGjC,QAASW,GAAaP,EAAOJ,EAAMa,GACjC,WAAiBd,KAAVK,EACLS,EACAT,EAAQ,EACNZ,KAAKC,IAAI,EAAGO,EAAOI,OACVL,KAATC,EACEI,EACAZ,KAAKsB,IAAId,EAAMI,GAevB,QAASW,GAASC,GACd/D,KAAK+D,KAAOA,EAmBhB,QAASC,GAAcC,EAAMC,EAAGC,EAAGC,GACjC,GAAI3D,GAAiB,IAATwD,EAAaC,EAAa,IAATD,EAAaE,GAAKD,EAAGC,EAIlD,OAHAC,GAAkBA,EAAe3D,MAAQA,EAAU2D,GACjD3D,MAAOA,EAAO4D,MAAM,GAEfD,EAGT,QAASE,KACP,OAAS7D,UAAOqC,GAAWuB,MAAM,GAGnC,QAASE,GAAYlD,GACnB,QAASmD,EAAcnD,GAGzB,QAASoD,GAAWC,GAClB,MAAOA,IAA+C,kBAAvBA,GAAcX,KAG/C,QAASY,GAAYC,GACnB,GAAIC,GAAaL,EAAcI,EAC/B,OAAOC,IAAcA,EAAWC,KAAKF,GAGvC,QAASJ,GAAcI,GACrB,GAAIC,GAAaD,IACdG,IAAwBH,EAASG,KAClCH,EAASI,IAEX,IAA0B,kBAAfH,GACT,MAAOA,GAIX,QAASI,GAAYxE,GACnB,MAAOA,IAAiC,gBAAjBA,GAAMgC,OAI7B,QAAS9B,GAAIF,GACX,MAAiB,QAAVA,OAA4BqC,KAAVrC,EAAsByE,IAC7CxE,EAAWD,GAASA,EAAM0E,QAAUC,EAAa3E,GAsCrD,QAASK,GAASL,GAChB,MAAiB,QAAVA,OAA4BqC,KAAVrC,EACvByE,IAAgBG,aAChB3E,EAAWD,GACRI,EAAQJ,GAASA,EAAM0E,QAAU1E,EAAM6E,eACxCC,EAAkB9E,GAUxB,QAASQ,GAAWR,GAClB,MAAiB,QAAVA,OAA4BqC,KAAVrC,EAAsByE,IAC5CxE,EAAWD,GACZI,EAAQJ,GAASA,EAAM+E,WAAa/E,EAAMgF,eADrBC,EAAoBjF,GA2B7C,QAASW,GAAOX,GACd,OACY,OAAVA,OAA4BqC,KAAVrC,EAAsByE,IACvCxE,EAAWD,GACZI,EAAQJ,GAASA,EAAM+E,WAAa/E,EADfiF,EAAoBjF,IAEzCkF,WAyBJ,QAASC,GAASC,GAChB7F,KAAK8F,OAASD,EACd7F,KAAK+C,KAAO8C,EAAMpD,OAgCpB,QAASsD,GAAUC,GACjB,GAAIC,GAAO5F,OAAO4F,KAAKD,EACvBhG,MAAKkG,QAAUF,EACfhG,KAAKmG,MAAQF,EACbjG,KAAK+C,KAAOkD,EAAKxD,OA4CnB,QAAS2D,GAAYxB,GACnB5E,KAAKqG,UAAYzB,EACjB5E,KAAK+C,KAAO6B,EAASnC,QAAUmC,EAAS7B,KAwC1C,QAASuD,GAAYC,GACnBvG,KAAKwG,UAAYD,EACjBvG,KAAKyG,kBAkDT,QAASC,GAAMC,GACb,SAAUA,IAAYA,EAASC,KAKjC,QAAS1B,KACP,MAAO2B,MAAcA,GAAY,GAAIjB,QAGvC,QAASL,GAAkB9E,GACzB,GAAIqG,GACFvH,MAAMwH,QAAQtG,GAAS,GAAImF,GAASnF,GAAO6E,eAC3Cb,EAAWhE,GAAS,GAAI6F,GAAY7F,GAAO6E,eAC3Cf,EAAY9D,GAAS,GAAI2F,GAAY3F,GAAO6E,eAC3B,gBAAV7E,GAAqB,GAAIsF,GAAUtF,OAC1CqC,EACF,KAAKgE,EACH,KAAM,IAAIE,WACR,yEACsBvG,EAG1B,OAAOqG,GAGT,QAASpB,GAAoBjF,GAC3B,GAAIqG,GAAMG,EAAyBxG,EACnC,KAAKqG,EACH,KAAM,IAAIE,WACR,gDAAkDvG,EAGtD,OAAOqG,GAGT,QAAS1B,GAAa3E,GACpB,GAAIqG,GAAMG,EAAyBxG,IACf,gBAAVA,IAAsB,GAAIsF,GAAUtF,EAC9C,KAAKqG,EACH,KAAM,IAAIE,WACR,iEAAmEvG,EAGvE,OAAOqG,GAGT,QAASG,GAAyBxG,GAChC,MACEwE,GAAYxE,GAAS,GAAImF,GAASnF,GAClCgE,EAAWhE,GAAS,GAAI6F,GAAY7F,GACpC8D,EAAY9D,GAAS,GAAI2F,GAAY3F,OACrCqC,GAIJ,QAASoE,GAAWJ,EAAKK,EAAIC,EAASC,GACpC,GAAIC,GAAQR,EAAIS,MAChB,IAAID,EAAO,CAET,IAAK,GADDE,GAAWF,EAAM7E,OAAS,EACrBE,EAAK,EAAGA,GAAM6E,EAAU7E,IAAM,CACrC,GAAI8E,GAAQH,EAAMF,EAAUI,EAAW7E,EAAKA,EAC5C,KAAmD,IAA/CwE,EAAGM,EAAM,GAAIJ,EAAUI,EAAM,GAAK9E,EAAImE,GACxC,MAAOnE,GAAK,EAGhB,MAAOA,GAET,MAAOmE,GAAIY,kBAAkBP,EAAIC,GAGnC,QAASO,GAAYb,EAAK7C,EAAMmD,EAASC,GACvC,GAAIC,GAAQR,EAAIS,MAChB,IAAID,EAAO,CACT,GAAIE,GAAWF,EAAM7E,OAAS,EAC1BE,EAAK,CACT,OAAO,IAAImB,GAAS,WAClB,GAAI2D,GAAQH,EAAMF,EAAUI,EAAW7E,EAAKA,EAC5C,OAAOA,KAAO6E,EACZlD,IACAN,EAAcC,EAAMoD,EAAUI,EAAM,GAAK9E,EAAK,EAAG8E,EAAM,MAG7D,MAAOX,GAAIc,mBAAmB3D,EAAMmD,GAGtC,QAASS,GAAOC,EAAMC,GACpB,MAAOA,GACLC,EAAWD,EAAWD,EAAM,IAAK,GAAIA,IACrCG,EAAcH,GAGlB,QAASE,GAAWD,EAAWD,EAAMI,EAAKC,GACxC,MAAI5I,OAAMwH,QAAQe,GACTC,EAAUjD,KAAKqD,EAAYD,EAAKjH,EAAW6G,GAAMM,IAAI,SAASjE,EAAGD,GAAK,MAAO8D,GAAWD,EAAW5D,EAAGD,EAAG4D,MAE9GO,EAAWP,GACNC,EAAUjD,KAAKqD,EAAYD,EAAKpH,EAASgH,GAAMM,IAAI,SAASjE,EAAGD,GAAK,MAAO8D,GAAWD,EAAW5D,EAAGD,EAAG4D,MAEzGA,EAGT,QAASG,GAAcH,GACrB,MAAIvI,OAAMwH,QAAQe,GACT7G,EAAW6G,GAAMM,IAAIH,GAAeK,SAEzCD,EAAWP,GACNhH,EAASgH,GAAMM,IAAIH,GAAeM,QAEpCT,EAGT,QAASO,GAAW5H,GAClB,MAAOA,KAAUA,EAAMF,cAAgBF,YAAgCyC,KAAtBrC,EAAMF,aAyDzD,QAASiI,GAAGC,EAAQC,GAClB,GAAID,IAAWC,GAAWD,IAAWA,GAAUC,IAAWA,EACxD,OAAO,CAET,KAAKD,IAAWC,EACd,OAAO,CAET,IAA8B,kBAAnBD,GAAOE,SACY,kBAAnBD,GAAOC,QAAwB,CAGxC,GAFAF,EAASA,EAAOE,UAChBD,EAASA,EAAOC,UACZF,IAAWC,GAAWD,IAAWA,GAAUC,IAAWA,EACxD,OAAO,CAET,KAAKD,IAAWC,EACd,OAAO,EAGX,QAA6B,kBAAlBD,GAAOG,QACW,kBAAlBF,GAAOE,SACdH,EAAOG,OAAOF,IAMpB,QAASG,GAAUC,EAAGC,GACpB,GAAID,IAAMC,EACR,OAAO,CAGT,KACGrI,EAAWqI,QACDjG,KAAXgG,EAAE/F,UAAiCD,KAAXiG,EAAEhG,MAAsB+F,EAAE/F,OAASgG,EAAEhG,UAChDD,KAAbgG,EAAEE,YAAqClG,KAAbiG,EAAEC,QAAwBF,EAAEE,SAAWD,EAAEC,QACnEnI,EAAQiI,KAAOjI,EAAQkI,IACvB/H,EAAU8H,KAAO9H,EAAU+H,IAC3BnH,EAAUkH,KAAOlH,EAAUmH,GAE3B,OAAO,CAGT,IAAe,IAAXD,EAAE/F,MAAyB,IAAXgG,EAAEhG,KACpB,OAAO,CAGT,IAAIkG,IAAkB9H,EAAc2H,EAEpC,IAAIlH,EAAUkH,GAAI,CAChB,GAAII,GAAUJ,EAAEI,SAChB,OAAOH,GAAEI,MAAM,SAAShF,EAAGD,GACzB,GAAIuD,GAAQyB,EAAQnF,OAAOtD,KAC3B,OAAOgH,IAASe,EAAGf,EAAM,GAAItD,KAAO8E,GAAkBT,EAAGf,EAAM,GAAIvD,OAC/DgF,EAAQnF,OAAOM,KAGvB,GAAI+E,IAAU,CAEd,QAAetG,KAAXgG,EAAE/F,KACJ,OAAeD,KAAXiG,EAAEhG,KACyB,kBAAlB+F,GAAEO,aACXP,EAAEO,kBAEC,CACLD,GAAU,CACV,IAAIE,GAAIR,CACRA,GAAIC,EACJA,EAAIO,EAIR,GAAIC,IAAW,EACXC,EAAQT,EAAE/F,UAAU,SAASmB,EAAGD,GAClC,GAAI+E,GAAkBH,EAAEW,IAAItF,GACxBiF,GAAWZ,EAAGrE,EAAG2E,EAAEY,IAAIxF,EAAGyF,MAAanB,EAAGM,EAAEY,IAAIxF,EAAGyF,IAAUxF,GAE/D,MADAoF,IAAW,GACJ,GAIX,OAAOA,IAAYT,EAAE/F,OAASyG,EAK9B,QAASI,GAAOnJ,EAAOoJ,GACrB,KAAM7J,eAAgB4J,IACpB,MAAO,IAAIA,GAAOnJ,EAAOoJ,EAI3B,IAFA7J,KAAK8J,OAASrJ,EACdT,KAAK+C,SAAiBD,KAAV+G,EAAsBE,IAAWxH,KAAKC,IAAI,EAAGqH,GACvC,IAAd7J,KAAK+C,KAAY,CACnB,GAAIiH,GACF,MAAOA,GAETA,IAAehK,MAoErB,QAASiK,GAAUC,EAAWC,GAC5B,IAAKD,EAAW,KAAM,IAAIE,OAAMD,GAKhC,QAASE,GAAMC,EAAO9G,EAAK+G,GACzB,KAAMvK,eAAgBqK,IACpB,MAAO,IAAIA,GAAMC,EAAO9G,EAAK+G,EAe/B,IAbAN,EAAmB,IAATM,EAAY,4BACtBD,EAAQA,GAAS,MACLxH,KAARU,IACFA,EAAMuG,KAERQ,MAAgBzH,KAATyH,EAAqB,EAAIhI,KAAKiI,IAAID,GACrC/G,EAAM8G,IACRC,GAAQA,GAEVvK,KAAKyK,OAASH,EACdtK,KAAK0K,KAAOlH,EACZxD,KAAK2K,MAAQJ,EACbvK,KAAK+C,KAAOR,KAAKC,IAAI,EAAGD,KAAKqI,MAAMpH,EAAM8G,GAASC,EAAO,GAAK,GAC5C,IAAdvK,KAAK+C,KAAY,CACnB,GAAI8H,GACF,MAAOA,GAETA,IAAc7K,MA2FlB,QAAS8K,MACP,KAAM9D,WAAU,YAIqB,QAAS+D,OAEP,QAASC,OAEb,QAASC,OAuBhD,QAASC,IAAIC,GACX,MAASA,KAAQ,EAAK,WAAqB,WAANA,EAGvC,QAASC,IAAKC,GACZ,IAAU,IAANA,GAAqB,OAANA,OAAoBvI,KAANuI,EAC/B,MAAO,EAET,IAAyB,kBAAdA,GAAE1C,WAED,KADV0C,EAAIA,EAAE1C,YACmB,OAAN0C,OAAoBvI,KAANuI,GAC/B,MAAO,EAGX,KAAU,IAANA,EACF,MAAO,EAET,IAAIpH,SAAcoH,EAClB,IAAa,WAATpH,EAAmB,CACrB,GAAIoH,IAAMA,GAAKA,IAAMtB,IACnB,MAAO,EAET,IAAIuB,GAAQ,EAAJD,CAIR,KAHIC,IAAMD,IACRC,GAAS,WAAJD,GAEAA,EAAI,YACTA,GAAK,WACLC,GAAKD,CAEP,OAAOH,IAAII,GAEb,GAAa,WAATrH,EACF,MAAOoH,GAAE5I,OAAS8I,GAA+BC,GAAiBH,GAAKI,GAAWJ,EAEpF,IAA0B,kBAAfA,GAAEK,SACX,MAAOL,GAAEK,UAEX,IAAa,WAATzH,EACF,MAAO0H,IAAUN,EAEnB,IAA0B,kBAAfA,GAAEO,SACX,MAAOH,IAAWJ,EAAEO,WAEtB,MAAM,IAAIxB,OAAM,cAAgBnG,EAAO,sBAGzC,QAASuH,IAAiBK,GACxB,GAAIT,GAAOU,GAAgBD,EAU3B,YATa/I,KAATsI,IACFA,EAAOK,GAAWI,GACdE,KAA2BC,KAC7BD,GAAyB,EACzBD,OAEFC,KACAD,GAAgBD,GAAUT,GAErBA,EAIT,QAASK,IAAWI,GAQlB,IAAK,GADDT,GAAO,EACFzI,EAAK,EAAGA,EAAKkJ,EAAOpJ,OAAQE,IACnCyI,EAAO,GAAKA,EAAOS,EAAOI,WAAWtJ,GAAM,CAE7C,OAAOuI,IAAIE,GAGb,QAASO,IAAUO,GACjB,GAAId,EACJ,IAAIe,QAEWrJ,MADbsI,EAAOgB,GAAQ1C,IAAIwC,IAEjB,MAAOd,EAKX,QAAatI,MADbsI,EAAOc,EAAIG,KAET,MAAOjB,EAGT,KAAKkB,GAAmB,CAEtB,OAAaxJ,MADbsI,EAAOc,EAAIK,sBAAwBL,EAAIK,qBAAqBF,KAE1D,MAAOjB,EAIT,QAAatI,MADbsI,EAAOoB,GAAcN,IAEnB,MAAOd,GASX,GALAA,IAASqB,GACQ,WAAbA,KACFA,GAAa,GAGXN,GACFC,GAAQM,IAAIR,EAAKd,OACZ,QAAqBtI,KAAjB6J,KAAoD,IAAtBA,GAAaT,GACpD,KAAM,IAAI9B,OAAM,kDACX,IAAIkC,GACTjM,OAAOuM,eAAeV,EAAKG,IACzB,YAAc,EACd,cAAgB,EAChB,UAAY,EACZ,MAASjB,QAEN,QAAiCtI,KAA7BoJ,EAAIK,sBACJL,EAAIK,uBAAyBL,EAAI3L,YAAYH,UAAUmM,qBAKhEL,EAAIK,qBAAuB,WACzB,MAAOvM,MAAKO,YAAYH,UAAUmM,qBAAqBM,MAAM7M,KAAM8M,YAErEZ,EAAIK,qBAAqBF,IAAgBjB,MACpC,QAAqBtI,KAAjBoJ,EAAIa,SAOb,KAAM,IAAI3C,OAAM,qDAFhB8B,GAAIG,IAAgBjB,GAKtB,MAAOA,GAkBT,QAASoB,IAAcQ,GACrB,GAAIA,GAAQA,EAAKD,SAAW,EAC1B,OAAQC,EAAKD,UACX,IAAK,GACH,MAAOC,GAAKC,QACd,KAAK,GACH,MAAOD,GAAKE,iBAAmBF,EAAKE,gBAAgBD,UAwB5D,QAASE,IAAkBpK,GACzBkH,EACElH,IAASgH,IACT,qDAQF,QAASqD,IAAI3M,GACX,MAAiB,QAAVA,OAA4BqC,KAAVrC,EAAsB4M,KAC7CC,GAAM7M,KAAWmB,EAAUnB,GAASA,EACpC4M,KAAWE,cAAc,SAASnF,GAChC,GAAIvF,GAAOjC,EAAcH,EACzB0M,IAAkBtK,EAAKE,MACvBF,EAAK2K,QAAQ,SAASrJ,EAAGD,GAAK,MAAOkE,GAAIsE,IAAIxI,EAAGC,OA6KxD,QAASmJ,IAAMG,GACb,SAAUA,IAAYA,EAASC,KAiB/B,QAASC,IAAaC,EAAS1E,GAC7BlJ,KAAK4N,QAAUA,EACf5N,KAAKkJ,QAAUA,EAgEjB,QAAS2E,IAAkBD,EAASE,EAAQC,GAC1C/N,KAAK4N,QAAUA,EACf5N,KAAK8N,OAASA,EACd9N,KAAK+N,MAAQA,EAkEf,QAASC,IAAiBJ,EAASK,EAAOF,GACxC/N,KAAK4N,QAAUA,EACf5N,KAAKiO,MAAQA,EACbjO,KAAK+N,MAAQA,EAuDf,QAASG,IAAkBN,EAASO,EAASjF,GAC3ClJ,KAAK4N,QAAUA,EACf5N,KAAKmO,QAAUA,EACfnO,KAAKkJ,QAAUA,EAyEjB,QAASkF,IAAUR,EAASO,EAAS1G,GACnCzH,KAAK4N,QAAUA,EACf5N,KAAKmO,QAAUA,EACfnO,KAAKyH,MAAQA,EAgEf,QAAS4G,IAAYjG,EAAKnE,EAAMmD,GAC9BpH,KAAKsO,MAAQrK,EACbjE,KAAKuO,SAAWnH,EAChBpH,KAAKwO,OAASpG,EAAIqG,OAASC,GAAiBtG,EAAIqG,OAsCpD,QAASE,IAAiB1K,EAAMwD,GAC9B,MAAOzD,GAAcC,EAAMwD,EAAM,GAAIA,EAAM,IAG7C,QAASiH,IAAiB1B,EAAM4B,GAC9B,OACE5B,KAAMA,EACN7J,MAAO,EACP0L,OAAQD,GAIZ,QAASE,IAAQ/L,EAAMgM,EAAMnB,EAASxC,GACpC,GAAIhD,GAAM/H,OAAOC,OAAO0O,GAMxB,OALA5G,GAAIrF,KAAOA,EACXqF,EAAIqG,MAAQM,EACZ3G,EAAI6G,UAAYrB,EAChBxF,EAAIY,OAASoC,EACbhD,EAAI8G,WAAY,EACT9G,EAIT,QAASiF,MACP,MAAO8B,MAAcA,GAAYL,GAAQ,IAG3C,QAASM,IAAUhH,EAAKlE,EAAGC,GACzB,GAAIkL,GACAC,CACJ,IAAKlH,EAAIqG,MAMF,CACL,GAAIc,GAAgBxN,EAAQyN,IACxBC,EAAW1N,EAAQ2N,GAEvB,IADAL,EAAUM,GAAWvH,EAAIqG,MAAOrG,EAAI6G,UAAW,MAAGnM,GAAWoB,EAAGC,EAAGoL,EAAeE,IAC7EA,EAAShP,MACZ,MAAO2H,EAETkH,GAAUlH,EAAIrF,MAAQwM,EAAc9O,MAAQ0D,IAAMwF,IAAW,EAAI,EAAI,OAbvD,CACd,GAAIxF,IAAMwF,GACR,MAAOvB,EAETkH,GAAU,EACVD,EAAU,GAAI1B,IAAavF,EAAI6G,YAAa/K,EAAGC,KAUjD,MAAIiE,GAAI6G,WACN7G,EAAIrF,KAAOuM,EACXlH,EAAIqG,MAAQY,EACZjH,EAAIY,WAASlG,GACbsF,EAAI8G,WAAY,EACT9G,GAEFiH,EAAUP,GAAQQ,EAASD,GAAWhC,KAG/C,QAASsC,IAAW3C,EAAMY,EAASgC,EAAOzB,EAASjG,EAAKzH,EAAO8O,EAAeE,GAC5E,MAAKzC,GAQEA,EAAK6C,OAAOjC,EAASgC,EAAOzB,EAASjG,EAAKzH,EAAO8O,EAAeE,GAPjEhP,IAAUkJ,GACLqD,GAET/K,EAAOwN,GACPxN,EAAOsN,GACA,GAAInB,IAAUR,EAASO,GAAUjG,EAAKzH,KAKjD,QAASqP,IAAW9C,GAClB,MAAOA,GAAKzM,cAAgB6N,IAAapB,EAAKzM,cAAgB2N,GAGhE,QAAS6B,IAAc/C,EAAMY,EAASgC,EAAOzB,EAAS1G,GACpD,GAAIuF,EAAKmB,UAAYA,EACnB,MAAO,IAAID,IAAkBN,EAASO,GAAUnB,EAAKvF,MAAOA,GAG9D,IAGIuI,GAHAC,GAAkB,IAAVL,EAAc5C,EAAKmB,QAAUnB,EAAKmB,UAAYyB,GAASM,GAC/DC,GAAkB,IAAVP,EAAczB,EAAUA,IAAYyB,GAASM,EAOzD,OAAO,IAAIrC,IAAkBD,EAAU,GAAKqC,EAAS,GAAKE,EAJ9CF,IAASE,GAClBJ,GAAc/C,EAAMY,EAASgC,EAAQQ,GAAOjC,EAAS1G,KACpDuI,EAAU,GAAI5B,IAAUR,EAASO,EAAS1G,GAASwI,EAAOE,GAAQnD,EAAMgD,IAAYA,EAAShD,KAKnG,QAASqD,IAAYzC,EAAS1E,EAAShB,EAAKzH,GACrCmN,IACHA,EAAU,GAAI1L,GAGhB,KAAK,GADD8K,GAAO,GAAIoB,IAAUR,EAASxC,GAAKlD,IAAOA,EAAKzH,IAC1CkC,EAAK,EAAGA,EAAKuG,EAAQzG,OAAQE,IAAM,CAC1C,GAAI8E,GAAQyB,EAAQvG,EACpBqK,GAAOA,EAAK6C,OAAOjC,EAAS,MAAG9K,GAAW2E,EAAM,GAAIA,EAAM,IAE5D,MAAOuF,GAGT,QAASsD,IAAU1C,EAASG,EAAOE,EAAOsC,GAIxC,IAAK,GAHDzC,GAAS,EACT0C,EAAW,EACXC,EAAc,GAAIlR,OAAM0O,GACnBtL,EAAK,EAAG+N,EAAM,EAAGpO,EAAMyL,EAAMtL,OAAQE,EAAKL,EAAKK,IAAM+N,IAAQ,EAAG,CACvE,GAAI1D,GAAOe,EAAMpL,OACJG,KAATkK,GAAsBrK,IAAO4N,IAC/BzC,GAAU4C,EACVD,EAAYD,KAAcxD,GAG9B,MAAO,IAAIa,IAAkBD,EAASE,EAAQ2C,GAGhD,QAASE,IAAY/C,EAASG,EAAOD,EAAQ8C,EAAW5D,GAGtD,IAAK,GAFDiB,GAAQ,EACR4C,EAAgB,GAAItR,OAAMuR,IACrBnO,EAAK,EAAc,IAAXmL,EAAcnL,IAAMmL,KAAY,EAC/C+C,EAAclO,GAAe,EAATmL,EAAaC,EAAME,SAAWnL,EAGpD,OADA+N,GAAcD,GAAa5D,EACpB,GAAIgB,IAAiBJ,EAASK,EAAQ,EAAG4C,GAGlD,QAASE,IAAiB3I,EAAK4I,EAAQC,GAErC,IAAK,GADDC,MACKvO,EAAK,EAAGA,EAAKsO,EAAUxO,OAAQE,IAAM,CAC5C,GAAIlC,GAAQwQ,EAAUtO,GAClBE,EAAOjC,EAAcH,EACpBC,GAAWD,KACdoC,EAAOA,EAAKuF,IAAI,SAASjE,GAAK,MAAO0D,GAAO1D,MAE9C+M,EAAMC,KAAKtO,GAEb,MAAOuO,IAAwBhJ,EAAK4I,EAAQE,GAG9C,QAASG,IAAWC,EAAU7Q,EAAOyH,GACnC,MAAOoJ,IAAYA,EAASC,WAAa7Q,EAAWD,GAClD6Q,EAASC,UAAU9Q,GACnB+H,EAAG8I,EAAU7Q,GAAS6Q,EAAW7Q,EAGrC,QAAS+Q,IAAeR,GACtB,MAAO,UAASM,EAAU7Q,EAAOyH,GAC/B,GAAIoJ,GAAYA,EAASG,eAAiB/Q,EAAWD,GACnD,MAAO6Q,GAASG,cAAcT,EAAQvQ,EAExC,IAAIiR,GAAYV,EAAOM,EAAU7Q,EAAOyH,EACxC,OAAOM,GAAG8I,EAAUI,GAAaJ,EAAWI,GAIhD,QAASN,IAAwBO,EAAYX,EAAQE,GAEnD,MADAA,GAAQA,EAAMU,OAAO,SAASC,GAAK,MAAkB,KAAXA,EAAE9O,OACvB,IAAjBmO,EAAMzO,OACDkP,EAEe,IAApBA,EAAW5O,MAAe4O,EAAW1C,WAA8B,IAAjBiC,EAAMzO,OAGrDkP,EAAWpE,cAAc,SAASoE,GAUvC,IAAK,GATDG,GAAed,EACjB,SAASvQ,EAAOyH,GACdyJ,EAAW9B,OAAO3H,EAAKyB,GAAS,SAAS2H,GACtC,MAAOA,KAAa3H,GAAUlJ,EAAQuQ,EAAOM,EAAU7Q,EAAOyH,MAGnE,SAASzH,EAAOyH,GACdyJ,EAAWjF,IAAIxE,EAAKzH,IAEfkC,EAAK,EAAGA,EAAKuO,EAAMzO,OAAQE,IAClCuO,EAAMvO,GAAI6K,QAAQsE,KAbbH,EAAWpR,YAAY2Q,EAAM,IAkBxC,QAASa,IAAgBT,EAAUU,EAAaC,EAAaC,GAC3D,GAAIC,GAAWb,IAAa3H,GACxBY,EAAOyH,EAAYjO,MACvB,IAAIwG,EAAKlG,KAAM,CACb,GAAI+N,GAAgBD,EAAWF,EAAcX,EACzCe,EAAWH,EAAQE,EACvB,OAAOC,KAAaD,EAAgBd,EAAWe,EAEjDpI,EACEkI,GAAab,GAAYA,EAAS5E,IAClC,kBAEF,IAAIxE,GAAMqC,EAAK9J,MACX6R,EAAeH,EAAWxI,GAAU2H,EAAS5H,IAAIxB,EAAKyB,IACtD4I,EAAcR,GAChBO,EACAN,EACAC,EACAC,EAEF,OAAOK,KAAgBD,EAAehB,EACpCiB,IAAgB5I,GAAU2H,EAASkB,OAAOtK,IACzCiK,EAAW9E,KAAaiE,GAAU5E,IAAIxE,EAAKqK,GAGhD,QAASE,IAASZ,GAMhB,MALAA,IAAUA,GAAK,EAAK,WACpBA,GAAS,UAAJA,IAAoBA,GAAK,EAAK,WACnCA,EAAKA,GAAKA,GAAK,GAAM,UACrBA,GAASA,GAAK,EAEH,KADXA,GAASA,GAAK,IAIhB,QAASa,IAAM7M,EAAO8M,EAAKC,EAAKC,GAC9B,GAAIC,GAAWD,EAAUhN,EAAQ1D,EAAQ0D,EAEzC,OADAiN,GAASH,GAAOC,EACTE,EAGT,QAASC,IAASlN,EAAO8M,EAAKC,EAAKC,GACjC,GAAIG,GAASnN,EAAMpD,OAAS,CAC5B,IAAIoQ,GAAWF,EAAM,IAAMK,EAEzB,MADAnN,GAAM8M,GAAOC,EACN/M,CAIT,KAAK,GAFDiN,GAAW,GAAIvT,OAAMyT,GACrBC,EAAQ,EACHtQ,EAAK,EAAGA,EAAKqQ,EAAQrQ,IACxBA,IAAOgQ,GACTG,EAASnQ,GAAMiQ,EACfK,GAAS,GAETH,EAASnQ,GAAMkD,EAAMlD,EAAKsQ,EAG9B,OAAOH,GAGT,QAASI,IAAUrN,EAAO8M,EAAKE,GAC7B,GAAIG,GAASnN,EAAMpD,OAAS,CAC5B,IAAIoQ,GAAWF,IAAQK,EAErB,MADAnN,GAAMsN,MACCtN,CAIT,KAAK,GAFDiN,GAAW,GAAIvT,OAAMyT,GACrBC,EAAQ,EACHtQ,EAAK,EAAGA,EAAKqQ,EAAQrQ,IACxBA,IAAOgQ,IACTM,EAAQ,GAEVH,EAASnQ,GAAMkD,EAAMlD,EAAKsQ,EAE5B,OAAOH,GAWP,QAASM,IAAK3S,GACZ,GAAI4S,GAAQC,IACZ,IAAc,OAAV7S,OAA4BqC,KAAVrC,EACpB,MAAO4S,EAET,IAAIE,GAAO9S,GACT,MAAOA,EAET,IAAIoC,GAAO9B,EAAgBN,GACvBsC,EAAOF,EAAKE,IAChB,OAAa,KAATA,EACKsQ,GAETlG,GAAkBpK,GACdA,EAAO,GAAKA,EAAO+N,GACd0C,GAAS,EAAGzQ,EAAMqN,GAAO,KAAM,GAAIqD,IAAM5Q,EAAK6Q,YAEhDL,EAAM9F,cAAc,SAASoG,GAClCA,EAAKC,QAAQ7Q,GACbF,EAAK2K,QAAQ,SAASrJ,EAAG0P,GAAK,MAAOF,GAAKjH,IAAImH,EAAG1P,QA4JvD,QAASoP,IAAOO,GACd,SAAUA,IAAaA,EAAUC,KAwBjC,QAASN,IAAM5N,EAAO+H,GACpB5N,KAAK6F,MAAQA,EACb7F,KAAK4N,QAAUA,EAmEnB,QAASoG,IAAYL,EAAMvM,GAQzB,QAAS6M,GAAkBjH,EAAMkH,EAAO7R,GACtC,MAAiB,KAAV6R,EACLC,EAAYnH,EAAM3K,GAClB+R,EAAYpH,EAAMkH,EAAO7R,GAG7B,QAAS8R,GAAYnH,EAAM3K,GACzB,GAAIwD,GAAQxD,IAAWgS,EAAUC,GAAQA,EAAKzO,MAAQmH,GAAQA,EAAKnH,MAC/D0O,EAAOlS,EAASmS,EAAO,EAAIA,EAAOnS,EAClCoS,EAAKC,EAAQrS,CAIjB,OAHIoS,GAAK3D,KACP2D,EAAK3D,IAEA,WACL,GAAIyD,IAASE,EACX,MAAOE,GAET,IAAIhC,GAAMvL,IAAYqN,EAAKF,GAC3B,OAAO1O,IAASA,EAAM8M,IAI1B,QAASyB,GAAYpH,EAAMkH,EAAO7R,GAChC,GAAIuS,GACA/O,EAAQmH,GAAQA,EAAKnH,MACrB0O,EAAOlS,EAASmS,EAAO,EAAKA,EAAOnS,GAAW6R,EAC9CO,EAAmC,GAA5BC,EAAQrS,GAAW6R,EAI9B,OAHIO,GAAK3D,KACP2D,EAAK3D,IAEA,WACL,OAAG,CACD,GAAI8D,EAAQ,CACV,GAAInU,GAAQmU,GACZ,IAAInU,IAAUkU,GACZ,MAAOlU,EAETmU,GAAS,KAEX,GAAIL,IAASE,EACX,MAAOE,GAET,IAAIhC,GAAMvL,IAAYqN,EAAKF,GAC3BK,GAASX,EACPpO,GAASA,EAAM8M,GAAMuB,EAAQ9D,GAAO/N,GAAUsQ,GAAOuB,MAnD7D,GAAIM,GAAOb,EAAKkB,QACZH,EAAQf,EAAKmB,UACbT,EAAUU,GAAcL,GACxBJ,EAAOX,EAAKqB,KAEhB,OAAOf,GAAkBN,EAAKlF,MAAOkF,EAAKsB,OAAQ,GAqDpD,QAASzB,IAAS0B,EAAQC,EAAUjB,EAAOnF,EAAMuF,EAAM1G,EAASxC,GAC9D,GAAIuI,GAAOtT,OAAOC,OAAO8U,GAUzB,OATAzB,GAAK5Q,KAAOoS,EAAWD,EACvBvB,EAAKkB,QAAUK,EACfvB,EAAKmB,UAAYK,EACjBxB,EAAKsB,OAASf,EACdP,EAAKlF,MAAQM,EACb4E,EAAKqB,MAAQV,EACbX,EAAK1E,UAAYrB,EACjB+F,EAAK3K,OAASoC,EACduI,EAAKzE,WAAY,EACVyE,EAIT,QAASL,MACP,MAAO+B,MAAeA,GAAa7B,GAAS,EAAG,EAAGpD,KAGpD,QAASkF,IAAW3B,EAAMxQ,EAAO1C,GAG/B,IAFA0C,EAAQD,EAAUyQ,EAAMxQ,MAEVA,EACZ,MAAOwQ,EAGT,IAAIxQ,GAASwQ,EAAK5Q,MAAQI,EAAQ,EAChC,MAAOwQ,GAAKpG,cAAc,SAASoG,GACjCxQ,EAAQ,EACNoS,GAAc5B,EAAMxQ,GAAOuJ,IAAI,EAAGjM,GAClC8U,GAAc5B,EAAM,EAAGxQ,EAAQ,GAAGuJ,IAAIvJ,EAAO1C,IAInD0C,IAASwQ,EAAKkB,OAEd,IAAIW,GAAU7B,EAAKqB,MACf3F,EAAUsE,EAAKlF,MACfgB,EAAW1N,EAAQ2N,GAOvB,OANIvM,IAAS4R,GAAcpB,EAAKmB,WAC9BU,EAAUC,GAAYD,EAAS7B,EAAK1E,UAAW,EAAG9L,EAAO1C,EAAOgP,GAEhEJ,EAAUoG,GAAYpG,EAASsE,EAAK1E,UAAW0E,EAAKsB,OAAQ9R,EAAO1C,EAAOgP,GAGvEA,EAAShP,MAIVkT,EAAK1E,WACP0E,EAAKlF,MAAQY,EACbsE,EAAKqB,MAAQQ,EACb7B,EAAK3K,WAASlG,GACd6Q,EAAKzE,WAAY,EACVyE,GAEFH,GAASG,EAAKkB,QAASlB,EAAKmB,UAAWnB,EAAKsB,OAAQ5F,EAASmG,GAV3D7B,EAaX,QAAS8B,IAAYzI,EAAMY,EAASsG,EAAO/Q,EAAO1C,EAAOgP,GACvD,GAAIkD,GAAOxP,IAAU+Q,EAAShE,GAC1BwF,EAAU1I,GAAQ2F,EAAM3F,EAAKnH,MAAMpD,MACvC,KAAKiT,OAAqB5S,KAAVrC,EACd,MAAOuM,EAGT,IAAIgD,EAEJ,IAAIkE,EAAQ,EAAG,CACb,GAAIyB,GAAY3I,GAAQA,EAAKnH,MAAM8M,GAC/BiD,EAAeH,GAAYE,EAAW/H,EAASsG,EAAQ9D,GAAOjN,EAAO1C,EAAOgP,EAChF,OAAImG,KAAiBD,EACZ3I,GAETgD,EAAU6F,GAAc7I,EAAMY,GAC9BoC,EAAQnK,MAAM8M,GAAOiD,EACd5F,GAGT,MAAI0F,IAAW1I,EAAKnH,MAAM8M,KAASlS,EAC1BuM,GAGT/K,EAAOwN,GAEPO,EAAU6F,GAAc7I,EAAMY,OAChB9K,KAAVrC,GAAuBkS,IAAQ3C,EAAQnK,MAAMpD,OAAS,EACxDuN,EAAQnK,MAAMsN,MAEdnD,EAAQnK,MAAM8M,GAAOlS,EAEhBuP,GAGT,QAAS6F,IAAc7I,EAAMY,GAC3B,MAAIA,IAAWZ,GAAQY,IAAYZ,EAAKY,QAC/BZ,EAEF,GAAIyG,IAAMzG,EAAOA,EAAKnH,MAAMiQ,WAAclI,GAGnD,QAASmI,IAAYpC,EAAMqC,GACzB,GAAIA,GAAYjB,GAAcpB,EAAKmB,WACjC,MAAOnB,GAAKqB,KAEd,IAAIgB,EAAW,GAAMrC,EAAKsB,OAAS7E,GAAQ,CAGzC,IAFA,GAAIpD,GAAO2G,EAAKlF,MACZyF,EAAQP,EAAKsB,OACVjI,GAAQkH,EAAQ,GACrBlH,EAAOA,EAAKnH,MAAOmQ,IAAa9B,EAAShE,IACzCgE,GAAS9D,EAEX,OAAOpD,IAIX,QAASuI,IAAc5B,EAAMpQ,EAAOC,OAGpBV,KAAVS,IACFA,GAAgB,OAENT,KAARU,IACFA,GAAY,EAEd,IAAIyS,GAAQtC,EAAK1E,WAAa,GAAI/M,GAC9BgU,EAAYvC,EAAKkB,QACjBsB,EAAcxC,EAAKmB,UACnBsB,EAAYF,EAAY3S,EACxB8S,MAAsBvT,KAARU,EAAoB2S,EAAc3S,EAAM,EAAI2S,EAAc3S,EAAM0S,EAAY1S,CAC9F,IAAI4S,IAAcF,GAAaG,IAAgBF,EAC7C,MAAOxC,EAIT,IAAIyC,GAAaC,EACf,MAAO1C,GAAK2C,OAQd,KALA,GAAIC,GAAW5C,EAAKsB,OAChB5F,EAAUsE,EAAKlF,MAGf+H,EAAc,EACXJ,EAAYI,EAAc,GAC/BnH,EAAU,GAAIoE,IAAMpE,GAAWA,EAAQxJ,MAAMpD,YAAUK,GAAWuM,MAAe4G,GACjFM,GAAYnG,GACZoG,GAAe,GAAKD,CAElBC,KACFJ,GAAaI,EACbN,GAAaM,EACbH,GAAeG,EACfL,GAAeK,EAOjB,KAJA,GAAIC,GAAgB1B,GAAcoB,GAC9BO,EAAgB3B,GAAcsB,GAG3BK,GAAiB,GAAMH,EAAWnG,IACvCf,EAAU,GAAIoE,IAAMpE,GAAWA,EAAQxJ,MAAMpD,QAAU4M,MAAe4G,GACtEM,GAAYnG,EAId,IAAIuG,GAAUhD,EAAKqB,MACfQ,EAAUkB,EAAgBD,EAC5BV,GAAYpC,EAAM0C,EAAc,GAChCK,EAAgBD,EAAgB,GAAIhD,OAAUwC,GAASU,CAGzD,IAAIA,GAAWD,EAAgBD,GAAiBL,EAAYD,GAAeQ,EAAQ9Q,MAAMpD,OAAQ,CAC/F4M,EAAUwG,GAAcxG,EAAS4G,EAEjC,KAAK,GADDjJ,GAAOqC,EACF6E,EAAQqC,EAAUrC,EAAQ9D,GAAO8D,GAAS9D,GAAO,CACxD,GAAIuC,GAAO8D,IAAkBvC,EAAShE,EACtClD,GAAOA,EAAKnH,MAAM8M,GAAOkD,GAAc7I,EAAKnH,MAAM8M,GAAMsD,GAE1DjJ,EAAKnH,MAAO4Q,IAAkBrG,GAASF,IAAQyG,EASjD,GALIN,EAAcF,IAChBX,EAAUA,GAAWA,EAAQoB,YAAYX,EAAO,EAAGI,IAIjDD,GAAaM,EACfN,GAAaM,EACbL,GAAeK,EACfH,EAAWnG,GACXf,EAAU,KACVmG,EAAUA,GAAWA,EAAQqB,aAAaZ,EAAO,EAAGG,OAG/C,IAAIA,EAAYF,GAAaQ,EAAgBD,EAAe,CAIjE,IAHAD,EAAc,EAGPnH,GAAS,CACd,GAAIyH,GAAcV,IAAcG,EAAYrG,EAC5C,IAAI4G,IAAgBJ,IAAkBH,EAAYrG,GAChD,KAEE4G,KACFN,IAAgB,GAAKD,GAAYO,GAEnCP,GAAYnG,GACZf,EAAUA,EAAQxJ,MAAMiR,GAItBzH,GAAW+G,EAAYF,IACzB7G,EAAUA,EAAQwH,aAAaZ,EAAOM,EAAUH,EAAYI,IAE1DnH,GAAWqH,EAAgBD,IAC7BpH,EAAUA,EAAQuH,YAAYX,EAAOM,EAAUG,EAAgBF,IAE7DA,IACFJ,GAAaI,EACbH,GAAeG,GAInB,MAAI7C,GAAK1E,WACP0E,EAAK5Q,KAAOsT,EAAcD,EAC1BzC,EAAKkB,QAAUuB,EACfzC,EAAKmB,UAAYuB,EACjB1C,EAAKsB,OAASsB,EACd5C,EAAKlF,MAAQY,EACbsE,EAAKqB,MAAQQ,EACb7B,EAAK3K,WAASlG,GACd6Q,EAAKzE,WAAY,EACVyE,GAEFH,GAAS4C,EAAWC,EAAaE,EAAUlH,EAASmG,GAG7D,QAASuB,IAAkBpD,EAAM3C,EAAQC,GAGvC,IAAK,GAFDC,MACA8F,EAAU,EACLrU,EAAK,EAAGA,EAAKsO,EAAUxO,OAAQE,IAAM,CAC5C,GAAIlC,GAAQwQ,EAAUtO,GAClBE,EAAO9B,EAAgBN,EACvBoC,GAAKE,KAAOiU,IACdA,EAAUnU,EAAKE,MAEZrC,EAAWD,KACdoC,EAAOA,EAAKuF,IAAI,SAASjE,GAAK,MAAO0D,GAAO1D,MAE9C+M,EAAMC,KAAKtO,GAKb,MAHImU,GAAUrD,EAAK5Q,OACjB4Q,EAAOA,EAAKC,QAAQoD,IAEf5F,GAAwBuC,EAAM3C,EAAQE,GAG/C,QAAS6D,IAAchS,GACrB,MAAOA,GAAO+N,GAAO,EAAO/N,EAAO,IAAOqN,IAAUA,GAOpD,QAAS6G,IAAWxW,GAClB,MAAiB,QAAVA,OAA4BqC,KAAVrC,EAAsByW,KAC7CC,GAAa1W,GAASA,EACtByW,KAAkB3J,cAAc,SAASnF,GACvC,GAAIvF,GAAOjC,EAAcH,EACzB0M,IAAkBtK,EAAKE,MACvBF,EAAK2K,QAAQ,SAASrJ,EAAGD,GAAK,MAAOkE,GAAIsE,IAAIxI,EAAGC,OAyExD,QAASgT,IAAaC,GACpB,MAAO9J,IAAM8J,IAAoBxV,EAAUwV,GAU7C,QAASC,IAAejP,EAAKuL,EAAM/F,EAASxC,GAC1C,GAAIkM,GAAOjX,OAAOC,OAAO2W,GAAW7W,UAMpC,OALAkX,GAAKvU,KAAOqF,EAAMA,EAAIrF,KAAO,EAC7BuU,EAAKC,KAAOnP,EACZkP,EAAKE,MAAQ7D,EACb2D,EAAKrI,UAAYrB,EACjB0J,EAAKtO,OAASoC,EACPkM,EAIT,QAASJ,MACP,MAAOO,MAAsBA,GAAoBJ,GAAehK,KAAYiG,OAG9E,QAASoE,IAAiBJ,EAAMpT,EAAGC,GACjC,GAIIwT,GACAC,EALAxP,EAAMkP,EAAKC,KACX5D,EAAO2D,EAAKE,MACZ3D,EAAIzL,EAAIsB,IAAIxF,GACZuF,MAAY3G,KAAN+Q,CAGV,IAAI1P,IAAMwF,GAAS,CACjB,IAAKF,EACH,MAAO6N,EAEL3D,GAAK5Q,MAAQ+N,IAAQ6C,EAAK5Q,MAAmB,EAAXqF,EAAIrF,MACxC6U,EAAUjE,EAAK/B,OAAO,SAASnK,EAAOkL,GAAO,WAAiB7P,KAAV2E,GAAuBoM,IAAMlB,IACjFgF,EAASC,EAAQvS,aAAa+C,IAAI,SAASX,GAAS,MAAOA,GAAM,KAAKoQ,OAAOtP,QACzE+O,EAAKrI,YACP0I,EAAO1I,UAAY2I,EAAQ3I,UAAYqI,EAAKrI,aAG9C0I,EAASvP,EAAIoK,OAAOtO,GACpB0T,EAAU/D,IAAMF,EAAK5Q,KAAO,EAAI4Q,EAAKR,MAAQQ,EAAKjH,IAAImH,MAAG/Q,SAG3D,IAAI2G,EAAK,CACP,GAAItF,IAAMwP,EAAKjK,IAAImK,GAAG,GACpB,MAAOyD,EAETK,GAASvP,EACTwP,EAAUjE,EAAKjH,IAAImH,GAAI3P,EAAGC,QAE1BwT,GAASvP,EAAIsE,IAAIxI,EAAGyP,EAAK5Q,MACzB6U,EAAUjE,EAAKjH,IAAIiH,EAAK5Q,MAAOmB,EAAGC,GAGtC,OAAImT,GAAKrI,WACPqI,EAAKvU,KAAO4U,EAAO5U,KACnBuU,EAAKC,KAAOI,EACZL,EAAKE,MAAQI,EACbN,EAAKtO,WAASlG,GACPwU,GAEFD,GAAeM,EAAQC,GAI9B,QAASE,IAAgBC,EAAS1Q,GAChCrH,KAAKgY,MAAQD,EACb/X,KAAKiY,SAAW5Q,EAChBrH,KAAK+C,KAAOgV,EAAQhV,KA2DtB,QAASmV,IAAkBrV,GACzB7C,KAAKgY,MAAQnV,EACb7C,KAAK+C,KAAOF,EAAKE,KAyBnB,QAASoV,IAActV,GACrB7C,KAAKgY,MAAQnV,EACb7C,KAAK+C,KAAOF,EAAKE,KAuBnB,QAASqV,IAAoBlP,GAC3BlJ,KAAKgY,MAAQ9O,EACblJ,KAAK+C,KAAOmG,EAAQnG,KAwDxB,QAASsV,IAAYzT,GACnB,GAAI0T,GAAeC,GAAa3T,EAiChC,OAhCA0T,GAAaN,MAAQpT,EACrB0T,EAAavV,KAAO6B,EAAS7B,KAC7BuV,EAAaT,KAAO,WAAa,MAAOjT,IACxC0T,EAAalR,QAAU,WACrB,GAAIoR,GAAmB5T,EAASwC,QAAQyF,MAAM7M,KAE9C,OADAwY,GAAiBX,KAAO,WAAa,MAAOjT,GAASwC,WAC9CoR,GAETF,EAAa7O,IAAM,SAASvB,GAAO,MAAOtD,GAAS6T,SAASvQ,IAC5DoQ,EAAaG,SAAW,SAASvQ,GAAO,MAAOtD,GAAS6E,IAAIvB,IAC5DoQ,EAAajP,YAAcqP,GAC3BJ,EAAa5Q,kBAAoB,SAAUP,EAAIC,GAAU,GAAIuR,GAAS3Y,IACpE,OAAO4E,GAAS5B,UAAU,SAASmB,EAAGD,GAAK,OAA4B,IAArBiD,EAAGjD,EAAGC,EAAGwU,IAAoBvR,IAEjFkR,EAAa1Q,mBAAqB,SAAS3D,EAAMmD,GAC/C,GAAInD,IAAS2U,GAAiB,CAC5B,GAAIrS,GAAW3B,EAASiU,WAAW5U,EAAMmD,EACzC,OAAO,IAAItD,GAAS,WAClB,GAAIyG,GAAOhE,EAASxC,MACpB,KAAKwG,EAAKlG,KAAM,CACd,GAAIH,GAAIqG,EAAK9J,MAAM,EACnB8J,GAAK9J,MAAM,GAAK8J,EAAK9J,MAAM,GAC3B8J,EAAK9J,MAAM,GAAKyD,EAElB,MAAOqG,KAGX,MAAO3F,GAASiU,WACd5U,IAAS6U,GAAiBC,GAAeD,GACzC1R,IAGGkR,EAIT,QAASU,IAAWpU,EAAUqU,EAAQC,GACpC,GAAIC,GAAiBZ,GAAa3T,EAgClC,OA/BAuU,GAAepW,KAAO6B,EAAS7B,KAC/BoW,EAAe1P,IAAM,SAASvB,GAAO,MAAOtD,GAAS6E,IAAIvB,IACzDiR,EAAezP,IAAM,SAASxB,EAAK+J,GACjC,GAAI9N,GAAIS,EAAS8E,IAAIxB,EAAKyB,GAC1B,OAAOxF,KAAMwF,GACXsI,EACAgH,EAAOnU,KAAKoU,EAAS/U,EAAG+D,EAAKtD,IAEjCuU,EAAezR,kBAAoB,SAAUP,EAAIC,GAAU,GAAIuR,GAAS3Y,IACtE,OAAO4E,GAAS5B,UACd,SAASmB,EAAGD,EAAGkV,GAAK,OAAwD,IAAjDjS,EAAG8R,EAAOnU,KAAKoU,EAAS/U,EAAGD,EAAGkV,GAAIlV,EAAGyU,IAChEvR,IAGJ+R,EAAevR,mBAAqB,SAAU3D,EAAMmD,GAClD,GAAIb,GAAW3B,EAASiU,WAAWD,GAAiBxR,EACpD,OAAO,IAAItD,GAAS,WAClB,GAAIyG,GAAOhE,EAASxC,MACpB,IAAIwG,EAAKlG,KACP,MAAOkG,EAET,IAAI9C,GAAQ8C,EAAK9J,MACbyH,EAAMT,EAAM,EAChB,OAAOzD,GACLC,EACAiE,EACA+Q,EAAOnU,KAAKoU,EAASzR,EAAM,GAAIS,EAAKtD,GACpC2F,MAIC4O,EAIT,QAASE,IAAezU,EAAUyC,GAChC,GAAImR,GAAmBD,GAAa3T,EAsBpC,OArBA4T,GAAiBR,MAAQpT,EACzB4T,EAAiBzV,KAAO6B,EAAS7B,KACjCyV,EAAiBpR,QAAU,WAAa,MAAOxC,IAC3CA,EAASiT,OACXW,EAAiBX,KAAO,WACtB,GAAIS,GAAeD,GAAYzT,EAE/B,OADA0T,GAAalR,QAAU,WAAa,MAAOxC,GAASiT,QAC7CS,IAGXE,EAAiB9O,IAAM,SAASxB,EAAK+J,GAClC,MAAOrN,GAAS8E,IAAIrC,EAAUa,GAAO,EAAIA,EAAK+J,IACjDuG,EAAiB/O,IAAM,SAASvB,GAC7B,MAAOtD,GAAS6E,IAAIpC,EAAUa,GAAO,EAAIA,IAC5CsQ,EAAiBC,SAAW,SAAShY,GAAS,MAAOmE,GAAS6T,SAAShY,IACvE+X,EAAiBnP,YAAcqP,GAC/BF,EAAiBxV,UAAY,SAAUmE,EAAIC,GAAU,GAAIuR,GAAS3Y,IAChE,OAAO4E,GAAS5B,UAAU,SAASmB,EAAGD,GAAK,MAAOiD,GAAGhD,EAAGD,EAAGyU,KAAWvR,IAExEoR,EAAiBK,WACf,SAAS5U,EAAMmD,GAAW,MAAOxC,GAASiU,WAAW5U,GAAOmD,IACvDoR,EAIT,QAASc,IAAc1U,EAAU2U,EAAWL,EAAS7R,GACnD,GAAImS,GAAiBjB,GAAa3T,EAwClC,OAvCIyC,KACFmS,EAAe/P,IAAM,SAASvB,GAC5B,GAAI/D,GAAIS,EAAS8E,IAAIxB,EAAKyB,GAC1B,OAAOxF,KAAMwF,MAAa4P,EAAUzU,KAAKoU,EAAS/U,EAAG+D,EAAKtD,IAE5D4U,EAAe9P,IAAM,SAASxB,EAAK+J,GACjC,GAAI9N,GAAIS,EAAS8E,IAAIxB,EAAKyB,GAC1B,OAAOxF,KAAMwF,IAAW4P,EAAUzU,KAAKoU,EAAS/U,EAAG+D,EAAKtD,GACtDT,EAAI8N,IAGVuH,EAAe9R,kBAAoB,SAAUP,EAAIC,GAAU,GAAIuR,GAAS3Y,KAClEyZ,EAAa,CAOjB,OANA7U,GAAS5B,UAAU,SAASmB,EAAGD,EAAGkV,GAChC,GAAIG,EAAUzU,KAAKoU,EAAS/U,EAAGD,EAAGkV,GAEhC,MADAK,KACOtS,EAAGhD,EAAGkD,EAAUnD,EAAIuV,EAAa,EAAGd,IAE5CvR,GACIqS,GAETD,EAAe5R,mBAAqB,SAAU3D,EAAMmD,GAClD,GAAIb,GAAW3B,EAASiU,WAAWD,GAAiBxR,GAChDqS,EAAa,CACjB,OAAO,IAAI3V,GAAS,WAClB,OAAa,CACX,GAAIyG,GAAOhE,EAASxC,MACpB,IAAIwG,EAAKlG,KACP,MAAOkG,EAET,IAAI9C,GAAQ8C,EAAK9J,MACbyH,EAAMT,EAAM,GACZhH,EAAQgH,EAAM,EAClB,IAAI8R,EAAUzU,KAAKoU,EAASzY,EAAOyH,EAAKtD,GACtC,MAAOZ,GAAcC,EAAMoD,EAAUa,EAAMuR,IAAchZ,EAAO8J,OAKjEiP,EAIT,QAASE,IAAe9U,EAAU+U,EAAST,GACzC,GAAIU,GAASxM,KAAMyM,WAQnB,OAPAjV,GAAS5B,UAAU,SAASmB,EAAGD,GAC7B0V,EAAO/J,OACL8J,EAAQ7U,KAAKoU,EAAS/U,EAAGD,EAAGU,GAC5B,EACA,SAASkE,GAAK,MAAOA,GAAI,MAGtB8Q,EAAOE,cAIhB,QAASC,IAAenV,EAAU+U,EAAST,GACzC,GAAIc,GAAcnZ,EAAQ+D,GACtBgV,GAAUhY,EAAUgD,GAAYqS,KAAe7J,MAAOyM,WAC1DjV,GAAS5B,UAAU,SAASmB,EAAGD,GAC7B0V,EAAO/J,OACL8J,EAAQ7U,KAAKoU,EAAS/U,EAAGD,EAAGU,GAC5B,SAASkE,GAAK,MAAQA,GAAIA,MAASA,EAAEqI,KAAK6I,GAAe9V,EAAGC,GAAKA,GAAI2E,KAGzE,IAAImR,GAASC,GAActV,EAC3B,OAAOgV,GAAOxR,IAAI,SAAShG,GAAO,MAAO+X,IAAMvV,EAAUqV,EAAO7X,MAIlE,QAASgY,IAAaxV,EAAUrB,EAAOC,EAAK6D,GAC1C,GAAIgT,GAAezV,EAAS7B,IAe5B,QAXcD,KAAVS,IACFA,GAAgB,OAENT,KAARU,IACEA,IAAQuG,IACVvG,EAAM6W,EAEN7W,GAAY,GAIZF,EAAWC,EAAOC,EAAK6W,GACzB,MAAOzV,EAGT,IAAI0V,GAAgB7W,EAAaF,EAAO8W,GACpCE,EAAc5W,EAAWH,EAAK6W,EAKlC,IAAIC,IAAkBA,GAAiBC,IAAgBA,EACrD,MAAOH,IAAaxV,EAASO,QAAQkE,cAAe9F,EAAOC,EAAK6D,EAOlE,IACImT,GADAC,EAAeF,EAAcD,CAE7BG,KAAiBA,IACnBD,EAAYC,EAAe,EAAI,EAAIA,EAGrC,IAAIC,GAAWnC,GAAa3T,EA6D5B,OAzDA8V,GAAS3X,KAAqB,IAAdyX,EAAkBA,EAAY5V,EAAS7B,MAAQyX,OAAa1X,IAEvEuE,GAAWX,EAAM9B,IAAa4V,GAAa,IAC9CE,EAAShR,IAAM,SAAUvG,EAAO8O,GAE9B,MADA9O,GAAQD,EAAUlD,KAAMmD,GACjBA,GAAS,GAAKA,EAAQqX,EAC3B5V,EAAS8E,IAAIvG,EAAQmX,EAAerI,GACpCA,IAINyI,EAAShT,kBAAoB,SAASP,EAAIC,GAAU,GAAIuR,GAAS3Y,IAC/D,IAAkB,IAAdwa,EACF,MAAO,EAET,IAAIpT,EACF,MAAOpH,MAAKqJ,cAAcrG,UAAUmE,EAAIC,EAE1C,IAAIuT,GAAU,EACVC,GAAa,EACbnB,EAAa,CAQjB,OAPA7U,GAAS5B,UAAU,SAASmB,EAAGD,GAC7B,IAAM0W,KAAeA,EAAaD,IAAYL,GAE5C,MADAb,MACuD,IAAhDtS,EAAGhD,EAAGkD,EAAUnD,EAAIuV,EAAa,EAAGd,IACpCc,IAAee,IAGnBf,GAGTiB,EAAS9S,mBAAqB,SAAS3D,EAAMmD,GAC3C,GAAkB,IAAdoT,GAAmBpT,EACrB,MAAOpH,MAAKqJ,cAAcwP,WAAW5U,EAAMmD,EAG7C,IAAIb,GAAyB,IAAdiU,GAAmB5V,EAASiU,WAAW5U,EAAMmD,GACxDuT,EAAU,EACVlB,EAAa,CACjB,OAAO,IAAI3V,GAAS,WAClB,KAAO6W,IAAYL,GACjB/T,EAASxC,MAEX,MAAM0V,EAAae,EACjB,MAAOlW,IAET,IAAIiG,GAAOhE,EAASxC,MACpB,OAAIsD,IAAWpD,IAAS6U,GACfvO,EACEtG,IAAS8U,GACX/U,EAAcC,EAAMwV,EAAa,MAAG3W,GAAWyH,GAE/CvG,EAAcC,EAAMwV,EAAa,EAAGlP,EAAK9J,MAAM,GAAI8J,MAKzDmQ,EAIT,QAASG,IAAiBjW,EAAU2U,EAAWL,GAC7C,GAAI4B,GAAevC,GAAa3T,EAoChC,OAnCAkW,GAAapT,kBAAoB,SAASP,EAAIC,GAAU,GAAIuR,GAAS3Y,IACnE,IAAIoH,EACF,MAAOpH,MAAKqJ,cAAcrG,UAAUmE,EAAIC,EAE1C,IAAIqS,GAAa,CAIjB,OAHA7U,GAAS5B,UAAU,SAASmB,EAAGD,EAAGkV,GAC/B,MAAOG,GAAUzU,KAAKoU,EAAS/U,EAAGD,EAAGkV,MAAQK,GAActS,EAAGhD,EAAGD,EAAGyU,KAEhEc,GAETqB,EAAalT,mBAAqB,SAAS3D,EAAMmD,GAAU,GAAIuR,GAAS3Y,IACtE,IAAIoH,EACF,MAAOpH,MAAKqJ,cAAcwP,WAAW5U,EAAMmD,EAE7C,IAAIb,GAAW3B,EAASiU,WAAWD,GAAiBxR,GAChD2T,GAAY,CAChB,OAAO,IAAIjX,GAAS,WAClB,IAAKiX,EACH,MAAOzW,IAET,IAAIiG,GAAOhE,EAASxC,MACpB,IAAIwG,EAAKlG,KACP,MAAOkG,EAET,IAAI9C,GAAQ8C,EAAK9J,MACbyD,EAAIuD,EAAM,GACVtD,EAAIsD,EAAM,EACd,OAAK8R,GAAUzU,KAAKoU,EAAS/U,EAAGD,EAAGyU,GAI5B1U,IAAS2U,GAAkBrO,EAChCvG,EAAcC,EAAMC,EAAGC,EAAGoG,IAJ1BwQ,GAAY,EACLzW,QAMNwW,EAIT,QAASE,IAAiBpW,EAAU2U,EAAWL,EAAS7R,GACtD,GAAI4T,GAAe1C,GAAa3T,EA4ChC,OA3CAqW,GAAavT,kBAAoB,SAAUP,EAAIC,GAAU,GAAIuR,GAAS3Y,IACpE,IAAIoH,EACF,MAAOpH,MAAKqJ,cAAcrG,UAAUmE,EAAIC,EAE1C,IAAIwT,IAAa,EACbnB,EAAa,CAOjB,OANA7U,GAAS5B,UAAU,SAASmB,EAAGD,EAAGkV,GAChC,IAAMwB,KAAeA,EAAarB,EAAUzU,KAAKoU,EAAS/U,EAAGD,EAAGkV,IAE9D,MADAK,KACOtS,EAAGhD,EAAGkD,EAAUnD,EAAIuV,EAAa,EAAGd,KAGxCc,GAETwB,EAAarT,mBAAqB,SAAS3D,EAAMmD,GAAU,GAAIuR,GAAS3Y,IACtE,IAAIoH,EACF,MAAOpH,MAAKqJ,cAAcwP,WAAW5U,EAAMmD,EAE7C,IAAIb,GAAW3B,EAASiU,WAAWD,GAAiBxR,GAChD8T,GAAW,EACXzB,EAAa,CACjB,OAAO,IAAI3V,GAAS,WAClB,GAAIyG,GAAMrG,EAAGC,CACb,GAAG,CAED,GADAoG,EAAOhE,EAASxC,OACZwG,EAAKlG,KACP,MAAIgD,IAAWpD,IAAS6U,GACfvO,EACEtG,IAAS8U,GACX/U,EAAcC,EAAMwV,QAAc3W,GAAWyH,GAE7CvG,EAAcC,EAAMwV,IAAclP,EAAK9J,MAAM,GAAI8J,EAG5D,IAAI9C,GAAQ8C,EAAK9J,KACjByD,GAAIuD,EAAM,GACVtD,EAAIsD,EAAM,GACVyT,IAAaA,EAAW3B,EAAUzU,KAAKoU,EAAS/U,EAAGD,EAAGyU,UAC/CuC,EACT,OAAOjX,KAAS2U,GAAkBrO,EAChCvG,EAAcC,EAAMC,EAAGC,EAAGoG,MAGzB0Q,EAIT,QAASE,IAAcvW,EAAUgQ,GAC/B,GAAIwG,GAAkBva,EAAQ+D,GAC1BsM,GAAStM,GAAUpF,OAAOoV,GAAQxM,IAAI,SAASjE,GAQjD,MAPKzD,GAAWyD,GAILiX,IACTjX,EAAIvD,EAAcuD,IAJlBA,EAAIiX,EACF7V,EAAkBpB,GAClBuB,EAAoBnG,MAAMwH,QAAQ5C,GAAKA,GAAKA,IAIzCA,IACNyN,OAAO,SAASzN,GAAK,MAAkB,KAAXA,EAAEpB,MAEjC,IAAqB,IAAjBmO,EAAMzO,OACR,MAAOmC,EAGT,IAAqB,IAAjBsM,EAAMzO,OAAc,CACtB,GAAI4Y,GAAYnK,EAAM,EACtB,IAAImK,IAAczW,GACdwW,GAAmBva,EAAQwa,IAC3Bra,EAAU4D,IAAa5D,EAAUqa,GACnC,MAAOA,GAIX,GAAIC,GAAY,GAAI1V,GAASsL,EAkB7B,OAjBIkK,GACFE,EAAYA,EAAUjW,aACZrE,EAAU4D,KACpB0W,EAAYA,EAAU3V,YAExB2V,EAAYA,EAAUC,SAAQ,GAC9BD,EAAUvY,KAAOmO,EAAMsK,OACrB,SAASC,EAAK3U,GACZ,OAAYhE,KAAR2Y,EAAmB,CACrB,GAAI1Y,GAAO+D,EAAI/D,IACf,QAAaD,KAATC,EACF,MAAO0Y,GAAM1Y,IAInB,GAEKuY,EAIT,QAASI,IAAe9W,EAAU+W,EAAOtU,GACvC,GAAIuU,GAAerD,GAAa3T,EA0ChC,OAzCAgX,GAAalU,kBAAoB,SAASP,EAAIC,GAG5C,QAASyU,GAAShZ,EAAMiZ,GAAe,GAAInD,GAAS3Y,IAClD6C,GAAKG,UAAU,SAASmB,EAAGD,GAMzB,QALMyX,GAASG,EAAeH,IAAUjb,EAAWyD,GACjD0X,EAAS1X,EAAG2X,EAAe,IAC4B,IAA9C3U,EAAGhD,EAAGkD,EAAUnD,EAAIuV,IAAcd,KAC3CoD,GAAU,IAEJA,GACP3U,GAVL,GAAIqS,GAAa,EACbsC,GAAU,CAYd,OADAF,GAASjX,EAAU,GACZ6U,GAETmC,EAAahU,mBAAqB,SAAS3D,EAAMmD,GAC/C,GAAIb,GAAW3B,EAASiU,WAAW5U,EAAMmD,GACrC4U,KACAvC,EAAa,CACjB,OAAO,IAAI3V,GAAS,WAClB,KAAOyC,GAAU,CACf,GAAIgE,GAAOhE,EAASxC,MACpB,KAAkB,IAAdwG,EAAKlG,KAAT,CAIA,GAAIF,GAAIoG,EAAK9J,KAIb,IAHIwD,IAAS2U,KACXzU,EAAIA,EAAE,IAEFwX,KAASK,EAAMvZ,OAASkZ,KAAUjb,EAAWyD,GAIjD,MAAOkD,GAAUkD,EAAOvG,EAAcC,EAAMwV,IAActV,EAAGoG,EAH7DyR,GAAM7K,KAAK5K,GACXA,EAAWpC,EAAE0U,WAAW5U,EAAMmD,OAT9Bb,GAAWyV,EAAM7I,MAcrB,MAAO7O,QAGJsX,EAIT,QAASK,IAAerX,EAAUqU,EAAQC,GACxC,GAAIe,GAASC,GAActV,EAC3B,OAAOA,GAASO,QAAQiD,IACtB,SAASjE,EAAGD,GAAK,MAAO+V,GAAOhB,EAAOnU,KAAKoU,EAAS/U,EAAGD,EAAGU,MAC1D2W,SAAQ,GAIZ,QAASW,IAAiBtX,EAAUuX,GAClC,GAAIC,GAAqB7D,GAAa3T,EA2BtC,OA1BAwX,GAAmBrZ,KAAO6B,EAAS7B,MAAwB,EAAhB6B,EAAS7B,KAAU,EAC9DqZ,EAAmB1U,kBAAoB,SAASP,EAAIC,GAAU,GAAIuR,GAAS3Y,KACrEyZ,EAAa,CAMjB,OALA7U,GAAS5B,UAAU,SAASmB,EAAGD,GAC5B,QAASuV,IAAsD,IAAxCtS,EAAGgV,EAAW1C,IAAcd,MACpB,IAAhCxR,EAAGhD,EAAGsV,IAAcd,IACpBvR,GAEKqS,GAET2C,EAAmBxU,mBAAqB,SAAS3D,EAAMmD,GACrD,GAEImD,GAFAhE,EAAW3B,EAASiU,WAAWC,GAAgB1R,GAC/CqS,EAAa,CAEjB,OAAO,IAAI3V,GAAS,WAClB,QAAKyG,GAAQkP,EAAa,KACxBlP,EAAOhE,EAASxC,OACZwG,EAAKlG,MACAkG,EAGJkP,EAAa,EAClBzV,EAAcC,EAAMwV,IAAc0C,GAClCnY,EAAcC,EAAMwV,IAAclP,EAAK9J,MAAO8J,MAG7C6R,EAIT,QAASC,IAAYzX,EAAU0X,EAAYrD,GACpCqD,IACHA,EAAaC,GAEf,IAAInB,GAAkBva,EAAQ+D,GAC1BzB,EAAQ,EACR+F,EAAUtE,EAASO,QAAQiD,IAC7B,SAASjE,EAAGD,GAAK,OAAQA,EAAGC,EAAGhB,IAAS8V,EAASA,EAAO9U,EAAGD,EAAGU,GAAYT,KAC1EuP,SAMF,OALAxK,GAAQsT,KAAK,SAAS1T,EAAGC,GAAK,MAAOuT,GAAWxT,EAAE,GAAIC,EAAE,KAAOD,EAAE,GAAKC,EAAE,KAAKyE,QAC3E4N,EACA,SAASjX,EAAG0P,GAAM3K,EAAQ2K,GAAGpR,OAAS,GACtC,SAAS0B,EAAG0P,GAAM3K,EAAQ2K,GAAK1P,EAAE,KAE5BiX,EAAkBta,EAASoI,GAChClI,EAAU4D,GAAY3D,EAAWiI,GACjC9H,EAAO8H,GAIX,QAASuT,IAAW7X,EAAU0X,EAAYrD,GAIxC,GAHKqD,IACHA,EAAaC,IAEXtD,EAAQ,CACV,GAAIxR,GAAQ7C,EAASO,QAClBiD,IAAI,SAASjE,EAAGD,GAAK,OAAQC,EAAG8U,EAAO9U,EAAGD,EAAGU,MAC7C4W,OAAO,SAAS1S,EAAGC,GAAK,MAAO2T,IAAWJ,EAAYxT,EAAE,GAAIC,EAAE,IAAMA,EAAID,GAC3E,OAAOrB,IAASA,EAAM,GAEtB,MAAO7C,GAAS4W,OAAO,SAAS1S,EAAGC,GAAK,MAAO2T,IAAWJ,EAAYxT,EAAGC,GAAKA,EAAID,IAItF,QAAS4T,IAAWJ,EAAYxT,EAAGC,GACjC,GAAI4T,GAAOL,EAAWvT,EAAGD,EAGzB,OAAiB,KAAT6T,GAAc5T,IAAMD,QAAYhG,KAANiG,GAAyB,OAANA,GAAcA,IAAMA,IAAO4T,EAAO,EAIzF,QAASC,IAAeC,EAASC,EAAQ5L,GACvC,GAAI6L,GAAcxE,GAAasE,EAkD/B,OAjDAE,GAAYha,KAAO,GAAI6C,GAASsL,GAAO9I,IAAI,SAASyL,GAAK,MAAOA,GAAE9Q,OAAOc,MAGzEkZ,EAAY/Z,UAAY,SAASmE,EAAIC,GAiBnC,IAHA,GACImD,GADAhE,EAAWvG,KAAK6Y,WAAWC,GAAgB1R,GAE3CqS,EAAa,IACRlP,EAAOhE,EAASxC,QAAQM,OACY,IAAvC8C,EAAGoD,EAAK9J,MAAOgZ,IAAczZ,QAInC,MAAOyZ,IAETsD,EAAYnV,mBAAqB,SAAS3D,EAAMmD,GAC9C,GAAI4V,GAAY9L,EAAM9I,IAAI,SAASyL,GAChC,MAAQA,GAAIrT,EAASqT,GAAIlP,EAAYyC,EAAUyM,EAAEzM,UAAYyM,KAE5D4F,EAAa,EACbwD,GAAS,CACb,OAAO,IAAInZ,GAAS,WAClB,GAAIoZ,EAKJ,OAJKD,KACHC,EAAQF,EAAU5U,IAAI,SAASyL,GAAK,MAAOA,GAAE9P,SAC7CkZ,EAASC,EAAMC,KAAK,SAASC,GAAK,MAAOA,GAAE/Y,QAEzC4Y,EACK3Y,IAEFN,EACLC,EACAwV,IACAqD,EAAOjQ,MAAM,KAAMqQ,EAAM9U,IAAI,SAASgV,GAAK,MAAOA,GAAE3c,aAInDsc,EAMT,QAAS5C,IAAMtX,EAAMiE,GACnB,MAAOJ,GAAM7D,GAAQiE,EAAMjE,EAAKtC,YAAYuG,GAG9C,QAASuW,IAAc5V,GACrB,GAAIA,IAAUpH,OAAOoH,GACnB,KAAM,IAAIT,WAAU,0BAA4BS,GAIpD,QAAS6V,IAAYza,GAEnB,MADAsK,IAAkBtK,EAAKE,MAChBH,EAAWC,GAGpB,QAASqX,IAActV,GACrB,MAAO/D,GAAQ+D,GAAYhE,EACzBI,EAAU4D,GAAY7D,EACtBG,EAGJ,QAASqX,IAAa3T,GACpB,MAAOvE,QAAOC,QAEVO,EAAQ+D,GAAY9D,EACpBE,EAAU4D,GAAY3D,EACtBG,GACAhB,WAIN,QAASsY,MACP,MAAI1Y,MAAKgY,MAAM3O,aACbrJ,KAAKgY,MAAM3O,cACXrJ,KAAK+C,KAAO/C,KAAKgY,MAAMjV,KAChB/C,MAEAW,EAAIP,UAAUiJ,YAAYvE,KAAK9E,MAI1C,QAASuc,IAAkBzT,EAAGC,GAC5B,MAAOD,GAAIC,EAAI,EAAID,EAAIC,GAAK,EAAI,EAGlC,QAASwU,IAAcC,GACrB,GAAI3a,GAAO8B,EAAY6Y,EACvB,KAAK3a,EAAM,CAGT,IAAKoC,EAAYuY,GACf,KAAM,IAAIxW,WAAU,oCAAsCwW,EAE5D3a,GAAO8B,EAAYnE,EAASgd,IAE9B,MAAO3a,GAKP,QAAS4a,IAAOC,EAAeC,GAC7B,GAAIC,GAEAC,EAAa,SAAgBjJ,GAC/B,GAAIA,YAAkBiJ,GACpB,MAAOjJ,EAET,MAAM5U,eAAgB6d,IACpB,MAAO,IAAIA,GAAWjJ,EAExB,KAAKgJ,EAAgB,CACnBA,GAAiB,CACjB,IAAI3X,GAAO5F,OAAO4F,KAAKyX,EACvBI,IAASC,EAAqB9X,GAC9B8X,EAAoBhb,KAAOkD,EAAKxD,OAChCsb,EAAoBC,MAAQL,EAC5BI,EAAoB5X,MAAQF,EAC5B8X,EAAoBE,eAAiBP,EAEvC1d,KAAKuX,KAAOnK,GAAIwH,IAGdmJ,EAAsBF,EAAWzd,UAAYC,OAAOC,OAAO4d,GAG/D,OAFAH,GAAoBxd,YAAcsd,EAE3BA,EAwGX,QAASM,IAAWC,EAAYhW,EAAKwF,GACnC,GAAIyQ,GAAShe,OAAOC,OAAOD,OAAOie,eAAeF,GAGjD,OAFAC,GAAO9G,KAAOnP,EACdiW,EAAOpP,UAAYrB,EACZyQ,EAGT,QAASE,IAAWF,GAClB,MAAOA,GAAOL,OAASK,EAAO9d,YAAYod,MAAQ,SAGpD,QAASG,IAAS1d,EAAWoe,GAC3B,IACEA,EAAMhR,QAAQiR,GAAQC,SAAK5b,GAAW1C,IACtC,MAAO+J,KAKX,QAASsU,IAAQre,EAAWud,GAC1Btd,OAAOuM,eAAexM,EAAWud,GAC/BjU,IAAK,WACH,MAAO1J,MAAK0J,IAAIiU,IAElBjR,IAAK,SAASjM,GACZwJ,EAAUjK,KAAKiP,UAAW,sCAC1BjP,KAAK0M,IAAIiR,EAAMld,MASnB,QAASke,IAAIle,GACX,MAAiB,QAAVA,OAA4BqC,KAAVrC,EAAsBme,KAC7CC,GAAMpe,KAAWmB,EAAUnB,GAASA,EACpCme,KAAWrR,cAAc,SAASb,GAChC,GAAI7J,GAAO3B,EAAYT,EACvB0M,IAAkBtK,EAAKE,MACvBF,EAAK2K,QAAQ,SAASrJ,GAAK,MAAOuI,GAAIoS,IAAI3a,OA+HlD,QAAS0a,IAAME,GACb,SAAUA,IAAYA,EAASC,KAmBjC,QAASC,IAAUvS,EAAKiL,GACtB,MAAIjL,GAAIuC,WACNvC,EAAI3J,KAAO4U,EAAO5U,KAClB2J,EAAI6K,KAAOI,EACJjL,GAEFiL,IAAWjL,EAAI6K,KAAO7K,EACX,IAAhBiL,EAAO5U,KAAa2J,EAAIwS,UACxBxS,EAAIyS,OAAOxH,GAGf,QAASyH,IAAQhX,EAAKwF,GACpB,GAAIlB,GAAMrM,OAAOC,OAAO+e,GAIxB,OAHA3S,GAAI3J,KAAOqF,EAAMA,EAAIrF,KAAO,EAC5B2J,EAAI6K,KAAOnP,EACXsE,EAAIuC,UAAYrB,EACTlB,EAIT,QAASkS,MACP,MAAOU,MAAcA,GAAYF,GAAQ/R,OAOzC,QAASkS,IAAW9e,GAClB,MAAiB,QAAVA,OAA4BqC,KAAVrC,EAAsB+e,KAC7CC,GAAahf,GAASA,EACtB+e,KAAkBjS,cAAc,SAASb,GACvC,GAAI7J,GAAO3B,EAAYT,EACvB0M,IAAkBtK,EAAKE,MACvBF,EAAK2K,QAAQ,SAASrJ,GAAK,MAAOuI,GAAIoS,IAAI3a,OAiBlD,QAASsb,IAAaC,GACpB,MAAOb,IAAMa,IAAoB9d,EAAU8d,GAW7C,QAASC,IAAevX,EAAKwF,GAC3B,GAAIlB,GAAMrM,OAAOC,OAAOsf,GAIxB,OAHAlT,GAAI3J,KAAOqF,EAAMA,EAAIrF,KAAO,EAC5B2J,EAAI6K,KAAOnP,EACXsE,EAAIuC,UAAYrB,EACTlB,EAIT,QAAS8S,MACP,MAAOK,MAAsBA,GAAoBF,GAAezI,OAOhE,QAAS4I,IAAMrf,GACb,MAAiB,QAAVA,OAA4BqC,KAAVrC,EAAsBsf,KAC7CC,GAAQvf,GAASA,EACjBsf,KAAaE,WAAWxf,GAkL9B,QAASuf,IAAQE,GACf,SAAUA,IAAcA,EAAWC,KAerC,QAASC,IAAUrd,EAAMsd,EAAMzS,EAASxC,GACtC,GAAIhD,GAAM/H,OAAOC,OAAOggB,GAMxB,OALAlY,GAAIrF,KAAOA,EACXqF,EAAImY,MAAQF,EACZjY,EAAI6G,UAAYrB,EAChBxF,EAAIY,OAASoC,EACbhD,EAAI8G,WAAY,EACT9G,EAIT,QAAS2X,MACP,MAAOS,MAAgBA,GAAcJ,GAAU,IAMjD,QAASK,IAAMvgB,EAAMwgB,GACnB,GAAIC,GAAY,SAASzY,GAAQhI,EAAKE,UAAU8H,GAAOwY,EAAQxY,GAI/D,OAHA7H,QAAO4F,KAAKya,GAASlT,QAAQmT,GAC7BtgB,OAAOugB,uBACLvgB,OAAOugB,sBAAsBF,GAASlT,QAAQmT,GACzCzgB,EAioBT,QAAS2gB,IAAU1c,EAAGD,GACpB,MAAOA,GAGT,QAAS4c,IAAY3c,EAAGD,GACtB,OAAQA,EAAGC,GAGb,QAAS4c,IAAIxH,GACX,MAAO,YACL,OAAQA,EAAU1M,MAAM7M,KAAM8M,YAIlC,QAASkU,IAAIzH,GACX,MAAO,YACL,OAAQA,EAAU1M,MAAM7M,KAAM8M,YAIlC,QAASmU,IAAYxgB,GACnB,MAAwB,gBAAVA,GAAqBygB,KAAKC,UAAU1gB,GAASm9B,OAAOn9B,GAGpE,QAAS2gB,MACP,MAAOjf,GAAQ2K,WAGjB,QAASuU,IAAqBvY,EAAGC,GAC/B,MAAOD,GAAIC,EAAI,EAAID,EAAIC,GAAK,EAAI,EAGlC,QAASuY,IAAa1c,GACpB,GAAIA,EAAS7B,OAASgH,IACpB,MAAO,EAET,IAAIwX,GAAU3f,EAAUgD,GACpB4c,EAAQ3gB,EAAQ+D,GAChB0G,EAAIiW,EAAU,EAAI,CAUtB,OAAOE,IATI7c,EAAS5B,UAClBwe,EACED,EACE,SAASpd,EAAGD,GAAMoH,EAAI,GAAKA,EAAIoW,GAAUtW,GAAKjH,GAAIiH,GAAKlH,IAAM,GAC7D,SAASC,EAAGD,GAAMoH,EAAIA,EAAIoW,GAAUtW,GAAKjH,GAAIiH,GAAKlH,IAAM,GAC1Dqd,EACE,SAASpd,GAAMmH,EAAI,GAAKA,EAAIF,GAAKjH,GAAK,GACtC,SAASA,GAAMmH,EAAIA,EAAIF,GAAKjH,GAAK,IAETmH,GAGhC,QAASmW,IAAiB1e,EAAMuI,GAQ9B,MAPAA,GAAIqW,GAAKrW,EAAG,YACZA,EAAIqW,GAAKrW,GAAK,GAAKA,KAAO,GAAI,WAC9BA,EAAIqW,GAAKrW,GAAK,GAAKA,KAAO,GAAI,GAC9BA,GAAKA,EAAI,WAAa,GAAKvI,EAC3BuI,EAAIqW,GAAKrW,EAAIA,IAAM,GAAI,YACvBA,EAAIqW,GAAKrW,EAAIA,IAAM,GAAI,YACvBA,EAAIJ,GAAII,EAAIA,IAAM,IAIpB,QAASoW,IAAU5Y,EAAGC,GACpB,MAAOD,GAAIC,EAAI,YAAcD,GAAK,IAAMA,GAAK,GAAK,EA10JnB,GAAI8Y,IAAUriB,MAAMa,UAAU0V,KAc/D7V,GAAYW,EAAeJ,GAM3BP,EAAYc,EAAiBP,GAM7BP,EAAYiB,EAAaV,GA2BzBA,EAASE,WAAaA,EACtBF,EAASK,QAAUA,EACnBL,EAASQ,UAAYA,EACrBR,EAASW,cAAgBA,EACzBX,EAASoB,UAAYA,EAErBpB,EAASqhB,MAAQjhB,EACjBJ,EAASshB,QAAU/gB,EACnBP,EAASme,IAAMzd,CAGf,IAAII,IAAuB,6BACvBE,GAAoB,0BACpBE,GAAsB,4BACtBI,GAAsB,4BAMtBsO,GAAQ,EACRU,GAAO,GAAKV,GACZF,GAAOY,GAAO,EAIdnH,MAGA6F,IAAkB/O,OAAO,GACzBiP,IAAcjP,OAAO,GAiFrBsY,GAAe,EACfD,GAAiB,EACjBF,GAAkB,EAElB7T,GAAyC,kBAAXgd,SAAyBA,OAAOxb,SAC9DvB,GAAuB,aAEvBgd,GAAkBjd,IAAwBC,EAO5ClB,GAAS1D,UAAUwL,SAAW,WAC5B,MAAO,cAIX9H,EAASme,KAAOlJ,GAChBjV,EAASoe,OAASpJ,GAClBhV,EAASqe,QAAUvJ,GAEnB9U,EAAS1D,UAAUgiB,QACnBte,EAAS1D,UAAUiiB,SAAW,WAAc,MAAOriB,MAAK4L,YACxD9H,EAAS1D,UAAU4hB,IAAmB,WACpC,MAAOhiB,OA2CTC,EAAYU,EAAKH,GAMfG,EAAI2hB,GAAK,WACP,MAAO3hB,GAAImM,YAGbnM,EAAIP,UAAU+E,MAAQ,WACpB,MAAOnF,OAGTW,EAAIP,UAAUwL,SAAW,WACvB,MAAO5L,MAAKuiB,WAAW,QAAS,MAGlC5hB,EAAIP,UAAUiJ,YAAc,WAK1B,OAJKrJ,KAAKuH,QAAUvH,KAAK0H,oBACvB1H,KAAKuH,OAASvH,KAAKwF,WAAWkO,UAC9B1T,KAAK+C,KAAO/C,KAAKuH,OAAO9E,QAEnBzC,MAKTW,EAAIP,UAAU4C,UAAY,SAASmE,EAAIC,GACrC,MAAOF,GAAWlH,KAAMmH,EAAIC,GAAS,IAKvCzG,EAAIP,UAAUyY,WAAa,SAAS5U,EAAMmD,GACxC,MAAOO,GAAY3H,KAAMiE,EAAMmD,GAAS,IAK5CnH,EAAYa,EAAUH,GASpBG,EAASV,UAAUiF,WAAa,WAC9B,MAAOrF,OAKXC,EAAYgB,EAAYN,GAOtBM,EAAWqhB,GAAK,WACd,MAAOrhB,GAAW6L,YAGpB7L,EAAWb,UAAUqF,aAAe,WAClC,MAAOzF,OAGTiB,EAAWb,UAAUwL,SAAW,WAC9B,MAAO5L,MAAKuiB,WAAW,QAAS,MAGlCthB,EAAWb,UAAU4C,UAAY,SAASmE,EAAIC,GAC5C,MAAOF,GAAWlH,KAAMmH,EAAIC,GAAS,IAGvCnG,EAAWb,UAAUyY,WAAa,SAAS5U,EAAMmD,GAC/C,MAAOO,GAAY3H,KAAMiE,EAAMmD,GAAS,IAK5CnH,EAAYmB,EAAQT,GASlBS,EAAOkhB,GAAK,WACV,MAAOlhB,GAAO0L,YAGhB1L,EAAOhB,UAAUuF,SAAW,WAC1B,MAAO3F,OAKXW,EAAI+F,MAAQA,EACZ/F,EAAIkhB,MAAQ/gB,EACZH,EAAIge,IAAMvd,EACVT,EAAImhB,QAAU7gB,CAEd,IAAI2F,IAAkB,uBAEtBjG,GAAIP,UAAUwG,KAAmB,EAIjC3G,EAAY2F,EAAU3E,GAMpB2E,EAASxF,UAAUsJ,IAAM,SAASvG,EAAO8O,GACvC,MAAOjS,MAAKyJ,IAAItG,GAASnD,KAAK8F,OAAO5C,EAAUlD,KAAMmD,IAAU8O,GAGjErM,EAASxF,UAAU4C,UAAY,SAASmE,EAAIC,GAG1C,IAAK,GAFDvB,GAAQ7F,KAAK8F,OACb0B,EAAW3B,EAAMpD,OAAS,EACrBE,EAAK,EAAGA,GAAM6E,EAAU7E,IAC/B,IAA0D,IAAtDwE,EAAGtB,EAAMuB,EAAUI,EAAW7E,EAAKA,GAAKA,EAAI3C,MAC9C,MAAO2C,GAAK,CAGhB,OAAOA,IAGTiD,EAASxF,UAAUyY,WAAa,SAAS5U,EAAMmD,GAC7C,GAAIvB,GAAQ7F,KAAK8F,OACb0B,EAAW3B,EAAMpD,OAAS,EAC1BE,EAAK,CACT,OAAO,IAAImB,GAAS,WACjB,MAAOnB,GAAK6E,EACXlD,IACAN,EAAcC,EAAMtB,EAAIkD,EAAMuB,EAAUI,EAAW7E,IAAOA,SAMlE1C,EAAY8F,EAAWjF,GAQrBiF,EAAU3F,UAAUsJ,IAAM,SAASxB,EAAK+J,GACtC,WAAoBnP,KAAhBmP,GAA8BjS,KAAKyJ,IAAIvB,GAGpClI,KAAKkG,QAAQgC,GAFX+J,GAKXlM,EAAU3F,UAAUqJ,IAAM,SAASvB,GACjC,MAAOlI,MAAKkG,QAAQsc,eAAeta,IAGrCnC,EAAU3F,UAAU4C,UAAY,SAASmE,EAAIC,GAI3C,IAAK,GAHDpB,GAAShG,KAAKkG,QACdD,EAAOjG,KAAKmG,MACZqB,EAAWvB,EAAKxD,OAAS,EACpBE,EAAK,EAAGA,GAAM6E,EAAU7E,IAAM,CACrC,GAAIuF,GAAMjC,EAAKmB,EAAUI,EAAW7E,EAAKA,EACzC,KAAmC,IAA/BwE,EAAGnB,EAAOkC,GAAMA,EAAKlI,MACvB,MAAO2C,GAAK,EAGhB,MAAOA,IAGToD,EAAU3F,UAAUyY,WAAa,SAAS5U,EAAMmD,GAC9C,GAAIpB,GAAShG,KAAKkG,QACdD,EAAOjG,KAAKmG,MACZqB,EAAWvB,EAAKxD,OAAS,EACzBE,EAAK,CACT,OAAO,IAAImB,GAAS,WAClB,GAAIoE,GAAMjC,EAAKmB,EAAUI,EAAW7E,EAAKA,EACzC,OAAOA,KAAO6E,EACZlD,IACAN,EAAcC,EAAMiE,EAAKlC,EAAOkC,OAIxCnC,EAAU3F,UAAU0B,KAAuB,EAG3C7B,EAAYmG,EAAanF,GAMvBmF,EAAYhG,UAAUsH,kBAAoB,SAASP,EAAIC,GACrD,GAAIA,EACF,MAAOpH,MAAKqJ,cAAcrG,UAAUmE,EAAIC,EAE1C,IAAIxC,GAAW5E,KAAKqG,UAChBE,EAAW5B,EAAYC,GACvB6U,EAAa,CACjB,IAAIhV,EAAW8B,GAEb,IADA,GAAIgE,KACKA,EAAOhE,EAASxC,QAAQM,OACY,IAAvC8C,EAAGoD,EAAK9J,MAAOgZ,IAAczZ,QAKrC,MAAOyZ,IAGTrT,EAAYhG,UAAUwH,mBAAqB,SAAS3D,EAAMmD,GACxD,GAAIA,EACF,MAAOpH,MAAKqJ,cAAcwP,WAAW5U,EAAMmD,EAE7C,IAAIxC,GAAW5E,KAAKqG,UAChBE,EAAW5B,EAAYC,EAC3B,KAAKH,EAAW8B,GACd,MAAO,IAAIzC,GAASQ,EAEtB,IAAImV,GAAa,CACjB,OAAO,IAAI3V,GAAS,WAClB,GAAIyG,GAAOhE,EAASxC,MACpB,OAAOwG,GAAKlG,KAAOkG,EAAOvG,EAAcC,EAAMwV,IAAclP,EAAK9J,UAMvER,EAAYqG,EAAarF,GAMvBqF,EAAYlG,UAAUsH,kBAAoB,SAASP,EAAIC,GACrD,GAAIA,EACF,MAAOpH,MAAKqJ,cAAcrG,UAAUmE,EAAIC,EAK1C,KAHA,GAAIb,GAAWvG,KAAKwG,UAChBc,EAAQtH,KAAKyG,eACbgT,EAAa,EACVA,EAAanS,EAAM7E,QACxB,IAAkD,IAA9C0E,EAAGG,EAAMmS,GAAaA,IAAczZ,MACtC,MAAOyZ,EAIX,KADA,GAAIlP,KACKA,EAAOhE,EAASxC,QAAQM,MAAM,CACrC,GAAIuO,GAAMrI,EAAK9J,KAEf,IADA6G,EAAMmS,GAAc7G,GACgB,IAAhCzL,EAAGyL,EAAK6G,IAAczZ,MACxB,MAGJ,MAAOyZ,IAGTnT,EAAYlG,UAAUwH,mBAAqB,SAAS3D,EAAMmD,GACxD,GAAIA,EACF,MAAOpH,MAAKqJ,cAAcwP,WAAW5U,EAAMmD,EAE7C,IAAIb,GAAWvG,KAAKwG,UAChBc,EAAQtH,KAAKyG,eACbgT,EAAa,CACjB,OAAO,IAAI3V,GAAS,WAClB,GAAI2V,GAAcnS,EAAM7E,OAAQ,CAC9B,GAAI8H,GAAOhE,EAASxC,MACpB,IAAIwG,EAAKlG,KACP,MAAOkG,EAETjD,GAAMmS,GAAclP,EAAK9J,MAE3B,MAAOuD,GAAcC,EAAMwV,EAAYnS,EAAMmS,QAanD,IAAI5S,GAyPJ5G,GAAY2J,EAAQ3I,GAgBlB2I,EAAOxJ,UAAUwL,SAAW,WAC1B,MAAkB,KAAd5L,KAAK+C,KACA,YAEF,YAAc/C,KAAK8J,OAAS,IAAM9J,KAAK+C,KAAO,YAGvD6G,EAAOxJ,UAAUsJ,IAAM,SAASvG,EAAO8O,GACrC,MAAOjS,MAAKyJ,IAAItG,GAASnD,KAAK8J,OAASmI,GAGzCrI,EAAOxJ,UAAUqY,SAAW,SAASgK,GACnC,MAAOja,GAAGxI,KAAK8J,OAAQ2Y,IAGzB7Y,EAAOxJ,UAAU0V,MAAQ,SAASvS,EAAOC,GACvC,GAAIT,GAAO/C,KAAK+C,IAChB,OAAOO,GAAWC,EAAOC,EAAKT,GAAQ/C,KACpC,GAAI4J,GAAO5J,KAAK8J,OAAQnG,EAAWH,EAAKT,GAAQU,EAAaF,EAAOR,KAGxE6G,EAAOxJ,UAAUgH,QAAU,WACzB,MAAOpH,OAGT4J,EAAOxJ,UAAUsiB,QAAU,SAASD,GAClC,MAAIja,GAAGxI,KAAK8J,OAAQ2Y,GACX,GAED,GAGV7Y,EAAOxJ,UAAUuiB,YAAc,SAASF,GACtC,MAAIja,GAAGxI,KAAK8J,OAAQ2Y,GACXziB,KAAK+C,MAEN,GAGV6G,EAAOxJ,UAAU4C,UAAY,SAASmE,EAAIC,GACxC,IAAK,GAAIzE,GAAK,EAAGA,EAAK3C,KAAK+C,KAAMJ,IAC/B,IAAkC,IAA9BwE,EAAGnH,KAAK8J,OAAQnH,EAAI3C,MACtB,MAAO2C,GAAK,CAGhB,OAAOA,IAGTiH,EAAOxJ,UAAUyY,WAAa,SAAS5U,EAAMmD,GAAU,GAAIuR,GAAS3Y,KAC9D2C,EAAK,CACT,OAAO,IAAImB,GAAS,WACjB,MAAOnB,GAAKgW,EAAO5V,KAAOiB,EAAcC,EAAMtB,IAAMgW,EAAO7O,QAAUxF,OAI1EsF,EAAOxJ,UAAUwI,OAAS,SAASga,GACjC,MAAOA,aAAiBhZ,GACtBpB,EAAGxI,KAAK8J,OAAQ8Y,EAAM9Y,QACtBjB,EAAU+Z,GAIhB,IAAI5Y,GAMJ/J,GAAYoK,EAAOpJ,GA2BjBoJ,EAAMjK,UAAUwL,SAAW,WACzB,MAAkB,KAAd5L,KAAK+C,KACA,WAEF,WACL/C,KAAKyK,OAAS,MAAQzK,KAAK0K,MACX,IAAf1K,KAAK2K,MAAc,OAAS3K,KAAK2K,MAAQ,IAC5C,MAGFN,EAAMjK,UAAUsJ,IAAM,SAASvG,EAAO8O,GACpC,MAAOjS,MAAKyJ,IAAItG,GACdnD,KAAKyK,OAASvH,EAAUlD,KAAMmD,GAASnD,KAAK2K,MAC5CsH,GAGJ5H,EAAMjK,UAAUqY,SAAW,SAASgK,GAClC,GAAII,IAAiBJ,EAAcziB,KAAKyK,QAAUzK,KAAK2K,KACvD,OAAOkY,IAAiB,GACtBA,EAAgB7iB,KAAK+C,MACrB8f,IAAkBtgB,KAAKugB,MAAMD,IAGjCxY,EAAMjK,UAAU0V,MAAQ,SAASvS,EAAOC,GACtC,MAAIF,GAAWC,EAAOC,EAAKxD,KAAK+C,MACvB/C,MAETuD,EAAQE,EAAaF,EAAOvD,KAAK+C,MACjCS,EAAMG,EAAWH,EAAKxD,KAAK+C,MACvBS,GAAOD,EACF,GAAI8G,GAAM,EAAG,GAEf,GAAIA,GAAMrK,KAAK0J,IAAInG,EAAOvD,KAAK0K,MAAO1K,KAAK0J,IAAIlG,EAAKxD,KAAK0K,MAAO1K,KAAK2K,SAG9EN,EAAMjK,UAAUsiB,QAAU,SAASD,GACjC,GAAIM,GAAcN,EAAcziB,KAAKyK,MACrC,IAAIsY,EAAc/iB,KAAK2K,OAAU,EAAG,CAClC,GAAIxH,GAAQ4f,EAAc/iB,KAAK2K,KAC/B,IAAIxH,GAAS,GAAKA,EAAQnD,KAAK+C,KAC7B,MAAOI,GAGX,OAAQ,GAGVkH,EAAMjK,UAAUuiB,YAAc,SAASF,GACrC,MAAOziB,MAAK0iB,QAAQD,IAGtBpY,EAAMjK,UAAU4C,UAAY,SAASmE,EAAIC,GAIvC,IAAK,GAHDI,GAAWxH,KAAK+C,KAAO,EACvBwH,EAAOvK,KAAK2K,MACZlK,EAAQ2G,EAAUpH,KAAKyK,OAASjD,EAAW+C,EAAOvK,KAAKyK,OAClD9H,EAAK,EAAGA,GAAM6E,EAAU7E,IAAM,CACrC,IAA4B,IAAxBwE,EAAG1G,EAAOkC,EAAI3C,MAChB,MAAO2C,GAAK,CAEdlC,IAAS2G,GAAWmD,EAAOA,EAE7B,MAAO5H,IAGT0H,EAAMjK,UAAUyY,WAAa,SAAS5U,EAAMmD,GAC1C,GAAII,GAAWxH,KAAK+C,KAAO,EACvBwH,EAAOvK,KAAK2K,MACZlK,EAAQ2G,EAAUpH,KAAKyK,OAASjD,EAAW+C,EAAOvK,KAAKyK,OACvD9H,EAAK,CACT,OAAO,IAAImB,GAAS,WAClB,GAAIK,GAAI1D,CAER,OADAA,IAAS2G,GAAWmD,EAAOA,EACpB5H,EAAK6E,EAAWlD,IAAiBN,EAAcC,EAAMtB,IAAMwB,MAItEkG,EAAMjK,UAAUwI,OAAS,SAASga,GAChC,MAAOA,aAAiBvY,GACtBrK,KAAKyK,SAAWmY,EAAMnY,QACtBzK,KAAK0K,OAASkY,EAAMlY,MACpB1K,KAAK2K,QAAUiY,EAAMjY,MACrB9B,EAAU7I,KAAM4iB,GAItB,IAAI/X,GAEJ5K,GAAY6K,GAAYtK,GAMxBP,EAAY8K,GAAiBD,IAE7B7K,EAAY+K,GAAmBF,IAE/B7K,EAAYgL,GAAeH,IAG3BA,GAAW+W,MAAQ9W,GACnBD,GAAWgX,QAAU9W,GACrBF,GAAW6T,IAAM1T,EAEjB,IAyLImB,IAzLAuV,GACmB,kBAAdpf,MAAKof,OAAqD,IAA9Bpf,KAAKof,KAAK,WAAY,GACzDpf,KAAKof,KACL,SAAc7Y,EAAGC,GACfD,GAAQ,EACRC,GAAQ,CACR,IAAIqQ,GAAQ,MAAJtQ,EACJka,EAAQ,MAAJja,CAER,OAAQqQ,GAAI4J,IAASla,IAAM,IAAMka,EAAI5J,GAAKrQ,IAAM,KAAQ,KAAQ,GAAK,GAqJrE4D,GAAetM,OAAOsM,aAGtBL,GAAqB,WACvB,IAEE,MADAjM,QAAOuM,kBAAmB,SACnB,EACP,MAAOqW,GACP,OAAO,MAkBP9W,GAAkC,kBAAZ+W,QAEtB/W,MACFC,GAAU,GAAI8W,SAGhB,IAAIzW,IAAa,EAEbJ,GAAe,mBACG,mBAAX0V,UACT1V,GAAe0V,OAAO1V,IAGxB,IAAId,IAA+B,GAC/BS,GAA6B,IAC7BD,GAAyB,EACzBD,KASJ7L,GAAYmN,GAAKrC,IAcfqC,GAAIkV,GAAK,WAAY,GAAIujC,GAAYjkC,GAAQ9c,KAAKgI,UAAW,EAC3D,OAAOO,MAAWE,cAAc,SAASnF,GACvC,IAAK,GAAIyL,GAAI,EAAGA,EAAIgyC,EAAUpjD,OAAQoR,GAAK,EAAG,CAC5C,GAAIA,EAAI,GAAKgyC,EAAUpjD,OACrB,KAAM,IAAI2H,OAAM,0BAA4By7C,EAAUhyC,GAExDzL,GAAIsE,IAAIm5C,EAAUhyC,GAAIgyC,EAAUhyC,EAAI,QAK1CzG,GAAIhN,UAAUwL,SAAW,WACvB,MAAO5L,MAAKuiB,WAAW,QAAS,MAKlCnV,GAAIhN,UAAUsJ,IAAM,SAASxF,EAAG+N,GAC9B,MAAOjS,MAAKyO,MACVzO,KAAKyO,MAAM/E,IAAI,MAAG5G,GAAWoB,EAAG+N,GAChCA,GAKJ7E,GAAIhN,UAAUsM,IAAM,SAASxI,EAAGC,GAC9B,MAAOiL,IAAUpP,KAAMkE,EAAGC,IAG5BiJ,GAAIhN,UAAUsS,MAAQ,SAAS8K,EAASrZ,GACtC,MAAOnE,MAAKmjB,SAAS3F,EAAS7T,GAAS,WAAa,MAAOxF,MAG7DiJ,GAAIhN,UAAUoS,OAAS,SAAStO,GAC9B,MAAOkL,IAAUpP,KAAMkE,EAAGyF,KAG5ByD,GAAIhN,UAAUgjB,SAAW,SAAS5F,GAChC,MAAOxd,MAAKmjB,SAAS3F,EAAS,WAAa,MAAO7T,OAGpDyD,GAAIhN,UAAUyP,OAAS,SAAS3L,EAAG+N,EAAaC,GAC9C,MAA4B,KAArBpF,UAAUrK,OACfyB,EAAElE,MACFA,KAAKmjB,UAAUjf,GAAI+N,EAAaC,IAGpC9E,GAAIhN,UAAU+iB,SAAW,SAAS3F,EAASvL,EAAaC,GACjDA,IACHA,EAAUD,EACVA,MAAcnP,GAEhB,IAAIugB,GAAetR,GACjB/R,KACAud,GAAcC,GACdvL,EACAC,EAEF,OAAOmR,KAAiB1Z,OAAU7G,GAAYugB,GAGhDjW,GAAIhN,UAAUkW,MAAQ,WACpB,MAAkB,KAAdtW,KAAK+C,KACA/C,KAELA,KAAKiP,WACPjP,KAAK+C,KAAO,EACZ/C,KAAKyO,MAAQ,KACbzO,KAAKgJ,WAASlG,GACd9C,KAAKkP,WAAY,EACVlP,MAEFqN,MAKTD,GAAIhN,UAAUkjB,MAAQ,WACpB,MAAOvS,IAAiB/Q,SAAM8C,GAAWgK,YAG3CM,GAAIhN,UAAUmjB,UAAY,SAASvS,GACjC,MAAOD,IAAiB/Q,KAAMgR,EADwB4Q,GAAQ9c,KAAKgI,UAAW,KAIhFM,GAAIhN,UAAUojB,QAAU,SAAShG,GAAU,GAAItM,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EAC7E,OAAO9M,MAAKmjB,SACV3F,EACAnQ,KACA,SAASoW,GAAK,MAA0B,kBAAZA,GAAEH,MAC5BG,EAAEH,MAAMzW,MAAM4W,EAAGvS,GACjBA,EAAMA,EAAMzO,OAAS,MAI3B2K,GAAIhN,UAAUmR,UAAY,WACxB,MAAOR,IAAiB/Q,KAAMqR,GAAYvE,YAG5CM,GAAIhN,UAAUqR,cAAgB,SAAST,GAAS,GAAIE,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EAClF,OAAOiE,IAAiB/Q,KAAMwR,GAAeR,GAASE,IAGxD9D,GAAIhN,UAAUsjB,YAAc,SAASlG,GAAU,GAAItM,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EACjF,OAAO9M,MAAKmjB,SACV3F,EACAnQ,KACA,SAASoW,GAAK,MAA8B,kBAAhBA,GAAElS,UAC5BkS,EAAElS,UAAU1E,MAAM4W,EAAGvS,GACrBA,EAAMA,EAAMzO,OAAS,MAI3B2K,GAAIhN,UAAUoc,KAAO,SAASF,GAE5B,MAAOrF,IAAWoF,GAAYrc,KAAMsc,KAGtClP,GAAIhN,UAAUujB,OAAS,SAAS1K,EAAQqD,GAEtC,MAAOrF,IAAWoF,GAAYrc,KAAMsc,EAAYrD,KAKlD7L,GAAIhN,UAAUmN,cAAgB,SAASpG,GACrC,GAAIyc,GAAU5jB,KAAK6Z,WAEnB,OADA1S,GAAGyc,GACIA,EAAQC,aAAeD,EAAQE,cAAc9jB,KAAKiP,WAAajP,MAGxEoN,GAAIhN,UAAUyZ,UAAY,WACxB,MAAO7Z,MAAKiP,UAAYjP,KAAOA,KAAK8jB,cAAc,GAAI5hB,KAGxDkL,GAAIhN,UAAU0Z,YAAc,WAC1B,MAAO9Z,MAAK8jB,iBAGd1W,GAAIhN,UAAUyjB,WAAa,WACzB,MAAO7jB,MAAKkP,WAGd9B,GAAIhN,UAAUyY,WAAa,SAAS5U,EAAMmD,GACxC,MAAO,IAAIiH,IAAYrO,KAAMiE,EAAMmD,IAGrCgG,GAAIhN,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GAAIuR,GAAS3Y,KACxDyZ,EAAa,CAKjB,OAJAzZ,MAAKyO,OAASzO,KAAKyO,MAAMsV,QAAQ,SAAStc,GAExC,MADAgS,KACOtS,EAAGM,EAAM,GAAIA,EAAM,GAAIkR,IAC7BvR,GACIqS,GAGTrM,GAAIhN,UAAU0jB,cAAgB,SAASlW,GACrC,MAAIA,KAAY5N,KAAKiP,UACZjP,KAEJ4N,EAKEkB,GAAQ9O,KAAK+C,KAAM/C,KAAKyO,MAAOb,EAAS5N,KAAKgJ,SAJlDhJ,KAAKiP,UAAYrB,EACjB5N,KAAKkP,WAAY,EACVlP,OAUboN,GAAIE,MAAQA,EAEZ,IAAII,IAAkB,wBAElBsB,GAAe5B,GAAIhN,SACvB4O,IAAatB,KAAmB,EAChCsB,GAAmB,OAAIA,GAAawD,OACpCxD,GAAagV,SAAWhV,GAAaoU,SAYnCzV,GAAavN,UAAUsJ,IAAM,SAASkG,EAAOzB,EAASjG,EAAK+J,GAEzD,IAAK,GADD/I,GAAUlJ,KAAKkJ,QACVvG,EAAK,EAAGL,EAAM4G,EAAQzG,OAAQE,EAAKL,EAAKK,IAC/C,GAAI6F,EAAGN,EAAKgB,EAAQvG,GAAI,IACtB,MAAOuG,GAAQvG,GAAI,EAGvB,OAAOsP,IAGTtE,GAAavN,UAAUyP,OAAS,SAASjC,EAASgC,EAAOzB,EAASjG,EAAKzH,EAAO8O,EAAeE,GAK3F,IAAK,GAJDwU,GAAUxjB,IAAUkJ,GAEpBT,EAAUlJ,KAAKkJ,QACfyJ,EAAM,EACDrQ,EAAM4G,EAAQzG,OAAQkQ,EAAMrQ,IAC/BkG,EAAGN,EAAKgB,EAAQyJ,GAAK,IADeA,KAK1C,GAAIuR,GAASvR,EAAMrQ,CAEnB,IAAI4hB,EAAShb,EAAQyJ,GAAK,KAAOlS,EAAQwjB,EACvC,MAAOjkB,KAMT,IAHAiC,EAAOwN,IACNwU,IAAYC,IAAWjiB,EAAOsN,IAE3B0U,GAA8B,IAAnB/a,EAAQzG,OAAvB,CAIA,IAAKyhB,IAAWD,GAAW/a,EAAQzG,QAAU0hB,GAC3C,MAAO9T,IAAYzC,EAAS1E,EAAShB,EAAKzH,EAG5C,IAAI2jB,GAAaxW,GAAWA,IAAY5N,KAAK4N,QACzCyW,EAAaD,EAAalb,EAAU/G,EAAQ+G,EAYhD,OAVIgb,GACED,EACFtR,IAAQrQ,EAAM,EAAI+hB,EAAWlR,MAASkR,EAAW1R,GAAO0R,EAAWlR,MAEnEkR,EAAW1R,IAAQzK,EAAKzH,GAG1B4jB,EAAWlT,MAAMjJ,EAAKzH,IAGpB2jB,GACFpkB,KAAKkJ,QAAUmb,EACRrkB,MAGF,GAAI2N,IAAaC,EAASyW,KAYnCxW,GAAkBzN,UAAUsJ,IAAM,SAASkG,EAAOzB,EAASjG,EAAK+J,OAC9CnP,KAAZqL,IACFA,EAAU/C,GAAKlD,GAEjB,IAAIwI,GAAO,KAAiB,IAAVd,EAAczB,EAAUA,IAAYyB,GAASM,IAC3DpC,EAAS9N,KAAK8N,MAClB,OAA0B,KAAlBA,EAAS4C,GAAauB,EAC5BjS,KAAK+N,MAAM0E,GAAS3E,EAAU4C,EAAM,IAAKhH,IAAIkG,EAAQQ,GAAOjC,EAASjG,EAAK+J,IAG9EpE,GAAkBzN,UAAUyP,OAAS,SAASjC,EAASgC,EAAOzB,EAASjG,EAAKzH,EAAO8O,EAAeE,OAChF3M,KAAZqL,IACFA,EAAU/C,GAAKlD,GAEjB,IAAIoc,IAAyB,IAAV1U,EAAczB,EAAUA,IAAYyB,GAASM,GAC5DQ,EAAM,GAAK4T,EACXxW,EAAS9N,KAAK8N,OACdoW,EAA4B,IAAlBpW,EAAS4C,EAEvB,KAAKwT,GAAUzjB,IAAUkJ,GACvB,MAAO3J,KAGT,IAAI2S,GAAMF,GAAS3E,EAAU4C,EAAM,GAC/B3C,EAAQ/N,KAAK+N,MACbf,EAAOkX,EAASnW,EAAM4E,OAAO7P,GAC7BkN,EAAUL,GAAW3C,EAAMY,EAASgC,EAAQQ,GAAOjC,EAASjG,EAAKzH,EAAO8O,EAAeE,EAE3F,IAAIO,IAAYhD,EACd,MAAOhN,KAGT,KAAKkkB,GAAUlU,GAAWjC,EAAMtL,QAAU8hB,GACxC,MAAO5T,IAAY/C,EAASG,EAAOD,EAAQwW,EAAatU,EAG1D,IAAIkU,IAAWlU,GAA4B,IAAjBjC,EAAMtL,QAAgBqN,GAAW/B,EAAY,EAAN4E,IAC/D,MAAO5E,GAAY,EAAN4E,EAGf,IAAIuR,GAAUlU,GAA4B,IAAjBjC,EAAMtL,QAAgBqN,GAAWE,GACxD,MAAOA,EAGT,IAAIoU,GAAaxW,GAAWA,IAAY5N,KAAK4N,QACzC4W,EAAYN,EAASlU,EAAUlC,EAASA,EAAS4C,EAAM5C,EAAS4C,EAChE+T,EAAWP,EAASlU,EACtB0C,GAAM3E,EAAO4E,EAAK3C,EAASoU,GAC3BlR,GAAUnF,EAAO4E,EAAKyR,GACtBrR,GAAShF,EAAO4E,EAAK3C,EAASoU,EAEhC,OAAIA,IACFpkB,KAAK8N,OAAS0W,EACdxkB,KAAK+N,MAAQ0W,EACNzkB,MAGF,GAAI6N,IAAkBD,EAAS4W,EAAWC,IAYnDzW,GAAiB5N,UAAUsJ,IAAM,SAASkG,EAAOzB,EAASjG,EAAK+J,OAC7CnP,KAAZqL,IACFA,EAAU/C,GAAKlD,GAEjB,IAAIyK,IAAiB,IAAV/C,EAAczB,EAAUA,IAAYyB,GAASM,GACpDlD,EAAOhN,KAAK+N,MAAM4E,EACtB,OAAO3F,GAAOA,EAAKtD,IAAIkG,EAAQQ,GAAOjC,EAASjG,EAAK+J,GAAeA,GAGrEjE,GAAiB5N,UAAUyP,OAAS,SAASjC,EAASgC,EAAOzB,EAASjG,EAAKzH,EAAO8O,EAAeE,OAC/E3M,KAAZqL,IACFA,EAAU/C,GAAKlD,GAEjB,IAAIyK,IAAiB,IAAV/C,EAAczB,EAAUA,IAAYyB,GAASM,GACpD+T,EAAUxjB,IAAUkJ,GACpBoE,EAAQ/N,KAAK+N,MACbf,EAAOe,EAAM4E,EAEjB,IAAIsR,IAAYjX,EACd,MAAOhN,KAGT,IAAIgQ,GAAUL,GAAW3C,EAAMY,EAASgC,EAAQQ,GAAOjC,EAASjG,EAAKzH,EAAO8O,EAAeE,EAC3F,IAAIO,IAAYhD,EACd,MAAOhN,KAGT,IAAI0kB,GAAW1kB,KAAKiO,KACpB,IAAKjB,GAEE,IAAKgD,KACV0U,EACeC,GACb,MAAOrU,IAAU1C,EAASG,EAAO2W,EAAU/R,OAJ7C+R,IAQF,IAAIN,GAAaxW,GAAWA,IAAY5N,KAAK4N,QACzC6W,EAAW/R,GAAM3E,EAAO4E,EAAK3C,EAASoU,EAE1C,OAAIA,IACFpkB,KAAKiO,MAAQyW,EACb1kB,KAAK+N,MAAQ0W,EACNzkB,MAGF,GAAIgO,IAAiBJ,EAAS8W,EAAUD,IAYjDvW,GAAkB9N,UAAUsJ,IAAM,SAASkG,EAAOzB,EAASjG,EAAK+J,GAE9D,IAAK,GADD/I,GAAUlJ,KAAKkJ,QACVvG,EAAK,EAAGL,EAAM4G,EAAQzG,OAAQE,EAAKL,EAAKK,IAC/C,GAAI6F,EAAGN,EAAKgB,EAAQvG,GAAI,IACtB,MAAOuG,GAAQvG,GAAI,EAGvB,OAAOsP,IAGT/D,GAAkB9N,UAAUyP,OAAS,SAASjC,EAASgC,EAAOzB,EAASjG,EAAKzH,EAAO8O,EAAeE,OAChF3M,KAAZqL,IACFA,EAAU/C,GAAKlD,GAGjB,IAAI+b,GAAUxjB,IAAUkJ,EAExB,IAAIwE,IAAYnO,KAAKmO,QACnB,MAAI8V,GACKjkB,MAETiC,EAAOwN,GACPxN,EAAOsN,GACAQ,GAAc/P,KAAM4N,EAASgC,EAAOzB,GAAUjG,EAAKzH,IAK5D,KAAK,GAFDyI,GAAUlJ,KAAKkJ,QACfyJ,EAAM,EACDrQ,EAAM4G,EAAQzG,OAAQkQ,EAAMrQ,IAC/BkG,EAAGN,EAAKgB,EAAQyJ,GAAK,IADeA,KAK1C,GAAIuR,GAASvR,EAAMrQ,CAEnB,IAAI4hB,EAAShb,EAAQyJ,GAAK,KAAOlS,EAAQwjB,EACvC,MAAOjkB,KAMT,IAHAiC,EAAOwN,IACNwU,IAAYC,IAAWjiB,EAAOsN,GAE3B0U,GAAmB,IAAR3hB,EACb,MAAO,IAAI8L,IAAUR,EAAS5N,KAAKmO,QAASjF,EAAc,EAANyJ,GAGtD,IAAIyR,GAAaxW,GAAWA,IAAY5N,KAAK4N,QACzCyW,EAAaD,EAAalb,EAAU/G,EAAQ+G,EAYhD,OAVIgb,GACED,EACFtR,IAAQrQ,EAAM,EAAI+hB,EAAWlR,MAASkR,EAAW1R,GAAO0R,EAAWlR,MAEnEkR,EAAW1R,IAAQzK,EAAKzH,GAG1B4jB,EAAWlT,MAAMjJ,EAAKzH,IAGpB2jB,GACFpkB,KAAKkJ,QAAUmb,EACRrkB,MAGF,GAAIkO,IAAkBN,EAAS5N,KAAKmO,QAASkW,IAYtDjW,GAAUhO,UAAUsJ,IAAM,SAASkG,EAAOzB,EAASjG,EAAK+J,GACtD,MAAOzJ,GAAGN,EAAKlI,KAAKyH,MAAM,IAAMzH,KAAKyH,MAAM,GAAKwK,GAGlD7D,GAAUhO,UAAUyP,OAAS,SAASjC,EAASgC,EAAOzB,EAASjG,EAAKzH,EAAO8O,EAAeE,GACxF,GAAIwU,GAAUxjB,IAAUkJ,GACpBib,EAAWpc,EAAGN,EAAKlI,KAAKyH,MAAM,GAClC,QAAImd,EAAWnkB,IAAUT,KAAKyH,MAAM,GAAKwc,GAChCjkB,MAGTiC,EAAOwN,GAEHwU,MACFhiB,GAAOsN,GAILqV,EACEhX,GAAWA,IAAY5N,KAAK4N,SAC9B5N,KAAKyH,MAAM,GAAKhH,EACTT,MAEF,GAAIoO,IAAUR,EAAS5N,KAAKmO,SAAUjG,EAAKzH,KAGpDwB,EAAOsN,GACAQ,GAAc/P,KAAM4N,EAASgC,EAAOxE,GAAKlD,IAAOA,EAAKzH,OAOhEkN,GAAavN,UAAU2jB,QACvB7V,GAAkB9N,UAAU2jB,QAAU,SAAU5c,EAAIC,GAElD,IAAK,GADD8B,GAAUlJ,KAAKkJ,QACVvG,EAAK,EAAG6E,EAAW0B,EAAQzG,OAAS,EAAGE,GAAM6E,EAAU7E,IAC9D,IAAkD,IAA9CwE,EAAG+B,EAAQ9B,EAAUI,EAAW7E,EAAKA,IACvC,OAAO,GAKbkL,GAAkBzN,UAAU2jB,QAC5B/V,GAAiB5N,UAAU2jB,QAAU,SAAU5c,EAAIC,GAEjD,IAAK,GADD2G,GAAQ/N,KAAK+N,MACRpL,EAAK,EAAG6E,EAAWuG,EAAMtL,OAAS,EAAGE,GAAM6E,EAAU7E,IAAM,CAClE,GAAIqK,GAAOe,EAAM3G,EAAUI,EAAW7E,EAAKA,EAC3C,IAAIqK,IAAsC,IAA9BA,EAAK+W,QAAQ5c,EAAIC,GAC3B,OAAO,IAKbgH,GAAUhO,UAAU2jB,QAAU,SAAU5c,EAAIC,GAC1C,MAAOD,GAAGnH,KAAKyH,QAGjBxH,EAAYoO,GAAavK,GAQvBuK,GAAYjO,UAAU2D,KAAO,WAG3B,IAFA,GAAIE,GAAOjE,KAAKsO,MACZ0N,EAAQhc,KAAKwO,OACVwN,GAAO,CACZ,GAEIxU,GAFAwF,EAAOgP,EAAMhP,KACb7J,EAAQ6Y,EAAM7Y,OAElB,IAAI6J,EAAKvF,OACP,GAAc,IAAVtE,EACF,MAAOwL,IAAiB1K,EAAM+I,EAAKvF,WAEhC,IAAIuF,EAAK9D,SAEd,GADA1B,EAAWwF,EAAK9D,QAAQzG,OAAS,EAC7BU,GAASqE,EACX,MAAOmH,IAAiB1K,EAAM+I,EAAK9D,QAAQlJ,KAAKuO,SAAW/G,EAAWrE,EAAQA,QAIhF,IADAqE,EAAWwF,EAAKe,MAAMtL,OAAS,EAC3BU,GAASqE,EAAU,CACrB,GAAIqd,GAAU7X,EAAKe,MAAM/N,KAAKuO,SAAW/G,EAAWrE,EAAQA,EAC5D,IAAI0hB,EAAS,CACX,GAAIA,EAAQpd,MACV,MAAOkH,IAAiB1K,EAAM4gB,EAAQpd,MAExCuU,GAAQhc,KAAKwO,OAASE,GAAiBmW,EAAS7I,GAElD,SAGJA,EAAQhc,KAAKwO,OAASxO,KAAKwO,OAAOK,OAEpC,MAAOvK,KA0BX,IAAI6K,IAsOAgV,GAAqBrT,GAAO,EAC5ByT,GAA0BzT,GAAO,EACjC6T,GAA0B7T,GAAO,CAErC7Q,GAAYmT,GAAMpI,IA2BhBoI,GAAKkP,GAAK,WACR,MAAOtiB,MAAK8M,YAGdsG,GAAKhT,UAAUwL,SAAW,WACxB,MAAO5L,MAAKuiB,WAAW,SAAU,MAKnCnP,GAAKhT,UAAUsJ,IAAM,SAASvG,EAAO8O,GAEnC,IADA9O,EAAQD,EAAUlD,KAAMmD,KACX,GAAKA,EAAQnD,KAAK+C,KAAM,CACnCI,GAASnD,KAAK6U,OACd,IAAI7H,GAAO+I,GAAY/V,KAAMmD,EAC7B,OAAO6J,IAAQA,EAAKnH,MAAM1C,EAAQ+M,IAEpC,MAAO+B,IAKTmB,GAAKhT,UAAUsM,IAAM,SAASvJ,EAAO1C,GACnC,MAAO6U,IAAWtV,KAAMmD,EAAO1C,IAGjC2S,GAAKhT,UAAUoS,OAAS,SAASrP,GAC/B,MAAQnD,MAAKyJ,IAAItG,GACL,IAAVA,EAAcnD,KAAK4P,QACnBzM,IAAUnD,KAAK+C,KAAO,EAAI/C,KAAKmT,MAC/BnT,KAAK8kB,OAAO3hB,EAAO,GAHKnD,MAM5BoT,GAAKhT,UAAU2kB,OAAS,SAAS5hB,EAAO1C,GACtC,MAAOT,MAAK8kB,OAAO3hB,EAAO,EAAG1C,IAG/B2S,GAAKhT,UAAUkW,MAAQ,WACrB,MAAkB,KAAdtW,KAAK+C,KACA/C,KAELA,KAAKiP,WACPjP,KAAK+C,KAAO/C,KAAK6U,QAAU7U,KAAK8U,UAAY,EAC5C9U,KAAKiV,OAAS7E,GACdpQ,KAAKyO,MAAQzO,KAAKgV,MAAQ,KAC1BhV,KAAKgJ,WAASlG,GACd9C,KAAKkP,WAAY,EACVlP,MAEFsT,MAGTF,GAAKhT,UAAU+Q,KAAO,WACpB,GAAIyD,GAAS9H,UACTkY,EAAUhlB,KAAK+C,IACnB,OAAO/C,MAAKuN,cAAc,SAASoG,GACjC4B,GAAc5B,EAAM,EAAGqR,EAAUpQ,EAAOnS,OACxC,KAAK,GAAIE,GAAK,EAAGA,EAAKiS,EAAOnS,OAAQE,IACnCgR,EAAKjH,IAAIsY,EAAUriB,EAAIiS,EAAOjS,OAKpCyQ,GAAKhT,UAAU+S,IAAM,WACnB,MAAOoC,IAAcvV,KAAM,GAAI,IAGjCoT,GAAKhT,UAAU6kB,QAAU,WACvB,GAAIrQ,GAAS9H,SACb,OAAO9M,MAAKuN,cAAc,SAASoG,GACjC4B,GAAc5B,GAAOiB,EAAOnS,OAC5B,KAAK,GAAIE,GAAK,EAAGA,EAAKiS,EAAOnS,OAAQE,IACnCgR,EAAKjH,IAAI/J,EAAIiS,EAAOjS,OAK1ByQ,GAAKhT,UAAUwP,MAAQ,WACrB,MAAO2F,IAAcvV,KAAM,IAK7BoT,GAAKhT,UAAUkjB,MAAQ,WACrB,MAAOvM,IAAkB/W,SAAM8C,GAAWgK,YAG5CsG,GAAKhT,UAAUmjB,UAAY,SAASvS,GAClC,MAAO+F,IAAkB/W,KAAMgR,EADwB4Q,GAAQ9c,KAAKgI,UAAW,KAIjFsG,GAAKhT,UAAUmR,UAAY,WACzB,MAAOwF,IAAkB/W,KAAMqR,GAAYvE,YAG7CsG,GAAKhT,UAAUqR,cAAgB,SAAST,GAAS,GAAIE,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EACnF,OAAOiK,IAAkB/W,KAAMwR,GAAeR,GAASE,IAGzDkC,GAAKhT,UAAUwT,QAAU,SAAS7Q,GAChC,MAAOwS,IAAcvV,KAAM,EAAG+C,IAKhCqQ,GAAKhT,UAAU0V,MAAQ,SAASvS,EAAOC,GACrC,GAAIT,GAAO/C,KAAK+C,IAChB,OAAIO,GAAWC,EAAOC,EAAKT,GAClB/C,KAEFuV,GACLvV,KACAyD,EAAaF,EAAOR,GACpBY,EAAWH,EAAKT,KAIpBqQ,GAAKhT,UAAUyY,WAAa,SAAS5U,EAAMmD,GACzC,GAAIjE,GAAQ,EACRyR,EAASZ,GAAYhU,KAAMoH,EAC/B,OAAO,IAAItD,GAAS,WAClB,GAAIrD,GAAQmU,GACZ,OAAOnU,KAAUkU,GACfrQ,IACAN,EAAcC,EAAMd,IAAS1C,MAInC2S,GAAKhT,UAAU4C,UAAY,SAASmE,EAAIC,GAItC,IAHA,GAEI3G,GAFA0C,EAAQ,EACRyR,EAASZ,GAAYhU,KAAMoH,IAEvB3G,EAAQmU,OAAcD,KACK,IAA7BxN,EAAG1G,EAAO0C,IAASnD,QAIzB,MAAOmD,IAGTiQ,GAAKhT,UAAU0jB,cAAgB,SAASlW,GACtC,MAAIA,KAAY5N,KAAKiP,UACZjP,KAEJ4N,EAIE4F,GAASxT,KAAK6U,QAAS7U,KAAK8U,UAAW9U,KAAKiV,OAAQjV,KAAKyO,MAAOzO,KAAKgV,MAAOpH,EAAS5N,KAAKgJ,SAH/FhJ,KAAKiP,UAAYrB,EACV5N,OAUboT,GAAKG,OAASA,EAEd,IAAIQ,IAAmB,yBAEnBqB,GAAgBhC,GAAKhT,SACzBgV,IAAcrB,KAAoB,EAClCqB,GAAoB,OAAIA,GAAc5C,OACtC4C,GAAc1C,MAAQ1D,GAAa0D,MACnC0C,GAAcgO,SACdhO,GAAc4O,SAAWhV,GAAagV,SACtC5O,GAAcvF,OAASb,GAAaa,OACpCuF,GAAc+N,SAAWnU,GAAamU,SACtC/N,GAAcoO,QAAUxU,GAAawU,QACrCpO,GAAcsO,YAAc1U,GAAa0U,YACzCtO,GAAc7H,cAAgByB,GAAazB,cAC3C6H,GAAcyE,UAAY7K,GAAa6K,UACvCzE,GAAc0E,YAAc9K,GAAa8K,YACzC1E,GAAcyO,WAAa7U,GAAa6U,WAWtCpQ,GAAMrT,UAAUyW,aAAe,SAASjJ,EAASsG,EAAO/Q,GACtD,GAAIA,IAAU+Q,EAAQ,GAAKA,EAAmC,IAAtBlU,KAAK6F,MAAMpD,OACjD,MAAOzC,KAET,IAAIklB,GAAe/hB,IAAU+Q,EAAShE,EACtC,IAAIgV,GAAellB,KAAK6F,MAAMpD,OAC5B,MAAO,IAAIgR,OAAU7F,EAEvB,IACIuX,GADAC,EAAgC,IAAhBF,CAEpB,IAAIhR,EAAQ,EAAG,CACb,GAAImR,GAAWrlB,KAAK6F,MAAMqf,EAE1B,KADAC,EAAWE,GAAYA,EAASxO,aAAajJ,EAASsG,EAAQ9D,GAAOjN,MACpDkiB,GAAYD,EAC3B,MAAOplB,MAGX,GAAIolB,IAAkBD,EACpB,MAAOnlB,KAET,IAAIslB,GAAWzP,GAAc7V,KAAM4N,EACnC,KAAKwX,EACH,IAAK,GAAIziB,GAAK,EAAGA,EAAKuiB,EAAaviB,IACjC2iB,EAASzf,MAAMlD,OAAMG,EAMzB,OAHIqiB,KACFG,EAASzf,MAAMqf,GAAeC,GAEzBG,GAGT7R,GAAMrT,UAAUwW,YAAc,SAAShJ,EAASsG,EAAO/Q,GACrD,GAAIA,KAAW+Q,EAAQ,GAAKA,EAAQ,IAA4B,IAAtBlU,KAAK6F,MAAMpD,OACnD,MAAOzC,KAET,IAAIulB,GAAcpiB,EAAQ,IAAO+Q,EAAShE,EAC1C,IAAIqV,GAAavlB,KAAK6F,MAAMpD,OAC1B,MAAOzC,KAGT,IAAImlB,EACJ,IAAIjR,EAAQ,EAAG,CACb,GAAImR,GAAWrlB,KAAK6F,MAAM0f,EAE1B,KADAJ,EAAWE,GAAYA,EAASzO,YAAYhJ,EAASsG,EAAQ9D,GAAOjN,MACnDkiB,GAAYE,IAAcvlB,KAAK6F,MAAMpD,OAAS,EAC7D,MAAOzC,MAIX,GAAIslB,GAAWzP,GAAc7V,KAAM4N,EAKnC,OAJA0X,GAASzf,MAAMif,OAAOS,EAAY,GAC9BJ,IACFG,EAASzf,MAAM0f,GAAaJ,GAEvBG,EAKX,IA2EIjQ,IA3EAV,KAoUJ1U,GAAYgX,GAAY7J,IActB6J,GAAWqL,GAAK,WACd,MAAOtiB,MAAK8M,YAGdmK,GAAW7W,UAAUwL,SAAW,WAC9B,MAAO5L,MAAKuiB,WAAW,eAAgB,MAKzCtL,GAAW7W,UAAUsJ,IAAM,SAASxF,EAAG+N,GACrC,GAAI9O,GAAQnD,KAAKuX,KAAK7N,IAAIxF,EAC1B,YAAiBpB,KAAVK,EAAsBnD,KAAKwX,MAAM9N,IAAIvG,GAAO,GAAK8O,GAK1DgF,GAAW7W,UAAUkW,MAAQ,WAC3B,MAAkB,KAAdtW,KAAK+C,KACA/C,KAELA,KAAKiP,WACPjP,KAAK+C,KAAO,EACZ/C,KAAKuX,KAAKjB,QACVtW,KAAKwX,MAAMlB,QACJtW,MAEFkX,MAGTD,GAAW7W,UAAUsM,IAAM,SAASxI,EAAGC,GACrC,MAAOuT,IAAiB1X,KAAMkE,EAAGC,IAGnC8S,GAAW7W,UAAUoS,OAAS,SAAStO,GACrC,MAAOwT,IAAiB1X,KAAMkE,EAAGyF,KAGnCsN,GAAW7W,UAAUyjB,WAAa,WAChC,MAAO7jB,MAAKuX,KAAKsM,cAAgB7jB,KAAKwX,MAAMqM,cAG9C5M,GAAW7W,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GAAIuR,GAAS3Y,IACnE,OAAOA,MAAKwX,MAAMxU,UAChB,SAASyE,GAAS,MAAOA,IAASN,EAAGM,EAAM,GAAIA,EAAM,GAAIkR,IACzDvR,IAIJ6P,GAAW7W,UAAUyY,WAAa,SAAS5U,EAAMmD,GAC/C,MAAOpH,MAAKwX,MAAMlS,eAAeuT,WAAW5U,EAAMmD,IAGpD6P,GAAW7W,UAAU0jB,cAAgB,SAASlW,GAC5C,GAAIA,IAAY5N,KAAKiP,UACnB,MAAOjP,KAET,IAAI2X,GAAS3X,KAAKuX,KAAKuM,cAAclW,GACjCgK,EAAU5X,KAAKwX,MAAMsM,cAAclW,EACvC,OAAKA,GAMEyJ,GAAeM,EAAQC,EAAShK,EAAS5N,KAAKgJ,SALnDhJ,KAAKiP,UAAYrB,EACjB5N,KAAKuX,KAAOI,EACZ3X,KAAKwX,MAAQI,EACN5X,OAUbiX,GAAWE,aAAeA,GAE1BF,GAAW7W,UAAU0B,KAAuB,EAC5CmV,GAAW7W,UAAgB,OAAI6W,GAAW7W,UAAUoS,MAcpD,IAAIiF,GAgDJxX,GAAY6X,GAAiBhX,GAO3BgX,GAAgB1X,UAAUsJ,IAAM,SAASxB,EAAK+J,GAC5C,MAAOjS,MAAKgY,MAAMtO,IAAIxB,EAAK+J,IAG7B6F,GAAgB1X,UAAUqJ,IAAM,SAASvB,GACvC,MAAOlI,MAAKgY,MAAMvO,IAAIvB,IAGxB4P,GAAgB1X,UAAUolB,SAAW,WACnC,MAAOxlB,MAAKgY,MAAMwN,YAGpB1N,GAAgB1X,UAAUgH,QAAU,WAAY,GAAIuR,GAAS3Y,KACvDwY,EAAmBa,GAAerZ,MAAM,EAI5C,OAHKA,MAAKiY,WACRO,EAAiBgN,SAAW,WAAa,MAAO7M,GAAOX,MAAM7S,QAAQiC,YAEhEoR,GAGTV,GAAgB1X,UAAUgI,IAAM,SAAS6Q,EAAQC,GAAU,GAAIP,GAAS3Y,KAClEmZ,EAAiBH,GAAWhZ,KAAMiZ,EAAQC,EAI9C,OAHKlZ,MAAKiY,WACRkB,EAAeqM,SAAW,WAAa,MAAO7M,GAAOX,MAAM7S,QAAQiD,IAAI6Q,EAAQC,KAE1EC,GAGTrB,GAAgB1X,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GACvDzE,GAD2DgW,EAAS3Y,IAExE,OAAOA,MAAKgY,MAAMhV,UAChBhD,KAAKiY,SACH,SAAS9T,EAAGD,GAAK,MAAOiD,GAAGhD,EAAGD,EAAGyU,KAC/BhW,EAAKyE,EAAUkW,GAAYtd,MAAQ,EACnC,SAASmE,GAAK,MAAOgD,GAAGhD,EAAGiD,IAAYzE,EAAKA,IAAMgW,KACtDvR,IAIJ0Q,GAAgB1X,UAAUyY,WAAa,SAAS5U,EAAMmD,GACpD,GAAIpH,KAAKiY,SACP,MAAOjY,MAAKgY,MAAMa,WAAW5U,EAAMmD,EAErC,IAAIb,GAAWvG,KAAKgY,MAAMa,WAAWC,GAAgB1R,GACjDzE,EAAKyE,EAAUkW,GAAYtd,MAAQ,CACvC,OAAO,IAAI8D,GAAS,WAClB,GAAIyG,GAAOhE,EAASxC,MACpB,OAAOwG,GAAKlG,KAAOkG,EACjBvG,EAAcC,EAAMmD,IAAYzE,EAAKA,IAAM4H,EAAK9J,MAAO8J,MAI/DuN,GAAgB1X,UAAU0B,KAAuB,EAGjD7B,EAAYiY,GAAmBjX,GAM7BiX,GAAkB9X,UAAUqY,SAAW,SAAShY,GAC9C,MAAOT,MAAKgY,MAAMS,SAAShY,IAG7ByX,GAAkB9X,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GAAIuR,GAAS3Y,KACtEyZ,EAAa,CACjB,OAAOzZ,MAAKgY,MAAMhV,UAAU,SAASmB,GAAK,MAAOgD,GAAGhD,EAAGsV,IAAcd,IAAUvR,IAGjF8Q,GAAkB9X,UAAUyY,WAAa,SAAS5U,EAAMmD,GACtD,GAAIb,GAAWvG,KAAKgY,MAAMa,WAAWC,GAAgB1R,GACjDqS,EAAa,CACjB,OAAO,IAAI3V,GAAS,WAClB,GAAIyG,GAAOhE,EAASxC,MACpB,OAAOwG,GAAKlG,KAAOkG,EACjBvG,EAAcC,EAAMwV,IAAclP,EAAK9J,MAAO8J,MAMtDtK,EAAYkY,GAAe/W,GAMzB+W,GAAc/X,UAAUqJ,IAAM,SAASvB,GACrC,MAAOlI,MAAKgY,MAAMS,SAASvQ,IAG7BiQ,GAAc/X,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GAAIuR,GAAS3Y,IACtE,OAAOA,MAAKgY,MAAMhV,UAAU,SAASmB,GAAK,MAAOgD,GAAGhD,EAAGA,EAAGwU,IAAUvR,IAGtE+Q,GAAc/X,UAAUyY,WAAa,SAAS5U,EAAMmD,GAClD,GAAIb,GAAWvG,KAAKgY,MAAMa,WAAWC,GAAgB1R,EACrD,OAAO,IAAItD,GAAS,WAClB,GAAIyG,GAAOhE,EAASxC,MACpB,OAAOwG,GAAKlG,KAAOkG,EACjBvG,EAAcC,EAAMsG,EAAK9J,MAAO8J,EAAK9J,MAAO8J,MAMpDtK,EAAYmY,GAAqBtX,GAM/BsX,GAAoBhY,UAAUoF,SAAW,WACvC,MAAOxF,MAAKgY,MAAM7S,SAGpBiT,GAAoBhY,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GAAIuR,GAAS3Y,IAC5E,OAAOA,MAAKgY,MAAMhV,UAAU,SAASyE,GAGnC,GAAIA,EAAO,CACT4V,GAAc5V,EACd,IAAIge,GAAkB/kB,EAAW+G,EACjC,OAAON,GACLse,EAAkBhe,EAAMiC,IAAI,GAAKjC,EAAM,GACvCge,EAAkBhe,EAAMiC,IAAI,GAAKjC,EAAM,GACvCkR,KAGHvR,IAGLgR,GAAoBhY,UAAUyY,WAAa,SAAS5U,EAAMmD,GACxD,GAAIb,GAAWvG,KAAKgY,MAAMa,WAAWC,GAAgB1R,EACrD,OAAO,IAAItD,GAAS,WAClB,OAAa,CACX,GAAIyG,GAAOhE,EAASxC,MACpB,IAAIwG,EAAKlG,KACP,MAAOkG,EAET,IAAI9C,GAAQ8C,EAAK9J,KAGjB,IAAIgH,EAAO,CACT4V,GAAc5V,EACd,IAAIge,GAAkB/kB,EAAW+G,EACjC,OAAOzD,GACLC,EACAwhB,EAAkBhe,EAAMiC,IAAI,GAAKjC,EAAM,GACvCge,EAAkBhe,EAAMiC,IAAI,GAAKjC,EAAM,GACvC8C,QAQZ2N,GAAkB9X,UAAUiJ,YAC5ByO,GAAgB1X,UAAUiJ,YAC1B8O,GAAc/X,UAAUiJ,YACxB+O,GAAoBhY,UAAUiJ,YAC5BqP,GAwpBFzY,EAAYwd,GAAQ1S,IA8BlB0S,GAAOrd,UAAUwL,SAAW,WAC1B,MAAO5L,MAAKuiB,WAAWhE,GAAWve,MAAQ,KAAM,MAKlDyd,GAAOrd,UAAUqJ,IAAM,SAASvF,GAC9B,MAAOlE,MAAKie,eAAeuE,eAAete,IAG5CuZ,GAAOrd,UAAUsJ,IAAM,SAASxF,EAAG+N,GACjC,IAAKjS,KAAKyJ,IAAIvF,GACZ,MAAO+N,EAET,IAAIyT,GAAa1lB,KAAKie,eAAe/Z,EACrC,OAAOlE,MAAKuX,KAAOvX,KAAKuX,KAAK7N,IAAIxF,EAAGwhB,GAAcA,GAKpDjI,GAAOrd,UAAUkW,MAAQ,WACvB,GAAItW,KAAKiP,UAEP,MADAjP,MAAKuX,MAAQvX,KAAKuX,KAAKjB,QAChBtW,IAET,IAAI6d,GAAa7d,KAAKO,WACtB,OAAOsd,GAAW8H,SAAW9H,EAAW8H,OAASxH,GAAWne,KAAMqN,QAGpEoQ,GAAOrd,UAAUsM,IAAM,SAASxI,EAAGC,GACjC,IAAKnE,KAAKyJ,IAAIvF,GACZ,KAAM,IAAIkG,OAAM,2BAA6BlG,EAAI,QAAUqa,GAAWve,MAExE,IAAIA,KAAKuX,OAASvX,KAAKuX,KAAK9N,IAAIvF,GAAI,CAElC,GAAIC,IADanE,KAAKie,eAAe/Z,GAEnC,MAAOlE,MAGX,GAAI2X,GAAS3X,KAAKuX,MAAQvX,KAAKuX,KAAK7K,IAAIxI,EAAGC,EAC3C,OAAInE,MAAKiP,WAAa0I,IAAW3X,KAAKuX,KAC7BvX,KAEFme,GAAWne,KAAM2X,IAG1B8F,GAAOrd,UAAUoS,OAAS,SAAStO,GACjC,IAAKlE,KAAKyJ,IAAIvF,GACZ,MAAOlE,KAET,IAAI2X,GAAS3X,KAAKuX,MAAQvX,KAAKuX,KAAK/E,OAAOtO,EAC3C,OAAIlE,MAAKiP,WAAa0I,IAAW3X,KAAKuX,KAC7BvX,KAEFme,GAAWne,KAAM2X,IAG1B8F,GAAOrd,UAAUyjB,WAAa,WAC5B,MAAO7jB,MAAKuX,KAAKsM,cAGnBpG,GAAOrd,UAAUyY,WAAa,SAAS5U,EAAMmD,GAAU,GAAIuR,GAAS3Y,IAClE,OAAOY,GAAcZ,KAAKie,gBAAgB7V,IAAI,SAASkB,EAAGpF,GAAK,MAAOyU,GAAOjP,IAAIxF,KAAK2U,WAAW5U,EAAMmD,IAGzGqW,GAAOrd,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GAAIuR,GAAS3Y,IAC/D,OAAOY,GAAcZ,KAAKie,gBAAgB7V,IAAI,SAASkB,EAAGpF,GAAK,MAAOyU,GAAOjP,IAAIxF,KAAKlB,UAAUmE,EAAIC,IAGtGqW,GAAOrd,UAAU0jB,cAAgB,SAASlW,GACxC,GAAIA,IAAY5N,KAAKiP,UACnB,MAAOjP,KAET,IAAI2X,GAAS3X,KAAKuX,MAAQvX,KAAKuX,KAAKuM,cAAclW,EAClD,OAAKA,GAKEuQ,GAAWne,KAAM2X,EAAQ/J,IAJ9B5N,KAAKiP,UAAYrB,EACjB5N,KAAKuX,KAAOI,EACL3X,MAMb,IAAIke,IAAkBT,GAAOrd,SAC7B8d,IAAsB,OAAIA,GAAgB1L,OAC1C0L,GAAgBkF,SAChBlF,GAAgB8F,SAAWhV,GAAagV,SACxC9F,GAAgBoF,MAAQtU,GAAasU,MACrCpF,GAAgBqF,UAAYvU,GAAauU,UACzCrF,GAAgBsF,QAAUxU,GAAawU,QACvCtF,GAAgB3M,UAAYvC,GAAauC,UACzC2M,GAAgBzM,cAAgBzC,GAAayC,cAC7CyM,GAAgBwF,YAAc1U,GAAa0U,YAC3CxF,GAAgBxL,MAAQ1D,GAAa0D,MACrCwL,GAAgBrO,OAASb,GAAaa,OACtCqO,GAAgBiF,SAAWnU,GAAamU,SACxCjF,GAAgB3Q,cAAgByB,GAAazB,cAC7C2Q,GAAgBrE,UAAY7K,GAAa6K,UACzCqE,GAAgBpE,YAAc9K,GAAa8K,YAkC3C7Z,EAAY0e,GAAK1T,IAcf0T,GAAI2D,GAAK,WACP,MAAOtiB,MAAK8M,YAGd6R,GAAIiH,SAAW,SAASnlB,GACtB,MAAOT,MAAKY,EAAcH,GAAOolB,WAGnClH,GAAIve,UAAUwL,SAAW,WACvB,MAAO5L,MAAKuiB,WAAW,QAAS,MAKlC5D,GAAIve,UAAUqJ,IAAM,SAAShJ,GAC3B,MAAOT,MAAKuX,KAAK9N,IAAIhJ,IAKvBke,GAAIve,UAAU0e,IAAM,SAASre,GAC3B,MAAOwe,IAAUjf,KAAMA,KAAKuX,KAAK7K,IAAIjM,GAAO,KAG9Cke,GAAIve,UAAUoS,OAAS,SAAS/R,GAC9B,MAAOwe,IAAUjf,KAAMA,KAAKuX,KAAK/E,OAAO/R,KAG1Cke,GAAIve,UAAUkW,MAAQ,WACpB,MAAO2I,IAAUjf,KAAMA,KAAKuX,KAAKjB,UAKnCqI,GAAIve,UAAU0lB,MAAQ,WAAY,GAAI5U,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EAEpE,OADAoE,GAAQA,EAAMU,OAAO,SAASC,GAAK,MAAkB,KAAXA,EAAE9O,OACvB,IAAjBmO,EAAMzO,OACDzC,KAES,IAAdA,KAAK+C,MAAe/C,KAAKiP,WAA8B,IAAjBiC,EAAMzO,OAGzCzC,KAAKuN,cAAc,SAASb,GACjC,IAAK,GAAI/J,GAAK,EAAGA,EAAKuO,EAAMzO,OAAQE,IAClCzB,EAAYgQ,EAAMvO,IAAK6K,QAAQ,SAAS/M,GAAS,MAAOiM,GAAIoS,IAAIre,OAJ3DT,KAAKO,YAAY2Q,EAAM,KASlCyN,GAAIve,UAAU2lB,UAAY,WAAY,GAAI7U,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EACxE,IAAqB,IAAjBoE,EAAMzO,OACR,MAAOzC,KAETkR,GAAQA,EAAM9I,IAAI,SAASvF,GAAQ,MAAO3B,GAAY2B,IACtD,IAAImjB,GAAchmB,IAClB,OAAOA,MAAKuN,cAAc,SAASb,GACjCsZ,EAAYxY,QAAQ,SAAS/M,GACtByQ,EAAM/H,MAAM,SAAStG,GAAQ,MAAOA,GAAK4V,SAAShY,MACrDiM,EAAI8F,OAAO/R,QAMnBke,GAAIve,UAAU6lB,SAAW,WAAY,GAAI/U,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EACvE,IAAqB,IAAjBoE,EAAMzO,OACR,MAAOzC,KAETkR,GAAQA,EAAM9I,IAAI,SAASvF,GAAQ,MAAO3B,GAAY2B,IACtD,IAAImjB,GAAchmB,IAClB,OAAOA,MAAKuN,cAAc,SAASb,GACjCsZ,EAAYxY,QAAQ,SAAS/M,GACvByQ,EAAMiM,KAAK,SAASta,GAAQ,MAAOA,GAAK4V,SAAShY,MACnDiM,EAAI8F,OAAO/R,QAMnBke,GAAIve,UAAUkjB,MAAQ,WACpB,MAAOtjB,MAAK8lB,MAAMjZ,MAAM7M,KAAM8M,YAGhC6R,GAAIve,UAAUmjB,UAAY,SAASvS,GAAS,GAAIE,GAAQ0Q,GAAQ9c,KAAKgI,UAAW,EAC9E,OAAO9M,MAAK8lB,MAAMjZ,MAAM7M,KAAMkR,IAGhCyN,GAAIve,UAAUoc,KAAO,SAASF,GAE5B,MAAOiD,IAAWlD,GAAYrc,KAAMsc,KAGtCqC,GAAIve,UAAUujB,OAAS,SAAS1K,EAAQqD,GAEtC,MAAOiD,IAAWlD,GAAYrc,KAAMsc,EAAYrD,KAGlD0F,GAAIve,UAAUyjB,WAAa,WACzB,MAAO7jB,MAAKuX,KAAKsM,cAGnBlF,GAAIve,UAAU4C,UAAY,SAASmE,EAAIC,GAAU,GAAIuR,GAAS3Y,IAC5D,OAAOA,MAAKuX,KAAKvU,UAAU,SAASsG,EAAGpF,GAAK,MAAOiD,GAAGjD,EAAGA,EAAGyU,IAAUvR,IAGxEuX,GAAIve,UAAUyY,WAAa,SAAS5U,EAAMmD,GACxC,MAAOpH,MAAKuX,KAAKnP,IAAI,SAASkB,EAAGpF,GAAK,MAAOA,KAAI2U,WAAW5U,EAAMmD,IAGpEuX,GAAIve,UAAU0jB,cAAgB,SAASlW,GACrC,GAAIA,IAAY5N,KAAKiP,UACnB,MAAOjP,KAET,IAAI2X,GAAS3X,KAAKuX,KAAKuM,cAAclW,EACrC,OAAKA,GAKE5N,KAAKmf,OAAOxH,EAAQ/J,IAJzB5N,KAAKiP,UAAYrB,EACjB5N,KAAKuX,KAAOI,EACL3X,OAUb2e,GAAIE,MAAQA,EAEZ,IAAIG,IAAkB,wBAElBK,GAAeV,GAAIve,SACvBif,IAAaL,KAAmB,EAChCK,GAAmB,OAAIA,GAAa7M,OACpC6M,GAAa9N,UAAY8N,GAAaiE,MACtCjE,GAAa5N,cAAgB4N,GAAakE,UAC1ClE,GAAa9R,cAAgByB,GAAazB,cAC1C8R,GAAaxF,UAAY7K,GAAa6K,UACtCwF,GAAavF,YAAc9K,GAAa8K,YAExCuF,GAAaH,QAAUN,GACvBS,GAAaF,OAASC,EAqBtB,IAAIE,GAKJrf,GAAYsf,GAAYZ,IActBY,GAAW+C,GAAK,WACd,MAAOtiB,MAAK8M,YAGdyS,GAAWqG,SAAW,SAASnlB,GAC7B,MAAOT,MAAKY,EAAcH,GAAOolB,WAGnCtG,GAAWnf,UAAUwL,SAAW,WAC9B,MAAO5L,MAAKuiB,WAAW,eAAgB,MAQ3ChD,GAAWE,aAAeA,EAE1B,IAAIG,IAAsBL,GAAWnf,SACrCwf,IAAoB9d,KAAuB,EAE3C8d,GAAoBV,QAAUM,GAC9BI,GAAoBT,OAASQ,EAU7B,IAAIE,GAKJ5f,GAAY6f,GAAO9U,IAUjB8U,GAAMwC,GAAK,WACT,MAAOtiB,MAAK8M,YAGdgT,GAAM1f,UAAUwL,SAAW,WACzB,MAAO5L,MAAKuiB,WAAW,UAAW,MAKpCzC,GAAM1f,UAAUsJ,IAAM,SAASvG,EAAO8O,GACpC,GAAIoO,GAAOrgB,KAAKugB,KAEhB,KADApd,EAAQD,EAAUlD,KAAMmD,GACjBkd,GAAQld,KACbkd,EAAOA,EAAKtc,IAEd,OAAOsc,GAAOA,EAAK5f,MAAQwR,GAG7B6N,GAAM1f,UAAU8lB,KAAO,WACrB,MAAOlmB,MAAKugB,OAASvgB,KAAKugB,MAAM9f,OAKlCqf,GAAM1f,UAAU+Q,KAAO,WACrB,GAAyB,IAArBrE,UAAUrK,OACZ,MAAOzC,KAIT,KAAK,GAFDsP,GAAUtP,KAAK+C,KAAO+J,UAAUrK,OAChC4d,EAAOrgB,KAAKugB,MACP5d,EAAKmK,UAAUrK,OAAS,EAAGE,GAAM,EAAGA,IAC3C0d,GACE5f,MAAOqM,UAAUnK,GACjBoB,KAAMsc,EAGV,OAAIrgB,MAAKiP,WACPjP,KAAK+C,KAAOuM,EACZtP,KAAKugB,MAAQF,EACbrgB,KAAKgJ,WAASlG,GACd9C,KAAKkP,WAAY,EACVlP,MAEFogB,GAAU9Q,EAAS+Q,IAG5BP,GAAM1f,UAAU+lB,QAAU,SAAStjB,GAEjC,GADAA,EAAO9B,EAAgB8B,GACL,IAAdA,EAAKE,KACP,MAAO/C,KAETmN,IAAkBtK,EAAKE,KACvB,IAAIuM,GAAUtP,KAAK+C,KACfsd,EAAOrgB,KAAKugB,KAQhB,OAPA1d,GAAKuE,UAAUoG,QAAQ,SAAS/M,GAC9B6O,IACA+Q,GACE5f,MAAOA,EACPsD,KAAMsc,KAGNrgB,KAAKiP,WACPjP,KAAK+C,KAAOuM,EACZtP,KAAKugB,MAAQF,EACbrgB,KAAKgJ,WAASlG,GACd9C,KAAKkP,WAAY,EACVlP,MAEFogB,GAAU9Q,EAAS+Q,IAG5BP,GAAM1f,UAAU+S,IAAM,WACpB,MAAOnT,MAAK8V,MAAM,IAGpBgK,GAAM1f,UAAU6kB,QAAU,WACxB,MAAOjlB,MAAKmR,KAAKtE,MAAM7M,KAAM8M,YAG/BgT,GAAM1f,UAAU6f,WAAa,SAASpd,GACpC,MAAO7C,MAAKmmB,QAAQtjB,IAGtBid,GAAM1f,UAAUwP,MAAQ,WACtB,MAAO5P,MAAKmT,IAAItG,MAAM7M,KAAM8M,YAG9BgT,GAAM1f,UAAUkW,MAAQ,WACtB,MAAkB,KAAdtW,KAAK+C,KACA/C,KAELA,KAAKiP,WACPjP,KAAK+C,KAAO,EACZ/C,KAAKugB,UAAQzd,GACb9C,KAAKgJ,WAASlG,GACd9C,KAAKkP,WAAY,EACVlP,MAEF+f,MAGTD,GAAM1f,UAAU0V,MAAQ,SAASvS,EAAOC,GACtC,GAAIF,EAAWC,EAAOC,EAAKxD,KAAK+C,MAC9B,MAAO/C,KAET,IAAIsa,GAAgB7W,EAAaF,EAAOvD,KAAK+C,KAE7C,IADkBY,EAAWH,EAAKxD,KAAK+C,QACnB/C,KAAK+C,KAEvB,MAAOiI,IAAkB5K,UAAU0V,MAAMhR,KAAK9E,KAAMuD,EAAOC,EAI7D,KAFA,GAAI8L,GAAUtP,KAAK+C,KAAOuX,EACtB+F,EAAOrgB,KAAKugB,MACTjG,KACL+F,EAAOA,EAAKtc,IAEd,OAAI/D,MAAKiP,WACPjP,KAAK+C,KAAOuM,EACZtP,KAAKugB,MAAQF,EACbrgB,KAAKgJ,WAASlG,GACd9C,KAAKkP,WAAY,EACVlP,MAEFogB,GAAU9Q,EAAS+Q,IAK5BP,GAAM1f,UAAU0jB,cAAgB,SAASlW,GACvC,MAAIA,KAAY5N,KAAKiP,UACZjP,KAEJ4N,EAKEwS,GAAUpgB,KAAK+C,KAAM/C,KAAKugB,MAAO3S,EAAS5N,KAAKgJ,SAJpDhJ,KAAKiP,UAAYrB,EACjB5N,KAAKkP,WAAY,EACVlP,OAOX8f,GAAM1f,UAAU4C,UAAY,SAASmE,EAAIC,GACvC,GAAIA,EACF,MAAOpH,MAAKoH,UAAUpE,UAAUmE,EAIlC,KAFA,GAAIsS,GAAa,EACbzM,EAAOhN,KAAKugB,MACTvT,IACsC,IAAvC7F,EAAG6F,EAAKvM,MAAOgZ,IAAczZ,OAGjCgN,EAAOA,EAAKjJ,IAEd,OAAO0V,IAGTqG,GAAM1f,UAAUyY,WAAa,SAAS5U,EAAMmD,GAC1C,GAAIA,EACF,MAAOpH,MAAKoH,UAAUyR,WAAW5U,EAEnC,IAAIwV,GAAa,EACbzM,EAAOhN,KAAKugB,KAChB,OAAO,IAAIzc,GAAS,WAClB,GAAIkJ,EAAM,CACR,GAAIvM,GAAQuM,EAAKvM,KAEjB,OADAuM,GAAOA,EAAKjJ,KACLC,EAAcC,EAAMwV,IAAchZ,GAE3C,MAAO6D,QASbwb,GAAME,QAAUA,EAEhB,IAAIG,IAAoB,0BAEpBG,GAAiBR,GAAM1f,SAC3BkgB,IAAeH,KAAqB,EACpCG,GAAe/S,cAAgByB,GAAazB,cAC5C+S,GAAezG,UAAY7K,GAAa6K,UACxCyG,GAAexG,YAAc9K,GAAa8K,YAC1CwG,GAAeuD,WAAa7U,GAAa6U,UAazC,IAAIrD,GAgBJhgB,GAASsD,SAAWA,EAEpB2c,GAAMjgB,GAIJkT,QAAS,WACPvG,GAAkBnN,KAAK+C,KACvB,IAAI8C,GAAQ,GAAItG,OAAMS,KAAK+C,MAAQ,EAEnC,OADA/C,MAAKwlB,WAAWxiB,UAAU,SAASmB,EAAG0P,GAAMhO,EAAMgO,GAAK1P,IAChD0B,GAGTJ,aAAc,WACZ,MAAO,IAAIyS,IAAkBlY,OAG/BomB,KAAM,WACJ,MAAOpmB,MAAKmF,QAAQiD,IAClB,SAAS3H,GAAS,MAAOA,IAA+B,kBAAfA,GAAM2lB,KAAsB3lB,EAAM2lB,OAAS3lB,IACpF4lB,UAGJC,OAAQ,WACN,MAAOtmB,MAAKmF,QAAQiD,IAClB,SAAS3H,GAAS,MAAOA,IAAiC,kBAAjBA,GAAM6lB,OAAwB7lB,EAAM6lB,SAAW7lB,IACxF4lB,UAGJhhB,WAAY,WACV,MAAO,IAAIyS,IAAgB9X,MAAM,IAGnCuI,MAAO,WAEL,MAAO6E,IAAIpN,KAAKqF,eAGlBkhB,SAAU,WACRpZ,GAAkBnN,KAAK+C,KACvB,IAAIiD,KAEJ,OADAhG,MAAKgD,UAAU,SAASmB,EAAGD,GAAM8B,EAAO9B,GAAKC,IACtC6B,GAGTwgB,aAAc,WAEZ,MAAOvP,IAAWjX,KAAKqF,eAGzBohB,aAAc,WAEZ,MAAOlH,IAAW1e,EAAQb,MAAQA,KAAKwlB,WAAaxlB,OAGtD0mB,MAAO,WAEL,MAAO/H,IAAI9d,EAAQb,MAAQA,KAAKwlB,WAAaxlB,OAG/C2F,SAAU,WACR,MAAO,IAAIwS,IAAcnY,OAG3BmF,MAAO,WACL,MAAOnE,GAAUhB,MAAQA,KAAKyF,eAC5B5E,EAAQb,MAAQA,KAAKqF,aACrBrF,KAAK2F,YAGTghB,QAAS,WAEP,MAAO7G,IAAMjf,EAAQb,MAAQA,KAAKwlB,WAAaxlB,OAGjDsI,OAAQ,WAEN,MAAO8K,IAAKvS,EAAQb,MAAQA,KAAKwlB,WAAaxlB,OAMhD4L,SAAU,WACR,MAAO,cAGT2W,WAAY,SAASlC,EAAM/L,GACzB,MAAkB,KAAdtU,KAAK+C,KACAsd,EAAO/L,EAET+L,EAAO,IAAMrgB,KAAKmF,QAAQiD,IAAIpI,KAAK4mB,kBAAkBC,KAAK,MAAQ,IAAMvS,GAMjF9U,OAAQ,WACN,MAAO2a,IAAMna,KAAMmb,GAAcnb,KADF4hB,GAAQ9c,KAAKgI,UAAW,MAIzD2L,SAAU,SAASgK,GACjB,MAAOziB,MAAKmd,KAAK,SAAS1c,GAAS,MAAO+H,GAAG/H,EAAOgiB,MAGtDvZ,QAAS,WACP,MAAOlJ,MAAK6Y,WAAWD,KAGzBzP,MAAO,SAASoQ,EAAWL,GACzB/L,GAAkBnN,KAAK+C,KACvB,IAAI+jB,IAAc,CAOlB,OANA9mB,MAAKgD,UAAU,SAASmB,EAAGD,EAAGkV,GAC5B,IAAKG,EAAUzU,KAAKoU,EAAS/U,EAAGD,EAAGkV,GAEjC,MADA0N,IAAc,GACP,IAGJA,GAGTlV,OAAQ,SAAS2H,EAAWL,GAC1B,MAAOiB,IAAMna,KAAMsZ,GAActZ,KAAMuZ,EAAWL,GAAS,KAG7D6N,KAAM,SAASxN,EAAWL,EAASjH,GACjC,GAAIxK,GAAQzH,KAAKgnB,UAAUzN,EAAWL,EACtC,OAAOzR,GAAQA,EAAM,GAAKwK,GAG5BzE,QAAS,SAAS2Z,EAAYjO,GAE5B,MADA/L,IAAkBnN,KAAK+C,MAChB/C,KAAKgD,UAAUkW,EAAUiO,EAAWzI,KAAKxF,GAAWiO,IAG7DN,KAAM,SAAS1K,GACbhP,GAAkBnN,KAAK+C,MACvBoZ,MAA0BrZ,KAAdqZ,EAA0B,GAAKA,EAAY,GACvD,IAAIiL,GAAS,GACTC,GAAU,CAKd,OAJArnB,MAAKgD,UAAU,SAASmB,GACtBkjB,EAAWA,GAAU,EAAUD,GAAUjL,EACzCiL,GAAgB,OAANjjB,OAAoBrB,KAANqB,EAAkBA,EAAEyH,WAAa,KAEpDwb,GAGTnhB,KAAM,WACJ,MAAOjG,MAAK6Y,WAAWE,KAGzB3Q,IAAK,SAAS6Q,EAAQC,GACpB,MAAOiB,IAAMna,KAAMgZ,GAAWhZ,KAAMiZ,EAAQC,KAG9CsC,OAAQ,SAAS8L,EAASC,EAAkBrO,GAC1C/L,GAAkBnN,KAAK+C,KACvB,IAAIykB,GACAC,CAcJ,OAbI3a,WAAUrK,OAAS,EACrBglB,GAAW,EAEXD,EAAYD,EAEdvnB,KAAKgD,UAAU,SAASmB,EAAGD,EAAGkV,GACxBqO,GACFA,GAAW,EACXD,EAAYrjB,GAEZqjB,EAAYF,EAAQxiB,KAAKoU,EAASsO,EAAWrjB,EAAGD,EAAGkV,KAGhDoO,GAGTE,YAAa,SAASJ,EAASC,EAAkBrO,GAC/C,GAAIyO,GAAW3nB,KAAKqF,aAAa+B,SACjC,OAAOugB,GAASnM,OAAO3O,MAAM8a,EAAU7a,YAGzC1F,QAAS,WACP,MAAO+S,IAAMna,KAAMqZ,GAAerZ,MAAM,KAG1C8V,MAAO,SAASvS,EAAOC,GACrB,MAAO2W,IAAMna,KAAMoa,GAAapa,KAAMuD,EAAOC,GAAK,KAGpD2Z,KAAM,SAAS5D,EAAWL,GACxB,OAAQlZ,KAAKmJ,MAAM4X,GAAIxH,GAAYL,IAGrCsD,KAAM,SAASF,GACb,MAAOnC,IAAMna,KAAMqc,GAAYrc,KAAMsc,KAGvC1H,OAAQ,WACN,MAAO5U,MAAK6Y,WAAWC,KAMzB8O,QAAS,WACP,MAAO5nB,MAAK8V,MAAM,GAAI,IAGxB+R,QAAS,WACP,WAAqB/kB,KAAd9C,KAAK+C,KAAmC,IAAd/C,KAAK+C,MAAc/C,KAAKmd,KAAK,WAAa,OAAO,KAGpFlP,MAAO,SAASsL,EAAWL,GACzB,MAAOtW,GACL2W,EAAYvZ,KAAKmF,QAAQyM,OAAO2H,EAAWL,GAAWlZ,OAI1D8nB,QAAS,SAASnO,EAAST,GACzB,MAAOQ,IAAe1Z,KAAM2Z,EAAST,IAGvCtQ,OAAQ,SAASga,GACf,MAAO/Z,GAAU7I,KAAM4iB,IAGzBpd,SAAU,WACR,GAAIZ,GAAW5E,IACf,IAAI4E,EAAS2C,OAEX,MAAO,IAAI3B,GAAShB,EAAS2C,OAE/B,IAAIwgB,GAAkBnjB,EAASO,QAAQiD,IAAI0Y,IAAarb,cAExD,OADAsiB,GAAgBziB,aAAe,WAAa,MAAOV,GAASO,SACrD4iB,GAGTC,UAAW,SAASzO,EAAWL,GAC7B,MAAOlZ,MAAK4R,OAAOmP,GAAIxH,GAAYL,IAGrC8N,UAAW,SAASzN,EAAWL,EAASjH,GACtC,GAAIgV,GAAQhV,CAOZ,OANAjS,MAAKgD,UAAU,SAASmB,EAAGD,EAAGkV,GAC5B,GAAIG,EAAUzU,KAAKoU,EAAS/U,EAAGD,EAAGkV,GAEhC,MADA6N,IAAS/iB,EAAGC,IACL,IAGJ8iB,GAGT8C,QAAS,SAASxQ,EAAWL,GAC3B,GAAIzR,GAAQzH,KAAKgnB,UAAUzN,EAAWL,EACtC,OAAOzR,IAASA,EAAM,IAGxBwgB,SAAU,SAAS1O,EAAWL,EAASjH,GACrC,MAAOjS,MAAKqF,aAAa+B,UAAU2f,KAAKxN,EAAWL,EAASjH,IAG9DiV,cAAe,SAAS3N,EAAWL,EAASjH,GAC1C,MAAOjS,MAAKqF,aAAa+B,UAAU4f,UAAUzN,EAAWL,EAASjH,IAGnE+X,YAAa,SAASzQ,EAAWL,GAC/B,MAAOlZ,MAAKqF,aAAa+B,UAAU2iB,QAAQxQ,EAAWL,IAGxDgP,MAAO,WACL,MAAOloB,MAAK+mB,KAAK9jB,IAGnBklB,QAAS,SAASlP,EAAQC,GACxB,MAAOiB,IAAMna,KAAMic,GAAejc,KAAMiZ,EAAQC,KAGlDqC,QAAS,SAASI,GAChB,MAAOxB,IAAMna,KAAM0b,GAAe1b,KAAM2b,GAAO,KAGjDrW,aAAc,WACZ,MAAO,IAAI8S,IAAoBpY,OAGjC0J,IAAK,SAAS0e,EAAWnW,GACvB,MAAOjS,MAAK+mB,KAAK,SAASzd,EAAGpB,GAAO,MAAOM,GAAGN,EAAKkgB,QAAatlB,GAAWmP,IAG7EoW,MAAO,SAASC,EAAerW,GAM7B,IALA,GAII1H,GAJAge,EAASvoB,KAGT6C,EAAO0a,GAAc+K,KAEhB/d,EAAO1H,EAAKkB,QAAQM,MAAM,CACjC,GAAI6D,GAAMqC,EAAK9J,KAEf,KADA8nB,EAASA,GAAUA,EAAO7e,IAAM6e,EAAO7e,IAAIxB,EAAKyB,IAAWA,MAC5CA,GACb,MAAOsI,GAGX,MAAOsW,IAGTC,QAAS,SAAS7O,EAAST,GACzB,MAAOa,IAAe/Z,KAAM2Z,EAAST,IAGvCzP,IAAK,SAAS2e,GACZ,MAAOpoB,MAAK0J,IAAI0e,EAAWze,MAAaA,IAG1C8e,MAAO,SAASH,GACd,MAAOtoB,MAAKqoB,MAAMC,EAAe3e,MAAaA,IAGhD+e,SAAU,SAAS7lB,GAEjB,MADAA,GAAgC,kBAAlBA,GAAK4V,SAA0B5V,EAAOrC,EAASqC,GACtD7C,KAAKmJ,MAAM,SAAS1I,GAAS,MAAOoC,GAAK4V,SAAShY,MAG3DkoB,WAAY,SAAS9lB,GAEnB,MADAA,GAAgC,kBAAlBA,GAAK6lB,SAA0B7lB,EAAOrC,EAASqC,GACtDA,EAAK6lB,SAAS1oB,OAGvBiqB,MAAO,SAASxH,GACd,MAAOziB,MAAK+pB,QAAQ,SAAStpB,GAAS,MAAO+H,GAAG/H,EAAOgiB,MAGzDoD,OAAQ,WACN,MAAO7lB,MAAKmF,QAAQiD,IAAIyY,IAAWpb,gBAGrCmjB,KAAM,WACJ,MAAO5oB,MAAKmF,QAAQiC,UAAU8gB,SAGhCgC,UAAW,SAASzH,GAClB,MAAOziB,MAAKqF,aAAa+B,UAAU6iB,MAAMxH,IAG3CjgB,IAAK,SAAS8Z,GACZ,MAAOG,IAAWzc,KAAMsc,IAG1BuM,MAAO,SAAS5P,EAAQqD,GACtB,MAAOG,IAAWzc,KAAMsc,EAAYrD,IAGtCpV,IAAK,SAASyY,GACZ,MAAOG,IAAWzc,KAAMsc,EAAa0E,GAAI1E,GAAc+E,KAGzDyH,MAAO,SAAS7P,EAAQqD,GACtB,MAAOG,IAAWzc,KAAMsc,EAAa0E,GAAI1E,GAAc+E,GAAsBpI,IAG/E8P,KAAM,WACJ,MAAO/oB,MAAK8V,MAAM,IAGpBkT,KAAM,SAASC,GACb,MAAOjpB,MAAK8V,MAAMvT,KAAKC,IAAI,EAAGymB,KAGhCC,SAAU,SAASD,GACjB,MAAO9O,IAAMna,KAAMA,KAAKmF,QAAQiC,UAAU4hB,KAAKC,GAAQ7hB,YAGzD+hB,UAAW,SAAS5P,EAAWL,GAC7B,MAAOiB,IAAMna,KAAMgb,GAAiBhb,KAAMuZ,EAAWL,GAAS,KAGhEkQ,UAAW,SAAS7P,EAAWL,GAC7B,MAAOlZ,MAAKmpB,UAAUpI,GAAIxH,GAAYL,IAGxCyK,OAAQ,SAAS1K,EAAQqD,GACvB,MAAOnC,IAAMna,KAAMqc,GAAYrc,KAAMsc,EAAYrD,KAGnDoQ,KAAM,SAASJ,GACb,MAAOjpB,MAAK8V,MAAM,EAAGvT,KAAKC,IAAI,EAAGymB,KAGnCK,SAAU,SAASL,GACjB,MAAO9O,IAAMna,KAAMA,KAAKmF,QAAQiC,UAAUiiB,KAAKJ,GAAQ7hB,YAGzDmiB,UAAW,SAAShQ,EAAWL,GAC7B,MAAOiB,IAAMna,KAAM6a,GAAiB7a,KAAMuZ,EAAWL,KAGvDsQ,UAAW,SAASjQ,EAAWL,GAC7B,MAAOlZ,MAAKupB,UAAUxI,GAAIxH,GAAYL,IAGxCsM,SAAU,WACR,MAAOxlB,MAAKyF,gBAMdiG,SAAU,WACR,MAAO1L,MAAKgJ,SAAWhJ,KAAKgJ,OAASsY,GAAathB,SAgBtD,IAAIypB,IAAoBjpB,EAASJ,SACjCqpB,IAAkBnoB,KAAwB,EAC1CmoB,GAAkBzH,IAAmByH,GAAkB7U,OACvD6U,GAAkBpD,OAASoD,GAAkB/V,QAC7C+V,GAAkB7C,iBAAmB3F,GACrCwI,GAAkBrH,QAClBqH,GAAkBpH,SAAW,WAAa,MAAOriB,MAAK4L,YACtD6d,GAAkBC,MAAQD,GAAkBtB,QAC5CsB,GAAkBE,SAAWF,GAAkBhR,SAE/CgI,GAAM7f,GAIJiX,KAAM,WACJ,MAAOsC,IAAMna,KAAMqY,GAAYrY,QAGjCmqB,WAAY,SAASlR,EAAQC,GAAU,GAAIP,GAAS3Y,KAC9CyZ,EAAa,CACjB,OAAOU,IAAMna,KACXA,KAAKmF,QAAQiD,IACX,SAASjE,EAAGD,GAAK,MAAO+U,GAAOnU,KAAKoU,GAAUhV,EAAGC,GAAIsV,IAAcd,KACnErT,iBAIN8kB,QAAS,SAASnR,EAAQC,GAAU,GAAIP,GAAS3Y,IAC/C,OAAOma,IAAMna,KACXA,KAAKmF,QAAQ0S,OAAOzP,IAClB,SAASlE,EAAGC,GAAK,MAAO8U,GAAOnU,KAAKoU,EAAShV,EAAGC,EAAGwU,KACnDd,UAMR,IAAIwS,IAAyBzpB,EAAcR,SA2Q3C,OA1QAiqB,IAAuB7oB,KAAqB,EAC5C6oB,GAAuBrI,IAAmByH,GAAkBvgB,QAC5DmhB,GAAuBhE,OAASoD,GAAkBlD,SAClD8D,GAAuBzD,iBAAmB,SAASziB,EAAGD,GAAK,MAAOgd,MAAKC,UAAUjd,GAAK,KAAO+c,GAAY9c,IAIzGsc,GAAM1f,GAIJsE,WAAY,WACV,MAAO,IAAIyS,IAAgB9X,MAAM,IAMnC4R,OAAQ,SAAS2H,EAAWL,GAC1B,MAAOiB,IAAMna,KAAMsZ,GAActZ,KAAMuZ,EAAWL,GAAS,KAG7DoR,UAAW,SAAS/Q,EAAWL,GAC7B,GAAIzR,GAAQzH,KAAKgnB,UAAUzN,EAAWL,EACtC,OAAOzR,GAAQA,EAAM,IAAM,GAG7Bib,QAAS,SAASD,GAChB,GAAIva,GAAMlI,KAAKiqB,MAAMxH,EACrB,YAAe3f,KAARoF,GAAqB,EAAIA,GAGlCya,YAAa,SAASF,GACpB,GAAIva,GAAMlI,KAAKkqB,UAAUzH,EACzB,YAAe3f,KAARoF,GAAqB,EAAIA,GAGlCd,QAAS,WACP,MAAO+S,IAAMna,KAAMqZ,GAAerZ,MAAM,KAG1C8V,MAAO,SAASvS,EAAOC,GACrB,MAAO2W,IAAMna,KAAMoa,GAAapa,KAAMuD,EAAOC,GAAK,KAGpDshB,OAAQ,SAAS3hB,EAAOonB,GACtB,GAAIC,GAAU1d,UAAUrK,MAExB,IADA8nB,EAAYhoB,KAAKC,IAAgB,EAAZ+nB,EAAe,GACpB,IAAZC,GAA8B,IAAZA,IAAkBD,EACtC,MAAOvqB,KAKTmD,GAAQM,EAAaN,EAAOA,EAAQ,EAAInD,KAAKiO,QAAUjO,KAAK+C,KAC5D,IAAI0nB,GAAUzqB,KAAK8V,MAAM,EAAG3S,EAC5B,OAAOgX,IACLna,KACY,IAAZwqB,EACEC,EACAA,EAAQjrB,OAAO2C,EAAQ2K,UAAW,GAAI9M,KAAK8V,MAAM3S,EAAQonB,MAO/DG,cAAe,SAASnR,EAAWL,GACjC,GAAIzR,GAAQzH,KAAKknB,cAAc3N,EAAWL,EAC1C,OAAOzR,GAAQA,EAAM,IAAM,GAG7BygB,MAAO,WACL,MAAOloB,MAAK0J,IAAI,IAGlB6R,QAAS,SAASI,GAChB,MAAOxB,IAAMna,KAAM0b,GAAe1b,KAAM2b,GAAO,KAGjDjS,IAAK,SAASvG,EAAO8O,GAEnB,MADA9O,GAAQD,EAAUlD,KAAMmD,GAChBA,EAAQ,GAAMnD,KAAK+C,OAASgH,SACjBjH,KAAd9C,KAAK+C,MAAsBI,EAAQnD,KAAK+C,KAC3CkP,EACAjS,KAAK+mB,KAAK,SAASzd,EAAGpB,GAAO,MAAOA,KAAQ/E,OAAQL,GAAWmP,IAGnExI,IAAK,SAAStG,GAEZ,OADAA,EAAQD,EAAUlD,KAAMmD,KACR,QAAoBL,KAAd9C,KAAK+C,KACzB/C,KAAK+C,OAASgH,KAAY5G,EAAQnD,KAAK+C,MACd,IAAzB/C,KAAK0iB,QAAQvf,KAIjBwnB,UAAW,SAASxO,GAClB,MAAOhC,IAAMna,KAAMkc,GAAiBlc,KAAMmc,KAG5CyO,WAAY,WACV,GAAI3Z,IAAajR,MAAMR,OAAO2C,EAAQ2K,YAClC+d,EAASjO,GAAe5c,KAAKmF,QAASlE,EAAWqhB,GAAIrR,GACrD6Z,EAAcD,EAAOtP,SAAQ,EAIjC,OAHIsP,GAAO9nB,OACT+nB,EAAY/nB,KAAO8nB,EAAO9nB,KAAOkO,EAAUxO,QAEtC0X,GAAMna,KAAM8qB,IAGrBjF,OAAQ,WACN,MAAOxb,GAAM,EAAGrK,KAAK+C,OAGvB6lB,KAAM,WACJ,MAAO5oB,MAAK0J,KAAK,IAGnByf,UAAW,SAAS5P,EAAWL,GAC7B,MAAOiB,IAAMna,KAAMgb,GAAiBhb,KAAMuZ,EAAWL,GAAS,KAGhE6R,IAAK,WAEH,MAAO5Q,IAAMna,KAAM4c,GAAe5c,KAAMohB,IADvBphB,MAAMR,OAAO2C,EAAQ2K,eAIxCke,QAAS,SAASlO,GAChB,GAAI7L,GAAY9O,EAAQ2K,UAExB,OADAmE,GAAU,GAAKjR,KACRma,GAAMna,KAAM4c,GAAe5c,KAAM8c,EAAQ7L,OAKpDlQ,EAAgBX,UAAUsB,KAAuB,EACjDX,EAAgBX,UAAU0B,KAAuB,EAIjD2e,GAAMvf,GAIJwI,IAAK,SAASjJ,EAAOwR,GACnB,MAAOjS,MAAKyJ,IAAIhJ,GAASA,EAAQwR,GAGnCwG,SAAU,SAAShY,GACjB,MAAOT,MAAKyJ,IAAIhJ,IAMlBolB,OAAQ,WACN,MAAO7lB,MAAKwlB,cAKhBtkB,EAAYd,UAAUqJ,IAAMggB,GAAkBhR,SAC9CvX,EAAYd,UAAUupB,SAAWzoB,EAAYd,UAAUqY,SAKvDgI,GAAM3f,EAAUF,EAAcR,WAC9BqgB,GAAMxf,EAAYF,EAAgBX,WAClCqgB,GAAMrf,EAAQF,EAAYd,WAE1BqgB,GAAM1V,GAAiBnK,EAAcR,WACrCqgB,GAAMzV,GAAmBjK,EAAgBX,WACzCqgB,GAAMxV,GAAe/J,EAAYd,YAyE/BI,SAAUA,EAEVG,IAAKA,EACLmK,WAAYA,GACZsC,IAAKA,GACL6J,WAAYA,GACZ7D,KAAMA,GACN0M,MAAOA,GACPnB,IAAKA,GACLY,WAAYA,GAEZ9B,OAAQA,GACRpT,MAAOA,EACPT,OAAQA,EAERpB,GAAIA,EACJX,OAAQA,MnEggXN,SAAUpI,EAAQC,EAAqBC,GAE7C,YoEh2gBA,SAASmmD,GAAT,GAA8C,GAAnBC,GAAmB,EAAnBA,MAAOtT,EAAY,EAAZA,SAC1BuT,EAAoB,SAAA/iC,GAExB,GADAA,EAAEwhC,iBACGhS,EAAL,CACA,GAAMwT,GAAK3c,SAAS4c,cAAT,IAA2BzT,EAClCwT,IACFA,EAAGE,gBACDC,SAAU,SACV95B,MAAO,QACP+5B,OAAQ,aAId,OAAKN,OAEYjjD,KAAb2vC,EAEA,yBAAKvU,UAAWgE,IAAOokB,WAErB,uBAAGC,KAAK,aAAavF,KAAA,IAAUvO,EAAY+T,QAASR,GAClD,0BAAM9nB,UAAWgE,IAAO6jB,OAAQA,KAOtC,6BAEE,0BAAM7nB,UAAWgE,IAAO6jB,OAAQA,IAhBjB,KAzBrB,qCA8CAD,GAAgBrjB,YAAc,kBAE9BqjB,EAAgBxjB,aAtCK,KAwCNwjB,OpE03gBN,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,CACA,C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","file":"static/scripts/2-8d5f19f821570cc42ca9.js","sourcesContent":["webpackJsonp([2],Array(52).concat([\n/* 52 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"ONLY_SERVER\", function() { return ONLY_SERVER; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__ProposalEditor_js__ = __webpack_require__(421);\n/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, \"default\", function() { return __WEBPACK_IMPORTED_MODULE_0__ProposalEditor_js__[\"a\"]; });\n\n\n/**\n * Should the component only render server side?\n * You can set this to true if the component is a pure static component.\n */\nvar ONLY_SERVER = false;\n\n/***/ }),\n/* 53 */,\n/* 54 */,\n/* 55 */,\n/* 56 */,\n/* 57 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n *  Copyright (c) 2014-2015, Facebook, Inc.\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n\n(function (global, factory) {\n   true ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  global.Immutable = factory();\n}(this, function () { 'use strict';var SLICE$0 = Array.prototype.slice;\n\n  function createClass(ctor, superClass) {\n    if (superClass) {\n      ctor.prototype = Object.create(superClass.prototype);\n    }\n    ctor.prototype.constructor = ctor;\n  }\n\n  function Iterable(value) {\n      return isIterable(value) ? value : Seq(value);\n    }\n\n\n  createClass(KeyedIterable, Iterable);\n    function KeyedIterable(value) {\n      return isKeyed(value) ? value : KeyedSeq(value);\n    }\n\n\n  createClass(IndexedIterable, Iterable);\n    function IndexedIterable(value) {\n      return isIndexed(value) ? value : IndexedSeq(value);\n    }\n\n\n  createClass(SetIterable, Iterable);\n    function SetIterable(value) {\n      return isIterable(value) && !isAssociative(value) ? value : SetSeq(value);\n    }\n\n\n\n  function isIterable(maybeIterable) {\n    return !!(maybeIterable && maybeIterable[IS_ITERABLE_SENTINEL]);\n  }\n\n  function isKeyed(maybeKeyed) {\n    return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL]);\n  }\n\n  function isIndexed(maybeIndexed) {\n    return !!(maybeIndexed && maybeIndexed[IS_INDEXED_SENTINEL]);\n  }\n\n  function isAssociative(maybeAssociative) {\n    return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);\n  }\n\n  function isOrdered(maybeOrdered) {\n    return !!(maybeOrdered && maybeOrdered[IS_ORDERED_SENTINEL]);\n  }\n\n  Iterable.isIterable = isIterable;\n  Iterable.isKeyed = isKeyed;\n  Iterable.isIndexed = isIndexed;\n  Iterable.isAssociative = isAssociative;\n  Iterable.isOrdered = isOrdered;\n\n  Iterable.Keyed = KeyedIterable;\n  Iterable.Indexed = IndexedIterable;\n  Iterable.Set = SetIterable;\n\n\n  var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';\n  var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';\n  var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';\n  var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';\n\n  // Used for setting prototype methods that IE8 chokes on.\n  var DELETE = 'delete';\n\n  // Constants describing the size of trie nodes.\n  var SHIFT = 5; // Resulted in best performance after ______?\n  var SIZE = 1 << SHIFT;\n  var MASK = SIZE - 1;\n\n  // A consistent shared value representing \"not set\" which equals nothing other\n  // than itself, and nothing that could be provided externally.\n  var NOT_SET = {};\n\n  // Boolean references, Rough equivalent of `bool &`.\n  var CHANGE_LENGTH = { value: false };\n  var DID_ALTER = { value: false };\n\n  function MakeRef(ref) {\n    ref.value = false;\n    return ref;\n  }\n\n  function SetRef(ref) {\n    ref && (ref.value = true);\n  }\n\n  // A function which returns a value representing an \"owner\" for transient writes\n  // to tries. The return value will only ever equal itself, and will not equal\n  // the return of any subsequent call of this function.\n  function OwnerID() {}\n\n  // http://jsperf.com/copy-array-inline\n  function arrCopy(arr, offset) {\n    offset = offset || 0;\n    var len = Math.max(0, arr.length - offset);\n    var newArr = new Array(len);\n    for (var ii = 0; ii < len; ii++) {\n      newArr[ii] = arr[ii + offset];\n    }\n    return newArr;\n  }\n\n  function ensureSize(iter) {\n    if (iter.size === undefined) {\n      iter.size = iter.__iterate(returnTrue);\n    }\n    return iter.size;\n  }\n\n  function wrapIndex(iter, index) {\n    // This implements \"is array index\" which the ECMAString spec defines as:\n    //\n    //     A String property name P is an array index if and only if\n    //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal\n    //     to 2^32−1.\n    //\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects\n    if (typeof index !== 'number') {\n      var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32\n      if ('' + uint32Index !== index || uint32Index === 4294967295) {\n        return NaN;\n      }\n      index = uint32Index;\n    }\n    return index < 0 ? ensureSize(iter) + index : index;\n  }\n\n  function returnTrue() {\n    return true;\n  }\n\n  function wholeSlice(begin, end, size) {\n    return (begin === 0 || (size !== undefined && begin <= -size)) &&\n      (end === undefined || (size !== undefined && end >= size));\n  }\n\n  function resolveBegin(begin, size) {\n    return resolveIndex(begin, size, 0);\n  }\n\n  function resolveEnd(end, size) {\n    return resolveIndex(end, size, size);\n  }\n\n  function resolveIndex(index, size, defaultIndex) {\n    return index === undefined ?\n      defaultIndex :\n      index < 0 ?\n        Math.max(0, size + index) :\n        size === undefined ?\n          index :\n          Math.min(size, index);\n  }\n\n  /* global Symbol */\n\n  var ITERATE_KEYS = 0;\n  var ITERATE_VALUES = 1;\n  var ITERATE_ENTRIES = 2;\n\n  var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n  var FAUX_ITERATOR_SYMBOL = '@@iterator';\n\n  var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;\n\n\n  function Iterator(next) {\n      this.next = next;\n    }\n\n    Iterator.prototype.toString = function() {\n      return '[Iterator]';\n    };\n\n\n  Iterator.KEYS = ITERATE_KEYS;\n  Iterator.VALUES = ITERATE_VALUES;\n  Iterator.ENTRIES = ITERATE_ENTRIES;\n\n  Iterator.prototype.inspect =\n  Iterator.prototype.toSource = function () { return this.toString(); }\n  Iterator.prototype[ITERATOR_SYMBOL] = function () {\n    return this;\n  };\n\n\n  function iteratorValue(type, k, v, iteratorResult) {\n    var value = type === 0 ? k : type === 1 ? v : [k, v];\n    iteratorResult ? (iteratorResult.value = value) : (iteratorResult = {\n      value: value, done: false\n    });\n    return iteratorResult;\n  }\n\n  function iteratorDone() {\n    return { value: undefined, done: true };\n  }\n\n  function hasIterator(maybeIterable) {\n    return !!getIteratorFn(maybeIterable);\n  }\n\n  function isIterator(maybeIterator) {\n    return maybeIterator && typeof maybeIterator.next === 'function';\n  }\n\n  function getIterator(iterable) {\n    var iteratorFn = getIteratorFn(iterable);\n    return iteratorFn && iteratorFn.call(iterable);\n  }\n\n  function getIteratorFn(iterable) {\n    var iteratorFn = iterable && (\n      (REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||\n      iterable[FAUX_ITERATOR_SYMBOL]\n    );\n    if (typeof iteratorFn === 'function') {\n      return iteratorFn;\n    }\n  }\n\n  function isArrayLike(value) {\n    return value && typeof value.length === 'number';\n  }\n\n  createClass(Seq, Iterable);\n    function Seq(value) {\n      return value === null || value === undefined ? emptySequence() :\n        isIterable(value) ? value.toSeq() : seqFromValue(value);\n    }\n\n    Seq.of = function(/*...values*/) {\n      return Seq(arguments);\n    };\n\n    Seq.prototype.toSeq = function() {\n      return this;\n    };\n\n    Seq.prototype.toString = function() {\n      return this.__toString('Seq {', '}');\n    };\n\n    Seq.prototype.cacheResult = function() {\n      if (!this._cache && this.__iterateUncached) {\n        this._cache = this.entrySeq().toArray();\n        this.size = this._cache.length;\n      }\n      return this;\n    };\n\n    // abstract __iterateUncached(fn, reverse)\n\n    Seq.prototype.__iterate = function(fn, reverse) {\n      return seqIterate(this, fn, reverse, true);\n    };\n\n    // abstract __iteratorUncached(type, reverse)\n\n    Seq.prototype.__iterator = function(type, reverse) {\n      return seqIterator(this, type, reverse, true);\n    };\n\n\n\n  createClass(KeyedSeq, Seq);\n    function KeyedSeq(value) {\n      return value === null || value === undefined ?\n        emptySequence().toKeyedSeq() :\n        isIterable(value) ?\n          (isKeyed(value) ? value.toSeq() : value.fromEntrySeq()) :\n          keyedSeqFromValue(value);\n    }\n\n    KeyedSeq.prototype.toKeyedSeq = function() {\n      return this;\n    };\n\n\n\n  createClass(IndexedSeq, Seq);\n    function IndexedSeq(value) {\n      return value === null || value === undefined ? emptySequence() :\n        !isIterable(value) ? indexedSeqFromValue(value) :\n        isKeyed(value) ? value.entrySeq() : value.toIndexedSeq();\n    }\n\n    IndexedSeq.of = function(/*...values*/) {\n      return IndexedSeq(arguments);\n    };\n\n    IndexedSeq.prototype.toIndexedSeq = function() {\n      return this;\n    };\n\n    IndexedSeq.prototype.toString = function() {\n      return this.__toString('Seq [', ']');\n    };\n\n    IndexedSeq.prototype.__iterate = function(fn, reverse) {\n      return seqIterate(this, fn, reverse, false);\n    };\n\n    IndexedSeq.prototype.__iterator = function(type, reverse) {\n      return seqIterator(this, type, reverse, false);\n    };\n\n\n\n  createClass(SetSeq, Seq);\n    function SetSeq(value) {\n      return (\n        value === null || value === undefined ? emptySequence() :\n        !isIterable(value) ? indexedSeqFromValue(value) :\n        isKeyed(value) ? value.entrySeq() : value\n      ).toSetSeq();\n    }\n\n    SetSeq.of = function(/*...values*/) {\n      return SetSeq(arguments);\n    };\n\n    SetSeq.prototype.toSetSeq = function() {\n      return this;\n    };\n\n\n\n  Seq.isSeq = isSeq;\n  Seq.Keyed = KeyedSeq;\n  Seq.Set = SetSeq;\n  Seq.Indexed = IndexedSeq;\n\n  var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';\n\n  Seq.prototype[IS_SEQ_SENTINEL] = true;\n\n\n\n  createClass(ArraySeq, IndexedSeq);\n    function ArraySeq(array) {\n      this._array = array;\n      this.size = array.length;\n    }\n\n    ArraySeq.prototype.get = function(index, notSetValue) {\n      return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue;\n    };\n\n    ArraySeq.prototype.__iterate = function(fn, reverse) {\n      var array = this._array;\n      var maxIndex = array.length - 1;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        if (fn(array[reverse ? maxIndex - ii : ii], ii, this) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    };\n\n    ArraySeq.prototype.__iterator = function(type, reverse) {\n      var array = this._array;\n      var maxIndex = array.length - 1;\n      var ii = 0;\n      return new Iterator(function() \n        {return ii > maxIndex ?\n          iteratorDone() :\n          iteratorValue(type, ii, array[reverse ? maxIndex - ii++ : ii++])}\n      );\n    };\n\n\n\n  createClass(ObjectSeq, KeyedSeq);\n    function ObjectSeq(object) {\n      var keys = Object.keys(object);\n      this._object = object;\n      this._keys = keys;\n      this.size = keys.length;\n    }\n\n    ObjectSeq.prototype.get = function(key, notSetValue) {\n      if (notSetValue !== undefined && !this.has(key)) {\n        return notSetValue;\n      }\n      return this._object[key];\n    };\n\n    ObjectSeq.prototype.has = function(key) {\n      return this._object.hasOwnProperty(key);\n    };\n\n    ObjectSeq.prototype.__iterate = function(fn, reverse) {\n      var object = this._object;\n      var keys = this._keys;\n      var maxIndex = keys.length - 1;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        var key = keys[reverse ? maxIndex - ii : ii];\n        if (fn(object[key], key, this) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    };\n\n    ObjectSeq.prototype.__iterator = function(type, reverse) {\n      var object = this._object;\n      var keys = this._keys;\n      var maxIndex = keys.length - 1;\n      var ii = 0;\n      return new Iterator(function()  {\n        var key = keys[reverse ? maxIndex - ii : ii];\n        return ii++ > maxIndex ?\n          iteratorDone() :\n          iteratorValue(type, key, object[key]);\n      });\n    };\n\n  ObjectSeq.prototype[IS_ORDERED_SENTINEL] = true;\n\n\n  createClass(IterableSeq, IndexedSeq);\n    function IterableSeq(iterable) {\n      this._iterable = iterable;\n      this.size = iterable.length || iterable.size;\n    }\n\n    IterableSeq.prototype.__iterateUncached = function(fn, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterable = this._iterable;\n      var iterator = getIterator(iterable);\n      var iterations = 0;\n      if (isIterator(iterator)) {\n        var step;\n        while (!(step = iterator.next()).done) {\n          if (fn(step.value, iterations++, this) === false) {\n            break;\n          }\n        }\n      }\n      return iterations;\n    };\n\n    IterableSeq.prototype.__iteratorUncached = function(type, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterable = this._iterable;\n      var iterator = getIterator(iterable);\n      if (!isIterator(iterator)) {\n        return new Iterator(iteratorDone);\n      }\n      var iterations = 0;\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step : iteratorValue(type, iterations++, step.value);\n      });\n    };\n\n\n\n  createClass(IteratorSeq, IndexedSeq);\n    function IteratorSeq(iterator) {\n      this._iterator = iterator;\n      this._iteratorCache = [];\n    }\n\n    IteratorSeq.prototype.__iterateUncached = function(fn, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterator = this._iterator;\n      var cache = this._iteratorCache;\n      var iterations = 0;\n      while (iterations < cache.length) {\n        if (fn(cache[iterations], iterations++, this) === false) {\n          return iterations;\n        }\n      }\n      var step;\n      while (!(step = iterator.next()).done) {\n        var val = step.value;\n        cache[iterations] = val;\n        if (fn(val, iterations++, this) === false) {\n          break;\n        }\n      }\n      return iterations;\n    };\n\n    IteratorSeq.prototype.__iteratorUncached = function(type, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = this._iterator;\n      var cache = this._iteratorCache;\n      var iterations = 0;\n      return new Iterator(function()  {\n        if (iterations >= cache.length) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          cache[iterations] = step.value;\n        }\n        return iteratorValue(type, iterations, cache[iterations++]);\n      });\n    };\n\n\n\n\n  // # pragma Helper functions\n\n  function isSeq(maybeSeq) {\n    return !!(maybeSeq && maybeSeq[IS_SEQ_SENTINEL]);\n  }\n\n  var EMPTY_SEQ;\n\n  function emptySequence() {\n    return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));\n  }\n\n  function keyedSeqFromValue(value) {\n    var seq =\n      Array.isArray(value) ? new ArraySeq(value).fromEntrySeq() :\n      isIterator(value) ? new IteratorSeq(value).fromEntrySeq() :\n      hasIterator(value) ? new IterableSeq(value).fromEntrySeq() :\n      typeof value === 'object' ? new ObjectSeq(value) :\n      undefined;\n    if (!seq) {\n      throw new TypeError(\n        'Expected Array or iterable object of [k, v] entries, '+\n        'or keyed object: ' + value\n      );\n    }\n    return seq;\n  }\n\n  function indexedSeqFromValue(value) {\n    var seq = maybeIndexedSeqFromValue(value);\n    if (!seq) {\n      throw new TypeError(\n        'Expected Array or iterable object of values: ' + value\n      );\n    }\n    return seq;\n  }\n\n  function seqFromValue(value) {\n    var seq = maybeIndexedSeqFromValue(value) ||\n      (typeof value === 'object' && new ObjectSeq(value));\n    if (!seq) {\n      throw new TypeError(\n        'Expected Array or iterable object of values, or keyed object: ' + value\n      );\n    }\n    return seq;\n  }\n\n  function maybeIndexedSeqFromValue(value) {\n    return (\n      isArrayLike(value) ? new ArraySeq(value) :\n      isIterator(value) ? new IteratorSeq(value) :\n      hasIterator(value) ? new IterableSeq(value) :\n      undefined\n    );\n  }\n\n  function seqIterate(seq, fn, reverse, useKeys) {\n    var cache = seq._cache;\n    if (cache) {\n      var maxIndex = cache.length - 1;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        var entry = cache[reverse ? maxIndex - ii : ii];\n        if (fn(entry[1], useKeys ? entry[0] : ii, seq) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    }\n    return seq.__iterateUncached(fn, reverse);\n  }\n\n  function seqIterator(seq, type, reverse, useKeys) {\n    var cache = seq._cache;\n    if (cache) {\n      var maxIndex = cache.length - 1;\n      var ii = 0;\n      return new Iterator(function()  {\n        var entry = cache[reverse ? maxIndex - ii : ii];\n        return ii++ > maxIndex ?\n          iteratorDone() :\n          iteratorValue(type, useKeys ? entry[0] : ii - 1, entry[1]);\n      });\n    }\n    return seq.__iteratorUncached(type, reverse);\n  }\n\n  function fromJS(json, converter) {\n    return converter ?\n      fromJSWith(converter, json, '', {'': json}) :\n      fromJSDefault(json);\n  }\n\n  function fromJSWith(converter, json, key, parentJSON) {\n    if (Array.isArray(json)) {\n      return converter.call(parentJSON, key, IndexedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));\n    }\n    if (isPlainObj(json)) {\n      return converter.call(parentJSON, key, KeyedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));\n    }\n    return json;\n  }\n\n  function fromJSDefault(json) {\n    if (Array.isArray(json)) {\n      return IndexedSeq(json).map(fromJSDefault).toList();\n    }\n    if (isPlainObj(json)) {\n      return KeyedSeq(json).map(fromJSDefault).toMap();\n    }\n    return json;\n  }\n\n  function isPlainObj(value) {\n    return value && (value.constructor === Object || value.constructor === undefined);\n  }\n\n  /**\n   * An extension of the \"same-value\" algorithm as [described for use by ES6 Map\n   * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)\n   *\n   * NaN is considered the same as NaN, however -0 and 0 are considered the same\n   * value, which is different from the algorithm described by\n   * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).\n   *\n   * This is extended further to allow Objects to describe the values they\n   * represent, by way of `valueOf` or `equals` (and `hashCode`).\n   *\n   * Note: because of this extension, the key equality of Immutable.Map and the\n   * value equality of Immutable.Set will differ from ES6 Map and Set.\n   *\n   * ### Defining custom values\n   *\n   * The easiest way to describe the value an object represents is by implementing\n   * `valueOf`. For example, `Date` represents a value by returning a unix\n   * timestamp for `valueOf`:\n   *\n   *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...\n   *     var date2 = new Date(1234567890000);\n   *     date1.valueOf(); // 1234567890000\n   *     assert( date1 !== date2 );\n   *     assert( Immutable.is( date1, date2 ) );\n   *\n   * Note: overriding `valueOf` may have other implications if you use this object\n   * where JavaScript expects a primitive, such as implicit string coercion.\n   *\n   * For more complex types, especially collections, implementing `valueOf` may\n   * not be performant. An alternative is to implement `equals` and `hashCode`.\n   *\n   * `equals` takes another object, presumably of similar type, and returns true\n   * if the it is equal. Equality is symmetrical, so the same result should be\n   * returned if this and the argument are flipped.\n   *\n   *     assert( a.equals(b) === b.equals(a) );\n   *\n   * `hashCode` returns a 32bit integer number representing the object which will\n   * be used to determine how to store the value object in a Map or Set. You must\n   * provide both or neither methods, one must not exist without the other.\n   *\n   * Also, an important relationship between these methods must be upheld: if two\n   * values are equal, they *must* return the same hashCode. If the values are not\n   * equal, they might have the same hashCode; this is called a hash collision,\n   * and while undesirable for performance reasons, it is acceptable.\n   *\n   *     if (a.equals(b)) {\n   *       assert( a.hashCode() === b.hashCode() );\n   *     }\n   *\n   * All Immutable collections implement `equals` and `hashCode`.\n   *\n   */\n  function is(valueA, valueB) {\n    if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n      return true;\n    }\n    if (!valueA || !valueB) {\n      return false;\n    }\n    if (typeof valueA.valueOf === 'function' &&\n        typeof valueB.valueOf === 'function') {\n      valueA = valueA.valueOf();\n      valueB = valueB.valueOf();\n      if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n        return true;\n      }\n      if (!valueA || !valueB) {\n        return false;\n      }\n    }\n    if (typeof valueA.equals === 'function' &&\n        typeof valueB.equals === 'function' &&\n        valueA.equals(valueB)) {\n      return true;\n    }\n    return false;\n  }\n\n  function deepEqual(a, b) {\n    if (a === b) {\n      return true;\n    }\n\n    if (\n      !isIterable(b) ||\n      a.size !== undefined && b.size !== undefined && a.size !== b.size ||\n      a.__hash !== undefined && b.__hash !== undefined && a.__hash !== b.__hash ||\n      isKeyed(a) !== isKeyed(b) ||\n      isIndexed(a) !== isIndexed(b) ||\n      isOrdered(a) !== isOrdered(b)\n    ) {\n      return false;\n    }\n\n    if (a.size === 0 && b.size === 0) {\n      return true;\n    }\n\n    var notAssociative = !isAssociative(a);\n\n    if (isOrdered(a)) {\n      var entries = a.entries();\n      return b.every(function(v, k)  {\n        var entry = entries.next().value;\n        return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));\n      }) && entries.next().done;\n    }\n\n    var flipped = false;\n\n    if (a.size === undefined) {\n      if (b.size === undefined) {\n        if (typeof a.cacheResult === 'function') {\n          a.cacheResult();\n        }\n      } else {\n        flipped = true;\n        var _ = a;\n        a = b;\n        b = _;\n      }\n    }\n\n    var allEqual = true;\n    var bSize = b.__iterate(function(v, k)  {\n      if (notAssociative ? !a.has(v) :\n          flipped ? !is(v, a.get(k, NOT_SET)) : !is(a.get(k, NOT_SET), v)) {\n        allEqual = false;\n        return false;\n      }\n    });\n\n    return allEqual && a.size === bSize;\n  }\n\n  createClass(Repeat, IndexedSeq);\n\n    function Repeat(value, times) {\n      if (!(this instanceof Repeat)) {\n        return new Repeat(value, times);\n      }\n      this._value = value;\n      this.size = times === undefined ? Infinity : Math.max(0, times);\n      if (this.size === 0) {\n        if (EMPTY_REPEAT) {\n          return EMPTY_REPEAT;\n        }\n        EMPTY_REPEAT = this;\n      }\n    }\n\n    Repeat.prototype.toString = function() {\n      if (this.size === 0) {\n        return 'Repeat []';\n      }\n      return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]';\n    };\n\n    Repeat.prototype.get = function(index, notSetValue) {\n      return this.has(index) ? this._value : notSetValue;\n    };\n\n    Repeat.prototype.includes = function(searchValue) {\n      return is(this._value, searchValue);\n    };\n\n    Repeat.prototype.slice = function(begin, end) {\n      var size = this.size;\n      return wholeSlice(begin, end, size) ? this :\n        new Repeat(this._value, resolveEnd(end, size) - resolveBegin(begin, size));\n    };\n\n    Repeat.prototype.reverse = function() {\n      return this;\n    };\n\n    Repeat.prototype.indexOf = function(searchValue) {\n      if (is(this._value, searchValue)) {\n        return 0;\n      }\n      return -1;\n    };\n\n    Repeat.prototype.lastIndexOf = function(searchValue) {\n      if (is(this._value, searchValue)) {\n        return this.size;\n      }\n      return -1;\n    };\n\n    Repeat.prototype.__iterate = function(fn, reverse) {\n      for (var ii = 0; ii < this.size; ii++) {\n        if (fn(this._value, ii, this) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    };\n\n    Repeat.prototype.__iterator = function(type, reverse) {var this$0 = this;\n      var ii = 0;\n      return new Iterator(function() \n        {return ii < this$0.size ? iteratorValue(type, ii++, this$0._value) : iteratorDone()}\n      );\n    };\n\n    Repeat.prototype.equals = function(other) {\n      return other instanceof Repeat ?\n        is(this._value, other._value) :\n        deepEqual(other);\n    };\n\n\n  var EMPTY_REPEAT;\n\n  function invariant(condition, error) {\n    if (!condition) throw new Error(error);\n  }\n\n  createClass(Range, IndexedSeq);\n\n    function Range(start, end, step) {\n      if (!(this instanceof Range)) {\n        return new Range(start, end, step);\n      }\n      invariant(step !== 0, 'Cannot step a Range by 0');\n      start = start || 0;\n      if (end === undefined) {\n        end = Infinity;\n      }\n      step = step === undefined ? 1 : Math.abs(step);\n      if (end < start) {\n        step = -step;\n      }\n      this._start = start;\n      this._end = end;\n      this._step = step;\n      this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);\n      if (this.size === 0) {\n        if (EMPTY_RANGE) {\n          return EMPTY_RANGE;\n        }\n        EMPTY_RANGE = this;\n      }\n    }\n\n    Range.prototype.toString = function() {\n      if (this.size === 0) {\n        return 'Range []';\n      }\n      return 'Range [ ' +\n        this._start + '...' + this._end +\n        (this._step > 1 ? ' by ' + this._step : '') +\n      ' ]';\n    };\n\n    Range.prototype.get = function(index, notSetValue) {\n      return this.has(index) ?\n        this._start + wrapIndex(this, index) * this._step :\n        notSetValue;\n    };\n\n    Range.prototype.includes = function(searchValue) {\n      var possibleIndex = (searchValue - this._start) / this._step;\n      return possibleIndex >= 0 &&\n        possibleIndex < this.size &&\n        possibleIndex === Math.floor(possibleIndex);\n    };\n\n    Range.prototype.slice = function(begin, end) {\n      if (wholeSlice(begin, end, this.size)) {\n        return this;\n      }\n      begin = resolveBegin(begin, this.size);\n      end = resolveEnd(end, this.size);\n      if (end <= begin) {\n        return new Range(0, 0);\n      }\n      return new Range(this.get(begin, this._end), this.get(end, this._end), this._step);\n    };\n\n    Range.prototype.indexOf = function(searchValue) {\n      var offsetValue = searchValue - this._start;\n      if (offsetValue % this._step === 0) {\n        var index = offsetValue / this._step;\n        if (index >= 0 && index < this.size) {\n          return index\n        }\n      }\n      return -1;\n    };\n\n    Range.prototype.lastIndexOf = function(searchValue) {\n      return this.indexOf(searchValue);\n    };\n\n    Range.prototype.__iterate = function(fn, reverse) {\n      var maxIndex = this.size - 1;\n      var step = this._step;\n      var value = reverse ? this._start + maxIndex * step : this._start;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        if (fn(value, ii, this) === false) {\n          return ii + 1;\n        }\n        value += reverse ? -step : step;\n      }\n      return ii;\n    };\n\n    Range.prototype.__iterator = function(type, reverse) {\n      var maxIndex = this.size - 1;\n      var step = this._step;\n      var value = reverse ? this._start + maxIndex * step : this._start;\n      var ii = 0;\n      return new Iterator(function()  {\n        var v = value;\n        value += reverse ? -step : step;\n        return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii++, v);\n      });\n    };\n\n    Range.prototype.equals = function(other) {\n      return other instanceof Range ?\n        this._start === other._start &&\n        this._end === other._end &&\n        this._step === other._step :\n        deepEqual(this, other);\n    };\n\n\n  var EMPTY_RANGE;\n\n  createClass(Collection, Iterable);\n    function Collection() {\n      throw TypeError('Abstract');\n    }\n\n\n  createClass(KeyedCollection, Collection);function KeyedCollection() {}\n\n  createClass(IndexedCollection, Collection);function IndexedCollection() {}\n\n  createClass(SetCollection, Collection);function SetCollection() {}\n\n\n  Collection.Keyed = KeyedCollection;\n  Collection.Indexed = IndexedCollection;\n  Collection.Set = SetCollection;\n\n  var imul =\n    typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2 ?\n    Math.imul :\n    function imul(a, b) {\n      a = a | 0; // int\n      b = b | 0; // int\n      var c = a & 0xffff;\n      var d = b & 0xffff;\n      // Shift by 0 fixes the sign on the high part.\n      return (c * d) + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0) | 0; // int\n    };\n\n  // v8 has an optimization for storing 31-bit signed numbers.\n  // Values which have either 00 or 11 as the high order bits qualify.\n  // This function drops the highest order bit in a signed number, maintaining\n  // the sign bit.\n  function smi(i32) {\n    return ((i32 >>> 1) & 0x40000000) | (i32 & 0xBFFFFFFF);\n  }\n\n  function hash(o) {\n    if (o === false || o === null || o === undefined) {\n      return 0;\n    }\n    if (typeof o.valueOf === 'function') {\n      o = o.valueOf();\n      if (o === false || o === null || o === undefined) {\n        return 0;\n      }\n    }\n    if (o === true) {\n      return 1;\n    }\n    var type = typeof o;\n    if (type === 'number') {\n      var h = o | 0;\n      if (h !== o) {\n        h ^= o * 0xFFFFFFFF;\n      }\n      while (o > 0xFFFFFFFF) {\n        o /= 0xFFFFFFFF;\n        h ^= o;\n      }\n      return smi(h);\n    }\n    if (type === 'string') {\n      return o.length > STRING_HASH_CACHE_MIN_STRLEN ? cachedHashString(o) : hashString(o);\n    }\n    if (typeof o.hashCode === 'function') {\n      return o.hashCode();\n    }\n    if (type === 'object') {\n      return hashJSObj(o);\n    }\n    if (typeof o.toString === 'function') {\n      return hashString(o.toString());\n    }\n    throw new Error('Value type ' + type + ' cannot be hashed.');\n  }\n\n  function cachedHashString(string) {\n    var hash = stringHashCache[string];\n    if (hash === undefined) {\n      hash = hashString(string);\n      if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {\n        STRING_HASH_CACHE_SIZE = 0;\n        stringHashCache = {};\n      }\n      STRING_HASH_CACHE_SIZE++;\n      stringHashCache[string] = hash;\n    }\n    return hash;\n  }\n\n  // http://jsperf.com/hashing-strings\n  function hashString(string) {\n    // This is the hash from JVM\n    // The hash code for a string is computed as\n    // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],\n    // where s[i] is the ith character of the string and n is the length of\n    // the string. We \"mod\" the result to make it between 0 (inclusive) and 2^31\n    // (exclusive) by dropping high bits.\n    var hash = 0;\n    for (var ii = 0; ii < string.length; ii++) {\n      hash = 31 * hash + string.charCodeAt(ii) | 0;\n    }\n    return smi(hash);\n  }\n\n  function hashJSObj(obj) {\n    var hash;\n    if (usingWeakMap) {\n      hash = weakMap.get(obj);\n      if (hash !== undefined) {\n        return hash;\n      }\n    }\n\n    hash = obj[UID_HASH_KEY];\n    if (hash !== undefined) {\n      return hash;\n    }\n\n    if (!canDefineProperty) {\n      hash = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];\n      if (hash !== undefined) {\n        return hash;\n      }\n\n      hash = getIENodeHash(obj);\n      if (hash !== undefined) {\n        return hash;\n      }\n    }\n\n    hash = ++objHashUID;\n    if (objHashUID & 0x40000000) {\n      objHashUID = 0;\n    }\n\n    if (usingWeakMap) {\n      weakMap.set(obj, hash);\n    } else if (isExtensible !== undefined && isExtensible(obj) === false) {\n      throw new Error('Non-extensible objects are not allowed as keys.');\n    } else if (canDefineProperty) {\n      Object.defineProperty(obj, UID_HASH_KEY, {\n        'enumerable': false,\n        'configurable': false,\n        'writable': false,\n        'value': hash\n      });\n    } else if (obj.propertyIsEnumerable !== undefined &&\n               obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable) {\n      // Since we can't define a non-enumerable property on the object\n      // we'll hijack one of the less-used non-enumerable properties to\n      // save our hash on it. Since this is a function it will not show up in\n      // `JSON.stringify` which is what we want.\n      obj.propertyIsEnumerable = function() {\n        return this.constructor.prototype.propertyIsEnumerable.apply(this, arguments);\n      };\n      obj.propertyIsEnumerable[UID_HASH_KEY] = hash;\n    } else if (obj.nodeType !== undefined) {\n      // At this point we couldn't get the IE `uniqueID` to use as a hash\n      // and we couldn't use a non-enumerable property to exploit the\n      // dontEnum bug so we simply add the `UID_HASH_KEY` on the node\n      // itself.\n      obj[UID_HASH_KEY] = hash;\n    } else {\n      throw new Error('Unable to set a non-enumerable property on object.');\n    }\n\n    return hash;\n  }\n\n  // Get references to ES5 object methods.\n  var isExtensible = Object.isExtensible;\n\n  // True if Object.defineProperty works as expected. IE8 fails this test.\n  var canDefineProperty = (function() {\n    try {\n      Object.defineProperty({}, '@', {});\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }());\n\n  // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it\n  // and avoid memory leaks from the IE cloneNode bug.\n  function getIENodeHash(node) {\n    if (node && node.nodeType > 0) {\n      switch (node.nodeType) {\n        case 1: // Element\n          return node.uniqueID;\n        case 9: // Document\n          return node.documentElement && node.documentElement.uniqueID;\n      }\n    }\n  }\n\n  // If possible, use a WeakMap.\n  var usingWeakMap = typeof WeakMap === 'function';\n  var weakMap;\n  if (usingWeakMap) {\n    weakMap = new WeakMap();\n  }\n\n  var objHashUID = 0;\n\n  var UID_HASH_KEY = '__immutablehash__';\n  if (typeof Symbol === 'function') {\n    UID_HASH_KEY = Symbol(UID_HASH_KEY);\n  }\n\n  var STRING_HASH_CACHE_MIN_STRLEN = 16;\n  var STRING_HASH_CACHE_MAX_SIZE = 255;\n  var STRING_HASH_CACHE_SIZE = 0;\n  var stringHashCache = {};\n\n  function assertNotInfinite(size) {\n    invariant(\n      size !== Infinity,\n      'Cannot perform this action with an infinite size.'\n    );\n  }\n\n  createClass(Map, KeyedCollection);\n\n    // @pragma Construction\n\n    function Map(value) {\n      return value === null || value === undefined ? emptyMap() :\n        isMap(value) && !isOrdered(value) ? value :\n        emptyMap().withMutations(function(map ) {\n          var iter = KeyedIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v, k)  {return map.set(k, v)});\n        });\n    }\n\n    Map.prototype.toString = function() {\n      return this.__toString('Map {', '}');\n    };\n\n    // @pragma Access\n\n    Map.prototype.get = function(k, notSetValue) {\n      return this._root ?\n        this._root.get(0, undefined, k, notSetValue) :\n        notSetValue;\n    };\n\n    // @pragma Modification\n\n    Map.prototype.set = function(k, v) {\n      return updateMap(this, k, v);\n    };\n\n    Map.prototype.setIn = function(keyPath, v) {\n      return this.updateIn(keyPath, NOT_SET, function()  {return v});\n    };\n\n    Map.prototype.remove = function(k) {\n      return updateMap(this, k, NOT_SET);\n    };\n\n    Map.prototype.deleteIn = function(keyPath) {\n      return this.updateIn(keyPath, function()  {return NOT_SET});\n    };\n\n    Map.prototype.update = function(k, notSetValue, updater) {\n      return arguments.length === 1 ?\n        k(this) :\n        this.updateIn([k], notSetValue, updater);\n    };\n\n    Map.prototype.updateIn = function(keyPath, notSetValue, updater) {\n      if (!updater) {\n        updater = notSetValue;\n        notSetValue = undefined;\n      }\n      var updatedValue = updateInDeepMap(\n        this,\n        forceIterator(keyPath),\n        notSetValue,\n        updater\n      );\n      return updatedValue === NOT_SET ? undefined : updatedValue;\n    };\n\n    Map.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._root = null;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyMap();\n    };\n\n    // @pragma Composition\n\n    Map.prototype.merge = function(/*...iters*/) {\n      return mergeIntoMapWith(this, undefined, arguments);\n    };\n\n    Map.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoMapWith(this, merger, iters);\n    };\n\n    Map.prototype.mergeIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);\n      return this.updateIn(\n        keyPath,\n        emptyMap(),\n        function(m ) {return typeof m.merge === 'function' ?\n          m.merge.apply(m, iters) :\n          iters[iters.length - 1]}\n      );\n    };\n\n    Map.prototype.mergeDeep = function(/*...iters*/) {\n      return mergeIntoMapWith(this, deepMerger, arguments);\n    };\n\n    Map.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoMapWith(this, deepMergerWith(merger), iters);\n    };\n\n    Map.prototype.mergeDeepIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);\n      return this.updateIn(\n        keyPath,\n        emptyMap(),\n        function(m ) {return typeof m.mergeDeep === 'function' ?\n          m.mergeDeep.apply(m, iters) :\n          iters[iters.length - 1]}\n      );\n    };\n\n    Map.prototype.sort = function(comparator) {\n      // Late binding\n      return OrderedMap(sortFactory(this, comparator));\n    };\n\n    Map.prototype.sortBy = function(mapper, comparator) {\n      // Late binding\n      return OrderedMap(sortFactory(this, comparator, mapper));\n    };\n\n    // @pragma Mutability\n\n    Map.prototype.withMutations = function(fn) {\n      var mutable = this.asMutable();\n      fn(mutable);\n      return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;\n    };\n\n    Map.prototype.asMutable = function() {\n      return this.__ownerID ? this : this.__ensureOwner(new OwnerID());\n    };\n\n    Map.prototype.asImmutable = function() {\n      return this.__ensureOwner();\n    };\n\n    Map.prototype.wasAltered = function() {\n      return this.__altered;\n    };\n\n    Map.prototype.__iterator = function(type, reverse) {\n      return new MapIterator(this, type, reverse);\n    };\n\n    Map.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      this._root && this._root.iterate(function(entry ) {\n        iterations++;\n        return fn(entry[1], entry[0], this$0);\n      }, reverse);\n      return iterations;\n    };\n\n    Map.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this.__altered = false;\n        return this;\n      }\n      return makeMap(this.size, this._root, ownerID, this.__hash);\n    };\n\n\n  function isMap(maybeMap) {\n    return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]);\n  }\n\n  Map.isMap = isMap;\n\n  var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';\n\n  var MapPrototype = Map.prototype;\n  MapPrototype[IS_MAP_SENTINEL] = true;\n  MapPrototype[DELETE] = MapPrototype.remove;\n  MapPrototype.removeIn = MapPrototype.deleteIn;\n\n\n  // #pragma Trie Nodes\n\n\n\n    function ArrayMapNode(ownerID, entries) {\n      this.ownerID = ownerID;\n      this.entries = entries;\n    }\n\n    ArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      var entries = this.entries;\n      for (var ii = 0, len = entries.length; ii < len; ii++) {\n        if (is(key, entries[ii][0])) {\n          return entries[ii][1];\n        }\n      }\n      return notSetValue;\n    };\n\n    ArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      var removed = value === NOT_SET;\n\n      var entries = this.entries;\n      var idx = 0;\n      for (var len = entries.length; idx < len; idx++) {\n        if (is(key, entries[idx][0])) {\n          break;\n        }\n      }\n      var exists = idx < len;\n\n      if (exists ? entries[idx][1] === value : removed) {\n        return this;\n      }\n\n      SetRef(didAlter);\n      (removed || !exists) && SetRef(didChangeSize);\n\n      if (removed && entries.length === 1) {\n        return; // undefined\n      }\n\n      if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {\n        return createNodes(ownerID, entries, key, value);\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newEntries = isEditable ? entries : arrCopy(entries);\n\n      if (exists) {\n        if (removed) {\n          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());\n        } else {\n          newEntries[idx] = [key, value];\n        }\n      } else {\n        newEntries.push([key, value]);\n      }\n\n      if (isEditable) {\n        this.entries = newEntries;\n        return this;\n      }\n\n      return new ArrayMapNode(ownerID, newEntries);\n    };\n\n\n\n\n    function BitmapIndexedNode(ownerID, bitmap, nodes) {\n      this.ownerID = ownerID;\n      this.bitmap = bitmap;\n      this.nodes = nodes;\n    }\n\n    BitmapIndexedNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var bit = (1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK));\n      var bitmap = this.bitmap;\n      return (bitmap & bit) === 0 ? notSetValue :\n        this.nodes[popCount(bitmap & (bit - 1))].get(shift + SHIFT, keyHash, key, notSetValue);\n    };\n\n    BitmapIndexedNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n      var bit = 1 << keyHashFrag;\n      var bitmap = this.bitmap;\n      var exists = (bitmap & bit) !== 0;\n\n      if (!exists && value === NOT_SET) {\n        return this;\n      }\n\n      var idx = popCount(bitmap & (bit - 1));\n      var nodes = this.nodes;\n      var node = exists ? nodes[idx] : undefined;\n      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);\n\n      if (newNode === node) {\n        return this;\n      }\n\n      if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {\n        return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);\n      }\n\n      if (exists && !newNode && nodes.length === 2 && isLeafNode(nodes[idx ^ 1])) {\n        return nodes[idx ^ 1];\n      }\n\n      if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {\n        return newNode;\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newBitmap = exists ? newNode ? bitmap : bitmap ^ bit : bitmap | bit;\n      var newNodes = exists ? newNode ?\n        setIn(nodes, idx, newNode, isEditable) :\n        spliceOut(nodes, idx, isEditable) :\n        spliceIn(nodes, idx, newNode, isEditable);\n\n      if (isEditable) {\n        this.bitmap = newBitmap;\n        this.nodes = newNodes;\n        return this;\n      }\n\n      return new BitmapIndexedNode(ownerID, newBitmap, newNodes);\n    };\n\n\n\n\n    function HashArrayMapNode(ownerID, count, nodes) {\n      this.ownerID = ownerID;\n      this.count = count;\n      this.nodes = nodes;\n    }\n\n    HashArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n      var node = this.nodes[idx];\n      return node ? node.get(shift + SHIFT, keyHash, key, notSetValue) : notSetValue;\n    };\n\n    HashArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n      var removed = value === NOT_SET;\n      var nodes = this.nodes;\n      var node = nodes[idx];\n\n      if (removed && !node) {\n        return this;\n      }\n\n      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);\n      if (newNode === node) {\n        return this;\n      }\n\n      var newCount = this.count;\n      if (!node) {\n        newCount++;\n      } else if (!newNode) {\n        newCount--;\n        if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {\n          return packNodes(ownerID, nodes, newCount, idx);\n        }\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newNodes = setIn(nodes, idx, newNode, isEditable);\n\n      if (isEditable) {\n        this.count = newCount;\n        this.nodes = newNodes;\n        return this;\n      }\n\n      return new HashArrayMapNode(ownerID, newCount, newNodes);\n    };\n\n\n\n\n    function HashCollisionNode(ownerID, keyHash, entries) {\n      this.ownerID = ownerID;\n      this.keyHash = keyHash;\n      this.entries = entries;\n    }\n\n    HashCollisionNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      var entries = this.entries;\n      for (var ii = 0, len = entries.length; ii < len; ii++) {\n        if (is(key, entries[ii][0])) {\n          return entries[ii][1];\n        }\n      }\n      return notSetValue;\n    };\n\n    HashCollisionNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n\n      var removed = value === NOT_SET;\n\n      if (keyHash !== this.keyHash) {\n        if (removed) {\n          return this;\n        }\n        SetRef(didAlter);\n        SetRef(didChangeSize);\n        return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);\n      }\n\n      var entries = this.entries;\n      var idx = 0;\n      for (var len = entries.length; idx < len; idx++) {\n        if (is(key, entries[idx][0])) {\n          break;\n        }\n      }\n      var exists = idx < len;\n\n      if (exists ? entries[idx][1] === value : removed) {\n        return this;\n      }\n\n      SetRef(didAlter);\n      (removed || !exists) && SetRef(didChangeSize);\n\n      if (removed && len === 2) {\n        return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newEntries = isEditable ? entries : arrCopy(entries);\n\n      if (exists) {\n        if (removed) {\n          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());\n        } else {\n          newEntries[idx] = [key, value];\n        }\n      } else {\n        newEntries.push([key, value]);\n      }\n\n      if (isEditable) {\n        this.entries = newEntries;\n        return this;\n      }\n\n      return new HashCollisionNode(ownerID, this.keyHash, newEntries);\n    };\n\n\n\n\n    function ValueNode(ownerID, keyHash, entry) {\n      this.ownerID = ownerID;\n      this.keyHash = keyHash;\n      this.entry = entry;\n    }\n\n    ValueNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      return is(key, this.entry[0]) ? this.entry[1] : notSetValue;\n    };\n\n    ValueNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      var removed = value === NOT_SET;\n      var keyMatch = is(key, this.entry[0]);\n      if (keyMatch ? value === this.entry[1] : removed) {\n        return this;\n      }\n\n      SetRef(didAlter);\n\n      if (removed) {\n        SetRef(didChangeSize);\n        return; // undefined\n      }\n\n      if (keyMatch) {\n        if (ownerID && ownerID === this.ownerID) {\n          this.entry[1] = value;\n          return this;\n        }\n        return new ValueNode(ownerID, this.keyHash, [key, value]);\n      }\n\n      SetRef(didChangeSize);\n      return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);\n    };\n\n\n\n  // #pragma Iterators\n\n  ArrayMapNode.prototype.iterate =\n  HashCollisionNode.prototype.iterate = function (fn, reverse) {\n    var entries = this.entries;\n    for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {\n      if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {\n        return false;\n      }\n    }\n  }\n\n  BitmapIndexedNode.prototype.iterate =\n  HashArrayMapNode.prototype.iterate = function (fn, reverse) {\n    var nodes = this.nodes;\n    for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {\n      var node = nodes[reverse ? maxIndex - ii : ii];\n      if (node && node.iterate(fn, reverse) === false) {\n        return false;\n      }\n    }\n  }\n\n  ValueNode.prototype.iterate = function (fn, reverse) {\n    return fn(this.entry);\n  }\n\n  createClass(MapIterator, Iterator);\n\n    function MapIterator(map, type, reverse) {\n      this._type = type;\n      this._reverse = reverse;\n      this._stack = map._root && mapIteratorFrame(map._root);\n    }\n\n    MapIterator.prototype.next = function() {\n      var type = this._type;\n      var stack = this._stack;\n      while (stack) {\n        var node = stack.node;\n        var index = stack.index++;\n        var maxIndex;\n        if (node.entry) {\n          if (index === 0) {\n            return mapIteratorValue(type, node.entry);\n          }\n        } else if (node.entries) {\n          maxIndex = node.entries.length - 1;\n          if (index <= maxIndex) {\n            return mapIteratorValue(type, node.entries[this._reverse ? maxIndex - index : index]);\n          }\n        } else {\n          maxIndex = node.nodes.length - 1;\n          if (index <= maxIndex) {\n            var subNode = node.nodes[this._reverse ? maxIndex - index : index];\n            if (subNode) {\n              if (subNode.entry) {\n                return mapIteratorValue(type, subNode.entry);\n              }\n              stack = this._stack = mapIteratorFrame(subNode, stack);\n            }\n            continue;\n          }\n        }\n        stack = this._stack = this._stack.__prev;\n      }\n      return iteratorDone();\n    };\n\n\n  function mapIteratorValue(type, entry) {\n    return iteratorValue(type, entry[0], entry[1]);\n  }\n\n  function mapIteratorFrame(node, prev) {\n    return {\n      node: node,\n      index: 0,\n      __prev: prev\n    };\n  }\n\n  function makeMap(size, root, ownerID, hash) {\n    var map = Object.create(MapPrototype);\n    map.size = size;\n    map._root = root;\n    map.__ownerID = ownerID;\n    map.__hash = hash;\n    map.__altered = false;\n    return map;\n  }\n\n  var EMPTY_MAP;\n  function emptyMap() {\n    return EMPTY_MAP || (EMPTY_MAP = makeMap(0));\n  }\n\n  function updateMap(map, k, v) {\n    var newRoot;\n    var newSize;\n    if (!map._root) {\n      if (v === NOT_SET) {\n        return map;\n      }\n      newSize = 1;\n      newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);\n    } else {\n      var didChangeSize = MakeRef(CHANGE_LENGTH);\n      var didAlter = MakeRef(DID_ALTER);\n      newRoot = updateNode(map._root, map.__ownerID, 0, undefined, k, v, didChangeSize, didAlter);\n      if (!didAlter.value) {\n        return map;\n      }\n      newSize = map.size + (didChangeSize.value ? v === NOT_SET ? -1 : 1 : 0);\n    }\n    if (map.__ownerID) {\n      map.size = newSize;\n      map._root = newRoot;\n      map.__hash = undefined;\n      map.__altered = true;\n      return map;\n    }\n    return newRoot ? makeMap(newSize, newRoot) : emptyMap();\n  }\n\n  function updateNode(node, ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n    if (!node) {\n      if (value === NOT_SET) {\n        return node;\n      }\n      SetRef(didAlter);\n      SetRef(didChangeSize);\n      return new ValueNode(ownerID, keyHash, [key, value]);\n    }\n    return node.update(ownerID, shift, keyHash, key, value, didChangeSize, didAlter);\n  }\n\n  function isLeafNode(node) {\n    return node.constructor === ValueNode || node.constructor === HashCollisionNode;\n  }\n\n  function mergeIntoNode(node, ownerID, shift, keyHash, entry) {\n    if (node.keyHash === keyHash) {\n      return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);\n    }\n\n    var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;\n    var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n\n    var newNode;\n    var nodes = idx1 === idx2 ?\n      [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)] :\n      ((newNode = new ValueNode(ownerID, keyHash, entry)), idx1 < idx2 ? [node, newNode] : [newNode, node]);\n\n    return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);\n  }\n\n  function createNodes(ownerID, entries, key, value) {\n    if (!ownerID) {\n      ownerID = new OwnerID();\n    }\n    var node = new ValueNode(ownerID, hash(key), [key, value]);\n    for (var ii = 0; ii < entries.length; ii++) {\n      var entry = entries[ii];\n      node = node.update(ownerID, 0, undefined, entry[0], entry[1]);\n    }\n    return node;\n  }\n\n  function packNodes(ownerID, nodes, count, excluding) {\n    var bitmap = 0;\n    var packedII = 0;\n    var packedNodes = new Array(count);\n    for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {\n      var node = nodes[ii];\n      if (node !== undefined && ii !== excluding) {\n        bitmap |= bit;\n        packedNodes[packedII++] = node;\n      }\n    }\n    return new BitmapIndexedNode(ownerID, bitmap, packedNodes);\n  }\n\n  function expandNodes(ownerID, nodes, bitmap, including, node) {\n    var count = 0;\n    var expandedNodes = new Array(SIZE);\n    for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {\n      expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;\n    }\n    expandedNodes[including] = node;\n    return new HashArrayMapNode(ownerID, count + 1, expandedNodes);\n  }\n\n  function mergeIntoMapWith(map, merger, iterables) {\n    var iters = [];\n    for (var ii = 0; ii < iterables.length; ii++) {\n      var value = iterables[ii];\n      var iter = KeyedIterable(value);\n      if (!isIterable(value)) {\n        iter = iter.map(function(v ) {return fromJS(v)});\n      }\n      iters.push(iter);\n    }\n    return mergeIntoCollectionWith(map, merger, iters);\n  }\n\n  function deepMerger(existing, value, key) {\n    return existing && existing.mergeDeep && isIterable(value) ?\n      existing.mergeDeep(value) :\n      is(existing, value) ? existing : value;\n  }\n\n  function deepMergerWith(merger) {\n    return function(existing, value, key)  {\n      if (existing && existing.mergeDeepWith && isIterable(value)) {\n        return existing.mergeDeepWith(merger, value);\n      }\n      var nextValue = merger(existing, value, key);\n      return is(existing, nextValue) ? existing : nextValue;\n    };\n  }\n\n  function mergeIntoCollectionWith(collection, merger, iters) {\n    iters = iters.filter(function(x ) {return x.size !== 0});\n    if (iters.length === 0) {\n      return collection;\n    }\n    if (collection.size === 0 && !collection.__ownerID && iters.length === 1) {\n      return collection.constructor(iters[0]);\n    }\n    return collection.withMutations(function(collection ) {\n      var mergeIntoMap = merger ?\n        function(value, key)  {\n          collection.update(key, NOT_SET, function(existing )\n            {return existing === NOT_SET ? value : merger(existing, value, key)}\n          );\n        } :\n        function(value, key)  {\n          collection.set(key, value);\n        }\n      for (var ii = 0; ii < iters.length; ii++) {\n        iters[ii].forEach(mergeIntoMap);\n      }\n    });\n  }\n\n  function updateInDeepMap(existing, keyPathIter, notSetValue, updater) {\n    var isNotSet = existing === NOT_SET;\n    var step = keyPathIter.next();\n    if (step.done) {\n      var existingValue = isNotSet ? notSetValue : existing;\n      var newValue = updater(existingValue);\n      return newValue === existingValue ? existing : newValue;\n    }\n    invariant(\n      isNotSet || (existing && existing.set),\n      'invalid keyPath'\n    );\n    var key = step.value;\n    var nextExisting = isNotSet ? NOT_SET : existing.get(key, NOT_SET);\n    var nextUpdated = updateInDeepMap(\n      nextExisting,\n      keyPathIter,\n      notSetValue,\n      updater\n    );\n    return nextUpdated === nextExisting ? existing :\n      nextUpdated === NOT_SET ? existing.remove(key) :\n      (isNotSet ? emptyMap() : existing).set(key, nextUpdated);\n  }\n\n  function popCount(x) {\n    x = x - ((x >> 1) & 0x55555555);\n    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);\n    x = (x + (x >> 4)) & 0x0f0f0f0f;\n    x = x + (x >> 8);\n    x = x + (x >> 16);\n    return x & 0x7f;\n  }\n\n  function setIn(array, idx, val, canEdit) {\n    var newArray = canEdit ? array : arrCopy(array);\n    newArray[idx] = val;\n    return newArray;\n  }\n\n  function spliceIn(array, idx, val, canEdit) {\n    var newLen = array.length + 1;\n    if (canEdit && idx + 1 === newLen) {\n      array[idx] = val;\n      return array;\n    }\n    var newArray = new Array(newLen);\n    var after = 0;\n    for (var ii = 0; ii < newLen; ii++) {\n      if (ii === idx) {\n        newArray[ii] = val;\n        after = -1;\n      } else {\n        newArray[ii] = array[ii + after];\n      }\n    }\n    return newArray;\n  }\n\n  function spliceOut(array, idx, canEdit) {\n    var newLen = array.length - 1;\n    if (canEdit && idx === newLen) {\n      array.pop();\n      return array;\n    }\n    var newArray = new Array(newLen);\n    var after = 0;\n    for (var ii = 0; ii < newLen; ii++) {\n      if (ii === idx) {\n        after = 1;\n      }\n      newArray[ii] = array[ii + after];\n    }\n    return newArray;\n  }\n\n  var MAX_ARRAY_MAP_SIZE = SIZE / 4;\n  var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;\n  var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;\n\n  createClass(List, IndexedCollection);\n\n    // @pragma Construction\n\n    function List(value) {\n      var empty = emptyList();\n      if (value === null || value === undefined) {\n        return empty;\n      }\n      if (isList(value)) {\n        return value;\n      }\n      var iter = IndexedIterable(value);\n      var size = iter.size;\n      if (size === 0) {\n        return empty;\n      }\n      assertNotInfinite(size);\n      if (size > 0 && size < SIZE) {\n        return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));\n      }\n      return empty.withMutations(function(list ) {\n        list.setSize(size);\n        iter.forEach(function(v, i)  {return list.set(i, v)});\n      });\n    }\n\n    List.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    List.prototype.toString = function() {\n      return this.__toString('List [', ']');\n    };\n\n    // @pragma Access\n\n    List.prototype.get = function(index, notSetValue) {\n      index = wrapIndex(this, index);\n      if (index >= 0 && index < this.size) {\n        index += this._origin;\n        var node = listNodeFor(this, index);\n        return node && node.array[index & MASK];\n      }\n      return notSetValue;\n    };\n\n    // @pragma Modification\n\n    List.prototype.set = function(index, value) {\n      return updateList(this, index, value);\n    };\n\n    List.prototype.remove = function(index) {\n      return !this.has(index) ? this :\n        index === 0 ? this.shift() :\n        index === this.size - 1 ? this.pop() :\n        this.splice(index, 1);\n    };\n\n    List.prototype.insert = function(index, value) {\n      return this.splice(index, 0, value);\n    };\n\n    List.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = this._origin = this._capacity = 0;\n        this._level = SHIFT;\n        this._root = this._tail = null;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyList();\n    };\n\n    List.prototype.push = function(/*...values*/) {\n      var values = arguments;\n      var oldSize = this.size;\n      return this.withMutations(function(list ) {\n        setListBounds(list, 0, oldSize + values.length);\n        for (var ii = 0; ii < values.length; ii++) {\n          list.set(oldSize + ii, values[ii]);\n        }\n      });\n    };\n\n    List.prototype.pop = function() {\n      return setListBounds(this, 0, -1);\n    };\n\n    List.prototype.unshift = function(/*...values*/) {\n      var values = arguments;\n      return this.withMutations(function(list ) {\n        setListBounds(list, -values.length);\n        for (var ii = 0; ii < values.length; ii++) {\n          list.set(ii, values[ii]);\n        }\n      });\n    };\n\n    List.prototype.shift = function() {\n      return setListBounds(this, 1);\n    };\n\n    // @pragma Composition\n\n    List.prototype.merge = function(/*...iters*/) {\n      return mergeIntoListWith(this, undefined, arguments);\n    };\n\n    List.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoListWith(this, merger, iters);\n    };\n\n    List.prototype.mergeDeep = function(/*...iters*/) {\n      return mergeIntoListWith(this, deepMerger, arguments);\n    };\n\n    List.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoListWith(this, deepMergerWith(merger), iters);\n    };\n\n    List.prototype.setSize = function(size) {\n      return setListBounds(this, 0, size);\n    };\n\n    // @pragma Iteration\n\n    List.prototype.slice = function(begin, end) {\n      var size = this.size;\n      if (wholeSlice(begin, end, size)) {\n        return this;\n      }\n      return setListBounds(\n        this,\n        resolveBegin(begin, size),\n        resolveEnd(end, size)\n      );\n    };\n\n    List.prototype.__iterator = function(type, reverse) {\n      var index = 0;\n      var values = iterateList(this, reverse);\n      return new Iterator(function()  {\n        var value = values();\n        return value === DONE ?\n          iteratorDone() :\n          iteratorValue(type, index++, value);\n      });\n    };\n\n    List.prototype.__iterate = function(fn, reverse) {\n      var index = 0;\n      var values = iterateList(this, reverse);\n      var value;\n      while ((value = values()) !== DONE) {\n        if (fn(value, index++, this) === false) {\n          break;\n        }\n      }\n      return index;\n    };\n\n    List.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        return this;\n      }\n      return makeList(this._origin, this._capacity, this._level, this._root, this._tail, ownerID, this.__hash);\n    };\n\n\n  function isList(maybeList) {\n    return !!(maybeList && maybeList[IS_LIST_SENTINEL]);\n  }\n\n  List.isList = isList;\n\n  var IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';\n\n  var ListPrototype = List.prototype;\n  ListPrototype[IS_LIST_SENTINEL] = true;\n  ListPrototype[DELETE] = ListPrototype.remove;\n  ListPrototype.setIn = MapPrototype.setIn;\n  ListPrototype.deleteIn =\n  ListPrototype.removeIn = MapPrototype.removeIn;\n  ListPrototype.update = MapPrototype.update;\n  ListPrototype.updateIn = MapPrototype.updateIn;\n  ListPrototype.mergeIn = MapPrototype.mergeIn;\n  ListPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;\n  ListPrototype.withMutations = MapPrototype.withMutations;\n  ListPrototype.asMutable = MapPrototype.asMutable;\n  ListPrototype.asImmutable = MapPrototype.asImmutable;\n  ListPrototype.wasAltered = MapPrototype.wasAltered;\n\n\n\n    function VNode(array, ownerID) {\n      this.array = array;\n      this.ownerID = ownerID;\n    }\n\n    // TODO: seems like these methods are very similar\n\n    VNode.prototype.removeBefore = function(ownerID, level, index) {\n      if (index === level ? 1 << level : 0 || this.array.length === 0) {\n        return this;\n      }\n      var originIndex = (index >>> level) & MASK;\n      if (originIndex >= this.array.length) {\n        return new VNode([], ownerID);\n      }\n      var removingFirst = originIndex === 0;\n      var newChild;\n      if (level > 0) {\n        var oldChild = this.array[originIndex];\n        newChild = oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);\n        if (newChild === oldChild && removingFirst) {\n          return this;\n        }\n      }\n      if (removingFirst && !newChild) {\n        return this;\n      }\n      var editable = editableVNode(this, ownerID);\n      if (!removingFirst) {\n        for (var ii = 0; ii < originIndex; ii++) {\n          editable.array[ii] = undefined;\n        }\n      }\n      if (newChild) {\n        editable.array[originIndex] = newChild;\n      }\n      return editable;\n    };\n\n    VNode.prototype.removeAfter = function(ownerID, level, index) {\n      if (index === (level ? 1 << level : 0) || this.array.length === 0) {\n        return this;\n      }\n      var sizeIndex = ((index - 1) >>> level) & MASK;\n      if (sizeIndex >= this.array.length) {\n        return this;\n      }\n\n      var newChild;\n      if (level > 0) {\n        var oldChild = this.array[sizeIndex];\n        newChild = oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);\n        if (newChild === oldChild && sizeIndex === this.array.length - 1) {\n          return this;\n        }\n      }\n\n      var editable = editableVNode(this, ownerID);\n      editable.array.splice(sizeIndex + 1);\n      if (newChild) {\n        editable.array[sizeIndex] = newChild;\n      }\n      return editable;\n    };\n\n\n\n  var DONE = {};\n\n  function iterateList(list, reverse) {\n    var left = list._origin;\n    var right = list._capacity;\n    var tailPos = getTailOffset(right);\n    var tail = list._tail;\n\n    return iterateNodeOrLeaf(list._root, list._level, 0);\n\n    function iterateNodeOrLeaf(node, level, offset) {\n      return level === 0 ?\n        iterateLeaf(node, offset) :\n        iterateNode(node, level, offset);\n    }\n\n    function iterateLeaf(node, offset) {\n      var array = offset === tailPos ? tail && tail.array : node && node.array;\n      var from = offset > left ? 0 : left - offset;\n      var to = right - offset;\n      if (to > SIZE) {\n        to = SIZE;\n      }\n      return function()  {\n        if (from === to) {\n          return DONE;\n        }\n        var idx = reverse ? --to : from++;\n        return array && array[idx];\n      };\n    }\n\n    function iterateNode(node, level, offset) {\n      var values;\n      var array = node && node.array;\n      var from = offset > left ? 0 : (left - offset) >> level;\n      var to = ((right - offset) >> level) + 1;\n      if (to > SIZE) {\n        to = SIZE;\n      }\n      return function()  {\n        do {\n          if (values) {\n            var value = values();\n            if (value !== DONE) {\n              return value;\n            }\n            values = null;\n          }\n          if (from === to) {\n            return DONE;\n          }\n          var idx = reverse ? --to : from++;\n          values = iterateNodeOrLeaf(\n            array && array[idx], level - SHIFT, offset + (idx << level)\n          );\n        } while (true);\n      };\n    }\n  }\n\n  function makeList(origin, capacity, level, root, tail, ownerID, hash) {\n    var list = Object.create(ListPrototype);\n    list.size = capacity - origin;\n    list._origin = origin;\n    list._capacity = capacity;\n    list._level = level;\n    list._root = root;\n    list._tail = tail;\n    list.__ownerID = ownerID;\n    list.__hash = hash;\n    list.__altered = false;\n    return list;\n  }\n\n  var EMPTY_LIST;\n  function emptyList() {\n    return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));\n  }\n\n  function updateList(list, index, value) {\n    index = wrapIndex(list, index);\n\n    if (index !== index) {\n      return list;\n    }\n\n    if (index >= list.size || index < 0) {\n      return list.withMutations(function(list ) {\n        index < 0 ?\n          setListBounds(list, index).set(0, value) :\n          setListBounds(list, 0, index + 1).set(index, value)\n      });\n    }\n\n    index += list._origin;\n\n    var newTail = list._tail;\n    var newRoot = list._root;\n    var didAlter = MakeRef(DID_ALTER);\n    if (index >= getTailOffset(list._capacity)) {\n      newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter);\n    } else {\n      newRoot = updateVNode(newRoot, list.__ownerID, list._level, index, value, didAlter);\n    }\n\n    if (!didAlter.value) {\n      return list;\n    }\n\n    if (list.__ownerID) {\n      list._root = newRoot;\n      list._tail = newTail;\n      list.__hash = undefined;\n      list.__altered = true;\n      return list;\n    }\n    return makeList(list._origin, list._capacity, list._level, newRoot, newTail);\n  }\n\n  function updateVNode(node, ownerID, level, index, value, didAlter) {\n    var idx = (index >>> level) & MASK;\n    var nodeHas = node && idx < node.array.length;\n    if (!nodeHas && value === undefined) {\n      return node;\n    }\n\n    var newNode;\n\n    if (level > 0) {\n      var lowerNode = node && node.array[idx];\n      var newLowerNode = updateVNode(lowerNode, ownerID, level - SHIFT, index, value, didAlter);\n      if (newLowerNode === lowerNode) {\n        return node;\n      }\n      newNode = editableVNode(node, ownerID);\n      newNode.array[idx] = newLowerNode;\n      return newNode;\n    }\n\n    if (nodeHas && node.array[idx] === value) {\n      return node;\n    }\n\n    SetRef(didAlter);\n\n    newNode = editableVNode(node, ownerID);\n    if (value === undefined && idx === newNode.array.length - 1) {\n      newNode.array.pop();\n    } else {\n      newNode.array[idx] = value;\n    }\n    return newNode;\n  }\n\n  function editableVNode(node, ownerID) {\n    if (ownerID && node && ownerID === node.ownerID) {\n      return node;\n    }\n    return new VNode(node ? node.array.slice() : [], ownerID);\n  }\n\n  function listNodeFor(list, rawIndex) {\n    if (rawIndex >= getTailOffset(list._capacity)) {\n      return list._tail;\n    }\n    if (rawIndex < 1 << (list._level + SHIFT)) {\n      var node = list._root;\n      var level = list._level;\n      while (node && level > 0) {\n        node = node.array[(rawIndex >>> level) & MASK];\n        level -= SHIFT;\n      }\n      return node;\n    }\n  }\n\n  function setListBounds(list, begin, end) {\n    // Sanitize begin & end using this shorthand for ToInt32(argument)\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n    if (begin !== undefined) {\n      begin = begin | 0;\n    }\n    if (end !== undefined) {\n      end = end | 0;\n    }\n    var owner = list.__ownerID || new OwnerID();\n    var oldOrigin = list._origin;\n    var oldCapacity = list._capacity;\n    var newOrigin = oldOrigin + begin;\n    var newCapacity = end === undefined ? oldCapacity : end < 0 ? oldCapacity + end : oldOrigin + end;\n    if (newOrigin === oldOrigin && newCapacity === oldCapacity) {\n      return list;\n    }\n\n    // If it's going to end after it starts, it's empty.\n    if (newOrigin >= newCapacity) {\n      return list.clear();\n    }\n\n    var newLevel = list._level;\n    var newRoot = list._root;\n\n    // New origin might need creating a higher root.\n    var offsetShift = 0;\n    while (newOrigin + offsetShift < 0) {\n      newRoot = new VNode(newRoot && newRoot.array.length ? [undefined, newRoot] : [], owner);\n      newLevel += SHIFT;\n      offsetShift += 1 << newLevel;\n    }\n    if (offsetShift) {\n      newOrigin += offsetShift;\n      oldOrigin += offsetShift;\n      newCapacity += offsetShift;\n      oldCapacity += offsetShift;\n    }\n\n    var oldTailOffset = getTailOffset(oldCapacity);\n    var newTailOffset = getTailOffset(newCapacity);\n\n    // New size might need creating a higher root.\n    while (newTailOffset >= 1 << (newLevel + SHIFT)) {\n      newRoot = new VNode(newRoot && newRoot.array.length ? [newRoot] : [], owner);\n      newLevel += SHIFT;\n    }\n\n    // Locate or create the new tail.\n    var oldTail = list._tail;\n    var newTail = newTailOffset < oldTailOffset ?\n      listNodeFor(list, newCapacity - 1) :\n      newTailOffset > oldTailOffset ? new VNode([], owner) : oldTail;\n\n    // Merge Tail into tree.\n    if (oldTail && newTailOffset > oldTailOffset && newOrigin < oldCapacity && oldTail.array.length) {\n      newRoot = editableVNode(newRoot, owner);\n      var node = newRoot;\n      for (var level = newLevel; level > SHIFT; level -= SHIFT) {\n        var idx = (oldTailOffset >>> level) & MASK;\n        node = node.array[idx] = editableVNode(node.array[idx], owner);\n      }\n      node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;\n    }\n\n    // If the size has been reduced, there's a chance the tail needs to be trimmed.\n    if (newCapacity < oldCapacity) {\n      newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);\n    }\n\n    // If the new origin is within the tail, then we do not need a root.\n    if (newOrigin >= newTailOffset) {\n      newOrigin -= newTailOffset;\n      newCapacity -= newTailOffset;\n      newLevel = SHIFT;\n      newRoot = null;\n      newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);\n\n    // Otherwise, if the root has been trimmed, garbage collect.\n    } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {\n      offsetShift = 0;\n\n      // Identify the new top root node of the subtree of the old root.\n      while (newRoot) {\n        var beginIndex = (newOrigin >>> newLevel) & MASK;\n        if (beginIndex !== (newTailOffset >>> newLevel) & MASK) {\n          break;\n        }\n        if (beginIndex) {\n          offsetShift += (1 << newLevel) * beginIndex;\n        }\n        newLevel -= SHIFT;\n        newRoot = newRoot.array[beginIndex];\n      }\n\n      // Trim the new sides of the new root.\n      if (newRoot && newOrigin > oldOrigin) {\n        newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift);\n      }\n      if (newRoot && newTailOffset < oldTailOffset) {\n        newRoot = newRoot.removeAfter(owner, newLevel, newTailOffset - offsetShift);\n      }\n      if (offsetShift) {\n        newOrigin -= offsetShift;\n        newCapacity -= offsetShift;\n      }\n    }\n\n    if (list.__ownerID) {\n      list.size = newCapacity - newOrigin;\n      list._origin = newOrigin;\n      list._capacity = newCapacity;\n      list._level = newLevel;\n      list._root = newRoot;\n      list._tail = newTail;\n      list.__hash = undefined;\n      list.__altered = true;\n      return list;\n    }\n    return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);\n  }\n\n  function mergeIntoListWith(list, merger, iterables) {\n    var iters = [];\n    var maxSize = 0;\n    for (var ii = 0; ii < iterables.length; ii++) {\n      var value = iterables[ii];\n      var iter = IndexedIterable(value);\n      if (iter.size > maxSize) {\n        maxSize = iter.size;\n      }\n      if (!isIterable(value)) {\n        iter = iter.map(function(v ) {return fromJS(v)});\n      }\n      iters.push(iter);\n    }\n    if (maxSize > list.size) {\n      list = list.setSize(maxSize);\n    }\n    return mergeIntoCollectionWith(list, merger, iters);\n  }\n\n  function getTailOffset(size) {\n    return size < SIZE ? 0 : (((size - 1) >>> SHIFT) << SHIFT);\n  }\n\n  createClass(OrderedMap, Map);\n\n    // @pragma Construction\n\n    function OrderedMap(value) {\n      return value === null || value === undefined ? emptyOrderedMap() :\n        isOrderedMap(value) ? value :\n        emptyOrderedMap().withMutations(function(map ) {\n          var iter = KeyedIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v, k)  {return map.set(k, v)});\n        });\n    }\n\n    OrderedMap.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    OrderedMap.prototype.toString = function() {\n      return this.__toString('OrderedMap {', '}');\n    };\n\n    // @pragma Access\n\n    OrderedMap.prototype.get = function(k, notSetValue) {\n      var index = this._map.get(k);\n      return index !== undefined ? this._list.get(index)[1] : notSetValue;\n    };\n\n    // @pragma Modification\n\n    OrderedMap.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._map.clear();\n        this._list.clear();\n        return this;\n      }\n      return emptyOrderedMap();\n    };\n\n    OrderedMap.prototype.set = function(k, v) {\n      return updateOrderedMap(this, k, v);\n    };\n\n    OrderedMap.prototype.remove = function(k) {\n      return updateOrderedMap(this, k, NOT_SET);\n    };\n\n    OrderedMap.prototype.wasAltered = function() {\n      return this._map.wasAltered() || this._list.wasAltered();\n    };\n\n    OrderedMap.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._list.__iterate(\n        function(entry ) {return entry && fn(entry[1], entry[0], this$0)},\n        reverse\n      );\n    };\n\n    OrderedMap.prototype.__iterator = function(type, reverse) {\n      return this._list.fromEntrySeq().__iterator(type, reverse);\n    };\n\n    OrderedMap.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map.__ensureOwner(ownerID);\n      var newList = this._list.__ensureOwner(ownerID);\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        this._list = newList;\n        return this;\n      }\n      return makeOrderedMap(newMap, newList, ownerID, this.__hash);\n    };\n\n\n  function isOrderedMap(maybeOrderedMap) {\n    return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);\n  }\n\n  OrderedMap.isOrderedMap = isOrderedMap;\n\n  OrderedMap.prototype[IS_ORDERED_SENTINEL] = true;\n  OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;\n\n\n\n  function makeOrderedMap(map, list, ownerID, hash) {\n    var omap = Object.create(OrderedMap.prototype);\n    omap.size = map ? map.size : 0;\n    omap._map = map;\n    omap._list = list;\n    omap.__ownerID = ownerID;\n    omap.__hash = hash;\n    return omap;\n  }\n\n  var EMPTY_ORDERED_MAP;\n  function emptyOrderedMap() {\n    return EMPTY_ORDERED_MAP || (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()));\n  }\n\n  function updateOrderedMap(omap, k, v) {\n    var map = omap._map;\n    var list = omap._list;\n    var i = map.get(k);\n    var has = i !== undefined;\n    var newMap;\n    var newList;\n    if (v === NOT_SET) { // removed\n      if (!has) {\n        return omap;\n      }\n      if (list.size >= SIZE && list.size >= map.size * 2) {\n        newList = list.filter(function(entry, idx)  {return entry !== undefined && i !== idx});\n        newMap = newList.toKeyedSeq().map(function(entry ) {return entry[0]}).flip().toMap();\n        if (omap.__ownerID) {\n          newMap.__ownerID = newList.__ownerID = omap.__ownerID;\n        }\n      } else {\n        newMap = map.remove(k);\n        newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);\n      }\n    } else {\n      if (has) {\n        if (v === list.get(i)[1]) {\n          return omap;\n        }\n        newMap = map;\n        newList = list.set(i, [k, v]);\n      } else {\n        newMap = map.set(k, list.size);\n        newList = list.set(list.size, [k, v]);\n      }\n    }\n    if (omap.__ownerID) {\n      omap.size = newMap.size;\n      omap._map = newMap;\n      omap._list = newList;\n      omap.__hash = undefined;\n      return omap;\n    }\n    return makeOrderedMap(newMap, newList);\n  }\n\n  createClass(ToKeyedSequence, KeyedSeq);\n    function ToKeyedSequence(indexed, useKeys) {\n      this._iter = indexed;\n      this._useKeys = useKeys;\n      this.size = indexed.size;\n    }\n\n    ToKeyedSequence.prototype.get = function(key, notSetValue) {\n      return this._iter.get(key, notSetValue);\n    };\n\n    ToKeyedSequence.prototype.has = function(key) {\n      return this._iter.has(key);\n    };\n\n    ToKeyedSequence.prototype.valueSeq = function() {\n      return this._iter.valueSeq();\n    };\n\n    ToKeyedSequence.prototype.reverse = function() {var this$0 = this;\n      var reversedSequence = reverseFactory(this, true);\n      if (!this._useKeys) {\n        reversedSequence.valueSeq = function()  {return this$0._iter.toSeq().reverse()};\n      }\n      return reversedSequence;\n    };\n\n    ToKeyedSequence.prototype.map = function(mapper, context) {var this$0 = this;\n      var mappedSequence = mapFactory(this, mapper, context);\n      if (!this._useKeys) {\n        mappedSequence.valueSeq = function()  {return this$0._iter.toSeq().map(mapper, context)};\n      }\n      return mappedSequence;\n    };\n\n    ToKeyedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      var ii;\n      return this._iter.__iterate(\n        this._useKeys ?\n          function(v, k)  {return fn(v, k, this$0)} :\n          ((ii = reverse ? resolveSize(this) : 0),\n            function(v ) {return fn(v, reverse ? --ii : ii++, this$0)}),\n        reverse\n      );\n    };\n\n    ToKeyedSequence.prototype.__iterator = function(type, reverse) {\n      if (this._useKeys) {\n        return this._iter.__iterator(type, reverse);\n      }\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      var ii = reverse ? resolveSize(this) : 0;\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step :\n          iteratorValue(type, reverse ? --ii : ii++, step.value, step);\n      });\n    };\n\n  ToKeyedSequence.prototype[IS_ORDERED_SENTINEL] = true;\n\n\n  createClass(ToIndexedSequence, IndexedSeq);\n    function ToIndexedSequence(iter) {\n      this._iter = iter;\n      this.size = iter.size;\n    }\n\n    ToIndexedSequence.prototype.includes = function(value) {\n      return this._iter.includes(value);\n    };\n\n    ToIndexedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      return this._iter.__iterate(function(v ) {return fn(v, iterations++, this$0)}, reverse);\n    };\n\n    ToIndexedSequence.prototype.__iterator = function(type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      var iterations = 0;\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step :\n          iteratorValue(type, iterations++, step.value, step)\n      });\n    };\n\n\n\n  createClass(ToSetSequence, SetSeq);\n    function ToSetSequence(iter) {\n      this._iter = iter;\n      this.size = iter.size;\n    }\n\n    ToSetSequence.prototype.has = function(key) {\n      return this._iter.includes(key);\n    };\n\n    ToSetSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._iter.__iterate(function(v ) {return fn(v, v, this$0)}, reverse);\n    };\n\n    ToSetSequence.prototype.__iterator = function(type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step :\n          iteratorValue(type, step.value, step.value, step);\n      });\n    };\n\n\n\n  createClass(FromEntriesSequence, KeyedSeq);\n    function FromEntriesSequence(entries) {\n      this._iter = entries;\n      this.size = entries.size;\n    }\n\n    FromEntriesSequence.prototype.entrySeq = function() {\n      return this._iter.toSeq();\n    };\n\n    FromEntriesSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._iter.__iterate(function(entry ) {\n        // Check if entry exists first so array access doesn't throw for holes\n        // in the parent iteration.\n        if (entry) {\n          validateEntry(entry);\n          var indexedIterable = isIterable(entry);\n          return fn(\n            indexedIterable ? entry.get(1) : entry[1],\n            indexedIterable ? entry.get(0) : entry[0],\n            this$0\n          );\n        }\n      }, reverse);\n    };\n\n    FromEntriesSequence.prototype.__iterator = function(type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      return new Iterator(function()  {\n        while (true) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          var entry = step.value;\n          // Check if entry exists first so array access doesn't throw for holes\n          // in the parent iteration.\n          if (entry) {\n            validateEntry(entry);\n            var indexedIterable = isIterable(entry);\n            return iteratorValue(\n              type,\n              indexedIterable ? entry.get(0) : entry[0],\n              indexedIterable ? entry.get(1) : entry[1],\n              step\n            );\n          }\n        }\n      });\n    };\n\n\n  ToIndexedSequence.prototype.cacheResult =\n  ToKeyedSequence.prototype.cacheResult =\n  ToSetSequence.prototype.cacheResult =\n  FromEntriesSequence.prototype.cacheResult =\n    cacheResultThrough;\n\n\n  function flipFactory(iterable) {\n    var flipSequence = makeSequence(iterable);\n    flipSequence._iter = iterable;\n    flipSequence.size = iterable.size;\n    flipSequence.flip = function()  {return iterable};\n    flipSequence.reverse = function () {\n      var reversedSequence = iterable.reverse.apply(this); // super.reverse()\n      reversedSequence.flip = function()  {return iterable.reverse()};\n      return reversedSequence;\n    };\n    flipSequence.has = function(key ) {return iterable.includes(key)};\n    flipSequence.includes = function(key ) {return iterable.has(key)};\n    flipSequence.cacheResult = cacheResultThrough;\n    flipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      return iterable.__iterate(function(v, k)  {return fn(k, v, this$0) !== false}, reverse);\n    }\n    flipSequence.__iteratorUncached = function(type, reverse) {\n      if (type === ITERATE_ENTRIES) {\n        var iterator = iterable.__iterator(type, reverse);\n        return new Iterator(function()  {\n          var step = iterator.next();\n          if (!step.done) {\n            var k = step.value[0];\n            step.value[0] = step.value[1];\n            step.value[1] = k;\n          }\n          return step;\n        });\n      }\n      return iterable.__iterator(\n        type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,\n        reverse\n      );\n    }\n    return flipSequence;\n  }\n\n\n  function mapFactory(iterable, mapper, context) {\n    var mappedSequence = makeSequence(iterable);\n    mappedSequence.size = iterable.size;\n    mappedSequence.has = function(key ) {return iterable.has(key)};\n    mappedSequence.get = function(key, notSetValue)  {\n      var v = iterable.get(key, NOT_SET);\n      return v === NOT_SET ?\n        notSetValue :\n        mapper.call(context, v, key, iterable);\n    };\n    mappedSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      return iterable.__iterate(\n        function(v, k, c)  {return fn(mapper.call(context, v, k, c), k, this$0) !== false},\n        reverse\n      );\n    }\n    mappedSequence.__iteratorUncached = function (type, reverse) {\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      return new Iterator(function()  {\n        var step = iterator.next();\n        if (step.done) {\n          return step;\n        }\n        var entry = step.value;\n        var key = entry[0];\n        return iteratorValue(\n          type,\n          key,\n          mapper.call(context, entry[1], key, iterable),\n          step\n        );\n      });\n    }\n    return mappedSequence;\n  }\n\n\n  function reverseFactory(iterable, useKeys) {\n    var reversedSequence = makeSequence(iterable);\n    reversedSequence._iter = iterable;\n    reversedSequence.size = iterable.size;\n    reversedSequence.reverse = function()  {return iterable};\n    if (iterable.flip) {\n      reversedSequence.flip = function () {\n        var flipSequence = flipFactory(iterable);\n        flipSequence.reverse = function()  {return iterable.flip()};\n        return flipSequence;\n      };\n    }\n    reversedSequence.get = function(key, notSetValue) \n      {return iterable.get(useKeys ? key : -1 - key, notSetValue)};\n    reversedSequence.has = function(key )\n      {return iterable.has(useKeys ? key : -1 - key)};\n    reversedSequence.includes = function(value ) {return iterable.includes(value)};\n    reversedSequence.cacheResult = cacheResultThrough;\n    reversedSequence.__iterate = function (fn, reverse) {var this$0 = this;\n      return iterable.__iterate(function(v, k)  {return fn(v, k, this$0)}, !reverse);\n    };\n    reversedSequence.__iterator =\n      function(type, reverse)  {return iterable.__iterator(type, !reverse)};\n    return reversedSequence;\n  }\n\n\n  function filterFactory(iterable, predicate, context, useKeys) {\n    var filterSequence = makeSequence(iterable);\n    if (useKeys) {\n      filterSequence.has = function(key ) {\n        var v = iterable.get(key, NOT_SET);\n        return v !== NOT_SET && !!predicate.call(context, v, key, iterable);\n      };\n      filterSequence.get = function(key, notSetValue)  {\n        var v = iterable.get(key, NOT_SET);\n        return v !== NOT_SET && predicate.call(context, v, key, iterable) ?\n          v : notSetValue;\n      };\n    }\n    filterSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      iterable.__iterate(function(v, k, c)  {\n        if (predicate.call(context, v, k, c)) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$0);\n        }\n      }, reverse);\n      return iterations;\n    };\n    filterSequence.__iteratorUncached = function (type, reverse) {\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      var iterations = 0;\n      return new Iterator(function()  {\n        while (true) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          var entry = step.value;\n          var key = entry[0];\n          var value = entry[1];\n          if (predicate.call(context, value, key, iterable)) {\n            return iteratorValue(type, useKeys ? key : iterations++, value, step);\n          }\n        }\n      });\n    }\n    return filterSequence;\n  }\n\n\n  function countByFactory(iterable, grouper, context) {\n    var groups = Map().asMutable();\n    iterable.__iterate(function(v, k)  {\n      groups.update(\n        grouper.call(context, v, k, iterable),\n        0,\n        function(a ) {return a + 1}\n      );\n    });\n    return groups.asImmutable();\n  }\n\n\n  function groupByFactory(iterable, grouper, context) {\n    var isKeyedIter = isKeyed(iterable);\n    var groups = (isOrdered(iterable) ? OrderedMap() : Map()).asMutable();\n    iterable.__iterate(function(v, k)  {\n      groups.update(\n        grouper.call(context, v, k, iterable),\n        function(a ) {return (a = a || [], a.push(isKeyedIter ? [k, v] : v), a)}\n      );\n    });\n    var coerce = iterableClass(iterable);\n    return groups.map(function(arr ) {return reify(iterable, coerce(arr))});\n  }\n\n\n  function sliceFactory(iterable, begin, end, useKeys) {\n    var originalSize = iterable.size;\n\n    // Sanitize begin & end using this shorthand for ToInt32(argument)\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n    if (begin !== undefined) {\n      begin = begin | 0;\n    }\n    if (end !== undefined) {\n      end = end | 0;\n    }\n\n    if (wholeSlice(begin, end, originalSize)) {\n      return iterable;\n    }\n\n    var resolvedBegin = resolveBegin(begin, originalSize);\n    var resolvedEnd = resolveEnd(end, originalSize);\n\n    // begin or end will be NaN if they were provided as negative numbers and\n    // this iterable's size is unknown. In that case, cache first so there is\n    // a known size and these do not resolve to NaN.\n    if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {\n      return sliceFactory(iterable.toSeq().cacheResult(), begin, end, useKeys);\n    }\n\n    // Note: resolvedEnd is undefined when the original sequence's length is\n    // unknown and this slice did not supply an end and should contain all\n    // elements after resolvedBegin.\n    // In that case, resolvedSize will be NaN and sliceSize will remain undefined.\n    var resolvedSize = resolvedEnd - resolvedBegin;\n    var sliceSize;\n    if (resolvedSize === resolvedSize) {\n      sliceSize = resolvedSize < 0 ? 0 : resolvedSize;\n    }\n\n    var sliceSeq = makeSequence(iterable);\n\n    // If iterable.size is undefined, the size of the realized sliceSeq is\n    // unknown at this point unless the number of items to slice is 0\n    sliceSeq.size = sliceSize === 0 ? sliceSize : iterable.size && sliceSize || undefined;\n\n    if (!useKeys && isSeq(iterable) && sliceSize >= 0) {\n      sliceSeq.get = function (index, notSetValue) {\n        index = wrapIndex(this, index);\n        return index >= 0 && index < sliceSize ?\n          iterable.get(index + resolvedBegin, notSetValue) :\n          notSetValue;\n      }\n    }\n\n    sliceSeq.__iterateUncached = function(fn, reverse) {var this$0 = this;\n      if (sliceSize === 0) {\n        return 0;\n      }\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var skipped = 0;\n      var isSkipping = true;\n      var iterations = 0;\n      iterable.__iterate(function(v, k)  {\n        if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$0) !== false &&\n                 iterations !== sliceSize;\n        }\n      });\n      return iterations;\n    };\n\n    sliceSeq.__iteratorUncached = function(type, reverse) {\n      if (sliceSize !== 0 && reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      // Don't bother instantiating parent iterator if taking 0.\n      var iterator = sliceSize !== 0 && iterable.__iterator(type, reverse);\n      var skipped = 0;\n      var iterations = 0;\n      return new Iterator(function()  {\n        while (skipped++ < resolvedBegin) {\n          iterator.next();\n        }\n        if (++iterations > sliceSize) {\n          return iteratorDone();\n        }\n        var step = iterator.next();\n        if (useKeys || type === ITERATE_VALUES) {\n          return step;\n        } else if (type === ITERATE_KEYS) {\n          return iteratorValue(type, iterations - 1, undefined, step);\n        } else {\n          return iteratorValue(type, iterations - 1, step.value[1], step);\n        }\n      });\n    }\n\n    return sliceSeq;\n  }\n\n\n  function takeWhileFactory(iterable, predicate, context) {\n    var takeSequence = makeSequence(iterable);\n    takeSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterations = 0;\n      iterable.__iterate(function(v, k, c) \n        {return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$0)}\n      );\n      return iterations;\n    };\n    takeSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      var iterating = true;\n      return new Iterator(function()  {\n        if (!iterating) {\n          return iteratorDone();\n        }\n        var step = iterator.next();\n        if (step.done) {\n          return step;\n        }\n        var entry = step.value;\n        var k = entry[0];\n        var v = entry[1];\n        if (!predicate.call(context, v, k, this$0)) {\n          iterating = false;\n          return iteratorDone();\n        }\n        return type === ITERATE_ENTRIES ? step :\n          iteratorValue(type, k, v, step);\n      });\n    };\n    return takeSequence;\n  }\n\n\n  function skipWhileFactory(iterable, predicate, context, useKeys) {\n    var skipSequence = makeSequence(iterable);\n    skipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var isSkipping = true;\n      var iterations = 0;\n      iterable.__iterate(function(v, k, c)  {\n        if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$0);\n        }\n      });\n      return iterations;\n    };\n    skipSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      var skipping = true;\n      var iterations = 0;\n      return new Iterator(function()  {\n        var step, k, v;\n        do {\n          step = iterator.next();\n          if (step.done) {\n            if (useKeys || type === ITERATE_VALUES) {\n              return step;\n            } else if (type === ITERATE_KEYS) {\n              return iteratorValue(type, iterations++, undefined, step);\n            } else {\n              return iteratorValue(type, iterations++, step.value[1], step);\n            }\n          }\n          var entry = step.value;\n          k = entry[0];\n          v = entry[1];\n          skipping && (skipping = predicate.call(context, v, k, this$0));\n        } while (skipping);\n        return type === ITERATE_ENTRIES ? step :\n          iteratorValue(type, k, v, step);\n      });\n    };\n    return skipSequence;\n  }\n\n\n  function concatFactory(iterable, values) {\n    var isKeyedIterable = isKeyed(iterable);\n    var iters = [iterable].concat(values).map(function(v ) {\n      if (!isIterable(v)) {\n        v = isKeyedIterable ?\n          keyedSeqFromValue(v) :\n          indexedSeqFromValue(Array.isArray(v) ? v : [v]);\n      } else if (isKeyedIterable) {\n        v = KeyedIterable(v);\n      }\n      return v;\n    }).filter(function(v ) {return v.size !== 0});\n\n    if (iters.length === 0) {\n      return iterable;\n    }\n\n    if (iters.length === 1) {\n      var singleton = iters[0];\n      if (singleton === iterable ||\n          isKeyedIterable && isKeyed(singleton) ||\n          isIndexed(iterable) && isIndexed(singleton)) {\n        return singleton;\n      }\n    }\n\n    var concatSeq = new ArraySeq(iters);\n    if (isKeyedIterable) {\n      concatSeq = concatSeq.toKeyedSeq();\n    } else if (!isIndexed(iterable)) {\n      concatSeq = concatSeq.toSetSeq();\n    }\n    concatSeq = concatSeq.flatten(true);\n    concatSeq.size = iters.reduce(\n      function(sum, seq)  {\n        if (sum !== undefined) {\n          var size = seq.size;\n          if (size !== undefined) {\n            return sum + size;\n          }\n        }\n      },\n      0\n    );\n    return concatSeq;\n  }\n\n\n  function flattenFactory(iterable, depth, useKeys) {\n    var flatSequence = makeSequence(iterable);\n    flatSequence.__iterateUncached = function(fn, reverse) {\n      var iterations = 0;\n      var stopped = false;\n      function flatDeep(iter, currentDepth) {var this$0 = this;\n        iter.__iterate(function(v, k)  {\n          if ((!depth || currentDepth < depth) && isIterable(v)) {\n            flatDeep(v, currentDepth + 1);\n          } else if (fn(v, useKeys ? k : iterations++, this$0) === false) {\n            stopped = true;\n          }\n          return !stopped;\n        }, reverse);\n      }\n      flatDeep(iterable, 0);\n      return iterations;\n    }\n    flatSequence.__iteratorUncached = function(type, reverse) {\n      var iterator = iterable.__iterator(type, reverse);\n      var stack = [];\n      var iterations = 0;\n      return new Iterator(function()  {\n        while (iterator) {\n          var step = iterator.next();\n          if (step.done !== false) {\n            iterator = stack.pop();\n            continue;\n          }\n          var v = step.value;\n          if (type === ITERATE_ENTRIES) {\n            v = v[1];\n          }\n          if ((!depth || stack.length < depth) && isIterable(v)) {\n            stack.push(iterator);\n            iterator = v.__iterator(type, reverse);\n          } else {\n            return useKeys ? step : iteratorValue(type, iterations++, v, step);\n          }\n        }\n        return iteratorDone();\n      });\n    }\n    return flatSequence;\n  }\n\n\n  function flatMapFactory(iterable, mapper, context) {\n    var coerce = iterableClass(iterable);\n    return iterable.toSeq().map(\n      function(v, k)  {return coerce(mapper.call(context, v, k, iterable))}\n    ).flatten(true);\n  }\n\n\n  function interposeFactory(iterable, separator) {\n    var interposedSequence = makeSequence(iterable);\n    interposedSequence.size = iterable.size && iterable.size * 2 -1;\n    interposedSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      iterable.__iterate(function(v, k) \n        {return (!iterations || fn(separator, iterations++, this$0) !== false) &&\n        fn(v, iterations++, this$0) !== false},\n        reverse\n      );\n      return iterations;\n    };\n    interposedSequence.__iteratorUncached = function(type, reverse) {\n      var iterator = iterable.__iterator(ITERATE_VALUES, reverse);\n      var iterations = 0;\n      var step;\n      return new Iterator(function()  {\n        if (!step || iterations % 2) {\n          step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n        }\n        return iterations % 2 ?\n          iteratorValue(type, iterations++, separator) :\n          iteratorValue(type, iterations++, step.value, step);\n      });\n    };\n    return interposedSequence;\n  }\n\n\n  function sortFactory(iterable, comparator, mapper) {\n    if (!comparator) {\n      comparator = defaultComparator;\n    }\n    var isKeyedIterable = isKeyed(iterable);\n    var index = 0;\n    var entries = iterable.toSeq().map(\n      function(v, k)  {return [k, v, index++, mapper ? mapper(v, k, iterable) : v]}\n    ).toArray();\n    entries.sort(function(a, b)  {return comparator(a[3], b[3]) || a[2] - b[2]}).forEach(\n      isKeyedIterable ?\n      function(v, i)  { entries[i].length = 2; } :\n      function(v, i)  { entries[i] = v[1]; }\n    );\n    return isKeyedIterable ? KeyedSeq(entries) :\n      isIndexed(iterable) ? IndexedSeq(entries) :\n      SetSeq(entries);\n  }\n\n\n  function maxFactory(iterable, comparator, mapper) {\n    if (!comparator) {\n      comparator = defaultComparator;\n    }\n    if (mapper) {\n      var entry = iterable.toSeq()\n        .map(function(v, k)  {return [v, mapper(v, k, iterable)]})\n        .reduce(function(a, b)  {return maxCompare(comparator, a[1], b[1]) ? b : a});\n      return entry && entry[0];\n    } else {\n      return iterable.reduce(function(a, b)  {return maxCompare(comparator, a, b) ? b : a});\n    }\n  }\n\n  function maxCompare(comparator, a, b) {\n    var comp = comparator(b, a);\n    // b is considered the new max if the comparator declares them equal, but\n    // they are not equal and b is in fact a nullish value.\n    return (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) || comp > 0;\n  }\n\n\n  function zipWithFactory(keyIter, zipper, iters) {\n    var zipSequence = makeSequence(keyIter);\n    zipSequence.size = new ArraySeq(iters).map(function(i ) {return i.size}).min();\n    // Note: this a generic base implementation of __iterate in terms of\n    // __iterator which may be more generically useful in the future.\n    zipSequence.__iterate = function(fn, reverse) {\n      /* generic:\n      var iterator = this.__iterator(ITERATE_ENTRIES, reverse);\n      var step;\n      var iterations = 0;\n      while (!(step = iterator.next()).done) {\n        iterations++;\n        if (fn(step.value[1], step.value[0], this) === false) {\n          break;\n        }\n      }\n      return iterations;\n      */\n      // indexed:\n      var iterator = this.__iterator(ITERATE_VALUES, reverse);\n      var step;\n      var iterations = 0;\n      while (!(step = iterator.next()).done) {\n        if (fn(step.value, iterations++, this) === false) {\n          break;\n        }\n      }\n      return iterations;\n    };\n    zipSequence.__iteratorUncached = function(type, reverse) {\n      var iterators = iters.map(function(i )\n        {return (i = Iterable(i), getIterator(reverse ? i.reverse() : i))}\n      );\n      var iterations = 0;\n      var isDone = false;\n      return new Iterator(function()  {\n        var steps;\n        if (!isDone) {\n          steps = iterators.map(function(i ) {return i.next()});\n          isDone = steps.some(function(s ) {return s.done});\n        }\n        if (isDone) {\n          return iteratorDone();\n        }\n        return iteratorValue(\n          type,\n          iterations++,\n          zipper.apply(null, steps.map(function(s ) {return s.value}))\n        );\n      });\n    };\n    return zipSequence\n  }\n\n\n  // #pragma Helper Functions\n\n  function reify(iter, seq) {\n    return isSeq(iter) ? seq : iter.constructor(seq);\n  }\n\n  function validateEntry(entry) {\n    if (entry !== Object(entry)) {\n      throw new TypeError('Expected [K, V] tuple: ' + entry);\n    }\n  }\n\n  function resolveSize(iter) {\n    assertNotInfinite(iter.size);\n    return ensureSize(iter);\n  }\n\n  function iterableClass(iterable) {\n    return isKeyed(iterable) ? KeyedIterable :\n      isIndexed(iterable) ? IndexedIterable :\n      SetIterable;\n  }\n\n  function makeSequence(iterable) {\n    return Object.create(\n      (\n        isKeyed(iterable) ? KeyedSeq :\n        isIndexed(iterable) ? IndexedSeq :\n        SetSeq\n      ).prototype\n    );\n  }\n\n  function cacheResultThrough() {\n    if (this._iter.cacheResult) {\n      this._iter.cacheResult();\n      this.size = this._iter.size;\n      return this;\n    } else {\n      return Seq.prototype.cacheResult.call(this);\n    }\n  }\n\n  function defaultComparator(a, b) {\n    return a > b ? 1 : a < b ? -1 : 0;\n  }\n\n  function forceIterator(keyPath) {\n    var iter = getIterator(keyPath);\n    if (!iter) {\n      // Array might not be iterable in this environment, so we need a fallback\n      // to our wrapped type.\n      if (!isArrayLike(keyPath)) {\n        throw new TypeError('Expected iterable or array-like: ' + keyPath);\n      }\n      iter = getIterator(Iterable(keyPath));\n    }\n    return iter;\n  }\n\n  createClass(Record, KeyedCollection);\n\n    function Record(defaultValues, name) {\n      var hasInitialized;\n\n      var RecordType = function Record(values) {\n        if (values instanceof RecordType) {\n          return values;\n        }\n        if (!(this instanceof RecordType)) {\n          return new RecordType(values);\n        }\n        if (!hasInitialized) {\n          hasInitialized = true;\n          var keys = Object.keys(defaultValues);\n          setProps(RecordTypePrototype, keys);\n          RecordTypePrototype.size = keys.length;\n          RecordTypePrototype._name = name;\n          RecordTypePrototype._keys = keys;\n          RecordTypePrototype._defaultValues = defaultValues;\n        }\n        this._map = Map(values);\n      };\n\n      var RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype);\n      RecordTypePrototype.constructor = RecordType;\n\n      return RecordType;\n    }\n\n    Record.prototype.toString = function() {\n      return this.__toString(recordName(this) + ' {', '}');\n    };\n\n    // @pragma Access\n\n    Record.prototype.has = function(k) {\n      return this._defaultValues.hasOwnProperty(k);\n    };\n\n    Record.prototype.get = function(k, notSetValue) {\n      if (!this.has(k)) {\n        return notSetValue;\n      }\n      var defaultVal = this._defaultValues[k];\n      return this._map ? this._map.get(k, defaultVal) : defaultVal;\n    };\n\n    // @pragma Modification\n\n    Record.prototype.clear = function() {\n      if (this.__ownerID) {\n        this._map && this._map.clear();\n        return this;\n      }\n      var RecordType = this.constructor;\n      return RecordType._empty || (RecordType._empty = makeRecord(this, emptyMap()));\n    };\n\n    Record.prototype.set = function(k, v) {\n      if (!this.has(k)) {\n        throw new Error('Cannot set unknown key \"' + k + '\" on ' + recordName(this));\n      }\n      var newMap = this._map && this._map.set(k, v);\n      if (this.__ownerID || newMap === this._map) {\n        return this;\n      }\n      return makeRecord(this, newMap);\n    };\n\n    Record.prototype.remove = function(k) {\n      if (!this.has(k)) {\n        return this;\n      }\n      var newMap = this._map && this._map.remove(k);\n      if (this.__ownerID || newMap === this._map) {\n        return this;\n      }\n      return makeRecord(this, newMap);\n    };\n\n    Record.prototype.wasAltered = function() {\n      return this._map.wasAltered();\n    };\n\n    Record.prototype.__iterator = function(type, reverse) {var this$0 = this;\n      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterator(type, reverse);\n    };\n\n    Record.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterate(fn, reverse);\n    };\n\n    Record.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map && this._map.__ensureOwner(ownerID);\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        return this;\n      }\n      return makeRecord(this, newMap, ownerID);\n    };\n\n\n  var RecordPrototype = Record.prototype;\n  RecordPrototype[DELETE] = RecordPrototype.remove;\n  RecordPrototype.deleteIn =\n  RecordPrototype.removeIn = MapPrototype.removeIn;\n  RecordPrototype.merge = MapPrototype.merge;\n  RecordPrototype.mergeWith = MapPrototype.mergeWith;\n  RecordPrototype.mergeIn = MapPrototype.mergeIn;\n  RecordPrototype.mergeDeep = MapPrototype.mergeDeep;\n  RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith;\n  RecordPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;\n  RecordPrototype.setIn = MapPrototype.setIn;\n  RecordPrototype.update = MapPrototype.update;\n  RecordPrototype.updateIn = MapPrototype.updateIn;\n  RecordPrototype.withMutations = MapPrototype.withMutations;\n  RecordPrototype.asMutable = MapPrototype.asMutable;\n  RecordPrototype.asImmutable = MapPrototype.asImmutable;\n\n\n  function makeRecord(likeRecord, map, ownerID) {\n    var record = Object.create(Object.getPrototypeOf(likeRecord));\n    record._map = map;\n    record.__ownerID = ownerID;\n    return record;\n  }\n\n  function recordName(record) {\n    return record._name || record.constructor.name || 'Record';\n  }\n\n  function setProps(prototype, names) {\n    try {\n      names.forEach(setProp.bind(undefined, prototype));\n    } catch (error) {\n      // Object.defineProperty failed. Probably IE8.\n    }\n  }\n\n  function setProp(prototype, name) {\n    Object.defineProperty(prototype, name, {\n      get: function() {\n        return this.get(name);\n      },\n      set: function(value) {\n        invariant(this.__ownerID, 'Cannot set on an immutable record.');\n        this.set(name, value);\n      }\n    });\n  }\n\n  createClass(Set, SetCollection);\n\n    // @pragma Construction\n\n    function Set(value) {\n      return value === null || value === undefined ? emptySet() :\n        isSet(value) && !isOrdered(value) ? value :\n        emptySet().withMutations(function(set ) {\n          var iter = SetIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v ) {return set.add(v)});\n        });\n    }\n\n    Set.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    Set.fromKeys = function(value) {\n      return this(KeyedIterable(value).keySeq());\n    };\n\n    Set.prototype.toString = function() {\n      return this.__toString('Set {', '}');\n    };\n\n    // @pragma Access\n\n    Set.prototype.has = function(value) {\n      return this._map.has(value);\n    };\n\n    // @pragma Modification\n\n    Set.prototype.add = function(value) {\n      return updateSet(this, this._map.set(value, true));\n    };\n\n    Set.prototype.remove = function(value) {\n      return updateSet(this, this._map.remove(value));\n    };\n\n    Set.prototype.clear = function() {\n      return updateSet(this, this._map.clear());\n    };\n\n    // @pragma Composition\n\n    Set.prototype.union = function() {var iters = SLICE$0.call(arguments, 0);\n      iters = iters.filter(function(x ) {return x.size !== 0});\n      if (iters.length === 0) {\n        return this;\n      }\n      if (this.size === 0 && !this.__ownerID && iters.length === 1) {\n        return this.constructor(iters[0]);\n      }\n      return this.withMutations(function(set ) {\n        for (var ii = 0; ii < iters.length; ii++) {\n          SetIterable(iters[ii]).forEach(function(value ) {return set.add(value)});\n        }\n      });\n    };\n\n    Set.prototype.intersect = function() {var iters = SLICE$0.call(arguments, 0);\n      if (iters.length === 0) {\n        return this;\n      }\n      iters = iters.map(function(iter ) {return SetIterable(iter)});\n      var originalSet = this;\n      return this.withMutations(function(set ) {\n        originalSet.forEach(function(value ) {\n          if (!iters.every(function(iter ) {return iter.includes(value)})) {\n            set.remove(value);\n          }\n        });\n      });\n    };\n\n    Set.prototype.subtract = function() {var iters = SLICE$0.call(arguments, 0);\n      if (iters.length === 0) {\n        return this;\n      }\n      iters = iters.map(function(iter ) {return SetIterable(iter)});\n      var originalSet = this;\n      return this.withMutations(function(set ) {\n        originalSet.forEach(function(value ) {\n          if (iters.some(function(iter ) {return iter.includes(value)})) {\n            set.remove(value);\n          }\n        });\n      });\n    };\n\n    Set.prototype.merge = function() {\n      return this.union.apply(this, arguments);\n    };\n\n    Set.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return this.union.apply(this, iters);\n    };\n\n    Set.prototype.sort = function(comparator) {\n      // Late binding\n      return OrderedSet(sortFactory(this, comparator));\n    };\n\n    Set.prototype.sortBy = function(mapper, comparator) {\n      // Late binding\n      return OrderedSet(sortFactory(this, comparator, mapper));\n    };\n\n    Set.prototype.wasAltered = function() {\n      return this._map.wasAltered();\n    };\n\n    Set.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._map.__iterate(function(_, k)  {return fn(k, k, this$0)}, reverse);\n    };\n\n    Set.prototype.__iterator = function(type, reverse) {\n      return this._map.map(function(_, k)  {return k}).__iterator(type, reverse);\n    };\n\n    Set.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map.__ensureOwner(ownerID);\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        return this;\n      }\n      return this.__make(newMap, ownerID);\n    };\n\n\n  function isSet(maybeSet) {\n    return !!(maybeSet && maybeSet[IS_SET_SENTINEL]);\n  }\n\n  Set.isSet = isSet;\n\n  var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';\n\n  var SetPrototype = Set.prototype;\n  SetPrototype[IS_SET_SENTINEL] = true;\n  SetPrototype[DELETE] = SetPrototype.remove;\n  SetPrototype.mergeDeep = SetPrototype.merge;\n  SetPrototype.mergeDeepWith = SetPrototype.mergeWith;\n  SetPrototype.withMutations = MapPrototype.withMutations;\n  SetPrototype.asMutable = MapPrototype.asMutable;\n  SetPrototype.asImmutable = MapPrototype.asImmutable;\n\n  SetPrototype.__empty = emptySet;\n  SetPrototype.__make = makeSet;\n\n  function updateSet(set, newMap) {\n    if (set.__ownerID) {\n      set.size = newMap.size;\n      set._map = newMap;\n      return set;\n    }\n    return newMap === set._map ? set :\n      newMap.size === 0 ? set.__empty() :\n      set.__make(newMap);\n  }\n\n  function makeSet(map, ownerID) {\n    var set = Object.create(SetPrototype);\n    set.size = map ? map.size : 0;\n    set._map = map;\n    set.__ownerID = ownerID;\n    return set;\n  }\n\n  var EMPTY_SET;\n  function emptySet() {\n    return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));\n  }\n\n  createClass(OrderedSet, Set);\n\n    // @pragma Construction\n\n    function OrderedSet(value) {\n      return value === null || value === undefined ? emptyOrderedSet() :\n        isOrderedSet(value) ? value :\n        emptyOrderedSet().withMutations(function(set ) {\n          var iter = SetIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v ) {return set.add(v)});\n        });\n    }\n\n    OrderedSet.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    OrderedSet.fromKeys = function(value) {\n      return this(KeyedIterable(value).keySeq());\n    };\n\n    OrderedSet.prototype.toString = function() {\n      return this.__toString('OrderedSet {', '}');\n    };\n\n\n  function isOrderedSet(maybeOrderedSet) {\n    return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);\n  }\n\n  OrderedSet.isOrderedSet = isOrderedSet;\n\n  var OrderedSetPrototype = OrderedSet.prototype;\n  OrderedSetPrototype[IS_ORDERED_SENTINEL] = true;\n\n  OrderedSetPrototype.__empty = emptyOrderedSet;\n  OrderedSetPrototype.__make = makeOrderedSet;\n\n  function makeOrderedSet(map, ownerID) {\n    var set = Object.create(OrderedSetPrototype);\n    set.size = map ? map.size : 0;\n    set._map = map;\n    set.__ownerID = ownerID;\n    return set;\n  }\n\n  var EMPTY_ORDERED_SET;\n  function emptyOrderedSet() {\n    return EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()));\n  }\n\n  createClass(Stack, IndexedCollection);\n\n    // @pragma Construction\n\n    function Stack(value) {\n      return value === null || value === undefined ? emptyStack() :\n        isStack(value) ? value :\n        emptyStack().unshiftAll(value);\n    }\n\n    Stack.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    Stack.prototype.toString = function() {\n      return this.__toString('Stack [', ']');\n    };\n\n    // @pragma Access\n\n    Stack.prototype.get = function(index, notSetValue) {\n      var head = this._head;\n      index = wrapIndex(this, index);\n      while (head && index--) {\n        head = head.next;\n      }\n      return head ? head.value : notSetValue;\n    };\n\n    Stack.prototype.peek = function() {\n      return this._head && this._head.value;\n    };\n\n    // @pragma Modification\n\n    Stack.prototype.push = function(/*...values*/) {\n      if (arguments.length === 0) {\n        return this;\n      }\n      var newSize = this.size + arguments.length;\n      var head = this._head;\n      for (var ii = arguments.length - 1; ii >= 0; ii--) {\n        head = {\n          value: arguments[ii],\n          next: head\n        };\n      }\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    Stack.prototype.pushAll = function(iter) {\n      iter = IndexedIterable(iter);\n      if (iter.size === 0) {\n        return this;\n      }\n      assertNotInfinite(iter.size);\n      var newSize = this.size;\n      var head = this._head;\n      iter.reverse().forEach(function(value ) {\n        newSize++;\n        head = {\n          value: value,\n          next: head\n        };\n      });\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    Stack.prototype.pop = function() {\n      return this.slice(1);\n    };\n\n    Stack.prototype.unshift = function(/*...values*/) {\n      return this.push.apply(this, arguments);\n    };\n\n    Stack.prototype.unshiftAll = function(iter) {\n      return this.pushAll(iter);\n    };\n\n    Stack.prototype.shift = function() {\n      return this.pop.apply(this, arguments);\n    };\n\n    Stack.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._head = undefined;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyStack();\n    };\n\n    Stack.prototype.slice = function(begin, end) {\n      if (wholeSlice(begin, end, this.size)) {\n        return this;\n      }\n      var resolvedBegin = resolveBegin(begin, this.size);\n      var resolvedEnd = resolveEnd(end, this.size);\n      if (resolvedEnd !== this.size) {\n        // super.slice(begin, end);\n        return IndexedCollection.prototype.slice.call(this, begin, end);\n      }\n      var newSize = this.size - resolvedBegin;\n      var head = this._head;\n      while (resolvedBegin--) {\n        head = head.next;\n      }\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    // @pragma Mutability\n\n    Stack.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this.__altered = false;\n        return this;\n      }\n      return makeStack(this.size, this._head, ownerID, this.__hash);\n    };\n\n    // @pragma Iteration\n\n    Stack.prototype.__iterate = function(fn, reverse) {\n      if (reverse) {\n        return this.reverse().__iterate(fn);\n      }\n      var iterations = 0;\n      var node = this._head;\n      while (node) {\n        if (fn(node.value, iterations++, this) === false) {\n          break;\n        }\n        node = node.next;\n      }\n      return iterations;\n    };\n\n    Stack.prototype.__iterator = function(type, reverse) {\n      if (reverse) {\n        return this.reverse().__iterator(type);\n      }\n      var iterations = 0;\n      var node = this._head;\n      return new Iterator(function()  {\n        if (node) {\n          var value = node.value;\n          node = node.next;\n          return iteratorValue(type, iterations++, value);\n        }\n        return iteratorDone();\n      });\n    };\n\n\n  function isStack(maybeStack) {\n    return !!(maybeStack && maybeStack[IS_STACK_SENTINEL]);\n  }\n\n  Stack.isStack = isStack;\n\n  var IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';\n\n  var StackPrototype = Stack.prototype;\n  StackPrototype[IS_STACK_SENTINEL] = true;\n  StackPrototype.withMutations = MapPrototype.withMutations;\n  StackPrototype.asMutable = MapPrototype.asMutable;\n  StackPrototype.asImmutable = MapPrototype.asImmutable;\n  StackPrototype.wasAltered = MapPrototype.wasAltered;\n\n\n  function makeStack(size, head, ownerID, hash) {\n    var map = Object.create(StackPrototype);\n    map.size = size;\n    map._head = head;\n    map.__ownerID = ownerID;\n    map.__hash = hash;\n    map.__altered = false;\n    return map;\n  }\n\n  var EMPTY_STACK;\n  function emptyStack() {\n    return EMPTY_STACK || (EMPTY_STACK = makeStack(0));\n  }\n\n  /**\n   * Contributes additional methods to a constructor\n   */\n  function mixin(ctor, methods) {\n    var keyCopier = function(key ) { ctor.prototype[key] = methods[key]; };\n    Object.keys(methods).forEach(keyCopier);\n    Object.getOwnPropertySymbols &&\n      Object.getOwnPropertySymbols(methods).forEach(keyCopier);\n    return ctor;\n  }\n\n  Iterable.Iterator = Iterator;\n\n  mixin(Iterable, {\n\n    // ### Conversion to other types\n\n    toArray: function() {\n      assertNotInfinite(this.size);\n      var array = new Array(this.size || 0);\n      this.valueSeq().__iterate(function(v, i)  { array[i] = v; });\n      return array;\n    },\n\n    toIndexedSeq: function() {\n      return new ToIndexedSequence(this);\n    },\n\n    toJS: function() {\n      return this.toSeq().map(\n        function(value ) {return value && typeof value.toJS === 'function' ? value.toJS() : value}\n      ).__toJS();\n    },\n\n    toJSON: function() {\n      return this.toSeq().map(\n        function(value ) {return value && typeof value.toJSON === 'function' ? value.toJSON() : value}\n      ).__toJS();\n    },\n\n    toKeyedSeq: function() {\n      return new ToKeyedSequence(this, true);\n    },\n\n    toMap: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return Map(this.toKeyedSeq());\n    },\n\n    toObject: function() {\n      assertNotInfinite(this.size);\n      var object = {};\n      this.__iterate(function(v, k)  { object[k] = v; });\n      return object;\n    },\n\n    toOrderedMap: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return OrderedMap(this.toKeyedSeq());\n    },\n\n    toOrderedSet: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return OrderedSet(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toSet: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return Set(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toSetSeq: function() {\n      return new ToSetSequence(this);\n    },\n\n    toSeq: function() {\n      return isIndexed(this) ? this.toIndexedSeq() :\n        isKeyed(this) ? this.toKeyedSeq() :\n        this.toSetSeq();\n    },\n\n    toStack: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return Stack(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toList: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return List(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n\n    // ### Common JavaScript methods and properties\n\n    toString: function() {\n      return '[Iterable]';\n    },\n\n    __toString: function(head, tail) {\n      if (this.size === 0) {\n        return head + tail;\n      }\n      return head + ' ' + this.toSeq().map(this.__toStringMapper).join(', ') + ' ' + tail;\n    },\n\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    concat: function() {var values = SLICE$0.call(arguments, 0);\n      return reify(this, concatFactory(this, values));\n    },\n\n    includes: function(searchValue) {\n      return this.some(function(value ) {return is(value, searchValue)});\n    },\n\n    entries: function() {\n      return this.__iterator(ITERATE_ENTRIES);\n    },\n\n    every: function(predicate, context) {\n      assertNotInfinite(this.size);\n      var returnValue = true;\n      this.__iterate(function(v, k, c)  {\n        if (!predicate.call(context, v, k, c)) {\n          returnValue = false;\n          return false;\n        }\n      });\n      return returnValue;\n    },\n\n    filter: function(predicate, context) {\n      return reify(this, filterFactory(this, predicate, context, true));\n    },\n\n    find: function(predicate, context, notSetValue) {\n      var entry = this.findEntry(predicate, context);\n      return entry ? entry[1] : notSetValue;\n    },\n\n    findEntry: function(predicate, context) {\n      var found;\n      this.__iterate(function(v, k, c)  {\n        if (predicate.call(context, v, k, c)) {\n          found = [k, v];\n          return false;\n        }\n      });\n      return found;\n    },\n\n    findLastEntry: function(predicate, context) {\n      return this.toSeq().reverse().findEntry(predicate, context);\n    },\n\n    forEach: function(sideEffect, context) {\n      assertNotInfinite(this.size);\n      return this.__iterate(context ? sideEffect.bind(context) : sideEffect);\n    },\n\n    join: function(separator) {\n      assertNotInfinite(this.size);\n      separator = separator !== undefined ? '' + separator : ',';\n      var joined = '';\n      var isFirst = true;\n      this.__iterate(function(v ) {\n        isFirst ? (isFirst = false) : (joined += separator);\n        joined += v !== null && v !== undefined ? v.toString() : '';\n      });\n      return joined;\n    },\n\n    keys: function() {\n      return this.__iterator(ITERATE_KEYS);\n    },\n\n    map: function(mapper, context) {\n      return reify(this, mapFactory(this, mapper, context));\n    },\n\n    reduce: function(reducer, initialReduction, context) {\n      assertNotInfinite(this.size);\n      var reduction;\n      var useFirst;\n      if (arguments.length < 2) {\n        useFirst = true;\n      } else {\n        reduction = initialReduction;\n      }\n      this.__iterate(function(v, k, c)  {\n        if (useFirst) {\n          useFirst = false;\n          reduction = v;\n        } else {\n          reduction = reducer.call(context, reduction, v, k, c);\n        }\n      });\n      return reduction;\n    },\n\n    reduceRight: function(reducer, initialReduction, context) {\n      var reversed = this.toKeyedSeq().reverse();\n      return reversed.reduce.apply(reversed, arguments);\n    },\n\n    reverse: function() {\n      return reify(this, reverseFactory(this, true));\n    },\n\n    slice: function(begin, end) {\n      return reify(this, sliceFactory(this, begin, end, true));\n    },\n\n    some: function(predicate, context) {\n      return !this.every(not(predicate), context);\n    },\n\n    sort: function(comparator) {\n      return reify(this, sortFactory(this, comparator));\n    },\n\n    values: function() {\n      return this.__iterator(ITERATE_VALUES);\n    },\n\n\n    // ### More sequential methods\n\n    butLast: function() {\n      return this.slice(0, -1);\n    },\n\n    isEmpty: function() {\n      return this.size !== undefined ? this.size === 0 : !this.some(function()  {return true});\n    },\n\n    count: function(predicate, context) {\n      return ensureSize(\n        predicate ? this.toSeq().filter(predicate, context) : this\n      );\n    },\n\n    countBy: function(grouper, context) {\n      return countByFactory(this, grouper, context);\n    },\n\n    equals: function(other) {\n      return deepEqual(this, other);\n    },\n\n    entrySeq: function() {\n      var iterable = this;\n      if (iterable._cache) {\n        // We cache as an entries array, so we can just return the cache!\n        return new ArraySeq(iterable._cache);\n      }\n      var entriesSequence = iterable.toSeq().map(entryMapper).toIndexedSeq();\n      entriesSequence.fromEntrySeq = function()  {return iterable.toSeq()};\n      return entriesSequence;\n    },\n\n    filterNot: function(predicate, context) {\n      return this.filter(not(predicate), context);\n    },\n\n    findLast: function(predicate, context, notSetValue) {\n      return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);\n    },\n\n    first: function() {\n      return this.find(returnTrue);\n    },\n\n    flatMap: function(mapper, context) {\n      return reify(this, flatMapFactory(this, mapper, context));\n    },\n\n    flatten: function(depth) {\n      return reify(this, flattenFactory(this, depth, true));\n    },\n\n    fromEntrySeq: function() {\n      return new FromEntriesSequence(this);\n    },\n\n    get: function(searchKey, notSetValue) {\n      return this.find(function(_, key)  {return is(key, searchKey)}, undefined, notSetValue);\n    },\n\n    getIn: function(searchKeyPath, notSetValue) {\n      var nested = this;\n      // Note: in an ES6 environment, we would prefer:\n      // for (var key of searchKeyPath) {\n      var iter = forceIterator(searchKeyPath);\n      var step;\n      while (!(step = iter.next()).done) {\n        var key = step.value;\n        nested = nested && nested.get ? nested.get(key, NOT_SET) : NOT_SET;\n        if (nested === NOT_SET) {\n          return notSetValue;\n        }\n      }\n      return nested;\n    },\n\n    groupBy: function(grouper, context) {\n      return groupByFactory(this, grouper, context);\n    },\n\n    has: function(searchKey) {\n      return this.get(searchKey, NOT_SET) !== NOT_SET;\n    },\n\n    hasIn: function(searchKeyPath) {\n      return this.getIn(searchKeyPath, NOT_SET) !== NOT_SET;\n    },\n\n    isSubset: function(iter) {\n      iter = typeof iter.includes === 'function' ? iter : Iterable(iter);\n      return this.every(function(value ) {return iter.includes(value)});\n    },\n\n    isSuperset: function(iter) {\n      iter = typeof iter.isSubset === 'function' ? iter : Iterable(iter);\n      return iter.isSubset(this);\n    },\n\n    keySeq: function() {\n      return this.toSeq().map(keyMapper).toIndexedSeq();\n    },\n\n    last: function() {\n      return this.toSeq().reverse().first();\n    },\n\n    max: function(comparator) {\n      return maxFactory(this, comparator);\n    },\n\n    maxBy: function(mapper, comparator) {\n      return maxFactory(this, comparator, mapper);\n    },\n\n    min: function(comparator) {\n      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator);\n    },\n\n    minBy: function(mapper, comparator) {\n      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator, mapper);\n    },\n\n    rest: function() {\n      return this.slice(1);\n    },\n\n    skip: function(amount) {\n      return this.slice(Math.max(0, amount));\n    },\n\n    skipLast: function(amount) {\n      return reify(this, this.toSeq().reverse().skip(amount).reverse());\n    },\n\n    skipWhile: function(predicate, context) {\n      return reify(this, skipWhileFactory(this, predicate, context, true));\n    },\n\n    skipUntil: function(predicate, context) {\n      return this.skipWhile(not(predicate), context);\n    },\n\n    sortBy: function(mapper, comparator) {\n      return reify(this, sortFactory(this, comparator, mapper));\n    },\n\n    take: function(amount) {\n      return this.slice(0, Math.max(0, amount));\n    },\n\n    takeLast: function(amount) {\n      return reify(this, this.toSeq().reverse().take(amount).reverse());\n    },\n\n    takeWhile: function(predicate, context) {\n      return reify(this, takeWhileFactory(this, predicate, context));\n    },\n\n    takeUntil: function(predicate, context) {\n      return this.takeWhile(not(predicate), context);\n    },\n\n    valueSeq: function() {\n      return this.toIndexedSeq();\n    },\n\n\n    // ### Hashable Object\n\n    hashCode: function() {\n      return this.__hash || (this.__hash = hashIterable(this));\n    }\n\n\n    // ### Internal\n\n    // abstract __iterate(fn, reverse)\n\n    // abstract __iterator(type, reverse)\n  });\n\n  // var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';\n  // var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';\n  // var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';\n  // var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';\n\n  var IterablePrototype = Iterable.prototype;\n  IterablePrototype[IS_ITERABLE_SENTINEL] = true;\n  IterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.values;\n  IterablePrototype.__toJS = IterablePrototype.toArray;\n  IterablePrototype.__toStringMapper = quoteString;\n  IterablePrototype.inspect =\n  IterablePrototype.toSource = function() { return this.toString(); };\n  IterablePrototype.chain = IterablePrototype.flatMap;\n  IterablePrototype.contains = IterablePrototype.includes;\n\n  // Temporary warning about using length\n  (function () {\n    try {\n      Object.defineProperty(IterablePrototype, 'length', {\n        get: function () {\n          if (!Iterable.noLengthWarning) {\n            var stack;\n            try {\n              throw new Error();\n            } catch (error) {\n              stack = error.stack;\n            }\n            if (stack.indexOf('_wrapObject') === -1) {\n              console && console.warn && console.warn(\n                'iterable.length has been deprecated, '+\n                'use iterable.size or iterable.count(). '+\n                'This warning will become a silent error in a future version. ' +\n                stack\n              );\n              return this.size;\n            }\n          }\n        }\n      });\n    } catch (e) {}\n  })();\n\n\n\n  mixin(KeyedIterable, {\n\n    // ### More sequential methods\n\n    flip: function() {\n      return reify(this, flipFactory(this));\n    },\n\n    findKey: function(predicate, context) {\n      var entry = this.findEntry(predicate, context);\n      return entry && entry[0];\n    },\n\n    findLastKey: function(predicate, context) {\n      return this.toSeq().reverse().findKey(predicate, context);\n    },\n\n    keyOf: function(searchValue) {\n      return this.findKey(function(value ) {return is(value, searchValue)});\n    },\n\n    lastKeyOf: function(searchValue) {\n      return this.findLastKey(function(value ) {return is(value, searchValue)});\n    },\n\n    mapEntries: function(mapper, context) {var this$0 = this;\n      var iterations = 0;\n      return reify(this,\n        this.toSeq().map(\n          function(v, k)  {return mapper.call(context, [k, v], iterations++, this$0)}\n        ).fromEntrySeq()\n      );\n    },\n\n    mapKeys: function(mapper, context) {var this$0 = this;\n      return reify(this,\n        this.toSeq().flip().map(\n          function(k, v)  {return mapper.call(context, k, v, this$0)}\n        ).flip()\n      );\n    }\n\n  });\n\n  var KeyedIterablePrototype = KeyedIterable.prototype;\n  KeyedIterablePrototype[IS_KEYED_SENTINEL] = true;\n  KeyedIterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.entries;\n  KeyedIterablePrototype.__toJS = IterablePrototype.toObject;\n  KeyedIterablePrototype.__toStringMapper = function(v, k)  {return JSON.stringify(k) + ': ' + quoteString(v)};\n\n\n\n  mixin(IndexedIterable, {\n\n    // ### Conversion to other types\n\n    toKeyedSeq: function() {\n      return new ToKeyedSequence(this, false);\n    },\n\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    filter: function(predicate, context) {\n      return reify(this, filterFactory(this, predicate, context, false));\n    },\n\n    findIndex: function(predicate, context) {\n      var entry = this.findEntry(predicate, context);\n      return entry ? entry[0] : -1;\n    },\n\n    indexOf: function(searchValue) {\n      var key = this.toKeyedSeq().keyOf(searchValue);\n      return key === undefined ? -1 : key;\n    },\n\n    lastIndexOf: function(searchValue) {\n      var key = this.toKeyedSeq().reverse().keyOf(searchValue);\n      return key === undefined ? -1 : key;\n\n      // var index =\n      // return this.toSeq().reverse().indexOf(searchValue);\n    },\n\n    reverse: function() {\n      return reify(this, reverseFactory(this, false));\n    },\n\n    slice: function(begin, end) {\n      return reify(this, sliceFactory(this, begin, end, false));\n    },\n\n    splice: function(index, removeNum /*, ...values*/) {\n      var numArgs = arguments.length;\n      removeNum = Math.max(removeNum | 0, 0);\n      if (numArgs === 0 || (numArgs === 2 && !removeNum)) {\n        return this;\n      }\n      // If index is negative, it should resolve relative to the size of the\n      // collection. However size may be expensive to compute if not cached, so\n      // only call count() if the number is in fact negative.\n      index = resolveBegin(index, index < 0 ? this.count() : this.size);\n      var spliced = this.slice(0, index);\n      return reify(\n        this,\n        numArgs === 1 ?\n          spliced :\n          spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum))\n      );\n    },\n\n\n    // ### More collection methods\n\n    findLastIndex: function(predicate, context) {\n      var key = this.toKeyedSeq().findLastKey(predicate, context);\n      return key === undefined ? -1 : key;\n    },\n\n    first: function() {\n      return this.get(0);\n    },\n\n    flatten: function(depth) {\n      return reify(this, flattenFactory(this, depth, false));\n    },\n\n    get: function(index, notSetValue) {\n      index = wrapIndex(this, index);\n      return (index < 0 || (this.size === Infinity ||\n          (this.size !== undefined && index > this.size))) ?\n        notSetValue :\n        this.find(function(_, key)  {return key === index}, undefined, notSetValue);\n    },\n\n    has: function(index) {\n      index = wrapIndex(this, index);\n      return index >= 0 && (this.size !== undefined ?\n        this.size === Infinity || index < this.size :\n        this.indexOf(index) !== -1\n      );\n    },\n\n    interpose: function(separator) {\n      return reify(this, interposeFactory(this, separator));\n    },\n\n    interleave: function(/*...iterables*/) {\n      var iterables = [this].concat(arrCopy(arguments));\n      var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, iterables);\n      var interleaved = zipped.flatten(true);\n      if (zipped.size) {\n        interleaved.size = zipped.size * iterables.length;\n      }\n      return reify(this, interleaved);\n    },\n\n    last: function() {\n      return this.get(-1);\n    },\n\n    skipWhile: function(predicate, context) {\n      return reify(this, skipWhileFactory(this, predicate, context, false));\n    },\n\n    zip: function(/*, ...iterables */) {\n      var iterables = [this].concat(arrCopy(arguments));\n      return reify(this, zipWithFactory(this, defaultZipper, iterables));\n    },\n\n    zipWith: function(zipper/*, ...iterables */) {\n      var iterables = arrCopy(arguments);\n      iterables[0] = this;\n      return reify(this, zipWithFactory(this, zipper, iterables));\n    }\n\n  });\n\n  IndexedIterable.prototype[IS_INDEXED_SENTINEL] = true;\n  IndexedIterable.prototype[IS_ORDERED_SENTINEL] = true;\n\n\n\n  mixin(SetIterable, {\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    get: function(value, notSetValue) {\n      return this.has(value) ? value : notSetValue;\n    },\n\n    includes: function(value) {\n      return this.has(value);\n    },\n\n\n    // ### More sequential methods\n\n    keySeq: function() {\n      return this.valueSeq();\n    }\n\n  });\n\n  SetIterable.prototype.has = IterablePrototype.includes;\n\n\n  // Mixin subclasses\n\n  mixin(KeyedSeq, KeyedIterable.prototype);\n  mixin(IndexedSeq, IndexedIterable.prototype);\n  mixin(SetSeq, SetIterable.prototype);\n\n  mixin(KeyedCollection, KeyedIterable.prototype);\n  mixin(IndexedCollection, IndexedIterable.prototype);\n  mixin(SetCollection, SetIterable.prototype);\n\n\n  // #pragma Helper functions\n\n  function keyMapper(v, k) {\n    return k;\n  }\n\n  function entryMapper(v, k) {\n    return [k, v];\n  }\n\n  function not(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    }\n  }\n\n  function neg(predicate) {\n    return function() {\n      return -predicate.apply(this, arguments);\n    }\n  }\n\n  function quoteString(value) {\n    return typeof value === 'string' ? JSON.stringify(value) : value;\n  }\n\n  function defaultZipper() {\n    return arrCopy(arguments);\n  }\n\n  function defaultNegComparator(a, b) {\n    return a < b ? 1 : a > b ? -1 : 0;\n  }\n\n  function hashIterable(iterable) {\n    if (iterable.size === Infinity) {\n      return 0;\n    }\n    var ordered = isOrdered(iterable);\n    var keyed = isKeyed(iterable);\n    var h = ordered ? 1 : 0;\n    var size = iterable.__iterate(\n      keyed ?\n        ordered ?\n          function(v, k)  { h = 31 * h + hashMerge(hash(v), hash(k)) | 0; } :\n          function(v, k)  { h = h + hashMerge(hash(v), hash(k)) | 0; } :\n        ordered ?\n          function(v ) { h = 31 * h + hash(v) | 0; } :\n          function(v ) { h = h + hash(v) | 0; }\n    );\n    return murmurHashOfSize(size, h);\n  }\n\n  function murmurHashOfSize(size, h) {\n    h = imul(h, 0xCC9E2D51);\n    h = imul(h << 15 | h >>> -15, 0x1B873593);\n    h = imul(h << 13 | h >>> -13, 5);\n    h = (h + 0xE6546B64 | 0) ^ size;\n    h = imul(h ^ h >>> 16, 0x85EBCA6B);\n    h = imul(h ^ h >>> 13, 0xC2B2AE35);\n    h = smi(h ^ h >>> 16);\n    return h;\n  }\n\n  function hashMerge(a, b) {\n    return a ^ b + 0x9E3779B9 + (a << 6) + (a >> 2) | 0; // int\n  }\n\n  var Immutable = {\n\n    Iterable: Iterable,\n\n    Seq: Seq,\n    Collection: Collection,\n    Map: Map,\n    OrderedMap: OrderedMap,\n    List: List,\n    Stack: Stack,\n    Set: Set,\n    OrderedSet: OrderedSet,\n\n    Record: Record,\n    Range: Range,\n    Repeat: Repeat,\n\n    is: is,\n    fromJS: fromJS\n\n  };\n\n  return Immutable;\n\n}));\n\n/***/ }),\n/* 58 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar validateFormat = function validateFormat(format) {};\n\nif (false) {\n  validateFormat = function validateFormat(format) {\n    if (format === undefined) {\n      throw new Error('invariant requires an error message argument');\n    }\n  };\n}\n\nfunction invariant(condition, format, a, b, c, d, e, f) {\n  validateFormat(format);\n\n  if (!condition) {\n    var error;\n    if (format === undefined) {\n      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\n    } else {\n      var args = [a, b, c, d, e, f];\n      var argIndex = 0;\n      error = new Error(format.replace(/%s/g, function () {\n        return args[argIndex++];\n      }));\n      error.name = 'Invariant Violation';\n    }\n\n    error.framesToPop = 1; // we don't care about invariant's own frame\n    throw error;\n  }\n}\n\nmodule.exports = invariant;\n\n/***/ }),\n/* 59 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule EditorState\n * @format\n * \n */\n\n\n\nvar _assign = __webpack_require__(3);\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar BlockTree = __webpack_require__(222);\nvar ContentState = __webpack_require__(157);\nvar EditorBidiService = __webpack_require__(435);\nvar Immutable = __webpack_require__(57);\nvar SelectionState = __webpack_require__(83);\n\nvar OrderedSet = Immutable.OrderedSet,\n    Record = Immutable.Record,\n    Stack = Immutable.Stack;\n\n\nvar defaultRecord = {\n  allowUndo: true,\n  currentContent: null,\n  decorator: null,\n  directionMap: null,\n  forceSelection: false,\n  inCompositionMode: false,\n  inlineStyleOverride: null,\n  lastChangeType: null,\n  nativelyRenderedContent: null,\n  redoStack: Stack(),\n  selection: null,\n  treeMap: null,\n  undoStack: Stack()\n};\n\nvar EditorStateRecord = Record(defaultRecord);\n\nvar EditorState = function () {\n  EditorState.createEmpty = function createEmpty(decorator) {\n    return EditorState.createWithContent(ContentState.createFromText(''), decorator);\n  };\n\n  EditorState.createWithContent = function createWithContent(contentState, decorator) {\n    var firstKey = contentState.getBlockMap().first().getKey();\n    return EditorState.create({\n      currentContent: contentState,\n      undoStack: Stack(),\n      redoStack: Stack(),\n      decorator: decorator || null,\n      selection: SelectionState.createEmpty(firstKey)\n    });\n  };\n\n  EditorState.create = function create(config) {\n    var currentContent = config.currentContent,\n        decorator = config.decorator;\n\n    var recordConfig = _extends({}, config, {\n      treeMap: generateNewTreeMap(currentContent, decorator),\n      directionMap: EditorBidiService.getDirectionMap(currentContent)\n    });\n    return new EditorState(new EditorStateRecord(recordConfig));\n  };\n\n  EditorState.set = function set(editorState, put) {\n    var map = editorState.getImmutable().withMutations(function (state) {\n      var existingDecorator = state.get('decorator');\n      var decorator = existingDecorator;\n      if (put.decorator === null) {\n        decorator = null;\n      } else if (put.decorator) {\n        decorator = put.decorator;\n      }\n\n      var newContent = put.currentContent || editorState.getCurrentContent();\n\n      if (decorator !== existingDecorator) {\n        var treeMap = state.get('treeMap');\n        var newTreeMap;\n        if (decorator && existingDecorator) {\n          newTreeMap = regenerateTreeForNewDecorator(newContent, newContent.getBlockMap(), treeMap, decorator, existingDecorator);\n        } else {\n          newTreeMap = generateNewTreeMap(newContent, decorator);\n        }\n\n        state.merge({\n          decorator: decorator,\n          treeMap: newTreeMap,\n          nativelyRenderedContent: null\n        });\n        return;\n      }\n\n      var existingContent = editorState.getCurrentContent();\n      if (newContent !== existingContent) {\n        state.set('treeMap', regenerateTreeForNewBlocks(editorState, newContent.getBlockMap(), newContent.getEntityMap(), decorator));\n      }\n\n      state.merge(put);\n    });\n\n    return new EditorState(map);\n  };\n\n  EditorState.prototype.toJS = function toJS() {\n    return this.getImmutable().toJS();\n  };\n\n  EditorState.prototype.getAllowUndo = function getAllowUndo() {\n    return this.getImmutable().get('allowUndo');\n  };\n\n  EditorState.prototype.getCurrentContent = function getCurrentContent() {\n    return this.getImmutable().get('currentContent');\n  };\n\n  EditorState.prototype.getUndoStack = function getUndoStack() {\n    return this.getImmutable().get('undoStack');\n  };\n\n  EditorState.prototype.getRedoStack = function getRedoStack() {\n    return this.getImmutable().get('redoStack');\n  };\n\n  EditorState.prototype.getSelection = function getSelection() {\n    return this.getImmutable().get('selection');\n  };\n\n  EditorState.prototype.getDecorator = function getDecorator() {\n    return this.getImmutable().get('decorator');\n  };\n\n  EditorState.prototype.isInCompositionMode = function isInCompositionMode() {\n    return this.getImmutable().get('inCompositionMode');\n  };\n\n  EditorState.prototype.mustForceSelection = function mustForceSelection() {\n    return this.getImmutable().get('forceSelection');\n  };\n\n  EditorState.prototype.getNativelyRenderedContent = function getNativelyRenderedContent() {\n    return this.getImmutable().get('nativelyRenderedContent');\n  };\n\n  EditorState.prototype.getLastChangeType = function getLastChangeType() {\n    return this.getImmutable().get('lastChangeType');\n  };\n\n  /**\n   * While editing, the user may apply inline style commands with a collapsed\n   * cursor, intending to type text that adopts the specified style. In this\n   * case, we track the specified style as an \"override\" that takes precedence\n   * over the inline style of the text adjacent to the cursor.\n   *\n   * If null, there is no override in place.\n   */\n\n\n  EditorState.prototype.getInlineStyleOverride = function getInlineStyleOverride() {\n    return this.getImmutable().get('inlineStyleOverride');\n  };\n\n  EditorState.setInlineStyleOverride = function setInlineStyleOverride(editorState, inlineStyleOverride) {\n    return EditorState.set(editorState, { inlineStyleOverride: inlineStyleOverride });\n  };\n\n  /**\n   * Get the appropriate inline style for the editor state. If an\n   * override is in place, use it. Otherwise, the current style is\n   * based on the location of the selection state.\n   */\n\n\n  EditorState.prototype.getCurrentInlineStyle = function getCurrentInlineStyle() {\n    var override = this.getInlineStyleOverride();\n    if (override != null) {\n      return override;\n    }\n\n    var content = this.getCurrentContent();\n    var selection = this.getSelection();\n\n    if (selection.isCollapsed()) {\n      return getInlineStyleForCollapsedSelection(content, selection);\n    }\n\n    return getInlineStyleForNonCollapsedSelection(content, selection);\n  };\n\n  EditorState.prototype.getBlockTree = function getBlockTree(blockKey) {\n    return this.getImmutable().getIn(['treeMap', blockKey]);\n  };\n\n  EditorState.prototype.isSelectionAtStartOfContent = function isSelectionAtStartOfContent() {\n    var firstKey = this.getCurrentContent().getBlockMap().first().getKey();\n    return this.getSelection().hasEdgeWithin(firstKey, 0, 0);\n  };\n\n  EditorState.prototype.isSelectionAtEndOfContent = function isSelectionAtEndOfContent() {\n    var content = this.getCurrentContent();\n    var blockMap = content.getBlockMap();\n    var last = blockMap.last();\n    var end = last.getLength();\n    return this.getSelection().hasEdgeWithin(last.getKey(), end, end);\n  };\n\n  EditorState.prototype.getDirectionMap = function getDirectionMap() {\n    return this.getImmutable().get('directionMap');\n  };\n\n  /**\n   * Incorporate native DOM selection changes into the EditorState. This\n   * method can be used when we simply want to accept whatever the DOM\n   * has given us to represent selection, and we do not need to re-render\n   * the editor.\n   *\n   * To forcibly move the DOM selection, see `EditorState.forceSelection`.\n   */\n\n\n  EditorState.acceptSelection = function acceptSelection(editorState, selection) {\n    return updateSelection(editorState, selection, false);\n  };\n\n  /**\n   * At times, we need to force the DOM selection to be where we\n   * need it to be. This can occur when the anchor or focus nodes\n   * are non-text nodes, for instance. In this case, we want to trigger\n   * a re-render of the editor, which in turn forces selection into\n   * the correct place in the DOM. The `forceSelection` method\n   * accomplishes this.\n   *\n   * This method should be used in cases where you need to explicitly\n   * move the DOM selection from one place to another without a change\n   * in ContentState.\n   */\n\n\n  EditorState.forceSelection = function forceSelection(editorState, selection) {\n    if (!selection.getHasFocus()) {\n      selection = selection.set('hasFocus', true);\n    }\n    return updateSelection(editorState, selection, true);\n  };\n\n  /**\n   * Move selection to the end of the editor without forcing focus.\n   */\n\n\n  EditorState.moveSelectionToEnd = function moveSelectionToEnd(editorState) {\n    var content = editorState.getCurrentContent();\n    var lastBlock = content.getLastBlock();\n    var lastKey = lastBlock.getKey();\n    var length = lastBlock.getLength();\n\n    return EditorState.acceptSelection(editorState, new SelectionState({\n      anchorKey: lastKey,\n      anchorOffset: length,\n      focusKey: lastKey,\n      focusOffset: length,\n      isBackward: false\n    }));\n  };\n\n  /**\n   * Force focus to the end of the editor. This is useful in scenarios\n   * where we want to programmatically focus the input and it makes sense\n   * to allow the user to continue working seamlessly.\n   */\n\n\n  EditorState.moveFocusToEnd = function moveFocusToEnd(editorState) {\n    var afterSelectionMove = EditorState.moveSelectionToEnd(editorState);\n    return EditorState.forceSelection(afterSelectionMove, afterSelectionMove.getSelection());\n  };\n\n  /**\n   * Push the current ContentState onto the undo stack if it should be\n   * considered a boundary state, and set the provided ContentState as the\n   * new current content.\n   */\n\n\n  EditorState.push = function push(editorState, contentState, changeType) {\n    if (editorState.getCurrentContent() === contentState) {\n      return editorState;\n    }\n\n    var forceSelection = changeType !== 'insert-characters';\n    var directionMap = EditorBidiService.getDirectionMap(contentState, editorState.getDirectionMap());\n\n    if (!editorState.getAllowUndo()) {\n      return EditorState.set(editorState, {\n        currentContent: contentState,\n        directionMap: directionMap,\n        lastChangeType: changeType,\n        selection: contentState.getSelectionAfter(),\n        forceSelection: forceSelection,\n        inlineStyleOverride: null\n      });\n    }\n\n    var selection = editorState.getSelection();\n    var currentContent = editorState.getCurrentContent();\n    var undoStack = editorState.getUndoStack();\n    var newContent = contentState;\n\n    if (selection !== currentContent.getSelectionAfter() || mustBecomeBoundary(editorState, changeType)) {\n      undoStack = undoStack.push(currentContent);\n      newContent = newContent.set('selectionBefore', selection);\n    } else if (changeType === 'insert-characters' || changeType === 'backspace-character' || changeType === 'delete-character') {\n      // Preserve the previous selection.\n      newContent = newContent.set('selectionBefore', currentContent.getSelectionBefore());\n    }\n\n    var inlineStyleOverride = editorState.getInlineStyleOverride();\n\n    // Don't discard inline style overrides for the following change types:\n    var overrideChangeTypes = ['adjust-depth', 'change-block-type', 'split-block'];\n\n    if (overrideChangeTypes.indexOf(changeType) === -1) {\n      inlineStyleOverride = null;\n    }\n\n    var editorStateChanges = {\n      currentContent: newContent,\n      directionMap: directionMap,\n      undoStack: undoStack,\n      redoStack: Stack(),\n      lastChangeType: changeType,\n      selection: contentState.getSelectionAfter(),\n      forceSelection: forceSelection,\n      inlineStyleOverride: inlineStyleOverride\n    };\n\n    return EditorState.set(editorState, editorStateChanges);\n  };\n\n  /**\n   * Make the top ContentState in the undo stack the new current content and\n   * push the current content onto the redo stack.\n   */\n\n\n  EditorState.undo = function undo(editorState) {\n    if (!editorState.getAllowUndo()) {\n      return editorState;\n    }\n\n    var undoStack = editorState.getUndoStack();\n    var newCurrentContent = undoStack.peek();\n    if (!newCurrentContent) {\n      return editorState;\n    }\n\n    var currentContent = editorState.getCurrentContent();\n    var directionMap = EditorBidiService.getDirectionMap(newCurrentContent, editorState.getDirectionMap());\n\n    return EditorState.set(editorState, {\n      currentContent: newCurrentContent,\n      directionMap: directionMap,\n      undoStack: undoStack.shift(),\n      redoStack: editorState.getRedoStack().push(currentContent),\n      forceSelection: true,\n      inlineStyleOverride: null,\n      lastChangeType: 'undo',\n      nativelyRenderedContent: null,\n      selection: currentContent.getSelectionBefore()\n    });\n  };\n\n  /**\n   * Make the top ContentState in the redo stack the new current content and\n   * push the current content onto the undo stack.\n   */\n\n\n  EditorState.redo = function redo(editorState) {\n    if (!editorState.getAllowUndo()) {\n      return editorState;\n    }\n\n    var redoStack = editorState.getRedoStack();\n    var newCurrentContent = redoStack.peek();\n    if (!newCurrentContent) {\n      return editorState;\n    }\n\n    var currentContent = editorState.getCurrentContent();\n    var directionMap = EditorBidiService.getDirectionMap(newCurrentContent, editorState.getDirectionMap());\n\n    return EditorState.set(editorState, {\n      currentContent: newCurrentContent,\n      directionMap: directionMap,\n      undoStack: editorState.getUndoStack().push(currentContent),\n      redoStack: redoStack.shift(),\n      forceSelection: true,\n      inlineStyleOverride: null,\n      lastChangeType: 'redo',\n      nativelyRenderedContent: null,\n      selection: newCurrentContent.getSelectionAfter()\n    });\n  };\n\n  /**\n   * Not for public consumption.\n   */\n\n\n  function EditorState(immutable) {\n    _classCallCheck(this, EditorState);\n\n    this._immutable = immutable;\n  }\n\n  /**\n   * Not for public consumption.\n   */\n\n\n  EditorState.prototype.getImmutable = function getImmutable() {\n    return this._immutable;\n  };\n\n  return EditorState;\n}();\n\n/**\n * Set the supplied SelectionState as the new current selection, and set\n * the `force` flag to trigger manual selection placement by the view.\n */\n\n\nfunction updateSelection(editorState, selection, forceSelection) {\n  return EditorState.set(editorState, {\n    selection: selection,\n    forceSelection: forceSelection,\n    nativelyRenderedContent: null,\n    inlineStyleOverride: null\n  });\n}\n\n/**\n * Regenerate the entire tree map for a given ContentState and decorator.\n * Returns an OrderedMap that maps all available ContentBlock objects.\n */\nfunction generateNewTreeMap(contentState, decorator) {\n  return contentState.getBlockMap().map(function (block) {\n    return BlockTree.generate(contentState, block, decorator);\n  }).toOrderedMap();\n}\n\n/**\n * Regenerate tree map objects for all ContentBlocks that have changed\n * between the current editorState and newContent. Returns an OrderedMap\n * with only changed regenerated tree map objects.\n */\nfunction regenerateTreeForNewBlocks(editorState, newBlockMap, newEntityMap, decorator) {\n  var contentState = editorState.getCurrentContent().set('entityMap', newEntityMap);\n  var prevBlockMap = contentState.getBlockMap();\n  var prevTreeMap = editorState.getImmutable().get('treeMap');\n  return prevTreeMap.merge(newBlockMap.toSeq().filter(function (block, key) {\n    return block !== prevBlockMap.get(key);\n  }).map(function (block) {\n    return BlockTree.generate(contentState, block, decorator);\n  }));\n}\n\n/**\n * Generate tree map objects for a new decorator object, preserving any\n * decorations that are unchanged from the previous decorator.\n *\n * Note that in order for this to perform optimally, decoration Lists for\n * decorators should be preserved when possible to allow for direct immutable\n * List comparison.\n */\nfunction regenerateTreeForNewDecorator(content, blockMap, previousTreeMap, decorator, existingDecorator) {\n  return previousTreeMap.merge(blockMap.toSeq().filter(function (block) {\n    return decorator.getDecorations(block, content) !== existingDecorator.getDecorations(block, content);\n  }).map(function (block) {\n    return BlockTree.generate(content, block, decorator);\n  }));\n}\n\n/**\n * Return whether a change should be considered a boundary state, given\n * the previous change type. Allows us to discard potential boundary states\n * during standard typing or deletion behavior.\n */\nfunction mustBecomeBoundary(editorState, changeType) {\n  var lastChangeType = editorState.getLastChangeType();\n  return changeType !== lastChangeType || changeType !== 'insert-characters' && changeType !== 'backspace-character' && changeType !== 'delete-character';\n}\n\nfunction getInlineStyleForCollapsedSelection(content, selection) {\n  var startKey = selection.getStartKey();\n  var startOffset = selection.getStartOffset();\n  var startBlock = content.getBlockForKey(startKey);\n\n  // If the cursor is not at the start of the block, look backward to\n  // preserve the style of the preceding character.\n  if (startOffset > 0) {\n    return startBlock.getInlineStyleAt(startOffset - 1);\n  }\n\n  // The caret is at position zero in this block. If the block has any\n  // text at all, use the style of the first character.\n  if (startBlock.getLength()) {\n    return startBlock.getInlineStyleAt(0);\n  }\n\n  // Otherwise, look upward in the document to find the closest character.\n  return lookUpwardForInlineStyle(content, startKey);\n}\n\nfunction getInlineStyleForNonCollapsedSelection(content, selection) {\n  var startKey = selection.getStartKey();\n  var startOffset = selection.getStartOffset();\n  var startBlock = content.getBlockForKey(startKey);\n\n  // If there is a character just inside the selection, use its style.\n  if (startOffset < startBlock.getLength()) {\n    return startBlock.getInlineStyleAt(startOffset);\n  }\n\n  // Check if the selection at the end of a non-empty block. Use the last\n  // style in the block.\n  if (startOffset > 0) {\n    return startBlock.getInlineStyleAt(startOffset - 1);\n  }\n\n  // Otherwise, look upward in the document to find the closest character.\n  return lookUpwardForInlineStyle(content, startKey);\n}\n\nfunction lookUpwardForInlineStyle(content, fromKey) {\n  var lastNonEmpty = content.getBlockMap().reverse().skipUntil(function (_, k) {\n    return k === fromKey;\n  }).skip(1).skipUntil(function (block, _) {\n    return block.getLength();\n  }).first();\n\n  if (lastNonEmpty) return lastNonEmpty.getInlineStyleAt(lastNonEmpty.getLength() - 1);\n  return OrderedSet();\n}\n\nmodule.exports = EditorState;\n\n/***/ }),\n/* 60 */,\n/* 61 */,\n/* 62 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftModifier\n * @format\n * \n */\n\n\n\nvar CharacterMetadata = __webpack_require__(63);\nvar ContentStateInlineStyle = __webpack_require__(424);\nvar DraftFeatureFlags = __webpack_require__(71);\nvar Immutable = __webpack_require__(57);\n\nvar applyEntityToContentState = __webpack_require__(425);\nvar getCharacterRemovalRange = __webpack_require__(427);\nvar getContentStateFragment = __webpack_require__(114);\nvar insertFragmentIntoContentState = __webpack_require__(430);\nvar insertTextIntoContentState = __webpack_require__(431);\nvar invariant = __webpack_require__(58);\nvar modifyBlockForContentState = __webpack_require__(432);\nvar removeEntitiesAtEdges = __webpack_require__(219);\nvar removeRangeFromContentState = __webpack_require__(433);\nvar splitBlockInContentState = __webpack_require__(434);\n\nvar OrderedSet = Immutable.OrderedSet;\n\n/**\n * `DraftModifier` provides a set of convenience methods that apply\n * modifications to a `ContentState` object based on a target `SelectionState`.\n *\n * Any change to a `ContentState` should be decomposable into a series of\n * transaction functions that apply the required changes and return output\n * `ContentState` objects.\n *\n * These functions encapsulate some of the most common transaction sequences.\n */\n\nvar DraftModifier = {\n  replaceText: function replaceText(contentState, rangeToReplace, text, inlineStyle, entityKey) {\n    var withoutEntities = removeEntitiesAtEdges(contentState, rangeToReplace);\n    var withoutText = removeRangeFromContentState(withoutEntities, rangeToReplace);\n\n    var character = CharacterMetadata.create({\n      style: inlineStyle || OrderedSet(),\n      entity: entityKey || null\n    });\n\n    return insertTextIntoContentState(withoutText, withoutText.getSelectionAfter(), text, character);\n  },\n\n  insertText: function insertText(contentState, targetRange, text, inlineStyle, entityKey) {\n    !targetRange.isCollapsed() ?  false ? invariant(false, 'Target range must be collapsed for `insertText`.') : invariant(false) : void 0;\n    return DraftModifier.replaceText(contentState, targetRange, text, inlineStyle, entityKey);\n  },\n\n  moveText: function moveText(contentState, removalRange, targetRange) {\n    var movedFragment = getContentStateFragment(contentState, removalRange);\n\n    var afterRemoval = DraftModifier.removeRange(contentState, removalRange, 'backward');\n\n    return DraftModifier.replaceWithFragment(afterRemoval, targetRange, movedFragment);\n  },\n\n  replaceWithFragment: function replaceWithFragment(contentState, targetRange, fragment) {\n    var withoutEntities = removeEntitiesAtEdges(contentState, targetRange);\n    var withoutText = removeRangeFromContentState(withoutEntities, targetRange);\n\n    return insertFragmentIntoContentState(withoutText, withoutText.getSelectionAfter(), fragment);\n  },\n\n  removeRange: function removeRange(contentState, rangeToRemove, removalDirection) {\n    var startKey = void 0,\n        endKey = void 0,\n        startBlock = void 0,\n        endBlock = void 0;\n    if (rangeToRemove.getIsBackward()) {\n      rangeToRemove = rangeToRemove.merge({\n        anchorKey: rangeToRemove.getFocusKey(),\n        anchorOffset: rangeToRemove.getFocusOffset(),\n        focusKey: rangeToRemove.getAnchorKey(),\n        focusOffset: rangeToRemove.getAnchorOffset(),\n        isBackward: false\n      });\n    }\n    startKey = rangeToRemove.getAnchorKey();\n    endKey = rangeToRemove.getFocusKey();\n    startBlock = contentState.getBlockForKey(startKey);\n    endBlock = contentState.getBlockForKey(endKey);\n    var startOffset = rangeToRemove.getStartOffset();\n    var endOffset = rangeToRemove.getEndOffset();\n\n    var startEntityKey = startBlock.getEntityAt(startOffset);\n    var endEntityKey = endBlock.getEntityAt(endOffset - 1);\n\n    // Check whether the selection state overlaps with a single entity.\n    // If so, try to remove the appropriate substring of the entity text.\n    if (startKey === endKey) {\n      if (startEntityKey && startEntityKey === endEntityKey) {\n        var _adjustedRemovalRange = getCharacterRemovalRange(contentState.getEntityMap(), startBlock, endBlock, rangeToRemove, removalDirection);\n        return removeRangeFromContentState(contentState, _adjustedRemovalRange);\n      }\n    }\n    var adjustedRemovalRange = rangeToRemove;\n    if (DraftFeatureFlags.draft_segmented_entities_behavior) {\n      // Adjust the selection to properly delete segemented and immutable\n      // entities\n      adjustedRemovalRange = getCharacterRemovalRange(contentState.getEntityMap(), startBlock, endBlock, rangeToRemove, removalDirection);\n    }\n\n    var withoutEntities = removeEntitiesAtEdges(contentState, adjustedRemovalRange);\n    return removeRangeFromContentState(withoutEntities, adjustedRemovalRange);\n  },\n\n  splitBlock: function splitBlock(contentState, selectionState) {\n    var withoutEntities = removeEntitiesAtEdges(contentState, selectionState);\n    var withoutText = removeRangeFromContentState(withoutEntities, selectionState);\n\n    return splitBlockInContentState(withoutText, withoutText.getSelectionAfter());\n  },\n\n  applyInlineStyle: function applyInlineStyle(contentState, selectionState, inlineStyle) {\n    return ContentStateInlineStyle.add(contentState, selectionState, inlineStyle);\n  },\n\n  removeInlineStyle: function removeInlineStyle(contentState, selectionState, inlineStyle) {\n    return ContentStateInlineStyle.remove(contentState, selectionState, inlineStyle);\n  },\n\n  setBlockType: function setBlockType(contentState, selectionState, blockType) {\n    return modifyBlockForContentState(contentState, selectionState, function (block) {\n      return block.merge({ type: blockType, depth: 0 });\n    });\n  },\n\n  setBlockData: function setBlockData(contentState, selectionState, blockData) {\n    return modifyBlockForContentState(contentState, selectionState, function (block) {\n      return block.merge({ data: blockData });\n    });\n  },\n\n  mergeBlockData: function mergeBlockData(contentState, selectionState, blockData) {\n    return modifyBlockForContentState(contentState, selectionState, function (block) {\n      return block.merge({ data: block.getData().merge(blockData) });\n    });\n  },\n\n  applyEntity: function applyEntity(contentState, selectionState, entityKey) {\n    var withoutEntities = removeEntitiesAtEdges(contentState, selectionState);\n    return applyEntityToContentState(withoutEntities, selectionState, entityKey);\n  }\n};\n\nmodule.exports = DraftModifier;\n\n/***/ }),\n/* 63 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule CharacterMetadata\n * @format\n * \n */\n\n\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar _require = __webpack_require__(57),\n    Map = _require.Map,\n    OrderedSet = _require.OrderedSet,\n    Record = _require.Record;\n\n// Immutable.map is typed such that the value for every key in the map\n// must be the same type\n\n\nvar EMPTY_SET = OrderedSet();\n\nvar defaultRecord = {\n  style: EMPTY_SET,\n  entity: null\n};\n\nvar CharacterMetadataRecord = Record(defaultRecord);\n\nvar CharacterMetadata = function (_CharacterMetadataRec) {\n  _inherits(CharacterMetadata, _CharacterMetadataRec);\n\n  function CharacterMetadata() {\n    _classCallCheck(this, CharacterMetadata);\n\n    return _possibleConstructorReturn(this, _CharacterMetadataRec.apply(this, arguments));\n  }\n\n  CharacterMetadata.prototype.getStyle = function getStyle() {\n    return this.get('style');\n  };\n\n  CharacterMetadata.prototype.getEntity = function getEntity() {\n    return this.get('entity');\n  };\n\n  CharacterMetadata.prototype.hasStyle = function hasStyle(style) {\n    return this.getStyle().includes(style);\n  };\n\n  CharacterMetadata.applyStyle = function applyStyle(record, style) {\n    var withStyle = record.set('style', record.getStyle().add(style));\n    return CharacterMetadata.create(withStyle);\n  };\n\n  CharacterMetadata.removeStyle = function removeStyle(record, style) {\n    var withoutStyle = record.set('style', record.getStyle().remove(style));\n    return CharacterMetadata.create(withoutStyle);\n  };\n\n  CharacterMetadata.applyEntity = function applyEntity(record, entityKey) {\n    var withEntity = record.getEntity() === entityKey ? record : record.set('entity', entityKey);\n    return CharacterMetadata.create(withEntity);\n  };\n\n  /**\n   * Use this function instead of the `CharacterMetadata` constructor.\n   * Since most content generally uses only a very small number of\n   * style/entity permutations, we can reuse these objects as often as\n   * possible.\n   */\n\n\n  CharacterMetadata.create = function create(config) {\n    if (!config) {\n      return EMPTY;\n    }\n\n    var defaultConfig = {\n      style: EMPTY_SET,\n      entity: null\n    };\n\n    // Fill in unspecified properties, if necessary.\n    var configMap = Map(defaultConfig).merge(config);\n\n    var existing = pool.get(configMap);\n    if (existing) {\n      return existing;\n    }\n\n    var newCharacter = new CharacterMetadata(configMap);\n    pool = pool.set(configMap, newCharacter);\n    return newCharacter;\n  };\n\n  return CharacterMetadata;\n}(CharacterMetadataRecord);\n\nvar EMPTY = new CharacterMetadata();\nvar pool = Map([[Map(defaultRecord), EMPTY]]);\n\nCharacterMetadata.EMPTY = EMPTY;\n\nmodule.exports = CharacterMetadata;\n\n/***/ }),\n/* 64 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ContentBlockNode\n * @format\n * \n *\n * This file is a fork of ContentBlock adding support for nesting references by\n * providing links to children, parent, prevSibling, and nextSibling.\n *\n * This is unstable and not part of the public API and should not be used by\n * production systems. This file may be update/removed without notice.\n */\n\n\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar CharacterMetadata = __webpack_require__(63);\nvar Immutable = __webpack_require__(57);\n\nvar findRangesImmutable = __webpack_require__(92);\n\nvar List = Immutable.List,\n    Map = Immutable.Map,\n    OrderedSet = Immutable.OrderedSet,\n    Record = Immutable.Record,\n    Repeat = Immutable.Repeat;\n\n\nvar EMPTY_SET = OrderedSet();\n\nvar defaultRecord = {\n  parent: null,\n  characterList: List(),\n  data: Map(),\n  depth: 0,\n  key: '',\n  text: '',\n  type: 'unstyled',\n  children: List(),\n  prevSibling: null,\n  nextSibling: null\n};\n\nvar haveEqualStyle = function haveEqualStyle(charA, charB) {\n  return charA.getStyle() === charB.getStyle();\n};\n\nvar haveEqualEntity = function haveEqualEntity(charA, charB) {\n  return charA.getEntity() === charB.getEntity();\n};\n\nvar decorateCharacterList = function decorateCharacterList(config) {\n  if (!config) {\n    return config;\n  }\n\n  var characterList = config.characterList,\n      text = config.text;\n\n\n  if (text && !characterList) {\n    config.characterList = List(Repeat(CharacterMetadata.EMPTY, text.length));\n  }\n\n  return config;\n};\n\nvar ContentBlockNode = function (_Record) {\n  _inherits(ContentBlockNode, _Record);\n\n  function ContentBlockNode() {\n    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultRecord;\n\n    _classCallCheck(this, ContentBlockNode);\n\n    return _possibleConstructorReturn(this, _Record.call(this, decorateCharacterList(props)));\n  }\n\n  ContentBlockNode.prototype.getKey = function getKey() {\n    return this.get('key');\n  };\n\n  ContentBlockNode.prototype.getType = function getType() {\n    return this.get('type');\n  };\n\n  ContentBlockNode.prototype.getText = function getText() {\n    return this.get('text');\n  };\n\n  ContentBlockNode.prototype.getCharacterList = function getCharacterList() {\n    return this.get('characterList');\n  };\n\n  ContentBlockNode.prototype.getLength = function getLength() {\n    return this.getText().length;\n  };\n\n  ContentBlockNode.prototype.getDepth = function getDepth() {\n    return this.get('depth');\n  };\n\n  ContentBlockNode.prototype.getData = function getData() {\n    return this.get('data');\n  };\n\n  ContentBlockNode.prototype.getInlineStyleAt = function getInlineStyleAt(offset) {\n    var character = this.getCharacterList().get(offset);\n    return character ? character.getStyle() : EMPTY_SET;\n  };\n\n  ContentBlockNode.prototype.getEntityAt = function getEntityAt(offset) {\n    var character = this.getCharacterList().get(offset);\n    return character ? character.getEntity() : null;\n  };\n\n  ContentBlockNode.prototype.getChildKeys = function getChildKeys() {\n    return this.get('children');\n  };\n\n  ContentBlockNode.prototype.getParentKey = function getParentKey() {\n    return this.get('parent');\n  };\n\n  ContentBlockNode.prototype.getPrevSiblingKey = function getPrevSiblingKey() {\n    return this.get('prevSibling');\n  };\n\n  ContentBlockNode.prototype.getNextSiblingKey = function getNextSiblingKey() {\n    return this.get('nextSibling');\n  };\n\n  ContentBlockNode.prototype.findStyleRanges = function findStyleRanges(filterFn, callback) {\n    findRangesImmutable(this.getCharacterList(), haveEqualStyle, filterFn, callback);\n  };\n\n  ContentBlockNode.prototype.findEntityRanges = function findEntityRanges(filterFn, callback) {\n    findRangesImmutable(this.getCharacterList(), haveEqualEntity, filterFn, callback);\n  };\n\n  return ContentBlockNode;\n}(Record(defaultRecord));\n\nmodule.exports = ContentBlockNode;\n\n/***/ }),\n/* 65 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\nvar nullthrows = function nullthrows(x) {\n  if (x != null) {\n    return x;\n  }\n  throw new Error(\"Got unexpected null or undefined\");\n};\n\nmodule.exports = nullthrows;\n\n/***/ }),\n/* 66 */,\n/* 67 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n\n\nvar UserAgentData = __webpack_require__(445);\nvar VersionRange = __webpack_require__(448);\n\nvar mapObject = __webpack_require__(449);\nvar memoizeStringOnly = __webpack_require__(450);\n\n/**\n * Checks to see whether `name` and `version` satisfy `query`.\n *\n * @param {string} name Name of the browser, device, engine or platform\n * @param {?string} version Version of the browser, engine or platform\n * @param {string} query Query of form \"Name [range expression]\"\n * @param {?function} normalizer Optional pre-processor for range expression\n * @return {boolean}\n */\nfunction compare(name, version, query, normalizer) {\n  // check for exact match with no version\n  if (name === query) {\n    return true;\n  }\n\n  // check for non-matching names\n  if (!query.startsWith(name)) {\n    return false;\n  }\n\n  // full comparison with version\n  var range = query.slice(name.length);\n  if (version) {\n    range = normalizer ? normalizer(range) : range;\n    return VersionRange.contains(range, version);\n  }\n\n  return false;\n}\n\n/**\n * Normalizes `version` by stripping any \"NT\" prefix, but only on the Windows\n * platform.\n *\n * Mimics the stripping performed by the `UserAgentWindowsPlatform` PHP class.\n *\n * @param {string} version\n * @return {string}\n */\nfunction normalizePlatformVersion(version) {\n  if (UserAgentData.platformName === 'Windows') {\n    return version.replace(/^\\s*NT/, '');\n  }\n\n  return version;\n}\n\n/**\n * Provides client-side access to the authoritative PHP-generated User Agent\n * information supplied by the server.\n */\nvar UserAgent = {\n  /**\n   * Check if the User Agent browser matches `query`.\n   *\n   * `query` should be a string like \"Chrome\" or \"Chrome > 33\".\n   *\n   * Valid browser names include:\n   *\n   * - ACCESS NetFront\n   * - AOL\n   * - Amazon Silk\n   * - Android\n   * - BlackBerry\n   * - BlackBerry PlayBook\n   * - Chrome\n   * - Chrome for iOS\n   * - Chrome frame\n   * - Facebook PHP SDK\n   * - Facebook for iOS\n   * - Firefox\n   * - IE\n   * - IE Mobile\n   * - Mobile Safari\n   * - Motorola Internet Browser\n   * - Nokia\n   * - Openwave Mobile Browser\n   * - Opera\n   * - Opera Mini\n   * - Opera Mobile\n   * - Safari\n   * - UIWebView\n   * - Unknown\n   * - webOS\n   * - etc...\n   *\n   * An authoritative list can be found in the PHP `BrowserDetector` class and\n   * related classes in the same file (see calls to `new UserAgentBrowser` here:\n   * https://fburl.com/50728104).\n   *\n   * @note Function results are memoized\n   *\n   * @param {string} query Query of the form \"Name [range expression]\"\n   * @return {boolean}\n   */\n  isBrowser: function isBrowser(query) {\n    return compare(UserAgentData.browserName, UserAgentData.browserFullVersion, query);\n  },\n\n\n  /**\n   * Check if the User Agent browser uses a 32 or 64 bit architecture.\n   *\n   * @note Function results are memoized\n   *\n   * @param {string} query Query of the form \"32\" or \"64\".\n   * @return {boolean}\n   */\n  isBrowserArchitecture: function isBrowserArchitecture(query) {\n    return compare(UserAgentData.browserArchitecture, null, query);\n  },\n\n\n  /**\n   * Check if the User Agent device matches `query`.\n   *\n   * `query` should be a string like \"iPhone\" or \"iPad\".\n   *\n   * Valid device names include:\n   *\n   * - Kindle\n   * - Kindle Fire\n   * - Unknown\n   * - iPad\n   * - iPhone\n   * - iPod\n   * - etc...\n   *\n   * An authoritative list can be found in the PHP `DeviceDetector` class and\n   * related classes in the same file (see calls to `new UserAgentDevice` here:\n   * https://fburl.com/50728332).\n   *\n   * @note Function results are memoized\n   *\n   * @param {string} query Query of the form \"Name\"\n   * @return {boolean}\n   */\n  isDevice: function isDevice(query) {\n    return compare(UserAgentData.deviceName, null, query);\n  },\n\n\n  /**\n   * Check if the User Agent rendering engine matches `query`.\n   *\n   * `query` should be a string like \"WebKit\" or \"WebKit >= 537\".\n   *\n   * Valid engine names include:\n   *\n   * - Gecko\n   * - Presto\n   * - Trident\n   * - WebKit\n   * - etc...\n   *\n   * An authoritative list can be found in the PHP `RenderingEngineDetector`\n   * class related classes in the same file (see calls to `new\n   * UserAgentRenderingEngine` here: https://fburl.com/50728617).\n   *\n   * @note Function results are memoized\n   *\n   * @param {string} query Query of the form \"Name [range expression]\"\n   * @return {boolean}\n   */\n  isEngine: function isEngine(query) {\n    return compare(UserAgentData.engineName, UserAgentData.engineVersion, query);\n  },\n\n\n  /**\n   * Check if the User Agent platform matches `query`.\n   *\n   * `query` should be a string like \"Windows\" or \"iOS 5 - 6\".\n   *\n   * Valid platform names include:\n   *\n   * - Android\n   * - BlackBerry OS\n   * - Java ME\n   * - Linux\n   * - Mac OS X\n   * - Mac OS X Calendar\n   * - Mac OS X Internet Account\n   * - Symbian\n   * - SymbianOS\n   * - Windows\n   * - Windows Mobile\n   * - Windows Phone\n   * - iOS\n   * - iOS Facebook Integration Account\n   * - iOS Facebook Social Sharing UI\n   * - webOS\n   * - Chrome OS\n   * - etc...\n   *\n   * An authoritative list can be found in the PHP `PlatformDetector` class and\n   * related classes in the same file (see calls to `new UserAgentPlatform`\n   * here: https://fburl.com/50729226).\n   *\n   * @note Function results are memoized\n   *\n   * @param {string} query Query of the form \"Name [range expression]\"\n   * @return {boolean}\n   */\n  isPlatform: function isPlatform(query) {\n    return compare(UserAgentData.platformName, UserAgentData.platformFullVersion, query, normalizePlatformVersion);\n  },\n\n\n  /**\n   * Check if the User Agent platform is a 32 or 64 bit architecture.\n   *\n   * @note Function results are memoized\n   *\n   * @param {string} query Query of the form \"32\" or \"64\".\n   * @return {boolean}\n   */\n  isPlatformArchitecture: function isPlatformArchitecture(query) {\n    return compare(UserAgentData.platformArchitecture, null, query);\n  }\n};\n\nmodule.exports = mapObject(UserAgent, memoizeStringOnly);\n\n/***/ }),\n/* 68 */,\n/* 69 */,\n/* 70 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule generateRandomKey\n * @format\n * \n */\n\n\n\nvar seenKeys = {};\nvar MULTIPLIER = Math.pow(2, 24);\n\nfunction generateRandomKey() {\n  var key = void 0;\n  while (key === undefined || seenKeys.hasOwnProperty(key) || !isNaN(+key)) {\n    key = Math.floor(Math.random() * MULTIPLIER).toString(32);\n  }\n  seenKeys[key] = true;\n  return key;\n}\n\nmodule.exports = generateRandomKey;\n\n/***/ }),\n/* 71 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftFeatureFlags\n * @format\n * \n */\n\n\n\nvar DraftFeatureFlags = __webpack_require__(423);\n\nmodule.exports = DraftFeatureFlags;\n\n/***/ }),\n/* 72 */,\n/* 73 */,\n/* 74 */,\n/* 75 */,\n/* 76 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ContentBlock\n * @format\n * \n */\n\n\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar CharacterMetadata = __webpack_require__(63);\nvar Immutable = __webpack_require__(57);\n\nvar findRangesImmutable = __webpack_require__(92);\n\nvar List = Immutable.List,\n    Map = Immutable.Map,\n    OrderedSet = Immutable.OrderedSet,\n    Record = Immutable.Record,\n    Repeat = Immutable.Repeat;\n\n\nvar EMPTY_SET = OrderedSet();\n\nvar defaultRecord = {\n  key: '',\n  type: 'unstyled',\n  text: '',\n  characterList: List(),\n  depth: 0,\n  data: Map()\n};\n\nvar ContentBlockRecord = Record(defaultRecord);\n\nvar decorateCharacterList = function decorateCharacterList(config) {\n  if (!config) {\n    return config;\n  }\n\n  var characterList = config.characterList,\n      text = config.text;\n\n\n  if (text && !characterList) {\n    config.characterList = List(Repeat(CharacterMetadata.EMPTY, text.length));\n  }\n\n  return config;\n};\n\nvar ContentBlock = function (_ContentBlockRecord) {\n  _inherits(ContentBlock, _ContentBlockRecord);\n\n  function ContentBlock(config) {\n    _classCallCheck(this, ContentBlock);\n\n    return _possibleConstructorReturn(this, _ContentBlockRecord.call(this, decorateCharacterList(config)));\n  }\n\n  ContentBlock.prototype.getKey = function getKey() {\n    return this.get('key');\n  };\n\n  ContentBlock.prototype.getType = function getType() {\n    return this.get('type');\n  };\n\n  ContentBlock.prototype.getText = function getText() {\n    return this.get('text');\n  };\n\n  ContentBlock.prototype.getCharacterList = function getCharacterList() {\n    return this.get('characterList');\n  };\n\n  ContentBlock.prototype.getLength = function getLength() {\n    return this.getText().length;\n  };\n\n  ContentBlock.prototype.getDepth = function getDepth() {\n    return this.get('depth');\n  };\n\n  ContentBlock.prototype.getData = function getData() {\n    return this.get('data');\n  };\n\n  ContentBlock.prototype.getInlineStyleAt = function getInlineStyleAt(offset) {\n    var character = this.getCharacterList().get(offset);\n    return character ? character.getStyle() : EMPTY_SET;\n  };\n\n  ContentBlock.prototype.getEntityAt = function getEntityAt(offset) {\n    var character = this.getCharacterList().get(offset);\n    return character ? character.getEntity() : null;\n  };\n\n  /**\n   * Execute a callback for every contiguous range of styles within the block.\n   */\n\n\n  ContentBlock.prototype.findStyleRanges = function findStyleRanges(filterFn, callback) {\n    findRangesImmutable(this.getCharacterList(), haveEqualStyle, filterFn, callback);\n  };\n\n  /**\n   * Execute a callback for every contiguous range of entities within the block.\n   */\n\n\n  ContentBlock.prototype.findEntityRanges = function findEntityRanges(filterFn, callback) {\n    findRangesImmutable(this.getCharacterList(), haveEqualEntity, filterFn, callback);\n  };\n\n  return ContentBlock;\n}(ContentBlockRecord);\n\nfunction haveEqualStyle(charA, charB) {\n  return charA.getStyle() === charB.getStyle();\n}\n\nfunction haveEqualEntity(charA, charB) {\n  return charA.getEntity() === charB.getEntity();\n}\n\nmodule.exports = ContentBlock;\n\n/***/ }),\n/* 77 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n/**\n * Unicode-enabled replacesments for basic String functions.\n *\n * All the functions in this module assume that the input string is a valid\n * UTF-16 encoding of a Unicode sequence. If it's not the case, the behavior\n * will be undefined.\n *\n * WARNING: Since this module is typechecks-enforced, you may find new bugs\n * when replacing normal String functions with ones provided here.\n */\n\n\n\nvar invariant = __webpack_require__(58);\n\n// These two ranges are consecutive so anything in [HIGH_START, LOW_END] is a\n// surrogate code unit.\nvar SURROGATE_HIGH_START = 0xD800;\nvar SURROGATE_HIGH_END = 0xDBFF;\nvar SURROGATE_LOW_START = 0xDC00;\nvar SURROGATE_LOW_END = 0xDFFF;\nvar SURROGATE_UNITS_REGEX = /[\\uD800-\\uDFFF]/;\n\n/**\n * @param {number} codeUnit   A Unicode code-unit, in range [0, 0x10FFFF]\n * @return {boolean}          Whether code-unit is in a surrogate (hi/low) range\n */\nfunction isCodeUnitInSurrogateRange(codeUnit) {\n  return SURROGATE_HIGH_START <= codeUnit && codeUnit <= SURROGATE_LOW_END;\n}\n\n/**\n * Returns whether the two characters starting at `index` form a surrogate pair.\n * For example, given the string s = \"\\uD83D\\uDE0A\", (s, 0) returns true and\n * (s, 1) returns false.\n *\n * @param {string} str\n * @param {number} index\n * @return {boolean}\n */\nfunction isSurrogatePair(str, index) {\n  !(0 <= index && index < str.length) ?  false ? invariant(false, 'isSurrogatePair: Invalid index %s for string length %s.', index, str.length) : invariant(false) : void 0;\n  if (index + 1 === str.length) {\n    return false;\n  }\n  var first = str.charCodeAt(index);\n  var second = str.charCodeAt(index + 1);\n  return SURROGATE_HIGH_START <= first && first <= SURROGATE_HIGH_END && SURROGATE_LOW_START <= second && second <= SURROGATE_LOW_END;\n}\n\n/**\n * @param {string} str  Non-empty string\n * @return {boolean}    True if the input includes any surrogate code units\n */\nfunction hasSurrogateUnit(str) {\n  return SURROGATE_UNITS_REGEX.test(str);\n}\n\n/**\n * Return the length of the original Unicode character at given position in the\n * String by looking into the UTF-16 code unit; that is equal to 1 for any\n * non-surrogate characters in BMP ([U+0000..U+D7FF] and [U+E000, U+FFFF]); and\n * returns 2 for the hi/low surrogates ([U+D800..U+DFFF]), which are in fact\n * representing non-BMP characters ([U+10000..U+10FFFF]).\n *\n * Examples:\n * - '\\u0020' => 1\n * - '\\u3020' => 1\n * - '\\uD835' => 2\n * - '\\uD835\\uDDEF' => 2\n * - '\\uDDEF' => 2\n *\n * @param {string} str  Non-empty string\n * @param {number} pos  Position in the string to look for one code unit\n * @return {number}      Number 1 or 2\n */\nfunction getUTF16Length(str, pos) {\n  return 1 + isCodeUnitInSurrogateRange(str.charCodeAt(pos));\n}\n\n/**\n * Fully Unicode-enabled replacement for String#length\n *\n * @param {string} str  Valid Unicode string\n * @return {number}     The number of Unicode characters in the string\n */\nfunction strlen(str) {\n  // Call the native functions if there's no surrogate char\n  if (!hasSurrogateUnit(str)) {\n    return str.length;\n  }\n\n  var len = 0;\n  for (var pos = 0; pos < str.length; pos += getUTF16Length(str, pos)) {\n    len++;\n  }\n  return len;\n}\n\n/**\n * Fully Unicode-enabled replacement for String#substr()\n *\n * @param {string} str      Valid Unicode string\n * @param {number} start    Location in Unicode sequence to begin extracting\n * @param {?number} length  The number of Unicode characters to extract\n *                          (default: to the end of the string)\n * @return {string}         Extracted sub-string\n */\nfunction substr(str, start, length) {\n  start = start || 0;\n  length = length === undefined ? Infinity : length || 0;\n\n  // Call the native functions if there's no surrogate char\n  if (!hasSurrogateUnit(str)) {\n    return str.substr(start, length);\n  }\n\n  // Obvious cases\n  var size = str.length;\n  if (size <= 0 || start > size || length <= 0) {\n    return '';\n  }\n\n  // Find the actual starting position\n  var posA = 0;\n  if (start > 0) {\n    for (; start > 0 && posA < size; start--) {\n      posA += getUTF16Length(str, posA);\n    }\n    if (posA >= size) {\n      return '';\n    }\n  } else if (start < 0) {\n    for (posA = size; start < 0 && 0 < posA; start++) {\n      posA -= getUTF16Length(str, posA - 1);\n    }\n    if (posA < 0) {\n      posA = 0;\n    }\n  }\n\n  // Find the actual ending position\n  var posB = size;\n  if (length < size) {\n    for (posB = posA; length > 0 && posB < size; length--) {\n      posB += getUTF16Length(str, posB);\n    }\n  }\n\n  return str.substring(posA, posB);\n}\n\n/**\n * Fully Unicode-enabled replacement for String#substring()\n *\n * @param {string} str    Valid Unicode string\n * @param {number} start  Location in Unicode sequence to begin extracting\n * @param {?number} end   Location in Unicode sequence to end extracting\n *                        (default: end of the string)\n * @return {string}       Extracted sub-string\n */\nfunction substring(str, start, end) {\n  start = start || 0;\n  end = end === undefined ? Infinity : end || 0;\n\n  if (start < 0) {\n    start = 0;\n  }\n  if (end < 0) {\n    end = 0;\n  }\n\n  var length = Math.abs(end - start);\n  start = start < end ? start : end;\n  return substr(str, start, length);\n}\n\n/**\n * Get a list of Unicode code-points from a String\n *\n * @param {string} str        Valid Unicode string\n * @return {array<number>}    A list of code-points in [0..0x10FFFF]\n */\nfunction getCodePoints(str) {\n  var codePoints = [];\n  for (var pos = 0; pos < str.length; pos += getUTF16Length(str, pos)) {\n    codePoints.push(str.codePointAt(pos));\n  }\n  return codePoints;\n}\n\nvar UnicodeUtils = {\n  getCodePoints: getCodePoints,\n  getUTF16Length: getUTF16Length,\n  hasSurrogateUnit: hasSurrogateUnit,\n  isCodeUnitInSurrogateRange: isCodeUnitInSurrogateRange,\n  isSurrogatePair: isSurrogatePair,\n  strlen: strlen,\n  substring: substring,\n  substr: substr\n};\n\nmodule.exports = UnicodeUtils;\n\n/***/ }),\n/* 78 */,\n/* 79 */,\n/* 80 */,\n/* 81 */,\n/* 82 */,\n/* 83 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule SelectionState\n * @format\n * \n */\n\n\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar Immutable = __webpack_require__(57);\n\nvar Record = Immutable.Record;\n\n\nvar defaultRecord = {\n  anchorKey: '',\n  anchorOffset: 0,\n  focusKey: '',\n  focusOffset: 0,\n  isBackward: false,\n  hasFocus: false\n};\n\nvar SelectionStateRecord = Record(defaultRecord);\n\nvar SelectionState = function (_SelectionStateRecord) {\n  _inherits(SelectionState, _SelectionStateRecord);\n\n  function SelectionState() {\n    _classCallCheck(this, SelectionState);\n\n    return _possibleConstructorReturn(this, _SelectionStateRecord.apply(this, arguments));\n  }\n\n  SelectionState.prototype.serialize = function serialize() {\n    return 'Anchor: ' + this.getAnchorKey() + ':' + this.getAnchorOffset() + ', ' + 'Focus: ' + this.getFocusKey() + ':' + this.getFocusOffset() + ', ' + 'Is Backward: ' + String(this.getIsBackward()) + ', ' + 'Has Focus: ' + String(this.getHasFocus());\n  };\n\n  SelectionState.prototype.getAnchorKey = function getAnchorKey() {\n    return this.get('anchorKey');\n  };\n\n  SelectionState.prototype.getAnchorOffset = function getAnchorOffset() {\n    return this.get('anchorOffset');\n  };\n\n  SelectionState.prototype.getFocusKey = function getFocusKey() {\n    return this.get('focusKey');\n  };\n\n  SelectionState.prototype.getFocusOffset = function getFocusOffset() {\n    return this.get('focusOffset');\n  };\n\n  SelectionState.prototype.getIsBackward = function getIsBackward() {\n    return this.get('isBackward');\n  };\n\n  SelectionState.prototype.getHasFocus = function getHasFocus() {\n    return this.get('hasFocus');\n  };\n\n  /**\n   * Return whether the specified range overlaps with an edge of the\n   * SelectionState.\n   */\n\n\n  SelectionState.prototype.hasEdgeWithin = function hasEdgeWithin(blockKey, start, end) {\n    var anchorKey = this.getAnchorKey();\n    var focusKey = this.getFocusKey();\n\n    if (anchorKey === focusKey && anchorKey === blockKey) {\n      var selectionStart = this.getStartOffset();\n      var selectionEnd = this.getEndOffset();\n      return start <= selectionEnd && selectionStart <= end;\n    }\n\n    if (blockKey !== anchorKey && blockKey !== focusKey) {\n      return false;\n    }\n\n    var offsetToCheck = blockKey === anchorKey ? this.getAnchorOffset() : this.getFocusOffset();\n\n    return start <= offsetToCheck && end >= offsetToCheck;\n  };\n\n  SelectionState.prototype.isCollapsed = function isCollapsed() {\n    return this.getAnchorKey() === this.getFocusKey() && this.getAnchorOffset() === this.getFocusOffset();\n  };\n\n  SelectionState.prototype.getStartKey = function getStartKey() {\n    return this.getIsBackward() ? this.getFocusKey() : this.getAnchorKey();\n  };\n\n  SelectionState.prototype.getStartOffset = function getStartOffset() {\n    return this.getIsBackward() ? this.getFocusOffset() : this.getAnchorOffset();\n  };\n\n  SelectionState.prototype.getEndKey = function getEndKey() {\n    return this.getIsBackward() ? this.getAnchorKey() : this.getFocusKey();\n  };\n\n  SelectionState.prototype.getEndOffset = function getEndOffset() {\n    return this.getIsBackward() ? this.getAnchorOffset() : this.getFocusOffset();\n  };\n\n  SelectionState.createEmpty = function createEmpty(key) {\n    return new SelectionState({\n      anchorKey: key,\n      anchorOffset: 0,\n      focusKey: key,\n      focusOffset: 0,\n      isBackward: false,\n      hasFocus: false\n    });\n  };\n\n  return SelectionState;\n}(SelectionStateRecord);\n\nmodule.exports = SelectionState;\n\n/***/ }),\n/* 84 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/**\n * This function is used to mark string literals representing CSS class names\n * so that they can be transformed statically. This allows for modularization\n * and minification of CSS class names.\n *\n * In static_upstream, this function is actually implemented, but it should\n * eventually be replaced with something more descriptive, and the transform\n * that is used in the main stack should be ported for use elsewhere.\n *\n * @param string|object className to modularize, or an object of key/values.\n *                      In the object case, the values are conditions that\n *                      determine if the className keys should be included.\n * @param [string ...]  Variable list of classNames in the string case.\n * @return string       Renderable space-separated CSS className.\n */\nfunction cx(classNames) {\n  if (typeof classNames == 'object') {\n    return Object.keys(classNames).filter(function (className) {\n      return classNames[className];\n    }).map(replace).join(' ');\n  }\n  return Array.prototype.map.call(arguments, replace).join(' ');\n}\n\nfunction replace(str) {\n  return str.replace(/\\//g, '-');\n}\n\nmodule.exports = cx;\n\n/***/ }),\n/* 85 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {var DEFAULT_MODE_DESKTOP = true;\nvar MOBILE_MAX_WIDTH = 767;\nvar DESKTOP_MIN_WIDTH = 768;\nvar DEFAULT_WIDTH = 768;\n\nfunction isMobile() {\n  if (!global.window) return !DEFAULT_MODE_DESKTOP;\n  return window.innerWidth < DESKTOP_MIN_WIDTH;\n}\nfunction isDesktop() {\n  if (!global.window) return DEFAULT_MODE_DESKTOP;\n  return window.innerWidth > MOBILE_MAX_WIDTH;\n}\n\n/* harmony default export */ __webpack_exports__[\"a\"] = ({\n  defaultWidth: DEFAULT_WIDTH,\n  desktopWidth: DESKTOP_MIN_WIDTH,\n  mobileWidth: MOBILE_MAX_WIDTH,\n  isDesktop: isDesktop,\n  isMobile: isMobile\n});\n/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(2)))\n\n/***/ }),\n/* 86 */,\n/* 87 */,\n/* 88 */,\n/* 89 */,\n/* 90 */,\n/* 91 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule BlockMapBuilder\n * @format\n * \n */\n\n\n\nvar Immutable = __webpack_require__(57);\n\nvar OrderedMap = Immutable.OrderedMap;\n\n\nvar BlockMapBuilder = {\n  createFromArray: function createFromArray(blocks) {\n    return OrderedMap(blocks.map(function (block) {\n      return [block.getKey(), block];\n    }));\n  }\n};\n\nmodule.exports = BlockMapBuilder;\n\n/***/ }),\n/* 92 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule findRangesImmutable\n * @format\n * \n */\n\n\n\n/**\n * Search through an array to find contiguous stretches of elements that\n * match a specified filter function.\n *\n * When ranges are found, execute a specified `found` function to supply\n * the values to the caller.\n */\nfunction findRangesImmutable(haystack, areEqualFn, filterFn, foundFn) {\n  if (!haystack.size) {\n    return;\n  }\n\n  var cursor = 0;\n\n  haystack.reduce(function (value, nextValue, nextIndex) {\n    if (!areEqualFn(value, nextValue)) {\n      if (filterFn(value)) {\n        foundFn(cursor, nextIndex);\n      }\n      cursor = nextIndex;\n    }\n    return nextValue;\n  });\n\n  filterFn(haystack.last()) && foundFn(cursor, haystack.count());\n}\n\nmodule.exports = findRangesImmutable;\n\n/***/ }),\n/* 93 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule isEventHandled\n * @format\n * \n */\n\n\n\n/**\n * Utility method for determining whether or not the value returned\n * from a handler indicates that it was handled.\n */\nfunction isEventHandled(value) {\n  return value === 'handled' || value === true;\n}\n\nmodule.exports = isEventHandled;\n\n/***/ }),\n/* 94 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule removeTextWithStrategy\n * @format\n * \n */\n\n\n\nvar DraftModifier = __webpack_require__(62);\n\n/**\n * For a collapsed selection state, remove text based on the specified strategy.\n * If the selection state is not collapsed, remove the entire selected range.\n */\nfunction removeTextWithStrategy(editorState, strategy, direction) {\n  var selection = editorState.getSelection();\n  var content = editorState.getCurrentContent();\n  var target = selection;\n  if (selection.isCollapsed()) {\n    if (direction === 'forward') {\n      if (editorState.isSelectionAtEndOfContent()) {\n        return content;\n      }\n    } else if (editorState.isSelectionAtStartOfContent()) {\n      return content;\n    }\n\n    target = strategy(editorState);\n    if (target === selection) {\n      return content;\n    }\n  }\n  return DraftModifier.removeRange(content, target, direction);\n}\n\nmodule.exports = removeTextWithStrategy;\n\n/***/ }),\n/* 95 */,\n/* 96 */,\n/* 97 */,\n/* 98 */,\n/* 99 */,\n/* 100 */,\n/* 101 */,\n/* 102 */,\n/* 103 */,\n/* 104 */,\n/* 105 */,\n/* 106 */,\n/* 107 */,\n/* 108 */,\n/* 109 */,\n/* 110 */,\n/* 111 */,\n/* 112 */,\n/* 113 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"preview\":\"lQq327\",\"date\":\"t2Ob9m\",\"header\":\"_2kk3hN\",\"title\":\"Cfb3RR\",\"votes\":\"_3at1A7\",\"info\":\"_2-6RI9\",\"progressContainer\":\"ssLhPH\",\"progress\":\"_2KXwjO\",\"finished\":\"_25moSc\"};\n\n/***/ }),\n/* 114 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getContentStateFragment\n * @format\n * \n */\n\n\n\nvar randomizeBlockMapKeys = __webpack_require__(218);\nvar removeEntitiesAtEdges = __webpack_require__(219);\n\nvar getContentStateFragment = function getContentStateFragment(contentState, selectionState) {\n  var startKey = selectionState.getStartKey();\n  var startOffset = selectionState.getStartOffset();\n  var endKey = selectionState.getEndKey();\n  var endOffset = selectionState.getEndOffset();\n\n  // Edge entities should be stripped to ensure that we don't preserve\n  // invalid partial entities when the fragment is reused. We do, however,\n  // preserve entities that are entirely within the selection range.\n  var contentWithoutEdgeEntities = removeEntitiesAtEdges(contentState, selectionState);\n\n  var blockMap = contentWithoutEdgeEntities.getBlockMap();\n  var blockKeys = blockMap.keySeq();\n  var startIndex = blockKeys.indexOf(startKey);\n  var endIndex = blockKeys.indexOf(endKey) + 1;\n\n  return randomizeBlockMapKeys(blockMap.slice(startIndex, endIndex).map(function (block, blockKey) {\n    var text = block.getText();\n    var chars = block.getCharacterList();\n\n    if (startKey === endKey) {\n      return block.merge({\n        text: text.slice(startOffset, endOffset),\n        characterList: chars.slice(startOffset, endOffset)\n      });\n    }\n\n    if (blockKey === startKey) {\n      return block.merge({\n        text: text.slice(startOffset),\n        characterList: chars.slice(startOffset)\n      });\n    }\n\n    if (blockKey === endKey) {\n      return block.merge({\n        text: text.slice(0, endOffset),\n        characterList: chars.slice(0, endOffset)\n      });\n    }\n\n    return block;\n  }));\n};\n\nmodule.exports = getContentStateFragment;\n\n/***/ }),\n/* 115 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _assign = __webpack_require__(3);\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEntity\n * @format\n * \n */\n\nvar DraftEntityInstance = __webpack_require__(223);\nvar Immutable = __webpack_require__(57);\n\nvar invariant = __webpack_require__(58);\n\nvar Map = Immutable.Map;\n\n\nvar instances = Map();\nvar instanceKey = 0;\n\n/**\n * Temporary utility for generating the warnings\n */\nfunction logWarning(oldMethodCall, newMethodCall) {\n  console.warn('WARNING: ' + oldMethodCall + ' will be deprecated soon!\\nPlease use \"' + newMethodCall + '\" instead.');\n}\n\n/**\n * A \"document entity\" is an object containing metadata associated with a\n * piece of text in a ContentBlock.\n *\n * For example, a `link` entity might include a `uri` property. When a\n * ContentBlock is rendered in the browser, text that refers to that link\n * entity may be rendered as an anchor, with the `uri` as the href value.\n *\n * In a ContentBlock, every position in the text may correspond to zero\n * or one entities. This correspondence is tracked using a key string,\n * generated via DraftEntity.create() and used to obtain entity metadata\n * via DraftEntity.get().\n */\nvar DraftEntity = {\n  /**\n   * WARNING: This method will be deprecated soon!\n   * Please use 'contentState.getLastCreatedEntityKey' instead.\n   * ---\n   * Get the random key string from whatever entity was last created.\n   * We need this to support the new API, as part of transitioning to put Entity\n   * storage in contentState.\n   */\n  getLastCreatedEntityKey: function getLastCreatedEntityKey() {\n    logWarning('DraftEntity.getLastCreatedEntityKey', 'contentState.getLastCreatedEntityKey');\n    return DraftEntity.__getLastCreatedEntityKey();\n  },\n\n  /**\n   * WARNING: This method will be deprecated soon!\n   * Please use 'contentState.createEntity' instead.\n   * ---\n   * Create a DraftEntityInstance and store it for later retrieval.\n   *\n   * A random key string will be generated and returned. This key may\n   * be used to track the entity's usage in a ContentBlock, and for\n   * retrieving data about the entity at render time.\n   */\n  create: function create(type, mutability, data) {\n    logWarning('DraftEntity.create', 'contentState.createEntity');\n    return DraftEntity.__create(type, mutability, data);\n  },\n\n  /**\n   * WARNING: This method will be deprecated soon!\n   * Please use 'contentState.addEntity' instead.\n   * ---\n   * Add an existing DraftEntityInstance to the DraftEntity map. This is\n   * useful when restoring instances from the server.\n   */\n  add: function add(instance) {\n    logWarning('DraftEntity.add', 'contentState.addEntity');\n    return DraftEntity.__add(instance);\n  },\n\n  /**\n   * WARNING: This method will be deprecated soon!\n   * Please use 'contentState.getEntity' instead.\n   * ---\n   * Retrieve the entity corresponding to the supplied key string.\n   */\n  get: function get(key) {\n    logWarning('DraftEntity.get', 'contentState.getEntity');\n    return DraftEntity.__get(key);\n  },\n\n  /**\n   * WARNING: This method will be deprecated soon!\n   * Please use 'contentState.mergeEntityData' instead.\n   * ---\n   * Entity instances are immutable. If you need to update the data for an\n   * instance, this method will merge your data updates and return a new\n   * instance.\n   */\n  mergeData: function mergeData(key, toMerge) {\n    logWarning('DraftEntity.mergeData', 'contentState.mergeEntityData');\n    return DraftEntity.__mergeData(key, toMerge);\n  },\n\n  /**\n   * WARNING: This method will be deprecated soon!\n   * Please use 'contentState.replaceEntityData' instead.\n   * ---\n   * Completely replace the data for a given instance.\n   */\n  replaceData: function replaceData(key, newData) {\n    logWarning('DraftEntity.replaceData', 'contentState.replaceEntityData');\n    return DraftEntity.__replaceData(key, newData);\n  },\n\n  // ***********************************WARNING******************************\n  // --- the above public API will be deprecated in the next version of Draft!\n  // The methods below this line are private - don't call them directly.\n\n  /**\n   * Get the random key string from whatever entity was last created.\n   * We need this to support the new API, as part of transitioning to put Entity\n   * storage in contentState.\n   */\n  __getLastCreatedEntityKey: function __getLastCreatedEntityKey() {\n    return '' + instanceKey;\n  },\n\n  /**\n   * Create a DraftEntityInstance and store it for later retrieval.\n   *\n   * A random key string will be generated and returned. This key may\n   * be used to track the entity's usage in a ContentBlock, and for\n   * retrieving data about the entity at render time.\n   */\n  __create: function __create(type, mutability, data) {\n    return DraftEntity.__add(new DraftEntityInstance({ type: type, mutability: mutability, data: data || {} }));\n  },\n\n  /**\n   * Add an existing DraftEntityInstance to the DraftEntity map. This is\n   * useful when restoring instances from the server.\n   */\n  __add: function __add(instance) {\n    var key = '' + ++instanceKey;\n    instances = instances.set(key, instance);\n    return key;\n  },\n\n  /**\n   * Retrieve the entity corresponding to the supplied key string.\n   */\n  __get: function __get(key) {\n    var instance = instances.get(key);\n    !!!instance ?  false ? invariant(false, 'Unknown DraftEntity key: %s.', key) : invariant(false) : void 0;\n    return instance;\n  },\n\n  /**\n   * Entity instances are immutable. If you need to update the data for an\n   * instance, this method will merge your data updates and return a new\n   * instance.\n   */\n  __mergeData: function __mergeData(key, toMerge) {\n    var instance = DraftEntity.__get(key);\n    var newData = _extends({}, instance.getData(), toMerge);\n    var newInstance = instance.set('data', newData);\n    instances = instances.set(key, newInstance);\n    return newInstance;\n  },\n\n  /**\n   * Completely replace the data for a given instance.\n   */\n  __replaceData: function __replaceData(key, newData) {\n    var instance = DraftEntity.__get(key);\n    var newInstance = instance.set('data', newData);\n    instances = instances.set(key, newInstance);\n    return newInstance;\n  }\n};\n\nmodule.exports = DraftEntity;\n\n/***/ }),\n/* 116 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftOffsetKey\n * @format\n * \n */\n\n\n\nvar KEY_DELIMITER = '-';\n\nvar DraftOffsetKey = {\n  encode: function encode(blockKey, decoratorKey, leafKey) {\n    return blockKey + KEY_DELIMITER + decoratorKey + KEY_DELIMITER + leafKey;\n  },\n\n  decode: function decode(offsetKey) {\n    var _offsetKey$split = offsetKey.split(KEY_DELIMITER),\n        blockKey = _offsetKey$split[0],\n        decoratorKey = _offsetKey$split[1],\n        leafKey = _offsetKey$split[2];\n\n    return {\n      blockKey: blockKey,\n      decoratorKey: parseInt(decoratorKey, 10),\n      leafKey: parseInt(leafKey, 10)\n    };\n  }\n};\n\nmodule.exports = DraftOffsetKey;\n\n/***/ }),\n/* 117 */,\n/* 118 */,\n/* 119 */,\n/* 120 */,\n/* 121 */,\n/* 122 */,\n/* 123 */,\n/* 124 */,\n/* 125 */,\n/* 126 */,\n/* 127 */,\n/* 128 */,\n/* 129 */,\n/* 130 */,\n/* 131 */,\n/* 132 */,\n/* 133 */,\n/* 134 */,\n/* 135 */,\n/* 136 */,\n/* 137 */,\n/* 138 */,\n/* 139 */,\n/* 140 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony default export */ __webpack_exports__[\"a\"] = ([{\n  errorType: 'fieldIsRequired',\n  errorMessage: 'Dette felt skal udfyldes'\n}, {\n  errorType: 'maxLengthExceeded',\n  errorMessage: 'Der er brugt for mange tegn'\n}, {\n  errorType: 'isLessThanMinLength',\n  errorMessage: 'Dette felt er ikke langt nok'\n}, {\n  errorType: 'isNotPhoneNumber',\n  errorMessage: 'Ikke valid telefonnummer'\n}, {\n  errorType: 'isNotValidEmail',\n  errorMessage: 'Ikke valid email'\n}, {\n  errorType: 'isNotValidTitle',\n  errorMessage: 'Titel er allerede brugt'\n}, {\n  errorType: 'somethingWentWrong',\n  errorMessage: 'Der skete en fejl, prøv igen'\n}]);\n\n/***/ }),\n/* 141 */,\n/* 142 */,\n/* 143 */,\n/* 144 */,\n/* 145 */,\n/* 146 */,\n/* 147 */,\n/* 148 */,\n/* 149 */,\n/* 150 */,\n/* 151 */,\n/* 152 */,\n/* 153 */,\n/* 154 */,\n/* 155 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__preview_style_css__ = __webpack_require__(113);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__preview_style_css___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__preview_style_css__);\n\n// eslint-disable-line no-unused-vars\n\n\n// Add any default values for props\nvar defaultProps = {\n  votes: 10000,\n  votesLimit: 50000\n};\n\nvar getWidth = function getWidth(votes, limit) {\n  /*\n   * If there are less than 5% the votes needed,\n   * represent the progress by using Math.sqrt\n   */\n  if (votes / limit * 100 <= 5) return Math.sqrt(votes) / Math.sqrt(limit) * 50;\n  if (votes / limit * 100 <= 15) return Math.sqrt(votes) / Math.sqrt(limit) * 55;\n  /*\n   * Else use a linear representation\n   */\n  return votes / limit * 100;\n};\n\nfunction VotesIndicator(_ref) {\n  var _ref$votes = _ref.votes,\n      votes = _ref$votes === undefined ? 20356 : _ref$votes,\n      votesLimit = _ref.votesLimit;\n\n  var progress = parseInt(votes, 10);\n  return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n    'div',\n    { className: __WEBPACK_IMPORTED_MODULE_1__preview_style_css___default.a.progressContainer },\n    __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement('div', {\n      className: __WEBPACK_IMPORTED_MODULE_1__preview_style_css___default.a.progress,\n      style: { width: getWidth(progress, votesLimit) + '%' }\n    })\n  );\n}\n\nVotesIndicator.displayName = 'VotesIndicator';\n\nVotesIndicator.defaultProps = defaultProps;\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (VotesIndicator);\n\n/***/ }),\n/* 156 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\nfunction makeEmptyFunction(arg) {\n  return function () {\n    return arg;\n  };\n}\n\n/**\n * This function accepts and discards inputs; it has no side effects. This is\n * primarily useful idiomatically for overridable function endpoints which\n * always need to be callable, since JS lacks a null-call idiom ala Cocoa.\n */\nvar emptyFunction = function emptyFunction() {};\n\nemptyFunction.thatReturns = makeEmptyFunction;\nemptyFunction.thatReturnsFalse = makeEmptyFunction(false);\nemptyFunction.thatReturnsTrue = makeEmptyFunction(true);\nemptyFunction.thatReturnsNull = makeEmptyFunction(null);\nemptyFunction.thatReturnsThis = function () {\n  return this;\n};\nemptyFunction.thatReturnsArgument = function (arg) {\n  return arg;\n};\n\nmodule.exports = emptyFunction;\n\n/***/ }),\n/* 157 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ContentState\n * @format\n * \n */\n\n\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar BlockMapBuilder = __webpack_require__(91);\nvar CharacterMetadata = __webpack_require__(63);\nvar ContentBlock = __webpack_require__(76);\nvar ContentBlockNode = __webpack_require__(64);\nvar DraftEntity = __webpack_require__(115);\nvar DraftFeatureFlags = __webpack_require__(71);\nvar Immutable = __webpack_require__(57);\nvar SelectionState = __webpack_require__(83);\n\nvar generateRandomKey = __webpack_require__(70);\nvar sanitizeDraftText = __webpack_require__(158);\n\nvar List = Immutable.List,\n    Record = Immutable.Record,\n    Repeat = Immutable.Repeat;\n\n\nvar experimentalTreeDataSupport = DraftFeatureFlags.draft_tree_data_support;\n\nvar defaultRecord = {\n  entityMap: null,\n  blockMap: null,\n  selectionBefore: null,\n  selectionAfter: null\n};\n\nvar ContentBlockNodeRecord = experimentalTreeDataSupport ? ContentBlockNode : ContentBlock;\n\nvar ContentStateRecord = Record(defaultRecord);\n\nvar ContentState = function (_ContentStateRecord) {\n  _inherits(ContentState, _ContentStateRecord);\n\n  function ContentState() {\n    _classCallCheck(this, ContentState);\n\n    return _possibleConstructorReturn(this, _ContentStateRecord.apply(this, arguments));\n  }\n\n  ContentState.prototype.getEntityMap = function getEntityMap() {\n    // TODO: update this when we fully remove DraftEntity\n    return DraftEntity;\n  };\n\n  ContentState.prototype.getBlockMap = function getBlockMap() {\n    return this.get('blockMap');\n  };\n\n  ContentState.prototype.getSelectionBefore = function getSelectionBefore() {\n    return this.get('selectionBefore');\n  };\n\n  ContentState.prototype.getSelectionAfter = function getSelectionAfter() {\n    return this.get('selectionAfter');\n  };\n\n  ContentState.prototype.getBlockForKey = function getBlockForKey(key) {\n    var block = this.getBlockMap().get(key);\n    return block;\n  };\n\n  ContentState.prototype.getKeyBefore = function getKeyBefore(key) {\n    return this.getBlockMap().reverse().keySeq().skipUntil(function (v) {\n      return v === key;\n    }).skip(1).first();\n  };\n\n  ContentState.prototype.getKeyAfter = function getKeyAfter(key) {\n    return this.getBlockMap().keySeq().skipUntil(function (v) {\n      return v === key;\n    }).skip(1).first();\n  };\n\n  ContentState.prototype.getBlockAfter = function getBlockAfter(key) {\n    return this.getBlockMap().skipUntil(function (_, k) {\n      return k === key;\n    }).skip(1).first();\n  };\n\n  ContentState.prototype.getBlockBefore = function getBlockBefore(key) {\n    return this.getBlockMap().reverse().skipUntil(function (_, k) {\n      return k === key;\n    }).skip(1).first();\n  };\n\n  ContentState.prototype.getBlocksAsArray = function getBlocksAsArray() {\n    return this.getBlockMap().toArray();\n  };\n\n  ContentState.prototype.getFirstBlock = function getFirstBlock() {\n    return this.getBlockMap().first();\n  };\n\n  ContentState.prototype.getLastBlock = function getLastBlock() {\n    return this.getBlockMap().last();\n  };\n\n  ContentState.prototype.getPlainText = function getPlainText(delimiter) {\n    return this.getBlockMap().map(function (block) {\n      return block ? block.getText() : '';\n    }).join(delimiter || '\\n');\n  };\n\n  ContentState.prototype.getLastCreatedEntityKey = function getLastCreatedEntityKey() {\n    // TODO: update this when we fully remove DraftEntity\n    return DraftEntity.__getLastCreatedEntityKey();\n  };\n\n  ContentState.prototype.hasText = function hasText() {\n    var blockMap = this.getBlockMap();\n    return blockMap.size > 1 || blockMap.first().getLength() > 0;\n  };\n\n  ContentState.prototype.createEntity = function createEntity(type, mutability, data) {\n    // TODO: update this when we fully remove DraftEntity\n    DraftEntity.__create(type, mutability, data);\n    return this;\n  };\n\n  ContentState.prototype.mergeEntityData = function mergeEntityData(key, toMerge) {\n    // TODO: update this when we fully remove DraftEntity\n    DraftEntity.__mergeData(key, toMerge);\n    return this;\n  };\n\n  ContentState.prototype.replaceEntityData = function replaceEntityData(key, newData) {\n    // TODO: update this when we fully remove DraftEntity\n    DraftEntity.__replaceData(key, newData);\n    return this;\n  };\n\n  ContentState.prototype.addEntity = function addEntity(instance) {\n    // TODO: update this when we fully remove DraftEntity\n    DraftEntity.__add(instance);\n    return this;\n  };\n\n  ContentState.prototype.getEntity = function getEntity(key) {\n    // TODO: update this when we fully remove DraftEntity\n    return DraftEntity.__get(key);\n  };\n\n  ContentState.createFromBlockArray = function createFromBlockArray(\n  // TODO: update flow type when we completely deprecate the old entity API\n  blocks, entityMap) {\n    // TODO: remove this when we completely deprecate the old entity API\n    var theBlocks = Array.isArray(blocks) ? blocks : blocks.contentBlocks;\n    var blockMap = BlockMapBuilder.createFromArray(theBlocks);\n    var selectionState = blockMap.isEmpty() ? new SelectionState() : SelectionState.createEmpty(blockMap.first().getKey());\n    return new ContentState({\n      blockMap: blockMap,\n      entityMap: entityMap || DraftEntity,\n      selectionBefore: selectionState,\n      selectionAfter: selectionState\n    });\n  };\n\n  ContentState.createFromText = function createFromText(text) {\n    var delimiter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : /\\r\\n?|\\n/g;\n\n    var strings = text.split(delimiter);\n    var blocks = strings.map(function (block) {\n      block = sanitizeDraftText(block);\n      return new ContentBlockNodeRecord({\n        key: generateRandomKey(),\n        text: block,\n        type: 'unstyled',\n        characterList: List(Repeat(CharacterMetadata.EMPTY, block.length))\n      });\n    });\n    return ContentState.createFromBlockArray(blocks);\n  };\n\n  return ContentState;\n}(ContentStateRecord);\n\nmodule.exports = ContentState;\n\n/***/ }),\n/* 158 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule sanitizeDraftText\n * @format\n * \n */\n\n\n\nvar REGEX_BLOCK_DELIMITER = new RegExp('\\r', 'g');\n\nfunction sanitizeDraftText(input) {\n  return input.replace(REGEX_BLOCK_DELIMITER, '');\n}\n\nmodule.exports = sanitizeDraftText;\n\n/***/ }),\n/* 159 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n * \n */\n\n/**\n * Constants to represent text directionality\n *\n * Also defines a *global* direciton, to be used in bidi algorithms as a\n * default fallback direciton, when no better direction is found or provided.\n *\n * NOTE: Use `setGlobalDir()`, or update `initGlobalDir()`, to set the initial\n *       global direction value based on the application.\n *\n * Part of the implementation of Unicode Bidirectional Algorithm (UBA)\n * Unicode Standard Annex #9 (UAX9)\n * http://www.unicode.org/reports/tr9/\n */\n\n\n\nvar invariant = __webpack_require__(58);\n\nvar NEUTRAL = 'NEUTRAL'; // No strong direction\nvar LTR = 'LTR'; // Left-to-Right direction\nvar RTL = 'RTL'; // Right-to-Left direction\n\nvar globalDir = null;\n\n// == Helpers ==\n\n/**\n * Check if a directionality value is a Strong one\n */\nfunction isStrong(dir) {\n  return dir === LTR || dir === RTL;\n}\n\n/**\n * Get string value to be used for `dir` HTML attribute or `direction` CSS\n * property.\n */\nfunction getHTMLDir(dir) {\n  !isStrong(dir) ?  false ? invariant(false, '`dir` must be a strong direction to be converted to HTML Direction') : invariant(false) : void 0;\n  return dir === LTR ? 'ltr' : 'rtl';\n}\n\n/**\n * Get string value to be used for `dir` HTML attribute or `direction` CSS\n * property, but returns null if `dir` has same value as `otherDir`.\n * `null`.\n */\nfunction getHTMLDirIfDifferent(dir, otherDir) {\n  !isStrong(dir) ?  false ? invariant(false, '`dir` must be a strong direction to be converted to HTML Direction') : invariant(false) : void 0;\n  !isStrong(otherDir) ?  false ? invariant(false, '`otherDir` must be a strong direction to be converted to HTML Direction') : invariant(false) : void 0;\n  return dir === otherDir ? null : getHTMLDir(dir);\n}\n\n// == Global Direction ==\n\n/**\n * Set the global direction.\n */\nfunction setGlobalDir(dir) {\n  globalDir = dir;\n}\n\n/**\n * Initialize the global direction\n */\nfunction initGlobalDir() {\n  setGlobalDir(LTR);\n}\n\n/**\n * Get the global direction\n */\nfunction getGlobalDir() {\n  if (!globalDir) {\n    this.initGlobalDir();\n  }\n  !globalDir ?  false ? invariant(false, 'Global direction not set.') : invariant(false) : void 0;\n  return globalDir;\n}\n\nvar UnicodeBidiDirection = {\n  // Values\n  NEUTRAL: NEUTRAL,\n  LTR: LTR,\n  RTL: RTL,\n  // Helpers\n  isStrong: isStrong,\n  getHTMLDir: getHTMLDir,\n  getHTMLDirIfDifferent: getHTMLDirIfDifferent,\n  // Global Direction\n  setGlobalDir: setGlobalDir,\n  initGlobalDir: initGlobalDir,\n  getGlobalDir: getGlobalDir\n};\n\nmodule.exports = UnicodeBidiDirection;\n\n/***/ }),\n/* 160 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DefaultDraftBlockRenderMap\n * @format\n * \n */\n\n\n\nvar _require = __webpack_require__(57),\n    Map = _require.Map;\n\nvar React = __webpack_require__(0);\n\nvar cx = __webpack_require__(84);\n\nvar UL_WRAP = React.createElement('ul', { className: cx('public/DraftStyleDefault/ul') });\nvar OL_WRAP = React.createElement('ol', { className: cx('public/DraftStyleDefault/ol') });\nvar PRE_WRAP = React.createElement('pre', { className: cx('public/DraftStyleDefault/pre') });\n\nvar DefaultDraftBlockRenderMap = Map({\n  'header-one': {\n    element: 'h1'\n  },\n  'header-two': {\n    element: 'h2'\n  },\n  'header-three': {\n    element: 'h3'\n  },\n  'header-four': {\n    element: 'h4'\n  },\n  'header-five': {\n    element: 'h5'\n  },\n  'header-six': {\n    element: 'h6'\n  },\n  'unordered-list-item': {\n    element: 'li',\n    wrapper: UL_WRAP\n  },\n  'ordered-list-item': {\n    element: 'li',\n    wrapper: OL_WRAP\n  },\n  blockquote: {\n    element: 'blockquote'\n  },\n  atomic: {\n    element: 'figure'\n  },\n  'code-block': {\n    element: 'pre',\n    wrapper: PRE_WRAP\n  },\n  unstyled: {\n    element: 'div',\n    aliasedElements: ['p']\n  }\n});\n\nmodule.exports = DefaultDraftBlockRenderMap;\n\n/***/ }),\n/* 161 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nmodule.exports = {\n  BACKSPACE: 8,\n  TAB: 9,\n  RETURN: 13,\n  ALT: 18,\n  ESC: 27,\n  SPACE: 32,\n  PAGE_UP: 33,\n  PAGE_DOWN: 34,\n  END: 35,\n  HOME: 36,\n  LEFT: 37,\n  UP: 38,\n  RIGHT: 39,\n  DOWN: 40,\n  DELETE: 46,\n  COMMA: 188,\n  PERIOD: 190,\n  A: 65,\n  Z: 90,\n  ZERO: 48,\n  NUMPAD_0: 96,\n  NUMPAD_9: 105\n};\n\n/***/ }),\n/* 162 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getEntityKeyForSelection\n * @format\n * \n */\n\n\n\n/**\n * Return the entity key that should be used when inserting text for the\n * specified target selection, only if the entity is `MUTABLE`. `IMMUTABLE`\n * and `SEGMENTED` entities should not be used for insertion behavior.\n */\nfunction getEntityKeyForSelection(contentState, targetSelection) {\n  var entityKey;\n\n  if (targetSelection.isCollapsed()) {\n    var key = targetSelection.getAnchorKey();\n    var offset = targetSelection.getAnchorOffset();\n    if (offset > 0) {\n      entityKey = contentState.getBlockForKey(key).getEntityAt(offset - 1);\n      if (entityKey !== contentState.getBlockForKey(key).getEntityAt(offset)) {\n        return null;\n      }\n      return filterKey(contentState.getEntityMap(), entityKey);\n    }\n    return null;\n  }\n\n  var startKey = targetSelection.getStartKey();\n  var startOffset = targetSelection.getStartOffset();\n  var startBlock = contentState.getBlockForKey(startKey);\n\n  entityKey = startOffset === startBlock.getLength() ? null : startBlock.getEntityAt(startOffset);\n\n  return filterKey(contentState.getEntityMap(), entityKey);\n}\n\n/**\n * Determine whether an entity key corresponds to a `MUTABLE` entity. If so,\n * return it. If not, return null.\n */\nfunction filterKey(entityMap, entityKey) {\n  if (entityKey) {\n    var entity = entityMap.__get(entityKey);\n    return entity.getMutability() === 'MUTABLE' ? entityKey : null;\n  }\n  return null;\n}\n\nmodule.exports = getEntityKeyForSelection;\n\n/***/ }),\n/* 163 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\nvar isTextNode = __webpack_require__(453);\n\n/*eslint-disable no-bitwise */\n\n/**\n * Checks if a given DOM node contains or is another DOM node.\n */\nfunction containsNode(outerNode, innerNode) {\n  if (!outerNode || !innerNode) {\n    return false;\n  } else if (outerNode === innerNode) {\n    return true;\n  } else if (isTextNode(outerNode)) {\n    return false;\n  } else if (isTextNode(innerNode)) {\n    return containsNode(outerNode, innerNode.parentNode);\n  } else if ('contains' in outerNode) {\n    return outerNode.contains(innerNode);\n  } else if (outerNode.compareDocumentPosition) {\n    return !!(outerNode.compareDocumentPosition(innerNode) & 16);\n  } else {\n    return false;\n  }\n}\n\nmodule.exports = containsNode;\n\n/***/ }),\n/* 164 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar getStyleProperty = __webpack_require__(455);\n\n/**\n * @param {DOMNode} element [description]\n * @param {string} name Overflow style property name.\n * @return {boolean} True if the supplied ndoe is scrollable.\n */\nfunction _isNodeScrollable(element, name) {\n  var overflow = Style.get(element, name);\n  return overflow === 'auto' || overflow === 'scroll';\n}\n\n/**\n * Utilities for querying and mutating style properties.\n */\nvar Style = {\n  /**\n   * Gets the style property for the supplied node. This will return either the\n   * computed style, if available, or the declared style.\n   *\n   * @param {DOMNode} node\n   * @param {string} name Style property name.\n   * @return {?string} Style property value.\n   */\n  get: getStyleProperty,\n\n  /**\n   * Determines the nearest ancestor of a node that is scrollable.\n   *\n   * NOTE: This can be expensive if used repeatedly or on a node nested deeply.\n   *\n   * @param {?DOMNode} node Node from which to start searching.\n   * @return {?DOMWindow|DOMElement} Scroll parent of the supplied node.\n   */\n  getScrollParent: function getScrollParent(node) {\n    if (!node) {\n      return null;\n    }\n    var ownerDocument = node.ownerDocument;\n    while (node && node !== ownerDocument.body) {\n      if (_isNodeScrollable(node, 'overflow') || _isNodeScrollable(node, 'overflowY') || _isNodeScrollable(node, 'overflowX')) {\n        return node;\n      }\n      node = node.parentNode;\n    }\n    return ownerDocument.defaultView || ownerDocument.parentWindow;\n  }\n\n};\n\nmodule.exports = Style;\n\n/***/ }),\n/* 165 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n\n\nvar getDocumentScrollElement = __webpack_require__(460);\nvar getUnboundedScrollPosition = __webpack_require__(461);\n\n/**\n * Gets the scroll position of the supplied element or window.\n *\n * The return values are bounded. This means that if the scroll position is\n * negative or exceeds the element boundaries (which is possible using inertial\n * scrolling), you will get zero or the maximum scroll position, respectively.\n *\n * If you need the unbound scroll position, use `getUnboundedScrollPosition`.\n *\n * @param {DOMWindow|DOMElement} scrollable\n * @return {object} Map with `x` and `y` keys.\n */\nfunction getScrollPosition(scrollable) {\n  var documentScrollElement = getDocumentScrollElement(scrollable.ownerDocument || scrollable.document);\n  if (scrollable.Window && scrollable instanceof scrollable.Window) {\n    scrollable = documentScrollElement;\n  }\n  var scrollPosition = getUnboundedScrollPosition(scrollable);\n\n  var viewport = scrollable === documentScrollElement ? scrollable.ownerDocument.documentElement : scrollable;\n\n  var xMax = scrollable.scrollWidth - viewport.clientWidth;\n  var yMax = scrollable.scrollHeight - viewport.clientHeight;\n\n  scrollPosition.x = Math.max(0, Math.min(scrollPosition.x, xMax));\n  scrollPosition.y = Math.max(0, Math.min(scrollPosition.y, yMax));\n\n  return scrollPosition;\n}\n\nmodule.exports = getScrollPosition;\n\n/***/ }),\n/* 166 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule findAncestorOffsetKey\n * @format\n * \n */\n\n\n\nvar getSelectionOffsetKeyForNode = __webpack_require__(231);\n\n/**\n * Get the key from the node's nearest offset-aware ancestor.\n */\nfunction findAncestorOffsetKey(node) {\n  var searchNode = node;\n  while (searchNode && searchNode !== document.documentElement) {\n    var key = getSelectionOffsetKeyForNode(searchNode);\n    if (key != null) {\n      return key;\n    }\n    searchNode = searchNode.parentNode;\n  }\n  return null;\n}\n\nmodule.exports = findAncestorOffsetKey;\n\n/***/ }),\n/* 167 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule KeyBindingUtil\n * @format\n * \n */\n\n\n\nvar UserAgent = __webpack_require__(67);\n\nvar isOSX = UserAgent.isPlatform('Mac OS X');\n\nvar KeyBindingUtil = {\n  /**\n   * Check whether the ctrlKey modifier is *not* being used in conjunction with\n   * the altKey modifier. If they are combined, the result is an `altGraph`\n   * key modifier, which should not be handled by this set of key bindings.\n   */\n  isCtrlKeyCommand: function isCtrlKeyCommand(e) {\n    return !!e.ctrlKey && !e.altKey;\n  },\n\n  isOptionKeyCommand: function isOptionKeyCommand(e) {\n    return isOSX && e.altKey;\n  },\n\n  hasCommandModifier: function hasCommandModifier(e) {\n    return isOSX ? !!e.metaKey && !e.altKey : KeyBindingUtil.isCtrlKeyCommand(e);\n  }\n};\n\nmodule.exports = KeyBindingUtil;\n\n/***/ }),\n/* 168 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule moveSelectionBackward\n * @format\n * \n */\n\n\n\n/**\n * Given a collapsed selection, move the focus `maxDistance` backward within\n * the selected block. If the selection will go beyond the start of the block,\n * move focus to the end of the previous block, but no further.\n *\n * This function is not Unicode-aware, so surrogate pairs will be treated\n * as having length 2.\n */\nfunction moveSelectionBackward(editorState, maxDistance) {\n  var selection = editorState.getSelection();\n  var content = editorState.getCurrentContent();\n  var key = selection.getStartKey();\n  var offset = selection.getStartOffset();\n\n  var focusKey = key;\n  var focusOffset = 0;\n\n  if (maxDistance > offset) {\n    var keyBefore = content.getKeyBefore(key);\n    if (keyBefore == null) {\n      focusKey = key;\n    } else {\n      focusKey = keyBefore;\n      var blockBefore = content.getBlockForKey(keyBefore);\n      focusOffset = blockBefore.getText().length;\n    }\n  } else {\n    focusOffset = offset - maxDistance;\n  }\n\n  return selection.merge({\n    focusKey: focusKey,\n    focusOffset: focusOffset,\n    isBackward: true\n  });\n}\n\nmodule.exports = moveSelectionBackward;\n\n/***/ }),\n/* 169 */,\n/* 170 */,\n/* 171 */,\n/* 172 */,\n/* 173 */,\n/* 174 */,\n/* 175 */,\n/* 176 */,\n/* 177 */,\n/* 178 */,\n/* 179 */,\n/* 180 */,\n/* 181 */,\n/* 182 */,\n/* 183 */,\n/* 184 */,\n/* 185 */,\n/* 186 */,\n/* 187 */,\n/* 188 */,\n/* 189 */,\n/* 190 */,\n/* 191 */,\n/* 192 */,\n/* 193 */,\n/* 194 */,\n/* 195 */,\n/* 196 */,\n/* 197 */,\n/* 198 */,\n/* 199 */,\n/* 200 */,\n/* 201 */,\n/* 202 */,\n/* 203 */,\n/* 204 */,\n/* 205 */,\n/* 206 */,\n/* 207 */,\n/* 208 */,\n/* 209 */,\n/* 210 */,\n/* 211 */,\n/* 212 */,\n/* 213 */,\n/* 214 */,\n/* 215 */,\n/* 216 */,\n/* 217 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule Draft\n * @format\n * \n */\n\n\n\nvar AtomicBlockUtils = __webpack_require__(422);\nvar BlockMapBuilder = __webpack_require__(91);\nvar CharacterMetadata = __webpack_require__(63);\nvar CompositeDraftDecorator = __webpack_require__(438);\nvar ContentBlock = __webpack_require__(76);\nvar ContentState = __webpack_require__(157);\nvar DefaultDraftBlockRenderMap = __webpack_require__(160);\nvar DefaultDraftInlineStyle = __webpack_require__(225);\nvar DraftEditor = __webpack_require__(439);\nvar DraftEditorBlock = __webpack_require__(227);\nvar DraftEntity = __webpack_require__(115);\nvar DraftModifier = __webpack_require__(62);\nvar DraftEntityInstance = __webpack_require__(223);\nvar EditorState = __webpack_require__(59);\nvar KeyBindingUtil = __webpack_require__(167);\nvar RichTextEditorUtil = __webpack_require__(241);\nvar SelectionState = __webpack_require__(83);\n\nvar convertFromDraftStateToRaw = __webpack_require__(501);\nvar convertFromHTMLToContentBlocks = __webpack_require__(239);\nvar convertFromRawToDraftState = __webpack_require__(504);\nvar generateRandomKey = __webpack_require__(70);\nvar getDefaultKeyBinding = __webpack_require__(242);\nvar getVisibleSelectionRect = __webpack_require__(509);\n\nvar DraftPublic = {\n  Editor: DraftEditor,\n  EditorBlock: DraftEditorBlock,\n  EditorState: EditorState,\n\n  CompositeDecorator: CompositeDraftDecorator,\n  Entity: DraftEntity,\n  EntityInstance: DraftEntityInstance,\n\n  BlockMapBuilder: BlockMapBuilder,\n  CharacterMetadata: CharacterMetadata,\n  ContentBlock: ContentBlock,\n  ContentState: ContentState,\n  SelectionState: SelectionState,\n\n  AtomicBlockUtils: AtomicBlockUtils,\n  KeyBindingUtil: KeyBindingUtil,\n  Modifier: DraftModifier,\n  RichUtils: RichTextEditorUtil,\n\n  DefaultDraftBlockRenderMap: DefaultDraftBlockRenderMap,\n  DefaultDraftInlineStyle: DefaultDraftInlineStyle,\n\n  convertFromHTML: convertFromHTMLToContentBlocks,\n  convertFromRaw: convertFromRawToDraftState,\n  convertToRaw: convertFromDraftStateToRaw,\n  genKey: generateRandomKey,\n  getDefaultKeyBinding: getDefaultKeyBinding,\n  getVisibleSelectionRect: getVisibleSelectionRect\n};\n\nmodule.exports = DraftPublic;\n\n/***/ }),\n/* 218 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule randomizeBlockMapKeys\n * @format\n * \n */\n\n\n\nvar ContentBlockNode = __webpack_require__(64);\nvar Immutable = __webpack_require__(57);\n\nvar generateRandomKey = __webpack_require__(70);\n\nvar OrderedMap = Immutable.OrderedMap;\n\n\nvar randomizeContentBlockNodeKeys = function randomizeContentBlockNodeKeys(blockMap) {\n  var newKeysRef = {};\n\n  // we keep track of root blocks in order to update subsequent sibling links\n  var lastRootBlock = void 0;\n\n  return OrderedMap(blockMap.withMutations(function (blockMapState) {\n    blockMapState.forEach(function (block, index) {\n      var oldKey = block.getKey();\n      var nextKey = block.getNextSiblingKey();\n      var prevKey = block.getPrevSiblingKey();\n      var childrenKeys = block.getChildKeys();\n      var parentKey = block.getParentKey();\n\n      // new key that we will use to build linking\n      var key = generateRandomKey();\n\n      // we will add it here to re-use it later\n      newKeysRef[oldKey] = key;\n\n      if (nextKey) {\n        var nextBlock = blockMapState.get(nextKey);\n        if (nextBlock) {\n          blockMapState.setIn([nextKey, 'prevSibling'], key);\n        } else {\n          // this can happen when generating random keys for fragments\n          blockMapState.setIn([oldKey, 'nextSibling'], null);\n        }\n      }\n\n      if (prevKey) {\n        var prevBlock = blockMapState.get(prevKey);\n        if (prevBlock) {\n          blockMapState.setIn([prevKey, 'nextSibling'], key);\n        } else {\n          // this can happen when generating random keys for fragments\n          blockMapState.setIn([oldKey, 'prevSibling'], null);\n        }\n      }\n\n      if (parentKey && blockMapState.get(parentKey)) {\n        var parentBlock = blockMapState.get(parentKey);\n        var parentChildrenList = parentBlock.getChildKeys();\n        blockMapState.setIn([parentKey, 'children'], parentChildrenList.set(parentChildrenList.indexOf(block.getKey()), key));\n      } else {\n        // blocks will then be treated as root block nodes\n        blockMapState.setIn([oldKey, 'parent'], null);\n\n        if (lastRootBlock) {\n          blockMapState.setIn([lastRootBlock.getKey(), 'nextSibling'], key);\n          blockMapState.setIn([oldKey, 'prevSibling'], newKeysRef[lastRootBlock.getKey()]);\n        }\n\n        lastRootBlock = blockMapState.get(oldKey);\n      }\n\n      childrenKeys.forEach(function (childKey) {\n        var childBlock = blockMapState.get(childKey);\n        if (childBlock) {\n          blockMapState.setIn([childKey, 'parent'], key);\n        } else {\n          blockMapState.setIn([oldKey, 'children'], block.getChildKeys().filter(function (child) {\n            return child !== childKey;\n          }));\n        }\n      });\n    });\n  }).toArray().map(function (block) {\n    return [newKeysRef[block.getKey()], block.set('key', newKeysRef[block.getKey()])];\n  }));\n};\n\nvar randomizeContentBlockKeys = function randomizeContentBlockKeys(blockMap) {\n  return OrderedMap(blockMap.toArray().map(function (block) {\n    var key = generateRandomKey();\n    return [key, block.set('key', key)];\n  }));\n};\n\nvar randomizeBlockMapKeys = function randomizeBlockMapKeys(blockMap) {\n  var isTreeBasedBlockMap = blockMap.first() instanceof ContentBlockNode;\n\n  if (!isTreeBasedBlockMap) {\n    return randomizeContentBlockKeys(blockMap);\n  }\n\n  return randomizeContentBlockNodeKeys(blockMap);\n};\n\nmodule.exports = randomizeBlockMapKeys;\n\n/***/ }),\n/* 219 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule removeEntitiesAtEdges\n * @format\n * \n */\n\n\n\nvar CharacterMetadata = __webpack_require__(63);\n\nvar findRangesImmutable = __webpack_require__(92);\nvar invariant = __webpack_require__(58);\n\nfunction removeEntitiesAtEdges(contentState, selectionState) {\n  var blockMap = contentState.getBlockMap();\n  var entityMap = contentState.getEntityMap();\n\n  var updatedBlocks = {};\n\n  var startKey = selectionState.getStartKey();\n  var startOffset = selectionState.getStartOffset();\n  var startBlock = blockMap.get(startKey);\n  var updatedStart = removeForBlock(entityMap, startBlock, startOffset);\n\n  if (updatedStart !== startBlock) {\n    updatedBlocks[startKey] = updatedStart;\n  }\n\n  var endKey = selectionState.getEndKey();\n  var endOffset = selectionState.getEndOffset();\n  var endBlock = blockMap.get(endKey);\n  if (startKey === endKey) {\n    endBlock = updatedStart;\n  }\n\n  var updatedEnd = removeForBlock(entityMap, endBlock, endOffset);\n\n  if (updatedEnd !== endBlock) {\n    updatedBlocks[endKey] = updatedEnd;\n  }\n\n  if (!Object.keys(updatedBlocks).length) {\n    return contentState.set('selectionAfter', selectionState);\n  }\n\n  return contentState.merge({\n    blockMap: blockMap.merge(updatedBlocks),\n    selectionAfter: selectionState\n  });\n}\n\nfunction getRemovalRange(characters, key, offset) {\n  var removalRange;\n  findRangesImmutable(characters, function (a, b) {\n    return a.getEntity() === b.getEntity();\n  }, function (element) {\n    return element.getEntity() === key;\n  }, function (start, end) {\n    if (start <= offset && end >= offset) {\n      removalRange = { start: start, end: end };\n    }\n  });\n  !(typeof removalRange === 'object') ?  false ? invariant(false, 'Removal range must exist within character list.') : invariant(false) : void 0;\n  return removalRange;\n}\n\nfunction removeForBlock(entityMap, block, offset) {\n  var chars = block.getCharacterList();\n  var charBefore = offset > 0 ? chars.get(offset - 1) : undefined;\n  var charAfter = offset < chars.count() ? chars.get(offset) : undefined;\n  var entityBeforeCursor = charBefore ? charBefore.getEntity() : undefined;\n  var entityAfterCursor = charAfter ? charAfter.getEntity() : undefined;\n\n  if (entityAfterCursor && entityAfterCursor === entityBeforeCursor) {\n    var entity = entityMap.__get(entityAfterCursor);\n    if (entity.getMutability() !== 'MUTABLE') {\n      var _getRemovalRange = getRemovalRange(chars, entityAfterCursor, offset),\n          start = _getRemovalRange.start,\n          end = _getRemovalRange.end;\n\n      var current;\n      while (start < end) {\n        current = chars.get(start);\n        chars = chars.set(start, CharacterMetadata.applyEntity(current, null));\n        start++;\n      }\n      return block.set('characterList', chars);\n    }\n  }\n\n  return block;\n}\n\nmodule.exports = removeEntitiesAtEdges;\n\n/***/ }),\n/* 220 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule insertIntoList\n * @format\n * \n */\n\n\n\n/**\n * Maintain persistence for target list when appending and prepending.\n */\nfunction insertIntoList(targetList, toInsert, offset) {\n  if (offset === targetList.count()) {\n    toInsert.forEach(function (c) {\n      targetList = targetList.push(c);\n    });\n  } else if (offset === 0) {\n    toInsert.reverse().forEach(function (c) {\n      targetList = targetList.unshift(c);\n    });\n  } else {\n    var head = targetList.slice(0, offset);\n    var tail = targetList.slice(offset);\n    targetList = head.concat(toInsert, tail).toList();\n  }\n  return targetList;\n}\n\nmodule.exports = insertIntoList;\n\n/***/ }),\n/* 221 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getNextDelimiterBlockKey\n * @format\n * \n *\n * This is unstable and not part of the public API and should not be used by\n * production systems. This file may be update/removed without notice.\n */\n\nvar ContentBlockNode = __webpack_require__(64);\n\nvar getNextDelimiterBlockKey = function getNextDelimiterBlockKey(block, blockMap) {\n  var isExperimentalTreeBlock = block instanceof ContentBlockNode;\n\n  if (!isExperimentalTreeBlock) {\n    return null;\n  }\n\n  var nextSiblingKey = block.getNextSiblingKey();\n\n  if (nextSiblingKey) {\n    return nextSiblingKey;\n  }\n\n  var parent = block.getParentKey();\n\n  if (!parent) {\n    return null;\n  }\n\n  var nextNonDescendantBlock = blockMap.get(parent);\n  while (nextNonDescendantBlock && !nextNonDescendantBlock.getNextSiblingKey()) {\n    var parentKey = nextNonDescendantBlock.getParentKey();\n    nextNonDescendantBlock = parentKey ? blockMap.get(parentKey) : null;\n  }\n\n  if (!nextNonDescendantBlock) {\n    return null;\n  }\n\n  return nextNonDescendantBlock.getNextSiblingKey();\n};\n\nmodule.exports = getNextDelimiterBlockKey;\n\n/***/ }),\n/* 222 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule BlockTree\n * @format\n * \n */\n\n\n\nvar Immutable = __webpack_require__(57);\n\nvar emptyFunction = __webpack_require__(156);\nvar findRangesImmutable = __webpack_require__(92);\n\nvar List = Immutable.List,\n    Repeat = Immutable.Repeat,\n    Record = Immutable.Record;\n\n\nvar returnTrue = emptyFunction.thatReturnsTrue;\n\nvar FINGERPRINT_DELIMITER = '-';\n\nvar defaultLeafRange = {\n  start: null,\n  end: null\n};\n\nvar LeafRange = Record(defaultLeafRange);\n\nvar defaultDecoratorRange = {\n  start: null,\n  end: null,\n  decoratorKey: null,\n  leaves: null\n};\n\nvar DecoratorRange = Record(defaultDecoratorRange);\n\nvar BlockTree = {\n  /**\n   * Generate a block tree for a given ContentBlock/decorator pair.\n   */\n  generate: function generate(contentState, block, decorator) {\n    var textLength = block.getLength();\n    if (!textLength) {\n      return List.of(new DecoratorRange({\n        start: 0,\n        end: 0,\n        decoratorKey: null,\n        leaves: List.of(new LeafRange({ start: 0, end: 0 }))\n      }));\n    }\n\n    var leafSets = [];\n    var decorations = decorator ? decorator.getDecorations(block, contentState) : List(Repeat(null, textLength));\n\n    var chars = block.getCharacterList();\n\n    findRangesImmutable(decorations, areEqual, returnTrue, function (start, end) {\n      leafSets.push(new DecoratorRange({\n        start: start,\n        end: end,\n        decoratorKey: decorations.get(start),\n        leaves: generateLeaves(chars.slice(start, end).toList(), start)\n      }));\n    });\n\n    return List(leafSets);\n  },\n\n  /**\n   * Create a string representation of the given tree map. This allows us\n   * to rapidly determine whether a tree has undergone a significant\n   * structural change.\n   */\n  getFingerprint: function getFingerprint(tree) {\n    return tree.map(function (leafSet) {\n      var decoratorKey = leafSet.get('decoratorKey');\n      var fingerprintString = decoratorKey !== null ? decoratorKey + '.' + (leafSet.get('end') - leafSet.get('start')) : '';\n      return '' + fingerprintString + '.' + leafSet.get('leaves').size;\n    }).join(FINGERPRINT_DELIMITER);\n  }\n};\n\n/**\n * Generate LeafRange records for a given character list.\n */\nfunction generateLeaves(characters, offset) {\n  var leaves = [];\n  var inlineStyles = characters.map(function (c) {\n    return c.getStyle();\n  }).toList();\n  findRangesImmutable(inlineStyles, areEqual, returnTrue, function (start, end) {\n    leaves.push(new LeafRange({\n      start: start + offset,\n      end: end + offset\n    }));\n  });\n  return List(leaves);\n}\n\nfunction areEqual(a, b) {\n  return a === b;\n}\n\nmodule.exports = BlockTree;\n\n/***/ }),\n/* 223 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEntityInstance\n * @legacyServerCallableInstance\n * @format\n * \n */\n\n\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar Immutable = __webpack_require__(57);\n\nvar Record = Immutable.Record;\n\n\nvar DraftEntityInstanceRecord = Record({\n  type: 'TOKEN',\n  mutability: 'IMMUTABLE',\n  data: Object\n});\n\n/**\n * An instance of a document entity, consisting of a `type` and relevant\n * `data`, metadata about the entity.\n *\n * For instance, a \"link\" entity might provide a URI, and a \"mention\"\n * entity might provide the mentioned user's ID. These pieces of data\n * may be used when rendering the entity as part of a ContentBlock DOM\n * representation. For a link, the data would be used as an href for\n * the rendered anchor. For a mention, the ID could be used to retrieve\n * a hovercard.\n */\n\nvar DraftEntityInstance = function (_DraftEntityInstanceR) {\n  _inherits(DraftEntityInstance, _DraftEntityInstanceR);\n\n  function DraftEntityInstance() {\n    _classCallCheck(this, DraftEntityInstance);\n\n    return _possibleConstructorReturn(this, _DraftEntityInstanceR.apply(this, arguments));\n  }\n\n  DraftEntityInstance.prototype.getType = function getType() {\n    return this.get('type');\n  };\n\n  DraftEntityInstance.prototype.getMutability = function getMutability() {\n    return this.get('mutability');\n  };\n\n  DraftEntityInstance.prototype.getData = function getData() {\n    return this.get('data');\n  };\n\n  return DraftEntityInstance;\n}(DraftEntityInstanceRecord);\n\nmodule.exports = DraftEntityInstance;\n\n/***/ }),\n/* 224 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n * \n */\n\n/**\n * Basic (stateless) API for text direction detection\n *\n * Part of our implementation of Unicode Bidirectional Algorithm (UBA)\n * Unicode Standard Annex #9 (UAX9)\n * http://www.unicode.org/reports/tr9/\n */\n\n\n\nvar UnicodeBidiDirection = __webpack_require__(159);\n\nvar invariant = __webpack_require__(58);\n\n/**\n * RegExp ranges of characters with a *Strong* Bidi_Class value.\n *\n * Data is based on DerivedBidiClass.txt in UCD version 7.0.0.\n *\n * NOTE: For performance reasons, we only support Unicode's\n *       Basic Multilingual Plane (BMP) for now.\n */\nvar RANGE_BY_BIDI_TYPE = {\n\n  L: 'A-Za-z\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u01BA\\u01BB' + '\\u01BC-\\u01BF\\u01C0-\\u01C3\\u01C4-\\u0293\\u0294\\u0295-\\u02AF\\u02B0-\\u02B8' + '\\u02BB-\\u02C1\\u02D0-\\u02D1\\u02E0-\\u02E4\\u02EE\\u0370-\\u0373\\u0376-\\u0377' + '\\u037A\\u037B-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1' + '\\u03A3-\\u03F5\\u03F7-\\u0481\\u0482\\u048A-\\u052F\\u0531-\\u0556\\u0559' + '\\u055A-\\u055F\\u0561-\\u0587\\u0589\\u0903\\u0904-\\u0939\\u093B\\u093D' + '\\u093E-\\u0940\\u0949-\\u094C\\u094E-\\u094F\\u0950\\u0958-\\u0961\\u0964-\\u0965' + '\\u0966-\\u096F\\u0970\\u0971\\u0972-\\u0980\\u0982-\\u0983\\u0985-\\u098C' + '\\u098F-\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD' + '\\u09BE-\\u09C0\\u09C7-\\u09C8\\u09CB-\\u09CC\\u09CE\\u09D7\\u09DC-\\u09DD' + '\\u09DF-\\u09E1\\u09E6-\\u09EF\\u09F0-\\u09F1\\u09F4-\\u09F9\\u09FA\\u0A03' + '\\u0A05-\\u0A0A\\u0A0F-\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32-\\u0A33' + '\\u0A35-\\u0A36\\u0A38-\\u0A39\\u0A3E-\\u0A40\\u0A59-\\u0A5C\\u0A5E\\u0A66-\\u0A6F' + '\\u0A72-\\u0A74\\u0A83\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0' + '\\u0AB2-\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0ABE-\\u0AC0\\u0AC9\\u0ACB-\\u0ACC\\u0AD0' + '\\u0AE0-\\u0AE1\\u0AE6-\\u0AEF\\u0AF0\\u0B02-\\u0B03\\u0B05-\\u0B0C\\u0B0F-\\u0B10' + '\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32-\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B3E\\u0B40' + '\\u0B47-\\u0B48\\u0B4B-\\u0B4C\\u0B57\\u0B5C-\\u0B5D\\u0B5F-\\u0B61\\u0B66-\\u0B6F' + '\\u0B70\\u0B71\\u0B72-\\u0B77\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95' + '\\u0B99-\\u0B9A\\u0B9C\\u0B9E-\\u0B9F\\u0BA3-\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9' + '\\u0BBE-\\u0BBF\\u0BC1-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCC\\u0BD0\\u0BD7' + '\\u0BE6-\\u0BEF\\u0BF0-\\u0BF2\\u0C01-\\u0C03\\u0C05-\\u0C0C\\u0C0E-\\u0C10' + '\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C41-\\u0C44\\u0C58-\\u0C59\\u0C60-\\u0C61' + '\\u0C66-\\u0C6F\\u0C7F\\u0C82-\\u0C83\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8' + '\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CBE\\u0CBF\\u0CC0-\\u0CC4\\u0CC6' + '\\u0CC7-\\u0CC8\\u0CCA-\\u0CCB\\u0CD5-\\u0CD6\\u0CDE\\u0CE0-\\u0CE1\\u0CE6-\\u0CEF' + '\\u0CF1-\\u0CF2\\u0D02-\\u0D03\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D' + '\\u0D3E-\\u0D40\\u0D46-\\u0D48\\u0D4A-\\u0D4C\\u0D4E\\u0D57\\u0D60-\\u0D61' + '\\u0D66-\\u0D6F\\u0D70-\\u0D75\\u0D79\\u0D7A-\\u0D7F\\u0D82-\\u0D83\\u0D85-\\u0D96' + '\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0DCF-\\u0DD1\\u0DD8-\\u0DDF' + '\\u0DE6-\\u0DEF\\u0DF2-\\u0DF3\\u0DF4\\u0E01-\\u0E30\\u0E32-\\u0E33\\u0E40-\\u0E45' + '\\u0E46\\u0E4F\\u0E50-\\u0E59\\u0E5A-\\u0E5B\\u0E81-\\u0E82\\u0E84\\u0E87-\\u0E88' + '\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7' + '\\u0EAA-\\u0EAB\\u0EAD-\\u0EB0\\u0EB2-\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6' + '\\u0ED0-\\u0ED9\\u0EDC-\\u0EDF\\u0F00\\u0F01-\\u0F03\\u0F04-\\u0F12\\u0F13\\u0F14' + '\\u0F15-\\u0F17\\u0F1A-\\u0F1F\\u0F20-\\u0F29\\u0F2A-\\u0F33\\u0F34\\u0F36\\u0F38' + '\\u0F3E-\\u0F3F\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F7F\\u0F85\\u0F88-\\u0F8C' + '\\u0FBE-\\u0FC5\\u0FC7-\\u0FCC\\u0FCE-\\u0FCF\\u0FD0-\\u0FD4\\u0FD5-\\u0FD8' + '\\u0FD9-\\u0FDA\\u1000-\\u102A\\u102B-\\u102C\\u1031\\u1038\\u103B-\\u103C\\u103F' + '\\u1040-\\u1049\\u104A-\\u104F\\u1050-\\u1055\\u1056-\\u1057\\u105A-\\u105D\\u1061' + '\\u1062-\\u1064\\u1065-\\u1066\\u1067-\\u106D\\u106E-\\u1070\\u1075-\\u1081' + '\\u1083-\\u1084\\u1087-\\u108C\\u108E\\u108F\\u1090-\\u1099\\u109A-\\u109C' + '\\u109E-\\u109F\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FB\\u10FC' + '\\u10FD-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288' + '\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5' + '\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1360-\\u1368' + '\\u1369-\\u137C\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166D-\\u166E' + '\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EB-\\u16ED\\u16EE-\\u16F0' + '\\u16F1-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1735-\\u1736' + '\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17B6\\u17BE-\\u17C5' + '\\u17C7-\\u17C8\\u17D4-\\u17D6\\u17D7\\u17D8-\\u17DA\\u17DC\\u17E0-\\u17E9' + '\\u1810-\\u1819\\u1820-\\u1842\\u1843\\u1844-\\u1877\\u1880-\\u18A8\\u18AA' + '\\u18B0-\\u18F5\\u1900-\\u191E\\u1923-\\u1926\\u1929-\\u192B\\u1930-\\u1931' + '\\u1933-\\u1938\\u1946-\\u194F\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB' + '\\u19B0-\\u19C0\\u19C1-\\u19C7\\u19C8-\\u19C9\\u19D0-\\u19D9\\u19DA\\u1A00-\\u1A16' + '\\u1A19-\\u1A1A\\u1A1E-\\u1A1F\\u1A20-\\u1A54\\u1A55\\u1A57\\u1A61\\u1A63-\\u1A64' + '\\u1A6D-\\u1A72\\u1A80-\\u1A89\\u1A90-\\u1A99\\u1AA0-\\u1AA6\\u1AA7\\u1AA8-\\u1AAD' + '\\u1B04\\u1B05-\\u1B33\\u1B35\\u1B3B\\u1B3D-\\u1B41\\u1B43-\\u1B44\\u1B45-\\u1B4B' + '\\u1B50-\\u1B59\\u1B5A-\\u1B60\\u1B61-\\u1B6A\\u1B74-\\u1B7C\\u1B82\\u1B83-\\u1BA0' + '\\u1BA1\\u1BA6-\\u1BA7\\u1BAA\\u1BAE-\\u1BAF\\u1BB0-\\u1BB9\\u1BBA-\\u1BE5\\u1BE7' + '\\u1BEA-\\u1BEC\\u1BEE\\u1BF2-\\u1BF3\\u1BFC-\\u1BFF\\u1C00-\\u1C23\\u1C24-\\u1C2B' + '\\u1C34-\\u1C35\\u1C3B-\\u1C3F\\u1C40-\\u1C49\\u1C4D-\\u1C4F\\u1C50-\\u1C59' + '\\u1C5A-\\u1C77\\u1C78-\\u1C7D\\u1C7E-\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u1CE1' + '\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF2-\\u1CF3\\u1CF5-\\u1CF6\\u1D00-\\u1D2B' + '\\u1D2C-\\u1D6A\\u1D6B-\\u1D77\\u1D78\\u1D79-\\u1D9A\\u1D9B-\\u1DBF\\u1E00-\\u1F15' + '\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D' + '\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC' + '\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u200E' + '\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D' + '\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2134\\u2135-\\u2138\\u2139' + '\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u214F\\u2160-\\u2182\\u2183-\\u2184' + '\\u2185-\\u2188\\u2336-\\u237A\\u2395\\u249C-\\u24E9\\u26AC\\u2800-\\u28FF' + '\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2C7B\\u2C7C-\\u2C7D\\u2C7E-\\u2CE4' + '\\u2CEB-\\u2CEE\\u2CF2-\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F' + '\\u2D70\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE' + '\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u3005\\u3006\\u3007' + '\\u3021-\\u3029\\u302E-\\u302F\\u3031-\\u3035\\u3038-\\u303A\\u303B\\u303C' + '\\u3041-\\u3096\\u309D-\\u309E\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FE\\u30FF' + '\\u3105-\\u312D\\u3131-\\u318E\\u3190-\\u3191\\u3192-\\u3195\\u3196-\\u319F' + '\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3200-\\u321C\\u3220-\\u3229\\u322A-\\u3247' + '\\u3248-\\u324F\\u3260-\\u327B\\u327F\\u3280-\\u3289\\u328A-\\u32B0\\u32C0-\\u32CB' + '\\u32D0-\\u32FE\\u3300-\\u3376\\u337B-\\u33DD\\u33E0-\\u33FE\\u3400-\\u4DB5' + '\\u4E00-\\u9FCC\\uA000-\\uA014\\uA015\\uA016-\\uA48C\\uA4D0-\\uA4F7\\uA4F8-\\uA4FD' + '\\uA4FE-\\uA4FF\\uA500-\\uA60B\\uA60C\\uA610-\\uA61F\\uA620-\\uA629\\uA62A-\\uA62B' + '\\uA640-\\uA66D\\uA66E\\uA680-\\uA69B\\uA69C-\\uA69D\\uA6A0-\\uA6E5\\uA6E6-\\uA6EF' + '\\uA6F2-\\uA6F7\\uA722-\\uA76F\\uA770\\uA771-\\uA787\\uA789-\\uA78A\\uA78B-\\uA78E' + '\\uA790-\\uA7AD\\uA7B0-\\uA7B1\\uA7F7\\uA7F8-\\uA7F9\\uA7FA\\uA7FB-\\uA801' + '\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA823-\\uA824\\uA827\\uA830-\\uA835' + '\\uA836-\\uA837\\uA840-\\uA873\\uA880-\\uA881\\uA882-\\uA8B3\\uA8B4-\\uA8C3' + '\\uA8CE-\\uA8CF\\uA8D0-\\uA8D9\\uA8F2-\\uA8F7\\uA8F8-\\uA8FA\\uA8FB\\uA900-\\uA909' + '\\uA90A-\\uA925\\uA92E-\\uA92F\\uA930-\\uA946\\uA952-\\uA953\\uA95F\\uA960-\\uA97C' + '\\uA983\\uA984-\\uA9B2\\uA9B4-\\uA9B5\\uA9BA-\\uA9BB\\uA9BD-\\uA9C0\\uA9C1-\\uA9CD' + '\\uA9CF\\uA9D0-\\uA9D9\\uA9DE-\\uA9DF\\uA9E0-\\uA9E4\\uA9E6\\uA9E7-\\uA9EF' + '\\uA9F0-\\uA9F9\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA2F-\\uAA30\\uAA33-\\uAA34' + '\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA4D\\uAA50-\\uAA59\\uAA5C-\\uAA5F\\uAA60-\\uAA6F' + '\\uAA70\\uAA71-\\uAA76\\uAA77-\\uAA79\\uAA7A\\uAA7B\\uAA7D\\uAA7E-\\uAAAF\\uAAB1' + '\\uAAB5-\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADC\\uAADD\\uAADE-\\uAADF' + '\\uAAE0-\\uAAEA\\uAAEB\\uAAEE-\\uAAEF\\uAAF0-\\uAAF1\\uAAF2\\uAAF3-\\uAAF4\\uAAF5' + '\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E' + '\\uAB30-\\uAB5A\\uAB5B\\uAB5C-\\uAB5F\\uAB64-\\uAB65\\uABC0-\\uABE2\\uABE3-\\uABE4' + '\\uABE6-\\uABE7\\uABE9-\\uABEA\\uABEB\\uABEC\\uABF0-\\uABF9\\uAC00-\\uD7A3' + '\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uE000-\\uF8FF\\uF900-\\uFA6D\\uFA70-\\uFAD9' + '\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFF6F\\uFF70' + '\\uFF71-\\uFF9D\\uFF9E-\\uFF9F\\uFFA0-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF' + '\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC',\n\n  R: '\\u0590\\u05BE\\u05C0\\u05C3\\u05C6\\u05C8-\\u05CF\\u05D0-\\u05EA\\u05EB-\\u05EF' + '\\u05F0-\\u05F2\\u05F3-\\u05F4\\u05F5-\\u05FF\\u07C0-\\u07C9\\u07CA-\\u07EA' + '\\u07F4-\\u07F5\\u07FA\\u07FB-\\u07FF\\u0800-\\u0815\\u081A\\u0824\\u0828' + '\\u082E-\\u082F\\u0830-\\u083E\\u083F\\u0840-\\u0858\\u085C-\\u085D\\u085E' + '\\u085F-\\u089F\\u200F\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB37\\uFB38-\\uFB3C' + '\\uFB3D\\uFB3E\\uFB3F\\uFB40-\\uFB41\\uFB42\\uFB43-\\uFB44\\uFB45\\uFB46-\\uFB4F',\n\n  AL: '\\u0608\\u060B\\u060D\\u061B\\u061C\\u061D\\u061E-\\u061F\\u0620-\\u063F\\u0640' + '\\u0641-\\u064A\\u066D\\u066E-\\u066F\\u0671-\\u06D3\\u06D4\\u06D5\\u06E5-\\u06E6' + '\\u06EE-\\u06EF\\u06FA-\\u06FC\\u06FD-\\u06FE\\u06FF\\u0700-\\u070D\\u070E\\u070F' + '\\u0710\\u0712-\\u072F\\u074B-\\u074C\\u074D-\\u07A5\\u07B1\\u07B2-\\u07BF' + '\\u08A0-\\u08B2\\u08B3-\\u08E3\\uFB50-\\uFBB1\\uFBB2-\\uFBC1\\uFBC2-\\uFBD2' + '\\uFBD3-\\uFD3D\\uFD40-\\uFD4F\\uFD50-\\uFD8F\\uFD90-\\uFD91\\uFD92-\\uFDC7' + '\\uFDC8-\\uFDCF\\uFDF0-\\uFDFB\\uFDFC\\uFDFE-\\uFDFF\\uFE70-\\uFE74\\uFE75' + '\\uFE76-\\uFEFC\\uFEFD-\\uFEFE'\n\n};\n\nvar REGEX_STRONG = new RegExp('[' + RANGE_BY_BIDI_TYPE.L + RANGE_BY_BIDI_TYPE.R + RANGE_BY_BIDI_TYPE.AL + ']');\n\nvar REGEX_RTL = new RegExp('[' + RANGE_BY_BIDI_TYPE.R + RANGE_BY_BIDI_TYPE.AL + ']');\n\n/**\n * Returns the first strong character (has Bidi_Class value of L, R, or AL).\n *\n * @param str  A text block; e.g. paragraph, table cell, tag\n * @return     A character with strong bidi direction, or null if not found\n */\nfunction firstStrongChar(str) {\n  var match = REGEX_STRONG.exec(str);\n  return match == null ? null : match[0];\n}\n\n/**\n * Returns the direction of a block of text, based on the direction of its\n * first strong character (has Bidi_Class value of L, R, or AL).\n *\n * @param str  A text block; e.g. paragraph, table cell, tag\n * @return     The resolved direction\n */\nfunction firstStrongCharDir(str) {\n  var strongChar = firstStrongChar(str);\n  if (strongChar == null) {\n    return UnicodeBidiDirection.NEUTRAL;\n  }\n  return REGEX_RTL.exec(strongChar) ? UnicodeBidiDirection.RTL : UnicodeBidiDirection.LTR;\n}\n\n/**\n * Returns the direction of a block of text, based on the direction of its\n * first strong character (has Bidi_Class value of L, R, or AL), or a fallback\n * direction, if no strong character is found.\n *\n * This function is supposed to be used in respect to Higher-Level Protocol\n * rule HL1. (http://www.unicode.org/reports/tr9/#HL1)\n *\n * @param str       A text block; e.g. paragraph, table cell, tag\n * @param fallback  Fallback direction, used if no strong direction detected\n *                  for the block (default = NEUTRAL)\n * @return          The resolved direction\n */\nfunction resolveBlockDir(str, fallback) {\n  fallback = fallback || UnicodeBidiDirection.NEUTRAL;\n  if (!str.length) {\n    return fallback;\n  }\n  var blockDir = firstStrongCharDir(str);\n  return blockDir === UnicodeBidiDirection.NEUTRAL ? fallback : blockDir;\n}\n\n/**\n * Returns the direction of a block of text, based on the direction of its\n * first strong character (has Bidi_Class value of L, R, or AL), or a fallback\n * direction, if no strong character is found.\n *\n * NOTE: This function is similar to resolveBlockDir(), but uses the global\n * direction as the fallback, so it *always* returns a Strong direction,\n * making it useful for integration in places that you need to make the final\n * decision, like setting some CSS class.\n *\n * This function is supposed to be used in respect to Higher-Level Protocol\n * rule HL1. (http://www.unicode.org/reports/tr9/#HL1)\n *\n * @param str             A text block; e.g. paragraph, table cell\n * @param strongFallback  Fallback direction, used if no strong direction\n *                        detected for the block (default = global direction)\n * @return                The resolved Strong direction\n */\nfunction getDirection(str, strongFallback) {\n  if (!strongFallback) {\n    strongFallback = UnicodeBidiDirection.getGlobalDir();\n  }\n  !UnicodeBidiDirection.isStrong(strongFallback) ?  false ? invariant(false, 'Fallback direction must be a strong direction') : invariant(false) : void 0;\n  return resolveBlockDir(str, strongFallback);\n}\n\n/**\n * Returns true if getDirection(arguments...) returns LTR.\n *\n * @param str             A text block; e.g. paragraph, table cell\n * @param strongFallback  Fallback direction, used if no strong direction\n *                        detected for the block (default = global direction)\n * @return                True if the resolved direction is LTR\n */\nfunction isDirectionLTR(str, strongFallback) {\n  return getDirection(str, strongFallback) === UnicodeBidiDirection.LTR;\n}\n\n/**\n * Returns true if getDirection(arguments...) returns RTL.\n *\n * @param str             A text block; e.g. paragraph, table cell\n * @param strongFallback  Fallback direction, used if no strong direction\n *                        detected for the block (default = global direction)\n * @return                True if the resolved direction is RTL\n */\nfunction isDirectionRTL(str, strongFallback) {\n  return getDirection(str, strongFallback) === UnicodeBidiDirection.RTL;\n}\n\nvar UnicodeBidi = {\n  firstStrongChar: firstStrongChar,\n  firstStrongCharDir: firstStrongCharDir,\n  resolveBlockDir: resolveBlockDir,\n  getDirection: getDirection,\n  isDirectionLTR: isDirectionLTR,\n  isDirectionRTL: isDirectionRTL\n};\n\nmodule.exports = UnicodeBidi;\n\n/***/ }),\n/* 225 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DefaultDraftInlineStyle\n * @format\n * \n */\n\n\n\nmodule.exports = {\n  BOLD: {\n    fontWeight: 'bold'\n  },\n\n  CODE: {\n    fontFamily: 'monospace',\n    wordWrap: 'break-word'\n  },\n\n  ITALIC: {\n    fontStyle: 'italic'\n  },\n\n  STRIKETHROUGH: {\n    textDecoration: 'line-through'\n  },\n\n  UNDERLINE: {\n    textDecoration: 'underline'\n  }\n};\n\n/***/ }),\n/* 226 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule isSelectionAtLeafStart\n * @format\n * \n */\n\n\n\nfunction isSelectionAtLeafStart(editorState) {\n  var selection = editorState.getSelection();\n  var anchorKey = selection.getAnchorKey();\n  var blockTree = editorState.getBlockTree(anchorKey);\n  var offset = selection.getStartOffset();\n\n  var isAtStart = false;\n\n  blockTree.some(function (leafSet) {\n    if (offset === leafSet.get('start')) {\n      isAtStart = true;\n      return true;\n    }\n\n    if (offset < leafSet.get('end')) {\n      return leafSet.get('leaves').some(function (leaf) {\n        var leafStart = leaf.get('start');\n        if (offset === leafStart) {\n          isAtStart = true;\n          return true;\n        }\n\n        return false;\n      });\n    }\n\n    return false;\n  });\n\n  return isAtStart;\n}\n\nmodule.exports = isSelectionAtLeafStart;\n\n/***/ }),\n/* 227 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorBlock.react\n * @format\n * \n */\n\n\n\nvar _assign = __webpack_require__(3);\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar DraftEditorLeaf = __webpack_require__(443);\nvar DraftOffsetKey = __webpack_require__(116);\nvar React = __webpack_require__(0);\nvar ReactDOM = __webpack_require__(1);\nvar Scroll = __webpack_require__(229);\nvar Style = __webpack_require__(164);\nvar UnicodeBidi = __webpack_require__(224);\nvar UnicodeBidiDirection = __webpack_require__(159);\n\nvar cx = __webpack_require__(84);\nvar getElementPosition = __webpack_require__(458);\nvar getScrollPosition = __webpack_require__(165);\nvar getViewportDimensions = __webpack_require__(462);\nvar invariant = __webpack_require__(58);\nvar nullthrows = __webpack_require__(65);\n\nvar SCROLL_BUFFER = 10;\n\n/**\n * Return whether a block overlaps with either edge of the `SelectionState`.\n */\nvar isBlockOnSelectionEdge = function isBlockOnSelectionEdge(selection, key) {\n  return selection.getAnchorKey() === key || selection.getFocusKey() === key;\n};\n\n/**\n * The default block renderer for a `DraftEditor` component.\n *\n * A `DraftEditorBlock` is able to render a given `ContentBlock` to its\n * appropriate decorator and inline style components.\n */\n\nvar DraftEditorBlock = function (_React$Component) {\n  _inherits(DraftEditorBlock, _React$Component);\n\n  function DraftEditorBlock() {\n    _classCallCheck(this, DraftEditorBlock);\n\n    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));\n  }\n\n  DraftEditorBlock.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n    return this.props.block !== nextProps.block || this.props.tree !== nextProps.tree || this.props.direction !== nextProps.direction || isBlockOnSelectionEdge(nextProps.selection, nextProps.block.getKey()) && nextProps.forceSelection;\n  };\n\n  /**\n   * When a block is mounted and overlaps the selection state, we need to make\n   * sure that the cursor is visible to match native behavior. This may not\n   * be the case if the user has pressed `RETURN` or pasted some content, since\n   * programatically creating these new blocks and setting the DOM selection\n   * will miss out on the browser natively scrolling to that position.\n   *\n   * To replicate native behavior, if the block overlaps the selection state\n   * on mount, force the scroll position. Check the scroll state of the scroll\n   * parent, and adjust it to align the entire block to the bottom of the\n   * scroll parent.\n   */\n\n\n  DraftEditorBlock.prototype.componentDidMount = function componentDidMount() {\n    var selection = this.props.selection;\n    var endKey = selection.getEndKey();\n    if (!selection.getHasFocus() || endKey !== this.props.block.getKey()) {\n      return;\n    }\n\n    var blockNode = ReactDOM.findDOMNode(this);\n    var scrollParent = Style.getScrollParent(blockNode);\n    var scrollPosition = getScrollPosition(scrollParent);\n    var scrollDelta = void 0;\n\n    if (scrollParent === window) {\n      var nodePosition = getElementPosition(blockNode);\n      var nodeBottom = nodePosition.y + nodePosition.height;\n      var viewportHeight = getViewportDimensions().height;\n      scrollDelta = nodeBottom - viewportHeight;\n      if (scrollDelta > 0) {\n        window.scrollTo(scrollPosition.x, scrollPosition.y + scrollDelta + SCROLL_BUFFER);\n      }\n    } else {\n      !(blockNode instanceof HTMLElement) ?  false ? invariant(false, 'blockNode is not an HTMLElement') : invariant(false) : void 0;\n      var blockBottom = blockNode.offsetHeight + blockNode.offsetTop;\n      var scrollBottom = scrollParent.offsetHeight + scrollPosition.y;\n      scrollDelta = blockBottom - scrollBottom;\n      if (scrollDelta > 0) {\n        Scroll.setTop(scrollParent, Scroll.getTop(scrollParent) + scrollDelta + SCROLL_BUFFER);\n      }\n    }\n  };\n\n  DraftEditorBlock.prototype._renderChildren = function _renderChildren() {\n    var _this2 = this;\n\n    var block = this.props.block;\n    var blockKey = block.getKey();\n    var text = block.getText();\n    var lastLeafSet = this.props.tree.size - 1;\n    var hasSelection = isBlockOnSelectionEdge(this.props.selection, blockKey);\n\n    return this.props.tree.map(function (leafSet, ii) {\n      var leavesForLeafSet = leafSet.get('leaves');\n      var lastLeaf = leavesForLeafSet.size - 1;\n      var leaves = leavesForLeafSet.map(function (leaf, jj) {\n        var offsetKey = DraftOffsetKey.encode(blockKey, ii, jj);\n        var start = leaf.get('start');\n        var end = leaf.get('end');\n        return React.createElement(DraftEditorLeaf, {\n          key: offsetKey,\n          offsetKey: offsetKey,\n          block: block,\n          start: start,\n          selection: hasSelection ? _this2.props.selection : null,\n          forceSelection: _this2.props.forceSelection,\n          text: text.slice(start, end),\n          styleSet: block.getInlineStyleAt(start),\n          customStyleMap: _this2.props.customStyleMap,\n          customStyleFn: _this2.props.customStyleFn,\n          isLast: ii === lastLeafSet && jj === lastLeaf\n        });\n      }).toArray();\n\n      var decoratorKey = leafSet.get('decoratorKey');\n      if (decoratorKey == null) {\n        return leaves;\n      }\n\n      if (!_this2.props.decorator) {\n        return leaves;\n      }\n\n      var decorator = nullthrows(_this2.props.decorator);\n\n      var DecoratorComponent = decorator.getComponentForKey(decoratorKey);\n      if (!DecoratorComponent) {\n        return leaves;\n      }\n\n      var decoratorProps = decorator.getPropsForKey(decoratorKey);\n      var decoratorOffsetKey = DraftOffsetKey.encode(blockKey, ii, 0);\n      var decoratedText = text.slice(leavesForLeafSet.first().get('start'), leavesForLeafSet.last().get('end'));\n\n      // Resetting dir to the same value on a child node makes Chrome/Firefox\n      // confused on cursor movement. See http://jsfiddle.net/d157kLck/3/\n      var dir = UnicodeBidiDirection.getHTMLDirIfDifferent(UnicodeBidi.getDirection(decoratedText), _this2.props.direction);\n\n      return React.createElement(\n        DecoratorComponent,\n        _extends({}, decoratorProps, {\n          contentState: _this2.props.contentState,\n          decoratedText: decoratedText,\n          dir: dir,\n          key: decoratorOffsetKey,\n          entityKey: block.getEntityAt(leafSet.get('start')),\n          offsetKey: decoratorOffsetKey }),\n        leaves\n      );\n    }).toArray();\n  };\n\n  DraftEditorBlock.prototype.render = function render() {\n    var _props = this.props,\n        direction = _props.direction,\n        offsetKey = _props.offsetKey;\n\n    var className = cx({\n      'public/DraftStyleDefault/block': true,\n      'public/DraftStyleDefault/ltr': direction === 'LTR',\n      'public/DraftStyleDefault/rtl': direction === 'RTL'\n    });\n\n    return React.createElement(\n      'div',\n      { 'data-offset-key': offsetKey, className: className },\n      this._renderChildren()\n    );\n  };\n\n  return DraftEditorBlock;\n}(React.Component);\n\nmodule.exports = DraftEditorBlock;\n\n/***/ }),\n/* 228 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n/* eslint-disable fb-www/typeof-undefined */\n\n/**\n * Same as document.activeElement but wraps in a try-catch block. In IE it is\n * not safe to call document.activeElement if there is nothing focused.\n *\n * The activeElement will be null only if the document or document body is not\n * yet defined.\n *\n * @param {?DOMDocument} doc Defaults to current document.\n * @return {?DOMElement}\n */\nfunction getActiveElement(doc) /*?DOMElement*/{\n  doc = doc || (typeof document !== 'undefined' ? document : undefined);\n  if (typeof doc === 'undefined') {\n    return null;\n  }\n  try {\n    return doc.activeElement || doc.body;\n  } catch (e) {\n    return doc.body;\n  }\n}\n\nmodule.exports = getActiveElement;\n\n/***/ }),\n/* 229 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/**\n * @param {DOMElement} element\n * @param {DOMDocument} doc\n * @return {boolean}\n */\nfunction _isViewportScrollElement(element, doc) {\n  return !!doc && (element === doc.documentElement || element === doc.body);\n}\n\n/**\n * Scroll Module. This class contains 4 simple static functions\n * to be used to access Element.scrollTop/scrollLeft properties.\n * To solve the inconsistencies between browsers when either\n * document.body or document.documentElement is supplied,\n * below logic will be used to alleviate the issue:\n *\n * 1. If 'element' is either 'document.body' or 'document.documentElement,\n *    get whichever element's 'scroll{Top,Left}' is larger.\n * 2. If 'element' is either 'document.body' or 'document.documentElement',\n *    set the 'scroll{Top,Left}' on both elements.\n */\n\nvar Scroll = {\n  /**\n   * @param {DOMElement} element\n   * @return {number}\n   */\n  getTop: function getTop(element) {\n    var doc = element.ownerDocument;\n    return _isViewportScrollElement(element, doc) ?\n    // In practice, they will either both have the same value,\n    // or one will be zero and the other will be the scroll position\n    // of the viewport. So we can use `X || Y` instead of `Math.max(X, Y)`\n    doc.body.scrollTop || doc.documentElement.scrollTop : element.scrollTop;\n  },\n\n  /**\n   * @param {DOMElement} element\n   * @param {number} newTop\n   */\n  setTop: function setTop(element, newTop) {\n    var doc = element.ownerDocument;\n    if (_isViewportScrollElement(element, doc)) {\n      doc.body.scrollTop = doc.documentElement.scrollTop = newTop;\n    } else {\n      element.scrollTop = newTop;\n    }\n  },\n\n  /**\n   * @param {DOMElement} element\n   * @return {number}\n   */\n  getLeft: function getLeft(element) {\n    var doc = element.ownerDocument;\n    return _isViewportScrollElement(element, doc) ? doc.body.scrollLeft || doc.documentElement.scrollLeft : element.scrollLeft;\n  },\n\n  /**\n   * @param {DOMElement} element\n   * @param {number} newLeft\n   */\n  setLeft: function setLeft(element, newLeft) {\n    var doc = element.ownerDocument;\n    if (_isViewportScrollElement(element, doc)) {\n      doc.body.scrollLeft = doc.documentElement.scrollLeft = newLeft;\n    } else {\n      element.scrollLeft = newLeft;\n    }\n  }\n};\n\nmodule.exports = Scroll;\n\n/***/ }),\n/* 230 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar PhotosMimeType = __webpack_require__(465);\n\nvar createArrayFromMixed = __webpack_require__(466);\nvar emptyFunction = __webpack_require__(156);\n\nvar CR_LF_REGEX = new RegExp('\\r\\n', 'g');\nvar LF_ONLY = '\\n';\n\nvar RICH_TEXT_TYPES = {\n  'text/rtf': 1,\n  'text/html': 1\n};\n\n/**\n * If DataTransferItem is a file then return the Blob of data.\n *\n * @param {object} item\n * @return {?blob}\n */\nfunction getFileFromDataTransfer(item) {\n  if (item.kind == 'file') {\n    return item.getAsFile();\n  }\n}\n\nvar DataTransfer = function () {\n  /**\n   * @param {object} data\n   */\n  function DataTransfer(data) {\n    _classCallCheck(this, DataTransfer);\n\n    this.data = data;\n\n    // Types could be DOMStringList or array\n    this.types = data.types ? createArrayFromMixed(data.types) : [];\n  }\n\n  /**\n   * Is this likely to be a rich text data transfer?\n   *\n   * @return {boolean}\n   */\n\n\n  DataTransfer.prototype.isRichText = function isRichText() {\n    // If HTML is available, treat this data as rich text. This way, we avoid\n    // using a pasted image if it is packaged with HTML -- this may occur with\n    // pastes from MS Word, for example.  However this is only rich text if\n    // there's accompanying text.\n    if (this.getHTML() && this.getText()) {\n      return true;\n    }\n\n    // When an image is copied from a preview window, you end up with two\n    // DataTransferItems one of which is a file's metadata as text.  Skip those.\n    if (this.isImage()) {\n      return false;\n    }\n\n    return this.types.some(function (type) {\n      return RICH_TEXT_TYPES[type];\n    });\n  };\n\n  /**\n   * Get raw text.\n   *\n   * @return {?string}\n   */\n\n\n  DataTransfer.prototype.getText = function getText() {\n    var text;\n    if (this.data.getData) {\n      if (!this.types.length) {\n        text = this.data.getData('Text');\n      } else if (this.types.indexOf('text/plain') != -1) {\n        text = this.data.getData('text/plain');\n      }\n    }\n    return text ? text.replace(CR_LF_REGEX, LF_ONLY) : null;\n  };\n\n  /**\n   * Get HTML paste data\n   *\n   * @return {?string}\n   */\n\n\n  DataTransfer.prototype.getHTML = function getHTML() {\n    if (this.data.getData) {\n      if (!this.types.length) {\n        return this.data.getData('Text');\n      } else if (this.types.indexOf('text/html') != -1) {\n        return this.data.getData('text/html');\n      }\n    }\n  };\n\n  /**\n   * Is this a link data transfer?\n   *\n   * @return {boolean}\n   */\n\n\n  DataTransfer.prototype.isLink = function isLink() {\n    return this.types.some(function (type) {\n      return type.indexOf('Url') != -1 || type.indexOf('text/uri-list') != -1 || type.indexOf('text/x-moz-url');\n    });\n  };\n\n  /**\n   * Get a link url.\n   *\n   * @return {?string}\n   */\n\n\n  DataTransfer.prototype.getLink = function getLink() {\n    if (this.data.getData) {\n      if (this.types.indexOf('text/x-moz-url') != -1) {\n        var url = this.data.getData('text/x-moz-url').split('\\n');\n        return url[0];\n      }\n      return this.types.indexOf('text/uri-list') != -1 ? this.data.getData('text/uri-list') : this.data.getData('url');\n    }\n\n    return null;\n  };\n\n  /**\n   * Is this an image data transfer?\n   *\n   * @return {boolean}\n   */\n\n\n  DataTransfer.prototype.isImage = function isImage() {\n    var isImage = this.types.some(function (type) {\n      // Firefox will have a type of application/x-moz-file for images during\n      // dragging\n      return type.indexOf('application/x-moz-file') != -1;\n    });\n\n    if (isImage) {\n      return true;\n    }\n\n    var items = this.getFiles();\n    for (var i = 0; i < items.length; i++) {\n      var type = items[i].type;\n      if (!PhotosMimeType.isImage(type)) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n\n  DataTransfer.prototype.getCount = function getCount() {\n    if (this.data.hasOwnProperty('items')) {\n      return this.data.items.length;\n    } else if (this.data.hasOwnProperty('mozItemCount')) {\n      return this.data.mozItemCount;\n    } else if (this.data.files) {\n      return this.data.files.length;\n    }\n    return null;\n  };\n\n  /**\n   * Get files.\n   *\n   * @return {array}\n   */\n\n\n  DataTransfer.prototype.getFiles = function getFiles() {\n    if (this.data.items) {\n      // createArrayFromMixed doesn't properly handle DataTransferItemLists.\n      return Array.prototype.slice.call(this.data.items).map(getFileFromDataTransfer).filter(emptyFunction.thatReturnsArgument);\n    } else if (this.data.files) {\n      return Array.prototype.slice.call(this.data.files);\n    } else {\n      return [];\n    }\n  };\n\n  /**\n   * Are there any files to fetch?\n   *\n   * @return {boolean}\n   */\n\n\n  DataTransfer.prototype.hasFiles = function hasFiles() {\n    return this.getFiles().length > 0;\n  };\n\n  return DataTransfer;\n}();\n\nmodule.exports = DataTransfer;\n\n/***/ }),\n/* 231 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getSelectionOffsetKeyForNode\n * @format\n * \n */\n\n\n\n/**\n * Get offset key from a node or it's child nodes. Return the first offset key\n * found on the DOM tree of given node.\n */\n\nfunction getSelectionOffsetKeyForNode(node) {\n  if (node instanceof Element) {\n    var offsetKey = node.getAttribute('data-offset-key');\n    if (offsetKey) {\n      return offsetKey;\n    }\n    for (var ii = 0; ii < node.childNodes.length; ii++) {\n      var childOffsetKey = getSelectionOffsetKeyForNode(node.childNodes[ii]);\n      if (childOffsetKey) {\n        return childOffsetKey;\n      }\n    }\n  }\n  return null;\n}\n\nmodule.exports = getSelectionOffsetKeyForNode;\n\n/***/ }),\n/* 232 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getTextContentFromFiles\n * @format\n * \n */\n\n\n\nvar invariant = __webpack_require__(58);\n\nvar TEXT_CLIPPING_REGEX = /\\.textClipping$/;\n\nvar TEXT_TYPES = {\n  'text/plain': true,\n  'text/html': true,\n  'text/rtf': true\n};\n\n// Somewhat arbitrary upper bound on text size. Let's not lock up the browser.\nvar TEXT_SIZE_UPPER_BOUND = 5000;\n\n/**\n * Extract the text content from a file list.\n */\nfunction getTextContentFromFiles(files, callback) {\n  var readCount = 0;\n  var results = [];\n  files.forEach(function ( /*blob*/file) {\n    readFile(file, function ( /*string*/text) {\n      readCount++;\n      text && results.push(text.slice(0, TEXT_SIZE_UPPER_BOUND));\n      if (readCount == files.length) {\n        callback(results.join('\\r'));\n      }\n    });\n  });\n}\n\n/**\n * todo isaac: Do work to turn html/rtf into a content fragment.\n */\nfunction readFile(file, callback) {\n  if (!global.FileReader || file.type && !(file.type in TEXT_TYPES)) {\n    callback('');\n    return;\n  }\n\n  if (file.type === '') {\n    var contents = '';\n    // Special-case text clippings, which have an empty type but include\n    // `.textClipping` in the file name. `readAsText` results in an empty\n    // string for text clippings, so we force the file name to serve\n    // as the text value for the file.\n    if (TEXT_CLIPPING_REGEX.test(file.name)) {\n      contents = file.name.replace(TEXT_CLIPPING_REGEX, '');\n    }\n    callback(contents);\n    return;\n  }\n\n  var reader = new FileReader();\n  reader.onload = function () {\n    var result = reader.result;\n    !(typeof result === 'string') ?  false ? invariant(false, 'We should be calling \"FileReader.readAsText\" which returns a string') : invariant(false) : void 0;\n    callback(result);\n  };\n  reader.onerror = function () {\n    callback('');\n  };\n  reader.readAsText(file);\n}\n\nmodule.exports = getTextContentFromFiles;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2)))\n\n/***/ }),\n/* 233 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getUpdatedSelectionState\n * @format\n * \n */\n\n\n\nvar DraftOffsetKey = __webpack_require__(116);\n\nvar nullthrows = __webpack_require__(65);\n\nfunction getUpdatedSelectionState(editorState, anchorKey, anchorOffset, focusKey, focusOffset) {\n  var selection = nullthrows(editorState.getSelection());\n  if (false) {\n    if (!anchorKey || !focusKey) {\n      /*eslint-disable no-console */\n      console.warn('Invalid selection state.', arguments, editorState.toJS());\n      /*eslint-enable no-console */\n      return selection;\n    }\n  }\n\n  var anchorPath = DraftOffsetKey.decode(anchorKey);\n  var anchorBlockKey = anchorPath.blockKey;\n  var anchorLeaf = editorState.getBlockTree(anchorBlockKey).getIn([anchorPath.decoratorKey, 'leaves', anchorPath.leafKey]);\n\n  var focusPath = DraftOffsetKey.decode(focusKey);\n  var focusBlockKey = focusPath.blockKey;\n  var focusLeaf = editorState.getBlockTree(focusBlockKey).getIn([focusPath.decoratorKey, 'leaves', focusPath.leafKey]);\n\n  var anchorLeafStart = anchorLeaf.get('start');\n  var focusLeafStart = focusLeaf.get('start');\n\n  var anchorBlockOffset = anchorLeaf ? anchorLeafStart + anchorOffset : null;\n  var focusBlockOffset = focusLeaf ? focusLeafStart + focusOffset : null;\n\n  var areEqual = selection.getAnchorKey() === anchorBlockKey && selection.getAnchorOffset() === anchorBlockOffset && selection.getFocusKey() === focusBlockKey && selection.getFocusOffset() === focusBlockOffset;\n\n  if (areEqual) {\n    return selection;\n  }\n\n  var isBackward = false;\n  if (anchorBlockKey === focusBlockKey) {\n    var anchorLeafEnd = anchorLeaf.get('end');\n    var focusLeafEnd = focusLeaf.get('end');\n    if (focusLeafStart === anchorLeafStart && focusLeafEnd === anchorLeafEnd) {\n      isBackward = focusOffset < anchorOffset;\n    } else {\n      isBackward = focusLeafStart < anchorLeafStart;\n    }\n  } else {\n    var startKey = editorState.getCurrentContent().getBlockMap().keySeq().skipUntil(function (v) {\n      return v === anchorBlockKey || v === focusBlockKey;\n    }).first();\n    isBackward = startKey === focusBlockKey;\n  }\n\n  return selection.merge({\n    anchorKey: anchorBlockKey,\n    anchorOffset: anchorBlockOffset,\n    focusKey: focusBlockKey,\n    focusOffset: focusBlockOffset,\n    isBackward: isBackward\n  });\n}\n\nmodule.exports = getUpdatedSelectionState;\n\n/***/ }),\n/* 234 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getFragmentFromSelection\n * @format\n * \n */\n\n\n\nvar getContentStateFragment = __webpack_require__(114);\n\nfunction getFragmentFromSelection(editorState) {\n  var selectionState = editorState.getSelection();\n\n  if (selectionState.isCollapsed()) {\n    return null;\n  }\n\n  return getContentStateFragment(editorState.getCurrentContent(), selectionState);\n}\n\nmodule.exports = getFragmentFromSelection;\n\n/***/ }),\n/* 235 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getRangeClientRects\n * @format\n * \n */\n\n\n\nvar UserAgent = __webpack_require__(67);\n\nvar invariant = __webpack_require__(58);\n\nvar isChrome = UserAgent.isBrowser('Chrome');\n\n// In Chrome, the client rects will include the entire bounds of all nodes that\n// begin (have a start tag) within the selection, even if the selection does\n// not overlap the entire node. To resolve this, we split the range at each\n// start tag and join the client rects together.\n// https://code.google.com/p/chromium/issues/detail?id=324437\n/* eslint-disable consistent-return */\nfunction getRangeClientRectsChrome(range) {\n  var tempRange = range.cloneRange();\n  var clientRects = [];\n\n  for (var ancestor = range.endContainer; ancestor != null; ancestor = ancestor.parentNode) {\n    // If we've climbed up to the common ancestor, we can now use the\n    // original start point and stop climbing the tree.\n    var atCommonAncestor = ancestor === range.commonAncestorContainer;\n    if (atCommonAncestor) {\n      tempRange.setStart(range.startContainer, range.startOffset);\n    } else {\n      tempRange.setStart(tempRange.endContainer, 0);\n    }\n    var rects = Array.from(tempRange.getClientRects());\n    clientRects.push(rects);\n    if (atCommonAncestor) {\n      var _ref;\n\n      clientRects.reverse();\n      return (_ref = []).concat.apply(_ref, clientRects);\n    }\n    tempRange.setEndBefore(ancestor);\n  }\n\n   true ?  false ? invariant(false, 'Found an unexpected detached subtree when getting range client rects.') : invariant(false) : void 0;\n}\n/* eslint-enable consistent-return */\n\n/**\n * Like range.getClientRects() but normalizes for browser bugs.\n */\nvar getRangeClientRects = isChrome ? getRangeClientRectsChrome : function (range) {\n  return Array.from(range.getClientRects());\n};\n\nmodule.exports = getRangeClientRects;\n\n/***/ }),\n/* 236 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getDraftEditorSelectionWithNodes\n * @format\n * \n */\n\n\n\nvar findAncestorOffsetKey = __webpack_require__(166);\nvar getSelectionOffsetKeyForNode = __webpack_require__(231);\nvar getUpdatedSelectionState = __webpack_require__(233);\nvar invariant = __webpack_require__(58);\nvar nullthrows = __webpack_require__(65);\n\n/**\n * Convert the current selection range to an anchor/focus pair of offset keys\n * and values that can be interpreted by components.\n */\nfunction getDraftEditorSelectionWithNodes(editorState, root, anchorNode, anchorOffset, focusNode, focusOffset) {\n  var anchorIsTextNode = anchorNode.nodeType === Node.TEXT_NODE;\n  var focusIsTextNode = focusNode.nodeType === Node.TEXT_NODE;\n\n  // If the selection range lies only on text nodes, the task is simple.\n  // Find the nearest offset-aware elements and use the\n  // offset values supplied by the selection range.\n  if (anchorIsTextNode && focusIsTextNode) {\n    return {\n      selectionState: getUpdatedSelectionState(editorState, nullthrows(findAncestorOffsetKey(anchorNode)), anchorOffset, nullthrows(findAncestorOffsetKey(focusNode)), focusOffset),\n      needsRecovery: false\n    };\n  }\n\n  var anchorPoint = null;\n  var focusPoint = null;\n  var needsRecovery = true;\n\n  // An element is selected. Convert this selection range into leaf offset\n  // keys and offset values for consumption at the component level. This\n  // is common in Firefox, where select-all and triple click behavior leads\n  // to entire elements being selected.\n  //\n  // Note that we use the `needsRecovery` parameter in the callback here. This\n  // is because when certain elements are selected, the behavior for subsequent\n  // cursor movement (e.g. via arrow keys) is uncertain and may not match\n  // expectations at the component level. For example, if an entire <div> is\n  // selected and the user presses the right arrow, Firefox keeps the selection\n  // on the <div>. If we allow subsequent keypresses to insert characters\n  // natively, they will be inserted into a browser-created text node to the\n  // right of that <div>. This is obviously undesirable.\n  //\n  // With the `needsRecovery` flag, we inform the caller that it is responsible\n  // for manually setting the selection state on the rendered document to\n  // ensure proper selection state maintenance.\n\n  if (anchorIsTextNode) {\n    anchorPoint = {\n      key: nullthrows(findAncestorOffsetKey(anchorNode)),\n      offset: anchorOffset\n    };\n    focusPoint = getPointForNonTextNode(root, focusNode, focusOffset);\n  } else if (focusIsTextNode) {\n    focusPoint = {\n      key: nullthrows(findAncestorOffsetKey(focusNode)),\n      offset: focusOffset\n    };\n    anchorPoint = getPointForNonTextNode(root, anchorNode, anchorOffset);\n  } else {\n    anchorPoint = getPointForNonTextNode(root, anchorNode, anchorOffset);\n    focusPoint = getPointForNonTextNode(root, focusNode, focusOffset);\n\n    // If the selection is collapsed on an empty block, don't force recovery.\n    // This way, on arrow key selection changes, the browser can move the\n    // cursor from a non-zero offset on one block, through empty blocks,\n    // to a matching non-zero offset on other text blocks.\n    if (anchorNode === focusNode && anchorOffset === focusOffset) {\n      needsRecovery = !!anchorNode.firstChild && anchorNode.firstChild.nodeName !== 'BR';\n    }\n  }\n\n  return {\n    selectionState: getUpdatedSelectionState(editorState, anchorPoint.key, anchorPoint.offset, focusPoint.key, focusPoint.offset),\n    needsRecovery: needsRecovery\n  };\n}\n\n/**\n * Identify the first leaf descendant for the given node.\n */\nfunction getFirstLeaf(node) {\n  while (node.firstChild && (\n  // data-blocks has no offset\n  node.firstChild instanceof Element && node.firstChild.getAttribute('data-blocks') === 'true' || getSelectionOffsetKeyForNode(node.firstChild))) {\n    node = node.firstChild;\n  }\n  return node;\n}\n\n/**\n * Identify the last leaf descendant for the given node.\n */\nfunction getLastLeaf(node) {\n  while (node.lastChild && (\n  // data-blocks has no offset\n  node.lastChild instanceof Element && node.lastChild.getAttribute('data-blocks') === 'true' || getSelectionOffsetKeyForNode(node.lastChild))) {\n    node = node.lastChild;\n  }\n  return node;\n}\n\nfunction getPointForNonTextNode(editorRoot, startNode, childOffset) {\n  var node = startNode;\n  var offsetKey = findAncestorOffsetKey(node);\n\n  !(offsetKey != null || editorRoot && (editorRoot === node || editorRoot.firstChild === node)) ?  false ? invariant(false, 'Unknown node in selection range.') : invariant(false) : void 0;\n\n  // If the editorRoot is the selection, step downward into the content\n  // wrapper.\n  if (editorRoot === node) {\n    node = node.firstChild;\n    !(node instanceof Element && node.getAttribute('data-contents') === 'true') ?  false ? invariant(false, 'Invalid DraftEditorContents structure.') : invariant(false) : void 0;\n    if (childOffset > 0) {\n      childOffset = node.childNodes.length;\n    }\n  }\n\n  // If the child offset is zero and we have an offset key, we're done.\n  // If there's no offset key because the entire editor is selected,\n  // find the leftmost (\"first\") leaf in the tree and use that as the offset\n  // key.\n  if (childOffset === 0) {\n    var key = null;\n    if (offsetKey != null) {\n      key = offsetKey;\n    } else {\n      var firstLeaf = getFirstLeaf(node);\n      key = nullthrows(getSelectionOffsetKeyForNode(firstLeaf));\n    }\n    return { key: key, offset: 0 };\n  }\n\n  var nodeBeforeCursor = node.childNodes[childOffset - 1];\n  var leafKey = null;\n  var textLength = null;\n\n  if (!getSelectionOffsetKeyForNode(nodeBeforeCursor)) {\n    // Our target node may be a leaf or a text node, in which case we're\n    // already where we want to be and can just use the child's length as\n    // our offset.\n    leafKey = nullthrows(offsetKey);\n    textLength = getTextContentLength(nodeBeforeCursor);\n  } else {\n    // Otherwise, we'll look at the child to the left of the cursor and find\n    // the last leaf node in its subtree.\n    var lastLeaf = getLastLeaf(nodeBeforeCursor);\n    leafKey = nullthrows(getSelectionOffsetKeyForNode(lastLeaf));\n    textLength = getTextContentLength(lastLeaf);\n  }\n\n  return {\n    key: leafKey,\n    offset: textLength\n  };\n}\n\n/**\n * Return the length of a node's textContent, regarding single newline\n * characters as zero-length. This allows us to avoid problems with identifying\n * the correct selection offset for empty blocks in IE, in which we\n * render newlines instead of break tags.\n */\nfunction getTextContentLength(node) {\n  var textContent = node.textContent;\n  return textContent === '\\n' ? 0 : textContent.length;\n}\n\nmodule.exports = getDraftEditorSelectionWithNodes;\n\n/***/ }),\n/* 237 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftRemovableWord\n * @format\n * \n */\n\n\n\nvar TokenizeUtil = __webpack_require__(484);\n\nvar punctuation = TokenizeUtil.getPunctuation();\n\n// The apostrophe and curly single quotes behave in a curious way: when\n// surrounded on both sides by word characters, they behave as word chars; when\n// either neighbor is punctuation or an end of the string, they behave as\n// punctuation.\nvar CHAMELEON_CHARS = '[\\'\\u2018\\u2019]';\n\n// Remove the underscore, which should count as part of the removable word. The\n// \"chameleon chars\" also count as punctuation in this regex.\nvar WHITESPACE_AND_PUNCTUATION = '\\\\s|(?![_])' + punctuation;\n\nvar DELETE_STRING = '^' + '(?:' + WHITESPACE_AND_PUNCTUATION + ')*' + '(?:' + CHAMELEON_CHARS + '|(?!' + WHITESPACE_AND_PUNCTUATION + ').)*' + '(?:(?!' + WHITESPACE_AND_PUNCTUATION + ').)';\nvar DELETE_REGEX = new RegExp(DELETE_STRING);\n\nvar BACKSPACE_STRING = '(?:(?!' + WHITESPACE_AND_PUNCTUATION + ').)' + '(?:' + CHAMELEON_CHARS + '|(?!' + WHITESPACE_AND_PUNCTUATION + ').)*' + '(?:' + WHITESPACE_AND_PUNCTUATION + ')*' + '$';\nvar BACKSPACE_REGEX = new RegExp(BACKSPACE_STRING);\n\nfunction getRemovableWord(text, isBackward) {\n  var matches = isBackward ? BACKSPACE_REGEX.exec(text) : DELETE_REGEX.exec(text);\n  return matches ? matches[0] : text;\n}\n\nvar DraftRemovableWord = {\n  getBackward: function getBackward(text) {\n    return getRemovableWord(text, true);\n  },\n\n  getForward: function getForward(text) {\n    return getRemovableWord(text, false);\n  }\n};\n\nmodule.exports = DraftRemovableWord;\n\n/***/ }),\n/* 238 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule moveSelectionForward\n * @format\n * \n */\n\n\n\n/**\n * Given a collapsed selection, move the focus `maxDistance` forward within\n * the selected block. If the selection will go beyond the end of the block,\n * move focus to the start of the next block, but no further.\n *\n * This function is not Unicode-aware, so surrogate pairs will be treated\n * as having length 2.\n */\nfunction moveSelectionForward(editorState, maxDistance) {\n  var selection = editorState.getSelection();\n  var key = selection.getStartKey();\n  var offset = selection.getStartOffset();\n  var content = editorState.getCurrentContent();\n\n  var focusKey = key;\n  var focusOffset;\n\n  var block = content.getBlockForKey(key);\n\n  if (maxDistance > block.getText().length - offset) {\n    focusKey = content.getKeyAfter(key);\n    focusOffset = 0;\n  } else {\n    focusOffset = offset + maxDistance;\n  }\n\n  return selection.merge({ focusKey: focusKey, focusOffset: focusOffset });\n}\n\nmodule.exports = moveSelectionForward;\n\n/***/ }),\n/* 239 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule convertFromHTMLToContentBlocks\n * @format\n * \n */\n\n\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _knownListItemDepthCl,\n    _assign = __webpack_require__(3);\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar CharacterMetadata = __webpack_require__(63);\nvar ContentBlock = __webpack_require__(76);\nvar ContentBlockNode = __webpack_require__(64);\nvar DefaultDraftBlockRenderMap = __webpack_require__(160);\nvar DraftEntity = __webpack_require__(115);\nvar DraftFeatureFlags = __webpack_require__(71);\nvar Immutable = __webpack_require__(57);\n\nvar _require = __webpack_require__(57),\n    Set = _require.Set;\n\nvar URI = __webpack_require__(495);\n\nvar cx = __webpack_require__(84);\nvar generateRandomKey = __webpack_require__(70);\nvar getSafeBodyFromHTML = __webpack_require__(240);\nvar invariant = __webpack_require__(58);\nvar sanitizeDraftText = __webpack_require__(158);\n\nvar experimentalTreeDataSupport = DraftFeatureFlags.draft_tree_data_support;\n\nvar List = Immutable.List,\n    OrderedSet = Immutable.OrderedSet;\n\n\nvar NBSP = '&nbsp;';\nvar SPACE = ' ';\n\n// Arbitrary max indent\nvar MAX_DEPTH = 4;\n\n// used for replacing characters in HTML\nvar REGEX_CR = new RegExp('\\r', 'g');\nvar REGEX_LF = new RegExp('\\n', 'g');\nvar REGEX_NBSP = new RegExp(NBSP, 'g');\nvar REGEX_CARRIAGE = new RegExp('&#13;?', 'g');\nvar REGEX_ZWS = new RegExp('&#8203;?', 'g');\n\n// https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight\nvar boldValues = ['bold', 'bolder', '500', '600', '700', '800', '900'];\nvar notBoldValues = ['light', 'lighter', '100', '200', '300', '400'];\n\n// Block tag flow is different because LIs do not have\n// a deterministic style ;_;\nvar inlineTags = {\n  b: 'BOLD',\n  code: 'CODE',\n  del: 'STRIKETHROUGH',\n  em: 'ITALIC',\n  i: 'ITALIC',\n  s: 'STRIKETHROUGH',\n  strike: 'STRIKETHROUGH',\n  strong: 'BOLD',\n  u: 'UNDERLINE'\n};\n\nvar knownListItemDepthClasses = (_knownListItemDepthCl = {}, _defineProperty(_knownListItemDepthCl, cx('public/DraftStyleDefault/depth0'), 0), _defineProperty(_knownListItemDepthCl, cx('public/DraftStyleDefault/depth1'), 1), _defineProperty(_knownListItemDepthCl, cx('public/DraftStyleDefault/depth2'), 2), _defineProperty(_knownListItemDepthCl, cx('public/DraftStyleDefault/depth3'), 3), _defineProperty(_knownListItemDepthCl, cx('public/DraftStyleDefault/depth4'), 4), _knownListItemDepthCl);\n\nvar anchorAttr = ['className', 'href', 'rel', 'target', 'title'];\n\nvar imgAttr = ['alt', 'className', 'height', 'src', 'width'];\n\nvar lastBlock = void 0;\n\nvar EMPTY_CHUNK = {\n  text: '',\n  inlines: [],\n  entities: [],\n  blocks: []\n};\n\nvar EMPTY_BLOCK = {\n  children: List(),\n  depth: 0,\n  key: '',\n  type: ''\n};\n\nvar getListBlockType = function getListBlockType(tag, lastList) {\n  if (tag === 'li') {\n    return lastList === 'ol' ? 'ordered-list-item' : 'unordered-list-item';\n  }\n  return null;\n};\n\nvar getBlockMapSupportedTags = function getBlockMapSupportedTags(blockRenderMap) {\n  var unstyledElement = blockRenderMap.get('unstyled').element;\n  var tags = Set([]);\n\n  blockRenderMap.forEach(function (draftBlock) {\n    if (draftBlock.aliasedElements) {\n      draftBlock.aliasedElements.forEach(function (tag) {\n        tags = tags.add(tag);\n      });\n    }\n\n    tags = tags.add(draftBlock.element);\n  });\n\n  return tags.filter(function (tag) {\n    return tag && tag !== unstyledElement;\n  }).toArray().sort();\n};\n\n// custom element conversions\nvar getMultiMatchedType = function getMultiMatchedType(tag, lastList, multiMatchExtractor) {\n  for (var ii = 0; ii < multiMatchExtractor.length; ii++) {\n    var matchType = multiMatchExtractor[ii](tag, lastList);\n    if (matchType) {\n      return matchType;\n    }\n  }\n  return null;\n};\n\nvar getBlockTypeForTag = function getBlockTypeForTag(tag, lastList, blockRenderMap) {\n  var matchedTypes = blockRenderMap.filter(function (draftBlock) {\n    return draftBlock.element === tag || draftBlock.wrapper === tag || draftBlock.aliasedElements && draftBlock.aliasedElements.some(function (alias) {\n      return alias === tag;\n    });\n  }).keySeq().toSet().toArray().sort();\n\n  // if we dont have any matched type, return unstyled\n  // if we have one matched type return it\n  // if we have multi matched types use the multi-match function to gather type\n  switch (matchedTypes.length) {\n    case 0:\n      return 'unstyled';\n    case 1:\n      return matchedTypes[0];\n    default:\n      return getMultiMatchedType(tag, lastList, [getListBlockType]) || 'unstyled';\n  }\n};\n\nvar processInlineTag = function processInlineTag(tag, node, currentStyle) {\n  var styleToCheck = inlineTags[tag];\n  if (styleToCheck) {\n    currentStyle = currentStyle.add(styleToCheck).toOrderedSet();\n  } else if (node instanceof HTMLElement) {\n    var htmlElement = node;\n    currentStyle = currentStyle.withMutations(function (style) {\n      var fontWeight = htmlElement.style.fontWeight;\n      var fontStyle = htmlElement.style.fontStyle;\n      var textDecoration = htmlElement.style.textDecoration;\n\n      if (boldValues.indexOf(fontWeight) >= 0) {\n        style.add('BOLD');\n      } else if (notBoldValues.indexOf(fontWeight) >= 0) {\n        style.remove('BOLD');\n      }\n\n      if (fontStyle === 'italic') {\n        style.add('ITALIC');\n      } else if (fontStyle === 'normal') {\n        style.remove('ITALIC');\n      }\n\n      if (textDecoration === 'underline') {\n        style.add('UNDERLINE');\n      }\n      if (textDecoration === 'line-through') {\n        style.add('STRIKETHROUGH');\n      }\n      if (textDecoration === 'none') {\n        style.remove('UNDERLINE');\n        style.remove('STRIKETHROUGH');\n      }\n    }).toOrderedSet();\n  }\n  return currentStyle;\n};\n\nvar joinChunks = function joinChunks(A, B, experimentalHasNestedBlocks) {\n  // Sometimes two blocks will touch in the DOM and we need to strip the\n  // extra delimiter to preserve niceness.\n  var lastInA = A.text.slice(-1);\n  var firstInB = B.text.slice(0, 1);\n\n  if (lastInA === '\\r' && firstInB === '\\r' && !experimentalHasNestedBlocks) {\n    A.text = A.text.slice(0, -1);\n    A.inlines.pop();\n    A.entities.pop();\n    A.blocks.pop();\n  }\n\n  // Kill whitespace after blocks\n  if (lastInA === '\\r') {\n    if (B.text === SPACE || B.text === '\\n') {\n      return A;\n    } else if (firstInB === SPACE || firstInB === '\\n') {\n      B.text = B.text.slice(1);\n      B.inlines.shift();\n      B.entities.shift();\n    }\n  }\n\n  return {\n    text: A.text + B.text,\n    inlines: A.inlines.concat(B.inlines),\n    entities: A.entities.concat(B.entities),\n    blocks: A.blocks.concat(B.blocks)\n  };\n};\n\n/**\n * Check to see if we have anything like <p> <blockquote> <h1>... to create\n * block tags from. If we do, we can use those and ignore <div> tags. If we\n * don't, we can treat <div> tags as meaningful (unstyled) blocks.\n */\nvar containsSemanticBlockMarkup = function containsSemanticBlockMarkup(html, blockTags) {\n  return blockTags.some(function (tag) {\n    return html.indexOf('<' + tag) !== -1;\n  });\n};\n\nvar hasValidLinkText = function hasValidLinkText(link) {\n  !(link instanceof HTMLAnchorElement) ?  false ? invariant(false, 'Link must be an HTMLAnchorElement.') : invariant(false) : void 0;\n  var protocol = link.protocol;\n  return protocol === 'http:' || protocol === 'https:' || protocol === 'mailto:';\n};\n\nvar getWhitespaceChunk = function getWhitespaceChunk(inEntity) {\n  var entities = new Array(1);\n  if (inEntity) {\n    entities[0] = inEntity;\n  }\n  return _extends({}, EMPTY_CHUNK, {\n    text: SPACE,\n    inlines: [OrderedSet()],\n    entities: entities\n  });\n};\n\nvar getSoftNewlineChunk = function getSoftNewlineChunk() {\n  return _extends({}, EMPTY_CHUNK, {\n    text: '\\n',\n    inlines: [OrderedSet()],\n    entities: new Array(1)\n  });\n};\n\nvar getChunkedBlock = function getChunkedBlock() {\n  var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n  return _extends({}, EMPTY_BLOCK, props);\n};\n\nvar getBlockDividerChunk = function getBlockDividerChunk(block, depth) {\n  var parentKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n\n  return {\n    text: '\\r',\n    inlines: [OrderedSet()],\n    entities: new Array(1),\n    blocks: [getChunkedBlock({\n      parent: parentKey,\n      key: generateRandomKey(),\n      type: block,\n      depth: Math.max(0, Math.min(MAX_DEPTH, depth))\n    })]\n  };\n};\n\n/**\n *  If we're pasting from one DraftEditor to another we can check to see if\n *  existing list item depth classes are being used and preserve this style\n */\nvar getListItemDepth = function getListItemDepth(node) {\n  var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n  Object.keys(knownListItemDepthClasses).some(function (depthClass) {\n    if (node.classList.contains(depthClass)) {\n      depth = knownListItemDepthClasses[depthClass];\n    }\n  });\n  return depth;\n};\n\nvar genFragment = function genFragment(entityMap, node, inlineStyle, lastList, inBlock, blockTags, depth, blockRenderMap, inEntity, parentKey) {\n  var lastLastBlock = lastBlock;\n  var nodeName = node.nodeName.toLowerCase();\n  var newEntityMap = entityMap;\n  var nextBlockType = 'unstyled';\n  var newBlock = false;\n  var inBlockType = inBlock && getBlockTypeForTag(inBlock, lastList, blockRenderMap);\n  var chunk = _extends({}, EMPTY_CHUNK);\n  var newChunk = null;\n  var blockKey = void 0;\n\n  // Base Case\n  if (nodeName === '#text') {\n    var _text = node.textContent;\n    var nodeTextContent = _text.trim();\n\n    // We should not create blocks for leading spaces that are\n    // existing around ol/ul and their children list items\n    if (lastList && nodeTextContent === '' && node.parentElement) {\n      var parentNodeName = node.parentElement.nodeName.toLowerCase();\n      if (parentNodeName === 'ol' || parentNodeName === 'ul') {\n        return { chunk: _extends({}, EMPTY_CHUNK), entityMap: entityMap };\n      }\n    }\n\n    if (nodeTextContent === '' && inBlock !== 'pre') {\n      return { chunk: getWhitespaceChunk(inEntity), entityMap: entityMap };\n    }\n    if (inBlock !== 'pre') {\n      // Can't use empty string because MSWord\n      _text = _text.replace(REGEX_LF, SPACE);\n    }\n\n    // save the last block so we can use it later\n    lastBlock = nodeName;\n\n    return {\n      chunk: {\n        text: _text,\n        inlines: Array(_text.length).fill(inlineStyle),\n        entities: Array(_text.length).fill(inEntity),\n        blocks: []\n      },\n      entityMap: entityMap\n    };\n  }\n\n  // save the last block so we can use it later\n  lastBlock = nodeName;\n\n  // BR tags\n  if (nodeName === 'br') {\n    if (lastLastBlock === 'br' && (!inBlock || inBlockType === 'unstyled')) {\n      return {\n        chunk: getBlockDividerChunk('unstyled', depth, parentKey),\n        entityMap: entityMap\n      };\n    }\n    return { chunk: getSoftNewlineChunk(), entityMap: entityMap };\n  }\n\n  // IMG tags\n  if (nodeName === 'img' && node instanceof HTMLImageElement && node.attributes.getNamedItem('src') && node.attributes.getNamedItem('src').value) {\n    var image = node;\n    var entityConfig = {};\n\n    imgAttr.forEach(function (attr) {\n      var imageAttribute = image.getAttribute(attr);\n      if (imageAttribute) {\n        entityConfig[attr] = imageAttribute;\n      }\n    });\n    // Forcing this node to have children because otherwise no entity will be\n    // created for this node.\n    // The child text node cannot just have a space or return as content -\n    // we strip those out.\n    // See https://github.com/facebook/draft-js/issues/231 for some context.\n    node.textContent = '\\uD83D\\uDCF7';\n\n    // TODO: update this when we remove DraftEntity entirely\n    inEntity = DraftEntity.__create('IMAGE', 'MUTABLE', entityConfig || {});\n  }\n\n  // Inline tags\n  inlineStyle = processInlineTag(nodeName, node, inlineStyle);\n\n  // Handle lists\n  if (nodeName === 'ul' || nodeName === 'ol') {\n    if (lastList) {\n      depth += 1;\n    }\n    lastList = nodeName;\n  }\n\n  if (!experimentalTreeDataSupport && nodeName === 'li' && node instanceof HTMLElement) {\n    depth = getListItemDepth(node, depth);\n  }\n\n  var blockType = getBlockTypeForTag(nodeName, lastList, blockRenderMap);\n  var inListBlock = lastList && inBlock === 'li' && nodeName === 'li';\n  var inBlockOrHasNestedBlocks = (!inBlock || experimentalTreeDataSupport) && blockTags.indexOf(nodeName) !== -1;\n\n  // Block Tags\n  if (inListBlock || inBlockOrHasNestedBlocks) {\n    chunk = getBlockDividerChunk(blockType, depth, parentKey);\n    blockKey = chunk.blocks[0].key;\n    inBlock = nodeName;\n    newBlock = !experimentalTreeDataSupport;\n  }\n\n  // this is required so that we can handle 'ul' and 'ol'\n  if (inListBlock) {\n    nextBlockType = lastList === 'ul' ? 'unordered-list-item' : 'ordered-list-item';\n  }\n\n  // Recurse through children\n  var child = node.firstChild;\n  if (child != null) {\n    nodeName = child.nodeName.toLowerCase();\n  }\n\n  var entityId = null;\n\n  while (child) {\n    if (child instanceof HTMLAnchorElement && child.href && hasValidLinkText(child)) {\n      (function () {\n        var anchor = child;\n        var entityConfig = {};\n\n        anchorAttr.forEach(function (attr) {\n          var anchorAttribute = anchor.getAttribute(attr);\n          if (anchorAttribute) {\n            entityConfig[attr] = anchorAttribute;\n          }\n        });\n\n        entityConfig.url = new URI(anchor.href).toString();\n        // TODO: update this when we remove DraftEntity completely\n        entityId = DraftEntity.__create('LINK', 'MUTABLE', entityConfig || {});\n      })();\n    } else {\n      entityId = undefined;\n    }\n\n    var _genFragment = genFragment(newEntityMap, child, inlineStyle, lastList, inBlock, blockTags, depth, blockRenderMap, entityId || inEntity, experimentalTreeDataSupport ? blockKey : null),\n        generatedChunk = _genFragment.chunk,\n        maybeUpdatedEntityMap = _genFragment.entityMap;\n\n    newChunk = generatedChunk;\n    newEntityMap = maybeUpdatedEntityMap;\n\n    chunk = joinChunks(chunk, newChunk, experimentalTreeDataSupport);\n    var sibling = child.nextSibling;\n\n    // Put in a newline to break up blocks inside blocks\n    if (!parentKey && sibling && blockTags.indexOf(nodeName) >= 0 && inBlock) {\n      chunk = joinChunks(chunk, getSoftNewlineChunk());\n    }\n    if (sibling) {\n      nodeName = sibling.nodeName.toLowerCase();\n    }\n    child = sibling;\n  }\n\n  if (newBlock) {\n    chunk = joinChunks(chunk, getBlockDividerChunk(nextBlockType, depth, parentKey));\n  }\n\n  return { chunk: chunk, entityMap: newEntityMap };\n};\n\nvar getChunkForHTML = function getChunkForHTML(html, DOMBuilder, blockRenderMap, entityMap) {\n  html = html.trim().replace(REGEX_CR, '').replace(REGEX_NBSP, SPACE).replace(REGEX_CARRIAGE, '').replace(REGEX_ZWS, '');\n\n  var supportedBlockTags = getBlockMapSupportedTags(blockRenderMap);\n\n  var safeBody = DOMBuilder(html);\n  if (!safeBody) {\n    return null;\n  }\n  lastBlock = null;\n\n  // Sometimes we aren't dealing with content that contains nice semantic\n  // tags. In this case, use divs to separate everything out into paragraphs\n  // and hope for the best.\n  var workingBlocks = containsSemanticBlockMarkup(html, supportedBlockTags) ? supportedBlockTags : ['div'];\n\n  // Start with -1 block depth to offset the fact that we are passing in a fake\n  // UL block to start with.\n  var fragment = genFragment(entityMap, safeBody, OrderedSet(), 'ul', null, workingBlocks, -1, blockRenderMap);\n\n  var chunk = fragment.chunk;\n  var newEntityMap = fragment.entityMap;\n\n  // join with previous block to prevent weirdness on paste\n  if (chunk.text.indexOf('\\r') === 0) {\n    chunk = {\n      text: chunk.text.slice(1),\n      inlines: chunk.inlines.slice(1),\n      entities: chunk.entities.slice(1),\n      blocks: chunk.blocks\n    };\n  }\n\n  // Kill block delimiter at the end\n  if (chunk.text.slice(-1) === '\\r') {\n    chunk.text = chunk.text.slice(0, -1);\n    chunk.inlines = chunk.inlines.slice(0, -1);\n    chunk.entities = chunk.entities.slice(0, -1);\n    chunk.blocks.pop();\n  }\n\n  // If we saw no block tags, put an unstyled one in\n  if (chunk.blocks.length === 0) {\n    chunk.blocks.push(_extends({}, EMPTY_CHUNK, {\n      type: 'unstyled',\n      depth: 0\n    }));\n  }\n\n  // Sometimes we start with text that isn't in a block, which is then\n  // followed by blocks. Need to fix up the blocks to add in\n  // an unstyled block for this content\n  if (chunk.text.split('\\r').length === chunk.blocks.length + 1) {\n    chunk.blocks.unshift({ type: 'unstyled', depth: 0 });\n  }\n\n  return { chunk: chunk, entityMap: newEntityMap };\n};\n\nvar convertChunkToContentBlocks = function convertChunkToContentBlocks(chunk) {\n  if (!chunk || !chunk.text || !Array.isArray(chunk.blocks)) {\n    return null;\n  }\n\n  var initialState = {\n    cacheRef: {},\n    contentBlocks: []\n  };\n\n  var start = 0;\n\n  var rawBlocks = chunk.blocks,\n      rawInlines = chunk.inlines,\n      rawEntities = chunk.entities;\n\n\n  var BlockNodeRecord = experimentalTreeDataSupport ? ContentBlockNode : ContentBlock;\n\n  return chunk.text.split('\\r').reduce(function (acc, textBlock, index) {\n    // Make absolutely certain that our text is acceptable.\n    textBlock = sanitizeDraftText(textBlock);\n\n    var block = rawBlocks[index];\n    var end = start + textBlock.length;\n    var inlines = rawInlines.slice(start, end);\n    var entities = rawEntities.slice(start, end);\n    var characterList = List(inlines.map(function (style, index) {\n      var data = { style: style, entity: null };\n      if (entities[index]) {\n        data.entity = entities[index];\n      }\n      return CharacterMetadata.create(data);\n    }));\n    start = end + 1;\n\n    var depth = block.depth,\n        type = block.type,\n        parent = block.parent;\n\n\n    var key = block.key || generateRandomKey();\n    var parentTextNodeKey = null; // will be used to store container text nodes\n\n    // childrens add themselves to their parents since we are iterating in order\n    if (parent) {\n      var parentIndex = acc.cacheRef[parent];\n      var parentRecord = acc.contentBlocks[parentIndex];\n\n      // if parent has text we need to split it into a separate unstyled element\n      if (parentRecord.getChildKeys().isEmpty() && parentRecord.getText()) {\n        var parentCharacterList = parentRecord.getCharacterList();\n        var parentText = parentRecord.getText();\n        parentTextNodeKey = generateRandomKey();\n\n        var textNode = new ContentBlockNode({\n          key: parentTextNodeKey,\n          text: parentText,\n          characterList: parentCharacterList,\n          parent: parent,\n          nextSibling: key\n        });\n\n        acc.contentBlocks.push(textNode);\n\n        parentRecord = parentRecord.withMutations(function (block) {\n          block.set('characterList', List()).set('text', '').set('children', parentRecord.children.push(textNode.getKey()));\n        });\n      }\n\n      acc.contentBlocks[parentIndex] = parentRecord.set('children', parentRecord.children.push(key));\n    }\n\n    var blockNode = new BlockNodeRecord({\n      key: key,\n      parent: parent,\n      type: type,\n      depth: depth,\n      text: textBlock,\n      characterList: characterList,\n      prevSibling: parentTextNodeKey || (index === 0 || rawBlocks[index - 1].parent !== parent ? null : rawBlocks[index - 1].key),\n      nextSibling: index === rawBlocks.length - 1 || rawBlocks[index + 1].parent !== parent ? null : rawBlocks[index + 1].key\n    });\n\n    // insert node\n    acc.contentBlocks.push(blockNode);\n\n    // cache ref for building links\n    acc.cacheRef[blockNode.key] = index;\n\n    return acc;\n  }, initialState).contentBlocks;\n};\n\nvar convertFromHTMLtoContentBlocks = function convertFromHTMLtoContentBlocks(html) {\n  var DOMBuilder = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : getSafeBodyFromHTML;\n  var blockRenderMap = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DefaultDraftBlockRenderMap;\n\n  // Be ABSOLUTELY SURE that the dom builder you pass here won't execute\n  // arbitrary code in whatever environment you're running this in. For an\n  // example of how we try to do this in-browser, see getSafeBodyFromHTML.\n\n  // TODO: replace DraftEntity with an OrderedMap here\n  var chunkData = getChunkForHTML(html, DOMBuilder, blockRenderMap, DraftEntity);\n\n  if (chunkData == null) {\n    return null;\n  }\n\n  var chunk = chunkData.chunk,\n      entityMap = chunkData.entityMap;\n\n  var contentBlocks = convertChunkToContentBlocks(chunk);\n\n  return {\n    contentBlocks: contentBlocks,\n    entityMap: entityMap\n  };\n};\n\nmodule.exports = convertFromHTMLtoContentBlocks;\n\n/***/ }),\n/* 240 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getSafeBodyFromHTML\n * @format\n * \n */\n\n\n\nvar UserAgent = __webpack_require__(67);\n\nvar invariant = __webpack_require__(58);\n\nvar isOldIE = UserAgent.isBrowser('IE <= 9');\n\n// Provides a dom node that will not execute scripts\n// https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation.createHTMLDocument\n// https://developer.mozilla.org/en-US/Add-ons/Code_snippets/HTML_to_DOM\n\nfunction getSafeBodyFromHTML(html) {\n  var doc;\n  var root = null;\n  // Provides a safe context\n  if (!isOldIE && document.implementation && document.implementation.createHTMLDocument) {\n    doc = document.implementation.createHTMLDocument('foo');\n    !doc.documentElement ?  false ? invariant(false, 'Missing doc.documentElement') : invariant(false) : void 0;\n    doc.documentElement.innerHTML = html;\n    root = doc.getElementsByTagName('body')[0];\n  }\n  return root;\n}\n\nmodule.exports = getSafeBodyFromHTML;\n\n/***/ }),\n/* 241 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule RichTextEditorUtil\n * @format\n * \n */\n\n\n\nvar DraftModifier = __webpack_require__(62);\nvar EditorState = __webpack_require__(59);\nvar SelectionState = __webpack_require__(83);\n\nvar adjustBlockDepthForContentState = __webpack_require__(496);\nvar nullthrows = __webpack_require__(65);\n\nvar RichTextEditorUtil = {\n  currentBlockContainsLink: function currentBlockContainsLink(editorState) {\n    var selection = editorState.getSelection();\n    var contentState = editorState.getCurrentContent();\n    var entityMap = contentState.getEntityMap();\n    return contentState.getBlockForKey(selection.getAnchorKey()).getCharacterList().slice(selection.getStartOffset(), selection.getEndOffset()).some(function (v) {\n      var entity = v.getEntity();\n      return !!entity && entityMap.__get(entity).getType() === 'LINK';\n    });\n  },\n\n  getCurrentBlockType: function getCurrentBlockType(editorState) {\n    var selection = editorState.getSelection();\n    return editorState.getCurrentContent().getBlockForKey(selection.getStartKey()).getType();\n  },\n\n  getDataObjectForLinkURL: function getDataObjectForLinkURL(uri) {\n    return { url: uri.toString() };\n  },\n\n  handleKeyCommand: function handleKeyCommand(editorState, command) {\n    switch (command) {\n      case 'bold':\n        return RichTextEditorUtil.toggleInlineStyle(editorState, 'BOLD');\n      case 'italic':\n        return RichTextEditorUtil.toggleInlineStyle(editorState, 'ITALIC');\n      case 'underline':\n        return RichTextEditorUtil.toggleInlineStyle(editorState, 'UNDERLINE');\n      case 'code':\n        return RichTextEditorUtil.toggleCode(editorState);\n      case 'backspace':\n      case 'backspace-word':\n      case 'backspace-to-start-of-line':\n        return RichTextEditorUtil.onBackspace(editorState);\n      case 'delete':\n      case 'delete-word':\n      case 'delete-to-end-of-block':\n        return RichTextEditorUtil.onDelete(editorState);\n      default:\n        // they may have custom editor commands; ignore those\n        return null;\n    }\n  },\n\n  insertSoftNewline: function insertSoftNewline(editorState) {\n    var contentState = DraftModifier.insertText(editorState.getCurrentContent(), editorState.getSelection(), '\\n', editorState.getCurrentInlineStyle(), null);\n\n    var newEditorState = EditorState.push(editorState, contentState, 'insert-characters');\n\n    return EditorState.forceSelection(newEditorState, contentState.getSelectionAfter());\n  },\n\n  /**\n   * For collapsed selections at the start of styled blocks, backspace should\n   * just remove the existing style.\n   */\n  onBackspace: function onBackspace(editorState) {\n    var selection = editorState.getSelection();\n    if (!selection.isCollapsed() || selection.getAnchorOffset() || selection.getFocusOffset()) {\n      return null;\n    }\n\n    // First, try to remove a preceding atomic block.\n    var content = editorState.getCurrentContent();\n    var startKey = selection.getStartKey();\n    var blockBefore = content.getBlockBefore(startKey);\n\n    if (blockBefore && blockBefore.getType() === 'atomic') {\n      var blockMap = content.getBlockMap()['delete'](blockBefore.getKey());\n      var withoutAtomicBlock = content.merge({\n        blockMap: blockMap,\n        selectionAfter: selection\n      });\n      if (withoutAtomicBlock !== content) {\n        return EditorState.push(editorState, withoutAtomicBlock, 'remove-range');\n      }\n    }\n\n    // If that doesn't succeed, try to remove the current block style.\n    var withoutBlockStyle = RichTextEditorUtil.tryToRemoveBlockStyle(editorState);\n\n    if (withoutBlockStyle) {\n      return EditorState.push(editorState, withoutBlockStyle, 'change-block-type');\n    }\n\n    return null;\n  },\n\n  onDelete: function onDelete(editorState) {\n    var selection = editorState.getSelection();\n    if (!selection.isCollapsed()) {\n      return null;\n    }\n\n    var content = editorState.getCurrentContent();\n    var startKey = selection.getStartKey();\n    var block = content.getBlockForKey(startKey);\n    var length = block.getLength();\n\n    // The cursor is somewhere within the text. Behave normally.\n    if (selection.getStartOffset() < length) {\n      return null;\n    }\n\n    var blockAfter = content.getBlockAfter(startKey);\n\n    if (!blockAfter || blockAfter.getType() !== 'atomic') {\n      return null;\n    }\n\n    var atomicBlockTarget = selection.merge({\n      focusKey: blockAfter.getKey(),\n      focusOffset: blockAfter.getLength()\n    });\n\n    var withoutAtomicBlock = DraftModifier.removeRange(content, atomicBlockTarget, 'forward');\n\n    if (withoutAtomicBlock !== content) {\n      return EditorState.push(editorState, withoutAtomicBlock, 'remove-range');\n    }\n\n    return null;\n  },\n\n  onTab: function onTab(event, editorState, maxDepth) {\n    var selection = editorState.getSelection();\n    var key = selection.getAnchorKey();\n    if (key !== selection.getFocusKey()) {\n      return editorState;\n    }\n\n    var content = editorState.getCurrentContent();\n    var block = content.getBlockForKey(key);\n    var type = block.getType();\n    if (type !== 'unordered-list-item' && type !== 'ordered-list-item') {\n      return editorState;\n    }\n\n    event.preventDefault();\n\n    // Only allow indenting one level beyond the block above, and only if\n    // the block above is a list item as well.\n    var blockAbove = content.getBlockBefore(key);\n    if (!blockAbove) {\n      return editorState;\n    }\n\n    var typeAbove = blockAbove.getType();\n    if (typeAbove !== 'unordered-list-item' && typeAbove !== 'ordered-list-item') {\n      return editorState;\n    }\n\n    var depth = block.getDepth();\n    if (!event.shiftKey && depth === maxDepth) {\n      return editorState;\n    }\n\n    maxDepth = Math.min(blockAbove.getDepth() + 1, maxDepth);\n\n    var withAdjustment = adjustBlockDepthForContentState(content, selection, event.shiftKey ? -1 : 1, maxDepth);\n\n    return EditorState.push(editorState, withAdjustment, 'adjust-depth');\n  },\n\n  toggleBlockType: function toggleBlockType(editorState, blockType) {\n    var selection = editorState.getSelection();\n    var startKey = selection.getStartKey();\n    var endKey = selection.getEndKey();\n    var content = editorState.getCurrentContent();\n    var target = selection;\n\n    // Triple-click can lead to a selection that includes offset 0 of the\n    // following block. The `SelectionState` for this case is accurate, but\n    // we should avoid toggling block type for the trailing block because it\n    // is a confusing interaction.\n    if (startKey !== endKey && selection.getEndOffset() === 0) {\n      var blockBefore = nullthrows(content.getBlockBefore(endKey));\n      endKey = blockBefore.getKey();\n      target = target.merge({\n        anchorKey: startKey,\n        anchorOffset: selection.getStartOffset(),\n        focusKey: endKey,\n        focusOffset: blockBefore.getLength(),\n        isBackward: false\n      });\n    }\n\n    var hasAtomicBlock = content.getBlockMap().skipWhile(function (_, k) {\n      return k !== startKey;\n    }).reverse().skipWhile(function (_, k) {\n      return k !== endKey;\n    }).some(function (v) {\n      return v.getType() === 'atomic';\n    });\n\n    if (hasAtomicBlock) {\n      return editorState;\n    }\n\n    var typeToSet = content.getBlockForKey(startKey).getType() === blockType ? 'unstyled' : blockType;\n\n    return EditorState.push(editorState, DraftModifier.setBlockType(content, target, typeToSet), 'change-block-type');\n  },\n\n  toggleCode: function toggleCode(editorState) {\n    var selection = editorState.getSelection();\n    var anchorKey = selection.getAnchorKey();\n    var focusKey = selection.getFocusKey();\n\n    if (selection.isCollapsed() || anchorKey !== focusKey) {\n      return RichTextEditorUtil.toggleBlockType(editorState, 'code-block');\n    }\n\n    return RichTextEditorUtil.toggleInlineStyle(editorState, 'CODE');\n  },\n\n  /**\n   * Toggle the specified inline style for the selection. If the\n   * user's selection is collapsed, apply or remove the style for the\n   * internal state. If it is not collapsed, apply the change directly\n   * to the document state.\n   */\n  toggleInlineStyle: function toggleInlineStyle(editorState, inlineStyle) {\n    var selection = editorState.getSelection();\n    var currentStyle = editorState.getCurrentInlineStyle();\n\n    // If the selection is collapsed, toggle the specified style on or off and\n    // set the result as the new inline style override. This will then be\n    // used as the inline style for the next character to be inserted.\n    if (selection.isCollapsed()) {\n      return EditorState.setInlineStyleOverride(editorState, currentStyle.has(inlineStyle) ? currentStyle.remove(inlineStyle) : currentStyle.add(inlineStyle));\n    }\n\n    // If characters are selected, immediately apply or remove the\n    // inline style on the document state itself.\n    var content = editorState.getCurrentContent();\n    var newContent;\n\n    // If the style is already present for the selection range, remove it.\n    // Otherwise, apply it.\n    if (currentStyle.has(inlineStyle)) {\n      newContent = DraftModifier.removeInlineStyle(content, selection, inlineStyle);\n    } else {\n      newContent = DraftModifier.applyInlineStyle(content, selection, inlineStyle);\n    }\n\n    return EditorState.push(editorState, newContent, 'change-inline-style');\n  },\n\n  toggleLink: function toggleLink(editorState, targetSelection, entityKey) {\n    var withoutLink = DraftModifier.applyEntity(editorState.getCurrentContent(), targetSelection, entityKey);\n\n    return EditorState.push(editorState, withoutLink, 'apply-entity');\n  },\n\n  /**\n   * When a collapsed cursor is at the start of the first styled block, or\n   * an empty styled block, changes block to 'unstyled'. Returns null if\n   * block or selection does not meet that criteria.\n   */\n  tryToRemoveBlockStyle: function tryToRemoveBlockStyle(editorState) {\n    var selection = editorState.getSelection();\n    var offset = selection.getAnchorOffset();\n    if (selection.isCollapsed() && offset === 0) {\n      var key = selection.getAnchorKey();\n      var content = editorState.getCurrentContent();\n      var block = content.getBlockForKey(key);\n\n      var firstBlock = content.getFirstBlock();\n      if (block.getLength() > 0 && block !== firstBlock) {\n        return null;\n      }\n\n      var type = block.getType();\n      var blockBefore = content.getBlockBefore(key);\n      if (type === 'code-block' && blockBefore && blockBefore.getType() === 'code-block' && blockBefore.getLength() !== 0) {\n        return null;\n      }\n\n      if (type !== 'unstyled') {\n        return DraftModifier.setBlockType(content, selection, 'unstyled');\n      }\n    }\n    return null;\n  }\n};\n\nmodule.exports = RichTextEditorUtil;\n\n/***/ }),\n/* 242 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getDefaultKeyBinding\n * @format\n * \n */\n\n\n\nvar KeyBindingUtil = __webpack_require__(167);\nvar Keys = __webpack_require__(161);\nvar UserAgent = __webpack_require__(67);\n\nvar isOSX = UserAgent.isPlatform('Mac OS X');\nvar isWindows = UserAgent.isPlatform('Windows');\n\n// Firefox on OSX had a bug resulting in navigation instead of cursor movement.\n// This bug was fixed in Firefox 29. Feature detection is virtually impossible\n// so we just check the version number. See #342765.\nvar shouldFixFirefoxMovement = isOSX && UserAgent.isBrowser('Firefox < 29');\n\nvar hasCommandModifier = KeyBindingUtil.hasCommandModifier,\n    isCtrlKeyCommand = KeyBindingUtil.isCtrlKeyCommand;\n\n\nfunction shouldRemoveWord(e) {\n  return isOSX && e.altKey || isCtrlKeyCommand(e);\n}\n\n/**\n * Get the appropriate undo/redo command for a Z key command.\n */\nfunction getZCommand(e) {\n  if (!hasCommandModifier(e)) {\n    return null;\n  }\n  return e.shiftKey ? 'redo' : 'undo';\n}\n\nfunction getDeleteCommand(e) {\n  // Allow default \"cut\" behavior for Windows on Shift + Delete.\n  if (isWindows && e.shiftKey) {\n    return null;\n  }\n  return shouldRemoveWord(e) ? 'delete-word' : 'delete';\n}\n\nfunction getBackspaceCommand(e) {\n  if (hasCommandModifier(e) && isOSX) {\n    return 'backspace-to-start-of-line';\n  }\n  return shouldRemoveWord(e) ? 'backspace-word' : 'backspace';\n}\n\n/**\n * Retrieve a bound key command for the given event.\n */\nfunction getDefaultKeyBinding(e) {\n  switch (e.keyCode) {\n    case 66:\n      // B\n      return hasCommandModifier(e) ? 'bold' : null;\n    case 68:\n      // D\n      return isCtrlKeyCommand(e) ? 'delete' : null;\n    case 72:\n      // H\n      return isCtrlKeyCommand(e) ? 'backspace' : null;\n    case 73:\n      // I\n      return hasCommandModifier(e) ? 'italic' : null;\n    case 74:\n      // J\n      return hasCommandModifier(e) ? 'code' : null;\n    case 75:\n      // K\n      return !isWindows && isCtrlKeyCommand(e) ? 'secondary-cut' : null;\n    case 77:\n      // M\n      return isCtrlKeyCommand(e) ? 'split-block' : null;\n    case 79:\n      // O\n      return isCtrlKeyCommand(e) ? 'split-block' : null;\n    case 84:\n      // T\n      return isOSX && isCtrlKeyCommand(e) ? 'transpose-characters' : null;\n    case 85:\n      // U\n      return hasCommandModifier(e) ? 'underline' : null;\n    case 87:\n      // W\n      return isOSX && isCtrlKeyCommand(e) ? 'backspace-word' : null;\n    case 89:\n      // Y\n      if (isCtrlKeyCommand(e)) {\n        return isWindows ? 'redo' : 'secondary-paste';\n      }\n      return null;\n    case 90:\n      // Z\n      return getZCommand(e) || null;\n    case Keys.RETURN:\n      return 'split-block';\n    case Keys.DELETE:\n      return getDeleteCommand(e);\n    case Keys.BACKSPACE:\n      return getBackspaceCommand(e);\n    // LEFT/RIGHT handlers serve as a workaround for a Firefox bug.\n    case Keys.LEFT:\n      return shouldFixFirefoxMovement && hasCommandModifier(e) ? 'move-selection-to-start-of-block' : null;\n    case Keys.RIGHT:\n      return shouldFixFirefoxMovement && hasCommandModifier(e) ? 'move-selection-to-end-of-block' : null;\n    default:\n      return null;\n  }\n}\n\nmodule.exports = getDefaultKeyBinding;\n\n/***/ }),\n/* 243 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftStringKey\n * @format\n * \n */\n\n\n\nvar DraftStringKey = {\n  stringify: function stringify(key) {\n    return '_' + String(key);\n  },\n\n  unstringify: function unstringify(key) {\n    return key.slice(1);\n  }\n};\n\nmodule.exports = DraftStringKey;\n\n/***/ }),\n/* 244 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n(function (global, factory) {\n   true ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global.Immutable = factory());\n}(this, function () { 'use strict';var SLICE$0 = Array.prototype.slice;\n\n  function createClass(ctor, superClass) {\n    if (superClass) {\n      ctor.prototype = Object.create(superClass.prototype);\n    }\n    ctor.prototype.constructor = ctor;\n  }\n\n  function Iterable(value) {\n      return isIterable(value) ? value : Seq(value);\n    }\n\n\n  createClass(KeyedIterable, Iterable);\n    function KeyedIterable(value) {\n      return isKeyed(value) ? value : KeyedSeq(value);\n    }\n\n\n  createClass(IndexedIterable, Iterable);\n    function IndexedIterable(value) {\n      return isIndexed(value) ? value : IndexedSeq(value);\n    }\n\n\n  createClass(SetIterable, Iterable);\n    function SetIterable(value) {\n      return isIterable(value) && !isAssociative(value) ? value : SetSeq(value);\n    }\n\n\n\n  function isIterable(maybeIterable) {\n    return !!(maybeIterable && maybeIterable[IS_ITERABLE_SENTINEL]);\n  }\n\n  function isKeyed(maybeKeyed) {\n    return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL]);\n  }\n\n  function isIndexed(maybeIndexed) {\n    return !!(maybeIndexed && maybeIndexed[IS_INDEXED_SENTINEL]);\n  }\n\n  function isAssociative(maybeAssociative) {\n    return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);\n  }\n\n  function isOrdered(maybeOrdered) {\n    return !!(maybeOrdered && maybeOrdered[IS_ORDERED_SENTINEL]);\n  }\n\n  Iterable.isIterable = isIterable;\n  Iterable.isKeyed = isKeyed;\n  Iterable.isIndexed = isIndexed;\n  Iterable.isAssociative = isAssociative;\n  Iterable.isOrdered = isOrdered;\n\n  Iterable.Keyed = KeyedIterable;\n  Iterable.Indexed = IndexedIterable;\n  Iterable.Set = SetIterable;\n\n\n  var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';\n  var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';\n  var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';\n  var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';\n\n  // Used for setting prototype methods that IE8 chokes on.\n  var DELETE = 'delete';\n\n  // Constants describing the size of trie nodes.\n  var SHIFT = 5; // Resulted in best performance after ______?\n  var SIZE = 1 << SHIFT;\n  var MASK = SIZE - 1;\n\n  // A consistent shared value representing \"not set\" which equals nothing other\n  // than itself, and nothing that could be provided externally.\n  var NOT_SET = {};\n\n  // Boolean references, Rough equivalent of `bool &`.\n  var CHANGE_LENGTH = { value: false };\n  var DID_ALTER = { value: false };\n\n  function MakeRef(ref) {\n    ref.value = false;\n    return ref;\n  }\n\n  function SetRef(ref) {\n    ref && (ref.value = true);\n  }\n\n  // A function which returns a value representing an \"owner\" for transient writes\n  // to tries. The return value will only ever equal itself, and will not equal\n  // the return of any subsequent call of this function.\n  function OwnerID() {}\n\n  // http://jsperf.com/copy-array-inline\n  function arrCopy(arr, offset) {\n    offset = offset || 0;\n    var len = Math.max(0, arr.length - offset);\n    var newArr = new Array(len);\n    for (var ii = 0; ii < len; ii++) {\n      newArr[ii] = arr[ii + offset];\n    }\n    return newArr;\n  }\n\n  function ensureSize(iter) {\n    if (iter.size === undefined) {\n      iter.size = iter.__iterate(returnTrue);\n    }\n    return iter.size;\n  }\n\n  function wrapIndex(iter, index) {\n    // This implements \"is array index\" which the ECMAString spec defines as:\n    //\n    //     A String property name P is an array index if and only if\n    //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal\n    //     to 2^32−1.\n    //\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects\n    if (typeof index !== 'number') {\n      var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32\n      if ('' + uint32Index !== index || uint32Index === 4294967295) {\n        return NaN;\n      }\n      index = uint32Index;\n    }\n    return index < 0 ? ensureSize(iter) + index : index;\n  }\n\n  function returnTrue() {\n    return true;\n  }\n\n  function wholeSlice(begin, end, size) {\n    return (begin === 0 || (size !== undefined && begin <= -size)) &&\n      (end === undefined || (size !== undefined && end >= size));\n  }\n\n  function resolveBegin(begin, size) {\n    return resolveIndex(begin, size, 0);\n  }\n\n  function resolveEnd(end, size) {\n    return resolveIndex(end, size, size);\n  }\n\n  function resolveIndex(index, size, defaultIndex) {\n    return index === undefined ?\n      defaultIndex :\n      index < 0 ?\n        Math.max(0, size + index) :\n        size === undefined ?\n          index :\n          Math.min(size, index);\n  }\n\n  /* global Symbol */\n\n  var ITERATE_KEYS = 0;\n  var ITERATE_VALUES = 1;\n  var ITERATE_ENTRIES = 2;\n\n  var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n  var FAUX_ITERATOR_SYMBOL = '@@iterator';\n\n  var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;\n\n\n  function Iterator(next) {\n      this.next = next;\n    }\n\n    Iterator.prototype.toString = function() {\n      return '[Iterator]';\n    };\n\n\n  Iterator.KEYS = ITERATE_KEYS;\n  Iterator.VALUES = ITERATE_VALUES;\n  Iterator.ENTRIES = ITERATE_ENTRIES;\n\n  Iterator.prototype.inspect =\n  Iterator.prototype.toSource = function () { return this.toString(); }\n  Iterator.prototype[ITERATOR_SYMBOL] = function () {\n    return this;\n  };\n\n\n  function iteratorValue(type, k, v, iteratorResult) {\n    var value = type === 0 ? k : type === 1 ? v : [k, v];\n    iteratorResult ? (iteratorResult.value = value) : (iteratorResult = {\n      value: value, done: false\n    });\n    return iteratorResult;\n  }\n\n  function iteratorDone() {\n    return { value: undefined, done: true };\n  }\n\n  function hasIterator(maybeIterable) {\n    return !!getIteratorFn(maybeIterable);\n  }\n\n  function isIterator(maybeIterator) {\n    return maybeIterator && typeof maybeIterator.next === 'function';\n  }\n\n  function getIterator(iterable) {\n    var iteratorFn = getIteratorFn(iterable);\n    return iteratorFn && iteratorFn.call(iterable);\n  }\n\n  function getIteratorFn(iterable) {\n    var iteratorFn = iterable && (\n      (REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||\n      iterable[FAUX_ITERATOR_SYMBOL]\n    );\n    if (typeof iteratorFn === 'function') {\n      return iteratorFn;\n    }\n  }\n\n  function isArrayLike(value) {\n    return value && typeof value.length === 'number';\n  }\n\n  createClass(Seq, Iterable);\n    function Seq(value) {\n      return value === null || value === undefined ? emptySequence() :\n        isIterable(value) ? value.toSeq() : seqFromValue(value);\n    }\n\n    Seq.of = function(/*...values*/) {\n      return Seq(arguments);\n    };\n\n    Seq.prototype.toSeq = function() {\n      return this;\n    };\n\n    Seq.prototype.toString = function() {\n      return this.__toString('Seq {', '}');\n    };\n\n    Seq.prototype.cacheResult = function() {\n      if (!this._cache && this.__iterateUncached) {\n        this._cache = this.entrySeq().toArray();\n        this.size = this._cache.length;\n      }\n      return this;\n    };\n\n    // abstract __iterateUncached(fn, reverse)\n\n    Seq.prototype.__iterate = function(fn, reverse) {\n      return seqIterate(this, fn, reverse, true);\n    };\n\n    // abstract __iteratorUncached(type, reverse)\n\n    Seq.prototype.__iterator = function(type, reverse) {\n      return seqIterator(this, type, reverse, true);\n    };\n\n\n\n  createClass(KeyedSeq, Seq);\n    function KeyedSeq(value) {\n      return value === null || value === undefined ?\n        emptySequence().toKeyedSeq() :\n        isIterable(value) ?\n          (isKeyed(value) ? value.toSeq() : value.fromEntrySeq()) :\n          keyedSeqFromValue(value);\n    }\n\n    KeyedSeq.prototype.toKeyedSeq = function() {\n      return this;\n    };\n\n\n\n  createClass(IndexedSeq, Seq);\n    function IndexedSeq(value) {\n      return value === null || value === undefined ? emptySequence() :\n        !isIterable(value) ? indexedSeqFromValue(value) :\n        isKeyed(value) ? value.entrySeq() : value.toIndexedSeq();\n    }\n\n    IndexedSeq.of = function(/*...values*/) {\n      return IndexedSeq(arguments);\n    };\n\n    IndexedSeq.prototype.toIndexedSeq = function() {\n      return this;\n    };\n\n    IndexedSeq.prototype.toString = function() {\n      return this.__toString('Seq [', ']');\n    };\n\n    IndexedSeq.prototype.__iterate = function(fn, reverse) {\n      return seqIterate(this, fn, reverse, false);\n    };\n\n    IndexedSeq.prototype.__iterator = function(type, reverse) {\n      return seqIterator(this, type, reverse, false);\n    };\n\n\n\n  createClass(SetSeq, Seq);\n    function SetSeq(value) {\n      return (\n        value === null || value === undefined ? emptySequence() :\n        !isIterable(value) ? indexedSeqFromValue(value) :\n        isKeyed(value) ? value.entrySeq() : value\n      ).toSetSeq();\n    }\n\n    SetSeq.of = function(/*...values*/) {\n      return SetSeq(arguments);\n    };\n\n    SetSeq.prototype.toSetSeq = function() {\n      return this;\n    };\n\n\n\n  Seq.isSeq = isSeq;\n  Seq.Keyed = KeyedSeq;\n  Seq.Set = SetSeq;\n  Seq.Indexed = IndexedSeq;\n\n  var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';\n\n  Seq.prototype[IS_SEQ_SENTINEL] = true;\n\n\n\n  createClass(ArraySeq, IndexedSeq);\n    function ArraySeq(array) {\n      this._array = array;\n      this.size = array.length;\n    }\n\n    ArraySeq.prototype.get = function(index, notSetValue) {\n      return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue;\n    };\n\n    ArraySeq.prototype.__iterate = function(fn, reverse) {\n      var array = this._array;\n      var maxIndex = array.length - 1;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        if (fn(array[reverse ? maxIndex - ii : ii], ii, this) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    };\n\n    ArraySeq.prototype.__iterator = function(type, reverse) {\n      var array = this._array;\n      var maxIndex = array.length - 1;\n      var ii = 0;\n      return new Iterator(function() \n        {return ii > maxIndex ?\n          iteratorDone() :\n          iteratorValue(type, ii, array[reverse ? maxIndex - ii++ : ii++])}\n      );\n    };\n\n\n\n  createClass(ObjectSeq, KeyedSeq);\n    function ObjectSeq(object) {\n      var keys = Object.keys(object);\n      this._object = object;\n      this._keys = keys;\n      this.size = keys.length;\n    }\n\n    ObjectSeq.prototype.get = function(key, notSetValue) {\n      if (notSetValue !== undefined && !this.has(key)) {\n        return notSetValue;\n      }\n      return this._object[key];\n    };\n\n    ObjectSeq.prototype.has = function(key) {\n      return this._object.hasOwnProperty(key);\n    };\n\n    ObjectSeq.prototype.__iterate = function(fn, reverse) {\n      var object = this._object;\n      var keys = this._keys;\n      var maxIndex = keys.length - 1;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        var key = keys[reverse ? maxIndex - ii : ii];\n        if (fn(object[key], key, this) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    };\n\n    ObjectSeq.prototype.__iterator = function(type, reverse) {\n      var object = this._object;\n      var keys = this._keys;\n      var maxIndex = keys.length - 1;\n      var ii = 0;\n      return new Iterator(function()  {\n        var key = keys[reverse ? maxIndex - ii : ii];\n        return ii++ > maxIndex ?\n          iteratorDone() :\n          iteratorValue(type, key, object[key]);\n      });\n    };\n\n  ObjectSeq.prototype[IS_ORDERED_SENTINEL] = true;\n\n\n  createClass(IterableSeq, IndexedSeq);\n    function IterableSeq(iterable) {\n      this._iterable = iterable;\n      this.size = iterable.length || iterable.size;\n    }\n\n    IterableSeq.prototype.__iterateUncached = function(fn, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterable = this._iterable;\n      var iterator = getIterator(iterable);\n      var iterations = 0;\n      if (isIterator(iterator)) {\n        var step;\n        while (!(step = iterator.next()).done) {\n          if (fn(step.value, iterations++, this) === false) {\n            break;\n          }\n        }\n      }\n      return iterations;\n    };\n\n    IterableSeq.prototype.__iteratorUncached = function(type, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterable = this._iterable;\n      var iterator = getIterator(iterable);\n      if (!isIterator(iterator)) {\n        return new Iterator(iteratorDone);\n      }\n      var iterations = 0;\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step : iteratorValue(type, iterations++, step.value);\n      });\n    };\n\n\n\n  createClass(IteratorSeq, IndexedSeq);\n    function IteratorSeq(iterator) {\n      this._iterator = iterator;\n      this._iteratorCache = [];\n    }\n\n    IteratorSeq.prototype.__iterateUncached = function(fn, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterator = this._iterator;\n      var cache = this._iteratorCache;\n      var iterations = 0;\n      while (iterations < cache.length) {\n        if (fn(cache[iterations], iterations++, this) === false) {\n          return iterations;\n        }\n      }\n      var step;\n      while (!(step = iterator.next()).done) {\n        var val = step.value;\n        cache[iterations] = val;\n        if (fn(val, iterations++, this) === false) {\n          break;\n        }\n      }\n      return iterations;\n    };\n\n    IteratorSeq.prototype.__iteratorUncached = function(type, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = this._iterator;\n      var cache = this._iteratorCache;\n      var iterations = 0;\n      return new Iterator(function()  {\n        if (iterations >= cache.length) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          cache[iterations] = step.value;\n        }\n        return iteratorValue(type, iterations, cache[iterations++]);\n      });\n    };\n\n\n\n\n  // # pragma Helper functions\n\n  function isSeq(maybeSeq) {\n    return !!(maybeSeq && maybeSeq[IS_SEQ_SENTINEL]);\n  }\n\n  var EMPTY_SEQ;\n\n  function emptySequence() {\n    return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));\n  }\n\n  function keyedSeqFromValue(value) {\n    var seq =\n      Array.isArray(value) ? new ArraySeq(value).fromEntrySeq() :\n      isIterator(value) ? new IteratorSeq(value).fromEntrySeq() :\n      hasIterator(value) ? new IterableSeq(value).fromEntrySeq() :\n      typeof value === 'object' ? new ObjectSeq(value) :\n      undefined;\n    if (!seq) {\n      throw new TypeError(\n        'Expected Array or iterable object of [k, v] entries, '+\n        'or keyed object: ' + value\n      );\n    }\n    return seq;\n  }\n\n  function indexedSeqFromValue(value) {\n    var seq = maybeIndexedSeqFromValue(value);\n    if (!seq) {\n      throw new TypeError(\n        'Expected Array or iterable object of values: ' + value\n      );\n    }\n    return seq;\n  }\n\n  function seqFromValue(value) {\n    var seq = maybeIndexedSeqFromValue(value) ||\n      (typeof value === 'object' && new ObjectSeq(value));\n    if (!seq) {\n      throw new TypeError(\n        'Expected Array or iterable object of values, or keyed object: ' + value\n      );\n    }\n    return seq;\n  }\n\n  function maybeIndexedSeqFromValue(value) {\n    return (\n      isArrayLike(value) ? new ArraySeq(value) :\n      isIterator(value) ? new IteratorSeq(value) :\n      hasIterator(value) ? new IterableSeq(value) :\n      undefined\n    );\n  }\n\n  function seqIterate(seq, fn, reverse, useKeys) {\n    var cache = seq._cache;\n    if (cache) {\n      var maxIndex = cache.length - 1;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        var entry = cache[reverse ? maxIndex - ii : ii];\n        if (fn(entry[1], useKeys ? entry[0] : ii, seq) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    }\n    return seq.__iterateUncached(fn, reverse);\n  }\n\n  function seqIterator(seq, type, reverse, useKeys) {\n    var cache = seq._cache;\n    if (cache) {\n      var maxIndex = cache.length - 1;\n      var ii = 0;\n      return new Iterator(function()  {\n        var entry = cache[reverse ? maxIndex - ii : ii];\n        return ii++ > maxIndex ?\n          iteratorDone() :\n          iteratorValue(type, useKeys ? entry[0] : ii - 1, entry[1]);\n      });\n    }\n    return seq.__iteratorUncached(type, reverse);\n  }\n\n  function fromJS(json, converter) {\n    return converter ?\n      fromJSWith(converter, json, '', {'': json}) :\n      fromJSDefault(json);\n  }\n\n  function fromJSWith(converter, json, key, parentJSON) {\n    if (Array.isArray(json)) {\n      return converter.call(parentJSON, key, IndexedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));\n    }\n    if (isPlainObj(json)) {\n      return converter.call(parentJSON, key, KeyedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));\n    }\n    return json;\n  }\n\n  function fromJSDefault(json) {\n    if (Array.isArray(json)) {\n      return IndexedSeq(json).map(fromJSDefault).toList();\n    }\n    if (isPlainObj(json)) {\n      return KeyedSeq(json).map(fromJSDefault).toMap();\n    }\n    return json;\n  }\n\n  function isPlainObj(value) {\n    return value && (value.constructor === Object || value.constructor === undefined);\n  }\n\n  /**\n   * An extension of the \"same-value\" algorithm as [described for use by ES6 Map\n   * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)\n   *\n   * NaN is considered the same as NaN, however -0 and 0 are considered the same\n   * value, which is different from the algorithm described by\n   * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).\n   *\n   * This is extended further to allow Objects to describe the values they\n   * represent, by way of `valueOf` or `equals` (and `hashCode`).\n   *\n   * Note: because of this extension, the key equality of Immutable.Map and the\n   * value equality of Immutable.Set will differ from ES6 Map and Set.\n   *\n   * ### Defining custom values\n   *\n   * The easiest way to describe the value an object represents is by implementing\n   * `valueOf`. For example, `Date` represents a value by returning a unix\n   * timestamp for `valueOf`:\n   *\n   *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...\n   *     var date2 = new Date(1234567890000);\n   *     date1.valueOf(); // 1234567890000\n   *     assert( date1 !== date2 );\n   *     assert( Immutable.is( date1, date2 ) );\n   *\n   * Note: overriding `valueOf` may have other implications if you use this object\n   * where JavaScript expects a primitive, such as implicit string coercion.\n   *\n   * For more complex types, especially collections, implementing `valueOf` may\n   * not be performant. An alternative is to implement `equals` and `hashCode`.\n   *\n   * `equals` takes another object, presumably of similar type, and returns true\n   * if the it is equal. Equality is symmetrical, so the same result should be\n   * returned if this and the argument are flipped.\n   *\n   *     assert( a.equals(b) === b.equals(a) );\n   *\n   * `hashCode` returns a 32bit integer number representing the object which will\n   * be used to determine how to store the value object in a Map or Set. You must\n   * provide both or neither methods, one must not exist without the other.\n   *\n   * Also, an important relationship between these methods must be upheld: if two\n   * values are equal, they *must* return the same hashCode. If the values are not\n   * equal, they might have the same hashCode; this is called a hash collision,\n   * and while undesirable for performance reasons, it is acceptable.\n   *\n   *     if (a.equals(b)) {\n   *       assert( a.hashCode() === b.hashCode() );\n   *     }\n   *\n   * All Immutable collections implement `equals` and `hashCode`.\n   *\n   */\n  function is(valueA, valueB) {\n    if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n      return true;\n    }\n    if (!valueA || !valueB) {\n      return false;\n    }\n    if (typeof valueA.valueOf === 'function' &&\n        typeof valueB.valueOf === 'function') {\n      valueA = valueA.valueOf();\n      valueB = valueB.valueOf();\n      if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n        return true;\n      }\n      if (!valueA || !valueB) {\n        return false;\n      }\n    }\n    if (typeof valueA.equals === 'function' &&\n        typeof valueB.equals === 'function' &&\n        valueA.equals(valueB)) {\n      return true;\n    }\n    return false;\n  }\n\n  function deepEqual(a, b) {\n    if (a === b) {\n      return true;\n    }\n\n    if (\n      !isIterable(b) ||\n      a.size !== undefined && b.size !== undefined && a.size !== b.size ||\n      a.__hash !== undefined && b.__hash !== undefined && a.__hash !== b.__hash ||\n      isKeyed(a) !== isKeyed(b) ||\n      isIndexed(a) !== isIndexed(b) ||\n      isOrdered(a) !== isOrdered(b)\n    ) {\n      return false;\n    }\n\n    if (a.size === 0 && b.size === 0) {\n      return true;\n    }\n\n    var notAssociative = !isAssociative(a);\n\n    if (isOrdered(a)) {\n      var entries = a.entries();\n      return b.every(function(v, k)  {\n        var entry = entries.next().value;\n        return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));\n      }) && entries.next().done;\n    }\n\n    var flipped = false;\n\n    if (a.size === undefined) {\n      if (b.size === undefined) {\n        if (typeof a.cacheResult === 'function') {\n          a.cacheResult();\n        }\n      } else {\n        flipped = true;\n        var _ = a;\n        a = b;\n        b = _;\n      }\n    }\n\n    var allEqual = true;\n    var bSize = b.__iterate(function(v, k)  {\n      if (notAssociative ? !a.has(v) :\n          flipped ? !is(v, a.get(k, NOT_SET)) : !is(a.get(k, NOT_SET), v)) {\n        allEqual = false;\n        return false;\n      }\n    });\n\n    return allEqual && a.size === bSize;\n  }\n\n  createClass(Repeat, IndexedSeq);\n\n    function Repeat(value, times) {\n      if (!(this instanceof Repeat)) {\n        return new Repeat(value, times);\n      }\n      this._value = value;\n      this.size = times === undefined ? Infinity : Math.max(0, times);\n      if (this.size === 0) {\n        if (EMPTY_REPEAT) {\n          return EMPTY_REPEAT;\n        }\n        EMPTY_REPEAT = this;\n      }\n    }\n\n    Repeat.prototype.toString = function() {\n      if (this.size === 0) {\n        return 'Repeat []';\n      }\n      return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]';\n    };\n\n    Repeat.prototype.get = function(index, notSetValue) {\n      return this.has(index) ? this._value : notSetValue;\n    };\n\n    Repeat.prototype.includes = function(searchValue) {\n      return is(this._value, searchValue);\n    };\n\n    Repeat.prototype.slice = function(begin, end) {\n      var size = this.size;\n      return wholeSlice(begin, end, size) ? this :\n        new Repeat(this._value, resolveEnd(end, size) - resolveBegin(begin, size));\n    };\n\n    Repeat.prototype.reverse = function() {\n      return this;\n    };\n\n    Repeat.prototype.indexOf = function(searchValue) {\n      if (is(this._value, searchValue)) {\n        return 0;\n      }\n      return -1;\n    };\n\n    Repeat.prototype.lastIndexOf = function(searchValue) {\n      if (is(this._value, searchValue)) {\n        return this.size;\n      }\n      return -1;\n    };\n\n    Repeat.prototype.__iterate = function(fn, reverse) {\n      for (var ii = 0; ii < this.size; ii++) {\n        if (fn(this._value, ii, this) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    };\n\n    Repeat.prototype.__iterator = function(type, reverse) {var this$0 = this;\n      var ii = 0;\n      return new Iterator(function() \n        {return ii < this$0.size ? iteratorValue(type, ii++, this$0._value) : iteratorDone()}\n      );\n    };\n\n    Repeat.prototype.equals = function(other) {\n      return other instanceof Repeat ?\n        is(this._value, other._value) :\n        deepEqual(other);\n    };\n\n\n  var EMPTY_REPEAT;\n\n  function invariant(condition, error) {\n    if (!condition) throw new Error(error);\n  }\n\n  createClass(Range, IndexedSeq);\n\n    function Range(start, end, step) {\n      if (!(this instanceof Range)) {\n        return new Range(start, end, step);\n      }\n      invariant(step !== 0, 'Cannot step a Range by 0');\n      start = start || 0;\n      if (end === undefined) {\n        end = Infinity;\n      }\n      step = step === undefined ? 1 : Math.abs(step);\n      if (end < start) {\n        step = -step;\n      }\n      this._start = start;\n      this._end = end;\n      this._step = step;\n      this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);\n      if (this.size === 0) {\n        if (EMPTY_RANGE) {\n          return EMPTY_RANGE;\n        }\n        EMPTY_RANGE = this;\n      }\n    }\n\n    Range.prototype.toString = function() {\n      if (this.size === 0) {\n        return 'Range []';\n      }\n      return 'Range [ ' +\n        this._start + '...' + this._end +\n        (this._step !== 1 ? ' by ' + this._step : '') +\n      ' ]';\n    };\n\n    Range.prototype.get = function(index, notSetValue) {\n      return this.has(index) ?\n        this._start + wrapIndex(this, index) * this._step :\n        notSetValue;\n    };\n\n    Range.prototype.includes = function(searchValue) {\n      var possibleIndex = (searchValue - this._start) / this._step;\n      return possibleIndex >= 0 &&\n        possibleIndex < this.size &&\n        possibleIndex === Math.floor(possibleIndex);\n    };\n\n    Range.prototype.slice = function(begin, end) {\n      if (wholeSlice(begin, end, this.size)) {\n        return this;\n      }\n      begin = resolveBegin(begin, this.size);\n      end = resolveEnd(end, this.size);\n      if (end <= begin) {\n        return new Range(0, 0);\n      }\n      return new Range(this.get(begin, this._end), this.get(end, this._end), this._step);\n    };\n\n    Range.prototype.indexOf = function(searchValue) {\n      var offsetValue = searchValue - this._start;\n      if (offsetValue % this._step === 0) {\n        var index = offsetValue / this._step;\n        if (index >= 0 && index < this.size) {\n          return index\n        }\n      }\n      return -1;\n    };\n\n    Range.prototype.lastIndexOf = function(searchValue) {\n      return this.indexOf(searchValue);\n    };\n\n    Range.prototype.__iterate = function(fn, reverse) {\n      var maxIndex = this.size - 1;\n      var step = this._step;\n      var value = reverse ? this._start + maxIndex * step : this._start;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        if (fn(value, ii, this) === false) {\n          return ii + 1;\n        }\n        value += reverse ? -step : step;\n      }\n      return ii;\n    };\n\n    Range.prototype.__iterator = function(type, reverse) {\n      var maxIndex = this.size - 1;\n      var step = this._step;\n      var value = reverse ? this._start + maxIndex * step : this._start;\n      var ii = 0;\n      return new Iterator(function()  {\n        var v = value;\n        value += reverse ? -step : step;\n        return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii++, v);\n      });\n    };\n\n    Range.prototype.equals = function(other) {\n      return other instanceof Range ?\n        this._start === other._start &&\n        this._end === other._end &&\n        this._step === other._step :\n        deepEqual(this, other);\n    };\n\n\n  var EMPTY_RANGE;\n\n  createClass(Collection, Iterable);\n    function Collection() {\n      throw TypeError('Abstract');\n    }\n\n\n  createClass(KeyedCollection, Collection);function KeyedCollection() {}\n\n  createClass(IndexedCollection, Collection);function IndexedCollection() {}\n\n  createClass(SetCollection, Collection);function SetCollection() {}\n\n\n  Collection.Keyed = KeyedCollection;\n  Collection.Indexed = IndexedCollection;\n  Collection.Set = SetCollection;\n\n  var imul =\n    typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2 ?\n    Math.imul :\n    function imul(a, b) {\n      a = a | 0; // int\n      b = b | 0; // int\n      var c = a & 0xffff;\n      var d = b & 0xffff;\n      // Shift by 0 fixes the sign on the high part.\n      return (c * d) + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0) | 0; // int\n    };\n\n  // v8 has an optimization for storing 31-bit signed numbers.\n  // Values which have either 00 or 11 as the high order bits qualify.\n  // This function drops the highest order bit in a signed number, maintaining\n  // the sign bit.\n  function smi(i32) {\n    return ((i32 >>> 1) & 0x40000000) | (i32 & 0xBFFFFFFF);\n  }\n\n  function hash(o) {\n    if (o === false || o === null || o === undefined) {\n      return 0;\n    }\n    if (typeof o.valueOf === 'function') {\n      o = o.valueOf();\n      if (o === false || o === null || o === undefined) {\n        return 0;\n      }\n    }\n    if (o === true) {\n      return 1;\n    }\n    var type = typeof o;\n    if (type === 'number') {\n      if (o !== o || o === Infinity) {\n        return 0;\n      }\n      var h = o | 0;\n      if (h !== o) {\n        h ^= o * 0xFFFFFFFF;\n      }\n      while (o > 0xFFFFFFFF) {\n        o /= 0xFFFFFFFF;\n        h ^= o;\n      }\n      return smi(h);\n    }\n    if (type === 'string') {\n      return o.length > STRING_HASH_CACHE_MIN_STRLEN ? cachedHashString(o) : hashString(o);\n    }\n    if (typeof o.hashCode === 'function') {\n      return o.hashCode();\n    }\n    if (type === 'object') {\n      return hashJSObj(o);\n    }\n    if (typeof o.toString === 'function') {\n      return hashString(o.toString());\n    }\n    throw new Error('Value type ' + type + ' cannot be hashed.');\n  }\n\n  function cachedHashString(string) {\n    var hash = stringHashCache[string];\n    if (hash === undefined) {\n      hash = hashString(string);\n      if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {\n        STRING_HASH_CACHE_SIZE = 0;\n        stringHashCache = {};\n      }\n      STRING_HASH_CACHE_SIZE++;\n      stringHashCache[string] = hash;\n    }\n    return hash;\n  }\n\n  // http://jsperf.com/hashing-strings\n  function hashString(string) {\n    // This is the hash from JVM\n    // The hash code for a string is computed as\n    // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],\n    // where s[i] is the ith character of the string and n is the length of\n    // the string. We \"mod\" the result to make it between 0 (inclusive) and 2^31\n    // (exclusive) by dropping high bits.\n    var hash = 0;\n    for (var ii = 0; ii < string.length; ii++) {\n      hash = 31 * hash + string.charCodeAt(ii) | 0;\n    }\n    return smi(hash);\n  }\n\n  function hashJSObj(obj) {\n    var hash;\n    if (usingWeakMap) {\n      hash = weakMap.get(obj);\n      if (hash !== undefined) {\n        return hash;\n      }\n    }\n\n    hash = obj[UID_HASH_KEY];\n    if (hash !== undefined) {\n      return hash;\n    }\n\n    if (!canDefineProperty) {\n      hash = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];\n      if (hash !== undefined) {\n        return hash;\n      }\n\n      hash = getIENodeHash(obj);\n      if (hash !== undefined) {\n        return hash;\n      }\n    }\n\n    hash = ++objHashUID;\n    if (objHashUID & 0x40000000) {\n      objHashUID = 0;\n    }\n\n    if (usingWeakMap) {\n      weakMap.set(obj, hash);\n    } else if (isExtensible !== undefined && isExtensible(obj) === false) {\n      throw new Error('Non-extensible objects are not allowed as keys.');\n    } else if (canDefineProperty) {\n      Object.defineProperty(obj, UID_HASH_KEY, {\n        'enumerable': false,\n        'configurable': false,\n        'writable': false,\n        'value': hash\n      });\n    } else if (obj.propertyIsEnumerable !== undefined &&\n               obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable) {\n      // Since we can't define a non-enumerable property on the object\n      // we'll hijack one of the less-used non-enumerable properties to\n      // save our hash on it. Since this is a function it will not show up in\n      // `JSON.stringify` which is what we want.\n      obj.propertyIsEnumerable = function() {\n        return this.constructor.prototype.propertyIsEnumerable.apply(this, arguments);\n      };\n      obj.propertyIsEnumerable[UID_HASH_KEY] = hash;\n    } else if (obj.nodeType !== undefined) {\n      // At this point we couldn't get the IE `uniqueID` to use as a hash\n      // and we couldn't use a non-enumerable property to exploit the\n      // dontEnum bug so we simply add the `UID_HASH_KEY` on the node\n      // itself.\n      obj[UID_HASH_KEY] = hash;\n    } else {\n      throw new Error('Unable to set a non-enumerable property on object.');\n    }\n\n    return hash;\n  }\n\n  // Get references to ES5 object methods.\n  var isExtensible = Object.isExtensible;\n\n  // True if Object.defineProperty works as expected. IE8 fails this test.\n  var canDefineProperty = (function() {\n    try {\n      Object.defineProperty({}, '@', {});\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }());\n\n  // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it\n  // and avoid memory leaks from the IE cloneNode bug.\n  function getIENodeHash(node) {\n    if (node && node.nodeType > 0) {\n      switch (node.nodeType) {\n        case 1: // Element\n          return node.uniqueID;\n        case 9: // Document\n          return node.documentElement && node.documentElement.uniqueID;\n      }\n    }\n  }\n\n  // If possible, use a WeakMap.\n  var usingWeakMap = typeof WeakMap === 'function';\n  var weakMap;\n  if (usingWeakMap) {\n    weakMap = new WeakMap();\n  }\n\n  var objHashUID = 0;\n\n  var UID_HASH_KEY = '__immutablehash__';\n  if (typeof Symbol === 'function') {\n    UID_HASH_KEY = Symbol(UID_HASH_KEY);\n  }\n\n  var STRING_HASH_CACHE_MIN_STRLEN = 16;\n  var STRING_HASH_CACHE_MAX_SIZE = 255;\n  var STRING_HASH_CACHE_SIZE = 0;\n  var stringHashCache = {};\n\n  function assertNotInfinite(size) {\n    invariant(\n      size !== Infinity,\n      'Cannot perform this action with an infinite size.'\n    );\n  }\n\n  createClass(Map, KeyedCollection);\n\n    // @pragma Construction\n\n    function Map(value) {\n      return value === null || value === undefined ? emptyMap() :\n        isMap(value) && !isOrdered(value) ? value :\n        emptyMap().withMutations(function(map ) {\n          var iter = KeyedIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v, k)  {return map.set(k, v)});\n        });\n    }\n\n    Map.of = function() {var keyValues = SLICE$0.call(arguments, 0);\n      return emptyMap().withMutations(function(map ) {\n        for (var i = 0; i < keyValues.length; i += 2) {\n          if (i + 1 >= keyValues.length) {\n            throw new Error('Missing value for key: ' + keyValues[i]);\n          }\n          map.set(keyValues[i], keyValues[i + 1]);\n        }\n      });\n    };\n\n    Map.prototype.toString = function() {\n      return this.__toString('Map {', '}');\n    };\n\n    // @pragma Access\n\n    Map.prototype.get = function(k, notSetValue) {\n      return this._root ?\n        this._root.get(0, undefined, k, notSetValue) :\n        notSetValue;\n    };\n\n    // @pragma Modification\n\n    Map.prototype.set = function(k, v) {\n      return updateMap(this, k, v);\n    };\n\n    Map.prototype.setIn = function(keyPath, v) {\n      return this.updateIn(keyPath, NOT_SET, function()  {return v});\n    };\n\n    Map.prototype.remove = function(k) {\n      return updateMap(this, k, NOT_SET);\n    };\n\n    Map.prototype.deleteIn = function(keyPath) {\n      return this.updateIn(keyPath, function()  {return NOT_SET});\n    };\n\n    Map.prototype.update = function(k, notSetValue, updater) {\n      return arguments.length === 1 ?\n        k(this) :\n        this.updateIn([k], notSetValue, updater);\n    };\n\n    Map.prototype.updateIn = function(keyPath, notSetValue, updater) {\n      if (!updater) {\n        updater = notSetValue;\n        notSetValue = undefined;\n      }\n      var updatedValue = updateInDeepMap(\n        this,\n        forceIterator(keyPath),\n        notSetValue,\n        updater\n      );\n      return updatedValue === NOT_SET ? undefined : updatedValue;\n    };\n\n    Map.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._root = null;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyMap();\n    };\n\n    // @pragma Composition\n\n    Map.prototype.merge = function(/*...iters*/) {\n      return mergeIntoMapWith(this, undefined, arguments);\n    };\n\n    Map.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoMapWith(this, merger, iters);\n    };\n\n    Map.prototype.mergeIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);\n      return this.updateIn(\n        keyPath,\n        emptyMap(),\n        function(m ) {return typeof m.merge === 'function' ?\n          m.merge.apply(m, iters) :\n          iters[iters.length - 1]}\n      );\n    };\n\n    Map.prototype.mergeDeep = function(/*...iters*/) {\n      return mergeIntoMapWith(this, deepMerger, arguments);\n    };\n\n    Map.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoMapWith(this, deepMergerWith(merger), iters);\n    };\n\n    Map.prototype.mergeDeepIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);\n      return this.updateIn(\n        keyPath,\n        emptyMap(),\n        function(m ) {return typeof m.mergeDeep === 'function' ?\n          m.mergeDeep.apply(m, iters) :\n          iters[iters.length - 1]}\n      );\n    };\n\n    Map.prototype.sort = function(comparator) {\n      // Late binding\n      return OrderedMap(sortFactory(this, comparator));\n    };\n\n    Map.prototype.sortBy = function(mapper, comparator) {\n      // Late binding\n      return OrderedMap(sortFactory(this, comparator, mapper));\n    };\n\n    // @pragma Mutability\n\n    Map.prototype.withMutations = function(fn) {\n      var mutable = this.asMutable();\n      fn(mutable);\n      return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;\n    };\n\n    Map.prototype.asMutable = function() {\n      return this.__ownerID ? this : this.__ensureOwner(new OwnerID());\n    };\n\n    Map.prototype.asImmutable = function() {\n      return this.__ensureOwner();\n    };\n\n    Map.prototype.wasAltered = function() {\n      return this.__altered;\n    };\n\n    Map.prototype.__iterator = function(type, reverse) {\n      return new MapIterator(this, type, reverse);\n    };\n\n    Map.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      this._root && this._root.iterate(function(entry ) {\n        iterations++;\n        return fn(entry[1], entry[0], this$0);\n      }, reverse);\n      return iterations;\n    };\n\n    Map.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this.__altered = false;\n        return this;\n      }\n      return makeMap(this.size, this._root, ownerID, this.__hash);\n    };\n\n\n  function isMap(maybeMap) {\n    return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]);\n  }\n\n  Map.isMap = isMap;\n\n  var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';\n\n  var MapPrototype = Map.prototype;\n  MapPrototype[IS_MAP_SENTINEL] = true;\n  MapPrototype[DELETE] = MapPrototype.remove;\n  MapPrototype.removeIn = MapPrototype.deleteIn;\n\n\n  // #pragma Trie Nodes\n\n\n\n    function ArrayMapNode(ownerID, entries) {\n      this.ownerID = ownerID;\n      this.entries = entries;\n    }\n\n    ArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      var entries = this.entries;\n      for (var ii = 0, len = entries.length; ii < len; ii++) {\n        if (is(key, entries[ii][0])) {\n          return entries[ii][1];\n        }\n      }\n      return notSetValue;\n    };\n\n    ArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      var removed = value === NOT_SET;\n\n      var entries = this.entries;\n      var idx = 0;\n      for (var len = entries.length; idx < len; idx++) {\n        if (is(key, entries[idx][0])) {\n          break;\n        }\n      }\n      var exists = idx < len;\n\n      if (exists ? entries[idx][1] === value : removed) {\n        return this;\n      }\n\n      SetRef(didAlter);\n      (removed || !exists) && SetRef(didChangeSize);\n\n      if (removed && entries.length === 1) {\n        return; // undefined\n      }\n\n      if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {\n        return createNodes(ownerID, entries, key, value);\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newEntries = isEditable ? entries : arrCopy(entries);\n\n      if (exists) {\n        if (removed) {\n          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());\n        } else {\n          newEntries[idx] = [key, value];\n        }\n      } else {\n        newEntries.push([key, value]);\n      }\n\n      if (isEditable) {\n        this.entries = newEntries;\n        return this;\n      }\n\n      return new ArrayMapNode(ownerID, newEntries);\n    };\n\n\n\n\n    function BitmapIndexedNode(ownerID, bitmap, nodes) {\n      this.ownerID = ownerID;\n      this.bitmap = bitmap;\n      this.nodes = nodes;\n    }\n\n    BitmapIndexedNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var bit = (1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK));\n      var bitmap = this.bitmap;\n      return (bitmap & bit) === 0 ? notSetValue :\n        this.nodes[popCount(bitmap & (bit - 1))].get(shift + SHIFT, keyHash, key, notSetValue);\n    };\n\n    BitmapIndexedNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n      var bit = 1 << keyHashFrag;\n      var bitmap = this.bitmap;\n      var exists = (bitmap & bit) !== 0;\n\n      if (!exists && value === NOT_SET) {\n        return this;\n      }\n\n      var idx = popCount(bitmap & (bit - 1));\n      var nodes = this.nodes;\n      var node = exists ? nodes[idx] : undefined;\n      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);\n\n      if (newNode === node) {\n        return this;\n      }\n\n      if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {\n        return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);\n      }\n\n      if (exists && !newNode && nodes.length === 2 && isLeafNode(nodes[idx ^ 1])) {\n        return nodes[idx ^ 1];\n      }\n\n      if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {\n        return newNode;\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newBitmap = exists ? newNode ? bitmap : bitmap ^ bit : bitmap | bit;\n      var newNodes = exists ? newNode ?\n        setIn(nodes, idx, newNode, isEditable) :\n        spliceOut(nodes, idx, isEditable) :\n        spliceIn(nodes, idx, newNode, isEditable);\n\n      if (isEditable) {\n        this.bitmap = newBitmap;\n        this.nodes = newNodes;\n        return this;\n      }\n\n      return new BitmapIndexedNode(ownerID, newBitmap, newNodes);\n    };\n\n\n\n\n    function HashArrayMapNode(ownerID, count, nodes) {\n      this.ownerID = ownerID;\n      this.count = count;\n      this.nodes = nodes;\n    }\n\n    HashArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n      var node = this.nodes[idx];\n      return node ? node.get(shift + SHIFT, keyHash, key, notSetValue) : notSetValue;\n    };\n\n    HashArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n      var removed = value === NOT_SET;\n      var nodes = this.nodes;\n      var node = nodes[idx];\n\n      if (removed && !node) {\n        return this;\n      }\n\n      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);\n      if (newNode === node) {\n        return this;\n      }\n\n      var newCount = this.count;\n      if (!node) {\n        newCount++;\n      } else if (!newNode) {\n        newCount--;\n        if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {\n          return packNodes(ownerID, nodes, newCount, idx);\n        }\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newNodes = setIn(nodes, idx, newNode, isEditable);\n\n      if (isEditable) {\n        this.count = newCount;\n        this.nodes = newNodes;\n        return this;\n      }\n\n      return new HashArrayMapNode(ownerID, newCount, newNodes);\n    };\n\n\n\n\n    function HashCollisionNode(ownerID, keyHash, entries) {\n      this.ownerID = ownerID;\n      this.keyHash = keyHash;\n      this.entries = entries;\n    }\n\n    HashCollisionNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      var entries = this.entries;\n      for (var ii = 0, len = entries.length; ii < len; ii++) {\n        if (is(key, entries[ii][0])) {\n          return entries[ii][1];\n        }\n      }\n      return notSetValue;\n    };\n\n    HashCollisionNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n\n      var removed = value === NOT_SET;\n\n      if (keyHash !== this.keyHash) {\n        if (removed) {\n          return this;\n        }\n        SetRef(didAlter);\n        SetRef(didChangeSize);\n        return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);\n      }\n\n      var entries = this.entries;\n      var idx = 0;\n      for (var len = entries.length; idx < len; idx++) {\n        if (is(key, entries[idx][0])) {\n          break;\n        }\n      }\n      var exists = idx < len;\n\n      if (exists ? entries[idx][1] === value : removed) {\n        return this;\n      }\n\n      SetRef(didAlter);\n      (removed || !exists) && SetRef(didChangeSize);\n\n      if (removed && len === 2) {\n        return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newEntries = isEditable ? entries : arrCopy(entries);\n\n      if (exists) {\n        if (removed) {\n          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());\n        } else {\n          newEntries[idx] = [key, value];\n        }\n      } else {\n        newEntries.push([key, value]);\n      }\n\n      if (isEditable) {\n        this.entries = newEntries;\n        return this;\n      }\n\n      return new HashCollisionNode(ownerID, this.keyHash, newEntries);\n    };\n\n\n\n\n    function ValueNode(ownerID, keyHash, entry) {\n      this.ownerID = ownerID;\n      this.keyHash = keyHash;\n      this.entry = entry;\n    }\n\n    ValueNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      return is(key, this.entry[0]) ? this.entry[1] : notSetValue;\n    };\n\n    ValueNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      var removed = value === NOT_SET;\n      var keyMatch = is(key, this.entry[0]);\n      if (keyMatch ? value === this.entry[1] : removed) {\n        return this;\n      }\n\n      SetRef(didAlter);\n\n      if (removed) {\n        SetRef(didChangeSize);\n        return; // undefined\n      }\n\n      if (keyMatch) {\n        if (ownerID && ownerID === this.ownerID) {\n          this.entry[1] = value;\n          return this;\n        }\n        return new ValueNode(ownerID, this.keyHash, [key, value]);\n      }\n\n      SetRef(didChangeSize);\n      return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);\n    };\n\n\n\n  // #pragma Iterators\n\n  ArrayMapNode.prototype.iterate =\n  HashCollisionNode.prototype.iterate = function (fn, reverse) {\n    var entries = this.entries;\n    for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {\n      if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {\n        return false;\n      }\n    }\n  }\n\n  BitmapIndexedNode.prototype.iterate =\n  HashArrayMapNode.prototype.iterate = function (fn, reverse) {\n    var nodes = this.nodes;\n    for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {\n      var node = nodes[reverse ? maxIndex - ii : ii];\n      if (node && node.iterate(fn, reverse) === false) {\n        return false;\n      }\n    }\n  }\n\n  ValueNode.prototype.iterate = function (fn, reverse) {\n    return fn(this.entry);\n  }\n\n  createClass(MapIterator, Iterator);\n\n    function MapIterator(map, type, reverse) {\n      this._type = type;\n      this._reverse = reverse;\n      this._stack = map._root && mapIteratorFrame(map._root);\n    }\n\n    MapIterator.prototype.next = function() {\n      var type = this._type;\n      var stack = this._stack;\n      while (stack) {\n        var node = stack.node;\n        var index = stack.index++;\n        var maxIndex;\n        if (node.entry) {\n          if (index === 0) {\n            return mapIteratorValue(type, node.entry);\n          }\n        } else if (node.entries) {\n          maxIndex = node.entries.length - 1;\n          if (index <= maxIndex) {\n            return mapIteratorValue(type, node.entries[this._reverse ? maxIndex - index : index]);\n          }\n        } else {\n          maxIndex = node.nodes.length - 1;\n          if (index <= maxIndex) {\n            var subNode = node.nodes[this._reverse ? maxIndex - index : index];\n            if (subNode) {\n              if (subNode.entry) {\n                return mapIteratorValue(type, subNode.entry);\n              }\n              stack = this._stack = mapIteratorFrame(subNode, stack);\n            }\n            continue;\n          }\n        }\n        stack = this._stack = this._stack.__prev;\n      }\n      return iteratorDone();\n    };\n\n\n  function mapIteratorValue(type, entry) {\n    return iteratorValue(type, entry[0], entry[1]);\n  }\n\n  function mapIteratorFrame(node, prev) {\n    return {\n      node: node,\n      index: 0,\n      __prev: prev\n    };\n  }\n\n  function makeMap(size, root, ownerID, hash) {\n    var map = Object.create(MapPrototype);\n    map.size = size;\n    map._root = root;\n    map.__ownerID = ownerID;\n    map.__hash = hash;\n    map.__altered = false;\n    return map;\n  }\n\n  var EMPTY_MAP;\n  function emptyMap() {\n    return EMPTY_MAP || (EMPTY_MAP = makeMap(0));\n  }\n\n  function updateMap(map, k, v) {\n    var newRoot;\n    var newSize;\n    if (!map._root) {\n      if (v === NOT_SET) {\n        return map;\n      }\n      newSize = 1;\n      newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);\n    } else {\n      var didChangeSize = MakeRef(CHANGE_LENGTH);\n      var didAlter = MakeRef(DID_ALTER);\n      newRoot = updateNode(map._root, map.__ownerID, 0, undefined, k, v, didChangeSize, didAlter);\n      if (!didAlter.value) {\n        return map;\n      }\n      newSize = map.size + (didChangeSize.value ? v === NOT_SET ? -1 : 1 : 0);\n    }\n    if (map.__ownerID) {\n      map.size = newSize;\n      map._root = newRoot;\n      map.__hash = undefined;\n      map.__altered = true;\n      return map;\n    }\n    return newRoot ? makeMap(newSize, newRoot) : emptyMap();\n  }\n\n  function updateNode(node, ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n    if (!node) {\n      if (value === NOT_SET) {\n        return node;\n      }\n      SetRef(didAlter);\n      SetRef(didChangeSize);\n      return new ValueNode(ownerID, keyHash, [key, value]);\n    }\n    return node.update(ownerID, shift, keyHash, key, value, didChangeSize, didAlter);\n  }\n\n  function isLeafNode(node) {\n    return node.constructor === ValueNode || node.constructor === HashCollisionNode;\n  }\n\n  function mergeIntoNode(node, ownerID, shift, keyHash, entry) {\n    if (node.keyHash === keyHash) {\n      return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);\n    }\n\n    var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;\n    var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n\n    var newNode;\n    var nodes = idx1 === idx2 ?\n      [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)] :\n      ((newNode = new ValueNode(ownerID, keyHash, entry)), idx1 < idx2 ? [node, newNode] : [newNode, node]);\n\n    return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);\n  }\n\n  function createNodes(ownerID, entries, key, value) {\n    if (!ownerID) {\n      ownerID = new OwnerID();\n    }\n    var node = new ValueNode(ownerID, hash(key), [key, value]);\n    for (var ii = 0; ii < entries.length; ii++) {\n      var entry = entries[ii];\n      node = node.update(ownerID, 0, undefined, entry[0], entry[1]);\n    }\n    return node;\n  }\n\n  function packNodes(ownerID, nodes, count, excluding) {\n    var bitmap = 0;\n    var packedII = 0;\n    var packedNodes = new Array(count);\n    for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {\n      var node = nodes[ii];\n      if (node !== undefined && ii !== excluding) {\n        bitmap |= bit;\n        packedNodes[packedII++] = node;\n      }\n    }\n    return new BitmapIndexedNode(ownerID, bitmap, packedNodes);\n  }\n\n  function expandNodes(ownerID, nodes, bitmap, including, node) {\n    var count = 0;\n    var expandedNodes = new Array(SIZE);\n    for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {\n      expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;\n    }\n    expandedNodes[including] = node;\n    return new HashArrayMapNode(ownerID, count + 1, expandedNodes);\n  }\n\n  function mergeIntoMapWith(map, merger, iterables) {\n    var iters = [];\n    for (var ii = 0; ii < iterables.length; ii++) {\n      var value = iterables[ii];\n      var iter = KeyedIterable(value);\n      if (!isIterable(value)) {\n        iter = iter.map(function(v ) {return fromJS(v)});\n      }\n      iters.push(iter);\n    }\n    return mergeIntoCollectionWith(map, merger, iters);\n  }\n\n  function deepMerger(existing, value, key) {\n    return existing && existing.mergeDeep && isIterable(value) ?\n      existing.mergeDeep(value) :\n      is(existing, value) ? existing : value;\n  }\n\n  function deepMergerWith(merger) {\n    return function(existing, value, key)  {\n      if (existing && existing.mergeDeepWith && isIterable(value)) {\n        return existing.mergeDeepWith(merger, value);\n      }\n      var nextValue = merger(existing, value, key);\n      return is(existing, nextValue) ? existing : nextValue;\n    };\n  }\n\n  function mergeIntoCollectionWith(collection, merger, iters) {\n    iters = iters.filter(function(x ) {return x.size !== 0});\n    if (iters.length === 0) {\n      return collection;\n    }\n    if (collection.size === 0 && !collection.__ownerID && iters.length === 1) {\n      return collection.constructor(iters[0]);\n    }\n    return collection.withMutations(function(collection ) {\n      var mergeIntoMap = merger ?\n        function(value, key)  {\n          collection.update(key, NOT_SET, function(existing )\n            {return existing === NOT_SET ? value : merger(existing, value, key)}\n          );\n        } :\n        function(value, key)  {\n          collection.set(key, value);\n        }\n      for (var ii = 0; ii < iters.length; ii++) {\n        iters[ii].forEach(mergeIntoMap);\n      }\n    });\n  }\n\n  function updateInDeepMap(existing, keyPathIter, notSetValue, updater) {\n    var isNotSet = existing === NOT_SET;\n    var step = keyPathIter.next();\n    if (step.done) {\n      var existingValue = isNotSet ? notSetValue : existing;\n      var newValue = updater(existingValue);\n      return newValue === existingValue ? existing : newValue;\n    }\n    invariant(\n      isNotSet || (existing && existing.set),\n      'invalid keyPath'\n    );\n    var key = step.value;\n    var nextExisting = isNotSet ? NOT_SET : existing.get(key, NOT_SET);\n    var nextUpdated = updateInDeepMap(\n      nextExisting,\n      keyPathIter,\n      notSetValue,\n      updater\n    );\n    return nextUpdated === nextExisting ? existing :\n      nextUpdated === NOT_SET ? existing.remove(key) :\n      (isNotSet ? emptyMap() : existing).set(key, nextUpdated);\n  }\n\n  function popCount(x) {\n    x = x - ((x >> 1) & 0x55555555);\n    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);\n    x = (x + (x >> 4)) & 0x0f0f0f0f;\n    x = x + (x >> 8);\n    x = x + (x >> 16);\n    return x & 0x7f;\n  }\n\n  function setIn(array, idx, val, canEdit) {\n    var newArray = canEdit ? array : arrCopy(array);\n    newArray[idx] = val;\n    return newArray;\n  }\n\n  function spliceIn(array, idx, val, canEdit) {\n    var newLen = array.length + 1;\n    if (canEdit && idx + 1 === newLen) {\n      array[idx] = val;\n      return array;\n    }\n    var newArray = new Array(newLen);\n    var after = 0;\n    for (var ii = 0; ii < newLen; ii++) {\n      if (ii === idx) {\n        newArray[ii] = val;\n        after = -1;\n      } else {\n        newArray[ii] = array[ii + after];\n      }\n    }\n    return newArray;\n  }\n\n  function spliceOut(array, idx, canEdit) {\n    var newLen = array.length - 1;\n    if (canEdit && idx === newLen) {\n      array.pop();\n      return array;\n    }\n    var newArray = new Array(newLen);\n    var after = 0;\n    for (var ii = 0; ii < newLen; ii++) {\n      if (ii === idx) {\n        after = 1;\n      }\n      newArray[ii] = array[ii + after];\n    }\n    return newArray;\n  }\n\n  var MAX_ARRAY_MAP_SIZE = SIZE / 4;\n  var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;\n  var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;\n\n  createClass(List, IndexedCollection);\n\n    // @pragma Construction\n\n    function List(value) {\n      var empty = emptyList();\n      if (value === null || value === undefined) {\n        return empty;\n      }\n      if (isList(value)) {\n        return value;\n      }\n      var iter = IndexedIterable(value);\n      var size = iter.size;\n      if (size === 0) {\n        return empty;\n      }\n      assertNotInfinite(size);\n      if (size > 0 && size < SIZE) {\n        return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));\n      }\n      return empty.withMutations(function(list ) {\n        list.setSize(size);\n        iter.forEach(function(v, i)  {return list.set(i, v)});\n      });\n    }\n\n    List.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    List.prototype.toString = function() {\n      return this.__toString('List [', ']');\n    };\n\n    // @pragma Access\n\n    List.prototype.get = function(index, notSetValue) {\n      index = wrapIndex(this, index);\n      if (index >= 0 && index < this.size) {\n        index += this._origin;\n        var node = listNodeFor(this, index);\n        return node && node.array[index & MASK];\n      }\n      return notSetValue;\n    };\n\n    // @pragma Modification\n\n    List.prototype.set = function(index, value) {\n      return updateList(this, index, value);\n    };\n\n    List.prototype.remove = function(index) {\n      return !this.has(index) ? this :\n        index === 0 ? this.shift() :\n        index === this.size - 1 ? this.pop() :\n        this.splice(index, 1);\n    };\n\n    List.prototype.insert = function(index, value) {\n      return this.splice(index, 0, value);\n    };\n\n    List.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = this._origin = this._capacity = 0;\n        this._level = SHIFT;\n        this._root = this._tail = null;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyList();\n    };\n\n    List.prototype.push = function(/*...values*/) {\n      var values = arguments;\n      var oldSize = this.size;\n      return this.withMutations(function(list ) {\n        setListBounds(list, 0, oldSize + values.length);\n        for (var ii = 0; ii < values.length; ii++) {\n          list.set(oldSize + ii, values[ii]);\n        }\n      });\n    };\n\n    List.prototype.pop = function() {\n      return setListBounds(this, 0, -1);\n    };\n\n    List.prototype.unshift = function(/*...values*/) {\n      var values = arguments;\n      return this.withMutations(function(list ) {\n        setListBounds(list, -values.length);\n        for (var ii = 0; ii < values.length; ii++) {\n          list.set(ii, values[ii]);\n        }\n      });\n    };\n\n    List.prototype.shift = function() {\n      return setListBounds(this, 1);\n    };\n\n    // @pragma Composition\n\n    List.prototype.merge = function(/*...iters*/) {\n      return mergeIntoListWith(this, undefined, arguments);\n    };\n\n    List.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoListWith(this, merger, iters);\n    };\n\n    List.prototype.mergeDeep = function(/*...iters*/) {\n      return mergeIntoListWith(this, deepMerger, arguments);\n    };\n\n    List.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoListWith(this, deepMergerWith(merger), iters);\n    };\n\n    List.prototype.setSize = function(size) {\n      return setListBounds(this, 0, size);\n    };\n\n    // @pragma Iteration\n\n    List.prototype.slice = function(begin, end) {\n      var size = this.size;\n      if (wholeSlice(begin, end, size)) {\n        return this;\n      }\n      return setListBounds(\n        this,\n        resolveBegin(begin, size),\n        resolveEnd(end, size)\n      );\n    };\n\n    List.prototype.__iterator = function(type, reverse) {\n      var index = 0;\n      var values = iterateList(this, reverse);\n      return new Iterator(function()  {\n        var value = values();\n        return value === DONE ?\n          iteratorDone() :\n          iteratorValue(type, index++, value);\n      });\n    };\n\n    List.prototype.__iterate = function(fn, reverse) {\n      var index = 0;\n      var values = iterateList(this, reverse);\n      var value;\n      while ((value = values()) !== DONE) {\n        if (fn(value, index++, this) === false) {\n          break;\n        }\n      }\n      return index;\n    };\n\n    List.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        return this;\n      }\n      return makeList(this._origin, this._capacity, this._level, this._root, this._tail, ownerID, this.__hash);\n    };\n\n\n  function isList(maybeList) {\n    return !!(maybeList && maybeList[IS_LIST_SENTINEL]);\n  }\n\n  List.isList = isList;\n\n  var IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';\n\n  var ListPrototype = List.prototype;\n  ListPrototype[IS_LIST_SENTINEL] = true;\n  ListPrototype[DELETE] = ListPrototype.remove;\n  ListPrototype.setIn = MapPrototype.setIn;\n  ListPrototype.deleteIn =\n  ListPrototype.removeIn = MapPrototype.removeIn;\n  ListPrototype.update = MapPrototype.update;\n  ListPrototype.updateIn = MapPrototype.updateIn;\n  ListPrototype.mergeIn = MapPrototype.mergeIn;\n  ListPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;\n  ListPrototype.withMutations = MapPrototype.withMutations;\n  ListPrototype.asMutable = MapPrototype.asMutable;\n  ListPrototype.asImmutable = MapPrototype.asImmutable;\n  ListPrototype.wasAltered = MapPrototype.wasAltered;\n\n\n\n    function VNode(array, ownerID) {\n      this.array = array;\n      this.ownerID = ownerID;\n    }\n\n    // TODO: seems like these methods are very similar\n\n    VNode.prototype.removeBefore = function(ownerID, level, index) {\n      if (index === level ? 1 << level : 0 || this.array.length === 0) {\n        return this;\n      }\n      var originIndex = (index >>> level) & MASK;\n      if (originIndex >= this.array.length) {\n        return new VNode([], ownerID);\n      }\n      var removingFirst = originIndex === 0;\n      var newChild;\n      if (level > 0) {\n        var oldChild = this.array[originIndex];\n        newChild = oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);\n        if (newChild === oldChild && removingFirst) {\n          return this;\n        }\n      }\n      if (removingFirst && !newChild) {\n        return this;\n      }\n      var editable = editableVNode(this, ownerID);\n      if (!removingFirst) {\n        for (var ii = 0; ii < originIndex; ii++) {\n          editable.array[ii] = undefined;\n        }\n      }\n      if (newChild) {\n        editable.array[originIndex] = newChild;\n      }\n      return editable;\n    };\n\n    VNode.prototype.removeAfter = function(ownerID, level, index) {\n      if (index === (level ? 1 << level : 0) || this.array.length === 0) {\n        return this;\n      }\n      var sizeIndex = ((index - 1) >>> level) & MASK;\n      if (sizeIndex >= this.array.length) {\n        return this;\n      }\n\n      var newChild;\n      if (level > 0) {\n        var oldChild = this.array[sizeIndex];\n        newChild = oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);\n        if (newChild === oldChild && sizeIndex === this.array.length - 1) {\n          return this;\n        }\n      }\n\n      var editable = editableVNode(this, ownerID);\n      editable.array.splice(sizeIndex + 1);\n      if (newChild) {\n        editable.array[sizeIndex] = newChild;\n      }\n      return editable;\n    };\n\n\n\n  var DONE = {};\n\n  function iterateList(list, reverse) {\n    var left = list._origin;\n    var right = list._capacity;\n    var tailPos = getTailOffset(right);\n    var tail = list._tail;\n\n    return iterateNodeOrLeaf(list._root, list._level, 0);\n\n    function iterateNodeOrLeaf(node, level, offset) {\n      return level === 0 ?\n        iterateLeaf(node, offset) :\n        iterateNode(node, level, offset);\n    }\n\n    function iterateLeaf(node, offset) {\n      var array = offset === tailPos ? tail && tail.array : node && node.array;\n      var from = offset > left ? 0 : left - offset;\n      var to = right - offset;\n      if (to > SIZE) {\n        to = SIZE;\n      }\n      return function()  {\n        if (from === to) {\n          return DONE;\n        }\n        var idx = reverse ? --to : from++;\n        return array && array[idx];\n      };\n    }\n\n    function iterateNode(node, level, offset) {\n      var values;\n      var array = node && node.array;\n      var from = offset > left ? 0 : (left - offset) >> level;\n      var to = ((right - offset) >> level) + 1;\n      if (to > SIZE) {\n        to = SIZE;\n      }\n      return function()  {\n        do {\n          if (values) {\n            var value = values();\n            if (value !== DONE) {\n              return value;\n            }\n            values = null;\n          }\n          if (from === to) {\n            return DONE;\n          }\n          var idx = reverse ? --to : from++;\n          values = iterateNodeOrLeaf(\n            array && array[idx], level - SHIFT, offset + (idx << level)\n          );\n        } while (true);\n      };\n    }\n  }\n\n  function makeList(origin, capacity, level, root, tail, ownerID, hash) {\n    var list = Object.create(ListPrototype);\n    list.size = capacity - origin;\n    list._origin = origin;\n    list._capacity = capacity;\n    list._level = level;\n    list._root = root;\n    list._tail = tail;\n    list.__ownerID = ownerID;\n    list.__hash = hash;\n    list.__altered = false;\n    return list;\n  }\n\n  var EMPTY_LIST;\n  function emptyList() {\n    return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));\n  }\n\n  function updateList(list, index, value) {\n    index = wrapIndex(list, index);\n\n    if (index !== index) {\n      return list;\n    }\n\n    if (index >= list.size || index < 0) {\n      return list.withMutations(function(list ) {\n        index < 0 ?\n          setListBounds(list, index).set(0, value) :\n          setListBounds(list, 0, index + 1).set(index, value)\n      });\n    }\n\n    index += list._origin;\n\n    var newTail = list._tail;\n    var newRoot = list._root;\n    var didAlter = MakeRef(DID_ALTER);\n    if (index >= getTailOffset(list._capacity)) {\n      newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter);\n    } else {\n      newRoot = updateVNode(newRoot, list.__ownerID, list._level, index, value, didAlter);\n    }\n\n    if (!didAlter.value) {\n      return list;\n    }\n\n    if (list.__ownerID) {\n      list._root = newRoot;\n      list._tail = newTail;\n      list.__hash = undefined;\n      list.__altered = true;\n      return list;\n    }\n    return makeList(list._origin, list._capacity, list._level, newRoot, newTail);\n  }\n\n  function updateVNode(node, ownerID, level, index, value, didAlter) {\n    var idx = (index >>> level) & MASK;\n    var nodeHas = node && idx < node.array.length;\n    if (!nodeHas && value === undefined) {\n      return node;\n    }\n\n    var newNode;\n\n    if (level > 0) {\n      var lowerNode = node && node.array[idx];\n      var newLowerNode = updateVNode(lowerNode, ownerID, level - SHIFT, index, value, didAlter);\n      if (newLowerNode === lowerNode) {\n        return node;\n      }\n      newNode = editableVNode(node, ownerID);\n      newNode.array[idx] = newLowerNode;\n      return newNode;\n    }\n\n    if (nodeHas && node.array[idx] === value) {\n      return node;\n    }\n\n    SetRef(didAlter);\n\n    newNode = editableVNode(node, ownerID);\n    if (value === undefined && idx === newNode.array.length - 1) {\n      newNode.array.pop();\n    } else {\n      newNode.array[idx] = value;\n    }\n    return newNode;\n  }\n\n  function editableVNode(node, ownerID) {\n    if (ownerID && node && ownerID === node.ownerID) {\n      return node;\n    }\n    return new VNode(node ? node.array.slice() : [], ownerID);\n  }\n\n  function listNodeFor(list, rawIndex) {\n    if (rawIndex >= getTailOffset(list._capacity)) {\n      return list._tail;\n    }\n    if (rawIndex < 1 << (list._level + SHIFT)) {\n      var node = list._root;\n      var level = list._level;\n      while (node && level > 0) {\n        node = node.array[(rawIndex >>> level) & MASK];\n        level -= SHIFT;\n      }\n      return node;\n    }\n  }\n\n  function setListBounds(list, begin, end) {\n    // Sanitize begin & end using this shorthand for ToInt32(argument)\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n    if (begin !== undefined) {\n      begin = begin | 0;\n    }\n    if (end !== undefined) {\n      end = end | 0;\n    }\n    var owner = list.__ownerID || new OwnerID();\n    var oldOrigin = list._origin;\n    var oldCapacity = list._capacity;\n    var newOrigin = oldOrigin + begin;\n    var newCapacity = end === undefined ? oldCapacity : end < 0 ? oldCapacity + end : oldOrigin + end;\n    if (newOrigin === oldOrigin && newCapacity === oldCapacity) {\n      return list;\n    }\n\n    // If it's going to end after it starts, it's empty.\n    if (newOrigin >= newCapacity) {\n      return list.clear();\n    }\n\n    var newLevel = list._level;\n    var newRoot = list._root;\n\n    // New origin might need creating a higher root.\n    var offsetShift = 0;\n    while (newOrigin + offsetShift < 0) {\n      newRoot = new VNode(newRoot && newRoot.array.length ? [undefined, newRoot] : [], owner);\n      newLevel += SHIFT;\n      offsetShift += 1 << newLevel;\n    }\n    if (offsetShift) {\n      newOrigin += offsetShift;\n      oldOrigin += offsetShift;\n      newCapacity += offsetShift;\n      oldCapacity += offsetShift;\n    }\n\n    var oldTailOffset = getTailOffset(oldCapacity);\n    var newTailOffset = getTailOffset(newCapacity);\n\n    // New size might need creating a higher root.\n    while (newTailOffset >= 1 << (newLevel + SHIFT)) {\n      newRoot = new VNode(newRoot && newRoot.array.length ? [newRoot] : [], owner);\n      newLevel += SHIFT;\n    }\n\n    // Locate or create the new tail.\n    var oldTail = list._tail;\n    var newTail = newTailOffset < oldTailOffset ?\n      listNodeFor(list, newCapacity - 1) :\n      newTailOffset > oldTailOffset ? new VNode([], owner) : oldTail;\n\n    // Merge Tail into tree.\n    if (oldTail && newTailOffset > oldTailOffset && newOrigin < oldCapacity && oldTail.array.length) {\n      newRoot = editableVNode(newRoot, owner);\n      var node = newRoot;\n      for (var level = newLevel; level > SHIFT; level -= SHIFT) {\n        var idx = (oldTailOffset >>> level) & MASK;\n        node = node.array[idx] = editableVNode(node.array[idx], owner);\n      }\n      node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;\n    }\n\n    // If the size has been reduced, there's a chance the tail needs to be trimmed.\n    if (newCapacity < oldCapacity) {\n      newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);\n    }\n\n    // If the new origin is within the tail, then we do not need a root.\n    if (newOrigin >= newTailOffset) {\n      newOrigin -= newTailOffset;\n      newCapacity -= newTailOffset;\n      newLevel = SHIFT;\n      newRoot = null;\n      newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);\n\n    // Otherwise, if the root has been trimmed, garbage collect.\n    } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {\n      offsetShift = 0;\n\n      // Identify the new top root node of the subtree of the old root.\n      while (newRoot) {\n        var beginIndex = (newOrigin >>> newLevel) & MASK;\n        if (beginIndex !== (newTailOffset >>> newLevel) & MASK) {\n          break;\n        }\n        if (beginIndex) {\n          offsetShift += (1 << newLevel) * beginIndex;\n        }\n        newLevel -= SHIFT;\n        newRoot = newRoot.array[beginIndex];\n      }\n\n      // Trim the new sides of the new root.\n      if (newRoot && newOrigin > oldOrigin) {\n        newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift);\n      }\n      if (newRoot && newTailOffset < oldTailOffset) {\n        newRoot = newRoot.removeAfter(owner, newLevel, newTailOffset - offsetShift);\n      }\n      if (offsetShift) {\n        newOrigin -= offsetShift;\n        newCapacity -= offsetShift;\n      }\n    }\n\n    if (list.__ownerID) {\n      list.size = newCapacity - newOrigin;\n      list._origin = newOrigin;\n      list._capacity = newCapacity;\n      list._level = newLevel;\n      list._root = newRoot;\n      list._tail = newTail;\n      list.__hash = undefined;\n      list.__altered = true;\n      return list;\n    }\n    return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);\n  }\n\n  function mergeIntoListWith(list, merger, iterables) {\n    var iters = [];\n    var maxSize = 0;\n    for (var ii = 0; ii < iterables.length; ii++) {\n      var value = iterables[ii];\n      var iter = IndexedIterable(value);\n      if (iter.size > maxSize) {\n        maxSize = iter.size;\n      }\n      if (!isIterable(value)) {\n        iter = iter.map(function(v ) {return fromJS(v)});\n      }\n      iters.push(iter);\n    }\n    if (maxSize > list.size) {\n      list = list.setSize(maxSize);\n    }\n    return mergeIntoCollectionWith(list, merger, iters);\n  }\n\n  function getTailOffset(size) {\n    return size < SIZE ? 0 : (((size - 1) >>> SHIFT) << SHIFT);\n  }\n\n  createClass(OrderedMap, Map);\n\n    // @pragma Construction\n\n    function OrderedMap(value) {\n      return value === null || value === undefined ? emptyOrderedMap() :\n        isOrderedMap(value) ? value :\n        emptyOrderedMap().withMutations(function(map ) {\n          var iter = KeyedIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v, k)  {return map.set(k, v)});\n        });\n    }\n\n    OrderedMap.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    OrderedMap.prototype.toString = function() {\n      return this.__toString('OrderedMap {', '}');\n    };\n\n    // @pragma Access\n\n    OrderedMap.prototype.get = function(k, notSetValue) {\n      var index = this._map.get(k);\n      return index !== undefined ? this._list.get(index)[1] : notSetValue;\n    };\n\n    // @pragma Modification\n\n    OrderedMap.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._map.clear();\n        this._list.clear();\n        return this;\n      }\n      return emptyOrderedMap();\n    };\n\n    OrderedMap.prototype.set = function(k, v) {\n      return updateOrderedMap(this, k, v);\n    };\n\n    OrderedMap.prototype.remove = function(k) {\n      return updateOrderedMap(this, k, NOT_SET);\n    };\n\n    OrderedMap.prototype.wasAltered = function() {\n      return this._map.wasAltered() || this._list.wasAltered();\n    };\n\n    OrderedMap.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._list.__iterate(\n        function(entry ) {return entry && fn(entry[1], entry[0], this$0)},\n        reverse\n      );\n    };\n\n    OrderedMap.prototype.__iterator = function(type, reverse) {\n      return this._list.fromEntrySeq().__iterator(type, reverse);\n    };\n\n    OrderedMap.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map.__ensureOwner(ownerID);\n      var newList = this._list.__ensureOwner(ownerID);\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        this._list = newList;\n        return this;\n      }\n      return makeOrderedMap(newMap, newList, ownerID, this.__hash);\n    };\n\n\n  function isOrderedMap(maybeOrderedMap) {\n    return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);\n  }\n\n  OrderedMap.isOrderedMap = isOrderedMap;\n\n  OrderedMap.prototype[IS_ORDERED_SENTINEL] = true;\n  OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;\n\n\n\n  function makeOrderedMap(map, list, ownerID, hash) {\n    var omap = Object.create(OrderedMap.prototype);\n    omap.size = map ? map.size : 0;\n    omap._map = map;\n    omap._list = list;\n    omap.__ownerID = ownerID;\n    omap.__hash = hash;\n    return omap;\n  }\n\n  var EMPTY_ORDERED_MAP;\n  function emptyOrderedMap() {\n    return EMPTY_ORDERED_MAP || (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()));\n  }\n\n  function updateOrderedMap(omap, k, v) {\n    var map = omap._map;\n    var list = omap._list;\n    var i = map.get(k);\n    var has = i !== undefined;\n    var newMap;\n    var newList;\n    if (v === NOT_SET) { // removed\n      if (!has) {\n        return omap;\n      }\n      if (list.size >= SIZE && list.size >= map.size * 2) {\n        newList = list.filter(function(entry, idx)  {return entry !== undefined && i !== idx});\n        newMap = newList.toKeyedSeq().map(function(entry ) {return entry[0]}).flip().toMap();\n        if (omap.__ownerID) {\n          newMap.__ownerID = newList.__ownerID = omap.__ownerID;\n        }\n      } else {\n        newMap = map.remove(k);\n        newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);\n      }\n    } else {\n      if (has) {\n        if (v === list.get(i)[1]) {\n          return omap;\n        }\n        newMap = map;\n        newList = list.set(i, [k, v]);\n      } else {\n        newMap = map.set(k, list.size);\n        newList = list.set(list.size, [k, v]);\n      }\n    }\n    if (omap.__ownerID) {\n      omap.size = newMap.size;\n      omap._map = newMap;\n      omap._list = newList;\n      omap.__hash = undefined;\n      return omap;\n    }\n    return makeOrderedMap(newMap, newList);\n  }\n\n  createClass(ToKeyedSequence, KeyedSeq);\n    function ToKeyedSequence(indexed, useKeys) {\n      this._iter = indexed;\n      this._useKeys = useKeys;\n      this.size = indexed.size;\n    }\n\n    ToKeyedSequence.prototype.get = function(key, notSetValue) {\n      return this._iter.get(key, notSetValue);\n    };\n\n    ToKeyedSequence.prototype.has = function(key) {\n      return this._iter.has(key);\n    };\n\n    ToKeyedSequence.prototype.valueSeq = function() {\n      return this._iter.valueSeq();\n    };\n\n    ToKeyedSequence.prototype.reverse = function() {var this$0 = this;\n      var reversedSequence = reverseFactory(this, true);\n      if (!this._useKeys) {\n        reversedSequence.valueSeq = function()  {return this$0._iter.toSeq().reverse()};\n      }\n      return reversedSequence;\n    };\n\n    ToKeyedSequence.prototype.map = function(mapper, context) {var this$0 = this;\n      var mappedSequence = mapFactory(this, mapper, context);\n      if (!this._useKeys) {\n        mappedSequence.valueSeq = function()  {return this$0._iter.toSeq().map(mapper, context)};\n      }\n      return mappedSequence;\n    };\n\n    ToKeyedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      var ii;\n      return this._iter.__iterate(\n        this._useKeys ?\n          function(v, k)  {return fn(v, k, this$0)} :\n          ((ii = reverse ? resolveSize(this) : 0),\n            function(v ) {return fn(v, reverse ? --ii : ii++, this$0)}),\n        reverse\n      );\n    };\n\n    ToKeyedSequence.prototype.__iterator = function(type, reverse) {\n      if (this._useKeys) {\n        return this._iter.__iterator(type, reverse);\n      }\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      var ii = reverse ? resolveSize(this) : 0;\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step :\n          iteratorValue(type, reverse ? --ii : ii++, step.value, step);\n      });\n    };\n\n  ToKeyedSequence.prototype[IS_ORDERED_SENTINEL] = true;\n\n\n  createClass(ToIndexedSequence, IndexedSeq);\n    function ToIndexedSequence(iter) {\n      this._iter = iter;\n      this.size = iter.size;\n    }\n\n    ToIndexedSequence.prototype.includes = function(value) {\n      return this._iter.includes(value);\n    };\n\n    ToIndexedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      return this._iter.__iterate(function(v ) {return fn(v, iterations++, this$0)}, reverse);\n    };\n\n    ToIndexedSequence.prototype.__iterator = function(type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      var iterations = 0;\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step :\n          iteratorValue(type, iterations++, step.value, step)\n      });\n    };\n\n\n\n  createClass(ToSetSequence, SetSeq);\n    function ToSetSequence(iter) {\n      this._iter = iter;\n      this.size = iter.size;\n    }\n\n    ToSetSequence.prototype.has = function(key) {\n      return this._iter.includes(key);\n    };\n\n    ToSetSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._iter.__iterate(function(v ) {return fn(v, v, this$0)}, reverse);\n    };\n\n    ToSetSequence.prototype.__iterator = function(type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step :\n          iteratorValue(type, step.value, step.value, step);\n      });\n    };\n\n\n\n  createClass(FromEntriesSequence, KeyedSeq);\n    function FromEntriesSequence(entries) {\n      this._iter = entries;\n      this.size = entries.size;\n    }\n\n    FromEntriesSequence.prototype.entrySeq = function() {\n      return this._iter.toSeq();\n    };\n\n    FromEntriesSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._iter.__iterate(function(entry ) {\n        // Check if entry exists first so array access doesn't throw for holes\n        // in the parent iteration.\n        if (entry) {\n          validateEntry(entry);\n          var indexedIterable = isIterable(entry);\n          return fn(\n            indexedIterable ? entry.get(1) : entry[1],\n            indexedIterable ? entry.get(0) : entry[0],\n            this$0\n          );\n        }\n      }, reverse);\n    };\n\n    FromEntriesSequence.prototype.__iterator = function(type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      return new Iterator(function()  {\n        while (true) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          var entry = step.value;\n          // Check if entry exists first so array access doesn't throw for holes\n          // in the parent iteration.\n          if (entry) {\n            validateEntry(entry);\n            var indexedIterable = isIterable(entry);\n            return iteratorValue(\n              type,\n              indexedIterable ? entry.get(0) : entry[0],\n              indexedIterable ? entry.get(1) : entry[1],\n              step\n            );\n          }\n        }\n      });\n    };\n\n\n  ToIndexedSequence.prototype.cacheResult =\n  ToKeyedSequence.prototype.cacheResult =\n  ToSetSequence.prototype.cacheResult =\n  FromEntriesSequence.prototype.cacheResult =\n    cacheResultThrough;\n\n\n  function flipFactory(iterable) {\n    var flipSequence = makeSequence(iterable);\n    flipSequence._iter = iterable;\n    flipSequence.size = iterable.size;\n    flipSequence.flip = function()  {return iterable};\n    flipSequence.reverse = function () {\n      var reversedSequence = iterable.reverse.apply(this); // super.reverse()\n      reversedSequence.flip = function()  {return iterable.reverse()};\n      return reversedSequence;\n    };\n    flipSequence.has = function(key ) {return iterable.includes(key)};\n    flipSequence.includes = function(key ) {return iterable.has(key)};\n    flipSequence.cacheResult = cacheResultThrough;\n    flipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      return iterable.__iterate(function(v, k)  {return fn(k, v, this$0) !== false}, reverse);\n    }\n    flipSequence.__iteratorUncached = function(type, reverse) {\n      if (type === ITERATE_ENTRIES) {\n        var iterator = iterable.__iterator(type, reverse);\n        return new Iterator(function()  {\n          var step = iterator.next();\n          if (!step.done) {\n            var k = step.value[0];\n            step.value[0] = step.value[1];\n            step.value[1] = k;\n          }\n          return step;\n        });\n      }\n      return iterable.__iterator(\n        type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,\n        reverse\n      );\n    }\n    return flipSequence;\n  }\n\n\n  function mapFactory(iterable, mapper, context) {\n    var mappedSequence = makeSequence(iterable);\n    mappedSequence.size = iterable.size;\n    mappedSequence.has = function(key ) {return iterable.has(key)};\n    mappedSequence.get = function(key, notSetValue)  {\n      var v = iterable.get(key, NOT_SET);\n      return v === NOT_SET ?\n        notSetValue :\n        mapper.call(context, v, key, iterable);\n    };\n    mappedSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      return iterable.__iterate(\n        function(v, k, c)  {return fn(mapper.call(context, v, k, c), k, this$0) !== false},\n        reverse\n      );\n    }\n    mappedSequence.__iteratorUncached = function (type, reverse) {\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      return new Iterator(function()  {\n        var step = iterator.next();\n        if (step.done) {\n          return step;\n        }\n        var entry = step.value;\n        var key = entry[0];\n        return iteratorValue(\n          type,\n          key,\n          mapper.call(context, entry[1], key, iterable),\n          step\n        );\n      });\n    }\n    return mappedSequence;\n  }\n\n\n  function reverseFactory(iterable, useKeys) {\n    var reversedSequence = makeSequence(iterable);\n    reversedSequence._iter = iterable;\n    reversedSequence.size = iterable.size;\n    reversedSequence.reverse = function()  {return iterable};\n    if (iterable.flip) {\n      reversedSequence.flip = function () {\n        var flipSequence = flipFactory(iterable);\n        flipSequence.reverse = function()  {return iterable.flip()};\n        return flipSequence;\n      };\n    }\n    reversedSequence.get = function(key, notSetValue) \n      {return iterable.get(useKeys ? key : -1 - key, notSetValue)};\n    reversedSequence.has = function(key )\n      {return iterable.has(useKeys ? key : -1 - key)};\n    reversedSequence.includes = function(value ) {return iterable.includes(value)};\n    reversedSequence.cacheResult = cacheResultThrough;\n    reversedSequence.__iterate = function (fn, reverse) {var this$0 = this;\n      return iterable.__iterate(function(v, k)  {return fn(v, k, this$0)}, !reverse);\n    };\n    reversedSequence.__iterator =\n      function(type, reverse)  {return iterable.__iterator(type, !reverse)};\n    return reversedSequence;\n  }\n\n\n  function filterFactory(iterable, predicate, context, useKeys) {\n    var filterSequence = makeSequence(iterable);\n    if (useKeys) {\n      filterSequence.has = function(key ) {\n        var v = iterable.get(key, NOT_SET);\n        return v !== NOT_SET && !!predicate.call(context, v, key, iterable);\n      };\n      filterSequence.get = function(key, notSetValue)  {\n        var v = iterable.get(key, NOT_SET);\n        return v !== NOT_SET && predicate.call(context, v, key, iterable) ?\n          v : notSetValue;\n      };\n    }\n    filterSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      iterable.__iterate(function(v, k, c)  {\n        if (predicate.call(context, v, k, c)) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$0);\n        }\n      }, reverse);\n      return iterations;\n    };\n    filterSequence.__iteratorUncached = function (type, reverse) {\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      var iterations = 0;\n      return new Iterator(function()  {\n        while (true) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          var entry = step.value;\n          var key = entry[0];\n          var value = entry[1];\n          if (predicate.call(context, value, key, iterable)) {\n            return iteratorValue(type, useKeys ? key : iterations++, value, step);\n          }\n        }\n      });\n    }\n    return filterSequence;\n  }\n\n\n  function countByFactory(iterable, grouper, context) {\n    var groups = Map().asMutable();\n    iterable.__iterate(function(v, k)  {\n      groups.update(\n        grouper.call(context, v, k, iterable),\n        0,\n        function(a ) {return a + 1}\n      );\n    });\n    return groups.asImmutable();\n  }\n\n\n  function groupByFactory(iterable, grouper, context) {\n    var isKeyedIter = isKeyed(iterable);\n    var groups = (isOrdered(iterable) ? OrderedMap() : Map()).asMutable();\n    iterable.__iterate(function(v, k)  {\n      groups.update(\n        grouper.call(context, v, k, iterable),\n        function(a ) {return (a = a || [], a.push(isKeyedIter ? [k, v] : v), a)}\n      );\n    });\n    var coerce = iterableClass(iterable);\n    return groups.map(function(arr ) {return reify(iterable, coerce(arr))});\n  }\n\n\n  function sliceFactory(iterable, begin, end, useKeys) {\n    var originalSize = iterable.size;\n\n    // Sanitize begin & end using this shorthand for ToInt32(argument)\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n    if (begin !== undefined) {\n      begin = begin | 0;\n    }\n    if (end !== undefined) {\n      if (end === Infinity) {\n        end = originalSize;\n      } else {\n        end = end | 0;\n      }\n    }\n\n    if (wholeSlice(begin, end, originalSize)) {\n      return iterable;\n    }\n\n    var resolvedBegin = resolveBegin(begin, originalSize);\n    var resolvedEnd = resolveEnd(end, originalSize);\n\n    // begin or end will be NaN if they were provided as negative numbers and\n    // this iterable's size is unknown. In that case, cache first so there is\n    // a known size and these do not resolve to NaN.\n    if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {\n      return sliceFactory(iterable.toSeq().cacheResult(), begin, end, useKeys);\n    }\n\n    // Note: resolvedEnd is undefined when the original sequence's length is\n    // unknown and this slice did not supply an end and should contain all\n    // elements after resolvedBegin.\n    // In that case, resolvedSize will be NaN and sliceSize will remain undefined.\n    var resolvedSize = resolvedEnd - resolvedBegin;\n    var sliceSize;\n    if (resolvedSize === resolvedSize) {\n      sliceSize = resolvedSize < 0 ? 0 : resolvedSize;\n    }\n\n    var sliceSeq = makeSequence(iterable);\n\n    // If iterable.size is undefined, the size of the realized sliceSeq is\n    // unknown at this point unless the number of items to slice is 0\n    sliceSeq.size = sliceSize === 0 ? sliceSize : iterable.size && sliceSize || undefined;\n\n    if (!useKeys && isSeq(iterable) && sliceSize >= 0) {\n      sliceSeq.get = function (index, notSetValue) {\n        index = wrapIndex(this, index);\n        return index >= 0 && index < sliceSize ?\n          iterable.get(index + resolvedBegin, notSetValue) :\n          notSetValue;\n      }\n    }\n\n    sliceSeq.__iterateUncached = function(fn, reverse) {var this$0 = this;\n      if (sliceSize === 0) {\n        return 0;\n      }\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var skipped = 0;\n      var isSkipping = true;\n      var iterations = 0;\n      iterable.__iterate(function(v, k)  {\n        if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$0) !== false &&\n                 iterations !== sliceSize;\n        }\n      });\n      return iterations;\n    };\n\n    sliceSeq.__iteratorUncached = function(type, reverse) {\n      if (sliceSize !== 0 && reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      // Don't bother instantiating parent iterator if taking 0.\n      var iterator = sliceSize !== 0 && iterable.__iterator(type, reverse);\n      var skipped = 0;\n      var iterations = 0;\n      return new Iterator(function()  {\n        while (skipped++ < resolvedBegin) {\n          iterator.next();\n        }\n        if (++iterations > sliceSize) {\n          return iteratorDone();\n        }\n        var step = iterator.next();\n        if (useKeys || type === ITERATE_VALUES) {\n          return step;\n        } else if (type === ITERATE_KEYS) {\n          return iteratorValue(type, iterations - 1, undefined, step);\n        } else {\n          return iteratorValue(type, iterations - 1, step.value[1], step);\n        }\n      });\n    }\n\n    return sliceSeq;\n  }\n\n\n  function takeWhileFactory(iterable, predicate, context) {\n    var takeSequence = makeSequence(iterable);\n    takeSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterations = 0;\n      iterable.__iterate(function(v, k, c) \n        {return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$0)}\n      );\n      return iterations;\n    };\n    takeSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      var iterating = true;\n      return new Iterator(function()  {\n        if (!iterating) {\n          return iteratorDone();\n        }\n        var step = iterator.next();\n        if (step.done) {\n          return step;\n        }\n        var entry = step.value;\n        var k = entry[0];\n        var v = entry[1];\n        if (!predicate.call(context, v, k, this$0)) {\n          iterating = false;\n          return iteratorDone();\n        }\n        return type === ITERATE_ENTRIES ? step :\n          iteratorValue(type, k, v, step);\n      });\n    };\n    return takeSequence;\n  }\n\n\n  function skipWhileFactory(iterable, predicate, context, useKeys) {\n    var skipSequence = makeSequence(iterable);\n    skipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var isSkipping = true;\n      var iterations = 0;\n      iterable.__iterate(function(v, k, c)  {\n        if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$0);\n        }\n      });\n      return iterations;\n    };\n    skipSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      var skipping = true;\n      var iterations = 0;\n      return new Iterator(function()  {\n        var step, k, v;\n        do {\n          step = iterator.next();\n          if (step.done) {\n            if (useKeys || type === ITERATE_VALUES) {\n              return step;\n            } else if (type === ITERATE_KEYS) {\n              return iteratorValue(type, iterations++, undefined, step);\n            } else {\n              return iteratorValue(type, iterations++, step.value[1], step);\n            }\n          }\n          var entry = step.value;\n          k = entry[0];\n          v = entry[1];\n          skipping && (skipping = predicate.call(context, v, k, this$0));\n        } while (skipping);\n        return type === ITERATE_ENTRIES ? step :\n          iteratorValue(type, k, v, step);\n      });\n    };\n    return skipSequence;\n  }\n\n\n  function concatFactory(iterable, values) {\n    var isKeyedIterable = isKeyed(iterable);\n    var iters = [iterable].concat(values).map(function(v ) {\n      if (!isIterable(v)) {\n        v = isKeyedIterable ?\n          keyedSeqFromValue(v) :\n          indexedSeqFromValue(Array.isArray(v) ? v : [v]);\n      } else if (isKeyedIterable) {\n        v = KeyedIterable(v);\n      }\n      return v;\n    }).filter(function(v ) {return v.size !== 0});\n\n    if (iters.length === 0) {\n      return iterable;\n    }\n\n    if (iters.length === 1) {\n      var singleton = iters[0];\n      if (singleton === iterable ||\n          isKeyedIterable && isKeyed(singleton) ||\n          isIndexed(iterable) && isIndexed(singleton)) {\n        return singleton;\n      }\n    }\n\n    var concatSeq = new ArraySeq(iters);\n    if (isKeyedIterable) {\n      concatSeq = concatSeq.toKeyedSeq();\n    } else if (!isIndexed(iterable)) {\n      concatSeq = concatSeq.toSetSeq();\n    }\n    concatSeq = concatSeq.flatten(true);\n    concatSeq.size = iters.reduce(\n      function(sum, seq)  {\n        if (sum !== undefined) {\n          var size = seq.size;\n          if (size !== undefined) {\n            return sum + size;\n          }\n        }\n      },\n      0\n    );\n    return concatSeq;\n  }\n\n\n  function flattenFactory(iterable, depth, useKeys) {\n    var flatSequence = makeSequence(iterable);\n    flatSequence.__iterateUncached = function(fn, reverse) {\n      var iterations = 0;\n      var stopped = false;\n      function flatDeep(iter, currentDepth) {var this$0 = this;\n        iter.__iterate(function(v, k)  {\n          if ((!depth || currentDepth < depth) && isIterable(v)) {\n            flatDeep(v, currentDepth + 1);\n          } else if (fn(v, useKeys ? k : iterations++, this$0) === false) {\n            stopped = true;\n          }\n          return !stopped;\n        }, reverse);\n      }\n      flatDeep(iterable, 0);\n      return iterations;\n    }\n    flatSequence.__iteratorUncached = function(type, reverse) {\n      var iterator = iterable.__iterator(type, reverse);\n      var stack = [];\n      var iterations = 0;\n      return new Iterator(function()  {\n        while (iterator) {\n          var step = iterator.next();\n          if (step.done !== false) {\n            iterator = stack.pop();\n            continue;\n          }\n          var v = step.value;\n          if (type === ITERATE_ENTRIES) {\n            v = v[1];\n          }\n          if ((!depth || stack.length < depth) && isIterable(v)) {\n            stack.push(iterator);\n            iterator = v.__iterator(type, reverse);\n          } else {\n            return useKeys ? step : iteratorValue(type, iterations++, v, step);\n          }\n        }\n        return iteratorDone();\n      });\n    }\n    return flatSequence;\n  }\n\n\n  function flatMapFactory(iterable, mapper, context) {\n    var coerce = iterableClass(iterable);\n    return iterable.toSeq().map(\n      function(v, k)  {return coerce(mapper.call(context, v, k, iterable))}\n    ).flatten(true);\n  }\n\n\n  function interposeFactory(iterable, separator) {\n    var interposedSequence = makeSequence(iterable);\n    interposedSequence.size = iterable.size && iterable.size * 2 -1;\n    interposedSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      iterable.__iterate(function(v, k) \n        {return (!iterations || fn(separator, iterations++, this$0) !== false) &&\n        fn(v, iterations++, this$0) !== false},\n        reverse\n      );\n      return iterations;\n    };\n    interposedSequence.__iteratorUncached = function(type, reverse) {\n      var iterator = iterable.__iterator(ITERATE_VALUES, reverse);\n      var iterations = 0;\n      var step;\n      return new Iterator(function()  {\n        if (!step || iterations % 2) {\n          step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n        }\n        return iterations % 2 ?\n          iteratorValue(type, iterations++, separator) :\n          iteratorValue(type, iterations++, step.value, step);\n      });\n    };\n    return interposedSequence;\n  }\n\n\n  function sortFactory(iterable, comparator, mapper) {\n    if (!comparator) {\n      comparator = defaultComparator;\n    }\n    var isKeyedIterable = isKeyed(iterable);\n    var index = 0;\n    var entries = iterable.toSeq().map(\n      function(v, k)  {return [k, v, index++, mapper ? mapper(v, k, iterable) : v]}\n    ).toArray();\n    entries.sort(function(a, b)  {return comparator(a[3], b[3]) || a[2] - b[2]}).forEach(\n      isKeyedIterable ?\n      function(v, i)  { entries[i].length = 2; } :\n      function(v, i)  { entries[i] = v[1]; }\n    );\n    return isKeyedIterable ? KeyedSeq(entries) :\n      isIndexed(iterable) ? IndexedSeq(entries) :\n      SetSeq(entries);\n  }\n\n\n  function maxFactory(iterable, comparator, mapper) {\n    if (!comparator) {\n      comparator = defaultComparator;\n    }\n    if (mapper) {\n      var entry = iterable.toSeq()\n        .map(function(v, k)  {return [v, mapper(v, k, iterable)]})\n        .reduce(function(a, b)  {return maxCompare(comparator, a[1], b[1]) ? b : a});\n      return entry && entry[0];\n    } else {\n      return iterable.reduce(function(a, b)  {return maxCompare(comparator, a, b) ? b : a});\n    }\n  }\n\n  function maxCompare(comparator, a, b) {\n    var comp = comparator(b, a);\n    // b is considered the new max if the comparator declares them equal, but\n    // they are not equal and b is in fact a nullish value.\n    return (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) || comp > 0;\n  }\n\n\n  function zipWithFactory(keyIter, zipper, iters) {\n    var zipSequence = makeSequence(keyIter);\n    zipSequence.size = new ArraySeq(iters).map(function(i ) {return i.size}).min();\n    // Note: this a generic base implementation of __iterate in terms of\n    // __iterator which may be more generically useful in the future.\n    zipSequence.__iterate = function(fn, reverse) {\n      /* generic:\n      var iterator = this.__iterator(ITERATE_ENTRIES, reverse);\n      var step;\n      var iterations = 0;\n      while (!(step = iterator.next()).done) {\n        iterations++;\n        if (fn(step.value[1], step.value[0], this) === false) {\n          break;\n        }\n      }\n      return iterations;\n      */\n      // indexed:\n      var iterator = this.__iterator(ITERATE_VALUES, reverse);\n      var step;\n      var iterations = 0;\n      while (!(step = iterator.next()).done) {\n        if (fn(step.value, iterations++, this) === false) {\n          break;\n        }\n      }\n      return iterations;\n    };\n    zipSequence.__iteratorUncached = function(type, reverse) {\n      var iterators = iters.map(function(i )\n        {return (i = Iterable(i), getIterator(reverse ? i.reverse() : i))}\n      );\n      var iterations = 0;\n      var isDone = false;\n      return new Iterator(function()  {\n        var steps;\n        if (!isDone) {\n          steps = iterators.map(function(i ) {return i.next()});\n          isDone = steps.some(function(s ) {return s.done});\n        }\n        if (isDone) {\n          return iteratorDone();\n        }\n        return iteratorValue(\n          type,\n          iterations++,\n          zipper.apply(null, steps.map(function(s ) {return s.value}))\n        );\n      });\n    };\n    return zipSequence\n  }\n\n\n  // #pragma Helper Functions\n\n  function reify(iter, seq) {\n    return isSeq(iter) ? seq : iter.constructor(seq);\n  }\n\n  function validateEntry(entry) {\n    if (entry !== Object(entry)) {\n      throw new TypeError('Expected [K, V] tuple: ' + entry);\n    }\n  }\n\n  function resolveSize(iter) {\n    assertNotInfinite(iter.size);\n    return ensureSize(iter);\n  }\n\n  function iterableClass(iterable) {\n    return isKeyed(iterable) ? KeyedIterable :\n      isIndexed(iterable) ? IndexedIterable :\n      SetIterable;\n  }\n\n  function makeSequence(iterable) {\n    return Object.create(\n      (\n        isKeyed(iterable) ? KeyedSeq :\n        isIndexed(iterable) ? IndexedSeq :\n        SetSeq\n      ).prototype\n    );\n  }\n\n  function cacheResultThrough() {\n    if (this._iter.cacheResult) {\n      this._iter.cacheResult();\n      this.size = this._iter.size;\n      return this;\n    } else {\n      return Seq.prototype.cacheResult.call(this);\n    }\n  }\n\n  function defaultComparator(a, b) {\n    return a > b ? 1 : a < b ? -1 : 0;\n  }\n\n  function forceIterator(keyPath) {\n    var iter = getIterator(keyPath);\n    if (!iter) {\n      // Array might not be iterable in this environment, so we need a fallback\n      // to our wrapped type.\n      if (!isArrayLike(keyPath)) {\n        throw new TypeError('Expected iterable or array-like: ' + keyPath);\n      }\n      iter = getIterator(Iterable(keyPath));\n    }\n    return iter;\n  }\n\n  createClass(Record, KeyedCollection);\n\n    function Record(defaultValues, name) {\n      var hasInitialized;\n\n      var RecordType = function Record(values) {\n        if (values instanceof RecordType) {\n          return values;\n        }\n        if (!(this instanceof RecordType)) {\n          return new RecordType(values);\n        }\n        if (!hasInitialized) {\n          hasInitialized = true;\n          var keys = Object.keys(defaultValues);\n          setProps(RecordTypePrototype, keys);\n          RecordTypePrototype.size = keys.length;\n          RecordTypePrototype._name = name;\n          RecordTypePrototype._keys = keys;\n          RecordTypePrototype._defaultValues = defaultValues;\n        }\n        this._map = Map(values);\n      };\n\n      var RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype);\n      RecordTypePrototype.constructor = RecordType;\n\n      return RecordType;\n    }\n\n    Record.prototype.toString = function() {\n      return this.__toString(recordName(this) + ' {', '}');\n    };\n\n    // @pragma Access\n\n    Record.prototype.has = function(k) {\n      return this._defaultValues.hasOwnProperty(k);\n    };\n\n    Record.prototype.get = function(k, notSetValue) {\n      if (!this.has(k)) {\n        return notSetValue;\n      }\n      var defaultVal = this._defaultValues[k];\n      return this._map ? this._map.get(k, defaultVal) : defaultVal;\n    };\n\n    // @pragma Modification\n\n    Record.prototype.clear = function() {\n      if (this.__ownerID) {\n        this._map && this._map.clear();\n        return this;\n      }\n      var RecordType = this.constructor;\n      return RecordType._empty || (RecordType._empty = makeRecord(this, emptyMap()));\n    };\n\n    Record.prototype.set = function(k, v) {\n      if (!this.has(k)) {\n        throw new Error('Cannot set unknown key \"' + k + '\" on ' + recordName(this));\n      }\n      if (this._map && !this._map.has(k)) {\n        var defaultVal = this._defaultValues[k];\n        if (v === defaultVal) {\n          return this;\n        }\n      }\n      var newMap = this._map && this._map.set(k, v);\n      if (this.__ownerID || newMap === this._map) {\n        return this;\n      }\n      return makeRecord(this, newMap);\n    };\n\n    Record.prototype.remove = function(k) {\n      if (!this.has(k)) {\n        return this;\n      }\n      var newMap = this._map && this._map.remove(k);\n      if (this.__ownerID || newMap === this._map) {\n        return this;\n      }\n      return makeRecord(this, newMap);\n    };\n\n    Record.prototype.wasAltered = function() {\n      return this._map.wasAltered();\n    };\n\n    Record.prototype.__iterator = function(type, reverse) {var this$0 = this;\n      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterator(type, reverse);\n    };\n\n    Record.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterate(fn, reverse);\n    };\n\n    Record.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map && this._map.__ensureOwner(ownerID);\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        return this;\n      }\n      return makeRecord(this, newMap, ownerID);\n    };\n\n\n  var RecordPrototype = Record.prototype;\n  RecordPrototype[DELETE] = RecordPrototype.remove;\n  RecordPrototype.deleteIn =\n  RecordPrototype.removeIn = MapPrototype.removeIn;\n  RecordPrototype.merge = MapPrototype.merge;\n  RecordPrototype.mergeWith = MapPrototype.mergeWith;\n  RecordPrototype.mergeIn = MapPrototype.mergeIn;\n  RecordPrototype.mergeDeep = MapPrototype.mergeDeep;\n  RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith;\n  RecordPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;\n  RecordPrototype.setIn = MapPrototype.setIn;\n  RecordPrototype.update = MapPrototype.update;\n  RecordPrototype.updateIn = MapPrototype.updateIn;\n  RecordPrototype.withMutations = MapPrototype.withMutations;\n  RecordPrototype.asMutable = MapPrototype.asMutable;\n  RecordPrototype.asImmutable = MapPrototype.asImmutable;\n\n\n  function makeRecord(likeRecord, map, ownerID) {\n    var record = Object.create(Object.getPrototypeOf(likeRecord));\n    record._map = map;\n    record.__ownerID = ownerID;\n    return record;\n  }\n\n  function recordName(record) {\n    return record._name || record.constructor.name || 'Record';\n  }\n\n  function setProps(prototype, names) {\n    try {\n      names.forEach(setProp.bind(undefined, prototype));\n    } catch (error) {\n      // Object.defineProperty failed. Probably IE8.\n    }\n  }\n\n  function setProp(prototype, name) {\n    Object.defineProperty(prototype, name, {\n      get: function() {\n        return this.get(name);\n      },\n      set: function(value) {\n        invariant(this.__ownerID, 'Cannot set on an immutable record.');\n        this.set(name, value);\n      }\n    });\n  }\n\n  createClass(Set, SetCollection);\n\n    // @pragma Construction\n\n    function Set(value) {\n      return value === null || value === undefined ? emptySet() :\n        isSet(value) && !isOrdered(value) ? value :\n        emptySet().withMutations(function(set ) {\n          var iter = SetIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v ) {return set.add(v)});\n        });\n    }\n\n    Set.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    Set.fromKeys = function(value) {\n      return this(KeyedIterable(value).keySeq());\n    };\n\n    Set.prototype.toString = function() {\n      return this.__toString('Set {', '}');\n    };\n\n    // @pragma Access\n\n    Set.prototype.has = function(value) {\n      return this._map.has(value);\n    };\n\n    // @pragma Modification\n\n    Set.prototype.add = function(value) {\n      return updateSet(this, this._map.set(value, true));\n    };\n\n    Set.prototype.remove = function(value) {\n      return updateSet(this, this._map.remove(value));\n    };\n\n    Set.prototype.clear = function() {\n      return updateSet(this, this._map.clear());\n    };\n\n    // @pragma Composition\n\n    Set.prototype.union = function() {var iters = SLICE$0.call(arguments, 0);\n      iters = iters.filter(function(x ) {return x.size !== 0});\n      if (iters.length === 0) {\n        return this;\n      }\n      if (this.size === 0 && !this.__ownerID && iters.length === 1) {\n        return this.constructor(iters[0]);\n      }\n      return this.withMutations(function(set ) {\n        for (var ii = 0; ii < iters.length; ii++) {\n          SetIterable(iters[ii]).forEach(function(value ) {return set.add(value)});\n        }\n      });\n    };\n\n    Set.prototype.intersect = function() {var iters = SLICE$0.call(arguments, 0);\n      if (iters.length === 0) {\n        return this;\n      }\n      iters = iters.map(function(iter ) {return SetIterable(iter)});\n      var originalSet = this;\n      return this.withMutations(function(set ) {\n        originalSet.forEach(function(value ) {\n          if (!iters.every(function(iter ) {return iter.includes(value)})) {\n            set.remove(value);\n          }\n        });\n      });\n    };\n\n    Set.prototype.subtract = function() {var iters = SLICE$0.call(arguments, 0);\n      if (iters.length === 0) {\n        return this;\n      }\n      iters = iters.map(function(iter ) {return SetIterable(iter)});\n      var originalSet = this;\n      return this.withMutations(function(set ) {\n        originalSet.forEach(function(value ) {\n          if (iters.some(function(iter ) {return iter.includes(value)})) {\n            set.remove(value);\n          }\n        });\n      });\n    };\n\n    Set.prototype.merge = function() {\n      return this.union.apply(this, arguments);\n    };\n\n    Set.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return this.union.apply(this, iters);\n    };\n\n    Set.prototype.sort = function(comparator) {\n      // Late binding\n      return OrderedSet(sortFactory(this, comparator));\n    };\n\n    Set.prototype.sortBy = function(mapper, comparator) {\n      // Late binding\n      return OrderedSet(sortFactory(this, comparator, mapper));\n    };\n\n    Set.prototype.wasAltered = function() {\n      return this._map.wasAltered();\n    };\n\n    Set.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._map.__iterate(function(_, k)  {return fn(k, k, this$0)}, reverse);\n    };\n\n    Set.prototype.__iterator = function(type, reverse) {\n      return this._map.map(function(_, k)  {return k}).__iterator(type, reverse);\n    };\n\n    Set.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map.__ensureOwner(ownerID);\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        return this;\n      }\n      return this.__make(newMap, ownerID);\n    };\n\n\n  function isSet(maybeSet) {\n    return !!(maybeSet && maybeSet[IS_SET_SENTINEL]);\n  }\n\n  Set.isSet = isSet;\n\n  var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';\n\n  var SetPrototype = Set.prototype;\n  SetPrototype[IS_SET_SENTINEL] = true;\n  SetPrototype[DELETE] = SetPrototype.remove;\n  SetPrototype.mergeDeep = SetPrototype.merge;\n  SetPrototype.mergeDeepWith = SetPrototype.mergeWith;\n  SetPrototype.withMutations = MapPrototype.withMutations;\n  SetPrototype.asMutable = MapPrototype.asMutable;\n  SetPrototype.asImmutable = MapPrototype.asImmutable;\n\n  SetPrototype.__empty = emptySet;\n  SetPrototype.__make = makeSet;\n\n  function updateSet(set, newMap) {\n    if (set.__ownerID) {\n      set.size = newMap.size;\n      set._map = newMap;\n      return set;\n    }\n    return newMap === set._map ? set :\n      newMap.size === 0 ? set.__empty() :\n      set.__make(newMap);\n  }\n\n  function makeSet(map, ownerID) {\n    var set = Object.create(SetPrototype);\n    set.size = map ? map.size : 0;\n    set._map = map;\n    set.__ownerID = ownerID;\n    return set;\n  }\n\n  var EMPTY_SET;\n  function emptySet() {\n    return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));\n  }\n\n  createClass(OrderedSet, Set);\n\n    // @pragma Construction\n\n    function OrderedSet(value) {\n      return value === null || value === undefined ? emptyOrderedSet() :\n        isOrderedSet(value) ? value :\n        emptyOrderedSet().withMutations(function(set ) {\n          var iter = SetIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v ) {return set.add(v)});\n        });\n    }\n\n    OrderedSet.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    OrderedSet.fromKeys = function(value) {\n      return this(KeyedIterable(value).keySeq());\n    };\n\n    OrderedSet.prototype.toString = function() {\n      return this.__toString('OrderedSet {', '}');\n    };\n\n\n  function isOrderedSet(maybeOrderedSet) {\n    return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);\n  }\n\n  OrderedSet.isOrderedSet = isOrderedSet;\n\n  var OrderedSetPrototype = OrderedSet.prototype;\n  OrderedSetPrototype[IS_ORDERED_SENTINEL] = true;\n\n  OrderedSetPrototype.__empty = emptyOrderedSet;\n  OrderedSetPrototype.__make = makeOrderedSet;\n\n  function makeOrderedSet(map, ownerID) {\n    var set = Object.create(OrderedSetPrototype);\n    set.size = map ? map.size : 0;\n    set._map = map;\n    set.__ownerID = ownerID;\n    return set;\n  }\n\n  var EMPTY_ORDERED_SET;\n  function emptyOrderedSet() {\n    return EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()));\n  }\n\n  createClass(Stack, IndexedCollection);\n\n    // @pragma Construction\n\n    function Stack(value) {\n      return value === null || value === undefined ? emptyStack() :\n        isStack(value) ? value :\n        emptyStack().unshiftAll(value);\n    }\n\n    Stack.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    Stack.prototype.toString = function() {\n      return this.__toString('Stack [', ']');\n    };\n\n    // @pragma Access\n\n    Stack.prototype.get = function(index, notSetValue) {\n      var head = this._head;\n      index = wrapIndex(this, index);\n      while (head && index--) {\n        head = head.next;\n      }\n      return head ? head.value : notSetValue;\n    };\n\n    Stack.prototype.peek = function() {\n      return this._head && this._head.value;\n    };\n\n    // @pragma Modification\n\n    Stack.prototype.push = function(/*...values*/) {\n      if (arguments.length === 0) {\n        return this;\n      }\n      var newSize = this.size + arguments.length;\n      var head = this._head;\n      for (var ii = arguments.length - 1; ii >= 0; ii--) {\n        head = {\n          value: arguments[ii],\n          next: head\n        };\n      }\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    Stack.prototype.pushAll = function(iter) {\n      iter = IndexedIterable(iter);\n      if (iter.size === 0) {\n        return this;\n      }\n      assertNotInfinite(iter.size);\n      var newSize = this.size;\n      var head = this._head;\n      iter.reverse().forEach(function(value ) {\n        newSize++;\n        head = {\n          value: value,\n          next: head\n        };\n      });\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    Stack.prototype.pop = function() {\n      return this.slice(1);\n    };\n\n    Stack.prototype.unshift = function(/*...values*/) {\n      return this.push.apply(this, arguments);\n    };\n\n    Stack.prototype.unshiftAll = function(iter) {\n      return this.pushAll(iter);\n    };\n\n    Stack.prototype.shift = function() {\n      return this.pop.apply(this, arguments);\n    };\n\n    Stack.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._head = undefined;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyStack();\n    };\n\n    Stack.prototype.slice = function(begin, end) {\n      if (wholeSlice(begin, end, this.size)) {\n        return this;\n      }\n      var resolvedBegin = resolveBegin(begin, this.size);\n      var resolvedEnd = resolveEnd(end, this.size);\n      if (resolvedEnd !== this.size) {\n        // super.slice(begin, end);\n        return IndexedCollection.prototype.slice.call(this, begin, end);\n      }\n      var newSize = this.size - resolvedBegin;\n      var head = this._head;\n      while (resolvedBegin--) {\n        head = head.next;\n      }\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    // @pragma Mutability\n\n    Stack.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this.__altered = false;\n        return this;\n      }\n      return makeStack(this.size, this._head, ownerID, this.__hash);\n    };\n\n    // @pragma Iteration\n\n    Stack.prototype.__iterate = function(fn, reverse) {\n      if (reverse) {\n        return this.reverse().__iterate(fn);\n      }\n      var iterations = 0;\n      var node = this._head;\n      while (node) {\n        if (fn(node.value, iterations++, this) === false) {\n          break;\n        }\n        node = node.next;\n      }\n      return iterations;\n    };\n\n    Stack.prototype.__iterator = function(type, reverse) {\n      if (reverse) {\n        return this.reverse().__iterator(type);\n      }\n      var iterations = 0;\n      var node = this._head;\n      return new Iterator(function()  {\n        if (node) {\n          var value = node.value;\n          node = node.next;\n          return iteratorValue(type, iterations++, value);\n        }\n        return iteratorDone();\n      });\n    };\n\n\n  function isStack(maybeStack) {\n    return !!(maybeStack && maybeStack[IS_STACK_SENTINEL]);\n  }\n\n  Stack.isStack = isStack;\n\n  var IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';\n\n  var StackPrototype = Stack.prototype;\n  StackPrototype[IS_STACK_SENTINEL] = true;\n  StackPrototype.withMutations = MapPrototype.withMutations;\n  StackPrototype.asMutable = MapPrototype.asMutable;\n  StackPrototype.asImmutable = MapPrototype.asImmutable;\n  StackPrototype.wasAltered = MapPrototype.wasAltered;\n\n\n  function makeStack(size, head, ownerID, hash) {\n    var map = Object.create(StackPrototype);\n    map.size = size;\n    map._head = head;\n    map.__ownerID = ownerID;\n    map.__hash = hash;\n    map.__altered = false;\n    return map;\n  }\n\n  var EMPTY_STACK;\n  function emptyStack() {\n    return EMPTY_STACK || (EMPTY_STACK = makeStack(0));\n  }\n\n  /**\n   * Contributes additional methods to a constructor\n   */\n  function mixin(ctor, methods) {\n    var keyCopier = function(key ) { ctor.prototype[key] = methods[key]; };\n    Object.keys(methods).forEach(keyCopier);\n    Object.getOwnPropertySymbols &&\n      Object.getOwnPropertySymbols(methods).forEach(keyCopier);\n    return ctor;\n  }\n\n  Iterable.Iterator = Iterator;\n\n  mixin(Iterable, {\n\n    // ### Conversion to other types\n\n    toArray: function() {\n      assertNotInfinite(this.size);\n      var array = new Array(this.size || 0);\n      this.valueSeq().__iterate(function(v, i)  { array[i] = v; });\n      return array;\n    },\n\n    toIndexedSeq: function() {\n      return new ToIndexedSequence(this);\n    },\n\n    toJS: function() {\n      return this.toSeq().map(\n        function(value ) {return value && typeof value.toJS === 'function' ? value.toJS() : value}\n      ).__toJS();\n    },\n\n    toJSON: function() {\n      return this.toSeq().map(\n        function(value ) {return value && typeof value.toJSON === 'function' ? value.toJSON() : value}\n      ).__toJS();\n    },\n\n    toKeyedSeq: function() {\n      return new ToKeyedSequence(this, true);\n    },\n\n    toMap: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return Map(this.toKeyedSeq());\n    },\n\n    toObject: function() {\n      assertNotInfinite(this.size);\n      var object = {};\n      this.__iterate(function(v, k)  { object[k] = v; });\n      return object;\n    },\n\n    toOrderedMap: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return OrderedMap(this.toKeyedSeq());\n    },\n\n    toOrderedSet: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return OrderedSet(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toSet: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return Set(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toSetSeq: function() {\n      return new ToSetSequence(this);\n    },\n\n    toSeq: function() {\n      return isIndexed(this) ? this.toIndexedSeq() :\n        isKeyed(this) ? this.toKeyedSeq() :\n        this.toSetSeq();\n    },\n\n    toStack: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return Stack(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toList: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return List(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n\n    // ### Common JavaScript methods and properties\n\n    toString: function() {\n      return '[Iterable]';\n    },\n\n    __toString: function(head, tail) {\n      if (this.size === 0) {\n        return head + tail;\n      }\n      return head + ' ' + this.toSeq().map(this.__toStringMapper).join(', ') + ' ' + tail;\n    },\n\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    concat: function() {var values = SLICE$0.call(arguments, 0);\n      return reify(this, concatFactory(this, values));\n    },\n\n    includes: function(searchValue) {\n      return this.some(function(value ) {return is(value, searchValue)});\n    },\n\n    entries: function() {\n      return this.__iterator(ITERATE_ENTRIES);\n    },\n\n    every: function(predicate, context) {\n      assertNotInfinite(this.size);\n      var returnValue = true;\n      this.__iterate(function(v, k, c)  {\n        if (!predicate.call(context, v, k, c)) {\n          returnValue = false;\n          return false;\n        }\n      });\n      return returnValue;\n    },\n\n    filter: function(predicate, context) {\n      return reify(this, filterFactory(this, predicate, context, true));\n    },\n\n    find: function(predicate, context, notSetValue) {\n      var entry = this.findEntry(predicate, context);\n      return entry ? entry[1] : notSetValue;\n    },\n\n    forEach: function(sideEffect, context) {\n      assertNotInfinite(this.size);\n      return this.__iterate(context ? sideEffect.bind(context) : sideEffect);\n    },\n\n    join: function(separator) {\n      assertNotInfinite(this.size);\n      separator = separator !== undefined ? '' + separator : ',';\n      var joined = '';\n      var isFirst = true;\n      this.__iterate(function(v ) {\n        isFirst ? (isFirst = false) : (joined += separator);\n        joined += v !== null && v !== undefined ? v.toString() : '';\n      });\n      return joined;\n    },\n\n    keys: function() {\n      return this.__iterator(ITERATE_KEYS);\n    },\n\n    map: function(mapper, context) {\n      return reify(this, mapFactory(this, mapper, context));\n    },\n\n    reduce: function(reducer, initialReduction, context) {\n      assertNotInfinite(this.size);\n      var reduction;\n      var useFirst;\n      if (arguments.length < 2) {\n        useFirst = true;\n      } else {\n        reduction = initialReduction;\n      }\n      this.__iterate(function(v, k, c)  {\n        if (useFirst) {\n          useFirst = false;\n          reduction = v;\n        } else {\n          reduction = reducer.call(context, reduction, v, k, c);\n        }\n      });\n      return reduction;\n    },\n\n    reduceRight: function(reducer, initialReduction, context) {\n      var reversed = this.toKeyedSeq().reverse();\n      return reversed.reduce.apply(reversed, arguments);\n    },\n\n    reverse: function() {\n      return reify(this, reverseFactory(this, true));\n    },\n\n    slice: function(begin, end) {\n      return reify(this, sliceFactory(this, begin, end, true));\n    },\n\n    some: function(predicate, context) {\n      return !this.every(not(predicate), context);\n    },\n\n    sort: function(comparator) {\n      return reify(this, sortFactory(this, comparator));\n    },\n\n    values: function() {\n      return this.__iterator(ITERATE_VALUES);\n    },\n\n\n    // ### More sequential methods\n\n    butLast: function() {\n      return this.slice(0, -1);\n    },\n\n    isEmpty: function() {\n      return this.size !== undefined ? this.size === 0 : !this.some(function()  {return true});\n    },\n\n    count: function(predicate, context) {\n      return ensureSize(\n        predicate ? this.toSeq().filter(predicate, context) : this\n      );\n    },\n\n    countBy: function(grouper, context) {\n      return countByFactory(this, grouper, context);\n    },\n\n    equals: function(other) {\n      return deepEqual(this, other);\n    },\n\n    entrySeq: function() {\n      var iterable = this;\n      if (iterable._cache) {\n        // We cache as an entries array, so we can just return the cache!\n        return new ArraySeq(iterable._cache);\n      }\n      var entriesSequence = iterable.toSeq().map(entryMapper).toIndexedSeq();\n      entriesSequence.fromEntrySeq = function()  {return iterable.toSeq()};\n      return entriesSequence;\n    },\n\n    filterNot: function(predicate, context) {\n      return this.filter(not(predicate), context);\n    },\n\n    findEntry: function(predicate, context, notSetValue) {\n      var found = notSetValue;\n      this.__iterate(function(v, k, c)  {\n        if (predicate.call(context, v, k, c)) {\n          found = [k, v];\n          return false;\n        }\n      });\n      return found;\n    },\n\n    findKey: function(predicate, context) {\n      var entry = this.findEntry(predicate, context);\n      return entry && entry[0];\n    },\n\n    findLast: function(predicate, context, notSetValue) {\n      return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);\n    },\n\n    findLastEntry: function(predicate, context, notSetValue) {\n      return this.toKeyedSeq().reverse().findEntry(predicate, context, notSetValue);\n    },\n\n    findLastKey: function(predicate, context) {\n      return this.toKeyedSeq().reverse().findKey(predicate, context);\n    },\n\n    first: function() {\n      return this.find(returnTrue);\n    },\n\n    flatMap: function(mapper, context) {\n      return reify(this, flatMapFactory(this, mapper, context));\n    },\n\n    flatten: function(depth) {\n      return reify(this, flattenFactory(this, depth, true));\n    },\n\n    fromEntrySeq: function() {\n      return new FromEntriesSequence(this);\n    },\n\n    get: function(searchKey, notSetValue) {\n      return this.find(function(_, key)  {return is(key, searchKey)}, undefined, notSetValue);\n    },\n\n    getIn: function(searchKeyPath, notSetValue) {\n      var nested = this;\n      // Note: in an ES6 environment, we would prefer:\n      // for (var key of searchKeyPath) {\n      var iter = forceIterator(searchKeyPath);\n      var step;\n      while (!(step = iter.next()).done) {\n        var key = step.value;\n        nested = nested && nested.get ? nested.get(key, NOT_SET) : NOT_SET;\n        if (nested === NOT_SET) {\n          return notSetValue;\n        }\n      }\n      return nested;\n    },\n\n    groupBy: function(grouper, context) {\n      return groupByFactory(this, grouper, context);\n    },\n\n    has: function(searchKey) {\n      return this.get(searchKey, NOT_SET) !== NOT_SET;\n    },\n\n    hasIn: function(searchKeyPath) {\n      return this.getIn(searchKeyPath, NOT_SET) !== NOT_SET;\n    },\n\n    isSubset: function(iter) {\n      iter = typeof iter.includes === 'function' ? iter : Iterable(iter);\n      return this.every(function(value ) {return iter.includes(value)});\n    },\n\n    isSuperset: function(iter) {\n      iter = typeof iter.isSubset === 'function' ? iter : Iterable(iter);\n      return iter.isSubset(this);\n    },\n\n    keyOf: function(searchValue) {\n      return this.findKey(function(value ) {return is(value, searchValue)});\n    },\n\n    keySeq: function() {\n      return this.toSeq().map(keyMapper).toIndexedSeq();\n    },\n\n    last: function() {\n      return this.toSeq().reverse().first();\n    },\n\n    lastKeyOf: function(searchValue) {\n      return this.toKeyedSeq().reverse().keyOf(searchValue);\n    },\n\n    max: function(comparator) {\n      return maxFactory(this, comparator);\n    },\n\n    maxBy: function(mapper, comparator) {\n      return maxFactory(this, comparator, mapper);\n    },\n\n    min: function(comparator) {\n      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator);\n    },\n\n    minBy: function(mapper, comparator) {\n      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator, mapper);\n    },\n\n    rest: function() {\n      return this.slice(1);\n    },\n\n    skip: function(amount) {\n      return this.slice(Math.max(0, amount));\n    },\n\n    skipLast: function(amount) {\n      return reify(this, this.toSeq().reverse().skip(amount).reverse());\n    },\n\n    skipWhile: function(predicate, context) {\n      return reify(this, skipWhileFactory(this, predicate, context, true));\n    },\n\n    skipUntil: function(predicate, context) {\n      return this.skipWhile(not(predicate), context);\n    },\n\n    sortBy: function(mapper, comparator) {\n      return reify(this, sortFactory(this, comparator, mapper));\n    },\n\n    take: function(amount) {\n      return this.slice(0, Math.max(0, amount));\n    },\n\n    takeLast: function(amount) {\n      return reify(this, this.toSeq().reverse().take(amount).reverse());\n    },\n\n    takeWhile: function(predicate, context) {\n      return reify(this, takeWhileFactory(this, predicate, context));\n    },\n\n    takeUntil: function(predicate, context) {\n      return this.takeWhile(not(predicate), context);\n    },\n\n    valueSeq: function() {\n      return this.toIndexedSeq();\n    },\n\n\n    // ### Hashable Object\n\n    hashCode: function() {\n      return this.__hash || (this.__hash = hashIterable(this));\n    }\n\n\n    // ### Internal\n\n    // abstract __iterate(fn, reverse)\n\n    // abstract __iterator(type, reverse)\n  });\n\n  // var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';\n  // var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';\n  // var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';\n  // var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';\n\n  var IterablePrototype = Iterable.prototype;\n  IterablePrototype[IS_ITERABLE_SENTINEL] = true;\n  IterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.values;\n  IterablePrototype.__toJS = IterablePrototype.toArray;\n  IterablePrototype.__toStringMapper = quoteString;\n  IterablePrototype.inspect =\n  IterablePrototype.toSource = function() { return this.toString(); };\n  IterablePrototype.chain = IterablePrototype.flatMap;\n  IterablePrototype.contains = IterablePrototype.includes;\n\n  mixin(KeyedIterable, {\n\n    // ### More sequential methods\n\n    flip: function() {\n      return reify(this, flipFactory(this));\n    },\n\n    mapEntries: function(mapper, context) {var this$0 = this;\n      var iterations = 0;\n      return reify(this,\n        this.toSeq().map(\n          function(v, k)  {return mapper.call(context, [k, v], iterations++, this$0)}\n        ).fromEntrySeq()\n      );\n    },\n\n    mapKeys: function(mapper, context) {var this$0 = this;\n      return reify(this,\n        this.toSeq().flip().map(\n          function(k, v)  {return mapper.call(context, k, v, this$0)}\n        ).flip()\n      );\n    }\n\n  });\n\n  var KeyedIterablePrototype = KeyedIterable.prototype;\n  KeyedIterablePrototype[IS_KEYED_SENTINEL] = true;\n  KeyedIterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.entries;\n  KeyedIterablePrototype.__toJS = IterablePrototype.toObject;\n  KeyedIterablePrototype.__toStringMapper = function(v, k)  {return JSON.stringify(k) + ': ' + quoteString(v)};\n\n\n\n  mixin(IndexedIterable, {\n\n    // ### Conversion to other types\n\n    toKeyedSeq: function() {\n      return new ToKeyedSequence(this, false);\n    },\n\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    filter: function(predicate, context) {\n      return reify(this, filterFactory(this, predicate, context, false));\n    },\n\n    findIndex: function(predicate, context) {\n      var entry = this.findEntry(predicate, context);\n      return entry ? entry[0] : -1;\n    },\n\n    indexOf: function(searchValue) {\n      var key = this.keyOf(searchValue);\n      return key === undefined ? -1 : key;\n    },\n\n    lastIndexOf: function(searchValue) {\n      var key = this.lastKeyOf(searchValue);\n      return key === undefined ? -1 : key;\n    },\n\n    reverse: function() {\n      return reify(this, reverseFactory(this, false));\n    },\n\n    slice: function(begin, end) {\n      return reify(this, sliceFactory(this, begin, end, false));\n    },\n\n    splice: function(index, removeNum /*, ...values*/) {\n      var numArgs = arguments.length;\n      removeNum = Math.max(removeNum | 0, 0);\n      if (numArgs === 0 || (numArgs === 2 && !removeNum)) {\n        return this;\n      }\n      // If index is negative, it should resolve relative to the size of the\n      // collection. However size may be expensive to compute if not cached, so\n      // only call count() if the number is in fact negative.\n      index = resolveBegin(index, index < 0 ? this.count() : this.size);\n      var spliced = this.slice(0, index);\n      return reify(\n        this,\n        numArgs === 1 ?\n          spliced :\n          spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum))\n      );\n    },\n\n\n    // ### More collection methods\n\n    findLastIndex: function(predicate, context) {\n      var entry = this.findLastEntry(predicate, context);\n      return entry ? entry[0] : -1;\n    },\n\n    first: function() {\n      return this.get(0);\n    },\n\n    flatten: function(depth) {\n      return reify(this, flattenFactory(this, depth, false));\n    },\n\n    get: function(index, notSetValue) {\n      index = wrapIndex(this, index);\n      return (index < 0 || (this.size === Infinity ||\n          (this.size !== undefined && index > this.size))) ?\n        notSetValue :\n        this.find(function(_, key)  {return key === index}, undefined, notSetValue);\n    },\n\n    has: function(index) {\n      index = wrapIndex(this, index);\n      return index >= 0 && (this.size !== undefined ?\n        this.size === Infinity || index < this.size :\n        this.indexOf(index) !== -1\n      );\n    },\n\n    interpose: function(separator) {\n      return reify(this, interposeFactory(this, separator));\n    },\n\n    interleave: function(/*...iterables*/) {\n      var iterables = [this].concat(arrCopy(arguments));\n      var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, iterables);\n      var interleaved = zipped.flatten(true);\n      if (zipped.size) {\n        interleaved.size = zipped.size * iterables.length;\n      }\n      return reify(this, interleaved);\n    },\n\n    keySeq: function() {\n      return Range(0, this.size);\n    },\n\n    last: function() {\n      return this.get(-1);\n    },\n\n    skipWhile: function(predicate, context) {\n      return reify(this, skipWhileFactory(this, predicate, context, false));\n    },\n\n    zip: function(/*, ...iterables */) {\n      var iterables = [this].concat(arrCopy(arguments));\n      return reify(this, zipWithFactory(this, defaultZipper, iterables));\n    },\n\n    zipWith: function(zipper/*, ...iterables */) {\n      var iterables = arrCopy(arguments);\n      iterables[0] = this;\n      return reify(this, zipWithFactory(this, zipper, iterables));\n    }\n\n  });\n\n  IndexedIterable.prototype[IS_INDEXED_SENTINEL] = true;\n  IndexedIterable.prototype[IS_ORDERED_SENTINEL] = true;\n\n\n\n  mixin(SetIterable, {\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    get: function(value, notSetValue) {\n      return this.has(value) ? value : notSetValue;\n    },\n\n    includes: function(value) {\n      return this.has(value);\n    },\n\n\n    // ### More sequential methods\n\n    keySeq: function() {\n      return this.valueSeq();\n    }\n\n  });\n\n  SetIterable.prototype.has = IterablePrototype.includes;\n  SetIterable.prototype.contains = SetIterable.prototype.includes;\n\n\n  // Mixin subclasses\n\n  mixin(KeyedSeq, KeyedIterable.prototype);\n  mixin(IndexedSeq, IndexedIterable.prototype);\n  mixin(SetSeq, SetIterable.prototype);\n\n  mixin(KeyedCollection, KeyedIterable.prototype);\n  mixin(IndexedCollection, IndexedIterable.prototype);\n  mixin(SetCollection, SetIterable.prototype);\n\n\n  // #pragma Helper functions\n\n  function keyMapper(v, k) {\n    return k;\n  }\n\n  function entryMapper(v, k) {\n    return [k, v];\n  }\n\n  function not(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    }\n  }\n\n  function neg(predicate) {\n    return function() {\n      return -predicate.apply(this, arguments);\n    }\n  }\n\n  function quoteString(value) {\n    return typeof value === 'string' ? JSON.stringify(value) : String(value);\n  }\n\n  function defaultZipper() {\n    return arrCopy(arguments);\n  }\n\n  function defaultNegComparator(a, b) {\n    return a < b ? 1 : a > b ? -1 : 0;\n  }\n\n  function hashIterable(iterable) {\n    if (iterable.size === Infinity) {\n      return 0;\n    }\n    var ordered = isOrdered(iterable);\n    var keyed = isKeyed(iterable);\n    var h = ordered ? 1 : 0;\n    var size = iterable.__iterate(\n      keyed ?\n        ordered ?\n          function(v, k)  { h = 31 * h + hashMerge(hash(v), hash(k)) | 0; } :\n          function(v, k)  { h = h + hashMerge(hash(v), hash(k)) | 0; } :\n        ordered ?\n          function(v ) { h = 31 * h + hash(v) | 0; } :\n          function(v ) { h = h + hash(v) | 0; }\n    );\n    return murmurHashOfSize(size, h);\n  }\n\n  function murmurHashOfSize(size, h) {\n    h = imul(h, 0xCC9E2D51);\n    h = imul(h << 15 | h >>> -15, 0x1B873593);\n    h = imul(h << 13 | h >>> -13, 5);\n    h = (h + 0xE6546B64 | 0) ^ size;\n    h = imul(h ^ h >>> 16, 0x85EBCA6B);\n    h = imul(h ^ h >>> 13, 0xC2B2AE35);\n    h = smi(h ^ h >>> 16);\n    return h;\n  }\n\n  function hashMerge(a, b) {\n    return a ^ b + 0x9E3779B9 + (a << 6) + (a >> 2) | 0; // int\n  }\n\n  var Immutable = {\n\n    Iterable: Iterable,\n\n    Seq: Seq,\n    Collection: Collection,\n    Map: Map,\n    OrderedMap: OrderedMap,\n    List: List,\n    Stack: Stack,\n    Set: Set,\n    OrderedSet: OrderedSet,\n\n    Record: Record,\n    Range: Range,\n    Repeat: Repeat,\n\n    is: is,\n    fromJS: fromJS\n\n  };\n\n  return Immutable;\n\n}));\n\n/***/ }),\n/* 245 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__conditionslabel_style_css__ = __webpack_require__(516);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__conditionslabel_style_css___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__conditionslabel_style_css__);\n\n// eslint-disable-line no-unused-vars\n\n\n// Add any default values for props\nvar defaultProps = null;\n\nfunction ConditionsLabel(_ref) {\n  var label = _ref.label,\n      scrollTo = _ref.scrollTo;\n\n  var scrollToCondition = function scrollToCondition(e) {\n    e.preventDefault();\n    if (!scrollTo) return;\n    var el = document.querySelector('#' + scrollTo);\n    if (el) {\n      el.scrollIntoView({\n        behavior: 'smooth',\n        block: 'start',\n        inline: 'nearest'\n      });\n    }\n  };\n  if (!label) return null;\n\n  if (scrollTo !== undefined) {\n    return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n      'div',\n      { className: __WEBPACK_IMPORTED_MODULE_1__conditionslabel_style_css___default.a.container },\n      __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n        'a',\n        { role: 'navigation', href: '#' + scrollTo, onClick: scrollToCondition },\n        __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n          'span',\n          { className: __WEBPACK_IMPORTED_MODULE_1__conditionslabel_style_css___default.a.label },\n          label\n        )\n      )\n    );\n  }\n\n  return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n    'div',\n    null,\n    __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n      'span',\n      { className: __WEBPACK_IMPORTED_MODULE_1__conditionslabel_style_css___default.a.label },\n      label\n    )\n  );\n}\n\nConditionsLabel.displayName = 'ConditionsLabel';\n\nConditionsLabel.defaultProps = defaultProps;\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (ConditionsLabel);\n\n/***/ }),\n/* 246 */,\n/* 247 */,\n/* 248 */,\n/* 249 */,\n/* 250 */,\n/* 251 */,\n/* 252 */,\n/* 253 */,\n/* 254 */,\n/* 255 */,\n/* 256 */,\n/* 257 */,\n/* 258 */,\n/* 259 */,\n/* 260 */,\n/* 261 */,\n/* 262 */,\n/* 263 */,\n/* 264 */,\n/* 265 */,\n/* 266 */,\n/* 267 */,\n/* 268 */,\n/* 269 */,\n/* 270 */,\n/* 271 */,\n/* 272 */,\n/* 273 */,\n/* 274 */,\n/* 275 */,\n/* 276 */,\n/* 277 */,\n/* 278 */,\n/* 279 */,\n/* 280 */,\n/* 281 */,\n/* 282 */,\n/* 283 */,\n/* 284 */,\n/* 285 */,\n/* 286 */,\n/* 287 */,\n/* 288 */,\n/* 289 */,\n/* 290 */,\n/* 291 */,\n/* 292 */,\n/* 293 */,\n/* 294 */,\n/* 295 */,\n/* 296 */,\n/* 297 */,\n/* 298 */,\n/* 299 */,\n/* 300 */,\n/* 301 */,\n/* 302 */,\n/* 303 */,\n/* 304 */,\n/* 305 */,\n/* 306 */,\n/* 307 */,\n/* 308 */,\n/* 309 */,\n/* 310 */,\n/* 311 */,\n/* 312 */,\n/* 313 */,\n/* 314 */,\n/* 315 */,\n/* 316 */,\n/* 317 */,\n/* 318 */,\n/* 319 */,\n/* 320 */,\n/* 321 */,\n/* 322 */,\n/* 323 */,\n/* 324 */,\n/* 325 */,\n/* 326 */,\n/* 327 */,\n/* 328 */,\n/* 329 */,\n/* 330 */,\n/* 331 */,\n/* 332 */,\n/* 333 */,\n/* 334 */,\n/* 335 */,\n/* 336 */,\n/* 337 */,\n/* 338 */,\n/* 339 */,\n/* 340 */,\n/* 341 */,\n/* 342 */,\n/* 343 */,\n/* 344 */,\n/* 345 */,\n/* 346 */,\n/* 347 */,\n/* 348 */,\n/* 349 */,\n/* 350 */,\n/* 351 */,\n/* 352 */,\n/* 353 */,\n/* 354 */,\n/* 355 */,\n/* 356 */,\n/* 357 */,\n/* 358 */,\n/* 359 */,\n/* 360 */,\n/* 361 */,\n/* 362 */,\n/* 363 */,\n/* 364 */,\n/* 365 */,\n/* 366 */,\n/* 367 */,\n/* 368 */,\n/* 369 */,\n/* 370 */,\n/* 371 */,\n/* 372 */,\n/* 373 */,\n/* 374 */,\n/* 375 */,\n/* 376 */,\n/* 377 */,\n/* 378 */,\n/* 379 */,\n/* 380 */,\n/* 381 */,\n/* 382 */,\n/* 383 */,\n/* 384 */,\n/* 385 */,\n/* 386 */,\n/* 387 */,\n/* 388 */,\n/* 389 */,\n/* 390 */,\n/* 391 */,\n/* 392 */,\n/* 393 */,\n/* 394 */,\n/* 395 */,\n/* 396 */,\n/* 397 */,\n/* 398 */,\n/* 399 */,\n/* 400 */,\n/* 401 */,\n/* 402 */,\n/* 403 */,\n/* 404 */,\n/* 405 */,\n/* 406 */,\n/* 407 */,\n/* 408 */,\n/* 409 */,\n/* 410 */,\n/* 411 */,\n/* 412 */,\n/* 413 */,\n/* 414 */,\n/* 415 */,\n/* 416 */,\n/* 417 */,\n/* 418 */,\n/* 419 */,\n/* 420 */,\n/* 421 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator__ = __webpack_require__(123);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react__ = __webpack_require__(0);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_draft_js__ = __webpack_require__(217);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_draft_js___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_draft_js__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_immutable__ = __webpack_require__(244);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_immutable___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_immutable__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_classnames__ = __webpack_require__(60);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_classnames__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_lodash_throttle__ = __webpack_require__(216);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_lodash_throttle___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_lodash_throttle__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__utils_responsive__ = __webpack_require__(85);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react_modal__ = __webpack_require__(68);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react_modal___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_react_modal__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__components_MyEditor_MyEditor__ = __webpack_require__(511);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__components_AuthorInfo_AuthorInfo__ = __webpack_require__(513);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__components_TopBar_TopBar__ = __webpack_require__(515);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__components_BaseButton_BaseButton__ = __webpack_require__(61);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__components_ConditionsLabel_ConditionsLabel__ = __webpack_require__(245);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13__components_ProposalStats_ProposalStats__ = __webpack_require__(518);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_14__components_ErrorMessage_ErrorMessage__ = __webpack_require__(69);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_15__proposalEditor_style_css__ = __webpack_require__(103);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_15__proposalEditor_style_css___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_15__proposalEditor_style_css__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_16__Form_Form_style_css__ = __webpack_require__(137);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_16__Form_Form_style_css___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_16__Form_Form_style_css__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_17__components_Modal_modal_style_css__ = __webpack_require__(78);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_17__components_Modal_modal_style_css___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_17__components_Modal_modal_style_css__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_18__components_RichText_RichText__ = __webpack_require__(86);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_19__proposalEditor_defaultProps__ = __webpack_require__(520);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_20__utils_request__ = __webpack_require__(104);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_21__components_ReadAloudPopover_ReadAloudPopover__ = __webpack_require__(134);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_22__components_ReadAloudButton_ReadAloudButton__ = __webpack_require__(133);\n\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step(\"next\", value); }, function (err) { step(\"throw\", err); }); } } return step(\"next\"); }); }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n\n// eslint-disable-line no-unused-vars\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nvar ProposalEditor = function (_Component) {\n  _inherits(ProposalEditor, _Component);\n\n  function ProposalEditor() {\n    var _ref,\n        _this2 = this;\n\n    var _temp, _this, _ret;\n\n    _classCallCheck(this, ProposalEditor);\n\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = ProposalEditor.__proto__ || Object.getPrototypeOf(ProposalEditor)).call.apply(_ref, [this].concat(args))), _this), _this.state = {\n      showConfirm: false\n    }, _this.handleScroll = function () {\n      _this.setState(function () {\n        return { showTopBar: global.pageYOffset > 400 };\n      });\n    }, _this.validateFields = ['title', 'remarks', 'proposalContent'], _this.loadProposal = function () {\n      var proposal = _this.props.proposalCreationViewModel.proposal;\n\n      var draft = {};\n\n      Object.keys(proposal).forEach(function (section) {\n        if (_this.validateFields.includes(section)) {\n          var content = __WEBPACK_IMPORTED_MODULE_2_draft_js__[\"ContentState\"].createFromText(proposal[section]);\n          draft[section] = __WEBPACK_IMPORTED_MODULE_2_draft_js__[\"EditorState\"].createWithContent(content);\n        }\n        draft.author = proposal.author;\n        draft.coAuthors = proposal.coAuthors;\n      });\n\n      _this.setState(function (state) {\n        return { proposal: draft };\n      });\n    }, _this.validateProposal = function () {\n      var _ref2 = _asyncToGenerator( /*#__PURE__*/__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.mark(function _callee(data, event) {\n        var _this$props, pageStructure, defaultErrors, errors, validTitle;\n\n        return __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.wrap(function _callee$(_context) {\n          while (1) {\n            switch (_context.prev = _context.next) {\n              case 0:\n                // event is used to see if it is the user, trying to submit\n                _this$props = _this.props, pageStructure = _this$props.pageStructure, defaultErrors = _this$props.defaultErrors;\n                errors = {};\n                _context.t0 = data.title;\n\n                if (!_context.t0) {\n                  _context.next = 7;\n                  break;\n                }\n\n                _context.next = 6;\n                return _this.checkTitle(data.title.getCurrentContent().getPlainText());\n\n              case 6:\n                _context.t0 = _context.sent;\n\n              case 7:\n                validTitle = _context.t0;\n\n\n                Object.keys(data).forEach(function (section) {\n                  if (_this.validateFields.includes(section)) {\n                    var maxLength = pageStructure[section + 'Section'].maxLength;\n                    var blockMap = data[section].getCurrentContent().getBlockMap();\n                    var totalChars = blockMap.reduce(function (arr, block) {\n                      return block.getLength() + arr;\n                    }, 0);\n\n                    if (!data[section].getCurrentContent().hasText() || !data[section]) {\n                      errors[section] = defaultErrors.find(function (err) {\n                        return err.errorType === 'fieldIsRequired';\n                      }).errorMessage;\n                    } else if (totalChars > maxLength) {\n                      errors[section] = defaultErrors.find(function (err) {\n                        return err.errorType === 'maxLengthExceeded';\n                      }).errorMessage;\n                    } else if (!validTitle) {\n                      errors.title = defaultErrors.find(function (err) {\n                        return err.errorType === 'isNotValidTitle';\n                      }).errorMessage;\n                    }\n                  }\n                });\n\n                _this.validateFields.forEach(function (section) {\n                  if (!data[section]) {\n                    errors[section] = defaultErrors.find(function (err) {\n                      return err.errorType === 'fieldIsRequired';\n                    }).errorMessage;\n                  }\n                });\n\n                // only show the errors if the user is trying to submit\n                event && _this.setState(function () {\n                  return { errors: errors };\n                });\n\n                if (!(Object.keys(errors).length !== 0)) {\n                  _context.next = 14;\n                  break;\n                }\n\n                _this.setState({ isValid: false });\n                return _context.abrupt('return', errors);\n\n              case 14:\n                return _context.abrupt('return', null);\n\n              case 15:\n              case 'end':\n                return _context.stop();\n            }\n          }\n        }, _callee, _this2);\n      }));\n\n      return function (_x, _x2) {\n        return _ref2.apply(this, arguments);\n      };\n    }(), _this.checkTitle = function (title) {\n      if (!title) return;\n\n      var checkTitleApi = _this.props.checkTitleApi;\n\n      var proposal = {\n        title: title\n      };\n\n      _this.setState({ checkingTitle: true });\n\n      if (true) {\n        /* Production api  */\n        return Object(__WEBPACK_IMPORTED_MODULE_20__utils_request__[\"a\" /* default */])(checkTitleApi, {\n          method: 'post',\n          headers: {\n            'content-type': 'application/json'\n          },\n          body: JSON.stringify(proposal),\n          credentials: 'include'\n        }).then(function (response) {\n          _this.setState({\n            checkingTitle: false,\n            errors: Object.assign({}, _this.state.errors, {\n              title: null\n            })\n          });\n\n          return true;\n        }).catch(function (err) {\n          _this.setState({ checkingTitle: false });\n\n          return false;\n        });\n      }\n\n      if (false) {\n        /* Used for debugging */\n        var localCheck = new Promise(function (resovle, reject) {\n          var titles = ['foo', 'bar', 'baz'];\n\n          if (titles.includes(title)) {\n            reject(title);\n          } else {\n            resovle();\n          }\n        });\n\n        return localCheck.then(function (response) {\n          _this.setState({\n            checkingTitle: false,\n            errors: Object.assign({}, _this.state.errors, {\n              title: null\n            })\n          });\n\n          return true;\n        }).catch(function (err) {\n          _this.setState({ checkingTitle: false });\n\n          return false;\n        });\n      }\n    }, _this.handleSave = function () {\n      var _ref3 = _asyncToGenerator( /*#__PURE__*/__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.mark(function _callee2(event) {\n        var proposal, _this$props2, displayStatus, pageStructure, hasErrors, data;\n\n        return __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.wrap(function _callee2$(_context2) {\n          while (1) {\n            switch (_context2.prev = _context2.next) {\n              case 0:\n                proposal = _this.state.proposal;\n                _this$props2 = _this.props, displayStatus = _this$props2.proposalCreationViewModel.proposal.displayStatus, pageStructure = _this$props2.pageStructure;\n\n                if (!(event && displayStatus === 'edit')) {\n                  _context2.next = 11;\n                  break;\n                }\n\n                // if user is trying to submit\n                event.preventDefault();\n\n                _context2.next = 6;\n                return _this.validateProposal(proposal, event);\n\n              case 6:\n                hasErrors = _context2.sent;\n\n                if (!hasErrors) {\n                  _context2.next = 10;\n                  break;\n                }\n\n                _this.focusInputOnError(pageStructure, hasErrors);\n                return _context2.abrupt('return');\n\n              case 10:\n                // do not try and submit\n                _this.setState(function () {\n                  return { isSubmitting: true };\n                });\n\n              case 11:\n                if (!(proposal && (displayStatus === 'edit' || displayStatus === 'preview'))) {\n                  _context2.next = 16;\n                  break;\n                }\n\n                data = _this.formatProposal(proposal);\n\n                if (!(data && displayStatus === 'edit')) {\n                  _context2.next = 15;\n                  break;\n                }\n\n                return _context2.abrupt('return', Object(__WEBPACK_IMPORTED_MODULE_20__utils_request__[\"a\" /* default */])(event ? _this.props.submitApi : _this.props.api, {\n                  method: 'post',\n                  headers: {\n                    'content-type': 'application/json'\n                  },\n                  body: JSON.stringify(data),\n                  credentials: 'include'\n                }).then(function (response) {\n                  // only redirect on submit\n                  if (event) global.location.href = _this.props.next.href;\n                  _this.setState(function (state) {\n                    return {\n                      data: data,\n                      isSubmitting: false,\n                      showConfirm: false\n                    };\n                  });\n                }).catch(function (error) {\n                  _this.setState(function (state) {\n                    return {\n                      data: data,\n                      isSubmitting: false,\n                      showConfirm: false\n                    };\n                  });\n                  // if the server throws an error after submitting, display the error.\n                  event && _this.setState(function () {\n                    return { error: error };\n                  });\n                }));\n\n              case 15:\n\n                global.location.href = _this.props.next.href;\n\n              case 16:\n              case 'end':\n                return _context2.stop();\n            }\n          }\n        }, _callee2, _this2);\n      }));\n\n      return function (_x3) {\n        return _ref3.apply(this, arguments);\n      };\n    }(), _this.handleBlur = function () {\n      var _ref4 = _asyncToGenerator( /*#__PURE__*/__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.mark(function _callee3(key, value) {\n        var errors, proposalErrors;\n        return __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.wrap(function _callee3$(_context3) {\n          while (1) {\n            switch (_context3.prev = _context3.next) {\n              case 0:\n                errors = Object.assign({}, _this.state.errors);\n                _context3.next = 3;\n                return _this.validateProposal(_this.state.proposal);\n\n              case 3:\n                proposalErrors = _context3.sent;\n\n\n                if (proposalErrors !== null) {\n                  _this.setState({\n                    errors: Object.assign({}, errors, _defineProperty({}, key, proposalErrors[key])),\n                    isValid: false\n                  });\n                }\n\n                if (proposalErrors === null) {\n                  _this.setState({ isValid: true, errors: null });\n                }\n\n              case 6:\n              case 'end':\n                return _context3.stop();\n            }\n          }\n        }, _callee3, _this2);\n      }));\n\n      return function (_x4, _x5) {\n        return _ref4.apply(this, arguments);\n      };\n    }(), _this.onFormChange = function () {\n      var _ref5 = _asyncToGenerator( /*#__PURE__*/__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.mark(function _callee4(editorState, section) {\n        var displayStatus, proposal;\n        return __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.wrap(function _callee4$(_context4) {\n          while (1) {\n            switch (_context4.prev = _context4.next) {\n              case 0:\n                displayStatus = _this.props.proposalCreationViewModel.proposal.displayStatus;\n\n\n                if (displayStatus === 'edit') {\n                  proposal = _this.state.proposal;\n\n                  proposal[section] = editorState;\n                  _this.setState(function (state) {\n                    return { proposal: proposal };\n                  });\n                }\n\n              case 2:\n              case 'end':\n                return _context4.stop();\n            }\n          }\n        }, _callee4, _this2);\n      }));\n\n      return function (_x6, _x7) {\n        return _ref5.apply(this, arguments);\n      };\n    }(), _this.handleConfirm = function () {\n      var _ref6 = _asyncToGenerator( /*#__PURE__*/__WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.mark(function _callee5(e) {\n        var proposal, _this$props3, displayStatus, next, errors;\n\n        return __WEBPACK_IMPORTED_MODULE_0_babel_runtime_regenerator___default.a.wrap(function _callee5$(_context5) {\n          while (1) {\n            switch (_context5.prev = _context5.next) {\n              case 0:\n                if (e) e.preventDefault();\n                proposal = _this.state.proposal;\n                _this$props3 = _this.props, displayStatus = _this$props3.proposalCreationViewModel.proposal.displayStatus, next = _this$props3.next;\n                errors = void 0;\n\n                if (!(displayStatus === 'edit')) {\n                  _context5.next = 8;\n                  break;\n                }\n\n                _context5.next = 7;\n                return _this.validateProposal(proposal);\n\n              case 7:\n                errors = _context5.sent;\n\n              case 8:\n                if (!(errors && displayStatus === 'edit')) {\n                  _context5.next = 11;\n                  break;\n                }\n\n                _this.setState({ errors: errors });\n\n                return _context5.abrupt('return');\n\n              case 11:\n\n                if (displayStatus === 'edit' && !errors) global.location.href = next.href;\n\n                if (displayStatus === 'preview') {\n                  _this.setState(function (state) {\n                    return { showConfirm: !state.showConfirm };\n                  });\n                }\n\n              case 13:\n              case 'end':\n                return _context5.stop();\n            }\n          }\n        }, _callee5, _this2);\n      }));\n\n      return function (_x8) {\n        return _ref6.apply(this, arguments);\n      };\n    }(), _temp), _possibleConstructorReturn(_this, _ret);\n  }\n\n  _createClass(ProposalEditor, [{\n    key: 'componentWillMount',\n    value: function componentWillMount() {\n      this.loadProposal();\n    }\n  }, {\n    key: 'componentDidMount',\n    value: function componentDidMount() {\n      var displayStatus = this.props.proposalCreationViewModel.proposal.displayStatus;\n\n\n      if (displayStatus === 'edit') this.autosave = setInterval(this.handleSave, 5000);\n\n      if (displayStatus === 'available') {\n        document.addEventListener('scroll', __WEBPACK_IMPORTED_MODULE_5_lodash_throttle___default()(this.handleScroll, 400));\n      }\n    }\n  }, {\n    key: 'componentWillUnmount',\n    value: function componentWillUnmount() {\n      var displayStatus = this.props.proposalCreationViewModel.proposal.displayStatus;\n\n\n      if (displayStatus === 'edit') clearInterval(this.autosave);\n\n      if (displayStatus === 'available') document.addEventListener('scroll', this.handleScroll);\n    }\n\n    /* Specify which fields where validation also occurs clientside */\n\n  }, {\n    key: 'formatProposal',\n    value: function formatProposal(proposal) {\n      var data = Object.apply({}, proposal);\n\n      Object.keys(proposal).forEach(function (p) {\n        if (proposal[p] instanceof __WEBPACK_IMPORTED_MODULE_2_draft_js__[\"EditorState\"]) {\n          data[p] = proposal[p].getCurrentContent().getPlainText();\n        }\n      });\n      data.author = proposal.author;\n      data.coAuthors = proposal.coAuthors;\n\n      return data;\n    }\n  }, {\n    key: 'focusInputOnError',\n    value: function focusInputOnError(pageStructure, errors) {\n      if (!pageStructure || !errors) {\n        return;\n      }\n\n      var form = Object.keys(pageStructure);\n\n      for (var i = 0; i < form.length; i++) {\n        // remove 'section' of string to compare to error object\n        var section = form[i].replace('Section', '');\n\n        // if error obj contains that section scrollToView and then focus on that section and break out of loop\n        if (errors.hasOwnProperty(section)) {\n          var refSelector = section + 'Editor';\n          if (refSelector) this[refSelector].handleFocus();\n          break;\n        }\n      }\n    }\n  }, {\n    key: 'getEditorState',\n    value: function getEditorState(section) {\n      var proposal = this.state.proposal;\n\n\n      return proposal[section];\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var _this3 = this;\n\n      var _props = this.props,\n          _props$pageStructure = _props.pageStructure,\n          completeProposalHintSection = _props$pageStructure.completeProposalHintSection,\n          titleSection = _props$pageStructure.titleSection,\n          proposalContentSection = _props$pageStructure.proposalContentSection,\n          remarksSection = _props$pageStructure.remarksSection,\n          overlaySection = _props$pageStructure.overlaySection,\n          proposalCreationViewModel = _props.proposalCreationViewModel,\n          _props$proposalCreati = _props.proposalCreationViewModel,\n          _props$proposalCreati2 = _props$proposalCreati.proposal,\n          displayStatus = _props$proposalCreati2.displayStatus,\n          conditionsHtml = _props$proposalCreati2.conditionsHtml,\n          conditionsHint = _props$proposalCreati2.conditionsHint,\n          externalId = _props$proposalCreati2.externalId,\n          proposalSupportersAcceptThreshold = _props$proposalCreati.proposalSupportersAcceptThreshold,\n          next = _props.next,\n          back = _props.back,\n          voteButton = _props.voteButton,\n          readAloud = _props.readAloud;\n      var _state = this.state,\n          showTopBar = _state.showTopBar,\n          proposal = _state.proposal,\n          errors = _state.errors,\n          error = _state.error,\n          isSubmitting = _state.isSubmitting,\n          checkingTitle = _state.checkingTitle,\n          showConfirm = _state.showConfirm;\n\n\n      var preview = displayStatus === 'preview' || displayStatus === 'plainview' || displayStatus === 'available';\n\n      return __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n        'div',\n        {\n          className: __WEBPACK_IMPORTED_MODULE_4_classnames___default()(preview && __WEBPACK_IMPORTED_MODULE_15__proposalEditor_style_css___default.a.preview, __WEBPACK_IMPORTED_MODULE_15__proposalEditor_style_css___default.a.proposalEditor),\n          'data-readaloud-ancestor': true\n        },\n        displayStatus === 'available' && __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_10__components_TopBar_TopBar__[\"a\" /* default */], {\n          show: showTopBar,\n          title: proposalCreationViewModel.proposal.title,\n          voteButton: voteButton,\n          conditionsHint: conditionsHtml ? { label: conditionsHint, scrollTo: 'conditions' } : false\n        }),\n        displayStatus !== 'edit' && __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_13__components_ProposalStats_ProposalStats__[\"a\" /* default */], Object.assign({}, proposalCreationViewModel.proposal, {\n          votesLimit: proposalSupportersAcceptThreshold\n        })),\n        __WEBPACK_IMPORTED_MODULE_6__utils_responsive__[\"a\" /* default */].isMobile() && displayStatus === 'available' && voteButton && __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n          'div',\n          {\n            className: __WEBPACK_IMPORTED_MODULE_4_classnames___default()(__WEBPACK_IMPORTED_MODULE_15__proposalEditor_style_css___default.a.voteButton),\n            style: { marginBottom: '10px' }\n          },\n          __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_11__components_BaseButton_BaseButton__[\"a\" /* default */], Object.assign({ primary: true }, voteButton, { fullwidth: true }))\n        ),\n        conditionsHtml && __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_12__components_ConditionsLabel_ConditionsLabel__[\"a\" /* default */], { scrollTo: 'conditions', label: conditionsHint }),\n        __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n          'section',\n          { 'data-readaloud': true },\n          __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_8__components_MyEditor_MyEditor__[\"a\" /* default */], Object.assign({\n            readOnly: preview\n          }, titleSection, {\n            editorState: proposal.title,\n            ref: function ref(node) {\n              return _this3.titleEditor = node;\n            },\n            id: 'title',\n            handleChange: this.onFormChange,\n            blockRenderMap: Object(__WEBPACK_IMPORTED_MODULE_3_immutable__[\"Map\"])({\n              unstyled: { element: preview ? 'h1' : 'div' }\n            }),\n            errors: errors,\n            onBlur: this.handleBlur,\n            checkingValue: checkingTitle\n          })),\n          displayStatus === 'available' && __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n            'span',\n            { className: __WEBPACK_IMPORTED_MODULE_15__proposalEditor_style_css___default.a.proposalId },\n            'ID: ',\n            externalId\n          )\n        ),\n        preview && readAloud ? __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n          __WEBPACK_IMPORTED_MODULE_1_react___default.a.Fragment,\n          null,\n          __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_22__components_ReadAloudButton_ReadAloudButton__[\"a\" /* default */], null),\n          __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_21__components_ReadAloudPopover_ReadAloudPopover__[\"a\" /* default */], null),\n          ' '\n        ) : null,\n        __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n          'section',\n          { 'data-readaloud': true },\n          __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_8__components_MyEditor_MyEditor__[\"a\" /* default */], Object.assign({\n            readOnly: preview\n          }, proposalContentSection, {\n            editorState: proposal.proposalContent,\n            ref: function ref(node) {\n              return _this3.proposalContentEditor = node;\n            },\n            id: 'proposalContent',\n            minHeight: 200,\n            handleChange: this.onFormChange,\n            errors: errors,\n            onBlur: this.handleBlur\n          }))\n        ),\n        __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n          'section',\n          { 'data-readaloud': true },\n          __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_8__components_MyEditor_MyEditor__[\"a\" /* default */], Object.assign({\n            readOnly: preview\n          }, remarksSection, {\n            editorState: proposal.remarks,\n            minHeight: 400,\n            ref: function ref(node) {\n              return _this3.remarksEditor = node;\n            },\n            id: 'remarks',\n            handleChange: this.onFormChange,\n            errors: errors,\n            onBlur: this.handleBlur\n          }))\n        ),\n        !preview && __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n          'p',\n          { style: { fontSize: '14px' } },\n          '* = Felter skal udfyldes'\n        ),\n        preview && __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n          'section',\n          null,\n          __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_9__components_AuthorInfo_AuthorInfo__[\"a\" /* default */], { author: proposalCreationViewModel.proposal.author }),\n          proposal.coAuthors && __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_9__components_AuthorInfo_AuthorInfo__[\"a\" /* default */], { coAuthors: proposal.coAuthors })\n        ),\n        conditionsHtml && __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n          'section',\n          { id: 'conditions' },\n          __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_12__components_ConditionsLabel_ConditionsLabel__[\"a\" /* default */], { label: 'Anm\\xE6rkning fra Folketingets Administration' }),\n          __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_18__components_RichText_RichText__[\"a\" /* default */], { html: conditionsHtml })\n        ),\n        completeProposalHintSection && __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n          'section',\n          { className: __WEBPACK_IMPORTED_MODULE_4_classnames___default()('no-print', __WEBPACK_IMPORTED_MODULE_15__proposalEditor_style_css___default.a.hint), 'data-readaloud': true },\n          __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n            'strong',\n            null,\n            completeProposalHintSection.title\n          ),\n          __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n            'p',\n            null,\n            completeProposalHintSection.description\n          )\n        ),\n        (back || next) && __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n          'div',\n          {\n            className: __WEBPACK_IMPORTED_MODULE_4_classnames___default()('no-print', __WEBPACK_IMPORTED_MODULE_15__proposalEditor_style_css___default.a.buttonGroup, 'vFact_DoNotReadAloud')\n          },\n          back && __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_11__components_BaseButton_BaseButton__[\"a\" /* default */], {\n            onClick: this.handleGoBack,\n            flat: true,\n            icon: 'back',\n            label: back.label,\n            href: back.href,\n            expands: true\n          }),\n          next && __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_11__components_BaseButton_BaseButton__[\"a\" /* default */], {\n            primary: true,\n            label: next.label // onClick={this.handleSave}\n            , onClick: preview ? this.handleConfirm : this.handleSave,\n            loading: isSubmitting,\n            type: 'submit',\n            expands: true\n          })\n        ),\n        __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_14__components_ErrorMessage_ErrorMessage__[\"a\" /* default */], { error: error }),\n        showConfirm && __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n          __WEBPACK_IMPORTED_MODULE_7_react_modal___default.a,\n          {\n            isOpen: showConfirm,\n            contentLabel: 'confirm',\n            appElement: document.querySelector('body'),\n            overlayClassName: {\n              base: __WEBPACK_IMPORTED_MODULE_17__components_Modal_modal_style_css___default.a.overlay,\n              afterOpen: __WEBPACK_IMPORTED_MODULE_17__components_Modal_modal_style_css___default.a.overlayAfteropen,\n              beforeClose: ''\n            },\n            className: {\n              base: __WEBPACK_IMPORTED_MODULE_17__components_Modal_modal_style_css___default.a.modalContent,\n              afterOpen: __WEBPACK_IMPORTED_MODULE_17__components_Modal_modal_style_css___default.a.afterOpen,\n              beforeClose: ''\n            },\n            onRequestClose: this.handleToggle\n          },\n          __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n            'div',\n            null,\n            __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n              'h2',\n              { style: { marginTop: '0px' } },\n              overlaySection && overlaySection.overlayTitle || ''\n            ),\n            __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n              'strong',\n              null,\n              overlaySection && overlaySection.title || ''\n            ),\n            __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n              'p',\n              null,\n              overlaySection && overlaySection.description || ''\n            ),\n            __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(\n              'div',\n              { className: __WEBPACK_IMPORTED_MODULE_16__Form_Form_style_css___default.a.buttonGroup },\n              __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_11__components_BaseButton_BaseButton__[\"a\" /* default */], {\n                flat: true,\n                onClick: this.handleConfirm,\n                label: overlaySection && overlaySection.back.label,\n                expands: true\n              }),\n              __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_11__components_BaseButton_BaseButton__[\"a\" /* default */], {\n                primary: true,\n                href: next.href,\n                label: overlaySection && overlaySection.next.label,\n                expands: true\n              })\n            ),\n            error && __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_14__components_ErrorMessage_ErrorMessage__[\"a\" /* default */], { error: error })\n          )\n        )\n      );\n    }\n  }]);\n\n  return ProposalEditor;\n}(__WEBPACK_IMPORTED_MODULE_1_react__[\"Component\"]);\n\nProposalEditor.displayName = 'ProposalEditor';\nProposalEditor.defaultProps = __WEBPACK_IMPORTED_MODULE_19__proposalEditor_defaultProps__[\"a\" /* default */];\n\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (ProposalEditor);\n/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(2)))\n\n/***/ }),\n/* 422 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule AtomicBlockUtils\n * @format\n * \n */\n\n\n\nvar _assign = __webpack_require__(3);\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar BlockMapBuilder = __webpack_require__(91);\nvar CharacterMetadata = __webpack_require__(63);\nvar ContentBlock = __webpack_require__(76);\nvar ContentBlockNode = __webpack_require__(64);\nvar DraftFeatureFlags = __webpack_require__(71);\nvar DraftModifier = __webpack_require__(62);\nvar EditorState = __webpack_require__(59);\nvar Immutable = __webpack_require__(57);\nvar SelectionState = __webpack_require__(83);\n\nvar generateRandomKey = __webpack_require__(70);\nvar moveBlockInContentState = __webpack_require__(437);\n\nvar experimentalTreeDataSupport = DraftFeatureFlags.draft_tree_data_support;\nvar ContentBlockRecord = experimentalTreeDataSupport ? ContentBlockNode : ContentBlock;\n\nvar List = Immutable.List,\n    Repeat = Immutable.Repeat;\n\n\nvar AtomicBlockUtils = {\n  insertAtomicBlock: function insertAtomicBlock(editorState, entityKey, character) {\n    var contentState = editorState.getCurrentContent();\n    var selectionState = editorState.getSelection();\n\n    var afterRemoval = DraftModifier.removeRange(contentState, selectionState, 'backward');\n\n    var targetSelection = afterRemoval.getSelectionAfter();\n    var afterSplit = DraftModifier.splitBlock(afterRemoval, targetSelection);\n    var insertionTarget = afterSplit.getSelectionAfter();\n\n    var asAtomicBlock = DraftModifier.setBlockType(afterSplit, insertionTarget, 'atomic');\n\n    var charData = CharacterMetadata.create({ entity: entityKey });\n\n    var atomicBlockConfig = {\n      key: generateRandomKey(),\n      type: 'atomic',\n      text: character,\n      characterList: List(Repeat(charData, character.length))\n    };\n\n    var atomicDividerBlockConfig = {\n      key: generateRandomKey(),\n      type: 'unstyled'\n    };\n\n    if (experimentalTreeDataSupport) {\n      atomicBlockConfig = _extends({}, atomicBlockConfig, {\n        nextSibling: atomicDividerBlockConfig.key\n      });\n      atomicDividerBlockConfig = _extends({}, atomicDividerBlockConfig, {\n        prevSibling: atomicBlockConfig.key\n      });\n    }\n\n    var fragmentArray = [new ContentBlockRecord(atomicBlockConfig), new ContentBlockRecord(atomicDividerBlockConfig)];\n\n    var fragment = BlockMapBuilder.createFromArray(fragmentArray);\n\n    var withAtomicBlock = DraftModifier.replaceWithFragment(asAtomicBlock, insertionTarget, fragment);\n\n    var newContent = withAtomicBlock.merge({\n      selectionBefore: selectionState,\n      selectionAfter: withAtomicBlock.getSelectionAfter().set('hasFocus', true)\n    });\n\n    return EditorState.push(editorState, newContent, 'insert-fragment');\n  },\n\n  moveAtomicBlock: function moveAtomicBlock(editorState, atomicBlock, targetRange, insertionMode) {\n    var contentState = editorState.getCurrentContent();\n    var selectionState = editorState.getSelection();\n\n    var withMovedAtomicBlock = void 0;\n\n    if (insertionMode === 'before' || insertionMode === 'after') {\n      var targetBlock = contentState.getBlockForKey(insertionMode === 'before' ? targetRange.getStartKey() : targetRange.getEndKey());\n\n      withMovedAtomicBlock = moveBlockInContentState(contentState, atomicBlock, targetBlock, insertionMode);\n    } else {\n      var afterRemoval = DraftModifier.removeRange(contentState, targetRange, 'backward');\n\n      var selectionAfterRemoval = afterRemoval.getSelectionAfter();\n      var _targetBlock = afterRemoval.getBlockForKey(selectionAfterRemoval.getFocusKey());\n\n      if (selectionAfterRemoval.getStartOffset() === 0) {\n        withMovedAtomicBlock = moveBlockInContentState(afterRemoval, atomicBlock, _targetBlock, 'before');\n      } else if (selectionAfterRemoval.getEndOffset() === _targetBlock.getLength()) {\n        withMovedAtomicBlock = moveBlockInContentState(afterRemoval, atomicBlock, _targetBlock, 'after');\n      } else {\n        var afterSplit = DraftModifier.splitBlock(afterRemoval, selectionAfterRemoval);\n\n        var selectionAfterSplit = afterSplit.getSelectionAfter();\n        var _targetBlock2 = afterSplit.getBlockForKey(selectionAfterSplit.getFocusKey());\n\n        withMovedAtomicBlock = moveBlockInContentState(afterSplit, atomicBlock, _targetBlock2, 'before');\n      }\n    }\n\n    var newContent = withMovedAtomicBlock.merge({\n      selectionBefore: selectionState,\n      selectionAfter: withMovedAtomicBlock.getSelectionAfter().set('hasFocus', true)\n    });\n\n    return EditorState.push(editorState, newContent, 'move-block');\n  }\n};\n\nmodule.exports = AtomicBlockUtils;\n\n/***/ }),\n/* 423 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftFeatureFlags-core\n * @format\n * \n */\n\n\n\nvar DraftFeatureFlags = {\n  draft_killswitch_allow_nontextnodes: false,\n  draft_segmented_entities_behavior: false,\n  draft_handlebeforeinput_composed_text: false,\n  draft_tree_data_support: false\n};\n\nmodule.exports = DraftFeatureFlags;\n\n/***/ }),\n/* 424 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ContentStateInlineStyle\n * @format\n * \n */\n\n\n\nvar CharacterMetadata = __webpack_require__(63);\n\nvar _require = __webpack_require__(57),\n    Map = _require.Map;\n\nvar ContentStateInlineStyle = {\n  add: function add(contentState, selectionState, inlineStyle) {\n    return modifyInlineStyle(contentState, selectionState, inlineStyle, true);\n  },\n\n  remove: function remove(contentState, selectionState, inlineStyle) {\n    return modifyInlineStyle(contentState, selectionState, inlineStyle, false);\n  }\n};\n\nfunction modifyInlineStyle(contentState, selectionState, inlineStyle, addOrRemove) {\n  var blockMap = contentState.getBlockMap();\n  var startKey = selectionState.getStartKey();\n  var startOffset = selectionState.getStartOffset();\n  var endKey = selectionState.getEndKey();\n  var endOffset = selectionState.getEndOffset();\n\n  var newBlocks = blockMap.skipUntil(function (_, k) {\n    return k === startKey;\n  }).takeUntil(function (_, k) {\n    return k === endKey;\n  }).concat(Map([[endKey, blockMap.get(endKey)]])).map(function (block, blockKey) {\n    var sliceStart;\n    var sliceEnd;\n\n    if (startKey === endKey) {\n      sliceStart = startOffset;\n      sliceEnd = endOffset;\n    } else {\n      sliceStart = blockKey === startKey ? startOffset : 0;\n      sliceEnd = blockKey === endKey ? endOffset : block.getLength();\n    }\n\n    var chars = block.getCharacterList();\n    var current;\n    while (sliceStart < sliceEnd) {\n      current = chars.get(sliceStart);\n      chars = chars.set(sliceStart, addOrRemove ? CharacterMetadata.applyStyle(current, inlineStyle) : CharacterMetadata.removeStyle(current, inlineStyle));\n      sliceStart++;\n    }\n\n    return block.set('characterList', chars);\n  });\n\n  return contentState.merge({\n    blockMap: blockMap.merge(newBlocks),\n    selectionBefore: selectionState,\n    selectionAfter: selectionState\n  });\n}\n\nmodule.exports = ContentStateInlineStyle;\n\n/***/ }),\n/* 425 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule applyEntityToContentState\n * @format\n * \n */\n\n\n\nvar Immutable = __webpack_require__(57);\n\nvar applyEntityToContentBlock = __webpack_require__(426);\n\nfunction applyEntityToContentState(contentState, selectionState, entityKey) {\n  var blockMap = contentState.getBlockMap();\n  var startKey = selectionState.getStartKey();\n  var startOffset = selectionState.getStartOffset();\n  var endKey = selectionState.getEndKey();\n  var endOffset = selectionState.getEndOffset();\n\n  var newBlocks = blockMap.skipUntil(function (_, k) {\n    return k === startKey;\n  }).takeUntil(function (_, k) {\n    return k === endKey;\n  }).toOrderedMap().merge(Immutable.OrderedMap([[endKey, blockMap.get(endKey)]])).map(function (block, blockKey) {\n    var sliceStart = blockKey === startKey ? startOffset : 0;\n    var sliceEnd = blockKey === endKey ? endOffset : block.getLength();\n    return applyEntityToContentBlock(block, sliceStart, sliceEnd, entityKey);\n  });\n\n  return contentState.merge({\n    blockMap: blockMap.merge(newBlocks),\n    selectionBefore: selectionState,\n    selectionAfter: selectionState\n  });\n}\n\nmodule.exports = applyEntityToContentState;\n\n/***/ }),\n/* 426 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule applyEntityToContentBlock\n * @format\n * \n */\n\n\n\nvar CharacterMetadata = __webpack_require__(63);\n\nfunction applyEntityToContentBlock(contentBlock, start, end, entityKey) {\n  var characterList = contentBlock.getCharacterList();\n  while (start < end) {\n    characterList = characterList.set(start, CharacterMetadata.applyEntity(characterList.get(start), entityKey));\n    start++;\n  }\n  return contentBlock.set('characterList', characterList);\n}\n\nmodule.exports = applyEntityToContentBlock;\n\n/***/ }),\n/* 427 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getCharacterRemovalRange\n * @format\n * \n */\n\n\n\nvar DraftEntitySegments = __webpack_require__(428);\n\nvar getRangesForDraftEntity = __webpack_require__(429);\nvar invariant = __webpack_require__(58);\n\n/**\n * Given a SelectionState and a removal direction, determine the entire range\n * that should be removed from a ContentState. This is based on any entities\n * within the target, with their `mutability` values taken into account.\n *\n * For instance, if we are attempting to remove part of an \"immutable\" entity\n * range, the entire entity must be removed. The returned `SelectionState`\n * will be adjusted accordingly.\n */\nfunction getCharacterRemovalRange(entityMap, startBlock, endBlock, selectionState, direction) {\n  var start = selectionState.getStartOffset();\n  var end = selectionState.getEndOffset();\n  var startEntityKey = startBlock.getEntityAt(start);\n  var endEntityKey = endBlock.getEntityAt(end - 1);\n  if (!startEntityKey && !endEntityKey) {\n    return selectionState;\n  }\n  var newSelectionState = selectionState;\n  if (startEntityKey && startEntityKey === endEntityKey) {\n    newSelectionState = getEntityRemovalRange(entityMap, startBlock, newSelectionState, direction, startEntityKey, true, true);\n  } else if (startEntityKey && endEntityKey) {\n    var startSelectionState = getEntityRemovalRange(entityMap, startBlock, newSelectionState, direction, startEntityKey, false, true);\n    var endSelectionState = getEntityRemovalRange(entityMap, endBlock, newSelectionState, direction, endEntityKey, false, false);\n    newSelectionState = newSelectionState.merge({\n      anchorOffset: startSelectionState.getAnchorOffset(),\n      focusOffset: endSelectionState.getFocusOffset(),\n      isBackward: false\n    });\n  } else if (startEntityKey) {\n    var _startSelectionState = getEntityRemovalRange(entityMap, startBlock, newSelectionState, direction, startEntityKey, false, true);\n    newSelectionState = newSelectionState.merge({\n      anchorOffset: _startSelectionState.getStartOffset(),\n      isBackward: false\n    });\n  } else if (endEntityKey) {\n    var _endSelectionState = getEntityRemovalRange(entityMap, endBlock, newSelectionState, direction, endEntityKey, false, false);\n    newSelectionState = newSelectionState.merge({\n      focusOffset: _endSelectionState.getEndOffset(),\n      isBackward: false\n    });\n  }\n  return newSelectionState;\n}\n\nfunction getEntityRemovalRange(entityMap, block, selectionState, direction, entityKey, isEntireSelectionWithinEntity, isEntityAtStart) {\n  var start = selectionState.getStartOffset();\n  var end = selectionState.getEndOffset();\n  var entity = entityMap.__get(entityKey);\n  var mutability = entity.getMutability();\n  var sideToConsider = isEntityAtStart ? start : end;\n\n  // `MUTABLE` entities can just have the specified range of text removed\n  // directly. No adjustments are needed.\n  if (mutability === 'MUTABLE') {\n    return selectionState;\n  }\n\n  // Find the entity range that overlaps with our removal range.\n  var entityRanges = getRangesForDraftEntity(block, entityKey).filter(function (range) {\n    return sideToConsider <= range.end && sideToConsider >= range.start;\n  });\n\n  !(entityRanges.length == 1) ?  false ? invariant(false, 'There should only be one entity range within this removal range.') : invariant(false) : void 0;\n\n  var entityRange = entityRanges[0];\n\n  // For `IMMUTABLE` entity types, we will remove the entire entity range.\n  if (mutability === 'IMMUTABLE') {\n    return selectionState.merge({\n      anchorOffset: entityRange.start,\n      focusOffset: entityRange.end,\n      isBackward: false\n    });\n  }\n\n  // For `SEGMENTED` entity types, determine the appropriate segment to\n  // remove.\n  if (!isEntireSelectionWithinEntity) {\n    if (isEntityAtStart) {\n      end = entityRange.end;\n    } else {\n      start = entityRange.start;\n    }\n  }\n\n  var removalRange = DraftEntitySegments.getRemovalRange(start, end, block.getText().slice(entityRange.start, entityRange.end), entityRange.start, direction);\n\n  return selectionState.merge({\n    anchorOffset: removalRange.start,\n    focusOffset: removalRange.end,\n    isBackward: false\n  });\n}\n\nmodule.exports = getCharacterRemovalRange;\n\n/***/ }),\n/* 428 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEntitySegments\n * @format\n * \n */\n\n\n\n/**\n * Identify the range to delete from a segmented entity.\n *\n * Rules:\n *\n *  Example: 'John F. Kennedy'\n *\n *   - Deletion from within any non-whitespace (i.e. ['John', 'F.', 'Kennedy'])\n *     will return the range of that text.\n *\n *       'John F. Kennedy' -> 'John F.'\n *                  ^\n *\n *   - Forward deletion of whitespace will remove the following section:\n *\n *       'John F. Kennedy' -> 'John Kennedy'\n *            ^\n *\n *   - Backward deletion of whitespace will remove the previous section:\n *\n *       'John F. Kennedy' -> 'F. Kennedy'\n *            ^\n */\nvar DraftEntitySegments = {\n  getRemovalRange: function getRemovalRange(selectionStart, selectionEnd, text, entityStart, direction) {\n    var segments = text.split(' ');\n    segments = segments.map(function ( /*string*/segment, /*number*/ii) {\n      if (direction === 'forward') {\n        if (ii > 0) {\n          return ' ' + segment;\n        }\n      } else if (ii < segments.length - 1) {\n        return segment + ' ';\n      }\n      return segment;\n    });\n\n    var segmentStart = entityStart;\n    var segmentEnd;\n    var segment;\n    var removalStart = null;\n    var removalEnd = null;\n\n    for (var jj = 0; jj < segments.length; jj++) {\n      segment = segments[jj];\n      segmentEnd = segmentStart + segment.length;\n\n      // Our selection overlaps this segment.\n      if (selectionStart < segmentEnd && segmentStart < selectionEnd) {\n        if (removalStart !== null) {\n          removalEnd = segmentEnd;\n        } else {\n          removalStart = segmentStart;\n          removalEnd = segmentEnd;\n        }\n      } else if (removalStart !== null) {\n        break;\n      }\n\n      segmentStart = segmentEnd;\n    }\n\n    var entityEnd = entityStart + text.length;\n    var atStart = removalStart === entityStart;\n    var atEnd = removalEnd === entityEnd;\n\n    if (!atStart && atEnd || atStart && !atEnd) {\n      if (direction === 'forward') {\n        if (removalEnd !== entityEnd) {\n          removalEnd++;\n        }\n      } else if (removalStart !== entityStart) {\n        removalStart--;\n      }\n    }\n\n    return {\n      start: removalStart,\n      end: removalEnd\n    };\n  }\n};\n\nmodule.exports = DraftEntitySegments;\n\n/***/ }),\n/* 429 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getRangesForDraftEntity\n * @format\n * \n */\n\n\n\nvar invariant = __webpack_require__(58);\n\n/**\n * Obtain the start and end positions of the range that has the\n * specified entity applied to it.\n *\n * Entity keys are applied only to contiguous stretches of text, so this\n * method searches for the first instance of the entity key and returns\n * the subsequent range.\n */\nfunction getRangesForDraftEntity(block, key) {\n  var ranges = [];\n  block.findEntityRanges(function (c) {\n    return c.getEntity() === key;\n  }, function (start, end) {\n    ranges.push({ start: start, end: end });\n  });\n\n  !!!ranges.length ?  false ? invariant(false, 'Entity key not found in this range.') : invariant(false) : void 0;\n\n  return ranges;\n}\n\nmodule.exports = getRangesForDraftEntity;\n\n/***/ }),\n/* 430 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule insertFragmentIntoContentState\n * @format\n * \n */\n\n\n\nvar BlockMapBuilder = __webpack_require__(91);\nvar ContentBlockNode = __webpack_require__(64);\nvar Immutable = __webpack_require__(57);\n\nvar insertIntoList = __webpack_require__(220);\nvar invariant = __webpack_require__(58);\nvar randomizeBlockMapKeys = __webpack_require__(218);\n\nvar List = Immutable.List;\n\n\nvar updateExistingBlock = function updateExistingBlock(contentState, selectionState, blockMap, fragmentBlock, targetKey, targetOffset) {\n  var targetBlock = blockMap.get(targetKey);\n  var text = targetBlock.getText();\n  var chars = targetBlock.getCharacterList();\n  var finalKey = targetKey;\n  var finalOffset = targetOffset + fragmentBlock.getText().length;\n\n  var newBlock = targetBlock.merge({\n    text: text.slice(0, targetOffset) + fragmentBlock.getText() + text.slice(targetOffset),\n    characterList: insertIntoList(chars, fragmentBlock.getCharacterList(), targetOffset),\n    data: fragmentBlock.getData()\n  });\n\n  return contentState.merge({\n    blockMap: blockMap.set(targetKey, newBlock),\n    selectionBefore: selectionState,\n    selectionAfter: selectionState.merge({\n      anchorKey: finalKey,\n      anchorOffset: finalOffset,\n      focusKey: finalKey,\n      focusOffset: finalOffset,\n      isBackward: false\n    })\n  });\n};\n\n/**\n * Appends text/characterList from the fragment first block to\n * target block.\n */\nvar updateHead = function updateHead(block, targetOffset, fragment) {\n  var text = block.getText();\n  var chars = block.getCharacterList();\n\n  // Modify head portion of block.\n  var headText = text.slice(0, targetOffset);\n  var headCharacters = chars.slice(0, targetOffset);\n  var appendToHead = fragment.first();\n\n  return block.merge({\n    text: headText + appendToHead.getText(),\n    characterList: headCharacters.concat(appendToHead.getCharacterList()),\n    type: headText ? block.getType() : appendToHead.getType(),\n    data: appendToHead.getData()\n  });\n};\n\n/**\n * Appends offset text/characterList from the target block to the last\n * fragment block.\n */\nvar updateTail = function updateTail(block, targetOffset, fragment) {\n  // Modify tail portion of block.\n  var text = block.getText();\n  var chars = block.getCharacterList();\n\n  // Modify head portion of block.\n  var blockSize = text.length;\n  var tailText = text.slice(targetOffset, blockSize);\n  var tailCharacters = chars.slice(targetOffset, blockSize);\n  var prependToTail = fragment.last();\n\n  return prependToTail.merge({\n    text: prependToTail.getText() + tailText,\n    characterList: prependToTail.getCharacterList().concat(tailCharacters),\n    data: prependToTail.getData()\n  });\n};\n\nvar getRootBlocks = function getRootBlocks(block, blockMap) {\n  var headKey = block.getKey();\n  var rootBlock = block;\n  var rootBlocks = [];\n\n  // sometimes the fragment head block will not be part of the blockMap itself this can happen when\n  // the fragment head is used to update the target block, however when this does not happen we need\n  // to make sure that we include it on the rootBlocks since the first block of a fragment is always a\n  // fragment root block\n  if (blockMap.get(headKey)) {\n    rootBlocks.push(headKey);\n  }\n\n  while (rootBlock && rootBlock.getNextSiblingKey()) {\n    var lastSiblingKey = rootBlock.getNextSiblingKey();\n\n    if (!lastSiblingKey) {\n      break;\n    }\n\n    rootBlocks.push(lastSiblingKey);\n    rootBlock = blockMap.get(lastSiblingKey);\n  }\n\n  return rootBlocks;\n};\n\nvar updateBlockMapLinks = function updateBlockMapLinks(blockMap, originalBlockMap, targetBlock, fragmentHeadBlock) {\n  return blockMap.withMutations(function (blockMapState) {\n    var targetKey = targetBlock.getKey();\n    var headKey = fragmentHeadBlock.getKey();\n    var targetNextKey = targetBlock.getNextSiblingKey();\n    var targetParentKey = targetBlock.getParentKey();\n    var fragmentRootBlocks = getRootBlocks(fragmentHeadBlock, blockMap);\n    var lastRootFragmentBlockKey = fragmentRootBlocks[fragmentRootBlocks.length - 1];\n\n    if (blockMapState.get(headKey)) {\n      // update the fragment head when it is part of the blockMap otherwise\n      blockMapState.setIn([targetKey, 'nextSibling'], headKey);\n      blockMapState.setIn([headKey, 'prevSibling'], targetKey);\n    } else {\n      // update the target block that had the fragment head contents merged into it\n      blockMapState.setIn([targetKey, 'nextSibling'], fragmentHeadBlock.getNextSiblingKey());\n      blockMapState.setIn([fragmentHeadBlock.getNextSiblingKey(), 'prevSibling'], targetKey);\n    }\n\n    // update the last root block fragment\n    blockMapState.setIn([lastRootFragmentBlockKey, 'nextSibling'], targetNextKey);\n\n    // update the original target next block\n    if (targetNextKey) {\n      blockMapState.setIn([targetNextKey, 'prevSibling'], lastRootFragmentBlockKey);\n    }\n\n    // update fragment parent links\n    fragmentRootBlocks.forEach(function (blockKey) {\n      return blockMapState.setIn([blockKey, 'parent'], targetParentKey);\n    });\n\n    // update targetBlock parent child links\n    if (targetParentKey) {\n      var targetParent = blockMap.get(targetParentKey);\n      var originalTargetParentChildKeys = targetParent.getChildKeys();\n\n      var targetBlockIndex = originalTargetParentChildKeys.indexOf(targetKey);\n      var insertionIndex = targetBlockIndex + 1;\n\n      var newChildrenKeysArray = originalTargetParentChildKeys.toArray();\n\n      // insert fragment children\n      newChildrenKeysArray.splice.apply(newChildrenKeysArray, [insertionIndex, 0].concat(fragmentRootBlocks));\n\n      blockMapState.setIn([targetParentKey, 'children'], List(newChildrenKeysArray));\n    }\n  });\n};\n\nvar insertFragment = function insertFragment(contentState, selectionState, blockMap, fragment, targetKey, targetOffset) {\n  var isTreeBasedBlockMap = blockMap.first() instanceof ContentBlockNode;\n  var newBlockArr = [];\n  var fragmentSize = fragment.size;\n  var target = blockMap.get(targetKey);\n  var head = fragment.first();\n  var tail = fragment.last();\n  var finalOffset = tail.getLength();\n  var finalKey = tail.getKey();\n  var shouldNotUpdateFromFragmentBlock = isTreeBasedBlockMap && (!target.getChildKeys().isEmpty() || !head.getChildKeys().isEmpty());\n\n  blockMap.forEach(function (block, blockKey) {\n    if (blockKey !== targetKey) {\n      newBlockArr.push(block);\n      return;\n    }\n\n    if (shouldNotUpdateFromFragmentBlock) {\n      newBlockArr.push(block);\n    } else {\n      newBlockArr.push(updateHead(block, targetOffset, fragment));\n    }\n\n    // Insert fragment blocks after the head and before the tail.\n    fragment\n    // when we are updating the target block with the head fragment block we skip the first fragment\n    // head since its contents have already been merged with the target block otherwise we include\n    // the whole fragment\n    .slice(shouldNotUpdateFromFragmentBlock ? 0 : 1, fragmentSize - 1).forEach(function (fragmentBlock) {\n      return newBlockArr.push(fragmentBlock);\n    });\n\n    // update tail\n    newBlockArr.push(updateTail(block, targetOffset, fragment));\n  });\n\n  var updatedBlockMap = BlockMapBuilder.createFromArray(newBlockArr);\n\n  if (isTreeBasedBlockMap) {\n    updatedBlockMap = updateBlockMapLinks(updatedBlockMap, blockMap, target, head);\n  }\n\n  return contentState.merge({\n    blockMap: updatedBlockMap,\n    selectionBefore: selectionState,\n    selectionAfter: selectionState.merge({\n      anchorKey: finalKey,\n      anchorOffset: finalOffset,\n      focusKey: finalKey,\n      focusOffset: finalOffset,\n      isBackward: false\n    })\n  });\n};\n\nvar insertFragmentIntoContentState = function insertFragmentIntoContentState(contentState, selectionState, fragmentBlockMap) {\n  !selectionState.isCollapsed() ?  false ? invariant(false, '`insertFragment` should only be called with a collapsed selection state.') : invariant(false) : void 0;\n\n  var blockMap = contentState.getBlockMap();\n  var fragment = randomizeBlockMapKeys(fragmentBlockMap);\n  var targetKey = selectionState.getStartKey();\n  var targetOffset = selectionState.getStartOffset();\n\n  var targetBlock = blockMap.get(targetKey);\n\n  if (targetBlock instanceof ContentBlockNode) {\n    !targetBlock.getChildKeys().isEmpty() ?  false ? invariant(false, '`insertFragment` should not be called when a container node is selected.') : invariant(false) : void 0;\n  }\n\n  // When we insert a fragment with a single block we simply update the target block\n  // with the contents of the inserted fragment block\n  if (fragment.size === 1) {\n    return updateExistingBlock(contentState, selectionState, blockMap, fragment.first(), targetKey, targetOffset);\n  }\n\n  return insertFragment(contentState, selectionState, blockMap, fragment, targetKey, targetOffset);\n};\n\nmodule.exports = insertFragmentIntoContentState;\n\n/***/ }),\n/* 431 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule insertTextIntoContentState\n * @format\n * \n */\n\n\n\nvar Immutable = __webpack_require__(57);\n\nvar insertIntoList = __webpack_require__(220);\nvar invariant = __webpack_require__(58);\n\nvar Repeat = Immutable.Repeat;\n\n\nfunction insertTextIntoContentState(contentState, selectionState, text, characterMetadata) {\n  !selectionState.isCollapsed() ?  false ? invariant(false, '`insertText` should only be called with a collapsed range.') : invariant(false) : void 0;\n\n  var len = text.length;\n  if (!len) {\n    return contentState;\n  }\n\n  var blockMap = contentState.getBlockMap();\n  var key = selectionState.getStartKey();\n  var offset = selectionState.getStartOffset();\n  var block = blockMap.get(key);\n  var blockText = block.getText();\n\n  var newBlock = block.merge({\n    text: blockText.slice(0, offset) + text + blockText.slice(offset, block.getLength()),\n    characterList: insertIntoList(block.getCharacterList(), Repeat(characterMetadata, len).toList(), offset)\n  });\n\n  var newOffset = offset + len;\n\n  return contentState.merge({\n    blockMap: blockMap.set(key, newBlock),\n    selectionAfter: selectionState.merge({\n      anchorOffset: newOffset,\n      focusOffset: newOffset\n    })\n  });\n}\n\nmodule.exports = insertTextIntoContentState;\n\n/***/ }),\n/* 432 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule modifyBlockForContentState\n * @format\n * \n */\n\n\n\nvar Immutable = __webpack_require__(57);\n\nvar Map = Immutable.Map;\n\n\nfunction modifyBlockForContentState(contentState, selectionState, operation) {\n  var startKey = selectionState.getStartKey();\n  var endKey = selectionState.getEndKey();\n  var blockMap = contentState.getBlockMap();\n  var newBlocks = blockMap.toSeq().skipUntil(function (_, k) {\n    return k === startKey;\n  }).takeUntil(function (_, k) {\n    return k === endKey;\n  }).concat(Map([[endKey, blockMap.get(endKey)]])).map(operation);\n\n  return contentState.merge({\n    blockMap: blockMap.merge(newBlocks),\n    selectionBefore: selectionState,\n    selectionAfter: selectionState\n  });\n}\n\nmodule.exports = modifyBlockForContentState;\n\n/***/ }),\n/* 433 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule removeRangeFromContentState\n * @format\n * \n */\n\n\n\nvar ContentBlockNode = __webpack_require__(64);\nvar Immutable = __webpack_require__(57);\n\nvar getNextDelimiterBlockKey = __webpack_require__(221);\n\nvar List = Immutable.List,\n    Map = Immutable.Map;\n\n\nvar transformBlock = function transformBlock(key, blockMap, func) {\n  if (!key) {\n    return;\n  }\n\n  var block = blockMap.get(key);\n\n  if (!block) {\n    return;\n  }\n\n  blockMap.set(key, func(block));\n};\n\n/**\n * Ancestors needs to be preserved when there are non selected\n * children to make sure we do not leave any orphans behind\n */\nvar getAncestorsKeys = function getAncestorsKeys(blockKey, blockMap) {\n  var parents = [];\n\n  if (!blockKey) {\n    return parents;\n  }\n\n  var blockNode = blockMap.get(blockKey);\n  while (blockNode && blockNode.getParentKey()) {\n    var parentKey = blockNode.getParentKey();\n    if (parentKey) {\n      parents.push(parentKey);\n    }\n    blockNode = parentKey ? blockMap.get(parentKey) : null;\n  }\n\n  return parents;\n};\n\n/**\n * Get all next delimiter keys until we hit a root delimiter and return\n * an array of key references\n */\nvar getNextDelimitersBlockKeys = function getNextDelimitersBlockKeys(block, blockMap) {\n  var nextDelimiters = [];\n\n  if (!block) {\n    return nextDelimiters;\n  }\n\n  var nextDelimiter = getNextDelimiterBlockKey(block, blockMap);\n  while (nextDelimiter && blockMap.get(nextDelimiter)) {\n    var _block = blockMap.get(nextDelimiter);\n    nextDelimiters.push(nextDelimiter);\n\n    // we do not need to keep checking all root node siblings, just the first occurance\n    nextDelimiter = _block.getParentKey() ? getNextDelimiterBlockKey(_block, blockMap) : null;\n  }\n\n  return nextDelimiters;\n};\n\nvar getNextValidSibling = function getNextValidSibling(block, blockMap, originalBlockMap) {\n  if (!block) {\n    return null;\n  }\n\n  // note that we need to make sure we refer to the original block since this\n  // function is called within a withMutations\n  var nextValidSiblingKey = originalBlockMap.get(block.getKey()).getNextSiblingKey();\n\n  while (nextValidSiblingKey && !blockMap.get(nextValidSiblingKey)) {\n    nextValidSiblingKey = originalBlockMap.get(nextValidSiblingKey).getNextSiblingKey() || null;\n  }\n\n  return nextValidSiblingKey;\n};\n\nvar getPrevValidSibling = function getPrevValidSibling(block, blockMap, originalBlockMap) {\n  if (!block) {\n    return null;\n  }\n\n  // note that we need to make sure we refer to the original block since this\n  // function is called within a withMutations\n  var prevValidSiblingKey = originalBlockMap.get(block.getKey()).getPrevSiblingKey();\n\n  while (prevValidSiblingKey && !blockMap.get(prevValidSiblingKey)) {\n    prevValidSiblingKey = originalBlockMap.get(prevValidSiblingKey).getPrevSiblingKey() || null;\n  }\n\n  return prevValidSiblingKey;\n};\n\nvar updateBlockMapLinks = function updateBlockMapLinks(blockMap, startBlock, endBlock, originalBlockMap) {\n  return blockMap.withMutations(function (blocks) {\n    // update start block if its retained\n    transformBlock(startBlock.getKey(), blocks, function (block) {\n      return block.merge({\n        nextSibling: getNextValidSibling(startBlock, blocks, originalBlockMap),\n        prevSibling: getPrevValidSibling(startBlock, blocks, originalBlockMap)\n      });\n    });\n\n    // update endblock if its retained\n    transformBlock(endBlock.getKey(), blocks, function (block) {\n      return block.merge({\n        nextSibling: getNextValidSibling(endBlock, blocks, originalBlockMap),\n        prevSibling: getPrevValidSibling(endBlock, blocks, originalBlockMap)\n      });\n    });\n\n    // update start block parent ancestors\n    getAncestorsKeys(startBlock.getKey(), originalBlockMap).forEach(function (parentKey) {\n      return transformBlock(parentKey, blocks, function (block) {\n        return block.merge({\n          children: block.getChildKeys().filter(function (key) {\n            return blocks.get(key);\n          }),\n          nextSibling: getNextValidSibling(block, blocks, originalBlockMap),\n          prevSibling: getPrevValidSibling(block, blocks, originalBlockMap)\n        });\n      });\n    });\n\n    // update start block next - can only happen if startBlock == endBlock\n    transformBlock(startBlock.getNextSiblingKey(), blocks, function (block) {\n      return block.merge({\n        prevSibling: startBlock.getPrevSiblingKey()\n      });\n    });\n\n    // update start block prev\n    transformBlock(startBlock.getPrevSiblingKey(), blocks, function (block) {\n      return block.merge({\n        nextSibling: getNextValidSibling(startBlock, blocks, originalBlockMap)\n      });\n    });\n\n    // update end block next\n    transformBlock(endBlock.getNextSiblingKey(), blocks, function (block) {\n      return block.merge({\n        prevSibling: getPrevValidSibling(endBlock, blocks, originalBlockMap)\n      });\n    });\n\n    // update end block prev\n    transformBlock(endBlock.getPrevSiblingKey(), blocks, function (block) {\n      return block.merge({\n        nextSibling: endBlock.getNextSiblingKey()\n      });\n    });\n\n    // update end block parent ancestors\n    getAncestorsKeys(endBlock.getKey(), originalBlockMap).forEach(function (parentKey) {\n      transformBlock(parentKey, blocks, function (block) {\n        return block.merge({\n          children: block.getChildKeys().filter(function (key) {\n            return blocks.get(key);\n          }),\n          nextSibling: getNextValidSibling(block, blocks, originalBlockMap),\n          prevSibling: getPrevValidSibling(block, blocks, originalBlockMap)\n        });\n      });\n    });\n\n    // update next delimiters all the way to a root delimiter\n    getNextDelimitersBlockKeys(endBlock, originalBlockMap).forEach(function (delimiterKey) {\n      return transformBlock(delimiterKey, blocks, function (block) {\n        return block.merge({\n          nextSibling: getNextValidSibling(block, blocks, originalBlockMap),\n          prevSibling: getPrevValidSibling(block, blocks, originalBlockMap)\n        });\n      });\n    });\n  });\n};\n\nvar removeRangeFromContentState = function removeRangeFromContentState(contentState, selectionState) {\n  if (selectionState.isCollapsed()) {\n    return contentState;\n  }\n\n  var blockMap = contentState.getBlockMap();\n  var startKey = selectionState.getStartKey();\n  var startOffset = selectionState.getStartOffset();\n  var endKey = selectionState.getEndKey();\n  var endOffset = selectionState.getEndOffset();\n\n  var startBlock = blockMap.get(startKey);\n  var endBlock = blockMap.get(endKey);\n\n  // we assume that ContentBlockNode and ContentBlocks are not mixed together\n  var isExperimentalTreeBlock = startBlock instanceof ContentBlockNode;\n\n  // used to retain blocks that should not be deleted to avoid orphan children\n  var parentAncestors = [];\n\n  if (isExperimentalTreeBlock) {\n    var endBlockchildrenKeys = endBlock.getChildKeys();\n    var endBlockAncestors = getAncestorsKeys(endKey, blockMap);\n\n    // endBlock has unselected sibblings so we can not remove its ancestors parents\n    if (endBlock.getNextSiblingKey()) {\n      parentAncestors = parentAncestors.concat(endBlockAncestors);\n    }\n\n    // endBlock has children so can not remove this block or any of its ancestors\n    if (!endBlockchildrenKeys.isEmpty()) {\n      parentAncestors = parentAncestors.concat(endBlockAncestors.concat([endKey]));\n    }\n\n    // we need to retain all ancestors of the next delimiter block\n    parentAncestors = parentAncestors.concat(getAncestorsKeys(getNextDelimiterBlockKey(endBlock, blockMap), blockMap));\n  }\n\n  var characterList = void 0;\n\n  if (startBlock === endBlock) {\n    characterList = removeFromList(startBlock.getCharacterList(), startOffset, endOffset);\n  } else {\n    characterList = startBlock.getCharacterList().slice(0, startOffset).concat(endBlock.getCharacterList().slice(endOffset));\n  }\n\n  var modifiedStart = startBlock.merge({\n    text: startBlock.getText().slice(0, startOffset) + endBlock.getText().slice(endOffset),\n    characterList: characterList\n  });\n\n  var newBlocks = blockMap.toSeq().skipUntil(function (_, k) {\n    return k === startKey;\n  }).takeUntil(function (_, k) {\n    return k === endKey;\n  }).filter(function (_, k) {\n    return parentAncestors.indexOf(k) === -1;\n  }).concat(Map([[endKey, null]])).map(function (_, k) {\n    return k === startKey ? modifiedStart : null;\n  });\n\n  var updatedBlockMap = blockMap.merge(newBlocks).filter(function (block) {\n    return !!block;\n  });\n\n  if (isExperimentalTreeBlock) {\n    updatedBlockMap = updateBlockMapLinks(updatedBlockMap, startBlock, endBlock, blockMap);\n  }\n\n  return contentState.merge({\n    blockMap: updatedBlockMap,\n    selectionBefore: selectionState,\n    selectionAfter: selectionState.merge({\n      anchorKey: startKey,\n      anchorOffset: startOffset,\n      focusKey: startKey,\n      focusOffset: startOffset,\n      isBackward: false\n    })\n  });\n};\n\n/**\n * Maintain persistence for target list when removing characters on the\n * head and tail of the character list.\n */\nvar removeFromList = function removeFromList(targetList, startOffset, endOffset) {\n  if (startOffset === 0) {\n    while (startOffset < endOffset) {\n      targetList = targetList.shift();\n      startOffset++;\n    }\n  } else if (endOffset === targetList.count()) {\n    while (endOffset > startOffset) {\n      targetList = targetList.pop();\n      endOffset--;\n    }\n  } else {\n    var head = targetList.slice(0, startOffset);\n    var tail = targetList.slice(endOffset);\n    targetList = head.concat(tail).toList();\n  }\n  return targetList;\n};\n\nmodule.exports = removeRangeFromContentState;\n\n/***/ }),\n/* 434 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule splitBlockInContentState\n * @format\n * \n */\n\n\n\nvar ContentBlockNode = __webpack_require__(64);\nvar Immutable = __webpack_require__(57);\n\nvar generateRandomKey = __webpack_require__(70);\nvar invariant = __webpack_require__(58);\n\nvar List = Immutable.List,\n    Map = Immutable.Map;\n\n\nvar transformBlock = function transformBlock(key, blockMap, func) {\n  if (!key) {\n    return;\n  }\n\n  var block = blockMap.get(key);\n\n  if (!block) {\n    return;\n  }\n\n  blockMap.set(key, func(block));\n};\n\nvar updateBlockMapLinks = function updateBlockMapLinks(blockMap, originalBlock, belowBlock) {\n  return blockMap.withMutations(function (blocks) {\n    var originalBlockKey = originalBlock.getKey();\n    var belowBlockKey = belowBlock.getKey();\n\n    // update block parent\n    transformBlock(originalBlock.getParentKey(), blocks, function (block) {\n      var parentChildrenList = block.getChildKeys();\n      var insertionIndex = parentChildrenList.indexOf(originalBlockKey) + 1;\n      var newChildrenArray = parentChildrenList.toArray();\n\n      newChildrenArray.splice(insertionIndex, 0, belowBlockKey);\n\n      return block.merge({\n        children: List(newChildrenArray)\n      });\n    });\n\n    // update original next block\n    transformBlock(originalBlock.getNextSiblingKey(), blocks, function (block) {\n      return block.merge({\n        prevSibling: belowBlockKey\n      });\n    });\n\n    // update original block\n    transformBlock(originalBlockKey, blocks, function (block) {\n      return block.merge({\n        nextSibling: belowBlockKey\n      });\n    });\n\n    // update below block\n    transformBlock(belowBlockKey, blocks, function (block) {\n      return block.merge({\n        prevSibling: originalBlockKey\n      });\n    });\n  });\n};\n\nvar splitBlockInContentState = function splitBlockInContentState(contentState, selectionState) {\n  !selectionState.isCollapsed() ?  false ? invariant(false, 'Selection range must be collapsed.') : invariant(false) : void 0;\n\n  var key = selectionState.getAnchorKey();\n  var offset = selectionState.getAnchorOffset();\n  var blockMap = contentState.getBlockMap();\n  var blockToSplit = blockMap.get(key);\n  var text = blockToSplit.getText();\n  var chars = blockToSplit.getCharacterList();\n  var keyBelow = generateRandomKey();\n  var isExperimentalTreeBlock = blockToSplit instanceof ContentBlockNode;\n\n  var blockAbove = blockToSplit.merge({\n    text: text.slice(0, offset),\n    characterList: chars.slice(0, offset)\n  });\n  var blockBelow = blockAbove.merge({\n    key: keyBelow,\n    text: text.slice(offset),\n    characterList: chars.slice(offset),\n    data: Map()\n  });\n\n  var blocksBefore = blockMap.toSeq().takeUntil(function (v) {\n    return v === blockToSplit;\n  });\n  var blocksAfter = blockMap.toSeq().skipUntil(function (v) {\n    return v === blockToSplit;\n  }).rest();\n  var newBlocks = blocksBefore.concat([[key, blockAbove], [keyBelow, blockBelow]], blocksAfter).toOrderedMap();\n\n  if (isExperimentalTreeBlock) {\n    !blockToSplit.getChildKeys().isEmpty() ?  false ? invariant(false, 'ContentBlockNode must not have children') : invariant(false) : void 0;\n\n    newBlocks = updateBlockMapLinks(newBlocks, blockAbove, blockBelow);\n  }\n\n  return contentState.merge({\n    blockMap: newBlocks,\n    selectionBefore: selectionState,\n    selectionAfter: selectionState.merge({\n      anchorKey: keyBelow,\n      anchorOffset: 0,\n      focusKey: keyBelow,\n      focusOffset: 0,\n      isBackward: false\n    })\n  });\n};\n\nmodule.exports = splitBlockInContentState;\n\n/***/ }),\n/* 435 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule EditorBidiService\n * @format\n * \n */\n\n\n\nvar Immutable = __webpack_require__(57);\nvar UnicodeBidiService = __webpack_require__(436);\n\nvar nullthrows = __webpack_require__(65);\n\nvar OrderedMap = Immutable.OrderedMap;\n\n\nvar bidiService;\n\nvar EditorBidiService = {\n  getDirectionMap: function getDirectionMap(content, prevBidiMap) {\n    if (!bidiService) {\n      bidiService = new UnicodeBidiService();\n    } else {\n      bidiService.reset();\n    }\n\n    var blockMap = content.getBlockMap();\n    var nextBidi = blockMap.valueSeq().map(function (block) {\n      return nullthrows(bidiService).getDirection(block.getText());\n    });\n    var bidiMap = OrderedMap(blockMap.keySeq().zip(nextBidi));\n\n    if (prevBidiMap != null && Immutable.is(prevBidiMap, bidiMap)) {\n      return prevBidiMap;\n    }\n\n    return bidiMap;\n  }\n};\n\nmodule.exports = EditorBidiService;\n\n/***/ }),\n/* 436 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n * \n */\n\n/**\n * Stateful API for text direction detection\n *\n * This class can be used in applications where you need to detect the\n * direction of a sequence of text blocks, where each direction shall be used\n * as the fallback direction for the next one.\n *\n * NOTE: A default direction, if not provided, is set based on the global\n *       direction, as defined by `UnicodeBidiDirection`.\n *\n * == Example ==\n * ```\n * var UnicodeBidiService = require('UnicodeBidiService');\n *\n * var bidiService = new UnicodeBidiService();\n *\n * ...\n *\n * bidiService.reset();\n * for (var para in paragraphs) {\n *   var dir = bidiService.getDirection(para);\n *   ...\n * }\n * ```\n *\n * Part of our implementation of Unicode Bidirectional Algorithm (UBA)\n * Unicode Standard Annex #9 (UAX9)\n * http://www.unicode.org/reports/tr9/\n */\n\n\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar UnicodeBidi = __webpack_require__(224);\nvar UnicodeBidiDirection = __webpack_require__(159);\n\nvar invariant = __webpack_require__(58);\n\nvar UnicodeBidiService = function () {\n\n  /**\n   * Stateful class for paragraph direction detection\n   *\n   * @param defaultDir  Default direction of the service\n   */\n  function UnicodeBidiService(defaultDir) {\n    _classCallCheck(this, UnicodeBidiService);\n\n    if (!defaultDir) {\n      defaultDir = UnicodeBidiDirection.getGlobalDir();\n    } else {\n      !UnicodeBidiDirection.isStrong(defaultDir) ?  false ? invariant(false, 'Default direction must be a strong direction (LTR or RTL)') : invariant(false) : void 0;\n    }\n    this._defaultDir = defaultDir;\n    this.reset();\n  }\n\n  /**\n   * Reset the internal state\n   *\n   * Instead of creating a new instance, you can just reset() your instance\n   * everytime you start a new loop.\n   */\n\n\n  UnicodeBidiService.prototype.reset = function reset() {\n    this._lastDir = this._defaultDir;\n  };\n\n  /**\n   * Returns the direction of a block of text, and remembers it as the\n   * fall-back direction for the next paragraph.\n   *\n   * @param str  A text block, e.g. paragraph, table cell, tag\n   * @return     The resolved direction\n   */\n\n\n  UnicodeBidiService.prototype.getDirection = function getDirection(str) {\n    this._lastDir = UnicodeBidi.getDirection(str, this._lastDir);\n    return this._lastDir;\n  };\n\n  return UnicodeBidiService;\n}();\n\nmodule.exports = UnicodeBidiService;\n\n/***/ }),\n/* 437 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule moveBlockInContentState\n * @format\n * \n */\n\n\n\nvar ContentBlockNode = __webpack_require__(64);\nvar Immutable = __webpack_require__(57);\n\nvar getNextDelimiterBlockKey = __webpack_require__(221);\nvar invariant = __webpack_require__(58);\n\nvar OrderedMap = Immutable.OrderedMap,\n    List = Immutable.List;\n\n\nvar transformBlock = function transformBlock(key, blockMap, func) {\n  if (!key) {\n    return;\n  }\n\n  var block = blockMap.get(key);\n\n  if (!block) {\n    return;\n  }\n\n  blockMap.set(key, func(block));\n};\n\nvar updateBlockMapLinks = function updateBlockMapLinks(blockMap, originalBlockToBeMoved, originalTargetBlock, insertionMode, isExperimentalTreeBlock) {\n  if (!isExperimentalTreeBlock) {\n    return blockMap;\n  }\n  // possible values of 'insertionMode' are: 'after', 'before'\n  var isInsertedAfterTarget = insertionMode === 'after';\n\n  var originalBlockKey = originalBlockToBeMoved.getKey();\n  var originalTargetKey = originalTargetBlock.getKey();\n  var originalParentKey = originalBlockToBeMoved.getParentKey();\n  var originalNextSiblingKey = originalBlockToBeMoved.getNextSiblingKey();\n  var originalPrevSiblingKey = originalBlockToBeMoved.getPrevSiblingKey();\n  var newParentKey = originalTargetBlock.getParentKey();\n  var newNextSiblingKey = isInsertedAfterTarget ? originalTargetBlock.getNextSiblingKey() : originalTargetKey;\n  var newPrevSiblingKey = isInsertedAfterTarget ? originalTargetKey : originalTargetBlock.getPrevSiblingKey();\n\n  return blockMap.withMutations(function (blocks) {\n    // update old parent\n    transformBlock(originalParentKey, blocks, function (block) {\n      var parentChildrenList = block.getChildKeys();\n      return block.merge({\n        children: parentChildrenList['delete'](parentChildrenList.indexOf(originalBlockKey))\n      });\n    });\n\n    // update old prev\n    transformBlock(originalPrevSiblingKey, blocks, function (block) {\n      return block.merge({\n        nextSibling: originalNextSiblingKey\n      });\n    });\n\n    // update old next\n    transformBlock(originalNextSiblingKey, blocks, function (block) {\n      return block.merge({\n        prevSibling: originalPrevSiblingKey\n      });\n    });\n\n    // update new next\n    transformBlock(newNextSiblingKey, blocks, function (block) {\n      return block.merge({\n        prevSibling: originalBlockKey\n      });\n    });\n\n    // update new prev\n    transformBlock(newPrevSiblingKey, blocks, function (block) {\n      return block.merge({\n        nextSibling: originalBlockKey\n      });\n    });\n\n    // update new parent\n    transformBlock(newParentKey, blocks, function (block) {\n      var newParentChildrenList = block.getChildKeys();\n      var targetBlockIndex = newParentChildrenList.indexOf(originalTargetKey);\n\n      var insertionIndex = isInsertedAfterTarget ? targetBlockIndex + 1 : targetBlockIndex !== 0 ? targetBlockIndex - 1 : 0;\n\n      var newChildrenArray = newParentChildrenList.toArray();\n      newChildrenArray.splice(insertionIndex, 0, originalBlockKey);\n\n      return block.merge({\n        children: List(newChildrenArray)\n      });\n    });\n\n    // update block\n    transformBlock(originalBlockKey, blocks, function (block) {\n      return block.merge({\n        nextSibling: newNextSiblingKey,\n        prevSibling: newPrevSiblingKey,\n        parent: newParentKey\n      });\n    });\n  });\n};\n\nvar moveBlockInContentState = function moveBlockInContentState(contentState, blockToBeMoved, targetBlock, insertionMode) {\n  !(insertionMode !== 'replace') ?  false ? invariant(false, 'Replacing blocks is not supported.') : invariant(false) : void 0;\n\n  var targetKey = targetBlock.getKey();\n  var blockKey = blockToBeMoved.getKey();\n\n  !(blockKey !== targetKey) ?  false ? invariant(false, 'Block cannot be moved next to itself.') : invariant(false) : void 0;\n\n  var blockMap = contentState.getBlockMap();\n  var isExperimentalTreeBlock = blockToBeMoved instanceof ContentBlockNode;\n\n  var blocksToBeMoved = [blockToBeMoved];\n  var blockMapWithoutBlocksToBeMoved = blockMap['delete'](blockKey);\n\n  if (isExperimentalTreeBlock) {\n    blocksToBeMoved = [];\n    blockMapWithoutBlocksToBeMoved = blockMap.withMutations(function (blocks) {\n      var nextSiblingKey = blockToBeMoved.getNextSiblingKey();\n      var nextDelimiterBlockKey = getNextDelimiterBlockKey(blockToBeMoved, blocks);\n\n      blocks.toSeq().skipUntil(function (block) {\n        return block.getKey() === blockKey;\n      }).takeWhile(function (block) {\n        var key = block.getKey();\n        var isBlockToBeMoved = key === blockKey;\n        var hasNextSiblingAndIsNotNextSibling = nextSiblingKey && key !== nextSiblingKey;\n        var doesNotHaveNextSiblingAndIsNotDelimiter = !nextSiblingKey && block.getParentKey() && (!nextDelimiterBlockKey || key !== nextDelimiterBlockKey);\n\n        return !!(isBlockToBeMoved || hasNextSiblingAndIsNotNextSibling || doesNotHaveNextSiblingAndIsNotDelimiter);\n      }).forEach(function (block) {\n        blocksToBeMoved.push(block);\n        blocks['delete'](block.getKey());\n      });\n    });\n  }\n\n  var blocksBefore = blockMapWithoutBlocksToBeMoved.toSeq().takeUntil(function (v) {\n    return v === targetBlock;\n  });\n\n  var blocksAfter = blockMapWithoutBlocksToBeMoved.toSeq().skipUntil(function (v) {\n    return v === targetBlock;\n  }).skip(1);\n\n  var slicedBlocks = blocksToBeMoved.map(function (block) {\n    return [block.getKey(), block];\n  });\n\n  var newBlocks = OrderedMap();\n\n  if (insertionMode === 'before') {\n    var blockBefore = contentState.getBlockBefore(targetKey);\n\n    !(!blockBefore || blockBefore.getKey() !== blockToBeMoved.getKey()) ?  false ? invariant(false, 'Block cannot be moved next to itself.') : invariant(false) : void 0;\n\n    newBlocks = blocksBefore.concat([].concat(slicedBlocks, [[targetKey, targetBlock]]), blocksAfter).toOrderedMap();\n  } else if (insertionMode === 'after') {\n    var blockAfter = contentState.getBlockAfter(targetKey);\n\n    !(!blockAfter || blockAfter.getKey() !== blockKey) ?  false ? invariant(false, 'Block cannot be moved next to itself.') : invariant(false) : void 0;\n\n    newBlocks = blocksBefore.concat([[targetKey, targetBlock]].concat(slicedBlocks), blocksAfter).toOrderedMap();\n  }\n\n  return contentState.merge({\n    blockMap: updateBlockMapLinks(newBlocks, blockToBeMoved, targetBlock, insertionMode, isExperimentalTreeBlock),\n    selectionBefore: contentState.getSelectionAfter(),\n    selectionAfter: contentState.getSelectionAfter().merge({\n      anchorKey: blockKey,\n      focusKey: blockKey\n    })\n  });\n};\n\nmodule.exports = moveBlockInContentState;\n\n/***/ }),\n/* 438 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule CompositeDraftDecorator\n * @format\n * \n */\n\n\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Immutable = __webpack_require__(57);\n\nvar List = Immutable.List;\n\n\nvar DELIMITER = '.';\n\n/**\n * A CompositeDraftDecorator traverses through a list of DraftDecorator\n * instances to identify sections of a ContentBlock that should be rendered\n * in a \"decorated\" manner. For example, hashtags, mentions, and links may\n * be intended to stand out visually, be rendered as anchors, etc.\n *\n * The list of decorators supplied to the constructor will be used in the\n * order they are provided. This allows the caller to specify a priority for\n * string matching, in case of match collisions among decorators.\n *\n * For instance, I may have a link with a `#` in its text. Though this section\n * of text may match our hashtag decorator, it should not be treated as a\n * hashtag. I should therefore list my link DraftDecorator\n * before my hashtag DraftDecorator when constructing this composite\n * decorator instance.\n *\n * Thus, when a collision like this is encountered, the earlier match is\n * preserved and the new match is discarded.\n */\n\nvar CompositeDraftDecorator = function () {\n  function CompositeDraftDecorator(decorators) {\n    _classCallCheck(this, CompositeDraftDecorator);\n\n    // Copy the decorator array, since we use this array order to determine\n    // precedence of decoration matching. If the array is mutated externally,\n    // we don't want to be affected here.\n    this._decorators = decorators.slice();\n  }\n\n  CompositeDraftDecorator.prototype.getDecorations = function getDecorations(block, contentState) {\n    var decorations = Array(block.getText().length).fill(null);\n\n    this._decorators.forEach(function ( /*object*/decorator, /*number*/ii) {\n      var counter = 0;\n      var strategy = decorator.strategy;\n      var callback = function callback( /*number*/start, /*number*/end) {\n        // Find out if any of our matching range is already occupied\n        // by another decorator. If so, discard the match. Otherwise, store\n        // the component key for rendering.\n        if (canOccupySlice(decorations, start, end)) {\n          occupySlice(decorations, start, end, ii + DELIMITER + counter);\n          counter++;\n        }\n      };\n      strategy(block, callback, contentState);\n    });\n\n    return List(decorations);\n  };\n\n  CompositeDraftDecorator.prototype.getComponentForKey = function getComponentForKey(key) {\n    var componentKey = parseInt(key.split(DELIMITER)[0], 10);\n    return this._decorators[componentKey].component;\n  };\n\n  CompositeDraftDecorator.prototype.getPropsForKey = function getPropsForKey(key) {\n    var componentKey = parseInt(key.split(DELIMITER)[0], 10);\n    return this._decorators[componentKey].props;\n  };\n\n  return CompositeDraftDecorator;\n}();\n\n/**\n * Determine whether we can occupy the specified slice of the decorations\n * array.\n */\n\n\nfunction canOccupySlice(decorations, start, end) {\n  for (var ii = start; ii < end; ii++) {\n    if (decorations[ii] != null) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Splice the specified component into our decoration array at the desired\n * range.\n */\nfunction occupySlice(targetArr, start, end, componentKey) {\n  for (var ii = start; ii < end; ii++) {\n    targetArr[ii] = componentKey;\n  }\n}\n\nmodule.exports = CompositeDraftDecorator;\n\n/***/ }),\n/* 439 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditor.react\n * @format\n * \n * @preventMunge\n */\n\n\n\nvar _assign = __webpack_require__(3);\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar DefaultDraftBlockRenderMap = __webpack_require__(160);\nvar DefaultDraftInlineStyle = __webpack_require__(225);\nvar DraftEditorCompositionHandler = __webpack_require__(440);\nvar DraftEditorContents = __webpack_require__(441);\nvar DraftEditorDragHandler = __webpack_require__(464);\nvar DraftEditorEditHandler = __webpack_require__(467);\nvar DraftEditorPlaceholder = __webpack_require__(500);\nvar EditorState = __webpack_require__(59);\nvar React = __webpack_require__(0);\nvar ReactDOM = __webpack_require__(1);\nvar Scroll = __webpack_require__(229);\nvar Style = __webpack_require__(164);\nvar UserAgent = __webpack_require__(67);\n\nvar cx = __webpack_require__(84);\nvar emptyFunction = __webpack_require__(156);\nvar generateRandomKey = __webpack_require__(70);\nvar getDefaultKeyBinding = __webpack_require__(242);\nvar getScrollPosition = __webpack_require__(165);\nvar invariant = __webpack_require__(58);\nvar nullthrows = __webpack_require__(65);\n\nvar isIE = UserAgent.isBrowser('IE');\n\n// IE does not support the `input` event on contentEditable, so we can't\n// observe spellcheck behavior.\nvar allowSpellCheck = !isIE;\n\n// Define a set of handler objects to correspond to each possible `mode`\n// of editor behavior.\nvar handlerMap = {\n  edit: DraftEditorEditHandler,\n  composite: DraftEditorCompositionHandler,\n  drag: DraftEditorDragHandler,\n  cut: null,\n  render: null\n};\n\n/**\n * `DraftEditor` is the root editor component. It composes a `contentEditable`\n * div, and provides a wide variety of useful function props for managing the\n * state of the editor. See `DraftEditorProps` for details.\n */\nvar DraftEditor = function (_React$Component) {\n  _inherits(DraftEditor, _React$Component);\n\n  function DraftEditor(props) {\n    _classCallCheck(this, DraftEditor);\n\n    var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));\n\n    _this.focus = function (scrollPosition) {\n      var editorState = _this.props.editorState;\n\n      var alreadyHasFocus = editorState.getSelection().getHasFocus();\n      var editorNode = ReactDOM.findDOMNode(_this.editor);\n\n      if (!editorNode) {\n        // once in a while people call 'focus' in a setTimeout, and the node has\n        // been deleted, so it can be null in that case.\n        return;\n      }\n\n      var scrollParent = Style.getScrollParent(editorNode);\n\n      var _ref = scrollPosition || getScrollPosition(scrollParent),\n          x = _ref.x,\n          y = _ref.y;\n\n      !(editorNode instanceof HTMLElement) ?  false ? invariant(false, 'editorNode is not an HTMLElement') : invariant(false) : void 0;\n      editorNode.focus();\n\n      // Restore scroll position\n      if (scrollParent === window) {\n        window.scrollTo(x, y);\n      } else {\n        Scroll.setTop(scrollParent, y);\n      }\n\n      // On Chrome and Safari, calling focus on contenteditable focuses the\n      // cursor at the first character. This is something you don't expect when\n      // you're clicking on an input element but not directly on a character.\n      // Put the cursor back where it was before the blur.\n      if (!alreadyHasFocus) {\n        _this.update(EditorState.forceSelection(editorState, editorState.getSelection()));\n      }\n    };\n\n    _this.blur = function () {\n      var editorNode = ReactDOM.findDOMNode(_this.editor);\n      !(editorNode instanceof HTMLElement) ?  false ? invariant(false, 'editorNode is not an HTMLElement') : invariant(false) : void 0;\n      editorNode.blur();\n    };\n\n    _this.setMode = function (mode) {\n      _this._handler = handlerMap[mode];\n    };\n\n    _this.exitCurrentMode = function () {\n      _this.setMode('edit');\n    };\n\n    _this.restoreEditorDOM = function (scrollPosition) {\n      _this.setState({ contentsKey: _this.state.contentsKey + 1 }, function () {\n        _this.focus(scrollPosition);\n      });\n    };\n\n    _this.setClipboard = function (clipboard) {\n      _this._clipboard = clipboard;\n    };\n\n    _this.getClipboard = function () {\n      return _this._clipboard;\n    };\n\n    _this.update = function (editorState) {\n      _this._latestEditorState = editorState;\n      _this.props.onChange(editorState);\n    };\n\n    _this.onDragEnter = function () {\n      _this._dragCount++;\n    };\n\n    _this.onDragLeave = function () {\n      _this._dragCount--;\n      if (_this._dragCount === 0) {\n        _this.exitCurrentMode();\n      }\n    };\n\n    _this._blockSelectEvents = false;\n    _this._clipboard = null;\n    _this._handler = null;\n    _this._dragCount = 0;\n    _this._editorKey = props.editorKey || generateRandomKey();\n    _this._placeholderAccessibilityID = 'placeholder-' + _this._editorKey;\n    _this._latestEditorState = props.editorState;\n    _this._latestCommittedEditorState = props.editorState;\n\n    _this._onBeforeInput = _this._buildHandler('onBeforeInput');\n    _this._onBlur = _this._buildHandler('onBlur');\n    _this._onCharacterData = _this._buildHandler('onCharacterData');\n    _this._onCompositionEnd = _this._buildHandler('onCompositionEnd');\n    _this._onCompositionStart = _this._buildHandler('onCompositionStart');\n    _this._onCopy = _this._buildHandler('onCopy');\n    _this._onCut = _this._buildHandler('onCut');\n    _this._onDragEnd = _this._buildHandler('onDragEnd');\n    _this._onDragOver = _this._buildHandler('onDragOver');\n    _this._onDragStart = _this._buildHandler('onDragStart');\n    _this._onDrop = _this._buildHandler('onDrop');\n    _this._onInput = _this._buildHandler('onInput');\n    _this._onFocus = _this._buildHandler('onFocus');\n    _this._onKeyDown = _this._buildHandler('onKeyDown');\n    _this._onKeyPress = _this._buildHandler('onKeyPress');\n    _this._onKeyUp = _this._buildHandler('onKeyUp');\n    _this._onMouseDown = _this._buildHandler('onMouseDown');\n    _this._onMouseUp = _this._buildHandler('onMouseUp');\n    _this._onPaste = _this._buildHandler('onPaste');\n    _this._onSelect = _this._buildHandler('onSelect');\n\n    _this.getEditorKey = function () {\n      return _this._editorKey;\n    };\n\n    // See `restoreEditorDOM()`.\n    _this.state = { contentsKey: 0 };\n    return _this;\n  }\n\n  /**\n   * Build a method that will pass the event to the specified handler method.\n   * This allows us to look up the correct handler function for the current\n   * editor mode, if any has been specified.\n   */\n\n\n  /**\n   * Define proxies that can route events to the current handler.\n   */\n\n\n  DraftEditor.prototype._buildHandler = function _buildHandler(eventName) {\n    var _this2 = this;\n\n    return function (e) {\n      if (!_this2.props.readOnly) {\n        var method = _this2._handler && _this2._handler[eventName];\n        method && method(_this2, e);\n      }\n    };\n  };\n\n  DraftEditor.prototype._showPlaceholder = function _showPlaceholder() {\n    return !!this.props.placeholder && !this.props.editorState.isInCompositionMode() && !this.props.editorState.getCurrentContent().hasText();\n  };\n\n  DraftEditor.prototype._renderPlaceholder = function _renderPlaceholder() {\n    if (this._showPlaceholder()) {\n      var placeHolderProps = {\n        text: nullthrows(this.props.placeholder),\n        editorState: this.props.editorState,\n        textAlignment: this.props.textAlignment,\n        accessibilityID: this._placeholderAccessibilityID\n      };\n\n      return React.createElement(DraftEditorPlaceholder, placeHolderProps);\n    }\n    return null;\n  };\n\n  DraftEditor.prototype.render = function render() {\n    var _this3 = this;\n\n    var _props = this.props,\n        blockRenderMap = _props.blockRenderMap,\n        blockRendererFn = _props.blockRendererFn,\n        blockStyleFn = _props.blockStyleFn,\n        customStyleFn = _props.customStyleFn,\n        customStyleMap = _props.customStyleMap,\n        editorState = _props.editorState,\n        readOnly = _props.readOnly,\n        textAlignment = _props.textAlignment,\n        textDirectionality = _props.textDirectionality;\n\n\n    var rootClass = cx({\n      'DraftEditor/root': true,\n      'DraftEditor/alignLeft': textAlignment === 'left',\n      'DraftEditor/alignRight': textAlignment === 'right',\n      'DraftEditor/alignCenter': textAlignment === 'center'\n    });\n\n    var contentStyle = {\n      outline: 'none',\n      // fix parent-draggable Safari bug. #1326\n      userSelect: 'text',\n      WebkitUserSelect: 'text',\n      whiteSpace: 'pre-wrap',\n      wordWrap: 'break-word'\n    };\n\n    // The aria-expanded and aria-haspopup properties should only be rendered\n    // for a combobox.\n    var ariaRole = this.props.role || 'textbox';\n    var ariaExpanded = ariaRole === 'combobox' ? !!this.props.ariaExpanded : null;\n\n    var editorContentsProps = {\n      blockRenderMap: blockRenderMap,\n      blockRendererFn: blockRendererFn,\n      blockStyleFn: blockStyleFn,\n      customStyleMap: _extends({}, DefaultDraftInlineStyle, customStyleMap),\n      customStyleFn: customStyleFn,\n      editorKey: this._editorKey,\n      editorState: editorState,\n      key: 'contents' + this.state.contentsKey,\n      textDirectionality: textDirectionality\n    };\n\n    return React.createElement(\n      'div',\n      { className: rootClass },\n      this._renderPlaceholder(),\n      React.createElement(\n        'div',\n        {\n          className: cx('DraftEditor/editorContainer'),\n          ref: function ref(_ref3) {\n            return _this3.editorContainer = _ref3;\n          } },\n        React.createElement(\n          'div',\n          {\n            'aria-activedescendant': readOnly ? null : this.props.ariaActiveDescendantID,\n            'aria-autocomplete': readOnly ? null : this.props.ariaAutoComplete,\n            'aria-controls': readOnly ? null : this.props.ariaControls,\n            'aria-describedby': this.props.ariaDescribedBy || this._placeholderAccessibilityID,\n            'aria-expanded': readOnly ? null : ariaExpanded,\n            'aria-label': this.props.ariaLabel,\n            'aria-labelledby': this.props.ariaLabelledBy,\n            'aria-multiline': this.props.ariaMultiline,\n            autoCapitalize: this.props.autoCapitalize,\n            autoComplete: this.props.autoComplete,\n            autoCorrect: this.props.autoCorrect,\n            className: cx({\n              // Chrome's built-in translation feature mutates the DOM in ways\n              // that Draft doesn't expect (ex: adding <font> tags inside\n              // DraftEditorLeaf spans) and causes problems. We add notranslate\n              // here which makes its autotranslation skip over this subtree.\n              notranslate: !readOnly,\n              'public/DraftEditor/content': true\n            }),\n            contentEditable: !readOnly,\n            'data-testid': this.props.webDriverTestID,\n            onBeforeInput: this._onBeforeInput,\n            onBlur: this._onBlur,\n            onCompositionEnd: this._onCompositionEnd,\n            onCompositionStart: this._onCompositionStart,\n            onCopy: this._onCopy,\n            onCut: this._onCut,\n            onDragEnd: this._onDragEnd,\n            onDragEnter: this.onDragEnter,\n            onDragLeave: this.onDragLeave,\n            onDragOver: this._onDragOver,\n            onDragStart: this._onDragStart,\n            onDrop: this._onDrop,\n            onFocus: this._onFocus,\n            onInput: this._onInput,\n            onKeyDown: this._onKeyDown,\n            onKeyPress: this._onKeyPress,\n            onKeyUp: this._onKeyUp,\n            onMouseUp: this._onMouseUp,\n            onPaste: this._onPaste,\n            onSelect: this._onSelect,\n            ref: function ref(_ref2) {\n              return _this3.editor = _ref2;\n            },\n            role: readOnly ? null : ariaRole,\n            spellCheck: allowSpellCheck && this.props.spellCheck,\n            style: contentStyle,\n            suppressContentEditableWarning: true,\n            tabIndex: this.props.tabIndex },\n          React.createElement(DraftEditorContents, editorContentsProps)\n        )\n      )\n    );\n  };\n\n  DraftEditor.prototype.componentDidMount = function componentDidMount() {\n    this.setMode('edit');\n\n    /**\n     * IE has a hardcoded \"feature\" that attempts to convert link text into\n     * anchors in contentEditable DOM. This breaks the editor's expectations of\n     * the DOM, and control is lost. Disable it to make IE behave.\n     * See: http://blogs.msdn.com/b/ieinternals/archive/2010/09/15/\n     * ie9-beta-minor-change-list.aspx\n     */\n    if (isIE) {\n      document.execCommand('AutoUrlDetect', false, false);\n    }\n  };\n\n  /**\n   * Prevent selection events from affecting the current editor state. This\n   * is mostly intended to defend against IE, which fires off `selectionchange`\n   * events regardless of whether the selection is set via the browser or\n   * programmatically. We only care about selection events that occur because\n   * of browser interaction, not re-renders and forced selections.\n   */\n\n\n  DraftEditor.prototype.componentWillUpdate = function componentWillUpdate(nextProps) {\n    this._blockSelectEvents = true;\n    this._latestEditorState = nextProps.editorState;\n  };\n\n  DraftEditor.prototype.componentDidUpdate = function componentDidUpdate() {\n    this._blockSelectEvents = false;\n    this._latestCommittedEditorState = this.props.editorState;\n  };\n\n  /**\n   * Used via `this.focus()`.\n   *\n   * Force focus back onto the editor node.\n   *\n   * We attempt to preserve scroll position when focusing. You can also pass\n   * a specified scroll position (for cases like `cut` behavior where it should\n   * be restored to a known position).\n   */\n\n\n  /**\n   * Used via `this.setMode(...)`.\n   *\n   * Set the behavior mode for the editor component. This switches the current\n   * handler module to ensure that DOM events are managed appropriately for\n   * the active mode.\n   */\n\n\n  /**\n   * Used via `this.restoreEditorDOM()`.\n   *\n   * Force a complete re-render of the DraftEditorContents based on the current\n   * EditorState. This is useful when we know we are going to lose control of\n   * the DOM state (cut command, IME) and we want to make sure that\n   * reconciliation occurs on a version of the DOM that is synchronized with\n   * our EditorState.\n   */\n\n\n  /**\n   * Used via `this.setClipboard(...)`.\n   *\n   * Set the clipboard state for a cut/copy event.\n   */\n\n\n  /**\n   * Used via `this.getClipboard()`.\n   *\n   * Retrieve the clipboard state for a cut/copy event.\n   */\n\n\n  /**\n   * Used via `this.update(...)`.\n   *\n   * Propagate a new `EditorState` object to higher-level components. This is\n   * the method by which event handlers inform the `DraftEditor` component of\n   * state changes. A component that composes a `DraftEditor` **must** provide\n   * an `onChange` prop to receive state updates passed along from this\n   * function.\n   */\n\n\n  /**\n   * Used in conjunction with `onDragLeave()`, by counting the number of times\n   * a dragged element enters and leaves the editor (or any of its children),\n   * to determine when the dragged element absolutely leaves the editor.\n   */\n\n\n  /**\n   * See `onDragEnter()`.\n   */\n\n\n  return DraftEditor;\n}(React.Component);\n\nDraftEditor.defaultProps = {\n  blockRenderMap: DefaultDraftBlockRenderMap,\n  blockRendererFn: emptyFunction.thatReturnsNull,\n  blockStyleFn: emptyFunction.thatReturns(''),\n  keyBindingFn: getDefaultKeyBinding,\n  readOnly: false,\n  spellCheck: false,\n  stripPastedStyles: false\n};\n\n\nmodule.exports = DraftEditor;\n\n/***/ }),\n/* 440 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorCompositionHandler\n * @format\n * \n */\n\n\n\nvar DraftFeatureFlags = __webpack_require__(71);\nvar DraftModifier = __webpack_require__(62);\nvar EditorState = __webpack_require__(59);\nvar Keys = __webpack_require__(161);\n\nvar getEntityKeyForSelection = __webpack_require__(162);\nvar isEventHandled = __webpack_require__(93);\nvar isSelectionAtLeafStart = __webpack_require__(226);\n\n/**\n * Millisecond delay to allow `compositionstart` to fire again upon\n * `compositionend`.\n *\n * This is used for Korean input to ensure that typing can continue without\n * the editor trying to render too quickly. More specifically, Safari 7.1+\n * triggers `compositionstart` a little slower than Chrome/FF, which\n * leads to composed characters being resolved and re-render occurring\n * sooner than we want.\n */\nvar RESOLVE_DELAY = 20;\n\n/**\n * A handful of variables used to track the current composition and its\n * resolution status. These exist at the module level because it is not\n * possible to have compositions occurring in multiple editors simultaneously,\n * and it simplifies state management with respect to the DraftEditor component.\n */\nvar resolved = false;\nvar stillComposing = false;\nvar textInputData = '';\n\nvar DraftEditorCompositionHandler = {\n  onBeforeInput: function onBeforeInput(editor, e) {\n    textInputData = (textInputData || '') + e.data;\n  },\n\n  /**\n   * A `compositionstart` event has fired while we're still in composition\n   * mode. Continue the current composition session to prevent a re-render.\n   */\n  onCompositionStart: function onCompositionStart(editor) {\n    stillComposing = true;\n  },\n\n  /**\n   * Attempt to end the current composition session.\n   *\n   * Defer handling because browser will still insert the chars into active\n   * element after `compositionend`. If a `compositionstart` event fires\n   * before `resolveComposition` executes, our composition session will\n   * continue.\n   *\n   * The `resolved` flag is useful because certain IME interfaces fire the\n   * `compositionend` event multiple times, thus queueing up multiple attempts\n   * at handling the composition. Since handling the same composition event\n   * twice could break the DOM, we only use the first event. Example: Arabic\n   * Google Input Tools on Windows 8.1 fires `compositionend` three times.\n   */\n  onCompositionEnd: function onCompositionEnd(editor) {\n    resolved = false;\n    stillComposing = false;\n    setTimeout(function () {\n      if (!resolved) {\n        DraftEditorCompositionHandler.resolveComposition(editor);\n      }\n    }, RESOLVE_DELAY);\n  },\n\n  /**\n   * In Safari, keydown events may fire when committing compositions. If\n   * the arrow keys are used to commit, prevent default so that the cursor\n   * doesn't move, otherwise it will jump back noticeably on re-render.\n   */\n  onKeyDown: function onKeyDown(editor, e) {\n    if (!stillComposing) {\n      // If a keydown event is received after compositionend but before the\n      // 20ms timer expires (ex: type option-E then backspace, or type A then\n      // backspace in 2-Set Korean), we should immediately resolve the\n      // composition and reinterpret the key press in edit mode.\n      DraftEditorCompositionHandler.resolveComposition(editor);\n      editor._onKeyDown(e);\n      return;\n    }\n    if (e.which === Keys.RIGHT || e.which === Keys.LEFT) {\n      e.preventDefault();\n    }\n  },\n\n  /**\n   * Keypress events may fire when committing compositions. In Firefox,\n   * pressing RETURN commits the composition and inserts extra newline\n   * characters that we do not want. `preventDefault` allows the composition\n   * to be committed while preventing the extra characters.\n   */\n  onKeyPress: function onKeyPress(editor, e) {\n    if (e.which === Keys.RETURN) {\n      e.preventDefault();\n    }\n  },\n\n  /**\n   * Attempt to insert composed characters into the document.\n   *\n   * If we are still in a composition session, do nothing. Otherwise, insert\n   * the characters into the document and terminate the composition session.\n   *\n   * If no characters were composed -- for instance, the user\n   * deleted all composed characters and committed nothing new --\n   * force a re-render. We also re-render when the composition occurs\n   * at the beginning of a leaf, to ensure that if the browser has\n   * created a new text node for the composition, we will discard it.\n   *\n   * Resetting innerHTML will move focus to the beginning of the editor,\n   * so we update to force it back to the correct place.\n   */\n  resolveComposition: function resolveComposition(editor) {\n    if (stillComposing) {\n      return;\n    }\n\n    resolved = true;\n    var composedChars = textInputData;\n    textInputData = '';\n\n    var editorState = EditorState.set(editor._latestEditorState, {\n      inCompositionMode: false\n    });\n\n    var currentStyle = editorState.getCurrentInlineStyle();\n    var entityKey = getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection());\n\n    var mustReset = !composedChars || isSelectionAtLeafStart(editorState) || currentStyle.size > 0 || entityKey !== null;\n\n    if (mustReset) {\n      editor.restoreEditorDOM();\n    }\n\n    editor.exitCurrentMode();\n\n    if (composedChars) {\n      if (DraftFeatureFlags.draft_handlebeforeinput_composed_text && editor.props.handleBeforeInput && isEventHandled(editor.props.handleBeforeInput(composedChars, editorState))) {\n        return;\n      }\n      // If characters have been composed, re-rendering with the update\n      // is sufficient to reset the editor.\n      var contentState = DraftModifier.replaceText(editorState.getCurrentContent(), editorState.getSelection(), composedChars, currentStyle, entityKey);\n      editor.update(EditorState.push(editorState, contentState, 'insert-characters'));\n      return;\n    }\n\n    if (mustReset) {\n      editor.update(EditorState.set(editorState, {\n        nativelyRenderedContent: null,\n        forceSelection: true\n      }));\n    }\n  }\n};\n\nmodule.exports = DraftEditorCompositionHandler;\n\n/***/ }),\n/* 441 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorContents.react\n * @format\n * \n */\n\n\n\nvar DraftEditorContents = __webpack_require__(442);\n\nmodule.exports = DraftEditorContents;\n\n/***/ }),\n/* 442 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorContents-core.react\n * @format\n * \n */\n\n\n\nvar _assign = __webpack_require__(3);\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar DraftEditorBlock = __webpack_require__(227);\nvar DraftOffsetKey = __webpack_require__(116);\nvar EditorState = __webpack_require__(59);\nvar React = __webpack_require__(0);\n\nvar cx = __webpack_require__(84);\nvar joinClasses = __webpack_require__(463);\nvar nullthrows = __webpack_require__(65);\n\n/**\n * Provide default styling for list items. This way, lists will be styled with\n * proper counters and indentation even if the caller does not specify\n * their own styling at all. If more than five levels of nesting are needed,\n * the necessary CSS classes can be provided via `blockStyleFn` configuration.\n */\nvar getListItemClasses = function getListItemClasses(type, depth, shouldResetCount, direction) {\n  return cx({\n    'public/DraftStyleDefault/unorderedListItem': type === 'unordered-list-item',\n    'public/DraftStyleDefault/orderedListItem': type === 'ordered-list-item',\n    'public/DraftStyleDefault/reset': shouldResetCount,\n    'public/DraftStyleDefault/depth0': depth === 0,\n    'public/DraftStyleDefault/depth1': depth === 1,\n    'public/DraftStyleDefault/depth2': depth === 2,\n    'public/DraftStyleDefault/depth3': depth === 3,\n    'public/DraftStyleDefault/depth4': depth === 4,\n    'public/DraftStyleDefault/listLTR': direction === 'LTR',\n    'public/DraftStyleDefault/listRTL': direction === 'RTL'\n  });\n};\n\n/**\n * `DraftEditorContents` is the container component for all block components\n * rendered for a `DraftEditor`. It is optimized to aggressively avoid\n * re-rendering blocks whenever possible.\n *\n * This component is separate from `DraftEditor` because certain props\n * (for instance, ARIA props) must be allowed to update without affecting\n * the contents of the editor.\n */\n\nvar DraftEditorContents = function (_React$Component) {\n  _inherits(DraftEditorContents, _React$Component);\n\n  function DraftEditorContents() {\n    _classCallCheck(this, DraftEditorContents);\n\n    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));\n  }\n\n  DraftEditorContents.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n    var prevEditorState = this.props.editorState;\n    var nextEditorState = nextProps.editorState;\n\n    var prevDirectionMap = prevEditorState.getDirectionMap();\n    var nextDirectionMap = nextEditorState.getDirectionMap();\n\n    // Text direction has changed for one or more blocks. We must re-render.\n    if (prevDirectionMap !== nextDirectionMap) {\n      return true;\n    }\n\n    var didHaveFocus = prevEditorState.getSelection().getHasFocus();\n    var nowHasFocus = nextEditorState.getSelection().getHasFocus();\n\n    if (didHaveFocus !== nowHasFocus) {\n      return true;\n    }\n\n    var nextNativeContent = nextEditorState.getNativelyRenderedContent();\n\n    var wasComposing = prevEditorState.isInCompositionMode();\n    var nowComposing = nextEditorState.isInCompositionMode();\n\n    // If the state is unchanged or we're currently rendering a natively\n    // rendered state, there's nothing new to be done.\n    if (prevEditorState === nextEditorState || nextNativeContent !== null && nextEditorState.getCurrentContent() === nextNativeContent || wasComposing && nowComposing) {\n      return false;\n    }\n\n    var prevContent = prevEditorState.getCurrentContent();\n    var nextContent = nextEditorState.getCurrentContent();\n    var prevDecorator = prevEditorState.getDecorator();\n    var nextDecorator = nextEditorState.getDecorator();\n    return wasComposing !== nowComposing || prevContent !== nextContent || prevDecorator !== nextDecorator || nextEditorState.mustForceSelection();\n  };\n\n  DraftEditorContents.prototype.render = function render() {\n    var _props = this.props,\n        blockRenderMap = _props.blockRenderMap,\n        blockRendererFn = _props.blockRendererFn,\n        blockStyleFn = _props.blockStyleFn,\n        customStyleMap = _props.customStyleMap,\n        customStyleFn = _props.customStyleFn,\n        editorState = _props.editorState,\n        editorKey = _props.editorKey,\n        textDirectionality = _props.textDirectionality;\n\n\n    var content = editorState.getCurrentContent();\n    var selection = editorState.getSelection();\n    var forceSelection = editorState.mustForceSelection();\n    var decorator = editorState.getDecorator();\n    var directionMap = nullthrows(editorState.getDirectionMap());\n\n    var blocksAsArray = content.getBlocksAsArray();\n    var processedBlocks = [];\n\n    var currentDepth = null;\n    var lastWrapperTemplate = null;\n\n    for (var ii = 0; ii < blocksAsArray.length; ii++) {\n      var _block = blocksAsArray[ii];\n      var key = _block.getKey();\n      var blockType = _block.getType();\n\n      var customRenderer = blockRendererFn(_block);\n      var CustomComponent = void 0,\n          customProps = void 0,\n          customEditable = void 0;\n      if (customRenderer) {\n        CustomComponent = customRenderer.component;\n        customProps = customRenderer.props;\n        customEditable = customRenderer.editable;\n      }\n\n      var direction = textDirectionality ? textDirectionality : directionMap.get(key);\n      var offsetKey = DraftOffsetKey.encode(key, 0, 0);\n      var componentProps = {\n        contentState: content,\n        block: _block,\n        blockProps: customProps,\n        blockStyleFn: blockStyleFn,\n        customStyleMap: customStyleMap,\n        customStyleFn: customStyleFn,\n        decorator: decorator,\n        direction: direction,\n        forceSelection: forceSelection,\n        key: key,\n        offsetKey: offsetKey,\n        selection: selection,\n        tree: editorState.getBlockTree(key)\n      };\n\n      var configForType = blockRenderMap.get(blockType) || blockRenderMap.get('unstyled');\n      var wrapperTemplate = configForType.wrapper;\n\n      var Element = configForType.element || blockRenderMap.get('unstyled').element;\n\n      var depth = _block.getDepth();\n      var className = '';\n      if (blockStyleFn) {\n        className = blockStyleFn(_block);\n      }\n\n      // List items are special snowflakes, since we handle nesting and\n      // counters manually.\n      if (Element === 'li') {\n        var shouldResetCount = lastWrapperTemplate !== wrapperTemplate || currentDepth === null || depth > currentDepth;\n        className = joinClasses(className, getListItemClasses(blockType, depth, shouldResetCount, direction));\n      }\n\n      var Component = CustomComponent || DraftEditorBlock;\n      var childProps = {\n        className: className,\n        'data-block': true,\n        'data-editor': editorKey,\n        'data-offset-key': offsetKey,\n        key: key\n      };\n      if (customEditable !== undefined) {\n        childProps = _extends({}, childProps, {\n          contentEditable: customEditable,\n          suppressContentEditableWarning: true\n        });\n      }\n\n      var child = React.createElement(Element, childProps, React.createElement(Component, componentProps));\n\n      processedBlocks.push({\n        block: child,\n        wrapperTemplate: wrapperTemplate,\n        key: key,\n        offsetKey: offsetKey\n      });\n\n      if (wrapperTemplate) {\n        currentDepth = _block.getDepth();\n      } else {\n        currentDepth = null;\n      }\n      lastWrapperTemplate = wrapperTemplate;\n    }\n\n    // Group contiguous runs of blocks that have the same wrapperTemplate\n    var outputBlocks = [];\n    for (var _ii = 0; _ii < processedBlocks.length;) {\n      var info = processedBlocks[_ii];\n      if (info.wrapperTemplate) {\n        var blocks = [];\n        do {\n          blocks.push(processedBlocks[_ii].block);\n          _ii++;\n        } while (_ii < processedBlocks.length && processedBlocks[_ii].wrapperTemplate === info.wrapperTemplate);\n        var wrapperElement = React.cloneElement(info.wrapperTemplate, {\n          key: info.key + '-wrap',\n          'data-offset-key': info.offsetKey\n        }, blocks);\n        outputBlocks.push(wrapperElement);\n      } else {\n        outputBlocks.push(info.block);\n        _ii++;\n      }\n    }\n\n    return React.createElement(\n      'div',\n      { 'data-contents': 'true' },\n      outputBlocks\n    );\n  };\n\n  return DraftEditorContents;\n}(React.Component);\n\nmodule.exports = DraftEditorContents;\n\n/***/ }),\n/* 443 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorLeaf.react\n * @format\n * \n */\n\n\n\nvar _assign = __webpack_require__(3);\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar DraftEditorTextNode = __webpack_require__(444);\nvar React = __webpack_require__(0);\nvar ReactDOM = __webpack_require__(1);\n\nvar invariant = __webpack_require__(58);\nvar setDraftEditorSelection = __webpack_require__(451);\n\n/**\n * All leaf nodes in the editor are spans with single text nodes. Leaf\n * elements are styled based on the merging of an optional custom style map\n * and a default style map.\n *\n * `DraftEditorLeaf` also provides a wrapper for calling into the imperative\n * DOM Selection API. In this way, top-level components can declaratively\n * maintain the selection state.\n */\nvar DraftEditorLeaf = function (_React$Component) {\n  _inherits(DraftEditorLeaf, _React$Component);\n\n  function DraftEditorLeaf() {\n    _classCallCheck(this, DraftEditorLeaf);\n\n    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));\n  }\n\n  DraftEditorLeaf.prototype._setSelection = function _setSelection() {\n    var selection = this.props.selection;\n\n    // If selection state is irrelevant to the parent block, no-op.\n\n    if (selection == null || !selection.getHasFocus()) {\n      return;\n    }\n\n    var _props = this.props,\n        block = _props.block,\n        start = _props.start,\n        text = _props.text;\n\n    var blockKey = block.getKey();\n    var end = start + text.length;\n    if (!selection.hasEdgeWithin(blockKey, start, end)) {\n      return;\n    }\n\n    // Determine the appropriate target node for selection. If the child\n    // is not a text node, it is a <br /> spacer. In this case, use the\n    // <span> itself as the selection target.\n    var node = ReactDOM.findDOMNode(this);\n    !node ?  false ? invariant(false, 'Missing node') : invariant(false) : void 0;\n    var child = node.firstChild;\n    !child ?  false ? invariant(false, 'Missing child') : invariant(false) : void 0;\n    var targetNode = void 0;\n\n    if (child.nodeType === Node.TEXT_NODE) {\n      targetNode = child;\n    } else if (child.tagName === 'BR') {\n      targetNode = node;\n    } else {\n      targetNode = child.firstChild;\n      !targetNode ?  false ? invariant(false, 'Missing targetNode') : invariant(false) : void 0;\n    }\n\n    setDraftEditorSelection(selection, targetNode, blockKey, start, end);\n  };\n  /**\n   * By making individual leaf instances aware of their context within\n   * the text of the editor, we can set our selection range more\n   * easily than we could in the non-React world.\n   *\n   * Note that this depends on our maintaining tight control over the\n   * DOM structure of the DraftEditor component. If leaves had multiple\n   * text nodes, this would be harder.\n   */\n\n  DraftEditorLeaf.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n    var leafNode = ReactDOM.findDOMNode(this.leaf);\n    !leafNode ?  false ? invariant(false, 'Missing leafNode') : invariant(false) : void 0;\n    return leafNode.textContent !== nextProps.text || nextProps.styleSet !== this.props.styleSet || nextProps.forceSelection;\n  };\n\n  DraftEditorLeaf.prototype.componentDidUpdate = function componentDidUpdate() {\n    this._setSelection();\n  };\n\n  DraftEditorLeaf.prototype.componentDidMount = function componentDidMount() {\n    this._setSelection();\n  };\n\n  DraftEditorLeaf.prototype.render = function render() {\n    var _this2 = this;\n\n    var block = this.props.block;\n    var text = this.props.text;\n\n    // If the leaf is at the end of its block and ends in a soft newline, append\n    // an extra line feed character. Browsers collapse trailing newline\n    // characters, which leaves the cursor in the wrong place after a\n    // shift+enter. The extra character repairs this.\n\n    if (text.endsWith('\\n') && this.props.isLast) {\n      text += '\\n';\n    }\n\n    var _props2 = this.props,\n        customStyleMap = _props2.customStyleMap,\n        customStyleFn = _props2.customStyleFn,\n        offsetKey = _props2.offsetKey,\n        styleSet = _props2.styleSet;\n\n    var styleObj = styleSet.reduce(function (map, styleName) {\n      var mergedStyles = {};\n      var style = customStyleMap[styleName];\n\n      if (style !== undefined && map.textDecoration !== style.textDecoration) {\n        // .trim() is necessary for IE9/10/11 and Edge\n        mergedStyles.textDecoration = [map.textDecoration, style.textDecoration].join(' ').trim();\n      }\n\n      return _assign(map, style, mergedStyles);\n    }, {});\n\n    if (customStyleFn) {\n      var newStyles = customStyleFn(styleSet, block);\n      styleObj = _assign(styleObj, newStyles);\n    }\n\n    return React.createElement(\n      'span',\n      {\n        'data-offset-key': offsetKey,\n        ref: function ref(_ref) {\n          return _this2.leaf = _ref;\n        },\n        style: styleObj },\n      React.createElement(\n        DraftEditorTextNode,\n        null,\n        text\n      )\n    );\n  };\n\n  return DraftEditorLeaf;\n}(React.Component);\n\nmodule.exports = DraftEditorLeaf;\n\n/***/ }),\n/* 444 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorTextNode.react\n * @format\n * \n */\n\n\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar React = __webpack_require__(0);\nvar ReactDOM = __webpack_require__(1);\nvar UserAgent = __webpack_require__(67);\n\nvar invariant = __webpack_require__(58);\n\n// In IE, spans with <br> tags render as two newlines. By rendering a span\n// with only a newline character, we can be sure to render a single line.\nvar useNewlineChar = UserAgent.isBrowser('IE <= 11');\n\n/**\n * Check whether the node should be considered a newline.\n */\nfunction isNewline(node) {\n  return useNewlineChar ? node.textContent === '\\n' : node.tagName === 'BR';\n}\n\n/**\n * Placeholder elements for empty text content.\n *\n * What is this `data-text` attribute, anyway? It turns out that we need to\n * put an attribute on the lowest-level text node in order to preserve correct\n * spellcheck handling. If the <span> is naked, Chrome and Safari may do\n * bizarre things to do the DOM -- split text nodes, create extra spans, etc.\n * If the <span> has an attribute, this appears not to happen.\n * See http://jsfiddle.net/9khdavod/ for the failure case, and\n * http://jsfiddle.net/7pg143f7/ for the fixed case.\n */\nvar NEWLINE_A = useNewlineChar ? React.createElement(\n  'span',\n  { key: 'A', 'data-text': 'true' },\n  '\\n'\n) : React.createElement('br', { key: 'A', 'data-text': 'true' });\n\nvar NEWLINE_B = useNewlineChar ? React.createElement(\n  'span',\n  { key: 'B', 'data-text': 'true' },\n  '\\n'\n) : React.createElement('br', { key: 'B', 'data-text': 'true' });\n\n/**\n * The lowest-level component in a `DraftEditor`, the text node component\n * replaces the default React text node implementation. This allows us to\n * perform custom handling of newline behavior and avoid re-rendering text\n * nodes with DOM state that already matches the expectations of our immutable\n * editor state.\n */\nvar DraftEditorTextNode = function (_React$Component) {\n  _inherits(DraftEditorTextNode, _React$Component);\n\n  function DraftEditorTextNode(props) {\n    _classCallCheck(this, DraftEditorTextNode);\n\n    // By flipping this flag, we also keep flipping keys which forces\n    // React to remount this node every time it rerenders.\n    var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));\n\n    _this._forceFlag = false;\n    return _this;\n  }\n\n  DraftEditorTextNode.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n    var node = ReactDOM.findDOMNode(this);\n    var shouldBeNewline = nextProps.children === '';\n    !(node instanceof Element) ?  false ? invariant(false, 'node is not an Element') : invariant(false) : void 0;\n    if (shouldBeNewline) {\n      return !isNewline(node);\n    }\n    return node.textContent !== nextProps.children;\n  };\n\n  DraftEditorTextNode.prototype.componentDidMount = function componentDidMount() {\n    this._forceFlag = !this._forceFlag;\n  };\n\n  DraftEditorTextNode.prototype.componentDidUpdate = function componentDidUpdate() {\n    this._forceFlag = !this._forceFlag;\n  };\n\n  DraftEditorTextNode.prototype.render = function render() {\n    if (this.props.children === '') {\n      return this._forceFlag ? NEWLINE_A : NEWLINE_B;\n    }\n    return React.createElement(\n      'span',\n      { key: this._forceFlag ? 'A' : 'B', 'data-text': 'true' },\n      this.props.children\n    );\n  };\n\n  return DraftEditorTextNode;\n}(React.Component);\n\nmodule.exports = DraftEditorTextNode;\n\n/***/ }),\n/* 445 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/**\n * Usage note:\n * This module makes a best effort to export the same data we would internally.\n * At Facebook we use a server-generated module that does the parsing and\n * exports the data for the client to use. We can't rely on a server-side\n * implementation in open source so instead we make use of an open source\n * library to do the heavy lifting and then make some adjustments as necessary.\n * It's likely there will be some differences. Some we can smooth over.\n * Others are going to be harder.\n */\n\n\n\nvar UAParser = __webpack_require__(446);\n\nvar UNKNOWN = 'Unknown';\n\nvar PLATFORM_MAP = {\n  'Mac OS': 'Mac OS X'\n};\n\n/**\n * Convert from UAParser platform name to what we expect.\n */\nfunction convertPlatformName(name) {\n  return PLATFORM_MAP[name] || name;\n}\n\n/**\n * Get the version number in parts. This is very naive. We actually get major\n * version as a part of UAParser already, which is generally good enough, but\n * let's get the minor just in case.\n */\nfunction getBrowserVersion(version) {\n  if (!version) {\n    return {\n      major: '',\n      minor: ''\n    };\n  }\n  var parts = version.split('.');\n  return {\n    major: parts[0],\n    minor: parts[1]\n  };\n}\n\n/**\n * Get the UA data fom UAParser and then convert it to the format we're\n * expecting for our APIS.\n */\nvar parser = new UAParser();\nvar results = parser.getResult();\n\n// Do some conversion first.\nvar browserVersionData = getBrowserVersion(results.browser.version);\nvar uaData = {\n  browserArchitecture: results.cpu.architecture || UNKNOWN,\n  browserFullVersion: results.browser.version || UNKNOWN,\n  browserMinorVersion: browserVersionData.minor || UNKNOWN,\n  browserName: results.browser.name || UNKNOWN,\n  browserVersion: results.browser.major || UNKNOWN,\n  deviceName: results.device.model || UNKNOWN,\n  engineName: results.engine.name || UNKNOWN,\n  engineVersion: results.engine.version || UNKNOWN,\n  platformArchitecture: results.cpu.architecture || UNKNOWN,\n  platformName: convertPlatformName(results.os.name) || UNKNOWN,\n  platformVersion: results.os.version || UNKNOWN,\n  platformFullVersion: results.os.version || UNKNOWN\n};\n\nmodule.exports = uaData;\n\n/***/ }),\n/* 446 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_RESULT__;/////////////////////////////////////////////////////////////////////////////////\n/* UAParser.js v0.7.37\n   Copyright © 2012-2021 Faisal Salman <f@faisalman.com>\n   MIT License *//*\n   Detect Browser, Engine, OS, CPU, and Device type/model from User-Agent data.\n   Supports browser & node.js environment. \n   Demo   : https://faisalman.github.io/ua-parser-js\n   Source : https://github.com/faisalman/ua-parser-js */\n/////////////////////////////////////////////////////////////////////////////////\n\n(function (window, undefined) {\n\n    'use strict';\n\n    //////////////\n    // Constants\n    /////////////\n\n\n    var LIBVERSION  = '0.7.37',\n        EMPTY       = '',\n        UNKNOWN     = '?',\n        FUNC_TYPE   = 'function',\n        UNDEF_TYPE  = 'undefined',\n        OBJ_TYPE    = 'object',\n        STR_TYPE    = 'string',\n        MAJOR       = 'major',\n        MODEL       = 'model',\n        NAME        = 'name',\n        TYPE        = 'type',\n        VENDOR      = 'vendor',\n        VERSION     = 'version',\n        ARCHITECTURE= 'architecture',\n        CONSOLE     = 'console',\n        MOBILE      = 'mobile',\n        TABLET      = 'tablet',\n        SMARTTV     = 'smarttv',\n        WEARABLE    = 'wearable',\n        EMBEDDED    = 'embedded',\n        UA_MAX_LENGTH = 500;\n\n    var AMAZON  = 'Amazon',\n        APPLE   = 'Apple',\n        ASUS    = 'ASUS',\n        BLACKBERRY = 'BlackBerry',\n        BROWSER = 'Browser',\n        CHROME  = 'Chrome',\n        EDGE    = 'Edge',\n        FIREFOX = 'Firefox',\n        GOOGLE  = 'Google',\n        HUAWEI  = 'Huawei',\n        LG      = 'LG',\n        MICROSOFT = 'Microsoft',\n        MOTOROLA  = 'Motorola',\n        OPERA   = 'Opera',\n        SAMSUNG = 'Samsung',\n        SHARP   = 'Sharp',\n        SONY    = 'Sony',\n        XIAOMI  = 'Xiaomi',\n        ZEBRA   = 'Zebra',\n        FACEBOOK    = 'Facebook',\n        CHROMIUM_OS = 'Chromium OS',\n        MAC_OS  = 'Mac OS';\n\n    ///////////\n    // Helper\n    //////////\n\n    var extend = function (regexes, extensions) {\n            var mergedRegexes = {};\n            for (var i in regexes) {\n                if (extensions[i] && extensions[i].length % 2 === 0) {\n                    mergedRegexes[i] = extensions[i].concat(regexes[i]);\n                } else {\n                    mergedRegexes[i] = regexes[i];\n                }\n            }\n            return mergedRegexes;\n        },\n        enumerize = function (arr) {\n            var enums = {};\n            for (var i=0; i<arr.length; i++) {\n                enums[arr[i].toUpperCase()] = arr[i];\n            }\n            return enums;\n        },\n        has = function (str1, str2) {\n            return typeof str1 === STR_TYPE ? lowerize(str2).indexOf(lowerize(str1)) !== -1 : false;\n        },\n        lowerize = function (str) {\n            return str.toLowerCase();\n        },\n        majorize = function (version) {\n            return typeof(version) === STR_TYPE ? version.replace(/[^\\d\\.]/g, EMPTY).split('.')[0] : undefined;\n        },\n        trim = function (str, len) {\n            if (typeof(str) === STR_TYPE) {\n                str = str.replace(/^\\s\\s*/, EMPTY);\n                return typeof(len) === UNDEF_TYPE ? str : str.substring(0, UA_MAX_LENGTH);\n            }\n    };\n\n    ///////////////\n    // Map helper\n    //////////////\n\n    var rgxMapper = function (ua, arrays) {\n\n            var i = 0, j, k, p, q, matches, match;\n\n            // loop through all regexes maps\n            while (i < arrays.length && !matches) {\n\n                var regex = arrays[i],       // even sequence (0,2,4,..)\n                    props = arrays[i + 1];   // odd sequence (1,3,5,..)\n                j = k = 0;\n\n                // try matching uastring with regexes\n                while (j < regex.length && !matches) {\n\n                    if (!regex[j]) { break; }\n                    matches = regex[j++].exec(ua);\n\n                    if (!!matches) {\n                        for (p = 0; p < props.length; p++) {\n                            match = matches[++k];\n                            q = props[p];\n                            // check if given property is actually array\n                            if (typeof q === OBJ_TYPE && q.length > 0) {\n                                if (q.length === 2) {\n                                    if (typeof q[1] == FUNC_TYPE) {\n                                        // assign modified match\n                                        this[q[0]] = q[1].call(this, match);\n                                    } else {\n                                        // assign given value, ignore regex match\n                                        this[q[0]] = q[1];\n                                    }\n                                } else if (q.length === 3) {\n                                    // check whether function or regex\n                                    if (typeof q[1] === FUNC_TYPE && !(q[1].exec && q[1].test)) {\n                                        // call function (usually string mapper)\n                                        this[q[0]] = match ? q[1].call(this, match, q[2]) : undefined;\n                                    } else {\n                                        // sanitize match using given regex\n                                        this[q[0]] = match ? match.replace(q[1], q[2]) : undefined;\n                                    }\n                                } else if (q.length === 4) {\n                                        this[q[0]] = match ? q[3].call(this, match.replace(q[1], q[2])) : undefined;\n                                }\n                            } else {\n                                this[q] = match ? match : undefined;\n                            }\n                        }\n                    }\n                }\n                i += 2;\n            }\n        },\n\n        strMapper = function (str, map) {\n\n            for (var i in map) {\n                // check if current value is array\n                if (typeof map[i] === OBJ_TYPE && map[i].length > 0) {\n                    for (var j = 0; j < map[i].length; j++) {\n                        if (has(map[i][j], str)) {\n                            return (i === UNKNOWN) ? undefined : i;\n                        }\n                    }\n                } else if (has(map[i], str)) {\n                    return (i === UNKNOWN) ? undefined : i;\n                }\n            }\n            return str;\n    };\n\n    ///////////////\n    // String map\n    //////////////\n\n    // Safari < 3.0\n    var oldSafariMap = {\n            '1.0'   : '/8',\n            '1.2'   : '/1',\n            '1.3'   : '/3',\n            '2.0'   : '/412',\n            '2.0.2' : '/416',\n            '2.0.3' : '/417',\n            '2.0.4' : '/419',\n            '?'     : '/'\n        },\n        windowsVersionMap = {\n            'ME'        : '4.90',\n            'NT 3.11'   : 'NT3.51',\n            'NT 4.0'    : 'NT4.0',\n            '2000'      : 'NT 5.0',\n            'XP'        : ['NT 5.1', 'NT 5.2'],\n            'Vista'     : 'NT 6.0',\n            '7'         : 'NT 6.1',\n            '8'         : 'NT 6.2',\n            '8.1'       : 'NT 6.3',\n            '10'        : ['NT 6.4', 'NT 10.0'],\n            'RT'        : 'ARM'\n    };\n\n    //////////////\n    // Regex map\n    /////////////\n\n    var regexes = {\n\n        browser : [[\n\n            /\\b(?:crmo|crios)\\/([\\w\\.]+)/i                                      // Chrome for Android/iOS\n            ], [VERSION, [NAME, 'Chrome']], [\n            /edg(?:e|ios|a)?\\/([\\w\\.]+)/i                                       // Microsoft Edge\n            ], [VERSION, [NAME, 'Edge']], [\n\n            // Presto based\n            /(opera mini)\\/([-\\w\\.]+)/i,                                        // Opera Mini\n            /(opera [mobiletab]{3,6})\\b.+version\\/([-\\w\\.]+)/i,                 // Opera Mobi/Tablet\n            /(opera)(?:.+version\\/|[\\/ ]+)([\\w\\.]+)/i                           // Opera\n            ], [NAME, VERSION], [\n            /opios[\\/ ]+([\\w\\.]+)/i                                             // Opera mini on iphone >= 8.0\n            ], [VERSION, [NAME, OPERA+' Mini']], [\n            /\\bopr\\/([\\w\\.]+)/i                                                 // Opera Webkit\n            ], [VERSION, [NAME, OPERA]], [\n\n            // Mixed\n            /\\bb[ai]*d(?:uhd|[ub]*[aekoprswx]{5,6})[\\/ ]?([\\w\\.]+)/i            // Baidu\n            ], [VERSION, [NAME, 'Baidu']], [\n            /(kindle)\\/([\\w\\.]+)/i,                                             // Kindle\n            /(lunascape|maxthon|netfront|jasmine|blazer)[\\/ ]?([\\w\\.]*)/i,      // Lunascape/Maxthon/Netfront/Jasmine/Blazer\n            // Trident based\n            /(avant|iemobile|slim)\\s?(?:browser)?[\\/ ]?([\\w\\.]*)/i,             // Avant/IEMobile/SlimBrowser\n            /(?:ms|\\()(ie) ([\\w\\.]+)/i,                                         // Internet Explorer\n\n            // Webkit/KHTML based                                               // Flock/RockMelt/Midori/Epiphany/Silk/Skyfire/Bolt/Iron/Iridium/PhantomJS/Bowser/QupZilla/Falkon\n            /(flock|rockmelt|midori|epiphany|silk|skyfire|bolt|iron|vivaldi|iridium|phantomjs|bowser|quark|qupzilla|falkon|rekonq|puffin|brave|whale(?!.+naver)|qqbrowserlite|qq|duckduckgo)\\/([-\\w\\.]+)/i,\n                                                                                // Rekonq/Puffin/Brave/Whale/QQBrowserLite/QQ, aka ShouQ\n            /(heytap|ovi)browser\\/([\\d\\.]+)/i,                                  // Heytap/Ovi\n            /(weibo)__([\\d\\.]+)/i                                               // Weibo\n            ], [NAME, VERSION], [\n            /(?:\\buc? ?browser|(?:juc.+)ucweb)[\\/ ]?([\\w\\.]+)/i                 // UCBrowser\n            ], [VERSION, [NAME, 'UC'+BROWSER]], [\n            /microm.+\\bqbcore\\/([\\w\\.]+)/i,                                     // WeChat Desktop for Windows Built-in Browser\n            /\\bqbcore\\/([\\w\\.]+).+microm/i,\n            /micromessenger\\/([\\w\\.]+)/i                                        // WeChat\n            ], [VERSION, [NAME, 'WeChat']], [\n            /konqueror\\/([\\w\\.]+)/i                                             // Konqueror\n            ], [VERSION, [NAME, 'Konqueror']], [\n            /trident.+rv[: ]([\\w\\.]{1,9})\\b.+like gecko/i                       // IE11\n            ], [VERSION, [NAME, 'IE']], [\n            /ya(?:search)?browser\\/([\\w\\.]+)/i                                  // Yandex\n            ], [VERSION, [NAME, 'Yandex']], [\n            /slbrowser\\/([\\w\\.]+)/i                                             // Smart Lenovo Browser\n            ], [VERSION, [NAME, 'Smart Lenovo '+BROWSER]], [\n            /(avast|avg)\\/([\\w\\.]+)/i                                           // Avast/AVG Secure Browser\n            ], [[NAME, /(.+)/, '$1 Secure '+BROWSER], VERSION], [\n            /\\bfocus\\/([\\w\\.]+)/i                                               // Firefox Focus\n            ], [VERSION, [NAME, FIREFOX+' Focus']], [\n            /\\bopt\\/([\\w\\.]+)/i                                                 // Opera Touch\n            ], [VERSION, [NAME, OPERA+' Touch']], [\n            /coc_coc\\w+\\/([\\w\\.]+)/i                                            // Coc Coc Browser\n            ], [VERSION, [NAME, 'Coc Coc']], [\n            /dolfin\\/([\\w\\.]+)/i                                                // Dolphin\n            ], [VERSION, [NAME, 'Dolphin']], [\n            /coast\\/([\\w\\.]+)/i                                                 // Opera Coast\n            ], [VERSION, [NAME, OPERA+' Coast']], [\n            /miuibrowser\\/([\\w\\.]+)/i                                           // MIUI Browser\n            ], [VERSION, [NAME, 'MIUI '+BROWSER]], [\n            /fxios\\/([-\\w\\.]+)/i                                                // Firefox for iOS\n            ], [VERSION, [NAME, FIREFOX]], [\n            /\\bqihu|(qi?ho?o?|360)browser/i                                     // 360\n            ], [[NAME, '360 ' + BROWSER]], [\n            /(oculus|sailfish|huawei|vivo)browser\\/([\\w\\.]+)/i\n            ], [[NAME, /(.+)/, '$1 ' + BROWSER], VERSION], [                    // Oculus/Sailfish/HuaweiBrowser/VivoBrowser\n            /samsungbrowser\\/([\\w\\.]+)/i                                        // Samsung Internet\n            ], [VERSION, [NAME, SAMSUNG + ' Internet']], [\n            /(comodo_dragon)\\/([\\w\\.]+)/i                                       // Comodo Dragon\n            ], [[NAME, /_/g, ' '], VERSION], [\n            /metasr[\\/ ]?([\\d\\.]+)/i                                            // Sogou Explorer\n            ], [VERSION, [NAME, 'Sogou Explorer']], [\n            /(sogou)mo\\w+\\/([\\d\\.]+)/i                                          // Sogou Mobile\n            ], [[NAME, 'Sogou Mobile'], VERSION], [\n            /(electron)\\/([\\w\\.]+) safari/i,                                    // Electron-based App\n            /(tesla)(?: qtcarbrowser|\\/(20\\d\\d\\.[-\\w\\.]+))/i,                   // Tesla\n            /m?(qqbrowser|2345Explorer)[\\/ ]?([\\w\\.]+)/i                        // QQBrowser/2345 Browser\n            ], [NAME, VERSION], [\n            /(lbbrowser)/i,                                                     // LieBao Browser\n            /\\[(linkedin)app\\]/i                                                // LinkedIn App for iOS & Android\n            ], [NAME], [\n\n            // WebView\n            /((?:fban\\/fbios|fb_iab\\/fb4a)(?!.+fbav)|;fbav\\/([\\w\\.]+);)/i       // Facebook App for iOS & Android\n            ], [[NAME, FACEBOOK], VERSION], [\n            /(Klarna)\\/([\\w\\.]+)/i,                                             // Klarna Shopping Browser for iOS & Android\n            /(kakao(?:talk|story))[\\/ ]([\\w\\.]+)/i,                             // Kakao App\n            /(naver)\\(.*?(\\d+\\.[\\w\\.]+).*\\)/i,                                  // Naver InApp\n            /safari (line)\\/([\\w\\.]+)/i,                                        // Line App for iOS\n            /\\b(line)\\/([\\w\\.]+)\\/iab/i,                                        // Line App for Android\n            /(alipay)client\\/([\\w\\.]+)/i,                                       // Alipay\n            /(chromium|instagram|snapchat)[\\/ ]([-\\w\\.]+)/i                     // Chromium/Instagram/Snapchat\n            ], [NAME, VERSION], [\n            /\\bgsa\\/([\\w\\.]+) .*safari\\//i                                      // Google Search Appliance on iOS\n            ], [VERSION, [NAME, 'GSA']], [\n            /musical_ly(?:.+app_?version\\/|_)([\\w\\.]+)/i                        // TikTok\n            ], [VERSION, [NAME, 'TikTok']], [\n\n            /headlesschrome(?:\\/([\\w\\.]+)| )/i                                  // Chrome Headless\n            ], [VERSION, [NAME, CHROME+' Headless']], [\n\n            / wv\\).+(chrome)\\/([\\w\\.]+)/i                                       // Chrome WebView\n            ], [[NAME, CHROME+' WebView'], VERSION], [\n\n            /droid.+ version\\/([\\w\\.]+)\\b.+(?:mobile safari|safari)/i           // Android Browser\n            ], [VERSION, [NAME, 'Android '+BROWSER]], [\n\n            /(chrome|omniweb|arora|[tizenoka]{5} ?browser)\\/v?([\\w\\.]+)/i       // Chrome/OmniWeb/Arora/Tizen/Nokia\n            ], [NAME, VERSION], [\n\n            /version\\/([\\w\\.\\,]+) .*mobile\\/\\w+ (safari)/i                      // Mobile Safari\n            ], [VERSION, [NAME, 'Mobile Safari']], [\n            /version\\/([\\w(\\.|\\,)]+) .*(mobile ?safari|safari)/i                // Safari & Safari Mobile\n            ], [VERSION, NAME], [\n            /webkit.+?(mobile ?safari|safari)(\\/[\\w\\.]+)/i                      // Safari < 3.0\n            ], [NAME, [VERSION, strMapper, oldSafariMap]], [\n\n            /(webkit|khtml)\\/([\\w\\.]+)/i\n            ], [NAME, VERSION], [\n\n            // Gecko based\n            /(navigator|netscape\\d?)\\/([-\\w\\.]+)/i                              // Netscape\n            ], [[NAME, 'Netscape'], VERSION], [\n            /mobile vr; rv:([\\w\\.]+)\\).+firefox/i                               // Firefox Reality\n            ], [VERSION, [NAME, FIREFOX+' Reality']], [\n            /ekiohf.+(flow)\\/([\\w\\.]+)/i,                                       // Flow\n            /(swiftfox)/i,                                                      // Swiftfox\n            /(icedragon|iceweasel|camino|chimera|fennec|maemo browser|minimo|conkeror|klar)[\\/ ]?([\\w\\.\\+]+)/i,\n                                                                                // IceDragon/Iceweasel/Camino/Chimera/Fennec/Maemo/Minimo/Conkeror/Klar\n            /(seamonkey|k-meleon|icecat|iceape|firebird|phoenix|palemoon|basilisk|waterfox)\\/([-\\w\\.]+)$/i,\n                                                                                // Firefox/SeaMonkey/K-Meleon/IceCat/IceApe/Firebird/Phoenix\n            /(firefox)\\/([\\w\\.]+)/i,                                            // Other Firefox-based\n            /(mozilla)\\/([\\w\\.]+) .+rv\\:.+gecko\\/\\d+/i,                         // Mozilla\n\n            // Other\n            /(polaris|lynx|dillo|icab|doris|amaya|w3m|netsurf|sleipnir|obigo|mosaic|(?:go|ice|up)[\\. ]?browser)[-\\/ ]?v?([\\w\\.]+)/i,\n                                                                                // Polaris/Lynx/Dillo/iCab/Doris/Amaya/w3m/NetSurf/Sleipnir/Obigo/Mosaic/Go/ICE/UP.Browser\n            /(links) \\(([\\w\\.]+)/i,                                             // Links\n            /panasonic;(viera)/i                                                // Panasonic Viera\n            ], [NAME, VERSION], [\n            \n            /(cobalt)\\/([\\w\\.]+)/i                                              // Cobalt\n            ], [NAME, [VERSION, /master.|lts./, \"\"]]\n        ],\n\n        cpu : [[\n\n            /(?:(amd|x(?:(?:86|64)[-_])?|wow|win)64)[;\\)]/i                     // AMD64 (x64)\n            ], [[ARCHITECTURE, 'amd64']], [\n\n            /(ia32(?=;))/i                                                      // IA32 (quicktime)\n            ], [[ARCHITECTURE, lowerize]], [\n\n            /((?:i[346]|x)86)[;\\)]/i                                            // IA32 (x86)\n            ], [[ARCHITECTURE, 'ia32']], [\n\n            /\\b(aarch64|arm(v?8e?l?|_?64))\\b/i                                 // ARM64\n            ], [[ARCHITECTURE, 'arm64']], [\n\n            /\\b(arm(?:v[67])?ht?n?[fl]p?)\\b/i                                   // ARMHF\n            ], [[ARCHITECTURE, 'armhf']], [\n\n            // PocketPC mistakenly identified as PowerPC\n            /windows (ce|mobile); ppc;/i\n            ], [[ARCHITECTURE, 'arm']], [\n\n            /((?:ppc|powerpc)(?:64)?)(?: mac|;|\\))/i                            // PowerPC\n            ], [[ARCHITECTURE, /ower/, EMPTY, lowerize]], [\n\n            /(sun4\\w)[;\\)]/i                                                    // SPARC\n            ], [[ARCHITECTURE, 'sparc']], [\n\n            /((?:avr32|ia64(?=;))|68k(?=\\))|\\barm(?=v(?:[1-7]|[5-7]1)l?|;|eabi)|(?=atmel )avr|(?:irix|mips|sparc)(?:64)?\\b|pa-risc)/i\n                                                                                // IA64, 68K, ARM/64, AVR/32, IRIX/64, MIPS/64, SPARC/64, PA-RISC\n            ], [[ARCHITECTURE, lowerize]]\n        ],\n\n        device : [[\n\n            //////////////////////////\n            // MOBILES & TABLETS\n            /////////////////////////\n\n            // Samsung\n            /\\b(sch-i[89]0\\d|shw-m380s|sm-[ptx]\\w{2,4}|gt-[pn]\\d{2,4}|sgh-t8[56]9|nexus 10)/i\n            ], [MODEL, [VENDOR, SAMSUNG], [TYPE, TABLET]], [\n            /\\b((?:s[cgp]h|gt|sm)-\\w+|sc[g-]?[\\d]+a?|galaxy nexus)/i,\n            /samsung[- ]([-\\w]+)/i,\n            /sec-(sgh\\w+)/i\n            ], [MODEL, [VENDOR, SAMSUNG], [TYPE, MOBILE]], [\n\n            // Apple\n            /(?:\\/|\\()(ip(?:hone|od)[\\w, ]*)(?:\\/|;)/i                          // iPod/iPhone\n            ], [MODEL, [VENDOR, APPLE], [TYPE, MOBILE]], [\n            /\\((ipad);[-\\w\\),; ]+apple/i,                                       // iPad\n            /applecoremedia\\/[\\w\\.]+ \\((ipad)/i,\n            /\\b(ipad)\\d\\d?,\\d\\d?[;\\]].+ios/i\n            ], [MODEL, [VENDOR, APPLE], [TYPE, TABLET]], [\n            /(macintosh);/i\n            ], [MODEL, [VENDOR, APPLE]], [\n\n            // Sharp\n            /\\b(sh-?[altvz]?\\d\\d[a-ekm]?)/i\n            ], [MODEL, [VENDOR, SHARP], [TYPE, MOBILE]], [\n\n            // Huawei\n            /\\b((?:ag[rs][23]?|bah2?|sht?|btv)-a?[lw]\\d{2})\\b(?!.+d\\/s)/i\n            ], [MODEL, [VENDOR, HUAWEI], [TYPE, TABLET]], [\n            /(?:huawei|honor)([-\\w ]+)[;\\)]/i,\n            /\\b(nexus 6p|\\w{2,4}e?-[atu]?[ln][\\dx][012359c][adn]?)\\b(?!.+d\\/s)/i\n            ], [MODEL, [VENDOR, HUAWEI], [TYPE, MOBILE]], [\n\n            // Xiaomi\n            /\\b(poco[\\w ]+|m2\\d{3}j\\d\\d[a-z]{2})(?: bui|\\))/i,                  // Xiaomi POCO\n            /\\b; (\\w+) build\\/hm\\1/i,                                           // Xiaomi Hongmi 'numeric' models\n            /\\b(hm[-_ ]?note?[_ ]?(?:\\d\\w)?) bui/i,                             // Xiaomi Hongmi\n            /\\b(redmi[\\-_ ]?(?:note|k)?[\\w_ ]+)(?: bui|\\))/i,                   // Xiaomi Redmi\n            /oid[^\\)]+; (m?[12][0-389][01]\\w{3,6}[c-y])( bui|; wv|\\))/i,        // Xiaomi Redmi 'numeric' models\n            /\\b(mi[-_ ]?(?:a\\d|one|one[_ ]plus|note lte|max|cc)?[_ ]?(?:\\d?\\w?)[_ ]?(?:plus|se|lite)?)(?: bui|\\))/i // Xiaomi Mi\n            ], [[MODEL, /_/g, ' '], [VENDOR, XIAOMI], [TYPE, MOBILE]], [\n            /oid[^\\)]+; (2\\d{4}(283|rpbf)[cgl])( bui|\\))/i,                     // Redmi Pad\n            /\\b(mi[-_ ]?(?:pad)(?:[\\w_ ]+))(?: bui|\\))/i                        // Mi Pad tablets\n            ],[[MODEL, /_/g, ' '], [VENDOR, XIAOMI], [TYPE, TABLET]], [\n\n            // OPPO\n            /; (\\w+) bui.+ oppo/i,\n            /\\b(cph[12]\\d{3}|p(?:af|c[al]|d\\w|e[ar])[mt]\\d0|x9007|a101op)\\b/i\n            ], [MODEL, [VENDOR, 'OPPO'], [TYPE, MOBILE]], [\n\n            // Vivo\n            /vivo (\\w+)(?: bui|\\))/i,\n            /\\b(v[12]\\d{3}\\w?[at])(?: bui|;)/i\n            ], [MODEL, [VENDOR, 'Vivo'], [TYPE, MOBILE]], [\n\n            // Realme\n            /\\b(rmx[1-3]\\d{3})(?: bui|;|\\))/i\n            ], [MODEL, [VENDOR, 'Realme'], [TYPE, MOBILE]], [\n\n            // Motorola\n            /\\b(milestone|droid(?:[2-4x]| (?:bionic|x2|pro|razr))?:?( 4g)?)\\b[\\w ]+build\\//i,\n            /\\bmot(?:orola)?[- ](\\w*)/i,\n            /((?:moto[\\w\\(\\) ]+|xt\\d{3,4}|nexus 6)(?= bui|\\)))/i\n            ], [MODEL, [VENDOR, MOTOROLA], [TYPE, MOBILE]], [\n            /\\b(mz60\\d|xoom[2 ]{0,2}) build\\//i\n            ], [MODEL, [VENDOR, MOTOROLA], [TYPE, TABLET]], [\n\n            // LG\n            /((?=lg)?[vl]k\\-?\\d{3}) bui| 3\\.[-\\w; ]{10}lg?-([06cv9]{3,4})/i\n            ], [MODEL, [VENDOR, LG], [TYPE, TABLET]], [\n            /(lm(?:-?f100[nv]?|-[\\w\\.]+)(?= bui|\\))|nexus [45])/i,\n            /\\blg[-e;\\/ ]+((?!browser|netcast|android tv)\\w+)/i,\n            /\\blg-?([\\d\\w]+) bui/i\n            ], [MODEL, [VENDOR, LG], [TYPE, MOBILE]], [\n\n            // Lenovo\n            /(ideatab[-\\w ]+)/i,\n            /lenovo ?(s[56]000[-\\w]+|tab(?:[\\w ]+)|yt[-\\d\\w]{6}|tb[-\\d\\w]{6})/i\n            ], [MODEL, [VENDOR, 'Lenovo'], [TYPE, TABLET]], [\n\n            // Nokia\n            /(?:maemo|nokia).*(n900|lumia \\d+)/i,\n            /nokia[-_ ]?([-\\w\\.]*)/i\n            ], [[MODEL, /_/g, ' '], [VENDOR, 'Nokia'], [TYPE, MOBILE]], [\n\n            // Google\n            /(pixel c)\\b/i                                                      // Google Pixel C\n            ], [MODEL, [VENDOR, GOOGLE], [TYPE, TABLET]], [\n            /droid.+; (pixel[\\daxl ]{0,6})(?: bui|\\))/i                         // Google Pixel\n            ], [MODEL, [VENDOR, GOOGLE], [TYPE, MOBILE]], [\n\n            // Sony\n            /droid.+ (a?\\d[0-2]{2}so|[c-g]\\d{4}|so[-gl]\\w+|xq-a\\w[4-7][12])(?= bui|\\).+chrome\\/(?![1-6]{0,1}\\d\\.))/i\n            ], [MODEL, [VENDOR, SONY], [TYPE, MOBILE]], [\n            /sony tablet [ps]/i,\n            /\\b(?:sony)?sgp\\w+(?: bui|\\))/i\n            ], [[MODEL, 'Xperia Tablet'], [VENDOR, SONY], [TYPE, TABLET]], [\n\n            // OnePlus\n            / (kb2005|in20[12]5|be20[12][59])\\b/i,\n            /(?:one)?(?:plus)? (a\\d0\\d\\d)(?: b|\\))/i\n            ], [MODEL, [VENDOR, 'OnePlus'], [TYPE, MOBILE]], [\n\n            // Amazon\n            /(alexa)webm/i,\n            /(kf[a-z]{2}wi|aeo[c-r]{2})( bui|\\))/i,                             // Kindle Fire without Silk / Echo Show\n            /(kf[a-z]+)( bui|\\)).+silk\\//i                                      // Kindle Fire HD\n            ], [MODEL, [VENDOR, AMAZON], [TYPE, TABLET]], [\n            /((?:sd|kf)[0349hijorstuw]+)( bui|\\)).+silk\\//i                     // Fire Phone\n            ], [[MODEL, /(.+)/g, 'Fire Phone $1'], [VENDOR, AMAZON], [TYPE, MOBILE]], [\n\n            // BlackBerry\n            /(playbook);[-\\w\\),; ]+(rim)/i                                      // BlackBerry PlayBook\n            ], [MODEL, VENDOR, [TYPE, TABLET]], [\n            /\\b((?:bb[a-f]|st[hv])100-\\d)/i,\n            /\\(bb10; (\\w+)/i                                                    // BlackBerry 10\n            ], [MODEL, [VENDOR, BLACKBERRY], [TYPE, MOBILE]], [\n\n            // Asus\n            /(?:\\b|asus_)(transfo[prime ]{4,10} \\w+|eeepc|slider \\w+|nexus 7|padfone|p00[cj])/i\n            ], [MODEL, [VENDOR, ASUS], [TYPE, TABLET]], [\n            / (z[bes]6[027][012][km][ls]|zenfone \\d\\w?)\\b/i\n            ], [MODEL, [VENDOR, ASUS], [TYPE, MOBILE]], [\n\n            // HTC\n            /(nexus 9)/i                                                        // HTC Nexus 9\n            ], [MODEL, [VENDOR, 'HTC'], [TYPE, TABLET]], [\n            /(htc)[-;_ ]{1,2}([\\w ]+(?=\\)| bui)|\\w+)/i,                         // HTC\n\n            // ZTE\n            /(zte)[- ]([\\w ]+?)(?: bui|\\/|\\))/i,\n            /(alcatel|geeksphone|nexian|panasonic(?!(?:;|\\.))|sony(?!-bra))[-_ ]?([-\\w]*)/i         // Alcatel/GeeksPhone/Nexian/Panasonic/Sony\n            ], [VENDOR, [MODEL, /_/g, ' '], [TYPE, MOBILE]], [\n\n            // Acer\n            /droid.+; ([ab][1-7]-?[0178a]\\d\\d?)/i\n            ], [MODEL, [VENDOR, 'Acer'], [TYPE, TABLET]], [\n\n            // Meizu\n            /droid.+; (m[1-5] note) bui/i,\n            /\\bmz-([-\\w]{2,})/i\n            ], [MODEL, [VENDOR, 'Meizu'], [TYPE, MOBILE]], [\n                \n            // Ulefone\n            /; ((?:power )?armor(?:[\\w ]{0,8}))(?: bui|\\))/i\n            ], [MODEL, [VENDOR, 'Ulefone'], [TYPE, MOBILE]], [\n\n            // MIXED\n            /(blackberry|benq|palm(?=\\-)|sonyericsson|acer|asus|dell|meizu|motorola|polytron|infinix|tecno)[-_ ]?([-\\w]*)/i,\n                                                                                // BlackBerry/BenQ/Palm/Sony-Ericsson/Acer/Asus/Dell/Meizu/Motorola/Polytron\n            /(hp) ([\\w ]+\\w)/i,                                                 // HP iPAQ\n            /(asus)-?(\\w+)/i,                                                   // Asus\n            /(microsoft); (lumia[\\w ]+)/i,                                      // Microsoft Lumia\n            /(lenovo)[-_ ]?([-\\w]+)/i,                                          // Lenovo\n            /(jolla)/i,                                                         // Jolla\n            /(oppo) ?([\\w ]+) bui/i                                             // OPPO\n            ], [VENDOR, MODEL, [TYPE, MOBILE]], [\n\n            /(kobo)\\s(ereader|touch)/i,                                         // Kobo\n            /(archos) (gamepad2?)/i,                                            // Archos\n            /(hp).+(touchpad(?!.+tablet)|tablet)/i,                             // HP TouchPad\n            /(kindle)\\/([\\w\\.]+)/i,                                             // Kindle\n            /(nook)[\\w ]+build\\/(\\w+)/i,                                        // Nook\n            /(dell) (strea[kpr\\d ]*[\\dko])/i,                                   // Dell Streak\n            /(le[- ]+pan)[- ]+(\\w{1,9}) bui/i,                                  // Le Pan Tablets\n            /(trinity)[- ]*(t\\d{3}) bui/i,                                      // Trinity Tablets\n            /(gigaset)[- ]+(q\\w{1,9}) bui/i,                                    // Gigaset Tablets\n            /(vodafone) ([\\w ]+)(?:\\)| bui)/i                                   // Vodafone\n            ], [VENDOR, MODEL, [TYPE, TABLET]], [\n\n            /(surface duo)/i                                                    // Surface Duo\n            ], [MODEL, [VENDOR, MICROSOFT], [TYPE, TABLET]], [\n            /droid [\\d\\.]+; (fp\\du?)(?: b|\\))/i                                 // Fairphone\n            ], [MODEL, [VENDOR, 'Fairphone'], [TYPE, MOBILE]], [\n            /(u304aa)/i                                                         // AT&T\n            ], [MODEL, [VENDOR, 'AT&T'], [TYPE, MOBILE]], [\n            /\\bsie-(\\w*)/i                                                      // Siemens\n            ], [MODEL, [VENDOR, 'Siemens'], [TYPE, MOBILE]], [\n            /\\b(rct\\w+) b/i                                                     // RCA Tablets\n            ], [MODEL, [VENDOR, 'RCA'], [TYPE, TABLET]], [\n            /\\b(venue[\\d ]{2,7}) b/i                                            // Dell Venue Tablets\n            ], [MODEL, [VENDOR, 'Dell'], [TYPE, TABLET]], [\n            /\\b(q(?:mv|ta)\\w+) b/i                                              // Verizon Tablet\n            ], [MODEL, [VENDOR, 'Verizon'], [TYPE, TABLET]], [\n            /\\b(?:barnes[& ]+noble |bn[rt])([\\w\\+ ]*) b/i                       // Barnes & Noble Tablet\n            ], [MODEL, [VENDOR, 'Barnes & Noble'], [TYPE, TABLET]], [\n            /\\b(tm\\d{3}\\w+) b/i\n            ], [MODEL, [VENDOR, 'NuVision'], [TYPE, TABLET]], [\n            /\\b(k88) b/i                                                        // ZTE K Series Tablet\n            ], [MODEL, [VENDOR, 'ZTE'], [TYPE, TABLET]], [\n            /\\b(nx\\d{3}j) b/i                                                   // ZTE Nubia\n            ], [MODEL, [VENDOR, 'ZTE'], [TYPE, MOBILE]], [\n            /\\b(gen\\d{3}) b.+49h/i                                              // Swiss GEN Mobile\n            ], [MODEL, [VENDOR, 'Swiss'], [TYPE, MOBILE]], [\n            /\\b(zur\\d{3}) b/i                                                   // Swiss ZUR Tablet\n            ], [MODEL, [VENDOR, 'Swiss'], [TYPE, TABLET]], [\n            /\\b((zeki)?tb.*\\b) b/i                                              // Zeki Tablets\n            ], [MODEL, [VENDOR, 'Zeki'], [TYPE, TABLET]], [\n            /\\b([yr]\\d{2}) b/i,\n            /\\b(dragon[- ]+touch |dt)(\\w{5}) b/i                                // Dragon Touch Tablet\n            ], [[VENDOR, 'Dragon Touch'], MODEL, [TYPE, TABLET]], [\n            /\\b(ns-?\\w{0,9}) b/i                                                // Insignia Tablets\n            ], [MODEL, [VENDOR, 'Insignia'], [TYPE, TABLET]], [\n            /\\b((nxa|next)-?\\w{0,9}) b/i                                        // NextBook Tablets\n            ], [MODEL, [VENDOR, 'NextBook'], [TYPE, TABLET]], [\n            /\\b(xtreme\\_)?(v(1[045]|2[015]|[3469]0|7[05])) b/i                  // Voice Xtreme Phones\n            ], [[VENDOR, 'Voice'], MODEL, [TYPE, MOBILE]], [\n            /\\b(lvtel\\-)?(v1[12]) b/i                                           // LvTel Phones\n            ], [[VENDOR, 'LvTel'], MODEL, [TYPE, MOBILE]], [\n            /\\b(ph-1) /i                                                        // Essential PH-1\n            ], [MODEL, [VENDOR, 'Essential'], [TYPE, MOBILE]], [\n            /\\b(v(100md|700na|7011|917g).*\\b) b/i                               // Envizen Tablets\n            ], [MODEL, [VENDOR, 'Envizen'], [TYPE, TABLET]], [\n            /\\b(trio[-\\w\\. ]+) b/i                                              // MachSpeed Tablets\n            ], [MODEL, [VENDOR, 'MachSpeed'], [TYPE, TABLET]], [\n            /\\btu_(1491) b/i                                                    // Rotor Tablets\n            ], [MODEL, [VENDOR, 'Rotor'], [TYPE, TABLET]], [\n            /(shield[\\w ]+) b/i                                                 // Nvidia Shield Tablets\n            ], [MODEL, [VENDOR, 'Nvidia'], [TYPE, TABLET]], [\n            /(sprint) (\\w+)/i                                                   // Sprint Phones\n            ], [VENDOR, MODEL, [TYPE, MOBILE]], [\n            /(kin\\.[onetw]{3})/i                                                // Microsoft Kin\n            ], [[MODEL, /\\./g, ' '], [VENDOR, MICROSOFT], [TYPE, MOBILE]], [\n            /droid.+; (cc6666?|et5[16]|mc[239][23]x?|vc8[03]x?)\\)/i             // Zebra\n            ], [MODEL, [VENDOR, ZEBRA], [TYPE, TABLET]], [\n            /droid.+; (ec30|ps20|tc[2-8]\\d[kx])\\)/i\n            ], [MODEL, [VENDOR, ZEBRA], [TYPE, MOBILE]], [\n\n            ///////////////////\n            // SMARTTVS\n            ///////////////////\n\n            /smart-tv.+(samsung)/i                                              // Samsung\n            ], [VENDOR, [TYPE, SMARTTV]], [\n            /hbbtv.+maple;(\\d+)/i\n            ], [[MODEL, /^/, 'SmartTV'], [VENDOR, SAMSUNG], [TYPE, SMARTTV]], [\n            /(nux; netcast.+smarttv|lg (netcast\\.tv-201\\d|android tv))/i        // LG SmartTV\n            ], [[VENDOR, LG], [TYPE, SMARTTV]], [\n            /(apple) ?tv/i                                                      // Apple TV\n            ], [VENDOR, [MODEL, APPLE+' TV'], [TYPE, SMARTTV]], [\n            /crkey/i                                                            // Google Chromecast\n            ], [[MODEL, CHROME+'cast'], [VENDOR, GOOGLE], [TYPE, SMARTTV]], [\n            /droid.+aft(\\w+)( bui|\\))/i                                         // Fire TV\n            ], [MODEL, [VENDOR, AMAZON], [TYPE, SMARTTV]], [\n            /\\(dtv[\\);].+(aquos)/i,\n            /(aquos-tv[\\w ]+)\\)/i                                               // Sharp\n            ], [MODEL, [VENDOR, SHARP], [TYPE, SMARTTV]],[\n            /(bravia[\\w ]+)( bui|\\))/i                                              // Sony\n            ], [MODEL, [VENDOR, SONY], [TYPE, SMARTTV]], [\n            /(mitv-\\w{5}) bui/i                                                 // Xiaomi\n            ], [MODEL, [VENDOR, XIAOMI], [TYPE, SMARTTV]], [\n            /Hbbtv.*(technisat) (.*);/i                                         // TechniSAT\n            ], [VENDOR, MODEL, [TYPE, SMARTTV]], [\n            /\\b(roku)[\\dx]*[\\)\\/]((?:dvp-)?[\\d\\.]*)/i,                          // Roku\n            /hbbtv\\/\\d+\\.\\d+\\.\\d+ +\\([\\w\\+ ]*; *([\\w\\d][^;]*);([^;]*)/i         // HbbTV devices\n            ], [[VENDOR, trim], [MODEL, trim], [TYPE, SMARTTV]], [\n            /\\b(android tv|smart[- ]?tv|opera tv|tv; rv:)\\b/i                   // SmartTV from Unidentified Vendors\n            ], [[TYPE, SMARTTV]], [\n\n            ///////////////////\n            // CONSOLES\n            ///////////////////\n\n            /(ouya)/i,                                                          // Ouya\n            /(nintendo) ([wids3utch]+)/i                                        // Nintendo\n            ], [VENDOR, MODEL, [TYPE, CONSOLE]], [\n            /droid.+; (shield) bui/i                                            // Nvidia\n            ], [MODEL, [VENDOR, 'Nvidia'], [TYPE, CONSOLE]], [\n            /(playstation [345portablevi]+)/i                                   // Playstation\n            ], [MODEL, [VENDOR, SONY], [TYPE, CONSOLE]], [\n            /\\b(xbox(?: one)?(?!; xbox))[\\); ]/i                                // Microsoft Xbox\n            ], [MODEL, [VENDOR, MICROSOFT], [TYPE, CONSOLE]], [\n\n            ///////////////////\n            // WEARABLES\n            ///////////////////\n\n            /((pebble))app/i                                                    // Pebble\n            ], [VENDOR, MODEL, [TYPE, WEARABLE]], [\n            /(watch)(?: ?os[,\\/]|\\d,\\d\\/)[\\d\\.]+/i                              // Apple Watch\n            ], [MODEL, [VENDOR, APPLE], [TYPE, WEARABLE]], [\n            /droid.+; (glass) \\d/i                                              // Google Glass\n            ], [MODEL, [VENDOR, GOOGLE], [TYPE, WEARABLE]], [\n            /droid.+; (wt63?0{2,3})\\)/i\n            ], [MODEL, [VENDOR, ZEBRA], [TYPE, WEARABLE]], [\n            /(quest( 2| pro)?)/i                                                // Oculus Quest\n            ], [MODEL, [VENDOR, FACEBOOK], [TYPE, WEARABLE]], [\n\n            ///////////////////\n            // EMBEDDED\n            ///////////////////\n\n            /(tesla)(?: qtcarbrowser|\\/[-\\w\\.]+)/i                              // Tesla\n            ], [VENDOR, [TYPE, EMBEDDED]], [\n            /(aeobc)\\b/i                                                        // Echo Dot\n            ], [MODEL, [VENDOR, AMAZON], [TYPE, EMBEDDED]], [\n\n            ////////////////////\n            // MIXED (GENERIC)\n            ///////////////////\n\n            /droid .+?; ([^;]+?)(?: bui|; wv\\)|\\) applew).+? mobile safari/i    // Android Phones from Unidentified Vendors\n            ], [MODEL, [TYPE, MOBILE]], [\n            /droid .+?; ([^;]+?)(?: bui|\\) applew).+?(?! mobile) safari/i       // Android Tablets from Unidentified Vendors\n            ], [MODEL, [TYPE, TABLET]], [\n            /\\b((tablet|tab)[;\\/]|focus\\/\\d(?!.+mobile))/i                      // Unidentifiable Tablet\n            ], [[TYPE, TABLET]], [\n            /(phone|mobile(?:[;\\/]| [ \\w\\/\\.]*safari)|pda(?=.+windows ce))/i    // Unidentifiable Mobile\n            ], [[TYPE, MOBILE]], [\n            /(android[-\\w\\. ]{0,9});.+buil/i                                    // Generic Android Device\n            ], [MODEL, [VENDOR, 'Generic']]\n        ],\n\n        engine : [[\n\n            /windows.+ edge\\/([\\w\\.]+)/i                                       // EdgeHTML\n            ], [VERSION, [NAME, EDGE+'HTML']], [\n\n            /webkit\\/537\\.36.+chrome\\/(?!27)([\\w\\.]+)/i                         // Blink\n            ], [VERSION, [NAME, 'Blink']], [\n\n            /(presto)\\/([\\w\\.]+)/i,                                             // Presto\n            /(webkit|trident|netfront|netsurf|amaya|lynx|w3m|goanna)\\/([\\w\\.]+)/i, // WebKit/Trident/NetFront/NetSurf/Amaya/Lynx/w3m/Goanna\n            /ekioh(flow)\\/([\\w\\.]+)/i,                                          // Flow\n            /(khtml|tasman|links)[\\/ ]\\(?([\\w\\.]+)/i,                           // KHTML/Tasman/Links\n            /(icab)[\\/ ]([23]\\.[\\d\\.]+)/i,                                      // iCab\n            /\\b(libweb)/i\n            ], [NAME, VERSION], [\n\n            /rv\\:([\\w\\.]{1,9})\\b.+(gecko)/i                                     // Gecko\n            ], [VERSION, NAME]\n        ],\n\n        os : [[\n\n            // Windows\n            /microsoft (windows) (vista|xp)/i                                   // Windows (iTunes)\n            ], [NAME, VERSION], [\n            /(windows (?:phone(?: os)?|mobile))[\\/ ]?([\\d\\.\\w ]*)/i             // Windows Phone\n            ], [NAME, [VERSION, strMapper, windowsVersionMap]], [\n            /windows nt 6\\.2; (arm)/i,                                        // Windows RT\n            /windows[\\/ ]?([ntce\\d\\. ]+\\w)(?!.+xbox)/i,\n            /(?:win(?=3|9|n)|win 9x )([nt\\d\\.]+)/i\n            ], [[VERSION, strMapper, windowsVersionMap], [NAME, 'Windows']], [\n\n            // iOS/macOS\n            /ip[honead]{2,4}\\b(?:.*os ([\\w]+) like mac|; opera)/i,              // iOS\n            /(?:ios;fbsv\\/|iphone.+ios[\\/ ])([\\d\\.]+)/i,\n            /cfnetwork\\/.+darwin/i\n            ], [[VERSION, /_/g, '.'], [NAME, 'iOS']], [\n            /(mac os x) ?([\\w\\. ]*)/i,\n            /(macintosh|mac_powerpc\\b)(?!.+haiku)/i                             // Mac OS\n            ], [[NAME, MAC_OS], [VERSION, /_/g, '.']], [\n\n            // Mobile OSes\n            /droid ([\\w\\.]+)\\b.+(android[- ]x86|harmonyos)/i                    // Android-x86/HarmonyOS\n            ], [VERSION, NAME], [                                               // Android/WebOS/QNX/Bada/RIM/Maemo/MeeGo/Sailfish OS\n            /(android|webos|qnx|bada|rim tablet os|maemo|meego|sailfish)[-\\/ ]?([\\w\\.]*)/i,\n            /(blackberry)\\w*\\/([\\w\\.]*)/i,                                      // Blackberry\n            /(tizen|kaios)[\\/ ]([\\w\\.]+)/i,                                     // Tizen/KaiOS\n            /\\((series40);/i                                                    // Series 40\n            ], [NAME, VERSION], [\n            /\\(bb(10);/i                                                        // BlackBerry 10\n            ], [VERSION, [NAME, BLACKBERRY]], [\n            /(?:symbian ?os|symbos|s60(?=;)|series60)[-\\/ ]?([\\w\\.]*)/i         // Symbian\n            ], [VERSION, [NAME, 'Symbian']], [\n            /mozilla\\/[\\d\\.]+ \\((?:mobile|tablet|tv|mobile; [\\w ]+); rv:.+ gecko\\/([\\w\\.]+)/i // Firefox OS\n            ], [VERSION, [NAME, FIREFOX+' OS']], [\n            /web0s;.+rt(tv)/i,\n            /\\b(?:hp)?wos(?:browser)?\\/([\\w\\.]+)/i                              // WebOS\n            ], [VERSION, [NAME, 'webOS']], [\n            /watch(?: ?os[,\\/]|\\d,\\d\\/)([\\d\\.]+)/i                              // watchOS\n            ], [VERSION, [NAME, 'watchOS']], [\n\n            // Google Chromecast\n            /crkey\\/([\\d\\.]+)/i                                                 // Google Chromecast\n            ], [VERSION, [NAME, CHROME+'cast']], [\n            /(cros) [\\w]+(?:\\)| ([\\w\\.]+)\\b)/i                                  // Chromium OS\n            ], [[NAME, CHROMIUM_OS], VERSION],[\n\n            // Smart TVs\n            /panasonic;(viera)/i,                                               // Panasonic Viera\n            /(netrange)mmh/i,                                                   // Netrange\n            /(nettv)\\/(\\d+\\.[\\w\\.]+)/i,                                         // NetTV\n\n            // Console\n            /(nintendo|playstation) ([wids345portablevuch]+)/i,                 // Nintendo/Playstation\n            /(xbox); +xbox ([^\\);]+)/i,                                         // Microsoft Xbox (360, One, X, S, Series X, Series S)\n\n            // Other\n            /\\b(joli|palm)\\b ?(?:os)?\\/?([\\w\\.]*)/i,                            // Joli/Palm\n            /(mint)[\\/\\(\\) ]?(\\w*)/i,                                           // Mint\n            /(mageia|vectorlinux)[; ]/i,                                        // Mageia/VectorLinux\n            /([kxln]?ubuntu|debian|suse|opensuse|gentoo|arch(?= linux)|slackware|fedora|mandriva|centos|pclinuxos|red ?hat|zenwalk|linpus|raspbian|plan 9|minix|risc os|contiki|deepin|manjaro|elementary os|sabayon|linspire)(?: gnu\\/linux)?(?: enterprise)?(?:[- ]linux)?(?:-gnu)?[-\\/ ]?(?!chrom|package)([-\\w\\.]*)/i,\n                                                                                // Ubuntu/Debian/SUSE/Gentoo/Arch/Slackware/Fedora/Mandriva/CentOS/PCLinuxOS/RedHat/Zenwalk/Linpus/Raspbian/Plan9/Minix/RISCOS/Contiki/Deepin/Manjaro/elementary/Sabayon/Linspire\n            /(hurd|linux) ?([\\w\\.]*)/i,                                         // Hurd/Linux\n            /(gnu) ?([\\w\\.]*)/i,                                                // GNU\n            /\\b([-frentopcghs]{0,5}bsd|dragonfly)[\\/ ]?(?!amd|[ix346]{1,2}86)([\\w\\.]*)/i, // FreeBSD/NetBSD/OpenBSD/PC-BSD/GhostBSD/DragonFly\n            /(haiku) (\\w+)/i                                                    // Haiku\n            ], [NAME, VERSION], [\n            /(sunos) ?([\\w\\.\\d]*)/i                                             // Solaris\n            ], [[NAME, 'Solaris'], VERSION], [\n            /((?:open)?solaris)[-\\/ ]?([\\w\\.]*)/i,                              // Solaris\n            /(aix) ((\\d)(?=\\.|\\)| )[\\w\\.])*/i,                                  // AIX\n            /\\b(beos|os\\/2|amigaos|morphos|openvms|fuchsia|hp-ux|serenityos)/i, // BeOS/OS2/AmigaOS/MorphOS/OpenVMS/Fuchsia/HP-UX/SerenityOS\n            /(unix) ?([\\w\\.]*)/i                                                // UNIX\n            ], [NAME, VERSION]\n        ]\n    };\n\n    /////////////////\n    // Constructor\n    ////////////////\n\n    var UAParser = function (ua, extensions) {\n\n        if (typeof ua === OBJ_TYPE) {\n            extensions = ua;\n            ua = undefined;\n        }\n\n        if (!(this instanceof UAParser)) {\n            return new UAParser(ua, extensions).getResult();\n        }\n\n        var _navigator = (typeof window !== UNDEF_TYPE && window.navigator) ? window.navigator : undefined;\n        var _ua = ua || ((_navigator && _navigator.userAgent) ? _navigator.userAgent : EMPTY);\n        var _uach = (_navigator && _navigator.userAgentData) ? _navigator.userAgentData : undefined;\n        var _rgxmap = extensions ? extend(regexes, extensions) : regexes;\n        var _isSelfNav = _navigator && _navigator.userAgent == _ua;\n\n        this.getBrowser = function () {\n            var _browser = {};\n            _browser[NAME] = undefined;\n            _browser[VERSION] = undefined;\n            rgxMapper.call(_browser, _ua, _rgxmap.browser);\n            _browser[MAJOR] = majorize(_browser[VERSION]);\n            // Brave-specific detection\n            if (_isSelfNav && _navigator && _navigator.brave && typeof _navigator.brave.isBrave == FUNC_TYPE) {\n                _browser[NAME] = 'Brave';\n            }\n            return _browser;\n        };\n        this.getCPU = function () {\n            var _cpu = {};\n            _cpu[ARCHITECTURE] = undefined;\n            rgxMapper.call(_cpu, _ua, _rgxmap.cpu);\n            return _cpu;\n        };\n        this.getDevice = function () {\n            var _device = {};\n            _device[VENDOR] = undefined;\n            _device[MODEL] = undefined;\n            _device[TYPE] = undefined;\n            rgxMapper.call(_device, _ua, _rgxmap.device);\n            if (_isSelfNav && !_device[TYPE] && _uach && _uach.mobile) {\n                _device[TYPE] = MOBILE;\n            }\n            // iPadOS-specific detection: identified as Mac, but has some iOS-only properties\n            if (_isSelfNav && _device[MODEL] == 'Macintosh' && _navigator && typeof _navigator.standalone !== UNDEF_TYPE && _navigator.maxTouchPoints && _navigator.maxTouchPoints > 2) {\n                _device[MODEL] = 'iPad';\n                _device[TYPE] = TABLET;\n            }\n            return _device;\n        };\n        this.getEngine = function () {\n            var _engine = {};\n            _engine[NAME] = undefined;\n            _engine[VERSION] = undefined;\n            rgxMapper.call(_engine, _ua, _rgxmap.engine);\n            return _engine;\n        };\n        this.getOS = function () {\n            var _os = {};\n            _os[NAME] = undefined;\n            _os[VERSION] = undefined;\n            rgxMapper.call(_os, _ua, _rgxmap.os);\n            if (_isSelfNav && !_os[NAME] && _uach && _uach.platform != 'Unknown') {\n                _os[NAME] = _uach.platform  \n                                    .replace(/chrome os/i, CHROMIUM_OS)\n                                    .replace(/macos/i, MAC_OS);           // backward compatibility\n            }\n            return _os;\n        };\n        this.getResult = function () {\n            return {\n                ua      : this.getUA(),\n                browser : this.getBrowser(),\n                engine  : this.getEngine(),\n                os      : this.getOS(),\n                device  : this.getDevice(),\n                cpu     : this.getCPU()\n            };\n        };\n        this.getUA = function () {\n            return _ua;\n        };\n        this.setUA = function (ua) {\n            _ua = (typeof ua === STR_TYPE && ua.length > UA_MAX_LENGTH) ? trim(ua, UA_MAX_LENGTH) : ua;\n            return this;\n        };\n        this.setUA(_ua);\n        return this;\n    };\n\n    UAParser.VERSION = LIBVERSION;\n    UAParser.BROWSER =  enumerize([NAME, VERSION, MAJOR]);\n    UAParser.CPU = enumerize([ARCHITECTURE]);\n    UAParser.DEVICE = enumerize([MODEL, VENDOR, TYPE, CONSOLE, MOBILE, SMARTTV, TABLET, WEARABLE, EMBEDDED]);\n    UAParser.ENGINE = UAParser.OS = enumerize([NAME, VERSION]);\n\n    ///////////\n    // Export\n    //////////\n\n    // check js environment\n    if (typeof(exports) !== UNDEF_TYPE) {\n        // nodejs env\n        if (typeof module !== UNDEF_TYPE && module.exports) {\n            exports = module.exports = UAParser;\n        }\n        exports.UAParser = UAParser;\n    } else {\n        // requirejs env (optional)\n        if (\"function\" === FUNC_TYPE && __webpack_require__(447)) {\n            !(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {\n                return UAParser;\n            }).call(exports, __webpack_require__, exports, module),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n        } else if (typeof window !== UNDEF_TYPE) {\n            // browser env\n            window.UAParser = UAParser;\n        }\n    }\n\n    // jQuery/Zepto specific (optional)\n    // Note:\n    //   In AMD env the global scope should be kept clean, but jQuery is an exception.\n    //   jQuery always exports to global scope, unless jQuery.noConflict(true) is used,\n    //   and we should catch that.\n    var $ = typeof window !== UNDEF_TYPE && (window.jQuery || window.Zepto);\n    if ($ && !$.ua) {\n        var parser = new UAParser();\n        $.ua = parser.getResult();\n        $.ua.get = function () {\n            return parser.getUA();\n        };\n        $.ua.set = function (ua) {\n            parser.setUA(ua);\n            var result = parser.getResult();\n            for (var prop in result) {\n                $.ua[prop] = result[prop];\n            }\n        };\n    }\n\n})(typeof window === 'object' ? window : this);\n\n\n/***/ }),\n/* 447 */\n/***/ (function(module, exports) {\n\n/* WEBPACK VAR INJECTION */(function(__webpack_amd_options__) {/* globals __webpack_amd_options__ */\r\nmodule.exports = __webpack_amd_options__;\r\n\n/* WEBPACK VAR INJECTION */}.call(exports, {}))\n\n/***/ }),\n/* 448 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n\n\nvar invariant = __webpack_require__(58);\n\nvar componentRegex = /\\./;\nvar orRegex = /\\|\\|/;\nvar rangeRegex = /\\s+\\-\\s+/;\nvar modifierRegex = /^(<=|<|=|>=|~>|~|>|)?\\s*(.+)/;\nvar numericRegex = /^(\\d*)(.*)/;\n\n/**\n * Splits input `range` on \"||\" and returns true if any subrange matches\n * `version`.\n *\n * @param {string} range\n * @param {string} version\n * @returns {boolean}\n */\nfunction checkOrExpression(range, version) {\n  var expressions = range.split(orRegex);\n\n  if (expressions.length > 1) {\n    return expressions.some(function (range) {\n      return VersionRange.contains(range, version);\n    });\n  } else {\n    range = expressions[0].trim();\n    return checkRangeExpression(range, version);\n  }\n}\n\n/**\n * Splits input `range` on \" - \" (the surrounding whitespace is required) and\n * returns true if version falls between the two operands.\n *\n * @param {string} range\n * @param {string} version\n * @returns {boolean}\n */\nfunction checkRangeExpression(range, version) {\n  var expressions = range.split(rangeRegex);\n\n  !(expressions.length > 0 && expressions.length <= 2) ?  false ? invariant(false, 'the \"-\" operator expects exactly 2 operands') : invariant(false) : void 0;\n\n  if (expressions.length === 1) {\n    return checkSimpleExpression(expressions[0], version);\n  } else {\n    var startVersion = expressions[0],\n        endVersion = expressions[1];\n\n    !(isSimpleVersion(startVersion) && isSimpleVersion(endVersion)) ?  false ? invariant(false, 'operands to the \"-\" operator must be simple (no modifiers)') : invariant(false) : void 0;\n\n    return checkSimpleExpression('>=' + startVersion, version) && checkSimpleExpression('<=' + endVersion, version);\n  }\n}\n\n/**\n * Checks if `range` matches `version`. `range` should be a \"simple\" range (ie.\n * not a compound range using the \" - \" or \"||\" operators).\n *\n * @param {string} range\n * @param {string} version\n * @returns {boolean}\n */\nfunction checkSimpleExpression(range, version) {\n  range = range.trim();\n  if (range === '') {\n    return true;\n  }\n\n  var versionComponents = version.split(componentRegex);\n\n  var _getModifierAndCompon = getModifierAndComponents(range),\n      modifier = _getModifierAndCompon.modifier,\n      rangeComponents = _getModifierAndCompon.rangeComponents;\n\n  switch (modifier) {\n    case '<':\n      return checkLessThan(versionComponents, rangeComponents);\n    case '<=':\n      return checkLessThanOrEqual(versionComponents, rangeComponents);\n    case '>=':\n      return checkGreaterThanOrEqual(versionComponents, rangeComponents);\n    case '>':\n      return checkGreaterThan(versionComponents, rangeComponents);\n    case '~':\n    case '~>':\n      return checkApproximateVersion(versionComponents, rangeComponents);\n    default:\n      return checkEqual(versionComponents, rangeComponents);\n  }\n}\n\n/**\n * Checks whether `a` is less than `b`.\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {boolean}\n */\nfunction checkLessThan(a, b) {\n  return compareComponents(a, b) === -1;\n}\n\n/**\n * Checks whether `a` is less than or equal to `b`.\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {boolean}\n */\nfunction checkLessThanOrEqual(a, b) {\n  var result = compareComponents(a, b);\n  return result === -1 || result === 0;\n}\n\n/**\n * Checks whether `a` is equal to `b`.\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {boolean}\n */\nfunction checkEqual(a, b) {\n  return compareComponents(a, b) === 0;\n}\n\n/**\n * Checks whether `a` is greater than or equal to `b`.\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {boolean}\n */\nfunction checkGreaterThanOrEqual(a, b) {\n  var result = compareComponents(a, b);\n  return result === 1 || result === 0;\n}\n\n/**\n * Checks whether `a` is greater than `b`.\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {boolean}\n */\nfunction checkGreaterThan(a, b) {\n  return compareComponents(a, b) === 1;\n}\n\n/**\n * Checks whether `a` is \"reasonably close\" to `b` (as described in\n * https://www.npmjs.org/doc/misc/semver.html). For example, if `b` is \"1.3.1\"\n * then \"reasonably close\" is defined as \">= 1.3.1 and < 1.4\".\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {boolean}\n */\nfunction checkApproximateVersion(a, b) {\n  var lowerBound = b.slice();\n  var upperBound = b.slice();\n\n  if (upperBound.length > 1) {\n    upperBound.pop();\n  }\n  var lastIndex = upperBound.length - 1;\n  var numeric = parseInt(upperBound[lastIndex], 10);\n  if (isNumber(numeric)) {\n    upperBound[lastIndex] = numeric + 1 + '';\n  }\n\n  return checkGreaterThanOrEqual(a, lowerBound) && checkLessThan(a, upperBound);\n}\n\n/**\n * Extracts the optional modifier (<, <=, =, >=, >, ~, ~>) and version\n * components from `range`.\n *\n * For example, given `range` \">= 1.2.3\" returns an object with a `modifier` of\n * `\">=\"` and `components` of `[1, 2, 3]`.\n *\n * @param {string} range\n * @returns {object}\n */\nfunction getModifierAndComponents(range) {\n  var rangeComponents = range.split(componentRegex);\n  var matches = rangeComponents[0].match(modifierRegex);\n  !matches ?  false ? invariant(false, 'expected regex to match but it did not') : invariant(false) : void 0;\n\n  return {\n    modifier: matches[1],\n    rangeComponents: [matches[2]].concat(rangeComponents.slice(1))\n  };\n}\n\n/**\n * Determines if `number` is a number.\n *\n * @param {mixed} number\n * @returns {boolean}\n */\nfunction isNumber(number) {\n  return !isNaN(number) && isFinite(number);\n}\n\n/**\n * Tests whether `range` is a \"simple\" version number without any modifiers\n * (\">\", \"~\" etc).\n *\n * @param {string} range\n * @returns {boolean}\n */\nfunction isSimpleVersion(range) {\n  return !getModifierAndComponents(range).modifier;\n}\n\n/**\n * Zero-pads array `array` until it is at least `length` long.\n *\n * @param {array} array\n * @param {number} length\n */\nfunction zeroPad(array, length) {\n  for (var i = array.length; i < length; i++) {\n    array[i] = '0';\n  }\n}\n\n/**\n * Normalizes `a` and `b` in preparation for comparison by doing the following:\n *\n * - zero-pads `a` and `b`\n * - marks any \"x\", \"X\" or \"*\" component in `b` as equivalent by zero-ing it out\n *   in both `a` and `b`\n * - marks any final \"*\" component in `b` as a greedy wildcard by zero-ing it\n *   and all of its successors in `a`\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {array<array<string>>}\n */\nfunction normalizeVersions(a, b) {\n  a = a.slice();\n  b = b.slice();\n\n  zeroPad(a, b.length);\n\n  // mark \"x\" and \"*\" components as equal\n  for (var i = 0; i < b.length; i++) {\n    var matches = b[i].match(/^[x*]$/i);\n    if (matches) {\n      b[i] = a[i] = '0';\n\n      // final \"*\" greedily zeros all remaining components\n      if (matches[0] === '*' && i === b.length - 1) {\n        for (var j = i; j < a.length; j++) {\n          a[j] = '0';\n        }\n      }\n    }\n  }\n\n  zeroPad(b, a.length);\n\n  return [a, b];\n}\n\n/**\n * Returns the numerical -- not the lexicographical -- ordering of `a` and `b`.\n *\n * For example, `10-alpha` is greater than `2-beta`.\n *\n * @param {string} a\n * @param {string} b\n * @returns {number} -1, 0 or 1 to indicate whether `a` is less than, equal to,\n * or greater than `b`, respectively\n */\nfunction compareNumeric(a, b) {\n  var aPrefix = a.match(numericRegex)[1];\n  var bPrefix = b.match(numericRegex)[1];\n  var aNumeric = parseInt(aPrefix, 10);\n  var bNumeric = parseInt(bPrefix, 10);\n\n  if (isNumber(aNumeric) && isNumber(bNumeric) && aNumeric !== bNumeric) {\n    return compare(aNumeric, bNumeric);\n  } else {\n    return compare(a, b);\n  }\n}\n\n/**\n * Returns the ordering of `a` and `b`.\n *\n * @param {string|number} a\n * @param {string|number} b\n * @returns {number} -1, 0 or 1 to indicate whether `a` is less than, equal to,\n * or greater than `b`, respectively\n */\nfunction compare(a, b) {\n  !(typeof a === typeof b) ?  false ? invariant(false, '\"a\" and \"b\" must be of the same type') : invariant(false) : void 0;\n\n  if (a > b) {\n    return 1;\n  } else if (a < b) {\n    return -1;\n  } else {\n    return 0;\n  }\n}\n\n/**\n * Compares arrays of version components.\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {number} -1, 0 or 1 to indicate whether `a` is less than, equal to,\n * or greater than `b`, respectively\n */\nfunction compareComponents(a, b) {\n  var _normalizeVersions = normalizeVersions(a, b),\n      aNormalized = _normalizeVersions[0],\n      bNormalized = _normalizeVersions[1];\n\n  for (var i = 0; i < bNormalized.length; i++) {\n    var result = compareNumeric(aNormalized[i], bNormalized[i]);\n    if (result) {\n      return result;\n    }\n  }\n\n  return 0;\n}\n\nvar VersionRange = {\n  /**\n   * Checks whether `version` satisfies the `range` specification.\n   *\n   * We support a subset of the expressions defined in\n   * https://www.npmjs.org/doc/misc/semver.html:\n   *\n   *    version   Must match version exactly\n   *    =version  Same as just version\n   *    >version  Must be greater than version\n   *    >=version Must be greater than or equal to version\n   *    <version  Must be less than version\n   *    <=version Must be less than or equal to version\n   *    ~version  Must be at least version, but less than the next significant\n   *              revision above version:\n   *              \"~1.2.3\" is equivalent to \">= 1.2.3 and < 1.3\"\n   *    ~>version Equivalent to ~version\n   *    1.2.x     Must match \"1.2.x\", where \"x\" is a wildcard that matches\n   *              anything\n   *    1.2.*     Similar to \"1.2.x\", but \"*\" in the trailing position is a\n   *              \"greedy\" wildcard, so will match any number of additional\n   *              components:\n   *              \"1.2.*\" will match \"1.2.1\", \"1.2.1.1\", \"1.2.1.1.1\" etc\n   *    *         Any version\n   *    \"\"        (Empty string) Same as *\n   *    v1 - v2   Equivalent to \">= v1 and <= v2\"\n   *    r1 || r2  Passes if either r1 or r2 are satisfied\n   *\n   * @param {string} range\n   * @param {string} version\n   * @returns {boolean}\n   */\n  contains: function contains(range, version) {\n    return checkOrExpression(range.trim(), version.trim());\n  }\n};\n\nmodule.exports = VersionRange;\n\n/***/ }),\n/* 449 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\n/**\n * Executes the provided `callback` once for each enumerable own property in the\n * object and constructs a new object from the results. The `callback` is\n * invoked with three arguments:\n *\n *  - the property value\n *  - the property name\n *  - the object being traversed\n *\n * Properties that are added after the call to `mapObject` will not be visited\n * by `callback`. If the values of existing properties are changed, the value\n * passed to `callback` will be the value at the time `mapObject` visits them.\n * Properties that are deleted before being visited are not visited.\n *\n * @grep function objectMap()\n * @grep function objMap()\n *\n * @param {?object} object\n * @param {function} callback\n * @param {*} context\n * @return {?object}\n */\nfunction mapObject(object, callback, context) {\n  if (!object) {\n    return null;\n  }\n  var result = {};\n  for (var name in object) {\n    if (hasOwnProperty.call(object, name)) {\n      result[name] = callback.call(context, object[name], name, object);\n    }\n  }\n  return result;\n}\n\nmodule.exports = mapObject;\n\n/***/ }),\n/* 450 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @typechecks static-only\n */\n\n\n\n/**\n * Memoizes the return value of a function that accepts one string argument.\n */\n\nfunction memoizeStringOnly(callback) {\n  var cache = {};\n  return function (string) {\n    if (!cache.hasOwnProperty(string)) {\n      cache[string] = callback.call(this, string);\n    }\n    return cache[string];\n  };\n}\n\nmodule.exports = memoizeStringOnly;\n\n/***/ }),\n/* 451 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule setDraftEditorSelection\n * @format\n * \n */\n\n\n\nvar DraftJsDebugLogging = __webpack_require__(452);\n\nvar containsNode = __webpack_require__(163);\nvar getActiveElement = __webpack_require__(228);\nvar invariant = __webpack_require__(58);\n\nfunction getAnonymizedDOM(node, getNodeLabels) {\n  if (!node) {\n    return '[empty]';\n  }\n\n  var anonymized = anonymizeTextWithin(node, getNodeLabels);\n  if (anonymized.nodeType === Node.TEXT_NODE) {\n    return anonymized.textContent;\n  }\n\n  !(anonymized instanceof Element) ?  false ? invariant(false, 'Node must be an Element if it is not a text node.') : invariant(false) : void 0;\n  return anonymized.outerHTML;\n}\n\nfunction anonymizeTextWithin(node, getNodeLabels) {\n  var labels = getNodeLabels !== undefined ? getNodeLabels(node) : [];\n\n  if (node.nodeType === Node.TEXT_NODE) {\n    var length = node.textContent.length;\n    return document.createTextNode('[text ' + length + (labels.length ? ' | ' + labels.join(', ') : '') + ']');\n  }\n\n  var clone = node.cloneNode();\n  if (clone.nodeType === 1 && labels.length) {\n    clone.setAttribute('data-labels', labels.join(', '));\n  }\n  var childNodes = node.childNodes;\n  for (var ii = 0; ii < childNodes.length; ii++) {\n    clone.appendChild(anonymizeTextWithin(childNodes[ii], getNodeLabels));\n  }\n\n  return clone;\n}\n\nfunction getAnonymizedEditorDOM(node, getNodeLabels) {\n  // grabbing the DOM content of the Draft editor\n  var currentNode = node;\n  while (currentNode) {\n    if (currentNode instanceof Element && currentNode.hasAttribute('contenteditable')) {\n      // found the Draft editor container\n      return getAnonymizedDOM(currentNode, getNodeLabels);\n    } else {\n      currentNode = currentNode.parentNode;\n    }\n  }\n  return 'Could not find contentEditable parent of node';\n}\n\nfunction getNodeLength(node) {\n  return node.nodeValue === null ? node.childNodes.length : node.nodeValue.length;\n}\n\n/**\n * In modern non-IE browsers, we can support both forward and backward\n * selections.\n *\n * Note: IE10+ supports the Selection object, but it does not support\n * the `extend` method, which means that even in modern IE, it's not possible\n * to programatically create a backward selection. Thus, for all IE\n * versions, we use the old IE API to create our selections.\n */\nfunction setDraftEditorSelection(selectionState, node, blockKey, nodeStart, nodeEnd) {\n  // It's possible that the editor has been removed from the DOM but\n  // our selection code doesn't know it yet. Forcing selection in\n  // this case may lead to errors, so just bail now.\n  if (!containsNode(document.documentElement, node)) {\n    return;\n  }\n\n  var selection = global.getSelection();\n  var anchorKey = selectionState.getAnchorKey();\n  var anchorOffset = selectionState.getAnchorOffset();\n  var focusKey = selectionState.getFocusKey();\n  var focusOffset = selectionState.getFocusOffset();\n  var isBackward = selectionState.getIsBackward();\n\n  // IE doesn't support backward selection. Swap key/offset pairs.\n  if (!selection.extend && isBackward) {\n    var tempKey = anchorKey;\n    var tempOffset = anchorOffset;\n    anchorKey = focusKey;\n    anchorOffset = focusOffset;\n    focusKey = tempKey;\n    focusOffset = tempOffset;\n    isBackward = false;\n  }\n\n  var hasAnchor = anchorKey === blockKey && nodeStart <= anchorOffset && nodeEnd >= anchorOffset;\n\n  var hasFocus = focusKey === blockKey && nodeStart <= focusOffset && nodeEnd >= focusOffset;\n\n  // If the selection is entirely bound within this node, set the selection\n  // and be done.\n  if (hasAnchor && hasFocus) {\n    selection.removeAllRanges();\n    addPointToSelection(selection, node, anchorOffset - nodeStart, selectionState);\n    addFocusToSelection(selection, node, focusOffset - nodeStart, selectionState);\n    return;\n  }\n\n  if (!isBackward) {\n    // If the anchor is within this node, set the range start.\n    if (hasAnchor) {\n      selection.removeAllRanges();\n      addPointToSelection(selection, node, anchorOffset - nodeStart, selectionState);\n    }\n\n    // If the focus is within this node, we can assume that we have\n    // already set the appropriate start range on the selection, and\n    // can simply extend the selection.\n    if (hasFocus) {\n      addFocusToSelection(selection, node, focusOffset - nodeStart, selectionState);\n    }\n  } else {\n    // If this node has the focus, set the selection range to be a\n    // collapsed range beginning here. Later, when we encounter the anchor,\n    // we'll use this information to extend the selection.\n    if (hasFocus) {\n      selection.removeAllRanges();\n      addPointToSelection(selection, node, focusOffset - nodeStart, selectionState);\n    }\n\n    // If this node has the anchor, we may assume that the correct\n    // focus information is already stored on the selection object.\n    // We keep track of it, reset the selection range, and extend it\n    // back to the focus point.\n    if (hasAnchor) {\n      var storedFocusNode = selection.focusNode;\n      var storedFocusOffset = selection.focusOffset;\n\n      selection.removeAllRanges();\n      addPointToSelection(selection, node, anchorOffset - nodeStart, selectionState);\n      addFocusToSelection(selection, storedFocusNode, storedFocusOffset, selectionState);\n    }\n  }\n}\n\n/**\n * Extend selection towards focus point.\n */\nfunction addFocusToSelection(selection, node, offset, selectionState) {\n  var activeElement = getActiveElement();\n  if (selection.extend && containsNode(activeElement, node)) {\n    // If `extend` is called while another element has focus, an error is\n    // thrown. We therefore disable `extend` if the active element is somewhere\n    // other than the node we are selecting. This should only occur in Firefox,\n    // since it is the only browser to support multiple selections.\n    // See https://bugzilla.mozilla.org/show_bug.cgi?id=921444.\n\n    // logging to catch bug that is being reported in t16250795\n    if (offset > getNodeLength(node)) {\n      // the call to 'selection.extend' is about to throw\n      DraftJsDebugLogging.logSelectionStateFailure({\n        anonymizedDom: getAnonymizedEditorDOM(node),\n        extraParams: JSON.stringify({ offset: offset }),\n        selectionState: JSON.stringify(selectionState.toJS())\n      });\n    }\n\n    // logging to catch bug that is being reported in t18110632\n    var nodeWasFocus = node === selection.focusNode;\n    try {\n      selection.extend(node, offset);\n    } catch (e) {\n      DraftJsDebugLogging.logSelectionStateFailure({\n        anonymizedDom: getAnonymizedEditorDOM(node, function (n) {\n          var labels = [];\n          if (n === activeElement) {\n            labels.push('active element');\n          }\n          if (n === selection.anchorNode) {\n            labels.push('selection anchor node');\n          }\n          if (n === selection.focusNode) {\n            labels.push('selection focus node');\n          }\n          return labels;\n        }),\n        extraParams: JSON.stringify({\n          activeElementName: activeElement ? activeElement.nodeName : null,\n          nodeIsFocus: node === selection.focusNode,\n          nodeWasFocus: nodeWasFocus,\n          selectionRangeCount: selection.rangeCount,\n          selectionAnchorNodeName: selection.anchorNode ? selection.anchorNode.nodeName : null,\n          selectionAnchorOffset: selection.anchorOffset,\n          selectionFocusNodeName: selection.focusNode ? selection.focusNode.nodeName : null,\n          selectionFocusOffset: selection.focusOffset,\n          message: e ? '' + e : null,\n          offset: offset\n        }, null, 2),\n        selectionState: JSON.stringify(selectionState.toJS(), null, 2)\n      });\n      // allow the error to be thrown -\n      // better than continuing in a broken state\n      throw e;\n    }\n  } else {\n    // IE doesn't support extend. This will mean no backward selection.\n    // Extract the existing selection range and add focus to it.\n    // Additionally, clone the selection range. IE11 throws an\n    // InvalidStateError when attempting to access selection properties\n    // after the range is detached.\n    var range = selection.getRangeAt(0);\n    range.setEnd(node, offset);\n    selection.addRange(range.cloneRange());\n  }\n}\n\nfunction addPointToSelection(selection, node, offset, selectionState) {\n  var range = document.createRange();\n  // logging to catch bug that is being reported in t16250795\n  if (offset > getNodeLength(node)) {\n    // in this case we know that the call to 'range.setStart' is about to throw\n    DraftJsDebugLogging.logSelectionStateFailure({\n      anonymizedDom: getAnonymizedEditorDOM(node),\n      extraParams: JSON.stringify({ offset: offset }),\n      selectionState: JSON.stringify(selectionState.toJS())\n    });\n  }\n  range.setStart(node, offset);\n  selection.addRange(range);\n}\n\nmodule.exports = setDraftEditorSelection;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2)))\n\n/***/ }),\n/* 452 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftJsDebugLogging\n */\n\n\n\nmodule.exports = {\n  logSelectionStateFailure: function logSelectionStateFailure() {\n    return null;\n  }\n};\n\n/***/ }),\n/* 453 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar isNode = __webpack_require__(454);\n\n/**\n * @param {*} object The object to check.\n * @return {boolean} Whether or not the object is a DOM text node.\n */\nfunction isTextNode(object) {\n  return isNode(object) && object.nodeType == 3;\n}\n\nmodule.exports = isTextNode;\n\n/***/ }),\n/* 454 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n/**\n * @param {*} object The object to check.\n * @return {boolean} Whether or not the object is a DOM node.\n */\nfunction isNode(object) {\n  var doc = object ? object.ownerDocument || object : document;\n  var defaultView = doc.defaultView || window;\n  return !!(object && (typeof defaultView.Node === 'function' ? object instanceof defaultView.Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string'));\n}\n\nmodule.exports = isNode;\n\n/***/ }),\n/* 455 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar camelize = __webpack_require__(456);\nvar hyphenate = __webpack_require__(457);\n\nfunction asString(value) /*?string*/{\n  return value == null ? value : String(value);\n}\n\nfunction getStyleProperty( /*DOMNode*/node, /*string*/name) /*?string*/{\n  var computedStyle = void 0;\n\n  // W3C Standard\n  if (window.getComputedStyle) {\n    // In certain cases such as within an iframe in FF3, this returns null.\n    computedStyle = window.getComputedStyle(node, null);\n    if (computedStyle) {\n      return asString(computedStyle.getPropertyValue(hyphenate(name)));\n    }\n  }\n  // Safari\n  if (document.defaultView && document.defaultView.getComputedStyle) {\n    computedStyle = document.defaultView.getComputedStyle(node, null);\n    // A Safari bug causes this to return null for `display: none` elements.\n    if (computedStyle) {\n      return asString(computedStyle.getPropertyValue(hyphenate(name)));\n    }\n    if (name === 'display') {\n      return 'none';\n    }\n  }\n  // Internet Explorer\n  if (node.currentStyle) {\n    if (name === 'float') {\n      return asString(node.currentStyle.cssFloat || node.currentStyle.styleFloat);\n    }\n    return asString(node.currentStyle[camelize(name)]);\n  }\n  return asString(node.style && node.style[camelize(name)]);\n}\n\nmodule.exports = getStyleProperty;\n\n/***/ }),\n/* 456 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar _hyphenPattern = /-(.)/g;\n\n/**\n * Camelcases a hyphenated string, for example:\n *\n *   > camelize('background-color')\n *   < \"backgroundColor\"\n *\n * @param {string} string\n * @return {string}\n */\nfunction camelize(string) {\n  return string.replace(_hyphenPattern, function (_, character) {\n    return character.toUpperCase();\n  });\n}\n\nmodule.exports = camelize;\n\n/***/ }),\n/* 457 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar _uppercasePattern = /([A-Z])/g;\n\n/**\n * Hyphenates a camelcased string, for example:\n *\n *   > hyphenate('backgroundColor')\n *   < \"background-color\"\n *\n * For CSS style names, use `hyphenateStyleName` instead which works properly\n * with all vendor prefixes, including `ms`.\n *\n * @param {string} string\n * @return {string}\n */\nfunction hyphenate(string) {\n  return string.replace(_uppercasePattern, '-$1').toLowerCase();\n}\n\nmodule.exports = hyphenate;\n\n/***/ }),\n/* 458 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar getElementRect = __webpack_require__(459);\n\n/**\n * Gets an element's position in pixels relative to the viewport. The returned\n * object represents the position of the element's top left corner.\n *\n * @param {DOMElement} element\n * @return {object}\n */\nfunction getElementPosition(element) {\n  var rect = getElementRect(element);\n  return {\n    x: rect.left,\n    y: rect.top,\n    width: rect.right - rect.left,\n    height: rect.bottom - rect.top\n  };\n}\n\nmodule.exports = getElementPosition;\n\n/***/ }),\n/* 459 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar containsNode = __webpack_require__(163);\n\n/**\n * Gets an element's bounding rect in pixels relative to the viewport.\n *\n * @param {DOMElement} elem\n * @return {object}\n */\nfunction getElementRect(elem) {\n  var docElem = elem.ownerDocument.documentElement;\n\n  // FF 2, Safari 3 and Opera 9.5- do not support getBoundingClientRect().\n  // IE9- will throw if the element is not in the document.\n  if (!('getBoundingClientRect' in elem) || !containsNode(docElem, elem)) {\n    return {\n      left: 0,\n      right: 0,\n      top: 0,\n      bottom: 0\n    };\n  }\n\n  // Subtracts clientTop/Left because IE8- added a 2px border to the\n  // <html> element (see http://fburl.com/1493213). IE 7 in\n  // Quicksmode does not report clientLeft/clientTop so there\n  // will be an unaccounted offset of 2px when in quirksmode\n  var rect = elem.getBoundingClientRect();\n\n  return {\n    left: Math.round(rect.left) - docElem.clientLeft,\n    right: Math.round(rect.right) - docElem.clientLeft,\n    top: Math.round(rect.top) - docElem.clientTop,\n    bottom: Math.round(rect.bottom) - docElem.clientTop\n  };\n}\n\nmodule.exports = getElementRect;\n\n/***/ }),\n/* 460 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n\n\nvar isWebkit = typeof navigator !== 'undefined' && navigator.userAgent.indexOf('AppleWebKit') > -1;\n\n/**\n * Gets the element with the document scroll properties such as `scrollLeft` and\n * `scrollHeight`. This may differ across different browsers.\n *\n * NOTE: The return value can be null if the DOM is not yet ready.\n *\n * @param {?DOMDocument} doc Defaults to current document.\n * @return {?DOMElement}\n */\nfunction getDocumentScrollElement(doc) {\n  doc = doc || document;\n  if (doc.scrollingElement) {\n    return doc.scrollingElement;\n  }\n  return !isWebkit && doc.compatMode === 'CSS1Compat' ? doc.documentElement : doc.body;\n}\n\nmodule.exports = getDocumentScrollElement;\n\n/***/ }),\n/* 461 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n\n\n/**\n * Gets the scroll position of the supplied element or window.\n *\n * The return values are unbounded, unlike `getScrollPosition`. This means they\n * may be negative or exceed the element boundaries (which is possible using\n * inertial scrolling).\n *\n * @param {DOMWindow|DOMElement} scrollable\n * @return {object} Map with `x` and `y` keys.\n */\n\nfunction getUnboundedScrollPosition(scrollable) {\n  if (scrollable.Window && scrollable instanceof scrollable.Window) {\n    return {\n      x: scrollable.pageXOffset || scrollable.document.documentElement.scrollLeft,\n      y: scrollable.pageYOffset || scrollable.document.documentElement.scrollTop\n    };\n  }\n  return {\n    x: scrollable.scrollLeft,\n    y: scrollable.scrollTop\n  };\n}\n\nmodule.exports = getUnboundedScrollPosition;\n\n/***/ }),\n/* 462 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nfunction getViewportWidth() {\n  var width = void 0;\n  if (document.documentElement) {\n    width = document.documentElement.clientWidth;\n  }\n\n  if (!width && document.body) {\n    width = document.body.clientWidth;\n  }\n\n  return width || 0;\n} /**\n   * Copyright (c) 2013-present, Facebook, Inc.\n   *\n   * This source code is licensed under the MIT license found in the\n   * LICENSE file in the root directory of this source tree.\n   *\n   * \n   * @typechecks\n   */\n\nfunction getViewportHeight() {\n  var height = void 0;\n  if (document.documentElement) {\n    height = document.documentElement.clientHeight;\n  }\n\n  if (!height && document.body) {\n    height = document.body.clientHeight;\n  }\n\n  return height || 0;\n}\n\n/**\n * Gets the viewport dimensions including any scrollbars.\n */\nfunction getViewportDimensions() {\n  return {\n    width: window.innerWidth || getViewportWidth(),\n    height: window.innerHeight || getViewportHeight()\n  };\n}\n\n/**\n * Gets the viewport dimensions excluding any scrollbars.\n */\ngetViewportDimensions.withoutScrollbars = function () {\n  return {\n    width: getViewportWidth(),\n    height: getViewportHeight()\n  };\n};\n\nmodule.exports = getViewportDimensions;\n\n/***/ }),\n/* 463 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks static-only\n */\n\n\n\n/**\n * Combines multiple className strings into one.\n * http://jsperf.com/joinclasses-args-vs-array\n *\n * @param {...?string} className\n * @return {string}\n */\n\nfunction joinClasses(className /*, ... */) {\n  if (!className) {\n    className = '';\n  }\n  var nextClass = void 0;\n  var argLength = arguments.length;\n  if (argLength > 1) {\n    for (var ii = 1; ii < argLength; ii++) {\n      nextClass = arguments[ii];\n      if (nextClass) {\n        className = (className ? className + ' ' : '') + nextClass;\n      }\n    }\n  }\n  return className;\n}\n\nmodule.exports = joinClasses;\n\n/***/ }),\n/* 464 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorDragHandler\n * @format\n * \n */\n\n\n\nvar DataTransfer = __webpack_require__(230);\nvar DraftModifier = __webpack_require__(62);\nvar EditorState = __webpack_require__(59);\n\nvar findAncestorOffsetKey = __webpack_require__(166);\nvar getTextContentFromFiles = __webpack_require__(232);\nvar getUpdatedSelectionState = __webpack_require__(233);\nvar isEventHandled = __webpack_require__(93);\nvar nullthrows = __webpack_require__(65);\n\n/**\n * Get a SelectionState for the supplied mouse event.\n */\nfunction getSelectionForEvent(event, editorState) {\n  var node = null;\n  var offset = null;\n\n  if (typeof document.caretRangeFromPoint === 'function') {\n    var dropRange = document.caretRangeFromPoint(event.x, event.y);\n    node = dropRange.startContainer;\n    offset = dropRange.startOffset;\n  } else if (event.rangeParent) {\n    node = event.rangeParent;\n    offset = event.rangeOffset;\n  } else {\n    return null;\n  }\n\n  node = nullthrows(node);\n  offset = nullthrows(offset);\n  var offsetKey = nullthrows(findAncestorOffsetKey(node));\n\n  return getUpdatedSelectionState(editorState, offsetKey, offset, offsetKey, offset);\n}\n\nvar DraftEditorDragHandler = {\n  /**\n   * Drag originating from input terminated.\n   */\n  onDragEnd: function onDragEnd(editor) {\n    editor.exitCurrentMode();\n  },\n\n  /**\n   * Handle data being dropped.\n   */\n  onDrop: function onDrop(editor, e) {\n    var data = new DataTransfer(e.nativeEvent.dataTransfer);\n\n    var editorState = editor._latestEditorState;\n    var dropSelection = getSelectionForEvent(e.nativeEvent, editorState);\n\n    e.preventDefault();\n    editor.exitCurrentMode();\n\n    if (dropSelection == null) {\n      return;\n    }\n\n    var files = data.getFiles();\n    if (files.length > 0) {\n      if (editor.props.handleDroppedFiles && isEventHandled(editor.props.handleDroppedFiles(dropSelection, files))) {\n        return;\n      }\n\n      getTextContentFromFiles(files, function (fileText) {\n        fileText && editor.update(insertTextAtSelection(editorState, dropSelection, fileText));\n      });\n      return;\n    }\n\n    var dragType = editor._internalDrag ? 'internal' : 'external';\n    if (editor.props.handleDrop && isEventHandled(editor.props.handleDrop(dropSelection, data, dragType))) {\n      return;\n    }\n\n    if (editor._internalDrag) {\n      editor.update(moveText(editorState, dropSelection));\n      return;\n    }\n\n    editor.update(insertTextAtSelection(editorState, dropSelection, data.getText()));\n  }\n};\n\nfunction moveText(editorState, targetSelection) {\n  var newContentState = DraftModifier.moveText(editorState.getCurrentContent(), editorState.getSelection(), targetSelection);\n  return EditorState.push(editorState, newContentState, 'insert-fragment');\n}\n\n/**\n * Insert text at a specified selection.\n */\nfunction insertTextAtSelection(editorState, selection, text) {\n  var newContentState = DraftModifier.insertText(editorState.getCurrentContent(), selection, text, editorState.getCurrentInlineStyle());\n  return EditorState.push(editorState, newContentState, 'insert-fragment');\n}\n\nmodule.exports = DraftEditorDragHandler;\n\n/***/ }),\n/* 465 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nvar PhotosMimeType = {\n  isImage: function isImage(mimeString) {\n    return getParts(mimeString)[0] === 'image';\n  },\n  isJpeg: function isJpeg(mimeString) {\n    var parts = getParts(mimeString);\n    return PhotosMimeType.isImage(mimeString) && (\n    // see http://fburl.com/10972194\n    parts[1] === 'jpeg' || parts[1] === 'pjpeg');\n  }\n};\n\nfunction getParts(mimeString) {\n  return mimeString.split('/');\n}\n\nmodule.exports = PhotosMimeType;\n\n/***/ }),\n/* 466 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar invariant = __webpack_require__(58);\n\n/**\n * Convert array-like objects to arrays.\n *\n * This API assumes the caller knows the contents of the data type. For less\n * well defined inputs use createArrayFromMixed.\n *\n * @param {object|function|filelist} obj\n * @return {array}\n */\nfunction toArray(obj) {\n  var length = obj.length;\n\n  // Some browsers builtin objects can report typeof 'function' (e.g. NodeList\n  // in old versions of Safari).\n  !(!Array.isArray(obj) && (typeof obj === 'object' || typeof obj === 'function')) ?  false ? invariant(false, 'toArray: Array-like object expected') : invariant(false) : void 0;\n\n  !(typeof length === 'number') ?  false ? invariant(false, 'toArray: Object needs a length property') : invariant(false) : void 0;\n\n  !(length === 0 || length - 1 in obj) ?  false ? invariant(false, 'toArray: Object should have keys for indices') : invariant(false) : void 0;\n\n  !(typeof obj.callee !== 'function') ?  false ? invariant(false, 'toArray: Object can\\'t be `arguments`. Use rest params ' + '(function(...args) {}) or Array.from() instead.') : invariant(false) : void 0;\n\n  // Old IE doesn't give collections access to hasOwnProperty. Assume inputs\n  // without method will throw during the slice call and skip straight to the\n  // fallback.\n  if (obj.hasOwnProperty) {\n    try {\n      return Array.prototype.slice.call(obj);\n    } catch (e) {\n      // IE < 9 does not support Array#slice on collections objects\n    }\n  }\n\n  // Fall back to copying key by key. This assumes all keys have a value,\n  // so will not preserve sparsely populated inputs.\n  var ret = Array(length);\n  for (var ii = 0; ii < length; ii++) {\n    ret[ii] = obj[ii];\n  }\n  return ret;\n}\n\n/**\n * Perform a heuristic test to determine if an object is \"array-like\".\n *\n *   A monk asked Joshu, a Zen master, \"Has a dog Buddha nature?\"\n *   Joshu replied: \"Mu.\"\n *\n * This function determines if its argument has \"array nature\": it returns\n * true if the argument is an actual array, an `arguments' object, or an\n * HTMLCollection (e.g. node.childNodes or node.getElementsByTagName()).\n *\n * It will return false for other array-like objects like Filelist.\n *\n * @param {*} obj\n * @return {boolean}\n */\nfunction hasArrayNature(obj) {\n  return (\n    // not null/false\n    !!obj && (\n    // arrays are objects, NodeLists are functions in Safari\n    typeof obj == 'object' || typeof obj == 'function') &&\n    // quacks like an array\n    'length' in obj &&\n    // not window\n    !('setInterval' in obj) &&\n    // no DOM node should be considered an array-like\n    // a 'select' element has 'length' and 'item' properties on IE8\n    typeof obj.nodeType != 'number' && (\n    // a real array\n    Array.isArray(obj) ||\n    // arguments\n    'callee' in obj ||\n    // HTMLCollection/NodeList\n    'item' in obj)\n  );\n}\n\n/**\n * Ensure that the argument is an array by wrapping it in an array if it is not.\n * Creates a copy of the argument if it is already an array.\n *\n * This is mostly useful idiomatically:\n *\n *   var createArrayFromMixed = require('createArrayFromMixed');\n *\n *   function takesOneOrMoreThings(things) {\n *     things = createArrayFromMixed(things);\n *     ...\n *   }\n *\n * This allows you to treat `things' as an array, but accept scalars in the API.\n *\n * If you need to convert an array-like object, like `arguments`, into an array\n * use toArray instead.\n *\n * @param {*} obj\n * @return {array}\n */\nfunction createArrayFromMixed(obj) {\n  if (!hasArrayNature(obj)) {\n    return [obj];\n  } else if (Array.isArray(obj)) {\n    return obj.slice();\n  } else {\n    return toArray(obj);\n  }\n}\n\nmodule.exports = createArrayFromMixed;\n\n/***/ }),\n/* 467 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorEditHandler\n * @format\n * \n */\n\n\n\nvar onBeforeInput = __webpack_require__(468);\nvar onBlur = __webpack_require__(471);\nvar onCompositionStart = __webpack_require__(472);\nvar onCopy = __webpack_require__(473);\nvar onCut = __webpack_require__(474);\nvar onDragOver = __webpack_require__(475);\nvar onDragStart = __webpack_require__(476);\nvar onFocus = __webpack_require__(477);\nvar onInput = __webpack_require__(478);\nvar onKeyDown = __webpack_require__(479);\nvar onPaste = __webpack_require__(493);\nvar onSelect = __webpack_require__(498);\n\nvar DraftEditorEditHandler = {\n  onBeforeInput: onBeforeInput,\n  onBlur: onBlur,\n  onCompositionStart: onCompositionStart,\n  onCopy: onCopy,\n  onCut: onCut,\n  onDragOver: onDragOver,\n  onDragStart: onDragStart,\n  onFocus: onFocus,\n  onInput: onInput,\n  onKeyDown: onKeyDown,\n  onPaste: onPaste,\n  onSelect: onSelect\n};\n\nmodule.exports = DraftEditorEditHandler;\n\n/***/ }),\n/* 468 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnBeforeInput\n * @format\n * \n */\n\n\n\nvar BlockTree = __webpack_require__(222);\nvar DraftModifier = __webpack_require__(62);\nvar EditorState = __webpack_require__(59);\nvar UserAgent = __webpack_require__(67);\n\nvar getEntityKeyForSelection = __webpack_require__(162);\nvar isEventHandled = __webpack_require__(93);\nvar isSelectionAtLeafStart = __webpack_require__(226);\nvar nullthrows = __webpack_require__(65);\nvar setImmediate = __webpack_require__(469);\n\n// When nothing is focused, Firefox regards two characters, `'` and `/`, as\n// commands that should open and focus the \"quickfind\" search bar. This should\n// *never* happen while a contenteditable is focused, but as of v28, it\n// sometimes does, even when the keypress event target is the contenteditable.\n// This breaks the input. Special case these characters to ensure that when\n// they are typed, we prevent default on the event to make sure not to\n// trigger quickfind.\nvar FF_QUICKFIND_CHAR = \"'\";\nvar FF_QUICKFIND_LINK_CHAR = '/';\nvar isFirefox = UserAgent.isBrowser('Firefox');\n\nfunction mustPreventDefaultForCharacter(character) {\n  return isFirefox && (character == FF_QUICKFIND_CHAR || character == FF_QUICKFIND_LINK_CHAR);\n}\n\n/**\n * Replace the current selection with the specified text string, with the\n * inline style and entity key applied to the newly inserted text.\n */\nfunction replaceText(editorState, text, inlineStyle, entityKey) {\n  var contentState = DraftModifier.replaceText(editorState.getCurrentContent(), editorState.getSelection(), text, inlineStyle, entityKey);\n  return EditorState.push(editorState, contentState, 'insert-characters');\n}\n\n/**\n * When `onBeforeInput` executes, the browser is attempting to insert a\n * character into the editor. Apply this character data to the document,\n * allowing native insertion if possible.\n *\n * Native insertion is encouraged in order to limit re-rendering and to\n * preserve spellcheck highlighting, which disappears or flashes if re-render\n * occurs on the relevant text nodes.\n */\nfunction editOnBeforeInput(editor, e) {\n  if (editor._pendingStateFromBeforeInput !== undefined) {\n    editor.update(editor._pendingStateFromBeforeInput);\n    editor._pendingStateFromBeforeInput = undefined;\n  }\n\n  var editorState = editor._latestEditorState;\n\n  var chars = e.data;\n\n  // In some cases (ex: IE ideographic space insertion) no character data\n  // is provided. There's nothing to do when this happens.\n  if (!chars) {\n    return;\n  }\n\n  // Allow the top-level component to handle the insertion manually. This is\n  // useful when triggering interesting behaviors for a character insertion,\n  // Simple examples: replacing a raw text ':)' with a smile emoji or image\n  // decorator, or setting a block to be a list item after typing '- ' at the\n  // start of the block.\n  if (editor.props.handleBeforeInput && isEventHandled(editor.props.handleBeforeInput(chars, editorState))) {\n    e.preventDefault();\n    return;\n  }\n\n  // If selection is collapsed, conditionally allow native behavior. This\n  // reduces re-renders and preserves spellcheck highlighting. If the selection\n  // is not collapsed, we will re-render.\n  var selection = editorState.getSelection();\n  var selectionStart = selection.getStartOffset();\n  var selectionEnd = selection.getEndOffset();\n  var anchorKey = selection.getAnchorKey();\n\n  if (!selection.isCollapsed()) {\n    e.preventDefault();\n\n    // If the currently selected text matches what the user is trying to\n    // replace it with, let's just update the `SelectionState`. If not, update\n    // the `ContentState` with the new text.\n    var currentlySelectedChars = editorState.getCurrentContent().getPlainText().slice(selectionStart, selectionEnd);\n    if (chars === currentlySelectedChars) {\n      editor.update(EditorState.forceSelection(editorState, selection.merge({\n        focusOffset: selectionEnd\n      })));\n    } else {\n      editor.update(replaceText(editorState, chars, editorState.getCurrentInlineStyle(), getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection())));\n    }\n    return;\n  }\n\n  var newEditorState = replaceText(editorState, chars, editorState.getCurrentInlineStyle(), getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection()));\n\n  // Bunch of different cases follow where we need to prevent native insertion.\n  var mustPreventNative = false;\n  if (!mustPreventNative) {\n    // Browsers tend to insert text in weird places in the DOM when typing at\n    // the start of a leaf, so we'll handle it ourselves.\n    mustPreventNative = isSelectionAtLeafStart(editor._latestCommittedEditorState);\n  }\n  if (!mustPreventNative) {\n    // Chrome will also split up a node into two pieces if it contains a Tab\n    // char, for no explicable reason. Seemingly caused by this commit:\n    // https://chromium.googlesource.com/chromium/src/+/013ac5eaf3%5E%21/\n    var nativeSelection = global.getSelection();\n    // Selection is necessarily collapsed at this point due to earlier check.\n    if (nativeSelection.anchorNode && nativeSelection.anchorNode.nodeType === Node.TEXT_NODE) {\n      // See isTabHTMLSpanElement in chromium EditingUtilities.cpp.\n      var parentNode = nativeSelection.anchorNode.parentNode;\n      mustPreventNative = parentNode.nodeName === 'SPAN' && parentNode.firstChild.nodeType === Node.TEXT_NODE && parentNode.firstChild.nodeValue.indexOf('\\t') !== -1;\n    }\n  }\n  if (!mustPreventNative) {\n    // Check the old and new \"fingerprints\" of the current block to determine\n    // whether this insertion requires any addition or removal of text nodes,\n    // in which case we would prevent the native character insertion.\n    var originalFingerprint = BlockTree.getFingerprint(editorState.getBlockTree(anchorKey));\n    var newFingerprint = BlockTree.getFingerprint(newEditorState.getBlockTree(anchorKey));\n    mustPreventNative = originalFingerprint !== newFingerprint;\n  }\n  if (!mustPreventNative) {\n    mustPreventNative = mustPreventDefaultForCharacter(chars);\n  }\n  if (!mustPreventNative) {\n    mustPreventNative = nullthrows(newEditorState.getDirectionMap()).get(anchorKey) !== nullthrows(editorState.getDirectionMap()).get(anchorKey);\n  }\n\n  if (mustPreventNative) {\n    e.preventDefault();\n    editor.update(newEditorState);\n    return;\n  }\n\n  // We made it all the way! Let the browser do its thing and insert the char.\n  newEditorState = EditorState.set(newEditorState, {\n    nativelyRenderedContent: newEditorState.getCurrentContent()\n  });\n  // The native event is allowed to occur. To allow user onChange handlers to\n  // change the inserted text, we wait until the text is actually inserted\n  // before we actually update our state. That way when we rerender, the text\n  // we see in the DOM will already have been inserted properly.\n  editor._pendingStateFromBeforeInput = newEditorState;\n  setImmediate(function () {\n    if (editor._pendingStateFromBeforeInput !== undefined) {\n      editor.update(editor._pendingStateFromBeforeInput);\n      editor._pendingStateFromBeforeInput = undefined;\n    }\n  });\n}\n\nmodule.exports = editOnBeforeInput;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2)))\n\n/***/ }),\n/* 469 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n\n\n// setimmediate adds setImmediate to the global. We want to make sure we export\n// the actual function.\n\n__webpack_require__(470);\nmodule.exports = global.setImmediate;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2)))\n\n/***/ }),\n/* 470 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2), __webpack_require__(130)))\n\n/***/ }),\n/* 471 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnBlur\n * @format\n * \n */\n\n\n\nvar EditorState = __webpack_require__(59);\n\nvar containsNode = __webpack_require__(163);\nvar getActiveElement = __webpack_require__(228);\n\nfunction editOnBlur(editor, e) {\n  // In a contentEditable element, when you select a range and then click\n  // another active element, this does trigger a `blur` event but will not\n  // remove the DOM selection from the contenteditable.\n  // This is consistent across all browsers, but we prefer that the editor\n  // behave like a textarea, where a `blur` event clears the DOM selection.\n  // We therefore force the issue to be certain, checking whether the active\n  // element is `body` to force it when blurring occurs within the window (as\n  // opposed to clicking to another tab or window).\n  if (getActiveElement() === document.body) {\n    var _selection = global.getSelection();\n    var editorNode = editor.editor;\n    if (_selection.rangeCount === 1 && containsNode(editorNode, _selection.anchorNode) && containsNode(editorNode, _selection.focusNode)) {\n      _selection.removeAllRanges();\n    }\n  }\n\n  var editorState = editor._latestEditorState;\n  var currentSelection = editorState.getSelection();\n  if (!currentSelection.getHasFocus()) {\n    return;\n  }\n\n  var selection = currentSelection.set('hasFocus', false);\n  editor.props.onBlur && editor.props.onBlur(e);\n  editor.update(EditorState.acceptSelection(editorState, selection));\n}\n\nmodule.exports = editOnBlur;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2)))\n\n/***/ }),\n/* 472 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnCompositionStart\n * @format\n * \n */\n\n\n\nvar EditorState = __webpack_require__(59);\n\n/**\n * The user has begun using an IME input system. Switching to `composite` mode\n * allows handling composition input and disables other edit behavior.\n */\nfunction editOnCompositionStart(editor, e) {\n  editor.setMode('composite');\n  editor.update(EditorState.set(editor._latestEditorState, { inCompositionMode: true }));\n  // Allow composition handler to interpret the compositionstart event\n  editor._onCompositionStart(e);\n}\n\nmodule.exports = editOnCompositionStart;\n\n/***/ }),\n/* 473 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnCopy\n * @format\n * \n */\n\n\n\nvar getFragmentFromSelection = __webpack_require__(234);\n\n/**\n * If we have a selection, create a ContentState fragment and store\n * it in our internal clipboard. Subsequent paste events will use this\n * fragment if no external clipboard data is supplied.\n */\nfunction editOnCopy(editor, e) {\n  var editorState = editor._latestEditorState;\n  var selection = editorState.getSelection();\n\n  // No selection, so there's nothing to copy.\n  if (selection.isCollapsed()) {\n    e.preventDefault();\n    return;\n  }\n\n  editor.setClipboard(getFragmentFromSelection(editor._latestEditorState));\n}\n\nmodule.exports = editOnCopy;\n\n/***/ }),\n/* 474 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnCut\n * @format\n * \n */\n\n\n\nvar DraftModifier = __webpack_require__(62);\nvar EditorState = __webpack_require__(59);\nvar Style = __webpack_require__(164);\n\nvar getFragmentFromSelection = __webpack_require__(234);\nvar getScrollPosition = __webpack_require__(165);\n\n/**\n * On `cut` events, native behavior is allowed to occur so that the system\n * clipboard is set properly. This means that we need to take steps to recover\n * the editor DOM state after the `cut` has occurred in order to maintain\n * control of the component.\n *\n * In addition, we can keep a copy of the removed fragment, including all\n * styles and entities, for use as an internal paste.\n */\nfunction editOnCut(editor, e) {\n  var editorState = editor._latestEditorState;\n  var selection = editorState.getSelection();\n  var element = e.target;\n  var scrollPosition = void 0;\n\n  // No selection, so there's nothing to cut.\n  if (selection.isCollapsed()) {\n    e.preventDefault();\n    return;\n  }\n\n  // Track the current scroll position so that it can be forced back in place\n  // after the editor regains control of the DOM.\n  if (element instanceof Node) {\n    scrollPosition = getScrollPosition(Style.getScrollParent(element));\n  }\n\n  var fragment = getFragmentFromSelection(editorState);\n  editor.setClipboard(fragment);\n\n  // Set `cut` mode to disable all event handling temporarily.\n  editor.setMode('cut');\n\n  // Let native `cut` behavior occur, then recover control.\n  setTimeout(function () {\n    editor.restoreEditorDOM(scrollPosition);\n    editor.exitCurrentMode();\n    editor.update(removeFragment(editorState));\n  }, 0);\n}\n\nfunction removeFragment(editorState) {\n  var newContent = DraftModifier.removeRange(editorState.getCurrentContent(), editorState.getSelection(), 'forward');\n  return EditorState.push(editorState, newContent, 'remove-range');\n}\n\nmodule.exports = editOnCut;\n\n/***/ }),\n/* 475 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnDragOver\n * @format\n * \n */\n\n\n\n/**\n * Drag behavior has begun from outside the editor element.\n */\nfunction editOnDragOver(editor, e) {\n  editor._internalDrag = false;\n  editor.setMode('drag');\n  e.preventDefault();\n}\n\nmodule.exports = editOnDragOver;\n\n/***/ }),\n/* 476 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnDragStart\n * @format\n * \n */\n\n\n\n/**\n * A `dragstart` event has begun within the text editor component.\n */\nfunction editOnDragStart(editor) {\n  editor._internalDrag = true;\n  editor.setMode('drag');\n}\n\nmodule.exports = editOnDragStart;\n\n/***/ }),\n/* 477 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnFocus\n * @format\n * \n */\n\n\n\nvar EditorState = __webpack_require__(59);\nvar UserAgent = __webpack_require__(67);\n\nfunction editOnFocus(editor, e) {\n  var editorState = editor._latestEditorState;\n  var currentSelection = editorState.getSelection();\n  if (currentSelection.getHasFocus()) {\n    return;\n  }\n\n  var selection = currentSelection.set('hasFocus', true);\n  editor.props.onFocus && editor.props.onFocus(e);\n\n  // When the tab containing this text editor is hidden and the user does a\n  // find-in-page in a _different_ tab, Chrome on Mac likes to forget what the\n  // selection was right after sending this focus event and (if you let it)\n  // moves the cursor back to the beginning of the editor, so we force the\n  // selection here instead of simply accepting it in order to preserve the\n  // old cursor position. See https://crbug.com/540004.\n  // But it looks like this is fixed in Chrome 60.0.3081.0.\n  // Other browsers also don't have this bug, so we prefer to acceptSelection\n  // when possible, to ensure that unfocusing and refocusing a Draft editor\n  // doesn't preserve the selection, matching how textareas work.\n  if (UserAgent.isBrowser('Chrome < 60.0.3081.0')) {\n    editor.update(EditorState.forceSelection(editorState, selection));\n  } else {\n    editor.update(EditorState.acceptSelection(editorState, selection));\n  }\n}\n\nmodule.exports = editOnFocus;\n\n/***/ }),\n/* 478 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnInput\n * @format\n * \n */\n\n\n\nvar DraftFeatureFlags = __webpack_require__(71);\nvar DraftModifier = __webpack_require__(62);\nvar DraftOffsetKey = __webpack_require__(116);\nvar EditorState = __webpack_require__(59);\nvar UserAgent = __webpack_require__(67);\n\nvar findAncestorOffsetKey = __webpack_require__(166);\nvar nullthrows = __webpack_require__(65);\n\nvar isGecko = UserAgent.isEngine('Gecko');\n\nvar DOUBLE_NEWLINE = '\\n\\n';\n\n/**\n * This function is intended to handle spellcheck and autocorrect changes,\n * which occur in the DOM natively without any opportunity to observe or\n * interpret the changes before they occur.\n *\n * The `input` event fires in contentEditable elements reliably for non-IE\n * browsers, immediately after changes occur to the editor DOM. Since our other\n * handlers override or otherwise handle cover other varieties of text input,\n * the DOM state should match the model in all controlled input cases. Thus,\n * when an `input` change leads to a DOM/model mismatch, the change should be\n * due to a spellcheck change, and we can incorporate it into our model.\n */\nfunction editOnInput(editor) {\n  if (editor._pendingStateFromBeforeInput !== undefined) {\n    editor.update(editor._pendingStateFromBeforeInput);\n    editor._pendingStateFromBeforeInput = undefined;\n  }\n\n  var domSelection = global.getSelection();\n\n  var anchorNode = domSelection.anchorNode,\n      isCollapsed = domSelection.isCollapsed;\n\n  var isNotTextNode = anchorNode.nodeType !== Node.TEXT_NODE;\n  var isNotTextOrElementNode = anchorNode.nodeType !== Node.TEXT_NODE && anchorNode.nodeType !== Node.ELEMENT_NODE;\n\n  if (DraftFeatureFlags.draft_killswitch_allow_nontextnodes) {\n    if (isNotTextNode) {\n      return;\n    }\n  } else {\n    if (isNotTextOrElementNode) {\n      // TODO: (t16149272) figure out context for this change\n      return;\n    }\n  }\n\n  if (anchorNode.nodeType === Node.TEXT_NODE && (anchorNode.previousSibling !== null || anchorNode.nextSibling !== null)) {\n    // When typing at the beginning of a visual line, Chrome splits the text\n    // nodes into two. Why? No one knows. This commit is suspicious:\n    // https://chromium.googlesource.com/chromium/src/+/a3b600981286b135632371477f902214c55a1724\n    // To work around, we'll merge the sibling text nodes back into this one.\n    var span = anchorNode.parentNode;\n    anchorNode.nodeValue = span.textContent;\n    for (var child = span.firstChild; child !== null; child = child.nextSibling) {\n      if (child !== anchorNode) {\n        span.removeChild(child);\n      }\n    }\n  }\n\n  var domText = anchorNode.textContent;\n  var editorState = editor._latestEditorState;\n  var offsetKey = nullthrows(findAncestorOffsetKey(anchorNode));\n\n  var _DraftOffsetKey$decod = DraftOffsetKey.decode(offsetKey),\n      blockKey = _DraftOffsetKey$decod.blockKey,\n      decoratorKey = _DraftOffsetKey$decod.decoratorKey,\n      leafKey = _DraftOffsetKey$decod.leafKey;\n\n  var _editorState$getBlock = editorState.getBlockTree(blockKey).getIn([decoratorKey, 'leaves', leafKey]),\n      start = _editorState$getBlock.start,\n      end = _editorState$getBlock.end;\n\n  var content = editorState.getCurrentContent();\n  var block = content.getBlockForKey(blockKey);\n  var modelText = block.getText().slice(start, end);\n\n  // Special-case soft newlines here. If the DOM text ends in a soft newline,\n  // we will have manually inserted an extra soft newline in DraftEditorLeaf.\n  // We want to remove this extra newline for the purpose of our comparison\n  // of DOM and model text.\n  if (domText.endsWith(DOUBLE_NEWLINE)) {\n    domText = domText.slice(0, -1);\n  }\n\n  // No change -- the DOM is up to date. Nothing to do here.\n  if (domText === modelText) {\n    // This can be buggy for some Android keyboards because they don't fire\n    // standard onkeydown/pressed events and only fired editOnInput\n    // so domText is already changed by the browser and ends up being equal\n    // to modelText unexpectedly\n    return;\n  }\n\n  var selection = editorState.getSelection();\n\n  // We'll replace the entire leaf with the text content of the target.\n  var targetRange = selection.merge({\n    anchorOffset: start,\n    focusOffset: end,\n    isBackward: false\n  });\n\n  var entityKey = block.getEntityAt(start);\n  var entity = entityKey && content.getEntity(entityKey);\n  var entityType = entity && entity.getMutability();\n  var preserveEntity = entityType === 'MUTABLE';\n\n  // Immutable or segmented entities cannot properly be handled by the\n  // default browser undo, so we have to use a different change type to\n  // force using our internal undo method instead of falling through to the\n  // native browser undo.\n  var changeType = preserveEntity ? 'spellcheck-change' : 'apply-entity';\n\n  var newContent = DraftModifier.replaceText(content, targetRange, domText, block.getInlineStyleAt(start), preserveEntity ? block.getEntityAt(start) : null);\n\n  var anchorOffset, focusOffset, startOffset, endOffset;\n\n  if (isGecko) {\n    // Firefox selection does not change while the context menu is open, so\n    // we preserve the anchor and focus values of the DOM selection.\n    anchorOffset = domSelection.anchorOffset;\n    focusOffset = domSelection.focusOffset;\n    startOffset = start + Math.min(anchorOffset, focusOffset);\n    endOffset = startOffset + Math.abs(anchorOffset - focusOffset);\n    anchorOffset = startOffset;\n    focusOffset = endOffset;\n  } else {\n    // Browsers other than Firefox may adjust DOM selection while the context\n    // menu is open, and Safari autocorrect is prone to providing an inaccurate\n    // DOM selection. Don't trust it. Instead, use our existing SelectionState\n    // and adjust it based on the number of characters changed during the\n    // mutation.\n    var charDelta = domText.length - modelText.length;\n    startOffset = selection.getStartOffset();\n    endOffset = selection.getEndOffset();\n\n    anchorOffset = isCollapsed ? endOffset + charDelta : startOffset;\n    focusOffset = endOffset + charDelta;\n  }\n\n  // Segmented entities are completely or partially removed when their\n  // text content changes. For this case we do not want any text to be selected\n  // after the change, so we are not merging the selection.\n  var contentWithAdjustedDOMSelection = newContent.merge({\n    selectionBefore: content.getSelectionAfter(),\n    selectionAfter: selection.merge({ anchorOffset: anchorOffset, focusOffset: focusOffset })\n  });\n\n  editor.update(EditorState.push(editorState, contentWithAdjustedDOMSelection, changeType));\n}\n\nmodule.exports = editOnInput;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2)))\n\n/***/ }),\n/* 479 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnKeyDown\n * @format\n * \n */\n\n\n\nvar DraftModifier = __webpack_require__(62);\nvar EditorState = __webpack_require__(59);\nvar KeyBindingUtil = __webpack_require__(167);\nvar Keys = __webpack_require__(161);\nvar SecondaryClipboard = __webpack_require__(480);\nvar UserAgent = __webpack_require__(67);\n\nvar isEventHandled = __webpack_require__(93);\nvar keyCommandBackspaceToStartOfLine = __webpack_require__(481);\nvar keyCommandBackspaceWord = __webpack_require__(483);\nvar keyCommandDeleteWord = __webpack_require__(485);\nvar keyCommandInsertNewline = __webpack_require__(486);\nvar keyCommandMoveSelectionToEndOfBlock = __webpack_require__(487);\nvar keyCommandMoveSelectionToStartOfBlock = __webpack_require__(488);\nvar keyCommandPlainBackspace = __webpack_require__(489);\nvar keyCommandPlainDelete = __webpack_require__(490);\nvar keyCommandTransposeCharacters = __webpack_require__(491);\nvar keyCommandUndo = __webpack_require__(492);\n\nvar isOptionKeyCommand = KeyBindingUtil.isOptionKeyCommand;\n\nvar isChrome = UserAgent.isBrowser('Chrome');\n\n/**\n * Map a `DraftEditorCommand` command value to a corresponding function.\n */\nfunction onKeyCommand(command, editorState) {\n  switch (command) {\n    case 'redo':\n      return EditorState.redo(editorState);\n    case 'delete':\n      return keyCommandPlainDelete(editorState);\n    case 'delete-word':\n      return keyCommandDeleteWord(editorState);\n    case 'backspace':\n      return keyCommandPlainBackspace(editorState);\n    case 'backspace-word':\n      return keyCommandBackspaceWord(editorState);\n    case 'backspace-to-start-of-line':\n      return keyCommandBackspaceToStartOfLine(editorState);\n    case 'split-block':\n      return keyCommandInsertNewline(editorState);\n    case 'transpose-characters':\n      return keyCommandTransposeCharacters(editorState);\n    case 'move-selection-to-start-of-block':\n      return keyCommandMoveSelectionToStartOfBlock(editorState);\n    case 'move-selection-to-end-of-block':\n      return keyCommandMoveSelectionToEndOfBlock(editorState);\n    case 'secondary-cut':\n      return SecondaryClipboard.cut(editorState);\n    case 'secondary-paste':\n      return SecondaryClipboard.paste(editorState);\n    default:\n      return editorState;\n  }\n}\n\n/**\n * Intercept keydown behavior to handle keys and commands manually, if desired.\n *\n * Keydown combinations may be mapped to `DraftCommand` values, which may\n * correspond to command functions that modify the editor or its contents.\n *\n * See `getDefaultKeyBinding` for defaults. Alternatively, the top-level\n * component may provide a custom mapping via the `keyBindingFn` prop.\n */\nfunction editOnKeyDown(editor, e) {\n  var keyCode = e.which;\n  var editorState = editor._latestEditorState;\n\n  switch (keyCode) {\n    case Keys.RETURN:\n      e.preventDefault();\n      // The top-level component may manually handle newline insertion. If\n      // no special handling is performed, fall through to command handling.\n      if (editor.props.handleReturn && isEventHandled(editor.props.handleReturn(e, editorState))) {\n        return;\n      }\n      break;\n    case Keys.ESC:\n      e.preventDefault();\n      editor.props.onEscape && editor.props.onEscape(e);\n      return;\n    case Keys.TAB:\n      editor.props.onTab && editor.props.onTab(e);\n      return;\n    case Keys.UP:\n      editor.props.onUpArrow && editor.props.onUpArrow(e);\n      return;\n    case Keys.RIGHT:\n      editor.props.onRightArrow && editor.props.onRightArrow(e);\n      return;\n    case Keys.DOWN:\n      editor.props.onDownArrow && editor.props.onDownArrow(e);\n      return;\n    case Keys.LEFT:\n      editor.props.onLeftArrow && editor.props.onLeftArrow(e);\n      return;\n    case Keys.SPACE:\n      // Handling for OSX where option + space scrolls.\n      if (isChrome && isOptionKeyCommand(e)) {\n        e.preventDefault();\n        // Insert a nbsp into the editor.\n        var contentState = DraftModifier.replaceText(editorState.getCurrentContent(), editorState.getSelection(), '\\xA0');\n        editor.update(EditorState.push(editorState, contentState, 'insert-characters'));\n        return;\n      }\n  }\n\n  var command = editor.props.keyBindingFn(e);\n\n  // If no command is specified, allow keydown event to continue.\n  if (!command) {\n    return;\n  }\n\n  if (command === 'undo') {\n    // Since undo requires some special updating behavior to keep the editor\n    // in sync, handle it separately.\n    keyCommandUndo(e, editorState, editor.update);\n    return;\n  }\n\n  // At this point, we know that we're handling a command of some kind, so\n  // we don't want to insert a character following the keydown.\n  e.preventDefault();\n\n  // Allow components higher up the tree to handle the command first.\n  if (editor.props.handleKeyCommand && isEventHandled(editor.props.handleKeyCommand(command, editorState))) {\n    return;\n  }\n\n  var newState = onKeyCommand(command, editorState);\n  if (newState !== editorState) {\n    editor.update(newState);\n  }\n}\n\nmodule.exports = editOnKeyDown;\n\n/***/ }),\n/* 480 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule SecondaryClipboard\n * @format\n * \n */\n\n\n\nvar DraftModifier = __webpack_require__(62);\nvar EditorState = __webpack_require__(59);\n\nvar getContentStateFragment = __webpack_require__(114);\nvar nullthrows = __webpack_require__(65);\n\nvar clipboard = null;\n\n/**\n * Some systems offer a \"secondary\" clipboard to allow quick internal cut\n * and paste behavior. For instance, Ctrl+K (cut) and Ctrl+Y (paste).\n */\nvar SecondaryClipboard = {\n  cut: function cut(editorState) {\n    var content = editorState.getCurrentContent();\n    var selection = editorState.getSelection();\n    var targetRange = null;\n\n    if (selection.isCollapsed()) {\n      var anchorKey = selection.getAnchorKey();\n      var blockEnd = content.getBlockForKey(anchorKey).getLength();\n\n      if (blockEnd === selection.getAnchorOffset()) {\n        return editorState;\n      }\n\n      targetRange = selection.set('focusOffset', blockEnd);\n    } else {\n      targetRange = selection;\n    }\n\n    targetRange = nullthrows(targetRange);\n    clipboard = getContentStateFragment(content, targetRange);\n\n    var afterRemoval = DraftModifier.removeRange(content, targetRange, 'forward');\n\n    if (afterRemoval === content) {\n      return editorState;\n    }\n\n    return EditorState.push(editorState, afterRemoval, 'remove-range');\n  },\n\n  paste: function paste(editorState) {\n    if (!clipboard) {\n      return editorState;\n    }\n\n    var newContent = DraftModifier.replaceWithFragment(editorState.getCurrentContent(), editorState.getSelection(), clipboard);\n\n    return EditorState.push(editorState, newContent, 'insert-fragment');\n  }\n};\n\nmodule.exports = SecondaryClipboard;\n\n/***/ }),\n/* 481 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandBackspaceToStartOfLine\n * @format\n * \n */\n\n\n\nvar EditorState = __webpack_require__(59);\n\nvar expandRangeToStartOfLine = __webpack_require__(482);\nvar getDraftEditorSelectionWithNodes = __webpack_require__(236);\nvar moveSelectionBackward = __webpack_require__(168);\nvar removeTextWithStrategy = __webpack_require__(94);\n\nfunction keyCommandBackspaceToStartOfLine(editorState) {\n  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {\n    var selection = strategyState.getSelection();\n    if (selection.isCollapsed() && selection.getAnchorOffset() === 0) {\n      return moveSelectionBackward(strategyState, 1);\n    }\n\n    var domSelection = global.getSelection();\n    var range = domSelection.getRangeAt(0);\n    range = expandRangeToStartOfLine(range);\n\n    return getDraftEditorSelectionWithNodes(strategyState, null, range.endContainer, range.endOffset, range.startContainer, range.startOffset).selectionState;\n  }, 'backward');\n\n  if (afterRemoval === editorState.getCurrentContent()) {\n    return editorState;\n  }\n\n  return EditorState.push(editorState, afterRemoval, 'remove-range');\n}\n\nmodule.exports = keyCommandBackspaceToStartOfLine;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2)))\n\n/***/ }),\n/* 482 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule expandRangeToStartOfLine\n * @format\n * \n */\n\nvar UnicodeUtils = __webpack_require__(77);\n\nvar getRangeClientRects = __webpack_require__(235);\nvar invariant = __webpack_require__(58);\n\n/**\n * Return the computed line height, in pixels, for the provided element.\n */\nfunction getLineHeightPx(element) {\n  var computed = getComputedStyle(element);\n  var div = document.createElement('div');\n  div.style.fontFamily = computed.fontFamily;\n  div.style.fontSize = computed.fontSize;\n  div.style.fontStyle = computed.fontStyle;\n  div.style.fontWeight = computed.fontWeight;\n  div.style.lineHeight = computed.lineHeight;\n  div.style.position = 'absolute';\n  div.textContent = 'M';\n\n  var documentBody = document.body;\n  !documentBody ?  false ? invariant(false, 'Missing document.body') : invariant(false) : void 0;\n\n  // forced layout here\n  documentBody.appendChild(div);\n  var rect = div.getBoundingClientRect();\n  documentBody.removeChild(div);\n\n  return rect.height;\n}\n\n/**\n * Return whether every ClientRect in the provided list lies on the same line.\n *\n * We assume that the rects on the same line all contain the baseline, so the\n * lowest top line needs to be above the highest bottom line (i.e., if you were\n * to project the rects onto the y-axis, their intersection would be nonempty).\n *\n * In addition, we require that no two boxes are lineHeight (or more) apart at\n * either top or bottom, which helps protect against false positives for fonts\n * with extremely large glyph heights (e.g., with a font size of 17px, Zapfino\n * produces rects of height 58px!).\n */\nfunction areRectsOnOneLine(rects, lineHeight) {\n  var minTop = Infinity;\n  var minBottom = Infinity;\n  var maxTop = -Infinity;\n  var maxBottom = -Infinity;\n\n  for (var ii = 0; ii < rects.length; ii++) {\n    var rect = rects[ii];\n    if (rect.width === 0 || rect.width === 1) {\n      // When a range starts or ends a soft wrap, many browsers (Chrome, IE,\n      // Safari) include an empty rect on the previous or next line. When the\n      // text lies in a container whose position is not integral (e.g., from\n      // margin: auto), Safari makes these empty rects have width 1 (instead of\n      // 0). Having one-pixel-wide characters seems unlikely (and most browsers\n      // report widths in subpixel precision anyway) so it's relatively safe to\n      // skip over them.\n      continue;\n    }\n    minTop = Math.min(minTop, rect.top);\n    minBottom = Math.min(minBottom, rect.bottom);\n    maxTop = Math.max(maxTop, rect.top);\n    maxBottom = Math.max(maxBottom, rect.bottom);\n  }\n\n  return maxTop <= minBottom && maxTop - minTop < lineHeight && maxBottom - minBottom < lineHeight;\n}\n\n/**\n * Return the length of a node, as used by Range offsets.\n */\nfunction getNodeLength(node) {\n  // http://www.w3.org/TR/dom/#concept-node-length\n  switch (node.nodeType) {\n    case Node.DOCUMENT_TYPE_NODE:\n      return 0;\n    case Node.TEXT_NODE:\n    case Node.PROCESSING_INSTRUCTION_NODE:\n    case Node.COMMENT_NODE:\n      return node.length;\n    default:\n      return node.childNodes.length;\n  }\n}\n\n/**\n * Given a collapsed range, move the start position backwards as far as\n * possible while the range still spans only a single line.\n */\nfunction expandRangeToStartOfLine(range) {\n  !range.collapsed ?  false ? invariant(false, 'expandRangeToStartOfLine: Provided range is not collapsed.') : invariant(false) : void 0;\n  range = range.cloneRange();\n\n  var containingElement = range.startContainer;\n  if (containingElement.nodeType !== 1) {\n    containingElement = containingElement.parentNode;\n  }\n  var lineHeight = getLineHeightPx(containingElement);\n\n  // Imagine our text looks like:\n  //   <div><span>once upon a time, there was a <em>boy\n  //   who lived</em> </span><q><strong>under^ the\n  //   stairs</strong> in a small closet.</q></div>\n  // where the caret represents the cursor. First, we crawl up the tree until\n  // the range spans multiple lines (setting the start point to before\n  // \"<strong>\", then before \"<div>\"), then at each level we do a search to\n  // find the latest point which is still on a previous line. We'll find that\n  // the break point is inside the span, then inside the <em>, then in its text\n  // node child, the actual break point before \"who\".\n\n  var bestContainer = range.endContainer;\n  var bestOffset = range.endOffset;\n  range.setStart(range.startContainer, 0);\n\n  while (areRectsOnOneLine(getRangeClientRects(range), lineHeight)) {\n    bestContainer = range.startContainer;\n    bestOffset = range.startOffset;\n    !bestContainer.parentNode ?  false ? invariant(false, 'Found unexpected detached subtree when traversing.') : invariant(false) : void 0;\n    range.setStartBefore(bestContainer);\n    if (bestContainer.nodeType === 1 && getComputedStyle(bestContainer).display !== 'inline') {\n      // The start of the line is never in a different block-level container.\n      break;\n    }\n  }\n\n  // In the above example, range now spans from \"<div>\" to \"under\",\n  // bestContainer is <div>, and bestOffset is 1 (index of <q> inside <div>)].\n  // Picking out which child to recurse into here is a special case since we\n  // don't want to check past <q> -- once we find that the final range starts\n  // in <span>, we can look at all of its children (and all of their children)\n  // to find the break point.\n\n  // At all times, (bestContainer, bestOffset) is the latest single-line start\n  // point that we know of.\n  var currentContainer = bestContainer;\n  var maxIndexToConsider = bestOffset - 1;\n\n  do {\n    var nodeValue = currentContainer.nodeValue;\n\n    for (var ii = maxIndexToConsider; ii >= 0; ii--) {\n      if (nodeValue != null && ii > 0 && UnicodeUtils.isSurrogatePair(nodeValue, ii - 1)) {\n        // We're in the middle of a surrogate pair -- skip over so we never\n        // return a range with an endpoint in the middle of a code point.\n        continue;\n      }\n\n      range.setStart(currentContainer, ii);\n      if (areRectsOnOneLine(getRangeClientRects(range), lineHeight)) {\n        bestContainer = currentContainer;\n        bestOffset = ii;\n      } else {\n        break;\n      }\n    }\n\n    if (ii === -1 || currentContainer.childNodes.length === 0) {\n      // If ii === -1, then (bestContainer, bestOffset), which is equal to\n      // (currentContainer, 0), was a single-line start point but a start\n      // point before currentContainer wasn't, so the line break seems to\n      // have occurred immediately after currentContainer's start tag\n      //\n      // If currentContainer.childNodes.length === 0, we're already at a\n      // terminal node (e.g., text node) and should return our current best.\n      break;\n    }\n\n    currentContainer = currentContainer.childNodes[ii];\n    maxIndexToConsider = getNodeLength(currentContainer);\n  } while (true);\n\n  range.setStart(bestContainer, bestOffset);\n  return range;\n}\n\nmodule.exports = expandRangeToStartOfLine;\n\n/***/ }),\n/* 483 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandBackspaceWord\n * @format\n * \n */\n\n\n\nvar DraftRemovableWord = __webpack_require__(237);\nvar EditorState = __webpack_require__(59);\n\nvar moveSelectionBackward = __webpack_require__(168);\nvar removeTextWithStrategy = __webpack_require__(94);\n\n/**\n * Delete the word that is left of the cursor, as well as any spaces or\n * punctuation after the word.\n */\nfunction keyCommandBackspaceWord(editorState) {\n  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {\n    var selection = strategyState.getSelection();\n    var offset = selection.getStartOffset();\n    // If there are no words before the cursor, remove the preceding newline.\n    if (offset === 0) {\n      return moveSelectionBackward(strategyState, 1);\n    }\n    var key = selection.getStartKey();\n    var content = strategyState.getCurrentContent();\n    var text = content.getBlockForKey(key).getText().slice(0, offset);\n    var toRemove = DraftRemovableWord.getBackward(text);\n    return moveSelectionBackward(strategyState, toRemove.length || 1);\n  }, 'backward');\n\n  if (afterRemoval === editorState.getCurrentContent()) {\n    return editorState;\n  }\n\n  return EditorState.push(editorState, afterRemoval, 'remove-range');\n}\n\nmodule.exports = keyCommandBackspaceWord;\n\n/***/ }),\n/* 484 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n * @stub\n * \n */\n\n\n\n// \\u00a1-\\u00b1\\u00b4-\\u00b8\\u00ba\\u00bb\\u00bf\n//             is latin supplement punctuation except fractions and superscript\n//             numbers\n// \\u2010-\\u2027\\u2030-\\u205e\n//             is punctuation from the general punctuation block:\n//             weird quotes, commas, bullets, dashes, etc.\n// \\u30fb\\u3001\\u3002\\u3008-\\u3011\\u3014-\\u301f\n//             is CJK punctuation\n// \\uff1a-\\uff1f\\uff01-\\uff0f\\uff3b-\\uff40\\uff5b-\\uff65\n//             is some full-width/half-width punctuation\n// \\u2E2E\\u061f\\u066a-\\u066c\\u061b\\u060c\\u060d\\uFD3e\\uFD3F\n//             is some Arabic punctuation marks\n// \\u1801\\u0964\\u104a\\u104b\n//             is misc. other language punctuation marks\n\nvar PUNCTUATION = '[.,+*?$|#{}()\\'\\\\^\\\\-\\\\[\\\\]\\\\\\\\\\\\/!@%\"~=<>_:;' + '\\u30FB\\u3001\\u3002\\u3008-\\u3011\\u3014-\\u301F\\uFF1A-\\uFF1F\\uFF01-\\uFF0F' + '\\uFF3B-\\uFF40\\uFF5B-\\uFF65\\u2E2E\\u061F\\u066A-\\u066C\\u061B\\u060C\\u060D' + '\\uFD3E\\uFD3F\\u1801\\u0964\\u104A\\u104B\\u2010-\\u2027\\u2030-\\u205E' + '\\xA1-\\xB1\\xB4-\\xB8\\xBA\\xBB\\xBF]';\n\nmodule.exports = {\n  getPunctuation: function getPunctuation() {\n    return PUNCTUATION;\n  }\n};\n\n/***/ }),\n/* 485 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandDeleteWord\n * @format\n * \n */\n\n\n\nvar DraftRemovableWord = __webpack_require__(237);\nvar EditorState = __webpack_require__(59);\n\nvar moveSelectionForward = __webpack_require__(238);\nvar removeTextWithStrategy = __webpack_require__(94);\n\n/**\n * Delete the word that is right of the cursor, as well as any spaces or\n * punctuation before the word.\n */\nfunction keyCommandDeleteWord(editorState) {\n  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {\n    var selection = strategyState.getSelection();\n    var offset = selection.getStartOffset();\n    var key = selection.getStartKey();\n    var content = strategyState.getCurrentContent();\n    var text = content.getBlockForKey(key).getText().slice(offset);\n    var toRemove = DraftRemovableWord.getForward(text);\n\n    // If there are no words in front of the cursor, remove the newline.\n    return moveSelectionForward(strategyState, toRemove.length || 1);\n  }, 'forward');\n\n  if (afterRemoval === editorState.getCurrentContent()) {\n    return editorState;\n  }\n\n  return EditorState.push(editorState, afterRemoval, 'remove-range');\n}\n\nmodule.exports = keyCommandDeleteWord;\n\n/***/ }),\n/* 486 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandInsertNewline\n * @format\n * \n */\n\n\n\nvar DraftModifier = __webpack_require__(62);\nvar EditorState = __webpack_require__(59);\n\nfunction keyCommandInsertNewline(editorState) {\n  var contentState = DraftModifier.splitBlock(editorState.getCurrentContent(), editorState.getSelection());\n  return EditorState.push(editorState, contentState, 'split-block');\n}\n\nmodule.exports = keyCommandInsertNewline;\n\n/***/ }),\n/* 487 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandMoveSelectionToEndOfBlock\n * @format\n * \n */\n\n\n\nvar EditorState = __webpack_require__(59);\n\n/**\n * See comment for `moveSelectionToStartOfBlock`.\n */\nfunction keyCommandMoveSelectionToEndOfBlock(editorState) {\n  var selection = editorState.getSelection();\n  var endKey = selection.getEndKey();\n  var content = editorState.getCurrentContent();\n  var textLength = content.getBlockForKey(endKey).getLength();\n  return EditorState.set(editorState, {\n    selection: selection.merge({\n      anchorKey: endKey,\n      anchorOffset: textLength,\n      focusKey: endKey,\n      focusOffset: textLength,\n      isBackward: false\n    }),\n    forceSelection: true\n  });\n}\n\nmodule.exports = keyCommandMoveSelectionToEndOfBlock;\n\n/***/ }),\n/* 488 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandMoveSelectionToStartOfBlock\n * @format\n * \n */\n\n\n\nvar EditorState = __webpack_require__(59);\n\n/**\n * Collapse selection at the start of the first selected block. This is used\n * for Firefox versions that attempt to navigate forward/backward instead of\n * moving the cursor. Other browsers are able to move the cursor natively.\n */\nfunction keyCommandMoveSelectionToStartOfBlock(editorState) {\n  var selection = editorState.getSelection();\n  var startKey = selection.getStartKey();\n  return EditorState.set(editorState, {\n    selection: selection.merge({\n      anchorKey: startKey,\n      anchorOffset: 0,\n      focusKey: startKey,\n      focusOffset: 0,\n      isBackward: false\n    }),\n    forceSelection: true\n  });\n}\n\nmodule.exports = keyCommandMoveSelectionToStartOfBlock;\n\n/***/ }),\n/* 489 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandPlainBackspace\n * @format\n * \n */\n\n\n\nvar EditorState = __webpack_require__(59);\nvar UnicodeUtils = __webpack_require__(77);\n\nvar moveSelectionBackward = __webpack_require__(168);\nvar removeTextWithStrategy = __webpack_require__(94);\n\n/**\n * Remove the selected range. If the cursor is collapsed, remove the preceding\n * character. This operation is Unicode-aware, so removing a single character\n * will remove a surrogate pair properly as well.\n */\nfunction keyCommandPlainBackspace(editorState) {\n  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {\n    var selection = strategyState.getSelection();\n    var content = strategyState.getCurrentContent();\n    var key = selection.getAnchorKey();\n    var offset = selection.getAnchorOffset();\n    var charBehind = content.getBlockForKey(key).getText()[offset - 1];\n    return moveSelectionBackward(strategyState, charBehind ? UnicodeUtils.getUTF16Length(charBehind, 0) : 1);\n  }, 'backward');\n\n  if (afterRemoval === editorState.getCurrentContent()) {\n    return editorState;\n  }\n\n  var selection = editorState.getSelection();\n  return EditorState.push(editorState, afterRemoval.set('selectionBefore', selection), selection.isCollapsed() ? 'backspace-character' : 'remove-range');\n}\n\nmodule.exports = keyCommandPlainBackspace;\n\n/***/ }),\n/* 490 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandPlainDelete\n * @format\n * \n */\n\n\n\nvar EditorState = __webpack_require__(59);\nvar UnicodeUtils = __webpack_require__(77);\n\nvar moveSelectionForward = __webpack_require__(238);\nvar removeTextWithStrategy = __webpack_require__(94);\n\n/**\n * Remove the selected range. If the cursor is collapsed, remove the following\n * character. This operation is Unicode-aware, so removing a single character\n * will remove a surrogate pair properly as well.\n */\nfunction keyCommandPlainDelete(editorState) {\n  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {\n    var selection = strategyState.getSelection();\n    var content = strategyState.getCurrentContent();\n    var key = selection.getAnchorKey();\n    var offset = selection.getAnchorOffset();\n    var charAhead = content.getBlockForKey(key).getText()[offset];\n    return moveSelectionForward(strategyState, charAhead ? UnicodeUtils.getUTF16Length(charAhead, 0) : 1);\n  }, 'forward');\n\n  if (afterRemoval === editorState.getCurrentContent()) {\n    return editorState;\n  }\n\n  var selection = editorState.getSelection();\n\n  return EditorState.push(editorState, afterRemoval.set('selectionBefore', selection), selection.isCollapsed() ? 'delete-character' : 'remove-range');\n}\n\nmodule.exports = keyCommandPlainDelete;\n\n/***/ }),\n/* 491 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandTransposeCharacters\n * @format\n * \n */\n\n\n\nvar DraftModifier = __webpack_require__(62);\nvar EditorState = __webpack_require__(59);\n\nvar getContentStateFragment = __webpack_require__(114);\n\n/**\n * Transpose the characters on either side of a collapsed cursor, or\n * if the cursor is at the end of the block, transpose the last two\n * characters.\n */\nfunction keyCommandTransposeCharacters(editorState) {\n  var selection = editorState.getSelection();\n  if (!selection.isCollapsed()) {\n    return editorState;\n  }\n\n  var offset = selection.getAnchorOffset();\n  if (offset === 0) {\n    return editorState;\n  }\n\n  var blockKey = selection.getAnchorKey();\n  var content = editorState.getCurrentContent();\n  var block = content.getBlockForKey(blockKey);\n  var length = block.getLength();\n\n  // Nothing to transpose if there aren't two characters.\n  if (length <= 1) {\n    return editorState;\n  }\n\n  var removalRange;\n  var finalSelection;\n\n  if (offset === length) {\n    // The cursor is at the end of the block. Swap the last two characters.\n    removalRange = selection.set('anchorOffset', offset - 1);\n    finalSelection = selection;\n  } else {\n    removalRange = selection.set('focusOffset', offset + 1);\n    finalSelection = removalRange.set('anchorOffset', offset + 1);\n  }\n\n  // Extract the character to move as a fragment. This preserves its\n  // styling and entity, if any.\n  var movedFragment = getContentStateFragment(content, removalRange);\n  var afterRemoval = DraftModifier.removeRange(content, removalRange, 'backward');\n\n  // After the removal, the insertion target is one character back.\n  var selectionAfter = afterRemoval.getSelectionAfter();\n  var targetOffset = selectionAfter.getAnchorOffset() - 1;\n  var targetRange = selectionAfter.merge({\n    anchorOffset: targetOffset,\n    focusOffset: targetOffset\n  });\n\n  var afterInsert = DraftModifier.replaceWithFragment(afterRemoval, targetRange, movedFragment);\n\n  var newEditorState = EditorState.push(editorState, afterInsert, 'insert-fragment');\n\n  return EditorState.acceptSelection(newEditorState, finalSelection);\n}\n\nmodule.exports = keyCommandTransposeCharacters;\n\n/***/ }),\n/* 492 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandUndo\n * @format\n * \n */\n\n\n\nvar EditorState = __webpack_require__(59);\n\nfunction keyCommandUndo(e, editorState, updateFn) {\n  var undoneState = EditorState.undo(editorState);\n\n  // If the last change to occur was a spellcheck change, allow the undo\n  // event to fall through to the browser. This allows the browser to record\n  // the unwanted change, which should soon lead it to learn not to suggest\n  // the correction again.\n  if (editorState.getLastChangeType() === 'spellcheck-change') {\n    var nativelyRenderedContent = undoneState.getCurrentContent();\n    updateFn(EditorState.set(undoneState, { nativelyRenderedContent: nativelyRenderedContent }));\n    return;\n  }\n\n  // Otheriwse, manage the undo behavior manually.\n  e.preventDefault();\n  if (!editorState.getNativelyRenderedContent()) {\n    updateFn(undoneState);\n    return;\n  }\n\n  // Trigger a re-render with the current content state to ensure that the\n  // component tree has up-to-date props for comparison.\n  updateFn(EditorState.set(editorState, { nativelyRenderedContent: null }));\n\n  // Wait to ensure that the re-render has occurred before performing\n  // the undo action.\n  setTimeout(function () {\n    updateFn(undoneState);\n  }, 0);\n}\n\nmodule.exports = keyCommandUndo;\n\n/***/ }),\n/* 493 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnPaste\n * @format\n * \n */\n\n\n\nvar BlockMapBuilder = __webpack_require__(91);\nvar CharacterMetadata = __webpack_require__(63);\nvar DataTransfer = __webpack_require__(230);\nvar DraftModifier = __webpack_require__(62);\nvar DraftPasteProcessor = __webpack_require__(494);\nvar EditorState = __webpack_require__(59);\nvar RichTextEditorUtil = __webpack_require__(241);\n\nvar getEntityKeyForSelection = __webpack_require__(162);\nvar getTextContentFromFiles = __webpack_require__(232);\nvar isEventHandled = __webpack_require__(93);\nvar splitTextIntoTextBlocks = __webpack_require__(497);\n\n/**\n * Paste content.\n */\nfunction editOnPaste(editor, e) {\n  e.preventDefault();\n  var data = new DataTransfer(e.clipboardData);\n\n  // Get files, unless this is likely to be a string the user wants inline.\n  if (!data.isRichText()) {\n    var files = data.getFiles();\n    var defaultFileText = data.getText();\n    if (files.length > 0) {\n      // Allow customized paste handling for images, etc. Otherwise, fall\n      // through to insert text contents into the editor.\n      if (editor.props.handlePastedFiles && isEventHandled(editor.props.handlePastedFiles(files))) {\n        return;\n      }\n\n      getTextContentFromFiles(files, function ( /*string*/fileText) {\n        fileText = fileText || defaultFileText;\n        if (!fileText) {\n          return;\n        }\n\n        var editorState = editor._latestEditorState;\n        var blocks = splitTextIntoTextBlocks(fileText);\n        var character = CharacterMetadata.create({\n          style: editorState.getCurrentInlineStyle(),\n          entity: getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection())\n        });\n        var currentBlockType = RichTextEditorUtil.getCurrentBlockType(editorState);\n\n        var text = DraftPasteProcessor.processText(blocks, character, currentBlockType);\n        var fragment = BlockMapBuilder.createFromArray(text);\n\n        var withInsertedText = DraftModifier.replaceWithFragment(editorState.getCurrentContent(), editorState.getSelection(), fragment);\n\n        editor.update(EditorState.push(editorState, withInsertedText, 'insert-fragment'));\n      });\n\n      return;\n    }\n  }\n\n  var textBlocks = [];\n  var text = data.getText();\n  var html = data.getHTML();\n  var editorState = editor._latestEditorState;\n\n  if (editor.props.handlePastedText && isEventHandled(editor.props.handlePastedText(text, html, editorState))) {\n    return;\n  }\n\n  if (text) {\n    textBlocks = splitTextIntoTextBlocks(text);\n  }\n\n  if (!editor.props.stripPastedStyles) {\n    // If the text from the paste event is rich content that matches what we\n    // already have on the internal clipboard, assume that we should just use\n    // the clipboard fragment for the paste. This will allow us to preserve\n    // styling and entities, if any are present. Note that newlines are\n    // stripped during comparison -- this is because copy/paste within the\n    // editor in Firefox and IE will not include empty lines. The resulting\n    // paste will preserve the newlines correctly.\n    var internalClipboard = editor.getClipboard();\n    if (data.isRichText() && internalClipboard) {\n      if (\n      // If the editorKey is present in the pasted HTML, it should be safe to\n      // assume this is an internal paste.\n      html.indexOf(editor.getEditorKey()) !== -1 ||\n      // The copy may have been made within a single block, in which case the\n      // editor key won't be part of the paste. In this case, just check\n      // whether the pasted text matches the internal clipboard.\n      textBlocks.length === 1 && internalClipboard.size === 1 && internalClipboard.first().getText() === text) {\n        editor.update(insertFragment(editor._latestEditorState, internalClipboard));\n        return;\n      }\n    } else if (internalClipboard && data.types.includes('com.apple.webarchive') && !data.types.includes('text/html') && areTextBlocksAndClipboardEqual(textBlocks, internalClipboard)) {\n      // Safari does not properly store text/html in some cases.\n      // Use the internalClipboard if present and equal to what is on\n      // the clipboard. See https://bugs.webkit.org/show_bug.cgi?id=19893.\n      editor.update(insertFragment(editor._latestEditorState, internalClipboard));\n      return;\n    }\n\n    // If there is html paste data, try to parse that.\n    if (html) {\n      var htmlFragment = DraftPasteProcessor.processHTML(html, editor.props.blockRenderMap);\n      if (htmlFragment) {\n        var contentBlocks = htmlFragment.contentBlocks,\n            entityMap = htmlFragment.entityMap;\n\n        if (contentBlocks) {\n          var htmlMap = BlockMapBuilder.createFromArray(contentBlocks);\n          editor.update(insertFragment(editor._latestEditorState, htmlMap, entityMap));\n          return;\n        }\n      }\n    }\n\n    // Otherwise, create a new fragment from our pasted text. Also\n    // empty the internal clipboard, since it's no longer valid.\n    editor.setClipboard(null);\n  }\n\n  if (textBlocks.length) {\n    var character = CharacterMetadata.create({\n      style: editorState.getCurrentInlineStyle(),\n      entity: getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection())\n    });\n\n    var currentBlockType = RichTextEditorUtil.getCurrentBlockType(editorState);\n\n    var textFragment = DraftPasteProcessor.processText(textBlocks, character, currentBlockType);\n\n    var textMap = BlockMapBuilder.createFromArray(textFragment);\n    editor.update(insertFragment(editor._latestEditorState, textMap));\n  }\n}\n\nfunction insertFragment(editorState, fragment, entityMap) {\n  var newContent = DraftModifier.replaceWithFragment(editorState.getCurrentContent(), editorState.getSelection(), fragment);\n  // TODO: merge the entity map once we stop using DraftEntity\n  // like this:\n  // const mergedEntityMap = newContent.getEntityMap().merge(entityMap);\n\n  return EditorState.push(editorState, newContent.set('entityMap', entityMap), 'insert-fragment');\n}\n\nfunction areTextBlocksAndClipboardEqual(textBlocks, blockMap) {\n  return textBlocks.length === blockMap.size && blockMap.valueSeq().every(function (block, ii) {\n    return block.getText() === textBlocks[ii];\n  });\n}\n\nmodule.exports = editOnPaste;\n\n/***/ }),\n/* 494 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftPasteProcessor\n * @format\n * \n */\n\n\n\nvar _assign = __webpack_require__(3);\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar CharacterMetadata = __webpack_require__(63);\nvar ContentBlock = __webpack_require__(76);\nvar ContentBlockNode = __webpack_require__(64);\nvar DraftFeatureFlags = __webpack_require__(71);\nvar Immutable = __webpack_require__(57);\n\nvar convertFromHTMLtoContentBlocks = __webpack_require__(239);\nvar generateRandomKey = __webpack_require__(70);\nvar getSafeBodyFromHTML = __webpack_require__(240);\nvar sanitizeDraftText = __webpack_require__(158);\n\nvar List = Immutable.List,\n    Repeat = Immutable.Repeat;\n\n\nvar experimentalTreeDataSupport = DraftFeatureFlags.draft_tree_data_support;\nvar ContentBlockRecord = experimentalTreeDataSupport ? ContentBlockNode : ContentBlock;\n\nvar DraftPasteProcessor = {\n  processHTML: function processHTML(html, blockRenderMap) {\n    return convertFromHTMLtoContentBlocks(html, getSafeBodyFromHTML, blockRenderMap);\n  },\n  processText: function processText(textBlocks, character, type) {\n    return textBlocks.reduce(function (acc, textLine, index) {\n      textLine = sanitizeDraftText(textLine);\n      var key = generateRandomKey();\n\n      var blockNodeConfig = {\n        key: key,\n        type: type,\n        text: textLine,\n        characterList: List(Repeat(character, textLine.length))\n      };\n\n      // next block updates previous block\n      if (experimentalTreeDataSupport && index !== 0) {\n        var prevSiblingIndex = index - 1;\n        // update previous block\n        var previousBlock = acc[prevSiblingIndex] = acc[prevSiblingIndex].merge({\n          nextSibling: key\n        });\n        blockNodeConfig = _extends({}, blockNodeConfig, {\n          prevSibling: previousBlock.getKey()\n        });\n      }\n\n      acc.push(new ContentBlockRecord(blockNodeConfig));\n\n      return acc;\n    }, []);\n  }\n};\n\nmodule.exports = DraftPasteProcessor;\n\n/***/ }),\n/* 495 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar URI = function () {\n  function URI(uri) {\n    _classCallCheck(this, URI);\n\n    this._uri = uri;\n  }\n\n  URI.prototype.toString = function toString() {\n    return this._uri;\n  };\n\n  return URI;\n}();\n\nmodule.exports = URI;\n\n/***/ }),\n/* 496 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule adjustBlockDepthForContentState\n * @format\n * \n */\n\n\n\nfunction adjustBlockDepthForContentState(contentState, selectionState, adjustment, maxDepth) {\n  var startKey = selectionState.getStartKey();\n  var endKey = selectionState.getEndKey();\n  var blockMap = contentState.getBlockMap();\n  var blocks = blockMap.toSeq().skipUntil(function (_, k) {\n    return k === startKey;\n  }).takeUntil(function (_, k) {\n    return k === endKey;\n  }).concat([[endKey, blockMap.get(endKey)]]).map(function (block) {\n    var depth = block.getDepth() + adjustment;\n    depth = Math.max(0, Math.min(depth, maxDepth));\n    return block.set('depth', depth);\n  });\n\n  blockMap = blockMap.merge(blocks);\n\n  return contentState.merge({\n    blockMap: blockMap,\n    selectionBefore: selectionState,\n    selectionAfter: selectionState\n  });\n}\n\nmodule.exports = adjustBlockDepthForContentState;\n\n/***/ }),\n/* 497 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule splitTextIntoTextBlocks\n * @format\n * \n */\n\n\n\nvar NEWLINE_REGEX = /\\r\\n?|\\n/g;\n\nfunction splitTextIntoTextBlocks(text) {\n  return text.split(NEWLINE_REGEX);\n}\n\nmodule.exports = splitTextIntoTextBlocks;\n\n/***/ }),\n/* 498 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnSelect\n * @format\n * \n */\n\n\n\nvar EditorState = __webpack_require__(59);\nvar ReactDOM = __webpack_require__(1);\n\nvar getDraftEditorSelection = __webpack_require__(499);\nvar invariant = __webpack_require__(58);\n\nfunction editOnSelect(editor) {\n  if (editor._blockSelectEvents || editor._latestEditorState !== editor.props.editorState) {\n    return;\n  }\n\n  var editorState = editor.props.editorState;\n  var editorNode = ReactDOM.findDOMNode(editor.editorContainer);\n  !editorNode ?  false ? invariant(false, 'Missing editorNode') : invariant(false) : void 0;\n  !(editorNode.firstChild instanceof HTMLElement) ?  false ? invariant(false, 'editorNode.firstChild is not an HTMLElement') : invariant(false) : void 0;\n  var documentSelection = getDraftEditorSelection(editorState, editorNode.firstChild);\n  var updatedSelectionState = documentSelection.selectionState;\n\n  if (updatedSelectionState !== editorState.getSelection()) {\n    if (documentSelection.needsRecovery) {\n      editorState = EditorState.forceSelection(editorState, updatedSelectionState);\n    } else {\n      editorState = EditorState.acceptSelection(editorState, updatedSelectionState);\n    }\n    editor.update(editorState);\n  }\n}\n\nmodule.exports = editOnSelect;\n\n/***/ }),\n/* 499 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getDraftEditorSelection\n * @format\n * \n */\n\n\n\nvar getDraftEditorSelectionWithNodes = __webpack_require__(236);\n\n/**\n * Convert the current selection range to an anchor/focus pair of offset keys\n * and values that can be interpreted by components.\n */\nfunction getDraftEditorSelection(editorState, root) {\n  var selection = global.getSelection();\n\n  // No active selection.\n  if (selection.rangeCount === 0) {\n    return {\n      selectionState: editorState.getSelection().set('hasFocus', false),\n      needsRecovery: false\n    };\n  }\n\n  return getDraftEditorSelectionWithNodes(editorState, root, selection.anchorNode, selection.anchorOffset, selection.focusNode, selection.focusOffset);\n}\n\nmodule.exports = getDraftEditorSelection;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2)))\n\n/***/ }),\n/* 500 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorPlaceholder.react\n * @format\n * \n */\n\n\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar React = __webpack_require__(0);\n\nvar cx = __webpack_require__(84);\n\n/**\n * This component is responsible for rendering placeholder text for the\n * `DraftEditor` component.\n *\n * Override placeholder style via CSS.\n */\nvar DraftEditorPlaceholder = function (_React$Component) {\n  _inherits(DraftEditorPlaceholder, _React$Component);\n\n  function DraftEditorPlaceholder() {\n    _classCallCheck(this, DraftEditorPlaceholder);\n\n    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));\n  }\n\n  DraftEditorPlaceholder.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n    return this.props.text !== nextProps.text || this.props.editorState.getSelection().getHasFocus() !== nextProps.editorState.getSelection().getHasFocus();\n  };\n\n  DraftEditorPlaceholder.prototype.render = function render() {\n    var hasFocus = this.props.editorState.getSelection().getHasFocus();\n\n    var className = cx({\n      'public/DraftEditorPlaceholder/root': true,\n      'public/DraftEditorPlaceholder/hasFocus': hasFocus\n    });\n\n    var contentStyle = {\n      whiteSpace: 'pre-wrap'\n    };\n\n    return React.createElement(\n      'div',\n      { className: className },\n      React.createElement(\n        'div',\n        {\n          className: cx('public/DraftEditorPlaceholder/inner'),\n          id: this.props.accessibilityID,\n          style: contentStyle },\n        this.props.text\n      )\n    );\n  };\n\n  return DraftEditorPlaceholder;\n}(React.Component);\n\nmodule.exports = DraftEditorPlaceholder;\n\n/***/ }),\n/* 501 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule convertFromDraftStateToRaw\n * @format\n * \n */\n\n\n\nvar _assign = __webpack_require__(3);\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar ContentBlock = __webpack_require__(76);\nvar ContentBlockNode = __webpack_require__(64);\nvar DraftStringKey = __webpack_require__(243);\n\nvar encodeEntityRanges = __webpack_require__(502);\nvar encodeInlineStyleRanges = __webpack_require__(503);\nvar invariant = __webpack_require__(58);\n\nvar createRawBlock = function createRawBlock(block, entityStorageMap) {\n  return {\n    key: block.getKey(),\n    text: block.getText(),\n    type: block.getType(),\n    depth: block.getDepth(),\n    inlineStyleRanges: encodeInlineStyleRanges(block),\n    entityRanges: encodeEntityRanges(block, entityStorageMap),\n    data: block.getData().toObject()\n  };\n};\n\nvar insertRawBlock = function insertRawBlock(block, entityMap, rawBlocks, blockCacheRef) {\n  if (block instanceof ContentBlock) {\n    rawBlocks.push(createRawBlock(block, entityMap));\n    return;\n  }\n\n  !(block instanceof ContentBlockNode) ?  false ? invariant(false, 'block is not a BlockNode') : invariant(false) : void 0;\n\n  var parentKey = block.getParentKey();\n  var rawBlock = blockCacheRef[block.getKey()] = _extends({}, createRawBlock(block, entityMap), {\n    children: []\n  });\n\n  if (parentKey) {\n    blockCacheRef[parentKey].children.push(rawBlock);\n    return;\n  }\n\n  rawBlocks.push(rawBlock);\n};\n\nvar encodeRawBlocks = function encodeRawBlocks(contentState, rawState) {\n  var entityMap = rawState.entityMap;\n\n\n  var rawBlocks = [];\n\n  var blockCacheRef = {};\n  var entityCacheRef = {};\n  var entityStorageKey = 0;\n\n  contentState.getBlockMap().forEach(function (block) {\n    block.findEntityRanges(function (character) {\n      return character.getEntity() !== null;\n    }, function (start) {\n      var entityKey = block.getEntityAt(start);\n      // Stringify to maintain order of otherwise numeric keys.\n      var stringifiedEntityKey = DraftStringKey.stringify(entityKey);\n      // This makes this function resilient to two entities\n      // erroneously having the same key\n      if (entityCacheRef[stringifiedEntityKey]) {\n        return;\n      }\n      entityCacheRef[stringifiedEntityKey] = entityKey;\n      // we need the `any` casting here since this is a temporary state\n      // where we will later on flip the entity map and populate it with\n      // real entity, at this stage we just need to map back the entity\n      // key used by the BlockNode\n      entityMap[stringifiedEntityKey] = '' + entityStorageKey;\n      entityStorageKey++;\n    });\n\n    insertRawBlock(block, entityMap, rawBlocks, blockCacheRef);\n  });\n\n  return {\n    blocks: rawBlocks,\n    entityMap: entityMap\n  };\n};\n\n// Flip storage map so that our storage keys map to global\n// DraftEntity keys.\nvar encodeRawEntityMap = function encodeRawEntityMap(contentState, rawState) {\n  var blocks = rawState.blocks,\n      entityMap = rawState.entityMap;\n\n\n  var rawEntityMap = {};\n\n  Object.keys(entityMap).forEach(function (key, index) {\n    var entity = contentState.getEntity(DraftStringKey.unstringify(key));\n    rawEntityMap[index] = {\n      type: entity.getType(),\n      mutability: entity.getMutability(),\n      data: entity.getData()\n    };\n  });\n\n  return {\n    blocks: blocks,\n    entityMap: rawEntityMap\n  };\n};\n\nvar convertFromDraftStateToRaw = function convertFromDraftStateToRaw(contentState) {\n  var rawDraftContentState = {\n    entityMap: {},\n    blocks: []\n  };\n\n  // add blocks\n  rawDraftContentState = encodeRawBlocks(contentState, rawDraftContentState);\n\n  // add entities\n  rawDraftContentState = encodeRawEntityMap(contentState, rawDraftContentState);\n\n  return rawDraftContentState;\n};\n\nmodule.exports = convertFromDraftStateToRaw;\n\n/***/ }),\n/* 502 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule encodeEntityRanges\n * @format\n * \n */\n\n\n\nvar DraftStringKey = __webpack_require__(243);\nvar UnicodeUtils = __webpack_require__(77);\n\nvar strlen = UnicodeUtils.strlen;\n\n/**\n * Convert to UTF-8 character counts for storage.\n */\n\nfunction encodeEntityRanges(block, storageMap) {\n  var encoded = [];\n  block.findEntityRanges(function (character) {\n    return !!character.getEntity();\n  }, function ( /*number*/start, /*number*/end) {\n    var text = block.getText();\n    var key = block.getEntityAt(start);\n    encoded.push({\n      offset: strlen(text.slice(0, start)),\n      length: strlen(text.slice(start, end)),\n      // Encode the key as a number for range storage.\n      key: Number(storageMap[DraftStringKey.stringify(key)])\n    });\n  });\n  return encoded;\n}\n\nmodule.exports = encodeEntityRanges;\n\n/***/ }),\n/* 503 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule encodeInlineStyleRanges\n * @format\n * \n */\n\n\n\nvar UnicodeUtils = __webpack_require__(77);\n\nvar findRangesImmutable = __webpack_require__(92);\n\nvar areEqual = function areEqual(a, b) {\n  return a === b;\n};\nvar isTruthy = function isTruthy(a) {\n  return !!a;\n};\nvar EMPTY_ARRAY = [];\n\n/**\n * Helper function for getting encoded styles for each inline style. Convert\n * to UTF-8 character counts for storage.\n */\nfunction getEncodedInlinesForType(block, styleList, styleToEncode) {\n  var ranges = [];\n\n  // Obtain an array with ranges for only the specified style.\n  var filteredInlines = styleList.map(function (style) {\n    return style.has(styleToEncode);\n  }).toList();\n\n  findRangesImmutable(filteredInlines, areEqual,\n  // We only want to keep ranges with nonzero style values.\n  isTruthy, function (start, end) {\n    var text = block.getText();\n    ranges.push({\n      offset: UnicodeUtils.strlen(text.slice(0, start)),\n      length: UnicodeUtils.strlen(text.slice(start, end)),\n      style: styleToEncode\n    });\n  });\n\n  return ranges;\n}\n\n/*\n * Retrieve the encoded arrays of inline styles, with each individual style\n * treated separately.\n */\nfunction encodeInlineStyleRanges(block) {\n  var styleList = block.getCharacterList().map(function (c) {\n    return c.getStyle();\n  }).toList();\n  var ranges = styleList.flatten().toSet().map(function (style) {\n    return getEncodedInlinesForType(block, styleList, style);\n  });\n\n  return Array.prototype.concat.apply(EMPTY_ARRAY, ranges.toJS());\n}\n\nmodule.exports = encodeInlineStyleRanges;\n\n/***/ }),\n/* 504 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule convertFromRawToDraftState\n * @format\n * \n */\n\n\n\nvar _assign = __webpack_require__(3);\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar ContentBlock = __webpack_require__(76);\nvar ContentBlockNode = __webpack_require__(64);\nvar ContentState = __webpack_require__(157);\nvar DraftEntity = __webpack_require__(115);\nvar DraftFeatureFlags = __webpack_require__(71);\nvar DraftTreeAdapter = __webpack_require__(505);\nvar Immutable = __webpack_require__(57);\nvar SelectionState = __webpack_require__(83);\n\nvar createCharacterList = __webpack_require__(506);\nvar decodeEntityRanges = __webpack_require__(507);\nvar decodeInlineStyleRanges = __webpack_require__(508);\nvar generateRandomKey = __webpack_require__(70);\nvar invariant = __webpack_require__(58);\n\nvar experimentalTreeDataSupport = DraftFeatureFlags.draft_tree_data_support;\n\nvar List = Immutable.List,\n    Map = Immutable.Map,\n    OrderedMap = Immutable.OrderedMap;\n\n\nvar decodeBlockNodeConfig = function decodeBlockNodeConfig(block, entityMap) {\n  var key = block.key,\n      type = block.type,\n      data = block.data,\n      text = block.text,\n      depth = block.depth;\n\n\n  var blockNodeConfig = {\n    text: text,\n    depth: depth || 0,\n    type: type || 'unstyled',\n    key: key || generateRandomKey(),\n    data: Map(data),\n    characterList: decodeCharacterList(block, entityMap)\n  };\n\n  return blockNodeConfig;\n};\n\nvar decodeCharacterList = function decodeCharacterList(block, entityMap) {\n  var text = block.text,\n      rawEntityRanges = block.entityRanges,\n      rawInlineStyleRanges = block.inlineStyleRanges;\n\n\n  var entityRanges = rawEntityRanges || [];\n  var inlineStyleRanges = rawInlineStyleRanges || [];\n\n  // Translate entity range keys to the DraftEntity map.\n  return createCharacterList(decodeInlineStyleRanges(text, inlineStyleRanges), decodeEntityRanges(text, entityRanges.filter(function (range) {\n    return entityMap.hasOwnProperty(range.key);\n  }).map(function (range) {\n    return _extends({}, range, { key: entityMap[range.key] });\n  })));\n};\n\nvar addKeyIfMissing = function addKeyIfMissing(block) {\n  return _extends({}, block, {\n    key: block.key || generateRandomKey()\n  });\n};\n\n/**\n * Node stack is responsible to ensure we traverse the tree only once\n * in depth order, while also providing parent refs to inner nodes to\n * construct their links.\n */\nvar updateNodeStack = function updateNodeStack(stack, nodes, parentRef) {\n  var nodesWithParentRef = nodes.map(function (block) {\n    return _extends({}, block, {\n      parentRef: parentRef\n    });\n  });\n\n  // since we pop nodes from the stack we need to insert them in reverse\n  return stack.concat(nodesWithParentRef.reverse());\n};\n\n/**\n * This will build a tree draft content state by creating the node\n * reference links into a single tree walk. Each node has a link\n * reference to \"parent\", \"children\", \"nextSibling\" and \"prevSibling\"\n * blockMap will be created using depth ordering.\n */\nvar decodeContentBlockNodes = function decodeContentBlockNodes(blocks, entityMap) {\n  return blocks\n  // ensure children have valid keys to enable sibling links\n  .map(addKeyIfMissing).reduce(function (blockMap, block, index) {\n    !Array.isArray(block.children) ?  false ? invariant(false, 'invalid RawDraftContentBlock can not be converted to ContentBlockNode') : invariant(false) : void 0;\n\n    // ensure children have valid keys to enable sibling links\n    var children = block.children.map(addKeyIfMissing);\n\n    // root level nodes\n    var contentBlockNode = new ContentBlockNode(_extends({}, decodeBlockNodeConfig(block, entityMap), {\n      prevSibling: index === 0 ? null : blocks[index - 1].key,\n      nextSibling: index === blocks.length - 1 ? null : blocks[index + 1].key,\n      children: List(children.map(function (child) {\n        return child.key;\n      }))\n    }));\n\n    // push root node to blockMap\n    blockMap = blockMap.set(contentBlockNode.getKey(), contentBlockNode);\n\n    // this stack is used to ensure we visit all nodes respecting depth ordering\n    var stack = updateNodeStack([], children, contentBlockNode);\n\n    // start computing children nodes\n    while (stack.length > 0) {\n      // we pop from the stack and start processing this node\n      var node = stack.pop();\n\n      // parentRef already points to a converted ContentBlockNode\n      var parentRef = node.parentRef;\n      var siblings = parentRef.getChildKeys();\n      var _index = siblings.indexOf(node.key);\n      var isValidBlock = Array.isArray(node.children);\n\n      if (!isValidBlock) {\n        !isValidBlock ?  false ? invariant(false, 'invalid RawDraftContentBlock can not be converted to ContentBlockNode') : invariant(false) : void 0;\n        break;\n      }\n\n      // ensure children have valid keys to enable sibling links\n      var _children = node.children.map(addKeyIfMissing);\n\n      var _contentBlockNode = new ContentBlockNode(_extends({}, decodeBlockNodeConfig(node, entityMap), {\n        parent: parentRef.getKey(),\n        children: List(_children.map(function (child) {\n          return child.key;\n        })),\n        prevSibling: _index === 0 ? null : siblings.get(_index - 1),\n        nextSibling: _index === siblings.size - 1 ? null : siblings.get(_index + 1)\n      }));\n\n      // push node to blockMap\n      blockMap = blockMap.set(_contentBlockNode.getKey(), _contentBlockNode);\n\n      // this stack is used to ensure we visit all nodes respecting depth ordering\n      stack = updateNodeStack(stack, _children, _contentBlockNode);\n    }\n\n    return blockMap;\n  }, OrderedMap());\n};\n\nvar decodeContentBlocks = function decodeContentBlocks(blocks, entityMap) {\n  return OrderedMap(blocks.map(function (block) {\n    var contentBlock = new ContentBlock(decodeBlockNodeConfig(block, entityMap));\n    return [contentBlock.getKey(), contentBlock];\n  }));\n};\n\nvar decodeRawBlocks = function decodeRawBlocks(rawState, entityMap) {\n  var isTreeRawBlock = Array.isArray(rawState.blocks[0].children);\n  var rawBlocks = experimentalTreeDataSupport && !isTreeRawBlock ? DraftTreeAdapter.fromRawStateToRawTreeState(rawState).blocks : rawState.blocks;\n\n  if (!experimentalTreeDataSupport) {\n    return decodeContentBlocks(isTreeRawBlock ? DraftTreeAdapter.fromRawTreeStateToRawState(rawState).blocks : rawBlocks, entityMap);\n  }\n\n  return decodeContentBlockNodes(rawBlocks, entityMap);\n};\n\nvar decodeRawEntityMap = function decodeRawEntityMap(rawState) {\n  var rawEntityMap = rawState.entityMap;\n\n  var entityMap = {};\n\n  // TODO: Update this once we completely remove DraftEntity\n  Object.keys(rawEntityMap).forEach(function (rawEntityKey) {\n    var _rawEntityMap$rawEnti = rawEntityMap[rawEntityKey],\n        type = _rawEntityMap$rawEnti.type,\n        mutability = _rawEntityMap$rawEnti.mutability,\n        data = _rawEntityMap$rawEnti.data;\n\n    // get the key reference to created entity\n\n    entityMap[rawEntityKey] = DraftEntity.__create(type, mutability, data || {});\n  });\n\n  return entityMap;\n};\n\nvar convertFromRawToDraftState = function convertFromRawToDraftState(rawState) {\n  !Array.isArray(rawState.blocks) ?  false ? invariant(false, 'invalid RawDraftContentState') : invariant(false) : void 0;\n\n  // decode entities\n  var entityMap = decodeRawEntityMap(rawState);\n\n  // decode blockMap\n  var blockMap = decodeRawBlocks(rawState, entityMap);\n\n  // create initial selection\n  var selectionState = blockMap.isEmpty() ? new SelectionState() : SelectionState.createEmpty(blockMap.first().getKey());\n\n  return new ContentState({\n    blockMap: blockMap,\n    entityMap: entityMap,\n    selectionBefore: selectionState,\n    selectionAfter: selectionState\n  });\n};\n\nmodule.exports = convertFromRawToDraftState;\n\n/***/ }),\n/* 505 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _assign = __webpack_require__(3);\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftTreeAdapter\n * @format\n * \n *\n * This is unstable and not part of the public API and should not be used by\n * production systems. This file may be update/removed without notice.\n */\n\nvar invariant = __webpack_require__(58);\n\nvar traverseInDepthOrder = function traverseInDepthOrder(blocks, fn) {\n  var stack = [].concat(blocks).reverse();\n  while (stack.length) {\n    var _block = stack.pop();\n\n    fn(_block);\n\n    var children = _block.children;\n\n    !Array.isArray(children) ?  false ? invariant(false, 'Invalid tree raw block') : invariant(false) : void 0;\n\n    stack = stack.concat([].concat(children.reverse()));\n  }\n};\n\nvar isListBlock = function isListBlock(block) {\n  if (!(block && block.type)) {\n    return false;\n  }\n  var type = block.type;\n\n  return type === 'unordered-list-item' || type === 'ordered-list-item';\n};\n\nvar addDepthToChildren = function addDepthToChildren(block) {\n  if (Array.isArray(block.children)) {\n    block.children = block.children.map(function (child) {\n      return child.type === block.type ? _extends({}, child, { depth: (block.depth || 0) + 1 }) : child;\n    });\n  }\n};\n\n/**\n * This adapter is intended to be be used as an adapter to draft tree data\n *\n * draft state <=====> draft tree state\n */\nvar DraftTreeAdapter = {\n  /**\n   * Converts from a tree raw state back to  draft raw state\n   */\n  fromRawTreeStateToRawState: function fromRawTreeStateToRawState(draftTreeState) {\n    var blocks = draftTreeState.blocks;\n\n    var transformedBlocks = [];\n\n    !Array.isArray(blocks) ?  false ? invariant(false, 'Invalid raw state') : invariant(false) : void 0;\n\n    if (!Array.isArray(blocks) || !blocks.length) {\n      return draftTreeState;\n    }\n\n    traverseInDepthOrder(blocks, function (block) {\n      var newBlock = _extends({}, block);\n\n      if (isListBlock(block)) {\n        newBlock.depth = newBlock.depth || 0;\n        addDepthToChildren(block);\n      }\n\n      delete newBlock.children;\n\n      transformedBlocks.push(newBlock);\n    });\n\n    draftTreeState.blocks = transformedBlocks;\n\n    return _extends({}, draftTreeState, {\n      blocks: transformedBlocks\n    });\n  },\n\n\n  /**\n   * Converts from draft raw state to tree draft state\n   */\n  fromRawStateToRawTreeState: function fromRawStateToRawTreeState(draftState) {\n    var lastListDepthCacheRef = {};\n    var transformedBlocks = [];\n\n    draftState.blocks.forEach(function (block) {\n      var isList = isListBlock(block);\n      var depth = block.depth || 0;\n      var treeBlock = _extends({}, block, {\n        children: []\n      });\n\n      if (!isList) {\n        // reset the cache path\n        lastListDepthCacheRef = {};\n        transformedBlocks.push(treeBlock);\n        return;\n      }\n\n      // update our depth cache reference path\n      lastListDepthCacheRef[depth] = treeBlock;\n\n      // if we are greater than zero we must have seen a parent already\n      if (depth > 0) {\n        var parent = lastListDepthCacheRef[depth - 1];\n\n        !parent ?  false ? invariant(false, 'Invalid depth for RawDraftContentBlock') : invariant(false) : void 0;\n\n        // push nested list blocks\n        parent.children.push(treeBlock);\n        return;\n      }\n\n      // push root list blocks\n      transformedBlocks.push(treeBlock);\n    });\n\n    return _extends({}, draftState, {\n      blocks: transformedBlocks\n    });\n  }\n};\n\nmodule.exports = DraftTreeAdapter;\n\n/***/ }),\n/* 506 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule createCharacterList\n * @format\n * \n */\n\n\n\nvar CharacterMetadata = __webpack_require__(63);\nvar Immutable = __webpack_require__(57);\n\nvar List = Immutable.List;\n\n\nfunction createCharacterList(inlineStyles, entities) {\n  var characterArray = inlineStyles.map(function (style, ii) {\n    var entity = entities[ii];\n    return CharacterMetadata.create({ style: style, entity: entity });\n  });\n  return List(characterArray);\n}\n\nmodule.exports = createCharacterList;\n\n/***/ }),\n/* 507 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule decodeEntityRanges\n * @format\n * \n */\n\n\n\nvar UnicodeUtils = __webpack_require__(77);\n\nvar substr = UnicodeUtils.substr;\n\n/**\n * Convert to native JavaScript string lengths to determine ranges.\n */\n\nfunction decodeEntityRanges(text, ranges) {\n  var entities = Array(text.length).fill(null);\n  if (ranges) {\n    ranges.forEach(function (range) {\n      // Using Unicode-enabled substrings converted to JavaScript lengths,\n      // fill the output array with entity keys.\n      var start = substr(text, 0, range.offset).length;\n      var end = start + substr(text, range.offset, range.length).length;\n      for (var ii = start; ii < end; ii++) {\n        entities[ii] = range.key;\n      }\n    });\n  }\n  return entities;\n}\n\nmodule.exports = decodeEntityRanges;\n\n/***/ }),\n/* 508 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule decodeInlineStyleRanges\n * @format\n * \n */\n\n\n\nvar _require = __webpack_require__(57),\n    OrderedSet = _require.OrderedSet;\n\nvar UnicodeUtils = __webpack_require__(77);\n\nvar substr = UnicodeUtils.substr;\n\n\nvar EMPTY_SET = OrderedSet();\n\n/**\n * Convert to native JavaScript string lengths to determine ranges.\n */\nfunction decodeInlineStyleRanges(text, ranges) {\n  var styles = Array(text.length).fill(EMPTY_SET);\n  if (ranges) {\n    ranges.forEach(function ( /*object*/range) {\n      var cursor = substr(text, 0, range.offset).length;\n      var end = cursor + substr(text, range.offset, range.length).length;\n      while (cursor < end) {\n        styles[cursor] = styles[cursor].add(range.style);\n        cursor++;\n      }\n    });\n  }\n  return styles;\n}\n\nmodule.exports = decodeInlineStyleRanges;\n\n/***/ }),\n/* 509 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getVisibleSelectionRect\n * @format\n * \n */\n\n\n\nvar getRangeBoundingClientRect = __webpack_require__(510);\n\n/**\n * Return the bounding ClientRect for the visible DOM selection, if any.\n * In cases where there are no selected ranges or the bounding rect is\n * temporarily invalid, return null.\n */\nfunction getVisibleSelectionRect(global) {\n  var selection = global.getSelection();\n  if (!selection.rangeCount) {\n    return null;\n  }\n\n  var range = selection.getRangeAt(0);\n  var boundingRect = getRangeBoundingClientRect(range);\n  var top = boundingRect.top,\n      right = boundingRect.right,\n      bottom = boundingRect.bottom,\n      left = boundingRect.left;\n\n  // When a re-render leads to a node being removed, the DOM selection will\n  // temporarily be placed on an ancestor node, which leads to an invalid\n  // bounding rect. Discard this state.\n\n  if (top === 0 && right === 0 && bottom === 0 && left === 0) {\n    return null;\n  }\n\n  return boundingRect;\n}\n\nmodule.exports = getVisibleSelectionRect;\n\n/***/ }),\n/* 510 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getRangeBoundingClientRect\n * @format\n * \n */\n\n\n\nvar getRangeClientRects = __webpack_require__(235);\n\n/**\n * Like range.getBoundingClientRect() but normalizes for browser bugs.\n */\nfunction getRangeBoundingClientRect(range) {\n  // \"Return a DOMRect object describing the smallest rectangle that includes\n  // the first rectangle in list and all of the remaining rectangles of which\n  // the height or width is not zero.\"\n  // http://www.w3.org/TR/cssom-view/#dom-range-getboundingclientrect\n  var rects = getRangeClientRects(range);\n  var top = 0;\n  var right = 0;\n  var bottom = 0;\n  var left = 0;\n\n  if (rects.length) {\n    // If the first rectangle has 0 width, we use the second, this is needed\n    // because Chrome renders a 0 width rectangle when the selection contains\n    // a line break.\n    if (rects.length > 1 && rects[0].width === 0) {\n      var _rects$ = rects[1];\n      top = _rects$.top;\n      right = _rects$.right;\n      bottom = _rects$.bottom;\n      left = _rects$.left;\n    } else {\n      var _rects$2 = rects[0];\n      top = _rects$2.top;\n      right = _rects$2.right;\n      bottom = _rects$2.bottom;\n      left = _rects$2.left;\n    }\n\n    for (var ii = 1; ii < rects.length; ii++) {\n      var rect = rects[ii];\n      if (rect.height !== 0 && rect.width !== 0) {\n        top = Math.min(top, rect.top);\n        right = Math.max(right, rect.right);\n        bottom = Math.max(bottom, rect.bottom);\n        left = Math.min(left, rect.left);\n      }\n    }\n  }\n\n  return {\n    top: top,\n    right: right,\n    bottom: bottom,\n    left: left,\n    width: right - left,\n    height: bottom - top\n  };\n}\n\nmodule.exports = getRangeBoundingClientRect;\n\n/***/ }),\n/* 511 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_immutable__ = __webpack_require__(244);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_immutable___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_immutable__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_format_number__ = __webpack_require__(154);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_format_number___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_format_number__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_classnames__ = __webpack_require__(60);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_classnames__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_draft_js__ = __webpack_require__(217);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_draft_js___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_draft_js__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__Spinner__ = __webpack_require__(119);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__myEditor_style_css__ = __webpack_require__(512);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__myEditor_style_css___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6__myEditor_style_css__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__modules_ProposalEditor_proposalEditor_style_css__ = __webpack_require__(103);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__modules_ProposalEditor_proposalEditor_style_css___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7__modules_ProposalEditor_proposalEditor_style_css__);\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/* eslint-disable react/no-did-mount-set-state */\n\n// eslint-disable-line no-unused-vars\n\n\n\n\n\n\n\n\nvar MyEditor = function (_Component) {\n  _inherits(MyEditor, _Component);\n\n  function MyEditor() {\n    var _ref;\n\n    var _temp, _this, _ret;\n\n    _classCallCheck(this, MyEditor);\n\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = MyEditor.__proto__ || Object.getPrototypeOf(MyEditor)).call.apply(_ref, [this].concat(args))), _this), _this.state = {\n      editorState: _this.props.editorState,\n      readOnly: _this.props.readOnly,\n      inFocus: false,\n      focus: false,\n      render: false,\n      charsLeft: _this.getChars(_this.props.editorState).charsLeft,\n      errorMessages: {}\n    }, _this.setEditorRef = function (node) {\n      return _this.DomEditor = node;\n    }, _this.getBlockRenderMap = function () {\n      return _this.props.blockRenderMap || Object(__WEBPACK_IMPORTED_MODULE_1_immutable__[\"Map\"])({\n        unstyled: {\n          element: 'div'\n        }\n      });\n    }, _this.handleClick = function (e) {\n      if (e.target === _this.DomEditor.editorContainer || e.target === _this.DomEditor) {\n        _this.DomEditor.focus();\n        _this.setState(function () {\n          return { inFocus: true };\n        });\n      }\n    }, _this.handleChange = function (editorState) {\n      var _this$props = _this.props,\n          maxLength = _this$props.maxLength,\n          id = _this$props.id;\n      var errorMessages = _this.state.errorMessages;\n\n      var totalChars = _this.getChars(editorState).totalChars;\n      var charsLeft = _this.getChars(editorState).charsLeft;\n\n      var showError = totalChars > maxLength;\n\n      _this.setState(function () {\n        return {\n          editorState: editorState,\n          totalChars: totalChars,\n          charsLeft: charsLeft,\n          errorMessages: Object.assign({}, errorMessages, _defineProperty({}, id, Object.assign({}, errorMessages[id], {\n            showError: showError\n          })))\n        };\n      });\n\n      if (_this.props.handleChange) {\n        _this.props.handleChange(editorState, _this.props.id);\n      }\n    }, _this.handleBlur = function () {\n      var id = _this.props.id;\n\n      var value = _this.state.editorState.getCurrentContent().getPlainText();\n\n      _this.setState(function () {\n        return { inFocus: false };\n      });\n\n      // An option to make a call to the server api for validations\n      if (_this.props.onBlur) _this.props.onBlur(id, value);\n    }, _this.handleFocus = function () {\n      var readOnly = _this.props.readOnly;\n\n\n      if (!readOnly) {\n        _this.DomEditor.focus();\n        _this.setState(function () {\n          return { inFocus: true };\n        });\n      }\n    }, _this.handleMouseEnter = function () {\n      return _this.setState(function () {\n        return { isHovering: true };\n      });\n    }, _this.handleMouseLeave = function () {\n      return _this.setState(function () {\n        return { isHovering: false };\n      });\n    }, _temp), _possibleConstructorReturn(_this, _ret);\n  }\n\n  _createClass(MyEditor, [{\n    key: 'componentDidMount',\n    value: function componentDidMount() {\n      var _this2 = this;\n\n      var _props = this.props,\n          minHeight = _props.minHeight,\n          readOnly = _props.readOnly;\n\n\n      this.setState({ render: true }); // eslint-disable-line\n\n      if (!\"production\" === 'test' || !\"production\" === 'server') document.addEventListener('click', this.handleClick);\n\n      if (minHeight && !readOnly) {\n        setTimeout(function () {\n          // make sure DraftJS is finished setting up\n          var editorContainer = _this2.DomEditor.editorContainer;\n\n          if (editorContainer) editorContainer.style.minHeight = minHeight + 'px';\n        }, 0);\n      }\n\n      if (!readOnly) {\n        // this.handleChange(this.state.editorState)\n      }\n    }\n  }, {\n    key: 'componentWillUnmount',\n    value: function componentWillUnmount() {\n      document.removeEventListener('click', this.handleClick);\n    }\n  }, {\n    key: 'getChars',\n    value: function getChars(editorState) {\n      var maxLength = this.props.maxLength;\n\n\n      var blockMap = editorState.getCurrentContent().getBlockMap();\n      var totalChars = blockMap.reduce(function (arr, block) {\n        return block.getLength() + arr;\n      }, 0);\n\n      var charsLeft = __WEBPACK_IMPORTED_MODULE_2_format_number___default()({ integerSeparator: '.' })(maxLength - totalChars);\n\n      return {\n        charsLeft: charsLeft,\n        totalChars: totalChars\n      };\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var _this3 = this;\n\n      var _state = this.state,\n          editorState = _state.editorState,\n          totalChars = _state.totalChars,\n          charsLeft = _state.charsLeft,\n          inFocus = _state.inFocus,\n          isHovering = _state.isHovering,\n          render = _state.render;\n      var _props2 = this.props,\n          id = _props2.id,\n          maxLength = _props2.maxLength,\n          title = _props2.title,\n          description = _props2.description,\n          readOnly = _props2.readOnly,\n          errors = _props2.errors,\n          checkingValue = _props2.checkingValue;\n\n      // make sure DraftJS is finished setting up\n\n      if (!render) return null;\n\n      return (\n        /* eslint-disable jsx-a11y/interactive-supports-focus, jsx-a11y/click-events-have-key-events, jsx-a11y/no-static-element-interactions  */\n        /* Draft.js handles the tab functionality and key events between editors.  */\n        __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n          'div',\n          {\n            className: __WEBPACK_IMPORTED_MODULE_3_classnames___default()(__WEBPACK_IMPORTED_MODULE_6__myEditor_style_css___default.a.myEditor, __WEBPACK_IMPORTED_MODULE_6__myEditor_style_css___default.a[id], inFocus && !readOnly && __WEBPACK_IMPORTED_MODULE_6__myEditor_style_css___default.a.focus, isHovering && !readOnly && !inFocus && __WEBPACK_IMPORTED_MODULE_6__myEditor_style_css___default.a.isHovering, readOnly && __WEBPACK_IMPORTED_MODULE_6__myEditor_style_css___default.a.readOnly),\n            ref: function ref(node) {\n              return _this3.node = node;\n            },\n            onClick: this.handleClick,\n            onMouseEnter: this.handleMouseEnter,\n            onMouseLeave: this.handleMouseLeave\n          },\n          title && __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'h2',\n            {\n              className: __WEBPACK_IMPORTED_MODULE_3_classnames___default()(__WEBPACK_IMPORTED_MODULE_6__myEditor_style_css___default.a.editorTitle, readOnly && __WEBPACK_IMPORTED_MODULE_6__myEditor_style_css___default.a.displayTitle)\n            },\n            title\n          ),\n          description && !readOnly && __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'p',\n            { className: __WEBPACK_IMPORTED_MODULE_6__myEditor_style_css___default.a.description },\n            description\n          ),\n          __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_4_draft_js__[\"Editor\"], {\n            spellCheck: true,\n            editorKey: id,\n            readOnly: readOnly,\n            ref: this.setEditorRef,\n            onFocus: this.handleFocus,\n            stripPastedStyles: true,\n            blockRenderMap: this.getBlockRenderMap(),\n            editorState: this.props.editorState[id] || editorState,\n            onChange: this.handleChange,\n            blockStyleFn: function blockStyleFn(block) {\n              if (block.getType() === 'unstyled') {\n                return !!readOnly ? __WEBPACK_IMPORTED_MODULE_6__myEditor_style_css___default.a.readOnly : __WEBPACK_IMPORTED_MODULE_6__myEditor_style_css___default.a.editorBlock;\n              }\n            },\n            onBlur: this.handleBlur\n          }),\n          checkingValue && __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'div',\n            { style: { position: 'relative', left: '80%', top: '-60px' } },\n            __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_5__Spinner__[\"a\" /* default */], { size: 'small' })\n          ),\n          ' ',\n          errors && errors[id] && __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'span',\n            { className: __WEBPACK_IMPORTED_MODULE_7__modules_ProposalEditor_proposalEditor_style_css___default.a.error },\n            errors[id]\n          ),\n          !readOnly && __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'div',\n            {\n              className: __WEBPACK_IMPORTED_MODULE_3_classnames___default()(__WEBPACK_IMPORTED_MODULE_6__myEditor_style_css___default.a.charsLeft, maxLength < totalChars && __WEBPACK_IMPORTED_MODULE_6__myEditor_style_css___default.a.error)\n            },\n            'Antal tegn tilbage: ',\n            charsLeft\n          )\n        )\n      );\n    }\n  }]);\n\n  return MyEditor;\n}(__WEBPACK_IMPORTED_MODULE_0_react__[\"Component\"]);\n\nMyEditor.displayName = 'MyEditor';\nMyEditor.defaultProps = {\n  maxLength: 4000,\n  editorState: __WEBPACK_IMPORTED_MODULE_4_draft_js__[\"EditorState\"].createEmpty()\n};\n\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (MyEditor);\n\n/***/ }),\n/* 512 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"myEditor\":\"hq8QYy\",\"focus\":\"_1-BR98\",\"isHovering\":\"_3jLTd5\",\"editorTitle\":\"nDpwlZ\",\"charsLeft\":\"qHVecP\",\"error\":\"_7HQkDy\",\"description\":\"_3-Valq\",\"readOnly\":\"rW7MzU\",\"editorBlock\":\"_2ABVhq\",\"proposalContent\":\"F2qutB\"};\n\n/***/ }),\n/* 513 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__authorInfo_style_css__ = __webpack_require__(514);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__authorInfo_style_css___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__authorInfo_style_css__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__Anchor_Anchor__ = __webpack_require__(95);\n\n// eslint-disable-line no-unused-vars\n\n\n\n// Add any default values for props\nvar defaultProps = null;\n\nfunction AuthorInfo(_ref) {\n  var author = _ref.author,\n      coAuthors = _ref.coAuthors;\n\n  if (!author && !coAuthors) return null;\n\n  return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n    'div',\n    { className: __WEBPACK_IMPORTED_MODULE_1__authorInfo_style_css___default.a.authorInfo, 'data-readaloud': true },\n    author && __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n      'div',\n      null,\n      __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n        'div',\n        { className: __WEBPACK_IMPORTED_MODULE_1__authorInfo_style_css___default.a.header },\n        __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n          'div',\n          null,\n          __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'strong',\n            null,\n            'Forslag stillet af:'\n          )\n        ),\n        __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n          'div',\n          null,\n          __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'strong',\n            null,\n            'Kontaktoplysninger:'\n          )\n        )\n      ),\n      __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n        'div',\n        { className: __WEBPACK_IMPORTED_MODULE_1__authorInfo_style_css___default.a.entry },\n        __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n          'div',\n          null,\n          __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'span',\n            null,\n            author.name\n          ),\n          __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'span',\n            null,\n            author.location || ''\n          )\n        ),\n        __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n          'div',\n          null,\n          __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'span',\n            null,\n            'E-mail:',\n            ' ',\n            __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_2__Anchor_Anchor__[\"a\" /* default */], {\n              href: 'mailto:' + author.email,\n              label: '' + author.email\n            })\n          ),\n          author.phoneNumber && __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'span',\n            null,\n            'Tlf.nr.: ',\n            author.phoneNumber\n          )\n        )\n      )\n    ),\n    coAuthors && __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n      'div',\n      null,\n      __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n        'div',\n        { className: __WEBPACK_IMPORTED_MODULE_1__authorInfo_style_css___default.a.header },\n        __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n          'div',\n          null,\n          __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'strong',\n            null,\n            'Medstillere:'\n          )\n        ),\n        __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n          'div',\n          null,\n          __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'strong',\n            null,\n            'Kontaktoplysninger:'\n          )\n        )\n      ),\n      coAuthors.map(function (sp, index) {\n        return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n          'div',\n          { key: index, className: __WEBPACK_IMPORTED_MODULE_1__authorInfo_style_css___default.a.entry },\n          __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'div',\n            null,\n            __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n              'span',\n              null,\n              sp.name\n            ),\n            __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n              'span',\n              null,\n              sp.location || ''\n            )\n          ),\n          sp.email && __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'div',\n            null,\n            __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n              'span',\n              null,\n              'E-mail:',\n              ' ',\n              __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_2__Anchor_Anchor__[\"a\" /* default */], { href: 'mailto:' + sp.email, label: '' + sp.email })\n            ),\n            __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n              'span',\n              null,\n              sp.phoneNumber && 'Tlf.nr.: ' + sp.phoneNumber\n            )\n          )\n        );\n      })\n    )\n  );\n}\n\nAuthorInfo.displayName = 'AuthorInfo';\n\nAuthorInfo.defaultProps = defaultProps;\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (AuthorInfo);\n\n/***/ }),\n/* 514 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"authorInfo\":\"IxfEwW\",\"entry\":\"_3mHEzx\",\"header\":\"N1pAd9\"};\n\n/***/ }),\n/* 515 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_classnames__ = __webpack_require__(60);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_classnames__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_react_motion_lib_Motion__ = __webpack_require__(100);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_react_motion_lib_Motion___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_react_motion_lib_Motion__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_react_motion_lib_spring__ = __webpack_require__(102);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_react_motion_lib_spring___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_react_motion_lib_spring__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__BaseButton_BaseButton__ = __webpack_require__(61);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__ConditionsLabel_ConditionsLabel__ = __webpack_require__(245);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__topBar_style_css__ = __webpack_require__(517);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__topBar_style_css___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6__topBar_style_css__);\n\n// eslint-disable-line no-unused-vars\n\n\n\n\n\n\n\n// Add any default values for props\nvar defaultProps = {\n  show: false,\n  voteButton: {\n    label: 'vote'\n  }\n};\n\nfunction TopBar(_ref) {\n  var conditionsHint = _ref.conditionsHint,\n      title = _ref.title,\n      voteButton = _ref.voteButton,\n      show = _ref.show;\n\n  return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n    __WEBPACK_IMPORTED_MODULE_2_react_motion_lib_Motion___default.a,\n    { defaultStyle: { y: 0 }, style: { y: __WEBPACK_IMPORTED_MODULE_3_react_motion_lib_spring___default()(show ? 1 : 0) } },\n    function (_ref2) {\n      var y = _ref2.y;\n      return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n        'div',\n        {\n          className: __WEBPACK_IMPORTED_MODULE_1_classnames___default()('no-print', __WEBPACK_IMPORTED_MODULE_6__topBar_style_css___default.a.topBar, 'vFact_DoNotReadAloud'),\n          style: { transform: 'translateY(' + (y - 1) * 100 + '%)' }\n        },\n        __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n          'div',\n          { className: __WEBPACK_IMPORTED_MODULE_6__topBar_style_css___default.a.content },\n          __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n            'div',\n            { className: __WEBPACK_IMPORTED_MODULE_6__topBar_style_css___default.a.titleSection },\n            __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n              'span',\n              null,\n              title\n            ),\n            conditionsHint && __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_5__ConditionsLabel_ConditionsLabel__[\"a\" /* default */], conditionsHint)\n          ),\n          __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_4__BaseButton_BaseButton__[\"a\" /* default */], Object.assign({\n            expands: true,\n            primary: true\n          }, voteButton, {\n            style: { minWidth: '180px' }\n          }))\n        )\n      );\n    }\n  );\n}\n\nTopBar.displayName = 'TopBar';\n\nTopBar.defaultProps = defaultProps;\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (TopBar);\n\n/***/ }),\n/* 516 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"label\":\"_1LWDQB\",\"container\":\"_2aiKhB\"};\n\n/***/ }),\n/* 517 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"topBar\":\"_1NXxBn\",\"content\":\"_28H2Ci\",\"titleSection\":\"cc552X\"};\n\n/***/ }),\n/* 518 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_format_number__ = __webpack_require__(154);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_format_number___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_format_number__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__proposalStats_style_css__ = __webpack_require__(519);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__proposalStats_style_css___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2__proposalStats_style_css__);\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__Preview_VotesIndicator_VotesIndicator__ = __webpack_require__(155);\n\n// eslint-disable-line no-unused-vars\n\n\n\n\n// Add any default values for props\nvar defaultProps = {\n  votes: 1000,\n  votesLimit: 50000\n};\n\nfunction ProposalStats(_ref) {\n  var votes = _ref.votes,\n      startDate = _ref.startDate,\n      votesLimit = _ref.votesLimit,\n      endDate = _ref.endDate;\n\n  // const formattedVotes = new Intl.NumberFormat('da-DK').format(votes)\n  var formattedVotes = __WEBPACK_IMPORTED_MODULE_1_format_number___default()({ integerSeparator: '.' })(votes);\n  return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n    'div',\n    { className: __WEBPACK_IMPORTED_MODULE_2__proposalStats_style_css___default.a.proposalStats, 'data-readaloud': true },\n    __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n      'div',\n      null,\n      __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n        'span',\n        { className: __WEBPACK_IMPORTED_MODULE_2__proposalStats_style_css___default.a.label },\n        'Startdato'\n      ),\n      __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n        'strong',\n        null,\n        startDate\n      )\n    ),\n    __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n      'div',\n      null,\n      __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n        'span',\n        { className: __WEBPACK_IMPORTED_MODULE_2__proposalStats_style_css___default.a.label },\n        'Slutdato'\n      ),\n      __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n        'strong',\n        null,\n        endDate\n      )\n    ),\n    __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n      'div',\n      null,\n      __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n        'span',\n        { className: __WEBPACK_IMPORTED_MODULE_2__proposalStats_style_css___default.a.label },\n        'Antal st\\xF8tter'\n      ),\n      __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(\n        'strong',\n        null,\n        formattedVotes\n      ),\n      __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_3__Preview_VotesIndicator_VotesIndicator__[\"a\" /* default */], { votesLimit: votesLimit, votes: votes })\n    )\n  );\n}\n\nProposalStats.displayName = 'ProposalStats';\n\nProposalStats.defaultProps = defaultProps;\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (ProposalStats);\n\n/***/ }),\n/* 519 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"proposalStats\":\"_3l86Vg\"};\n\n/***/ }),\n/* 520 */\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__Form_defaultErrors__ = __webpack_require__(140);\n\n\nvar defaultProps = {\n  defaultErrors: __WEBPACK_IMPORTED_MODULE_0__Form_defaultErrors__[\"a\" /* default */],\n  checkTitleApi: '/api/checkTitle',\n  pageStructure: {},\n  proposalCreationViewModel: {\n    proposal: {\n      proposalContent: '',\n      remarks: '',\n      author: {},\n      supporters: [],\n      externalId: 'FT-007'\n    },\n    errors: {}\n  },\n  voteButton: {\n    label: 'Støt forslaget',\n    href: '/'\n  }\n};\n\n/* harmony default export */ __webpack_exports__[\"a\"] = (defaultProps);\n\n/***/ })\n]));\n\n\n// WEBPACK FOOTER //\n// static/scripts/2-8d5f19f821570cc42ca9.js","export {default} from './ProposalEditor.js'\n\n/**\n * Should the component only render server side?\n * You can set this to true if the component is a pure static component.\n */\nexport const ONLY_SERVER = false\n\n\n// WEBPACK FOOTER //\n// ./src/modules/ProposalEditor/index.js","/**\n *  Copyright (c) 2014-2015, Facebook, Inc.\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  global.Immutable = factory();\n}(this, function () { 'use strict';var SLICE$0 = Array.prototype.slice;\n\n  function createClass(ctor, superClass) {\n    if (superClass) {\n      ctor.prototype = Object.create(superClass.prototype);\n    }\n    ctor.prototype.constructor = ctor;\n  }\n\n  function Iterable(value) {\n      return isIterable(value) ? value : Seq(value);\n    }\n\n\n  createClass(KeyedIterable, Iterable);\n    function KeyedIterable(value) {\n      return isKeyed(value) ? value : KeyedSeq(value);\n    }\n\n\n  createClass(IndexedIterable, Iterable);\n    function IndexedIterable(value) {\n      return isIndexed(value) ? value : IndexedSeq(value);\n    }\n\n\n  createClass(SetIterable, Iterable);\n    function SetIterable(value) {\n      return isIterable(value) && !isAssociative(value) ? value : SetSeq(value);\n    }\n\n\n\n  function isIterable(maybeIterable) {\n    return !!(maybeIterable && maybeIterable[IS_ITERABLE_SENTINEL]);\n  }\n\n  function isKeyed(maybeKeyed) {\n    return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL]);\n  }\n\n  function isIndexed(maybeIndexed) {\n    return !!(maybeIndexed && maybeIndexed[IS_INDEXED_SENTINEL]);\n  }\n\n  function isAssociative(maybeAssociative) {\n    return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);\n  }\n\n  function isOrdered(maybeOrdered) {\n    return !!(maybeOrdered && maybeOrdered[IS_ORDERED_SENTINEL]);\n  }\n\n  Iterable.isIterable = isIterable;\n  Iterable.isKeyed = isKeyed;\n  Iterable.isIndexed = isIndexed;\n  Iterable.isAssociative = isAssociative;\n  Iterable.isOrdered = isOrdered;\n\n  Iterable.Keyed = KeyedIterable;\n  Iterable.Indexed = IndexedIterable;\n  Iterable.Set = SetIterable;\n\n\n  var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';\n  var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';\n  var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';\n  var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';\n\n  // Used for setting prototype methods that IE8 chokes on.\n  var DELETE = 'delete';\n\n  // Constants describing the size of trie nodes.\n  var SHIFT = 5; // Resulted in best performance after ______?\n  var SIZE = 1 << SHIFT;\n  var MASK = SIZE - 1;\n\n  // A consistent shared value representing \"not set\" which equals nothing other\n  // than itself, and nothing that could be provided externally.\n  var NOT_SET = {};\n\n  // Boolean references, Rough equivalent of `bool &`.\n  var CHANGE_LENGTH = { value: false };\n  var DID_ALTER = { value: false };\n\n  function MakeRef(ref) {\n    ref.value = false;\n    return ref;\n  }\n\n  function SetRef(ref) {\n    ref && (ref.value = true);\n  }\n\n  // A function which returns a value representing an \"owner\" for transient writes\n  // to tries. The return value will only ever equal itself, and will not equal\n  // the return of any subsequent call of this function.\n  function OwnerID() {}\n\n  // http://jsperf.com/copy-array-inline\n  function arrCopy(arr, offset) {\n    offset = offset || 0;\n    var len = Math.max(0, arr.length - offset);\n    var newArr = new Array(len);\n    for (var ii = 0; ii < len; ii++) {\n      newArr[ii] = arr[ii + offset];\n    }\n    return newArr;\n  }\n\n  function ensureSize(iter) {\n    if (iter.size === undefined) {\n      iter.size = iter.__iterate(returnTrue);\n    }\n    return iter.size;\n  }\n\n  function wrapIndex(iter, index) {\n    // This implements \"is array index\" which the ECMAString spec defines as:\n    //\n    //     A String property name P is an array index if and only if\n    //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal\n    //     to 2^32−1.\n    //\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects\n    if (typeof index !== 'number') {\n      var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32\n      if ('' + uint32Index !== index || uint32Index === 4294967295) {\n        return NaN;\n      }\n      index = uint32Index;\n    }\n    return index < 0 ? ensureSize(iter) + index : index;\n  }\n\n  function returnTrue() {\n    return true;\n  }\n\n  function wholeSlice(begin, end, size) {\n    return (begin === 0 || (size !== undefined && begin <= -size)) &&\n      (end === undefined || (size !== undefined && end >= size));\n  }\n\n  function resolveBegin(begin, size) {\n    return resolveIndex(begin, size, 0);\n  }\n\n  function resolveEnd(end, size) {\n    return resolveIndex(end, size, size);\n  }\n\n  function resolveIndex(index, size, defaultIndex) {\n    return index === undefined ?\n      defaultIndex :\n      index < 0 ?\n        Math.max(0, size + index) :\n        size === undefined ?\n          index :\n          Math.min(size, index);\n  }\n\n  /* global Symbol */\n\n  var ITERATE_KEYS = 0;\n  var ITERATE_VALUES = 1;\n  var ITERATE_ENTRIES = 2;\n\n  var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n  var FAUX_ITERATOR_SYMBOL = '@@iterator';\n\n  var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;\n\n\n  function Iterator(next) {\n      this.next = next;\n    }\n\n    Iterator.prototype.toString = function() {\n      return '[Iterator]';\n    };\n\n\n  Iterator.KEYS = ITERATE_KEYS;\n  Iterator.VALUES = ITERATE_VALUES;\n  Iterator.ENTRIES = ITERATE_ENTRIES;\n\n  Iterator.prototype.inspect =\n  Iterator.prototype.toSource = function () { return this.toString(); }\n  Iterator.prototype[ITERATOR_SYMBOL] = function () {\n    return this;\n  };\n\n\n  function iteratorValue(type, k, v, iteratorResult) {\n    var value = type === 0 ? k : type === 1 ? v : [k, v];\n    iteratorResult ? (iteratorResult.value = value) : (iteratorResult = {\n      value: value, done: false\n    });\n    return iteratorResult;\n  }\n\n  function iteratorDone() {\n    return { value: undefined, done: true };\n  }\n\n  function hasIterator(maybeIterable) {\n    return !!getIteratorFn(maybeIterable);\n  }\n\n  function isIterator(maybeIterator) {\n    return maybeIterator && typeof maybeIterator.next === 'function';\n  }\n\n  function getIterator(iterable) {\n    var iteratorFn = getIteratorFn(iterable);\n    return iteratorFn && iteratorFn.call(iterable);\n  }\n\n  function getIteratorFn(iterable) {\n    var iteratorFn = iterable && (\n      (REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||\n      iterable[FAUX_ITERATOR_SYMBOL]\n    );\n    if (typeof iteratorFn === 'function') {\n      return iteratorFn;\n    }\n  }\n\n  function isArrayLike(value) {\n    return value && typeof value.length === 'number';\n  }\n\n  createClass(Seq, Iterable);\n    function Seq(value) {\n      return value === null || value === undefined ? emptySequence() :\n        isIterable(value) ? value.toSeq() : seqFromValue(value);\n    }\n\n    Seq.of = function(/*...values*/) {\n      return Seq(arguments);\n    };\n\n    Seq.prototype.toSeq = function() {\n      return this;\n    };\n\n    Seq.prototype.toString = function() {\n      return this.__toString('Seq {', '}');\n    };\n\n    Seq.prototype.cacheResult = function() {\n      if (!this._cache && this.__iterateUncached) {\n        this._cache = this.entrySeq().toArray();\n        this.size = this._cache.length;\n      }\n      return this;\n    };\n\n    // abstract __iterateUncached(fn, reverse)\n\n    Seq.prototype.__iterate = function(fn, reverse) {\n      return seqIterate(this, fn, reverse, true);\n    };\n\n    // abstract __iteratorUncached(type, reverse)\n\n    Seq.prototype.__iterator = function(type, reverse) {\n      return seqIterator(this, type, reverse, true);\n    };\n\n\n\n  createClass(KeyedSeq, Seq);\n    function KeyedSeq(value) {\n      return value === null || value === undefined ?\n        emptySequence().toKeyedSeq() :\n        isIterable(value) ?\n          (isKeyed(value) ? value.toSeq() : value.fromEntrySeq()) :\n          keyedSeqFromValue(value);\n    }\n\n    KeyedSeq.prototype.toKeyedSeq = function() {\n      return this;\n    };\n\n\n\n  createClass(IndexedSeq, Seq);\n    function IndexedSeq(value) {\n      return value === null || value === undefined ? emptySequence() :\n        !isIterable(value) ? indexedSeqFromValue(value) :\n        isKeyed(value) ? value.entrySeq() : value.toIndexedSeq();\n    }\n\n    IndexedSeq.of = function(/*...values*/) {\n      return IndexedSeq(arguments);\n    };\n\n    IndexedSeq.prototype.toIndexedSeq = function() {\n      return this;\n    };\n\n    IndexedSeq.prototype.toString = function() {\n      return this.__toString('Seq [', ']');\n    };\n\n    IndexedSeq.prototype.__iterate = function(fn, reverse) {\n      return seqIterate(this, fn, reverse, false);\n    };\n\n    IndexedSeq.prototype.__iterator = function(type, reverse) {\n      return seqIterator(this, type, reverse, false);\n    };\n\n\n\n  createClass(SetSeq, Seq);\n    function SetSeq(value) {\n      return (\n        value === null || value === undefined ? emptySequence() :\n        !isIterable(value) ? indexedSeqFromValue(value) :\n        isKeyed(value) ? value.entrySeq() : value\n      ).toSetSeq();\n    }\n\n    SetSeq.of = function(/*...values*/) {\n      return SetSeq(arguments);\n    };\n\n    SetSeq.prototype.toSetSeq = function() {\n      return this;\n    };\n\n\n\n  Seq.isSeq = isSeq;\n  Seq.Keyed = KeyedSeq;\n  Seq.Set = SetSeq;\n  Seq.Indexed = IndexedSeq;\n\n  var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';\n\n  Seq.prototype[IS_SEQ_SENTINEL] = true;\n\n\n\n  createClass(ArraySeq, IndexedSeq);\n    function ArraySeq(array) {\n      this._array = array;\n      this.size = array.length;\n    }\n\n    ArraySeq.prototype.get = function(index, notSetValue) {\n      return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue;\n    };\n\n    ArraySeq.prototype.__iterate = function(fn, reverse) {\n      var array = this._array;\n      var maxIndex = array.length - 1;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        if (fn(array[reverse ? maxIndex - ii : ii], ii, this) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    };\n\n    ArraySeq.prototype.__iterator = function(type, reverse) {\n      var array = this._array;\n      var maxIndex = array.length - 1;\n      var ii = 0;\n      return new Iterator(function() \n        {return ii > maxIndex ?\n          iteratorDone() :\n          iteratorValue(type, ii, array[reverse ? maxIndex - ii++ : ii++])}\n      );\n    };\n\n\n\n  createClass(ObjectSeq, KeyedSeq);\n    function ObjectSeq(object) {\n      var keys = Object.keys(object);\n      this._object = object;\n      this._keys = keys;\n      this.size = keys.length;\n    }\n\n    ObjectSeq.prototype.get = function(key, notSetValue) {\n      if (notSetValue !== undefined && !this.has(key)) {\n        return notSetValue;\n      }\n      return this._object[key];\n    };\n\n    ObjectSeq.prototype.has = function(key) {\n      return this._object.hasOwnProperty(key);\n    };\n\n    ObjectSeq.prototype.__iterate = function(fn, reverse) {\n      var object = this._object;\n      var keys = this._keys;\n      var maxIndex = keys.length - 1;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        var key = keys[reverse ? maxIndex - ii : ii];\n        if (fn(object[key], key, this) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    };\n\n    ObjectSeq.prototype.__iterator = function(type, reverse) {\n      var object = this._object;\n      var keys = this._keys;\n      var maxIndex = keys.length - 1;\n      var ii = 0;\n      return new Iterator(function()  {\n        var key = keys[reverse ? maxIndex - ii : ii];\n        return ii++ > maxIndex ?\n          iteratorDone() :\n          iteratorValue(type, key, object[key]);\n      });\n    };\n\n  ObjectSeq.prototype[IS_ORDERED_SENTINEL] = true;\n\n\n  createClass(IterableSeq, IndexedSeq);\n    function IterableSeq(iterable) {\n      this._iterable = iterable;\n      this.size = iterable.length || iterable.size;\n    }\n\n    IterableSeq.prototype.__iterateUncached = function(fn, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterable = this._iterable;\n      var iterator = getIterator(iterable);\n      var iterations = 0;\n      if (isIterator(iterator)) {\n        var step;\n        while (!(step = iterator.next()).done) {\n          if (fn(step.value, iterations++, this) === false) {\n            break;\n          }\n        }\n      }\n      return iterations;\n    };\n\n    IterableSeq.prototype.__iteratorUncached = function(type, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterable = this._iterable;\n      var iterator = getIterator(iterable);\n      if (!isIterator(iterator)) {\n        return new Iterator(iteratorDone);\n      }\n      var iterations = 0;\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step : iteratorValue(type, iterations++, step.value);\n      });\n    };\n\n\n\n  createClass(IteratorSeq, IndexedSeq);\n    function IteratorSeq(iterator) {\n      this._iterator = iterator;\n      this._iteratorCache = [];\n    }\n\n    IteratorSeq.prototype.__iterateUncached = function(fn, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterator = this._iterator;\n      var cache = this._iteratorCache;\n      var iterations = 0;\n      while (iterations < cache.length) {\n        if (fn(cache[iterations], iterations++, this) === false) {\n          return iterations;\n        }\n      }\n      var step;\n      while (!(step = iterator.next()).done) {\n        var val = step.value;\n        cache[iterations] = val;\n        if (fn(val, iterations++, this) === false) {\n          break;\n        }\n      }\n      return iterations;\n    };\n\n    IteratorSeq.prototype.__iteratorUncached = function(type, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = this._iterator;\n      var cache = this._iteratorCache;\n      var iterations = 0;\n      return new Iterator(function()  {\n        if (iterations >= cache.length) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          cache[iterations] = step.value;\n        }\n        return iteratorValue(type, iterations, cache[iterations++]);\n      });\n    };\n\n\n\n\n  // # pragma Helper functions\n\n  function isSeq(maybeSeq) {\n    return !!(maybeSeq && maybeSeq[IS_SEQ_SENTINEL]);\n  }\n\n  var EMPTY_SEQ;\n\n  function emptySequence() {\n    return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));\n  }\n\n  function keyedSeqFromValue(value) {\n    var seq =\n      Array.isArray(value) ? new ArraySeq(value).fromEntrySeq() :\n      isIterator(value) ? new IteratorSeq(value).fromEntrySeq() :\n      hasIterator(value) ? new IterableSeq(value).fromEntrySeq() :\n      typeof value === 'object' ? new ObjectSeq(value) :\n      undefined;\n    if (!seq) {\n      throw new TypeError(\n        'Expected Array or iterable object of [k, v] entries, '+\n        'or keyed object: ' + value\n      );\n    }\n    return seq;\n  }\n\n  function indexedSeqFromValue(value) {\n    var seq = maybeIndexedSeqFromValue(value);\n    if (!seq) {\n      throw new TypeError(\n        'Expected Array or iterable object of values: ' + value\n      );\n    }\n    return seq;\n  }\n\n  function seqFromValue(value) {\n    var seq = maybeIndexedSeqFromValue(value) ||\n      (typeof value === 'object' && new ObjectSeq(value));\n    if (!seq) {\n      throw new TypeError(\n        'Expected Array or iterable object of values, or keyed object: ' + value\n      );\n    }\n    return seq;\n  }\n\n  function maybeIndexedSeqFromValue(value) {\n    return (\n      isArrayLike(value) ? new ArraySeq(value) :\n      isIterator(value) ? new IteratorSeq(value) :\n      hasIterator(value) ? new IterableSeq(value) :\n      undefined\n    );\n  }\n\n  function seqIterate(seq, fn, reverse, useKeys) {\n    var cache = seq._cache;\n    if (cache) {\n      var maxIndex = cache.length - 1;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        var entry = cache[reverse ? maxIndex - ii : ii];\n        if (fn(entry[1], useKeys ? entry[0] : ii, seq) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    }\n    return seq.__iterateUncached(fn, reverse);\n  }\n\n  function seqIterator(seq, type, reverse, useKeys) {\n    var cache = seq._cache;\n    if (cache) {\n      var maxIndex = cache.length - 1;\n      var ii = 0;\n      return new Iterator(function()  {\n        var entry = cache[reverse ? maxIndex - ii : ii];\n        return ii++ > maxIndex ?\n          iteratorDone() :\n          iteratorValue(type, useKeys ? entry[0] : ii - 1, entry[1]);\n      });\n    }\n    return seq.__iteratorUncached(type, reverse);\n  }\n\n  function fromJS(json, converter) {\n    return converter ?\n      fromJSWith(converter, json, '', {'': json}) :\n      fromJSDefault(json);\n  }\n\n  function fromJSWith(converter, json, key, parentJSON) {\n    if (Array.isArray(json)) {\n      return converter.call(parentJSON, key, IndexedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));\n    }\n    if (isPlainObj(json)) {\n      return converter.call(parentJSON, key, KeyedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));\n    }\n    return json;\n  }\n\n  function fromJSDefault(json) {\n    if (Array.isArray(json)) {\n      return IndexedSeq(json).map(fromJSDefault).toList();\n    }\n    if (isPlainObj(json)) {\n      return KeyedSeq(json).map(fromJSDefault).toMap();\n    }\n    return json;\n  }\n\n  function isPlainObj(value) {\n    return value && (value.constructor === Object || value.constructor === undefined);\n  }\n\n  /**\n   * An extension of the \"same-value\" algorithm as [described for use by ES6 Map\n   * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)\n   *\n   * NaN is considered the same as NaN, however -0 and 0 are considered the same\n   * value, which is different from the algorithm described by\n   * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).\n   *\n   * This is extended further to allow Objects to describe the values they\n   * represent, by way of `valueOf` or `equals` (and `hashCode`).\n   *\n   * Note: because of this extension, the key equality of Immutable.Map and the\n   * value equality of Immutable.Set will differ from ES6 Map and Set.\n   *\n   * ### Defining custom values\n   *\n   * The easiest way to describe the value an object represents is by implementing\n   * `valueOf`. For example, `Date` represents a value by returning a unix\n   * timestamp for `valueOf`:\n   *\n   *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...\n   *     var date2 = new Date(1234567890000);\n   *     date1.valueOf(); // 1234567890000\n   *     assert( date1 !== date2 );\n   *     assert( Immutable.is( date1, date2 ) );\n   *\n   * Note: overriding `valueOf` may have other implications if you use this object\n   * where JavaScript expects a primitive, such as implicit string coercion.\n   *\n   * For more complex types, especially collections, implementing `valueOf` may\n   * not be performant. An alternative is to implement `equals` and `hashCode`.\n   *\n   * `equals` takes another object, presumably of similar type, and returns true\n   * if the it is equal. Equality is symmetrical, so the same result should be\n   * returned if this and the argument are flipped.\n   *\n   *     assert( a.equals(b) === b.equals(a) );\n   *\n   * `hashCode` returns a 32bit integer number representing the object which will\n   * be used to determine how to store the value object in a Map or Set. You must\n   * provide both or neither methods, one must not exist without the other.\n   *\n   * Also, an important relationship between these methods must be upheld: if two\n   * values are equal, they *must* return the same hashCode. If the values are not\n   * equal, they might have the same hashCode; this is called a hash collision,\n   * and while undesirable for performance reasons, it is acceptable.\n   *\n   *     if (a.equals(b)) {\n   *       assert( a.hashCode() === b.hashCode() );\n   *     }\n   *\n   * All Immutable collections implement `equals` and `hashCode`.\n   *\n   */\n  function is(valueA, valueB) {\n    if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n      return true;\n    }\n    if (!valueA || !valueB) {\n      return false;\n    }\n    if (typeof valueA.valueOf === 'function' &&\n        typeof valueB.valueOf === 'function') {\n      valueA = valueA.valueOf();\n      valueB = valueB.valueOf();\n      if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n        return true;\n      }\n      if (!valueA || !valueB) {\n        return false;\n      }\n    }\n    if (typeof valueA.equals === 'function' &&\n        typeof valueB.equals === 'function' &&\n        valueA.equals(valueB)) {\n      return true;\n    }\n    return false;\n  }\n\n  function deepEqual(a, b) {\n    if (a === b) {\n      return true;\n    }\n\n    if (\n      !isIterable(b) ||\n      a.size !== undefined && b.size !== undefined && a.size !== b.size ||\n      a.__hash !== undefined && b.__hash !== undefined && a.__hash !== b.__hash ||\n      isKeyed(a) !== isKeyed(b) ||\n      isIndexed(a) !== isIndexed(b) ||\n      isOrdered(a) !== isOrdered(b)\n    ) {\n      return false;\n    }\n\n    if (a.size === 0 && b.size === 0) {\n      return true;\n    }\n\n    var notAssociative = !isAssociative(a);\n\n    if (isOrdered(a)) {\n      var entries = a.entries();\n      return b.every(function(v, k)  {\n        var entry = entries.next().value;\n        return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));\n      }) && entries.next().done;\n    }\n\n    var flipped = false;\n\n    if (a.size === undefined) {\n      if (b.size === undefined) {\n        if (typeof a.cacheResult === 'function') {\n          a.cacheResult();\n        }\n      } else {\n        flipped = true;\n        var _ = a;\n        a = b;\n        b = _;\n      }\n    }\n\n    var allEqual = true;\n    var bSize = b.__iterate(function(v, k)  {\n      if (notAssociative ? !a.has(v) :\n          flipped ? !is(v, a.get(k, NOT_SET)) : !is(a.get(k, NOT_SET), v)) {\n        allEqual = false;\n        return false;\n      }\n    });\n\n    return allEqual && a.size === bSize;\n  }\n\n  createClass(Repeat, IndexedSeq);\n\n    function Repeat(value, times) {\n      if (!(this instanceof Repeat)) {\n        return new Repeat(value, times);\n      }\n      this._value = value;\n      this.size = times === undefined ? Infinity : Math.max(0, times);\n      if (this.size === 0) {\n        if (EMPTY_REPEAT) {\n          return EMPTY_REPEAT;\n        }\n        EMPTY_REPEAT = this;\n      }\n    }\n\n    Repeat.prototype.toString = function() {\n      if (this.size === 0) {\n        return 'Repeat []';\n      }\n      return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]';\n    };\n\n    Repeat.prototype.get = function(index, notSetValue) {\n      return this.has(index) ? this._value : notSetValue;\n    };\n\n    Repeat.prototype.includes = function(searchValue) {\n      return is(this._value, searchValue);\n    };\n\n    Repeat.prototype.slice = function(begin, end) {\n      var size = this.size;\n      return wholeSlice(begin, end, size) ? this :\n        new Repeat(this._value, resolveEnd(end, size) - resolveBegin(begin, size));\n    };\n\n    Repeat.prototype.reverse = function() {\n      return this;\n    };\n\n    Repeat.prototype.indexOf = function(searchValue) {\n      if (is(this._value, searchValue)) {\n        return 0;\n      }\n      return -1;\n    };\n\n    Repeat.prototype.lastIndexOf = function(searchValue) {\n      if (is(this._value, searchValue)) {\n        return this.size;\n      }\n      return -1;\n    };\n\n    Repeat.prototype.__iterate = function(fn, reverse) {\n      for (var ii = 0; ii < this.size; ii++) {\n        if (fn(this._value, ii, this) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    };\n\n    Repeat.prototype.__iterator = function(type, reverse) {var this$0 = this;\n      var ii = 0;\n      return new Iterator(function() \n        {return ii < this$0.size ? iteratorValue(type, ii++, this$0._value) : iteratorDone()}\n      );\n    };\n\n    Repeat.prototype.equals = function(other) {\n      return other instanceof Repeat ?\n        is(this._value, other._value) :\n        deepEqual(other);\n    };\n\n\n  var EMPTY_REPEAT;\n\n  function invariant(condition, error) {\n    if (!condition) throw new Error(error);\n  }\n\n  createClass(Range, IndexedSeq);\n\n    function Range(start, end, step) {\n      if (!(this instanceof Range)) {\n        return new Range(start, end, step);\n      }\n      invariant(step !== 0, 'Cannot step a Range by 0');\n      start = start || 0;\n      if (end === undefined) {\n        end = Infinity;\n      }\n      step = step === undefined ? 1 : Math.abs(step);\n      if (end < start) {\n        step = -step;\n      }\n      this._start = start;\n      this._end = end;\n      this._step = step;\n      this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);\n      if (this.size === 0) {\n        if (EMPTY_RANGE) {\n          return EMPTY_RANGE;\n        }\n        EMPTY_RANGE = this;\n      }\n    }\n\n    Range.prototype.toString = function() {\n      if (this.size === 0) {\n        return 'Range []';\n      }\n      return 'Range [ ' +\n        this._start + '...' + this._end +\n        (this._step > 1 ? ' by ' + this._step : '') +\n      ' ]';\n    };\n\n    Range.prototype.get = function(index, notSetValue) {\n      return this.has(index) ?\n        this._start + wrapIndex(this, index) * this._step :\n        notSetValue;\n    };\n\n    Range.prototype.includes = function(searchValue) {\n      var possibleIndex = (searchValue - this._start) / this._step;\n      return possibleIndex >= 0 &&\n        possibleIndex < this.size &&\n        possibleIndex === Math.floor(possibleIndex);\n    };\n\n    Range.prototype.slice = function(begin, end) {\n      if (wholeSlice(begin, end, this.size)) {\n        return this;\n      }\n      begin = resolveBegin(begin, this.size);\n      end = resolveEnd(end, this.size);\n      if (end <= begin) {\n        return new Range(0, 0);\n      }\n      return new Range(this.get(begin, this._end), this.get(end, this._end), this._step);\n    };\n\n    Range.prototype.indexOf = function(searchValue) {\n      var offsetValue = searchValue - this._start;\n      if (offsetValue % this._step === 0) {\n        var index = offsetValue / this._step;\n        if (index >= 0 && index < this.size) {\n          return index\n        }\n      }\n      return -1;\n    };\n\n    Range.prototype.lastIndexOf = function(searchValue) {\n      return this.indexOf(searchValue);\n    };\n\n    Range.prototype.__iterate = function(fn, reverse) {\n      var maxIndex = this.size - 1;\n      var step = this._step;\n      var value = reverse ? this._start + maxIndex * step : this._start;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        if (fn(value, ii, this) === false) {\n          return ii + 1;\n        }\n        value += reverse ? -step : step;\n      }\n      return ii;\n    };\n\n    Range.prototype.__iterator = function(type, reverse) {\n      var maxIndex = this.size - 1;\n      var step = this._step;\n      var value = reverse ? this._start + maxIndex * step : this._start;\n      var ii = 0;\n      return new Iterator(function()  {\n        var v = value;\n        value += reverse ? -step : step;\n        return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii++, v);\n      });\n    };\n\n    Range.prototype.equals = function(other) {\n      return other instanceof Range ?\n        this._start === other._start &&\n        this._end === other._end &&\n        this._step === other._step :\n        deepEqual(this, other);\n    };\n\n\n  var EMPTY_RANGE;\n\n  createClass(Collection, Iterable);\n    function Collection() {\n      throw TypeError('Abstract');\n    }\n\n\n  createClass(KeyedCollection, Collection);function KeyedCollection() {}\n\n  createClass(IndexedCollection, Collection);function IndexedCollection() {}\n\n  createClass(SetCollection, Collection);function SetCollection() {}\n\n\n  Collection.Keyed = KeyedCollection;\n  Collection.Indexed = IndexedCollection;\n  Collection.Set = SetCollection;\n\n  var imul =\n    typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2 ?\n    Math.imul :\n    function imul(a, b) {\n      a = a | 0; // int\n      b = b | 0; // int\n      var c = a & 0xffff;\n      var d = b & 0xffff;\n      // Shift by 0 fixes the sign on the high part.\n      return (c * d) + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0) | 0; // int\n    };\n\n  // v8 has an optimization for storing 31-bit signed numbers.\n  // Values which have either 00 or 11 as the high order bits qualify.\n  // This function drops the highest order bit in a signed number, maintaining\n  // the sign bit.\n  function smi(i32) {\n    return ((i32 >>> 1) & 0x40000000) | (i32 & 0xBFFFFFFF);\n  }\n\n  function hash(o) {\n    if (o === false || o === null || o === undefined) {\n      return 0;\n    }\n    if (typeof o.valueOf === 'function') {\n      o = o.valueOf();\n      if (o === false || o === null || o === undefined) {\n        return 0;\n      }\n    }\n    if (o === true) {\n      return 1;\n    }\n    var type = typeof o;\n    if (type === 'number') {\n      var h = o | 0;\n      if (h !== o) {\n        h ^= o * 0xFFFFFFFF;\n      }\n      while (o > 0xFFFFFFFF) {\n        o /= 0xFFFFFFFF;\n        h ^= o;\n      }\n      return smi(h);\n    }\n    if (type === 'string') {\n      return o.length > STRING_HASH_CACHE_MIN_STRLEN ? cachedHashString(o) : hashString(o);\n    }\n    if (typeof o.hashCode === 'function') {\n      return o.hashCode();\n    }\n    if (type === 'object') {\n      return hashJSObj(o);\n    }\n    if (typeof o.toString === 'function') {\n      return hashString(o.toString());\n    }\n    throw new Error('Value type ' + type + ' cannot be hashed.');\n  }\n\n  function cachedHashString(string) {\n    var hash = stringHashCache[string];\n    if (hash === undefined) {\n      hash = hashString(string);\n      if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {\n        STRING_HASH_CACHE_SIZE = 0;\n        stringHashCache = {};\n      }\n      STRING_HASH_CACHE_SIZE++;\n      stringHashCache[string] = hash;\n    }\n    return hash;\n  }\n\n  // http://jsperf.com/hashing-strings\n  function hashString(string) {\n    // This is the hash from JVM\n    // The hash code for a string is computed as\n    // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],\n    // where s[i] is the ith character of the string and n is the length of\n    // the string. We \"mod\" the result to make it between 0 (inclusive) and 2^31\n    // (exclusive) by dropping high bits.\n    var hash = 0;\n    for (var ii = 0; ii < string.length; ii++) {\n      hash = 31 * hash + string.charCodeAt(ii) | 0;\n    }\n    return smi(hash);\n  }\n\n  function hashJSObj(obj) {\n    var hash;\n    if (usingWeakMap) {\n      hash = weakMap.get(obj);\n      if (hash !== undefined) {\n        return hash;\n      }\n    }\n\n    hash = obj[UID_HASH_KEY];\n    if (hash !== undefined) {\n      return hash;\n    }\n\n    if (!canDefineProperty) {\n      hash = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];\n      if (hash !== undefined) {\n        return hash;\n      }\n\n      hash = getIENodeHash(obj);\n      if (hash !== undefined) {\n        return hash;\n      }\n    }\n\n    hash = ++objHashUID;\n    if (objHashUID & 0x40000000) {\n      objHashUID = 0;\n    }\n\n    if (usingWeakMap) {\n      weakMap.set(obj, hash);\n    } else if (isExtensible !== undefined && isExtensible(obj) === false) {\n      throw new Error('Non-extensible objects are not allowed as keys.');\n    } else if (canDefineProperty) {\n      Object.defineProperty(obj, UID_HASH_KEY, {\n        'enumerable': false,\n        'configurable': false,\n        'writable': false,\n        'value': hash\n      });\n    } else if (obj.propertyIsEnumerable !== undefined &&\n               obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable) {\n      // Since we can't define a non-enumerable property on the object\n      // we'll hijack one of the less-used non-enumerable properties to\n      // save our hash on it. Since this is a function it will not show up in\n      // `JSON.stringify` which is what we want.\n      obj.propertyIsEnumerable = function() {\n        return this.constructor.prototype.propertyIsEnumerable.apply(this, arguments);\n      };\n      obj.propertyIsEnumerable[UID_HASH_KEY] = hash;\n    } else if (obj.nodeType !== undefined) {\n      // At this point we couldn't get the IE `uniqueID` to use as a hash\n      // and we couldn't use a non-enumerable property to exploit the\n      // dontEnum bug so we simply add the `UID_HASH_KEY` on the node\n      // itself.\n      obj[UID_HASH_KEY] = hash;\n    } else {\n      throw new Error('Unable to set a non-enumerable property on object.');\n    }\n\n    return hash;\n  }\n\n  // Get references to ES5 object methods.\n  var isExtensible = Object.isExtensible;\n\n  // True if Object.defineProperty works as expected. IE8 fails this test.\n  var canDefineProperty = (function() {\n    try {\n      Object.defineProperty({}, '@', {});\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }());\n\n  // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it\n  // and avoid memory leaks from the IE cloneNode bug.\n  function getIENodeHash(node) {\n    if (node && node.nodeType > 0) {\n      switch (node.nodeType) {\n        case 1: // Element\n          return node.uniqueID;\n        case 9: // Document\n          return node.documentElement && node.documentElement.uniqueID;\n      }\n    }\n  }\n\n  // If possible, use a WeakMap.\n  var usingWeakMap = typeof WeakMap === 'function';\n  var weakMap;\n  if (usingWeakMap) {\n    weakMap = new WeakMap();\n  }\n\n  var objHashUID = 0;\n\n  var UID_HASH_KEY = '__immutablehash__';\n  if (typeof Symbol === 'function') {\n    UID_HASH_KEY = Symbol(UID_HASH_KEY);\n  }\n\n  var STRING_HASH_CACHE_MIN_STRLEN = 16;\n  var STRING_HASH_CACHE_MAX_SIZE = 255;\n  var STRING_HASH_CACHE_SIZE = 0;\n  var stringHashCache = {};\n\n  function assertNotInfinite(size) {\n    invariant(\n      size !== Infinity,\n      'Cannot perform this action with an infinite size.'\n    );\n  }\n\n  createClass(Map, KeyedCollection);\n\n    // @pragma Construction\n\n    function Map(value) {\n      return value === null || value === undefined ? emptyMap() :\n        isMap(value) && !isOrdered(value) ? value :\n        emptyMap().withMutations(function(map ) {\n          var iter = KeyedIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v, k)  {return map.set(k, v)});\n        });\n    }\n\n    Map.prototype.toString = function() {\n      return this.__toString('Map {', '}');\n    };\n\n    // @pragma Access\n\n    Map.prototype.get = function(k, notSetValue) {\n      return this._root ?\n        this._root.get(0, undefined, k, notSetValue) :\n        notSetValue;\n    };\n\n    // @pragma Modification\n\n    Map.prototype.set = function(k, v) {\n      return updateMap(this, k, v);\n    };\n\n    Map.prototype.setIn = function(keyPath, v) {\n      return this.updateIn(keyPath, NOT_SET, function()  {return v});\n    };\n\n    Map.prototype.remove = function(k) {\n      return updateMap(this, k, NOT_SET);\n    };\n\n    Map.prototype.deleteIn = function(keyPath) {\n      return this.updateIn(keyPath, function()  {return NOT_SET});\n    };\n\n    Map.prototype.update = function(k, notSetValue, updater) {\n      return arguments.length === 1 ?\n        k(this) :\n        this.updateIn([k], notSetValue, updater);\n    };\n\n    Map.prototype.updateIn = function(keyPath, notSetValue, updater) {\n      if (!updater) {\n        updater = notSetValue;\n        notSetValue = undefined;\n      }\n      var updatedValue = updateInDeepMap(\n        this,\n        forceIterator(keyPath),\n        notSetValue,\n        updater\n      );\n      return updatedValue === NOT_SET ? undefined : updatedValue;\n    };\n\n    Map.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._root = null;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyMap();\n    };\n\n    // @pragma Composition\n\n    Map.prototype.merge = function(/*...iters*/) {\n      return mergeIntoMapWith(this, undefined, arguments);\n    };\n\n    Map.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoMapWith(this, merger, iters);\n    };\n\n    Map.prototype.mergeIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);\n      return this.updateIn(\n        keyPath,\n        emptyMap(),\n        function(m ) {return typeof m.merge === 'function' ?\n          m.merge.apply(m, iters) :\n          iters[iters.length - 1]}\n      );\n    };\n\n    Map.prototype.mergeDeep = function(/*...iters*/) {\n      return mergeIntoMapWith(this, deepMerger, arguments);\n    };\n\n    Map.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoMapWith(this, deepMergerWith(merger), iters);\n    };\n\n    Map.prototype.mergeDeepIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);\n      return this.updateIn(\n        keyPath,\n        emptyMap(),\n        function(m ) {return typeof m.mergeDeep === 'function' ?\n          m.mergeDeep.apply(m, iters) :\n          iters[iters.length - 1]}\n      );\n    };\n\n    Map.prototype.sort = function(comparator) {\n      // Late binding\n      return OrderedMap(sortFactory(this, comparator));\n    };\n\n    Map.prototype.sortBy = function(mapper, comparator) {\n      // Late binding\n      return OrderedMap(sortFactory(this, comparator, mapper));\n    };\n\n    // @pragma Mutability\n\n    Map.prototype.withMutations = function(fn) {\n      var mutable = this.asMutable();\n      fn(mutable);\n      return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;\n    };\n\n    Map.prototype.asMutable = function() {\n      return this.__ownerID ? this : this.__ensureOwner(new OwnerID());\n    };\n\n    Map.prototype.asImmutable = function() {\n      return this.__ensureOwner();\n    };\n\n    Map.prototype.wasAltered = function() {\n      return this.__altered;\n    };\n\n    Map.prototype.__iterator = function(type, reverse) {\n      return new MapIterator(this, type, reverse);\n    };\n\n    Map.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      this._root && this._root.iterate(function(entry ) {\n        iterations++;\n        return fn(entry[1], entry[0], this$0);\n      }, reverse);\n      return iterations;\n    };\n\n    Map.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this.__altered = false;\n        return this;\n      }\n      return makeMap(this.size, this._root, ownerID, this.__hash);\n    };\n\n\n  function isMap(maybeMap) {\n    return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]);\n  }\n\n  Map.isMap = isMap;\n\n  var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';\n\n  var MapPrototype = Map.prototype;\n  MapPrototype[IS_MAP_SENTINEL] = true;\n  MapPrototype[DELETE] = MapPrototype.remove;\n  MapPrototype.removeIn = MapPrototype.deleteIn;\n\n\n  // #pragma Trie Nodes\n\n\n\n    function ArrayMapNode(ownerID, entries) {\n      this.ownerID = ownerID;\n      this.entries = entries;\n    }\n\n    ArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      var entries = this.entries;\n      for (var ii = 0, len = entries.length; ii < len; ii++) {\n        if (is(key, entries[ii][0])) {\n          return entries[ii][1];\n        }\n      }\n      return notSetValue;\n    };\n\n    ArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      var removed = value === NOT_SET;\n\n      var entries = this.entries;\n      var idx = 0;\n      for (var len = entries.length; idx < len; idx++) {\n        if (is(key, entries[idx][0])) {\n          break;\n        }\n      }\n      var exists = idx < len;\n\n      if (exists ? entries[idx][1] === value : removed) {\n        return this;\n      }\n\n      SetRef(didAlter);\n      (removed || !exists) && SetRef(didChangeSize);\n\n      if (removed && entries.length === 1) {\n        return; // undefined\n      }\n\n      if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {\n        return createNodes(ownerID, entries, key, value);\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newEntries = isEditable ? entries : arrCopy(entries);\n\n      if (exists) {\n        if (removed) {\n          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());\n        } else {\n          newEntries[idx] = [key, value];\n        }\n      } else {\n        newEntries.push([key, value]);\n      }\n\n      if (isEditable) {\n        this.entries = newEntries;\n        return this;\n      }\n\n      return new ArrayMapNode(ownerID, newEntries);\n    };\n\n\n\n\n    function BitmapIndexedNode(ownerID, bitmap, nodes) {\n      this.ownerID = ownerID;\n      this.bitmap = bitmap;\n      this.nodes = nodes;\n    }\n\n    BitmapIndexedNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var bit = (1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK));\n      var bitmap = this.bitmap;\n      return (bitmap & bit) === 0 ? notSetValue :\n        this.nodes[popCount(bitmap & (bit - 1))].get(shift + SHIFT, keyHash, key, notSetValue);\n    };\n\n    BitmapIndexedNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n      var bit = 1 << keyHashFrag;\n      var bitmap = this.bitmap;\n      var exists = (bitmap & bit) !== 0;\n\n      if (!exists && value === NOT_SET) {\n        return this;\n      }\n\n      var idx = popCount(bitmap & (bit - 1));\n      var nodes = this.nodes;\n      var node = exists ? nodes[idx] : undefined;\n      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);\n\n      if (newNode === node) {\n        return this;\n      }\n\n      if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {\n        return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);\n      }\n\n      if (exists && !newNode && nodes.length === 2 && isLeafNode(nodes[idx ^ 1])) {\n        return nodes[idx ^ 1];\n      }\n\n      if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {\n        return newNode;\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newBitmap = exists ? newNode ? bitmap : bitmap ^ bit : bitmap | bit;\n      var newNodes = exists ? newNode ?\n        setIn(nodes, idx, newNode, isEditable) :\n        spliceOut(nodes, idx, isEditable) :\n        spliceIn(nodes, idx, newNode, isEditable);\n\n      if (isEditable) {\n        this.bitmap = newBitmap;\n        this.nodes = newNodes;\n        return this;\n      }\n\n      return new BitmapIndexedNode(ownerID, newBitmap, newNodes);\n    };\n\n\n\n\n    function HashArrayMapNode(ownerID, count, nodes) {\n      this.ownerID = ownerID;\n      this.count = count;\n      this.nodes = nodes;\n    }\n\n    HashArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n      var node = this.nodes[idx];\n      return node ? node.get(shift + SHIFT, keyHash, key, notSetValue) : notSetValue;\n    };\n\n    HashArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n      var removed = value === NOT_SET;\n      var nodes = this.nodes;\n      var node = nodes[idx];\n\n      if (removed && !node) {\n        return this;\n      }\n\n      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);\n      if (newNode === node) {\n        return this;\n      }\n\n      var newCount = this.count;\n      if (!node) {\n        newCount++;\n      } else if (!newNode) {\n        newCount--;\n        if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {\n          return packNodes(ownerID, nodes, newCount, idx);\n        }\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newNodes = setIn(nodes, idx, newNode, isEditable);\n\n      if (isEditable) {\n        this.count = newCount;\n        this.nodes = newNodes;\n        return this;\n      }\n\n      return new HashArrayMapNode(ownerID, newCount, newNodes);\n    };\n\n\n\n\n    function HashCollisionNode(ownerID, keyHash, entries) {\n      this.ownerID = ownerID;\n      this.keyHash = keyHash;\n      this.entries = entries;\n    }\n\n    HashCollisionNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      var entries = this.entries;\n      for (var ii = 0, len = entries.length; ii < len; ii++) {\n        if (is(key, entries[ii][0])) {\n          return entries[ii][1];\n        }\n      }\n      return notSetValue;\n    };\n\n    HashCollisionNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n\n      var removed = value === NOT_SET;\n\n      if (keyHash !== this.keyHash) {\n        if (removed) {\n          return this;\n        }\n        SetRef(didAlter);\n        SetRef(didChangeSize);\n        return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);\n      }\n\n      var entries = this.entries;\n      var idx = 0;\n      for (var len = entries.length; idx < len; idx++) {\n        if (is(key, entries[idx][0])) {\n          break;\n        }\n      }\n      var exists = idx < len;\n\n      if (exists ? entries[idx][1] === value : removed) {\n        return this;\n      }\n\n      SetRef(didAlter);\n      (removed || !exists) && SetRef(didChangeSize);\n\n      if (removed && len === 2) {\n        return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newEntries = isEditable ? entries : arrCopy(entries);\n\n      if (exists) {\n        if (removed) {\n          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());\n        } else {\n          newEntries[idx] = [key, value];\n        }\n      } else {\n        newEntries.push([key, value]);\n      }\n\n      if (isEditable) {\n        this.entries = newEntries;\n        return this;\n      }\n\n      return new HashCollisionNode(ownerID, this.keyHash, newEntries);\n    };\n\n\n\n\n    function ValueNode(ownerID, keyHash, entry) {\n      this.ownerID = ownerID;\n      this.keyHash = keyHash;\n      this.entry = entry;\n    }\n\n    ValueNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      return is(key, this.entry[0]) ? this.entry[1] : notSetValue;\n    };\n\n    ValueNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      var removed = value === NOT_SET;\n      var keyMatch = is(key, this.entry[0]);\n      if (keyMatch ? value === this.entry[1] : removed) {\n        return this;\n      }\n\n      SetRef(didAlter);\n\n      if (removed) {\n        SetRef(didChangeSize);\n        return; // undefined\n      }\n\n      if (keyMatch) {\n        if (ownerID && ownerID === this.ownerID) {\n          this.entry[1] = value;\n          return this;\n        }\n        return new ValueNode(ownerID, this.keyHash, [key, value]);\n      }\n\n      SetRef(didChangeSize);\n      return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);\n    };\n\n\n\n  // #pragma Iterators\n\n  ArrayMapNode.prototype.iterate =\n  HashCollisionNode.prototype.iterate = function (fn, reverse) {\n    var entries = this.entries;\n    for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {\n      if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {\n        return false;\n      }\n    }\n  }\n\n  BitmapIndexedNode.prototype.iterate =\n  HashArrayMapNode.prototype.iterate = function (fn, reverse) {\n    var nodes = this.nodes;\n    for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {\n      var node = nodes[reverse ? maxIndex - ii : ii];\n      if (node && node.iterate(fn, reverse) === false) {\n        return false;\n      }\n    }\n  }\n\n  ValueNode.prototype.iterate = function (fn, reverse) {\n    return fn(this.entry);\n  }\n\n  createClass(MapIterator, Iterator);\n\n    function MapIterator(map, type, reverse) {\n      this._type = type;\n      this._reverse = reverse;\n      this._stack = map._root && mapIteratorFrame(map._root);\n    }\n\n    MapIterator.prototype.next = function() {\n      var type = this._type;\n      var stack = this._stack;\n      while (stack) {\n        var node = stack.node;\n        var index = stack.index++;\n        var maxIndex;\n        if (node.entry) {\n          if (index === 0) {\n            return mapIteratorValue(type, node.entry);\n          }\n        } else if (node.entries) {\n          maxIndex = node.entries.length - 1;\n          if (index <= maxIndex) {\n            return mapIteratorValue(type, node.entries[this._reverse ? maxIndex - index : index]);\n          }\n        } else {\n          maxIndex = node.nodes.length - 1;\n          if (index <= maxIndex) {\n            var subNode = node.nodes[this._reverse ? maxIndex - index : index];\n            if (subNode) {\n              if (subNode.entry) {\n                return mapIteratorValue(type, subNode.entry);\n              }\n              stack = this._stack = mapIteratorFrame(subNode, stack);\n            }\n            continue;\n          }\n        }\n        stack = this._stack = this._stack.__prev;\n      }\n      return iteratorDone();\n    };\n\n\n  function mapIteratorValue(type, entry) {\n    return iteratorValue(type, entry[0], entry[1]);\n  }\n\n  function mapIteratorFrame(node, prev) {\n    return {\n      node: node,\n      index: 0,\n      __prev: prev\n    };\n  }\n\n  function makeMap(size, root, ownerID, hash) {\n    var map = Object.create(MapPrototype);\n    map.size = size;\n    map._root = root;\n    map.__ownerID = ownerID;\n    map.__hash = hash;\n    map.__altered = false;\n    return map;\n  }\n\n  var EMPTY_MAP;\n  function emptyMap() {\n    return EMPTY_MAP || (EMPTY_MAP = makeMap(0));\n  }\n\n  function updateMap(map, k, v) {\n    var newRoot;\n    var newSize;\n    if (!map._root) {\n      if (v === NOT_SET) {\n        return map;\n      }\n      newSize = 1;\n      newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);\n    } else {\n      var didChangeSize = MakeRef(CHANGE_LENGTH);\n      var didAlter = MakeRef(DID_ALTER);\n      newRoot = updateNode(map._root, map.__ownerID, 0, undefined, k, v, didChangeSize, didAlter);\n      if (!didAlter.value) {\n        return map;\n      }\n      newSize = map.size + (didChangeSize.value ? v === NOT_SET ? -1 : 1 : 0);\n    }\n    if (map.__ownerID) {\n      map.size = newSize;\n      map._root = newRoot;\n      map.__hash = undefined;\n      map.__altered = true;\n      return map;\n    }\n    return newRoot ? makeMap(newSize, newRoot) : emptyMap();\n  }\n\n  function updateNode(node, ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n    if (!node) {\n      if (value === NOT_SET) {\n        return node;\n      }\n      SetRef(didAlter);\n      SetRef(didChangeSize);\n      return new ValueNode(ownerID, keyHash, [key, value]);\n    }\n    return node.update(ownerID, shift, keyHash, key, value, didChangeSize, didAlter);\n  }\n\n  function isLeafNode(node) {\n    return node.constructor === ValueNode || node.constructor === HashCollisionNode;\n  }\n\n  function mergeIntoNode(node, ownerID, shift, keyHash, entry) {\n    if (node.keyHash === keyHash) {\n      return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);\n    }\n\n    var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;\n    var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n\n    var newNode;\n    var nodes = idx1 === idx2 ?\n      [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)] :\n      ((newNode = new ValueNode(ownerID, keyHash, entry)), idx1 < idx2 ? [node, newNode] : [newNode, node]);\n\n    return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);\n  }\n\n  function createNodes(ownerID, entries, key, value) {\n    if (!ownerID) {\n      ownerID = new OwnerID();\n    }\n    var node = new ValueNode(ownerID, hash(key), [key, value]);\n    for (var ii = 0; ii < entries.length; ii++) {\n      var entry = entries[ii];\n      node = node.update(ownerID, 0, undefined, entry[0], entry[1]);\n    }\n    return node;\n  }\n\n  function packNodes(ownerID, nodes, count, excluding) {\n    var bitmap = 0;\n    var packedII = 0;\n    var packedNodes = new Array(count);\n    for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {\n      var node = nodes[ii];\n      if (node !== undefined && ii !== excluding) {\n        bitmap |= bit;\n        packedNodes[packedII++] = node;\n      }\n    }\n    return new BitmapIndexedNode(ownerID, bitmap, packedNodes);\n  }\n\n  function expandNodes(ownerID, nodes, bitmap, including, node) {\n    var count = 0;\n    var expandedNodes = new Array(SIZE);\n    for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {\n      expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;\n    }\n    expandedNodes[including] = node;\n    return new HashArrayMapNode(ownerID, count + 1, expandedNodes);\n  }\n\n  function mergeIntoMapWith(map, merger, iterables) {\n    var iters = [];\n    for (var ii = 0; ii < iterables.length; ii++) {\n      var value = iterables[ii];\n      var iter = KeyedIterable(value);\n      if (!isIterable(value)) {\n        iter = iter.map(function(v ) {return fromJS(v)});\n      }\n      iters.push(iter);\n    }\n    return mergeIntoCollectionWith(map, merger, iters);\n  }\n\n  function deepMerger(existing, value, key) {\n    return existing && existing.mergeDeep && isIterable(value) ?\n      existing.mergeDeep(value) :\n      is(existing, value) ? existing : value;\n  }\n\n  function deepMergerWith(merger) {\n    return function(existing, value, key)  {\n      if (existing && existing.mergeDeepWith && isIterable(value)) {\n        return existing.mergeDeepWith(merger, value);\n      }\n      var nextValue = merger(existing, value, key);\n      return is(existing, nextValue) ? existing : nextValue;\n    };\n  }\n\n  function mergeIntoCollectionWith(collection, merger, iters) {\n    iters = iters.filter(function(x ) {return x.size !== 0});\n    if (iters.length === 0) {\n      return collection;\n    }\n    if (collection.size === 0 && !collection.__ownerID && iters.length === 1) {\n      return collection.constructor(iters[0]);\n    }\n    return collection.withMutations(function(collection ) {\n      var mergeIntoMap = merger ?\n        function(value, key)  {\n          collection.update(key, NOT_SET, function(existing )\n            {return existing === NOT_SET ? value : merger(existing, value, key)}\n          );\n        } :\n        function(value, key)  {\n          collection.set(key, value);\n        }\n      for (var ii = 0; ii < iters.length; ii++) {\n        iters[ii].forEach(mergeIntoMap);\n      }\n    });\n  }\n\n  function updateInDeepMap(existing, keyPathIter, notSetValue, updater) {\n    var isNotSet = existing === NOT_SET;\n    var step = keyPathIter.next();\n    if (step.done) {\n      var existingValue = isNotSet ? notSetValue : existing;\n      var newValue = updater(existingValue);\n      return newValue === existingValue ? existing : newValue;\n    }\n    invariant(\n      isNotSet || (existing && existing.set),\n      'invalid keyPath'\n    );\n    var key = step.value;\n    var nextExisting = isNotSet ? NOT_SET : existing.get(key, NOT_SET);\n    var nextUpdated = updateInDeepMap(\n      nextExisting,\n      keyPathIter,\n      notSetValue,\n      updater\n    );\n    return nextUpdated === nextExisting ? existing :\n      nextUpdated === NOT_SET ? existing.remove(key) :\n      (isNotSet ? emptyMap() : existing).set(key, nextUpdated);\n  }\n\n  function popCount(x) {\n    x = x - ((x >> 1) & 0x55555555);\n    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);\n    x = (x + (x >> 4)) & 0x0f0f0f0f;\n    x = x + (x >> 8);\n    x = x + (x >> 16);\n    return x & 0x7f;\n  }\n\n  function setIn(array, idx, val, canEdit) {\n    var newArray = canEdit ? array : arrCopy(array);\n    newArray[idx] = val;\n    return newArray;\n  }\n\n  function spliceIn(array, idx, val, canEdit) {\n    var newLen = array.length + 1;\n    if (canEdit && idx + 1 === newLen) {\n      array[idx] = val;\n      return array;\n    }\n    var newArray = new Array(newLen);\n    var after = 0;\n    for (var ii = 0; ii < newLen; ii++) {\n      if (ii === idx) {\n        newArray[ii] = val;\n        after = -1;\n      } else {\n        newArray[ii] = array[ii + after];\n      }\n    }\n    return newArray;\n  }\n\n  function spliceOut(array, idx, canEdit) {\n    var newLen = array.length - 1;\n    if (canEdit && idx === newLen) {\n      array.pop();\n      return array;\n    }\n    var newArray = new Array(newLen);\n    var after = 0;\n    for (var ii = 0; ii < newLen; ii++) {\n      if (ii === idx) {\n        after = 1;\n      }\n      newArray[ii] = array[ii + after];\n    }\n    return newArray;\n  }\n\n  var MAX_ARRAY_MAP_SIZE = SIZE / 4;\n  var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;\n  var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;\n\n  createClass(List, IndexedCollection);\n\n    // @pragma Construction\n\n    function List(value) {\n      var empty = emptyList();\n      if (value === null || value === undefined) {\n        return empty;\n      }\n      if (isList(value)) {\n        return value;\n      }\n      var iter = IndexedIterable(value);\n      var size = iter.size;\n      if (size === 0) {\n        return empty;\n      }\n      assertNotInfinite(size);\n      if (size > 0 && size < SIZE) {\n        return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));\n      }\n      return empty.withMutations(function(list ) {\n        list.setSize(size);\n        iter.forEach(function(v, i)  {return list.set(i, v)});\n      });\n    }\n\n    List.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    List.prototype.toString = function() {\n      return this.__toString('List [', ']');\n    };\n\n    // @pragma Access\n\n    List.prototype.get = function(index, notSetValue) {\n      index = wrapIndex(this, index);\n      if (index >= 0 && index < this.size) {\n        index += this._origin;\n        var node = listNodeFor(this, index);\n        return node && node.array[index & MASK];\n      }\n      return notSetValue;\n    };\n\n    // @pragma Modification\n\n    List.prototype.set = function(index, value) {\n      return updateList(this, index, value);\n    };\n\n    List.prototype.remove = function(index) {\n      return !this.has(index) ? this :\n        index === 0 ? this.shift() :\n        index === this.size - 1 ? this.pop() :\n        this.splice(index, 1);\n    };\n\n    List.prototype.insert = function(index, value) {\n      return this.splice(index, 0, value);\n    };\n\n    List.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = this._origin = this._capacity = 0;\n        this._level = SHIFT;\n        this._root = this._tail = null;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyList();\n    };\n\n    List.prototype.push = function(/*...values*/) {\n      var values = arguments;\n      var oldSize = this.size;\n      return this.withMutations(function(list ) {\n        setListBounds(list, 0, oldSize + values.length);\n        for (var ii = 0; ii < values.length; ii++) {\n          list.set(oldSize + ii, values[ii]);\n        }\n      });\n    };\n\n    List.prototype.pop = function() {\n      return setListBounds(this, 0, -1);\n    };\n\n    List.prototype.unshift = function(/*...values*/) {\n      var values = arguments;\n      return this.withMutations(function(list ) {\n        setListBounds(list, -values.length);\n        for (var ii = 0; ii < values.length; ii++) {\n          list.set(ii, values[ii]);\n        }\n      });\n    };\n\n    List.prototype.shift = function() {\n      return setListBounds(this, 1);\n    };\n\n    // @pragma Composition\n\n    List.prototype.merge = function(/*...iters*/) {\n      return mergeIntoListWith(this, undefined, arguments);\n    };\n\n    List.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoListWith(this, merger, iters);\n    };\n\n    List.prototype.mergeDeep = function(/*...iters*/) {\n      return mergeIntoListWith(this, deepMerger, arguments);\n    };\n\n    List.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoListWith(this, deepMergerWith(merger), iters);\n    };\n\n    List.prototype.setSize = function(size) {\n      return setListBounds(this, 0, size);\n    };\n\n    // @pragma Iteration\n\n    List.prototype.slice = function(begin, end) {\n      var size = this.size;\n      if (wholeSlice(begin, end, size)) {\n        return this;\n      }\n      return setListBounds(\n        this,\n        resolveBegin(begin, size),\n        resolveEnd(end, size)\n      );\n    };\n\n    List.prototype.__iterator = function(type, reverse) {\n      var index = 0;\n      var values = iterateList(this, reverse);\n      return new Iterator(function()  {\n        var value = values();\n        return value === DONE ?\n          iteratorDone() :\n          iteratorValue(type, index++, value);\n      });\n    };\n\n    List.prototype.__iterate = function(fn, reverse) {\n      var index = 0;\n      var values = iterateList(this, reverse);\n      var value;\n      while ((value = values()) !== DONE) {\n        if (fn(value, index++, this) === false) {\n          break;\n        }\n      }\n      return index;\n    };\n\n    List.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        return this;\n      }\n      return makeList(this._origin, this._capacity, this._level, this._root, this._tail, ownerID, this.__hash);\n    };\n\n\n  function isList(maybeList) {\n    return !!(maybeList && maybeList[IS_LIST_SENTINEL]);\n  }\n\n  List.isList = isList;\n\n  var IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';\n\n  var ListPrototype = List.prototype;\n  ListPrototype[IS_LIST_SENTINEL] = true;\n  ListPrototype[DELETE] = ListPrototype.remove;\n  ListPrototype.setIn = MapPrototype.setIn;\n  ListPrototype.deleteIn =\n  ListPrototype.removeIn = MapPrototype.removeIn;\n  ListPrototype.update = MapPrototype.update;\n  ListPrototype.updateIn = MapPrototype.updateIn;\n  ListPrototype.mergeIn = MapPrototype.mergeIn;\n  ListPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;\n  ListPrototype.withMutations = MapPrototype.withMutations;\n  ListPrototype.asMutable = MapPrototype.asMutable;\n  ListPrototype.asImmutable = MapPrototype.asImmutable;\n  ListPrototype.wasAltered = MapPrototype.wasAltered;\n\n\n\n    function VNode(array, ownerID) {\n      this.array = array;\n      this.ownerID = ownerID;\n    }\n\n    // TODO: seems like these methods are very similar\n\n    VNode.prototype.removeBefore = function(ownerID, level, index) {\n      if (index === level ? 1 << level : 0 || this.array.length === 0) {\n        return this;\n      }\n      var originIndex = (index >>> level) & MASK;\n      if (originIndex >= this.array.length) {\n        return new VNode([], ownerID);\n      }\n      var removingFirst = originIndex === 0;\n      var newChild;\n      if (level > 0) {\n        var oldChild = this.array[originIndex];\n        newChild = oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);\n        if (newChild === oldChild && removingFirst) {\n          return this;\n        }\n      }\n      if (removingFirst && !newChild) {\n        return this;\n      }\n      var editable = editableVNode(this, ownerID);\n      if (!removingFirst) {\n        for (var ii = 0; ii < originIndex; ii++) {\n          editable.array[ii] = undefined;\n        }\n      }\n      if (newChild) {\n        editable.array[originIndex] = newChild;\n      }\n      return editable;\n    };\n\n    VNode.prototype.removeAfter = function(ownerID, level, index) {\n      if (index === (level ? 1 << level : 0) || this.array.length === 0) {\n        return this;\n      }\n      var sizeIndex = ((index - 1) >>> level) & MASK;\n      if (sizeIndex >= this.array.length) {\n        return this;\n      }\n\n      var newChild;\n      if (level > 0) {\n        var oldChild = this.array[sizeIndex];\n        newChild = oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);\n        if (newChild === oldChild && sizeIndex === this.array.length - 1) {\n          return this;\n        }\n      }\n\n      var editable = editableVNode(this, ownerID);\n      editable.array.splice(sizeIndex + 1);\n      if (newChild) {\n        editable.array[sizeIndex] = newChild;\n      }\n      return editable;\n    };\n\n\n\n  var DONE = {};\n\n  function iterateList(list, reverse) {\n    var left = list._origin;\n    var right = list._capacity;\n    var tailPos = getTailOffset(right);\n    var tail = list._tail;\n\n    return iterateNodeOrLeaf(list._root, list._level, 0);\n\n    function iterateNodeOrLeaf(node, level, offset) {\n      return level === 0 ?\n        iterateLeaf(node, offset) :\n        iterateNode(node, level, offset);\n    }\n\n    function iterateLeaf(node, offset) {\n      var array = offset === tailPos ? tail && tail.array : node && node.array;\n      var from = offset > left ? 0 : left - offset;\n      var to = right - offset;\n      if (to > SIZE) {\n        to = SIZE;\n      }\n      return function()  {\n        if (from === to) {\n          return DONE;\n        }\n        var idx = reverse ? --to : from++;\n        return array && array[idx];\n      };\n    }\n\n    function iterateNode(node, level, offset) {\n      var values;\n      var array = node && node.array;\n      var from = offset > left ? 0 : (left - offset) >> level;\n      var to = ((right - offset) >> level) + 1;\n      if (to > SIZE) {\n        to = SIZE;\n      }\n      return function()  {\n        do {\n          if (values) {\n            var value = values();\n            if (value !== DONE) {\n              return value;\n            }\n            values = null;\n          }\n          if (from === to) {\n            return DONE;\n          }\n          var idx = reverse ? --to : from++;\n          values = iterateNodeOrLeaf(\n            array && array[idx], level - SHIFT, offset + (idx << level)\n          );\n        } while (true);\n      };\n    }\n  }\n\n  function makeList(origin, capacity, level, root, tail, ownerID, hash) {\n    var list = Object.create(ListPrototype);\n    list.size = capacity - origin;\n    list._origin = origin;\n    list._capacity = capacity;\n    list._level = level;\n    list._root = root;\n    list._tail = tail;\n    list.__ownerID = ownerID;\n    list.__hash = hash;\n    list.__altered = false;\n    return list;\n  }\n\n  var EMPTY_LIST;\n  function emptyList() {\n    return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));\n  }\n\n  function updateList(list, index, value) {\n    index = wrapIndex(list, index);\n\n    if (index !== index) {\n      return list;\n    }\n\n    if (index >= list.size || index < 0) {\n      return list.withMutations(function(list ) {\n        index < 0 ?\n          setListBounds(list, index).set(0, value) :\n          setListBounds(list, 0, index + 1).set(index, value)\n      });\n    }\n\n    index += list._origin;\n\n    var newTail = list._tail;\n    var newRoot = list._root;\n    var didAlter = MakeRef(DID_ALTER);\n    if (index >= getTailOffset(list._capacity)) {\n      newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter);\n    } else {\n      newRoot = updateVNode(newRoot, list.__ownerID, list._level, index, value, didAlter);\n    }\n\n    if (!didAlter.value) {\n      return list;\n    }\n\n    if (list.__ownerID) {\n      list._root = newRoot;\n      list._tail = newTail;\n      list.__hash = undefined;\n      list.__altered = true;\n      return list;\n    }\n    return makeList(list._origin, list._capacity, list._level, newRoot, newTail);\n  }\n\n  function updateVNode(node, ownerID, level, index, value, didAlter) {\n    var idx = (index >>> level) & MASK;\n    var nodeHas = node && idx < node.array.length;\n    if (!nodeHas && value === undefined) {\n      return node;\n    }\n\n    var newNode;\n\n    if (level > 0) {\n      var lowerNode = node && node.array[idx];\n      var newLowerNode = updateVNode(lowerNode, ownerID, level - SHIFT, index, value, didAlter);\n      if (newLowerNode === lowerNode) {\n        return node;\n      }\n      newNode = editableVNode(node, ownerID);\n      newNode.array[idx] = newLowerNode;\n      return newNode;\n    }\n\n    if (nodeHas && node.array[idx] === value) {\n      return node;\n    }\n\n    SetRef(didAlter);\n\n    newNode = editableVNode(node, ownerID);\n    if (value === undefined && idx === newNode.array.length - 1) {\n      newNode.array.pop();\n    } else {\n      newNode.array[idx] = value;\n    }\n    return newNode;\n  }\n\n  function editableVNode(node, ownerID) {\n    if (ownerID && node && ownerID === node.ownerID) {\n      return node;\n    }\n    return new VNode(node ? node.array.slice() : [], ownerID);\n  }\n\n  function listNodeFor(list, rawIndex) {\n    if (rawIndex >= getTailOffset(list._capacity)) {\n      return list._tail;\n    }\n    if (rawIndex < 1 << (list._level + SHIFT)) {\n      var node = list._root;\n      var level = list._level;\n      while (node && level > 0) {\n        node = node.array[(rawIndex >>> level) & MASK];\n        level -= SHIFT;\n      }\n      return node;\n    }\n  }\n\n  function setListBounds(list, begin, end) {\n    // Sanitize begin & end using this shorthand for ToInt32(argument)\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n    if (begin !== undefined) {\n      begin = begin | 0;\n    }\n    if (end !== undefined) {\n      end = end | 0;\n    }\n    var owner = list.__ownerID || new OwnerID();\n    var oldOrigin = list._origin;\n    var oldCapacity = list._capacity;\n    var newOrigin = oldOrigin + begin;\n    var newCapacity = end === undefined ? oldCapacity : end < 0 ? oldCapacity + end : oldOrigin + end;\n    if (newOrigin === oldOrigin && newCapacity === oldCapacity) {\n      return list;\n    }\n\n    // If it's going to end after it starts, it's empty.\n    if (newOrigin >= newCapacity) {\n      return list.clear();\n    }\n\n    var newLevel = list._level;\n    var newRoot = list._root;\n\n    // New origin might need creating a higher root.\n    var offsetShift = 0;\n    while (newOrigin + offsetShift < 0) {\n      newRoot = new VNode(newRoot && newRoot.array.length ? [undefined, newRoot] : [], owner);\n      newLevel += SHIFT;\n      offsetShift += 1 << newLevel;\n    }\n    if (offsetShift) {\n      newOrigin += offsetShift;\n      oldOrigin += offsetShift;\n      newCapacity += offsetShift;\n      oldCapacity += offsetShift;\n    }\n\n    var oldTailOffset = getTailOffset(oldCapacity);\n    var newTailOffset = getTailOffset(newCapacity);\n\n    // New size might need creating a higher root.\n    while (newTailOffset >= 1 << (newLevel + SHIFT)) {\n      newRoot = new VNode(newRoot && newRoot.array.length ? [newRoot] : [], owner);\n      newLevel += SHIFT;\n    }\n\n    // Locate or create the new tail.\n    var oldTail = list._tail;\n    var newTail = newTailOffset < oldTailOffset ?\n      listNodeFor(list, newCapacity - 1) :\n      newTailOffset > oldTailOffset ? new VNode([], owner) : oldTail;\n\n    // Merge Tail into tree.\n    if (oldTail && newTailOffset > oldTailOffset && newOrigin < oldCapacity && oldTail.array.length) {\n      newRoot = editableVNode(newRoot, owner);\n      var node = newRoot;\n      for (var level = newLevel; level > SHIFT; level -= SHIFT) {\n        var idx = (oldTailOffset >>> level) & MASK;\n        node = node.array[idx] = editableVNode(node.array[idx], owner);\n      }\n      node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;\n    }\n\n    // If the size has been reduced, there's a chance the tail needs to be trimmed.\n    if (newCapacity < oldCapacity) {\n      newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);\n    }\n\n    // If the new origin is within the tail, then we do not need a root.\n    if (newOrigin >= newTailOffset) {\n      newOrigin -= newTailOffset;\n      newCapacity -= newTailOffset;\n      newLevel = SHIFT;\n      newRoot = null;\n      newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);\n\n    // Otherwise, if the root has been trimmed, garbage collect.\n    } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {\n      offsetShift = 0;\n\n      // Identify the new top root node of the subtree of the old root.\n      while (newRoot) {\n        var beginIndex = (newOrigin >>> newLevel) & MASK;\n        if (beginIndex !== (newTailOffset >>> newLevel) & MASK) {\n          break;\n        }\n        if (beginIndex) {\n          offsetShift += (1 << newLevel) * beginIndex;\n        }\n        newLevel -= SHIFT;\n        newRoot = newRoot.array[beginIndex];\n      }\n\n      // Trim the new sides of the new root.\n      if (newRoot && newOrigin > oldOrigin) {\n        newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift);\n      }\n      if (newRoot && newTailOffset < oldTailOffset) {\n        newRoot = newRoot.removeAfter(owner, newLevel, newTailOffset - offsetShift);\n      }\n      if (offsetShift) {\n        newOrigin -= offsetShift;\n        newCapacity -= offsetShift;\n      }\n    }\n\n    if (list.__ownerID) {\n      list.size = newCapacity - newOrigin;\n      list._origin = newOrigin;\n      list._capacity = newCapacity;\n      list._level = newLevel;\n      list._root = newRoot;\n      list._tail = newTail;\n      list.__hash = undefined;\n      list.__altered = true;\n      return list;\n    }\n    return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);\n  }\n\n  function mergeIntoListWith(list, merger, iterables) {\n    var iters = [];\n    var maxSize = 0;\n    for (var ii = 0; ii < iterables.length; ii++) {\n      var value = iterables[ii];\n      var iter = IndexedIterable(value);\n      if (iter.size > maxSize) {\n        maxSize = iter.size;\n      }\n      if (!isIterable(value)) {\n        iter = iter.map(function(v ) {return fromJS(v)});\n      }\n      iters.push(iter);\n    }\n    if (maxSize > list.size) {\n      list = list.setSize(maxSize);\n    }\n    return mergeIntoCollectionWith(list, merger, iters);\n  }\n\n  function getTailOffset(size) {\n    return size < SIZE ? 0 : (((size - 1) >>> SHIFT) << SHIFT);\n  }\n\n  createClass(OrderedMap, Map);\n\n    // @pragma Construction\n\n    function OrderedMap(value) {\n      return value === null || value === undefined ? emptyOrderedMap() :\n        isOrderedMap(value) ? value :\n        emptyOrderedMap().withMutations(function(map ) {\n          var iter = KeyedIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v, k)  {return map.set(k, v)});\n        });\n    }\n\n    OrderedMap.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    OrderedMap.prototype.toString = function() {\n      return this.__toString('OrderedMap {', '}');\n    };\n\n    // @pragma Access\n\n    OrderedMap.prototype.get = function(k, notSetValue) {\n      var index = this._map.get(k);\n      return index !== undefined ? this._list.get(index)[1] : notSetValue;\n    };\n\n    // @pragma Modification\n\n    OrderedMap.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._map.clear();\n        this._list.clear();\n        return this;\n      }\n      return emptyOrderedMap();\n    };\n\n    OrderedMap.prototype.set = function(k, v) {\n      return updateOrderedMap(this, k, v);\n    };\n\n    OrderedMap.prototype.remove = function(k) {\n      return updateOrderedMap(this, k, NOT_SET);\n    };\n\n    OrderedMap.prototype.wasAltered = function() {\n      return this._map.wasAltered() || this._list.wasAltered();\n    };\n\n    OrderedMap.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._list.__iterate(\n        function(entry ) {return entry && fn(entry[1], entry[0], this$0)},\n        reverse\n      );\n    };\n\n    OrderedMap.prototype.__iterator = function(type, reverse) {\n      return this._list.fromEntrySeq().__iterator(type, reverse);\n    };\n\n    OrderedMap.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map.__ensureOwner(ownerID);\n      var newList = this._list.__ensureOwner(ownerID);\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        this._list = newList;\n        return this;\n      }\n      return makeOrderedMap(newMap, newList, ownerID, this.__hash);\n    };\n\n\n  function isOrderedMap(maybeOrderedMap) {\n    return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);\n  }\n\n  OrderedMap.isOrderedMap = isOrderedMap;\n\n  OrderedMap.prototype[IS_ORDERED_SENTINEL] = true;\n  OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;\n\n\n\n  function makeOrderedMap(map, list, ownerID, hash) {\n    var omap = Object.create(OrderedMap.prototype);\n    omap.size = map ? map.size : 0;\n    omap._map = map;\n    omap._list = list;\n    omap.__ownerID = ownerID;\n    omap.__hash = hash;\n    return omap;\n  }\n\n  var EMPTY_ORDERED_MAP;\n  function emptyOrderedMap() {\n    return EMPTY_ORDERED_MAP || (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()));\n  }\n\n  function updateOrderedMap(omap, k, v) {\n    var map = omap._map;\n    var list = omap._list;\n    var i = map.get(k);\n    var has = i !== undefined;\n    var newMap;\n    var newList;\n    if (v === NOT_SET) { // removed\n      if (!has) {\n        return omap;\n      }\n      if (list.size >= SIZE && list.size >= map.size * 2) {\n        newList = list.filter(function(entry, idx)  {return entry !== undefined && i !== idx});\n        newMap = newList.toKeyedSeq().map(function(entry ) {return entry[0]}).flip().toMap();\n        if (omap.__ownerID) {\n          newMap.__ownerID = newList.__ownerID = omap.__ownerID;\n        }\n      } else {\n        newMap = map.remove(k);\n        newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);\n      }\n    } else {\n      if (has) {\n        if (v === list.get(i)[1]) {\n          return omap;\n        }\n        newMap = map;\n        newList = list.set(i, [k, v]);\n      } else {\n        newMap = map.set(k, list.size);\n        newList = list.set(list.size, [k, v]);\n      }\n    }\n    if (omap.__ownerID) {\n      omap.size = newMap.size;\n      omap._map = newMap;\n      omap._list = newList;\n      omap.__hash = undefined;\n      return omap;\n    }\n    return makeOrderedMap(newMap, newList);\n  }\n\n  createClass(ToKeyedSequence, KeyedSeq);\n    function ToKeyedSequence(indexed, useKeys) {\n      this._iter = indexed;\n      this._useKeys = useKeys;\n      this.size = indexed.size;\n    }\n\n    ToKeyedSequence.prototype.get = function(key, notSetValue) {\n      return this._iter.get(key, notSetValue);\n    };\n\n    ToKeyedSequence.prototype.has = function(key) {\n      return this._iter.has(key);\n    };\n\n    ToKeyedSequence.prototype.valueSeq = function() {\n      return this._iter.valueSeq();\n    };\n\n    ToKeyedSequence.prototype.reverse = function() {var this$0 = this;\n      var reversedSequence = reverseFactory(this, true);\n      if (!this._useKeys) {\n        reversedSequence.valueSeq = function()  {return this$0._iter.toSeq().reverse()};\n      }\n      return reversedSequence;\n    };\n\n    ToKeyedSequence.prototype.map = function(mapper, context) {var this$0 = this;\n      var mappedSequence = mapFactory(this, mapper, context);\n      if (!this._useKeys) {\n        mappedSequence.valueSeq = function()  {return this$0._iter.toSeq().map(mapper, context)};\n      }\n      return mappedSequence;\n    };\n\n    ToKeyedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      var ii;\n      return this._iter.__iterate(\n        this._useKeys ?\n          function(v, k)  {return fn(v, k, this$0)} :\n          ((ii = reverse ? resolveSize(this) : 0),\n            function(v ) {return fn(v, reverse ? --ii : ii++, this$0)}),\n        reverse\n      );\n    };\n\n    ToKeyedSequence.prototype.__iterator = function(type, reverse) {\n      if (this._useKeys) {\n        return this._iter.__iterator(type, reverse);\n      }\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      var ii = reverse ? resolveSize(this) : 0;\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step :\n          iteratorValue(type, reverse ? --ii : ii++, step.value, step);\n      });\n    };\n\n  ToKeyedSequence.prototype[IS_ORDERED_SENTINEL] = true;\n\n\n  createClass(ToIndexedSequence, IndexedSeq);\n    function ToIndexedSequence(iter) {\n      this._iter = iter;\n      this.size = iter.size;\n    }\n\n    ToIndexedSequence.prototype.includes = function(value) {\n      return this._iter.includes(value);\n    };\n\n    ToIndexedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      return this._iter.__iterate(function(v ) {return fn(v, iterations++, this$0)}, reverse);\n    };\n\n    ToIndexedSequence.prototype.__iterator = function(type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      var iterations = 0;\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step :\n          iteratorValue(type, iterations++, step.value, step)\n      });\n    };\n\n\n\n  createClass(ToSetSequence, SetSeq);\n    function ToSetSequence(iter) {\n      this._iter = iter;\n      this.size = iter.size;\n    }\n\n    ToSetSequence.prototype.has = function(key) {\n      return this._iter.includes(key);\n    };\n\n    ToSetSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._iter.__iterate(function(v ) {return fn(v, v, this$0)}, reverse);\n    };\n\n    ToSetSequence.prototype.__iterator = function(type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step :\n          iteratorValue(type, step.value, step.value, step);\n      });\n    };\n\n\n\n  createClass(FromEntriesSequence, KeyedSeq);\n    function FromEntriesSequence(entries) {\n      this._iter = entries;\n      this.size = entries.size;\n    }\n\n    FromEntriesSequence.prototype.entrySeq = function() {\n      return this._iter.toSeq();\n    };\n\n    FromEntriesSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._iter.__iterate(function(entry ) {\n        // Check if entry exists first so array access doesn't throw for holes\n        // in the parent iteration.\n        if (entry) {\n          validateEntry(entry);\n          var indexedIterable = isIterable(entry);\n          return fn(\n            indexedIterable ? entry.get(1) : entry[1],\n            indexedIterable ? entry.get(0) : entry[0],\n            this$0\n          );\n        }\n      }, reverse);\n    };\n\n    FromEntriesSequence.prototype.__iterator = function(type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      return new Iterator(function()  {\n        while (true) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          var entry = step.value;\n          // Check if entry exists first so array access doesn't throw for holes\n          // in the parent iteration.\n          if (entry) {\n            validateEntry(entry);\n            var indexedIterable = isIterable(entry);\n            return iteratorValue(\n              type,\n              indexedIterable ? entry.get(0) : entry[0],\n              indexedIterable ? entry.get(1) : entry[1],\n              step\n            );\n          }\n        }\n      });\n    };\n\n\n  ToIndexedSequence.prototype.cacheResult =\n  ToKeyedSequence.prototype.cacheResult =\n  ToSetSequence.prototype.cacheResult =\n  FromEntriesSequence.prototype.cacheResult =\n    cacheResultThrough;\n\n\n  function flipFactory(iterable) {\n    var flipSequence = makeSequence(iterable);\n    flipSequence._iter = iterable;\n    flipSequence.size = iterable.size;\n    flipSequence.flip = function()  {return iterable};\n    flipSequence.reverse = function () {\n      var reversedSequence = iterable.reverse.apply(this); // super.reverse()\n      reversedSequence.flip = function()  {return iterable.reverse()};\n      return reversedSequence;\n    };\n    flipSequence.has = function(key ) {return iterable.includes(key)};\n    flipSequence.includes = function(key ) {return iterable.has(key)};\n    flipSequence.cacheResult = cacheResultThrough;\n    flipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      return iterable.__iterate(function(v, k)  {return fn(k, v, this$0) !== false}, reverse);\n    }\n    flipSequence.__iteratorUncached = function(type, reverse) {\n      if (type === ITERATE_ENTRIES) {\n        var iterator = iterable.__iterator(type, reverse);\n        return new Iterator(function()  {\n          var step = iterator.next();\n          if (!step.done) {\n            var k = step.value[0];\n            step.value[0] = step.value[1];\n            step.value[1] = k;\n          }\n          return step;\n        });\n      }\n      return iterable.__iterator(\n        type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,\n        reverse\n      );\n    }\n    return flipSequence;\n  }\n\n\n  function mapFactory(iterable, mapper, context) {\n    var mappedSequence = makeSequence(iterable);\n    mappedSequence.size = iterable.size;\n    mappedSequence.has = function(key ) {return iterable.has(key)};\n    mappedSequence.get = function(key, notSetValue)  {\n      var v = iterable.get(key, NOT_SET);\n      return v === NOT_SET ?\n        notSetValue :\n        mapper.call(context, v, key, iterable);\n    };\n    mappedSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      return iterable.__iterate(\n        function(v, k, c)  {return fn(mapper.call(context, v, k, c), k, this$0) !== false},\n        reverse\n      );\n    }\n    mappedSequence.__iteratorUncached = function (type, reverse) {\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      return new Iterator(function()  {\n        var step = iterator.next();\n        if (step.done) {\n          return step;\n        }\n        var entry = step.value;\n        var key = entry[0];\n        return iteratorValue(\n          type,\n          key,\n          mapper.call(context, entry[1], key, iterable),\n          step\n        );\n      });\n    }\n    return mappedSequence;\n  }\n\n\n  function reverseFactory(iterable, useKeys) {\n    var reversedSequence = makeSequence(iterable);\n    reversedSequence._iter = iterable;\n    reversedSequence.size = iterable.size;\n    reversedSequence.reverse = function()  {return iterable};\n    if (iterable.flip) {\n      reversedSequence.flip = function () {\n        var flipSequence = flipFactory(iterable);\n        flipSequence.reverse = function()  {return iterable.flip()};\n        return flipSequence;\n      };\n    }\n    reversedSequence.get = function(key, notSetValue) \n      {return iterable.get(useKeys ? key : -1 - key, notSetValue)};\n    reversedSequence.has = function(key )\n      {return iterable.has(useKeys ? key : -1 - key)};\n    reversedSequence.includes = function(value ) {return iterable.includes(value)};\n    reversedSequence.cacheResult = cacheResultThrough;\n    reversedSequence.__iterate = function (fn, reverse) {var this$0 = this;\n      return iterable.__iterate(function(v, k)  {return fn(v, k, this$0)}, !reverse);\n    };\n    reversedSequence.__iterator =\n      function(type, reverse)  {return iterable.__iterator(type, !reverse)};\n    return reversedSequence;\n  }\n\n\n  function filterFactory(iterable, predicate, context, useKeys) {\n    var filterSequence = makeSequence(iterable);\n    if (useKeys) {\n      filterSequence.has = function(key ) {\n        var v = iterable.get(key, NOT_SET);\n        return v !== NOT_SET && !!predicate.call(context, v, key, iterable);\n      };\n      filterSequence.get = function(key, notSetValue)  {\n        var v = iterable.get(key, NOT_SET);\n        return v !== NOT_SET && predicate.call(context, v, key, iterable) ?\n          v : notSetValue;\n      };\n    }\n    filterSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      iterable.__iterate(function(v, k, c)  {\n        if (predicate.call(context, v, k, c)) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$0);\n        }\n      }, reverse);\n      return iterations;\n    };\n    filterSequence.__iteratorUncached = function (type, reverse) {\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      var iterations = 0;\n      return new Iterator(function()  {\n        while (true) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          var entry = step.value;\n          var key = entry[0];\n          var value = entry[1];\n          if (predicate.call(context, value, key, iterable)) {\n            return iteratorValue(type, useKeys ? key : iterations++, value, step);\n          }\n        }\n      });\n    }\n    return filterSequence;\n  }\n\n\n  function countByFactory(iterable, grouper, context) {\n    var groups = Map().asMutable();\n    iterable.__iterate(function(v, k)  {\n      groups.update(\n        grouper.call(context, v, k, iterable),\n        0,\n        function(a ) {return a + 1}\n      );\n    });\n    return groups.asImmutable();\n  }\n\n\n  function groupByFactory(iterable, grouper, context) {\n    var isKeyedIter = isKeyed(iterable);\n    var groups = (isOrdered(iterable) ? OrderedMap() : Map()).asMutable();\n    iterable.__iterate(function(v, k)  {\n      groups.update(\n        grouper.call(context, v, k, iterable),\n        function(a ) {return (a = a || [], a.push(isKeyedIter ? [k, v] : v), a)}\n      );\n    });\n    var coerce = iterableClass(iterable);\n    return groups.map(function(arr ) {return reify(iterable, coerce(arr))});\n  }\n\n\n  function sliceFactory(iterable, begin, end, useKeys) {\n    var originalSize = iterable.size;\n\n    // Sanitize begin & end using this shorthand for ToInt32(argument)\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n    if (begin !== undefined) {\n      begin = begin | 0;\n    }\n    if (end !== undefined) {\n      end = end | 0;\n    }\n\n    if (wholeSlice(begin, end, originalSize)) {\n      return iterable;\n    }\n\n    var resolvedBegin = resolveBegin(begin, originalSize);\n    var resolvedEnd = resolveEnd(end, originalSize);\n\n    // begin or end will be NaN if they were provided as negative numbers and\n    // this iterable's size is unknown. In that case, cache first so there is\n    // a known size and these do not resolve to NaN.\n    if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {\n      return sliceFactory(iterable.toSeq().cacheResult(), begin, end, useKeys);\n    }\n\n    // Note: resolvedEnd is undefined when the original sequence's length is\n    // unknown and this slice did not supply an end and should contain all\n    // elements after resolvedBegin.\n    // In that case, resolvedSize will be NaN and sliceSize will remain undefined.\n    var resolvedSize = resolvedEnd - resolvedBegin;\n    var sliceSize;\n    if (resolvedSize === resolvedSize) {\n      sliceSize = resolvedSize < 0 ? 0 : resolvedSize;\n    }\n\n    var sliceSeq = makeSequence(iterable);\n\n    // If iterable.size is undefined, the size of the realized sliceSeq is\n    // unknown at this point unless the number of items to slice is 0\n    sliceSeq.size = sliceSize === 0 ? sliceSize : iterable.size && sliceSize || undefined;\n\n    if (!useKeys && isSeq(iterable) && sliceSize >= 0) {\n      sliceSeq.get = function (index, notSetValue) {\n        index = wrapIndex(this, index);\n        return index >= 0 && index < sliceSize ?\n          iterable.get(index + resolvedBegin, notSetValue) :\n          notSetValue;\n      }\n    }\n\n    sliceSeq.__iterateUncached = function(fn, reverse) {var this$0 = this;\n      if (sliceSize === 0) {\n        return 0;\n      }\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var skipped = 0;\n      var isSkipping = true;\n      var iterations = 0;\n      iterable.__iterate(function(v, k)  {\n        if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$0) !== false &&\n                 iterations !== sliceSize;\n        }\n      });\n      return iterations;\n    };\n\n    sliceSeq.__iteratorUncached = function(type, reverse) {\n      if (sliceSize !== 0 && reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      // Don't bother instantiating parent iterator if taking 0.\n      var iterator = sliceSize !== 0 && iterable.__iterator(type, reverse);\n      var skipped = 0;\n      var iterations = 0;\n      return new Iterator(function()  {\n        while (skipped++ < resolvedBegin) {\n          iterator.next();\n        }\n        if (++iterations > sliceSize) {\n          return iteratorDone();\n        }\n        var step = iterator.next();\n        if (useKeys || type === ITERATE_VALUES) {\n          return step;\n        } else if (type === ITERATE_KEYS) {\n          return iteratorValue(type, iterations - 1, undefined, step);\n        } else {\n          return iteratorValue(type, iterations - 1, step.value[1], step);\n        }\n      });\n    }\n\n    return sliceSeq;\n  }\n\n\n  function takeWhileFactory(iterable, predicate, context) {\n    var takeSequence = makeSequence(iterable);\n    takeSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterations = 0;\n      iterable.__iterate(function(v, k, c) \n        {return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$0)}\n      );\n      return iterations;\n    };\n    takeSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      var iterating = true;\n      return new Iterator(function()  {\n        if (!iterating) {\n          return iteratorDone();\n        }\n        var step = iterator.next();\n        if (step.done) {\n          return step;\n        }\n        var entry = step.value;\n        var k = entry[0];\n        var v = entry[1];\n        if (!predicate.call(context, v, k, this$0)) {\n          iterating = false;\n          return iteratorDone();\n        }\n        return type === ITERATE_ENTRIES ? step :\n          iteratorValue(type, k, v, step);\n      });\n    };\n    return takeSequence;\n  }\n\n\n  function skipWhileFactory(iterable, predicate, context, useKeys) {\n    var skipSequence = makeSequence(iterable);\n    skipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var isSkipping = true;\n      var iterations = 0;\n      iterable.__iterate(function(v, k, c)  {\n        if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$0);\n        }\n      });\n      return iterations;\n    };\n    skipSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      var skipping = true;\n      var iterations = 0;\n      return new Iterator(function()  {\n        var step, k, v;\n        do {\n          step = iterator.next();\n          if (step.done) {\n            if (useKeys || type === ITERATE_VALUES) {\n              return step;\n            } else if (type === ITERATE_KEYS) {\n              return iteratorValue(type, iterations++, undefined, step);\n            } else {\n              return iteratorValue(type, iterations++, step.value[1], step);\n            }\n          }\n          var entry = step.value;\n          k = entry[0];\n          v = entry[1];\n          skipping && (skipping = predicate.call(context, v, k, this$0));\n        } while (skipping);\n        return type === ITERATE_ENTRIES ? step :\n          iteratorValue(type, k, v, step);\n      });\n    };\n    return skipSequence;\n  }\n\n\n  function concatFactory(iterable, values) {\n    var isKeyedIterable = isKeyed(iterable);\n    var iters = [iterable].concat(values).map(function(v ) {\n      if (!isIterable(v)) {\n        v = isKeyedIterable ?\n          keyedSeqFromValue(v) :\n          indexedSeqFromValue(Array.isArray(v) ? v : [v]);\n      } else if (isKeyedIterable) {\n        v = KeyedIterable(v);\n      }\n      return v;\n    }).filter(function(v ) {return v.size !== 0});\n\n    if (iters.length === 0) {\n      return iterable;\n    }\n\n    if (iters.length === 1) {\n      var singleton = iters[0];\n      if (singleton === iterable ||\n          isKeyedIterable && isKeyed(singleton) ||\n          isIndexed(iterable) && isIndexed(singleton)) {\n        return singleton;\n      }\n    }\n\n    var concatSeq = new ArraySeq(iters);\n    if (isKeyedIterable) {\n      concatSeq = concatSeq.toKeyedSeq();\n    } else if (!isIndexed(iterable)) {\n      concatSeq = concatSeq.toSetSeq();\n    }\n    concatSeq = concatSeq.flatten(true);\n    concatSeq.size = iters.reduce(\n      function(sum, seq)  {\n        if (sum !== undefined) {\n          var size = seq.size;\n          if (size !== undefined) {\n            return sum + size;\n          }\n        }\n      },\n      0\n    );\n    return concatSeq;\n  }\n\n\n  function flattenFactory(iterable, depth, useKeys) {\n    var flatSequence = makeSequence(iterable);\n    flatSequence.__iterateUncached = function(fn, reverse) {\n      var iterations = 0;\n      var stopped = false;\n      function flatDeep(iter, currentDepth) {var this$0 = this;\n        iter.__iterate(function(v, k)  {\n          if ((!depth || currentDepth < depth) && isIterable(v)) {\n            flatDeep(v, currentDepth + 1);\n          } else if (fn(v, useKeys ? k : iterations++, this$0) === false) {\n            stopped = true;\n          }\n          return !stopped;\n        }, reverse);\n      }\n      flatDeep(iterable, 0);\n      return iterations;\n    }\n    flatSequence.__iteratorUncached = function(type, reverse) {\n      var iterator = iterable.__iterator(type, reverse);\n      var stack = [];\n      var iterations = 0;\n      return new Iterator(function()  {\n        while (iterator) {\n          var step = iterator.next();\n          if (step.done !== false) {\n            iterator = stack.pop();\n            continue;\n          }\n          var v = step.value;\n          if (type === ITERATE_ENTRIES) {\n            v = v[1];\n          }\n          if ((!depth || stack.length < depth) && isIterable(v)) {\n            stack.push(iterator);\n            iterator = v.__iterator(type, reverse);\n          } else {\n            return useKeys ? step : iteratorValue(type, iterations++, v, step);\n          }\n        }\n        return iteratorDone();\n      });\n    }\n    return flatSequence;\n  }\n\n\n  function flatMapFactory(iterable, mapper, context) {\n    var coerce = iterableClass(iterable);\n    return iterable.toSeq().map(\n      function(v, k)  {return coerce(mapper.call(context, v, k, iterable))}\n    ).flatten(true);\n  }\n\n\n  function interposeFactory(iterable, separator) {\n    var interposedSequence = makeSequence(iterable);\n    interposedSequence.size = iterable.size && iterable.size * 2 -1;\n    interposedSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      iterable.__iterate(function(v, k) \n        {return (!iterations || fn(separator, iterations++, this$0) !== false) &&\n        fn(v, iterations++, this$0) !== false},\n        reverse\n      );\n      return iterations;\n    };\n    interposedSequence.__iteratorUncached = function(type, reverse) {\n      var iterator = iterable.__iterator(ITERATE_VALUES, reverse);\n      var iterations = 0;\n      var step;\n      return new Iterator(function()  {\n        if (!step || iterations % 2) {\n          step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n        }\n        return iterations % 2 ?\n          iteratorValue(type, iterations++, separator) :\n          iteratorValue(type, iterations++, step.value, step);\n      });\n    };\n    return interposedSequence;\n  }\n\n\n  function sortFactory(iterable, comparator, mapper) {\n    if (!comparator) {\n      comparator = defaultComparator;\n    }\n    var isKeyedIterable = isKeyed(iterable);\n    var index = 0;\n    var entries = iterable.toSeq().map(\n      function(v, k)  {return [k, v, index++, mapper ? mapper(v, k, iterable) : v]}\n    ).toArray();\n    entries.sort(function(a, b)  {return comparator(a[3], b[3]) || a[2] - b[2]}).forEach(\n      isKeyedIterable ?\n      function(v, i)  { entries[i].length = 2; } :\n      function(v, i)  { entries[i] = v[1]; }\n    );\n    return isKeyedIterable ? KeyedSeq(entries) :\n      isIndexed(iterable) ? IndexedSeq(entries) :\n      SetSeq(entries);\n  }\n\n\n  function maxFactory(iterable, comparator, mapper) {\n    if (!comparator) {\n      comparator = defaultComparator;\n    }\n    if (mapper) {\n      var entry = iterable.toSeq()\n        .map(function(v, k)  {return [v, mapper(v, k, iterable)]})\n        .reduce(function(a, b)  {return maxCompare(comparator, a[1], b[1]) ? b : a});\n      return entry && entry[0];\n    } else {\n      return iterable.reduce(function(a, b)  {return maxCompare(comparator, a, b) ? b : a});\n    }\n  }\n\n  function maxCompare(comparator, a, b) {\n    var comp = comparator(b, a);\n    // b is considered the new max if the comparator declares them equal, but\n    // they are not equal and b is in fact a nullish value.\n    return (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) || comp > 0;\n  }\n\n\n  function zipWithFactory(keyIter, zipper, iters) {\n    var zipSequence = makeSequence(keyIter);\n    zipSequence.size = new ArraySeq(iters).map(function(i ) {return i.size}).min();\n    // Note: this a generic base implementation of __iterate in terms of\n    // __iterator which may be more generically useful in the future.\n    zipSequence.__iterate = function(fn, reverse) {\n      /* generic:\n      var iterator = this.__iterator(ITERATE_ENTRIES, reverse);\n      var step;\n      var iterations = 0;\n      while (!(step = iterator.next()).done) {\n        iterations++;\n        if (fn(step.value[1], step.value[0], this) === false) {\n          break;\n        }\n      }\n      return iterations;\n      */\n      // indexed:\n      var iterator = this.__iterator(ITERATE_VALUES, reverse);\n      var step;\n      var iterations = 0;\n      while (!(step = iterator.next()).done) {\n        if (fn(step.value, iterations++, this) === false) {\n          break;\n        }\n      }\n      return iterations;\n    };\n    zipSequence.__iteratorUncached = function(type, reverse) {\n      var iterators = iters.map(function(i )\n        {return (i = Iterable(i), getIterator(reverse ? i.reverse() : i))}\n      );\n      var iterations = 0;\n      var isDone = false;\n      return new Iterator(function()  {\n        var steps;\n        if (!isDone) {\n          steps = iterators.map(function(i ) {return i.next()});\n          isDone = steps.some(function(s ) {return s.done});\n        }\n        if (isDone) {\n          return iteratorDone();\n        }\n        return iteratorValue(\n          type,\n          iterations++,\n          zipper.apply(null, steps.map(function(s ) {return s.value}))\n        );\n      });\n    };\n    return zipSequence\n  }\n\n\n  // #pragma Helper Functions\n\n  function reify(iter, seq) {\n    return isSeq(iter) ? seq : iter.constructor(seq);\n  }\n\n  function validateEntry(entry) {\n    if (entry !== Object(entry)) {\n      throw new TypeError('Expected [K, V] tuple: ' + entry);\n    }\n  }\n\n  function resolveSize(iter) {\n    assertNotInfinite(iter.size);\n    return ensureSize(iter);\n  }\n\n  function iterableClass(iterable) {\n    return isKeyed(iterable) ? KeyedIterable :\n      isIndexed(iterable) ? IndexedIterable :\n      SetIterable;\n  }\n\n  function makeSequence(iterable) {\n    return Object.create(\n      (\n        isKeyed(iterable) ? KeyedSeq :\n        isIndexed(iterable) ? IndexedSeq :\n        SetSeq\n      ).prototype\n    );\n  }\n\n  function cacheResultThrough() {\n    if (this._iter.cacheResult) {\n      this._iter.cacheResult();\n      this.size = this._iter.size;\n      return this;\n    } else {\n      return Seq.prototype.cacheResult.call(this);\n    }\n  }\n\n  function defaultComparator(a, b) {\n    return a > b ? 1 : a < b ? -1 : 0;\n  }\n\n  function forceIterator(keyPath) {\n    var iter = getIterator(keyPath);\n    if (!iter) {\n      // Array might not be iterable in this environment, so we need a fallback\n      // to our wrapped type.\n      if (!isArrayLike(keyPath)) {\n        throw new TypeError('Expected iterable or array-like: ' + keyPath);\n      }\n      iter = getIterator(Iterable(keyPath));\n    }\n    return iter;\n  }\n\n  createClass(Record, KeyedCollection);\n\n    function Record(defaultValues, name) {\n      var hasInitialized;\n\n      var RecordType = function Record(values) {\n        if (values instanceof RecordType) {\n          return values;\n        }\n        if (!(this instanceof RecordType)) {\n          return new RecordType(values);\n        }\n        if (!hasInitialized) {\n          hasInitialized = true;\n          var keys = Object.keys(defaultValues);\n          setProps(RecordTypePrototype, keys);\n          RecordTypePrototype.size = keys.length;\n          RecordTypePrototype._name = name;\n          RecordTypePrototype._keys = keys;\n          RecordTypePrototype._defaultValues = defaultValues;\n        }\n        this._map = Map(values);\n      };\n\n      var RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype);\n      RecordTypePrototype.constructor = RecordType;\n\n      return RecordType;\n    }\n\n    Record.prototype.toString = function() {\n      return this.__toString(recordName(this) + ' {', '}');\n    };\n\n    // @pragma Access\n\n    Record.prototype.has = function(k) {\n      return this._defaultValues.hasOwnProperty(k);\n    };\n\n    Record.prototype.get = function(k, notSetValue) {\n      if (!this.has(k)) {\n        return notSetValue;\n      }\n      var defaultVal = this._defaultValues[k];\n      return this._map ? this._map.get(k, defaultVal) : defaultVal;\n    };\n\n    // @pragma Modification\n\n    Record.prototype.clear = function() {\n      if (this.__ownerID) {\n        this._map && this._map.clear();\n        return this;\n      }\n      var RecordType = this.constructor;\n      return RecordType._empty || (RecordType._empty = makeRecord(this, emptyMap()));\n    };\n\n    Record.prototype.set = function(k, v) {\n      if (!this.has(k)) {\n        throw new Error('Cannot set unknown key \"' + k + '\" on ' + recordName(this));\n      }\n      var newMap = this._map && this._map.set(k, v);\n      if (this.__ownerID || newMap === this._map) {\n        return this;\n      }\n      return makeRecord(this, newMap);\n    };\n\n    Record.prototype.remove = function(k) {\n      if (!this.has(k)) {\n        return this;\n      }\n      var newMap = this._map && this._map.remove(k);\n      if (this.__ownerID || newMap === this._map) {\n        return this;\n      }\n      return makeRecord(this, newMap);\n    };\n\n    Record.prototype.wasAltered = function() {\n      return this._map.wasAltered();\n    };\n\n    Record.prototype.__iterator = function(type, reverse) {var this$0 = this;\n      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterator(type, reverse);\n    };\n\n    Record.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterate(fn, reverse);\n    };\n\n    Record.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map && this._map.__ensureOwner(ownerID);\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        return this;\n      }\n      return makeRecord(this, newMap, ownerID);\n    };\n\n\n  var RecordPrototype = Record.prototype;\n  RecordPrototype[DELETE] = RecordPrototype.remove;\n  RecordPrototype.deleteIn =\n  RecordPrototype.removeIn = MapPrototype.removeIn;\n  RecordPrototype.merge = MapPrototype.merge;\n  RecordPrototype.mergeWith = MapPrototype.mergeWith;\n  RecordPrototype.mergeIn = MapPrototype.mergeIn;\n  RecordPrototype.mergeDeep = MapPrototype.mergeDeep;\n  RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith;\n  RecordPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;\n  RecordPrototype.setIn = MapPrototype.setIn;\n  RecordPrototype.update = MapPrototype.update;\n  RecordPrototype.updateIn = MapPrototype.updateIn;\n  RecordPrototype.withMutations = MapPrototype.withMutations;\n  RecordPrototype.asMutable = MapPrototype.asMutable;\n  RecordPrototype.asImmutable = MapPrototype.asImmutable;\n\n\n  function makeRecord(likeRecord, map, ownerID) {\n    var record = Object.create(Object.getPrototypeOf(likeRecord));\n    record._map = map;\n    record.__ownerID = ownerID;\n    return record;\n  }\n\n  function recordName(record) {\n    return record._name || record.constructor.name || 'Record';\n  }\n\n  function setProps(prototype, names) {\n    try {\n      names.forEach(setProp.bind(undefined, prototype));\n    } catch (error) {\n      // Object.defineProperty failed. Probably IE8.\n    }\n  }\n\n  function setProp(prototype, name) {\n    Object.defineProperty(prototype, name, {\n      get: function() {\n        return this.get(name);\n      },\n      set: function(value) {\n        invariant(this.__ownerID, 'Cannot set on an immutable record.');\n        this.set(name, value);\n      }\n    });\n  }\n\n  createClass(Set, SetCollection);\n\n    // @pragma Construction\n\n    function Set(value) {\n      return value === null || value === undefined ? emptySet() :\n        isSet(value) && !isOrdered(value) ? value :\n        emptySet().withMutations(function(set ) {\n          var iter = SetIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v ) {return set.add(v)});\n        });\n    }\n\n    Set.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    Set.fromKeys = function(value) {\n      return this(KeyedIterable(value).keySeq());\n    };\n\n    Set.prototype.toString = function() {\n      return this.__toString('Set {', '}');\n    };\n\n    // @pragma Access\n\n    Set.prototype.has = function(value) {\n      return this._map.has(value);\n    };\n\n    // @pragma Modification\n\n    Set.prototype.add = function(value) {\n      return updateSet(this, this._map.set(value, true));\n    };\n\n    Set.prototype.remove = function(value) {\n      return updateSet(this, this._map.remove(value));\n    };\n\n    Set.prototype.clear = function() {\n      return updateSet(this, this._map.clear());\n    };\n\n    // @pragma Composition\n\n    Set.prototype.union = function() {var iters = SLICE$0.call(arguments, 0);\n      iters = iters.filter(function(x ) {return x.size !== 0});\n      if (iters.length === 0) {\n        return this;\n      }\n      if (this.size === 0 && !this.__ownerID && iters.length === 1) {\n        return this.constructor(iters[0]);\n      }\n      return this.withMutations(function(set ) {\n        for (var ii = 0; ii < iters.length; ii++) {\n          SetIterable(iters[ii]).forEach(function(value ) {return set.add(value)});\n        }\n      });\n    };\n\n    Set.prototype.intersect = function() {var iters = SLICE$0.call(arguments, 0);\n      if (iters.length === 0) {\n        return this;\n      }\n      iters = iters.map(function(iter ) {return SetIterable(iter)});\n      var originalSet = this;\n      return this.withMutations(function(set ) {\n        originalSet.forEach(function(value ) {\n          if (!iters.every(function(iter ) {return iter.includes(value)})) {\n            set.remove(value);\n          }\n        });\n      });\n    };\n\n    Set.prototype.subtract = function() {var iters = SLICE$0.call(arguments, 0);\n      if (iters.length === 0) {\n        return this;\n      }\n      iters = iters.map(function(iter ) {return SetIterable(iter)});\n      var originalSet = this;\n      return this.withMutations(function(set ) {\n        originalSet.forEach(function(value ) {\n          if (iters.some(function(iter ) {return iter.includes(value)})) {\n            set.remove(value);\n          }\n        });\n      });\n    };\n\n    Set.prototype.merge = function() {\n      return this.union.apply(this, arguments);\n    };\n\n    Set.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return this.union.apply(this, iters);\n    };\n\n    Set.prototype.sort = function(comparator) {\n      // Late binding\n      return OrderedSet(sortFactory(this, comparator));\n    };\n\n    Set.prototype.sortBy = function(mapper, comparator) {\n      // Late binding\n      return OrderedSet(sortFactory(this, comparator, mapper));\n    };\n\n    Set.prototype.wasAltered = function() {\n      return this._map.wasAltered();\n    };\n\n    Set.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._map.__iterate(function(_, k)  {return fn(k, k, this$0)}, reverse);\n    };\n\n    Set.prototype.__iterator = function(type, reverse) {\n      return this._map.map(function(_, k)  {return k}).__iterator(type, reverse);\n    };\n\n    Set.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map.__ensureOwner(ownerID);\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        return this;\n      }\n      return this.__make(newMap, ownerID);\n    };\n\n\n  function isSet(maybeSet) {\n    return !!(maybeSet && maybeSet[IS_SET_SENTINEL]);\n  }\n\n  Set.isSet = isSet;\n\n  var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';\n\n  var SetPrototype = Set.prototype;\n  SetPrototype[IS_SET_SENTINEL] = true;\n  SetPrototype[DELETE] = SetPrototype.remove;\n  SetPrototype.mergeDeep = SetPrototype.merge;\n  SetPrototype.mergeDeepWith = SetPrototype.mergeWith;\n  SetPrototype.withMutations = MapPrototype.withMutations;\n  SetPrototype.asMutable = MapPrototype.asMutable;\n  SetPrototype.asImmutable = MapPrototype.asImmutable;\n\n  SetPrototype.__empty = emptySet;\n  SetPrototype.__make = makeSet;\n\n  function updateSet(set, newMap) {\n    if (set.__ownerID) {\n      set.size = newMap.size;\n      set._map = newMap;\n      return set;\n    }\n    return newMap === set._map ? set :\n      newMap.size === 0 ? set.__empty() :\n      set.__make(newMap);\n  }\n\n  function makeSet(map, ownerID) {\n    var set = Object.create(SetPrototype);\n    set.size = map ? map.size : 0;\n    set._map = map;\n    set.__ownerID = ownerID;\n    return set;\n  }\n\n  var EMPTY_SET;\n  function emptySet() {\n    return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));\n  }\n\n  createClass(OrderedSet, Set);\n\n    // @pragma Construction\n\n    function OrderedSet(value) {\n      return value === null || value === undefined ? emptyOrderedSet() :\n        isOrderedSet(value) ? value :\n        emptyOrderedSet().withMutations(function(set ) {\n          var iter = SetIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v ) {return set.add(v)});\n        });\n    }\n\n    OrderedSet.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    OrderedSet.fromKeys = function(value) {\n      return this(KeyedIterable(value).keySeq());\n    };\n\n    OrderedSet.prototype.toString = function() {\n      return this.__toString('OrderedSet {', '}');\n    };\n\n\n  function isOrderedSet(maybeOrderedSet) {\n    return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);\n  }\n\n  OrderedSet.isOrderedSet = isOrderedSet;\n\n  var OrderedSetPrototype = OrderedSet.prototype;\n  OrderedSetPrototype[IS_ORDERED_SENTINEL] = true;\n\n  OrderedSetPrototype.__empty = emptyOrderedSet;\n  OrderedSetPrototype.__make = makeOrderedSet;\n\n  function makeOrderedSet(map, ownerID) {\n    var set = Object.create(OrderedSetPrototype);\n    set.size = map ? map.size : 0;\n    set._map = map;\n    set.__ownerID = ownerID;\n    return set;\n  }\n\n  var EMPTY_ORDERED_SET;\n  function emptyOrderedSet() {\n    return EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()));\n  }\n\n  createClass(Stack, IndexedCollection);\n\n    // @pragma Construction\n\n    function Stack(value) {\n      return value === null || value === undefined ? emptyStack() :\n        isStack(value) ? value :\n        emptyStack().unshiftAll(value);\n    }\n\n    Stack.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    Stack.prototype.toString = function() {\n      return this.__toString('Stack [', ']');\n    };\n\n    // @pragma Access\n\n    Stack.prototype.get = function(index, notSetValue) {\n      var head = this._head;\n      index = wrapIndex(this, index);\n      while (head && index--) {\n        head = head.next;\n      }\n      return head ? head.value : notSetValue;\n    };\n\n    Stack.prototype.peek = function() {\n      return this._head && this._head.value;\n    };\n\n    // @pragma Modification\n\n    Stack.prototype.push = function(/*...values*/) {\n      if (arguments.length === 0) {\n        return this;\n      }\n      var newSize = this.size + arguments.length;\n      var head = this._head;\n      for (var ii = arguments.length - 1; ii >= 0; ii--) {\n        head = {\n          value: arguments[ii],\n          next: head\n        };\n      }\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    Stack.prototype.pushAll = function(iter) {\n      iter = IndexedIterable(iter);\n      if (iter.size === 0) {\n        return this;\n      }\n      assertNotInfinite(iter.size);\n      var newSize = this.size;\n      var head = this._head;\n      iter.reverse().forEach(function(value ) {\n        newSize++;\n        head = {\n          value: value,\n          next: head\n        };\n      });\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    Stack.prototype.pop = function() {\n      return this.slice(1);\n    };\n\n    Stack.prototype.unshift = function(/*...values*/) {\n      return this.push.apply(this, arguments);\n    };\n\n    Stack.prototype.unshiftAll = function(iter) {\n      return this.pushAll(iter);\n    };\n\n    Stack.prototype.shift = function() {\n      return this.pop.apply(this, arguments);\n    };\n\n    Stack.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._head = undefined;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyStack();\n    };\n\n    Stack.prototype.slice = function(begin, end) {\n      if (wholeSlice(begin, end, this.size)) {\n        return this;\n      }\n      var resolvedBegin = resolveBegin(begin, this.size);\n      var resolvedEnd = resolveEnd(end, this.size);\n      if (resolvedEnd !== this.size) {\n        // super.slice(begin, end);\n        return IndexedCollection.prototype.slice.call(this, begin, end);\n      }\n      var newSize = this.size - resolvedBegin;\n      var head = this._head;\n      while (resolvedBegin--) {\n        head = head.next;\n      }\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    // @pragma Mutability\n\n    Stack.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this.__altered = false;\n        return this;\n      }\n      return makeStack(this.size, this._head, ownerID, this.__hash);\n    };\n\n    // @pragma Iteration\n\n    Stack.prototype.__iterate = function(fn, reverse) {\n      if (reverse) {\n        return this.reverse().__iterate(fn);\n      }\n      var iterations = 0;\n      var node = this._head;\n      while (node) {\n        if (fn(node.value, iterations++, this) === false) {\n          break;\n        }\n        node = node.next;\n      }\n      return iterations;\n    };\n\n    Stack.prototype.__iterator = function(type, reverse) {\n      if (reverse) {\n        return this.reverse().__iterator(type);\n      }\n      var iterations = 0;\n      var node = this._head;\n      return new Iterator(function()  {\n        if (node) {\n          var value = node.value;\n          node = node.next;\n          return iteratorValue(type, iterations++, value);\n        }\n        return iteratorDone();\n      });\n    };\n\n\n  function isStack(maybeStack) {\n    return !!(maybeStack && maybeStack[IS_STACK_SENTINEL]);\n  }\n\n  Stack.isStack = isStack;\n\n  var IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';\n\n  var StackPrototype = Stack.prototype;\n  StackPrototype[IS_STACK_SENTINEL] = true;\n  StackPrototype.withMutations = MapPrototype.withMutations;\n  StackPrototype.asMutable = MapPrototype.asMutable;\n  StackPrototype.asImmutable = MapPrototype.asImmutable;\n  StackPrototype.wasAltered = MapPrototype.wasAltered;\n\n\n  function makeStack(size, head, ownerID, hash) {\n    var map = Object.create(StackPrototype);\n    map.size = size;\n    map._head = head;\n    map.__ownerID = ownerID;\n    map.__hash = hash;\n    map.__altered = false;\n    return map;\n  }\n\n  var EMPTY_STACK;\n  function emptyStack() {\n    return EMPTY_STACK || (EMPTY_STACK = makeStack(0));\n  }\n\n  /**\n   * Contributes additional methods to a constructor\n   */\n  function mixin(ctor, methods) {\n    var keyCopier = function(key ) { ctor.prototype[key] = methods[key]; };\n    Object.keys(methods).forEach(keyCopier);\n    Object.getOwnPropertySymbols &&\n      Object.getOwnPropertySymbols(methods).forEach(keyCopier);\n    return ctor;\n  }\n\n  Iterable.Iterator = Iterator;\n\n  mixin(Iterable, {\n\n    // ### Conversion to other types\n\n    toArray: function() {\n      assertNotInfinite(this.size);\n      var array = new Array(this.size || 0);\n      this.valueSeq().__iterate(function(v, i)  { array[i] = v; });\n      return array;\n    },\n\n    toIndexedSeq: function() {\n      return new ToIndexedSequence(this);\n    },\n\n    toJS: function() {\n      return this.toSeq().map(\n        function(value ) {return value && typeof value.toJS === 'function' ? value.toJS() : value}\n      ).__toJS();\n    },\n\n    toJSON: function() {\n      return this.toSeq().map(\n        function(value ) {return value && typeof value.toJSON === 'function' ? value.toJSON() : value}\n      ).__toJS();\n    },\n\n    toKeyedSeq: function() {\n      return new ToKeyedSequence(this, true);\n    },\n\n    toMap: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return Map(this.toKeyedSeq());\n    },\n\n    toObject: function() {\n      assertNotInfinite(this.size);\n      var object = {};\n      this.__iterate(function(v, k)  { object[k] = v; });\n      return object;\n    },\n\n    toOrderedMap: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return OrderedMap(this.toKeyedSeq());\n    },\n\n    toOrderedSet: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return OrderedSet(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toSet: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return Set(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toSetSeq: function() {\n      return new ToSetSequence(this);\n    },\n\n    toSeq: function() {\n      return isIndexed(this) ? this.toIndexedSeq() :\n        isKeyed(this) ? this.toKeyedSeq() :\n        this.toSetSeq();\n    },\n\n    toStack: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return Stack(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toList: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return List(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n\n    // ### Common JavaScript methods and properties\n\n    toString: function() {\n      return '[Iterable]';\n    },\n\n    __toString: function(head, tail) {\n      if (this.size === 0) {\n        return head + tail;\n      }\n      return head + ' ' + this.toSeq().map(this.__toStringMapper).join(', ') + ' ' + tail;\n    },\n\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    concat: function() {var values = SLICE$0.call(arguments, 0);\n      return reify(this, concatFactory(this, values));\n    },\n\n    includes: function(searchValue) {\n      return this.some(function(value ) {return is(value, searchValue)});\n    },\n\n    entries: function() {\n      return this.__iterator(ITERATE_ENTRIES);\n    },\n\n    every: function(predicate, context) {\n      assertNotInfinite(this.size);\n      var returnValue = true;\n      this.__iterate(function(v, k, c)  {\n        if (!predicate.call(context, v, k, c)) {\n          returnValue = false;\n          return false;\n        }\n      });\n      return returnValue;\n    },\n\n    filter: function(predicate, context) {\n      return reify(this, filterFactory(this, predicate, context, true));\n    },\n\n    find: function(predicate, context, notSetValue) {\n      var entry = this.findEntry(predicate, context);\n      return entry ? entry[1] : notSetValue;\n    },\n\n    findEntry: function(predicate, context) {\n      var found;\n      this.__iterate(function(v, k, c)  {\n        if (predicate.call(context, v, k, c)) {\n          found = [k, v];\n          return false;\n        }\n      });\n      return found;\n    },\n\n    findLastEntry: function(predicate, context) {\n      return this.toSeq().reverse().findEntry(predicate, context);\n    },\n\n    forEach: function(sideEffect, context) {\n      assertNotInfinite(this.size);\n      return this.__iterate(context ? sideEffect.bind(context) : sideEffect);\n    },\n\n    join: function(separator) {\n      assertNotInfinite(this.size);\n      separator = separator !== undefined ? '' + separator : ',';\n      var joined = '';\n      var isFirst = true;\n      this.__iterate(function(v ) {\n        isFirst ? (isFirst = false) : (joined += separator);\n        joined += v !== null && v !== undefined ? v.toString() : '';\n      });\n      return joined;\n    },\n\n    keys: function() {\n      return this.__iterator(ITERATE_KEYS);\n    },\n\n    map: function(mapper, context) {\n      return reify(this, mapFactory(this, mapper, context));\n    },\n\n    reduce: function(reducer, initialReduction, context) {\n      assertNotInfinite(this.size);\n      var reduction;\n      var useFirst;\n      if (arguments.length < 2) {\n        useFirst = true;\n      } else {\n        reduction = initialReduction;\n      }\n      this.__iterate(function(v, k, c)  {\n        if (useFirst) {\n          useFirst = false;\n          reduction = v;\n        } else {\n          reduction = reducer.call(context, reduction, v, k, c);\n        }\n      });\n      return reduction;\n    },\n\n    reduceRight: function(reducer, initialReduction, context) {\n      var reversed = this.toKeyedSeq().reverse();\n      return reversed.reduce.apply(reversed, arguments);\n    },\n\n    reverse: function() {\n      return reify(this, reverseFactory(this, true));\n    },\n\n    slice: function(begin, end) {\n      return reify(this, sliceFactory(this, begin, end, true));\n    },\n\n    some: function(predicate, context) {\n      return !this.every(not(predicate), context);\n    },\n\n    sort: function(comparator) {\n      return reify(this, sortFactory(this, comparator));\n    },\n\n    values: function() {\n      return this.__iterator(ITERATE_VALUES);\n    },\n\n\n    // ### More sequential methods\n\n    butLast: function() {\n      return this.slice(0, -1);\n    },\n\n    isEmpty: function() {\n      return this.size !== undefined ? this.size === 0 : !this.some(function()  {return true});\n    },\n\n    count: function(predicate, context) {\n      return ensureSize(\n        predicate ? this.toSeq().filter(predicate, context) : this\n      );\n    },\n\n    countBy: function(grouper, context) {\n      return countByFactory(this, grouper, context);\n    },\n\n    equals: function(other) {\n      return deepEqual(this, other);\n    },\n\n    entrySeq: function() {\n      var iterable = this;\n      if (iterable._cache) {\n        // We cache as an entries array, so we can just return the cache!\n        return new ArraySeq(iterable._cache);\n      }\n      var entriesSequence = iterable.toSeq().map(entryMapper).toIndexedSeq();\n      entriesSequence.fromEntrySeq = function()  {return iterable.toSeq()};\n      return entriesSequence;\n    },\n\n    filterNot: function(predicate, context) {\n      return this.filter(not(predicate), context);\n    },\n\n    findLast: function(predicate, context, notSetValue) {\n      return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);\n    },\n\n    first: function() {\n      return this.find(returnTrue);\n    },\n\n    flatMap: function(mapper, context) {\n      return reify(this, flatMapFactory(this, mapper, context));\n    },\n\n    flatten: function(depth) {\n      return reify(this, flattenFactory(this, depth, true));\n    },\n\n    fromEntrySeq: function() {\n      return new FromEntriesSequence(this);\n    },\n\n    get: function(searchKey, notSetValue) {\n      return this.find(function(_, key)  {return is(key, searchKey)}, undefined, notSetValue);\n    },\n\n    getIn: function(searchKeyPath, notSetValue) {\n      var nested = this;\n      // Note: in an ES6 environment, we would prefer:\n      // for (var key of searchKeyPath) {\n      var iter = forceIterator(searchKeyPath);\n      var step;\n      while (!(step = iter.next()).done) {\n        var key = step.value;\n        nested = nested && nested.get ? nested.get(key, NOT_SET) : NOT_SET;\n        if (nested === NOT_SET) {\n          return notSetValue;\n        }\n      }\n      return nested;\n    },\n\n    groupBy: function(grouper, context) {\n      return groupByFactory(this, grouper, context);\n    },\n\n    has: function(searchKey) {\n      return this.get(searchKey, NOT_SET) !== NOT_SET;\n    },\n\n    hasIn: function(searchKeyPath) {\n      return this.getIn(searchKeyPath, NOT_SET) !== NOT_SET;\n    },\n\n    isSubset: function(iter) {\n      iter = typeof iter.includes === 'function' ? iter : Iterable(iter);\n      return this.every(function(value ) {return iter.includes(value)});\n    },\n\n    isSuperset: function(iter) {\n      iter = typeof iter.isSubset === 'function' ? iter : Iterable(iter);\n      return iter.isSubset(this);\n    },\n\n    keySeq: function() {\n      return this.toSeq().map(keyMapper).toIndexedSeq();\n    },\n\n    last: function() {\n      return this.toSeq().reverse().first();\n    },\n\n    max: function(comparator) {\n      return maxFactory(this, comparator);\n    },\n\n    maxBy: function(mapper, comparator) {\n      return maxFactory(this, comparator, mapper);\n    },\n\n    min: function(comparator) {\n      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator);\n    },\n\n    minBy: function(mapper, comparator) {\n      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator, mapper);\n    },\n\n    rest: function() {\n      return this.slice(1);\n    },\n\n    skip: function(amount) {\n      return this.slice(Math.max(0, amount));\n    },\n\n    skipLast: function(amount) {\n      return reify(this, this.toSeq().reverse().skip(amount).reverse());\n    },\n\n    skipWhile: function(predicate, context) {\n      return reify(this, skipWhileFactory(this, predicate, context, true));\n    },\n\n    skipUntil: function(predicate, context) {\n      return this.skipWhile(not(predicate), context);\n    },\n\n    sortBy: function(mapper, comparator) {\n      return reify(this, sortFactory(this, comparator, mapper));\n    },\n\n    take: function(amount) {\n      return this.slice(0, Math.max(0, amount));\n    },\n\n    takeLast: function(amount) {\n      return reify(this, this.toSeq().reverse().take(amount).reverse());\n    },\n\n    takeWhile: function(predicate, context) {\n      return reify(this, takeWhileFactory(this, predicate, context));\n    },\n\n    takeUntil: function(predicate, context) {\n      return this.takeWhile(not(predicate), context);\n    },\n\n    valueSeq: function() {\n      return this.toIndexedSeq();\n    },\n\n\n    // ### Hashable Object\n\n    hashCode: function() {\n      return this.__hash || (this.__hash = hashIterable(this));\n    }\n\n\n    // ### Internal\n\n    // abstract __iterate(fn, reverse)\n\n    // abstract __iterator(type, reverse)\n  });\n\n  // var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';\n  // var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';\n  // var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';\n  // var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';\n\n  var IterablePrototype = Iterable.prototype;\n  IterablePrototype[IS_ITERABLE_SENTINEL] = true;\n  IterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.values;\n  IterablePrototype.__toJS = IterablePrototype.toArray;\n  IterablePrototype.__toStringMapper = quoteString;\n  IterablePrototype.inspect =\n  IterablePrototype.toSource = function() { return this.toString(); };\n  IterablePrototype.chain = IterablePrototype.flatMap;\n  IterablePrototype.contains = IterablePrototype.includes;\n\n  // Temporary warning about using length\n  (function () {\n    try {\n      Object.defineProperty(IterablePrototype, 'length', {\n        get: function () {\n          if (!Iterable.noLengthWarning) {\n            var stack;\n            try {\n              throw new Error();\n            } catch (error) {\n              stack = error.stack;\n            }\n            if (stack.indexOf('_wrapObject') === -1) {\n              console && console.warn && console.warn(\n                'iterable.length has been deprecated, '+\n                'use iterable.size or iterable.count(). '+\n                'This warning will become a silent error in a future version. ' +\n                stack\n              );\n              return this.size;\n            }\n          }\n        }\n      });\n    } catch (e) {}\n  })();\n\n\n\n  mixin(KeyedIterable, {\n\n    // ### More sequential methods\n\n    flip: function() {\n      return reify(this, flipFactory(this));\n    },\n\n    findKey: function(predicate, context) {\n      var entry = this.findEntry(predicate, context);\n      return entry && entry[0];\n    },\n\n    findLastKey: function(predicate, context) {\n      return this.toSeq().reverse().findKey(predicate, context);\n    },\n\n    keyOf: function(searchValue) {\n      return this.findKey(function(value ) {return is(value, searchValue)});\n    },\n\n    lastKeyOf: function(searchValue) {\n      return this.findLastKey(function(value ) {return is(value, searchValue)});\n    },\n\n    mapEntries: function(mapper, context) {var this$0 = this;\n      var iterations = 0;\n      return reify(this,\n        this.toSeq().map(\n          function(v, k)  {return mapper.call(context, [k, v], iterations++, this$0)}\n        ).fromEntrySeq()\n      );\n    },\n\n    mapKeys: function(mapper, context) {var this$0 = this;\n      return reify(this,\n        this.toSeq().flip().map(\n          function(k, v)  {return mapper.call(context, k, v, this$0)}\n        ).flip()\n      );\n    }\n\n  });\n\n  var KeyedIterablePrototype = KeyedIterable.prototype;\n  KeyedIterablePrototype[IS_KEYED_SENTINEL] = true;\n  KeyedIterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.entries;\n  KeyedIterablePrototype.__toJS = IterablePrototype.toObject;\n  KeyedIterablePrototype.__toStringMapper = function(v, k)  {return JSON.stringify(k) + ': ' + quoteString(v)};\n\n\n\n  mixin(IndexedIterable, {\n\n    // ### Conversion to other types\n\n    toKeyedSeq: function() {\n      return new ToKeyedSequence(this, false);\n    },\n\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    filter: function(predicate, context) {\n      return reify(this, filterFactory(this, predicate, context, false));\n    },\n\n    findIndex: function(predicate, context) {\n      var entry = this.findEntry(predicate, context);\n      return entry ? entry[0] : -1;\n    },\n\n    indexOf: function(searchValue) {\n      var key = this.toKeyedSeq().keyOf(searchValue);\n      return key === undefined ? -1 : key;\n    },\n\n    lastIndexOf: function(searchValue) {\n      var key = this.toKeyedSeq().reverse().keyOf(searchValue);\n      return key === undefined ? -1 : key;\n\n      // var index =\n      // return this.toSeq().reverse().indexOf(searchValue);\n    },\n\n    reverse: function() {\n      return reify(this, reverseFactory(this, false));\n    },\n\n    slice: function(begin, end) {\n      return reify(this, sliceFactory(this, begin, end, false));\n    },\n\n    splice: function(index, removeNum /*, ...values*/) {\n      var numArgs = arguments.length;\n      removeNum = Math.max(removeNum | 0, 0);\n      if (numArgs === 0 || (numArgs === 2 && !removeNum)) {\n        return this;\n      }\n      // If index is negative, it should resolve relative to the size of the\n      // collection. However size may be expensive to compute if not cached, so\n      // only call count() if the number is in fact negative.\n      index = resolveBegin(index, index < 0 ? this.count() : this.size);\n      var spliced = this.slice(0, index);\n      return reify(\n        this,\n        numArgs === 1 ?\n          spliced :\n          spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum))\n      );\n    },\n\n\n    // ### More collection methods\n\n    findLastIndex: function(predicate, context) {\n      var key = this.toKeyedSeq().findLastKey(predicate, context);\n      return key === undefined ? -1 : key;\n    },\n\n    first: function() {\n      return this.get(0);\n    },\n\n    flatten: function(depth) {\n      return reify(this, flattenFactory(this, depth, false));\n    },\n\n    get: function(index, notSetValue) {\n      index = wrapIndex(this, index);\n      return (index < 0 || (this.size === Infinity ||\n          (this.size !== undefined && index > this.size))) ?\n        notSetValue :\n        this.find(function(_, key)  {return key === index}, undefined, notSetValue);\n    },\n\n    has: function(index) {\n      index = wrapIndex(this, index);\n      return index >= 0 && (this.size !== undefined ?\n        this.size === Infinity || index < this.size :\n        this.indexOf(index) !== -1\n      );\n    },\n\n    interpose: function(separator) {\n      return reify(this, interposeFactory(this, separator));\n    },\n\n    interleave: function(/*...iterables*/) {\n      var iterables = [this].concat(arrCopy(arguments));\n      var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, iterables);\n      var interleaved = zipped.flatten(true);\n      if (zipped.size) {\n        interleaved.size = zipped.size * iterables.length;\n      }\n      return reify(this, interleaved);\n    },\n\n    last: function() {\n      return this.get(-1);\n    },\n\n    skipWhile: function(predicate, context) {\n      return reify(this, skipWhileFactory(this, predicate, context, false));\n    },\n\n    zip: function(/*, ...iterables */) {\n      var iterables = [this].concat(arrCopy(arguments));\n      return reify(this, zipWithFactory(this, defaultZipper, iterables));\n    },\n\n    zipWith: function(zipper/*, ...iterables */) {\n      var iterables = arrCopy(arguments);\n      iterables[0] = this;\n      return reify(this, zipWithFactory(this, zipper, iterables));\n    }\n\n  });\n\n  IndexedIterable.prototype[IS_INDEXED_SENTINEL] = true;\n  IndexedIterable.prototype[IS_ORDERED_SENTINEL] = true;\n\n\n\n  mixin(SetIterable, {\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    get: function(value, notSetValue) {\n      return this.has(value) ? value : notSetValue;\n    },\n\n    includes: function(value) {\n      return this.has(value);\n    },\n\n\n    // ### More sequential methods\n\n    keySeq: function() {\n      return this.valueSeq();\n    }\n\n  });\n\n  SetIterable.prototype.has = IterablePrototype.includes;\n\n\n  // Mixin subclasses\n\n  mixin(KeyedSeq, KeyedIterable.prototype);\n  mixin(IndexedSeq, IndexedIterable.prototype);\n  mixin(SetSeq, SetIterable.prototype);\n\n  mixin(KeyedCollection, KeyedIterable.prototype);\n  mixin(IndexedCollection, IndexedIterable.prototype);\n  mixin(SetCollection, SetIterable.prototype);\n\n\n  // #pragma Helper functions\n\n  function keyMapper(v, k) {\n    return k;\n  }\n\n  function entryMapper(v, k) {\n    return [k, v];\n  }\n\n  function not(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    }\n  }\n\n  function neg(predicate) {\n    return function() {\n      return -predicate.apply(this, arguments);\n    }\n  }\n\n  function quoteString(value) {\n    return typeof value === 'string' ? JSON.stringify(value) : value;\n  }\n\n  function defaultZipper() {\n    return arrCopy(arguments);\n  }\n\n  function defaultNegComparator(a, b) {\n    return a < b ? 1 : a > b ? -1 : 0;\n  }\n\n  function hashIterable(iterable) {\n    if (iterable.size === Infinity) {\n      return 0;\n    }\n    var ordered = isOrdered(iterable);\n    var keyed = isKeyed(iterable);\n    var h = ordered ? 1 : 0;\n    var size = iterable.__iterate(\n      keyed ?\n        ordered ?\n          function(v, k)  { h = 31 * h + hashMerge(hash(v), hash(k)) | 0; } :\n          function(v, k)  { h = h + hashMerge(hash(v), hash(k)) | 0; } :\n        ordered ?\n          function(v ) { h = 31 * h + hash(v) | 0; } :\n          function(v ) { h = h + hash(v) | 0; }\n    );\n    return murmurHashOfSize(size, h);\n  }\n\n  function murmurHashOfSize(size, h) {\n    h = imul(h, 0xCC9E2D51);\n    h = imul(h << 15 | h >>> -15, 0x1B873593);\n    h = imul(h << 13 | h >>> -13, 5);\n    h = (h + 0xE6546B64 | 0) ^ size;\n    h = imul(h ^ h >>> 16, 0x85EBCA6B);\n    h = imul(h ^ h >>> 13, 0xC2B2AE35);\n    h = smi(h ^ h >>> 16);\n    return h;\n  }\n\n  function hashMerge(a, b) {\n    return a ^ b + 0x9E3779B9 + (a << 6) + (a >> 2) | 0; // int\n  }\n\n  var Immutable = {\n\n    Iterable: Iterable,\n\n    Seq: Seq,\n    Collection: Collection,\n    Map: Map,\n    OrderedMap: OrderedMap,\n    List: List,\n    Stack: Stack,\n    Set: Set,\n    OrderedSet: OrderedSet,\n\n    Record: Record,\n    Range: Range,\n    Repeat: Repeat,\n\n    is: is,\n    fromJS: fromJS\n\n  };\n\n  return Immutable;\n\n}));\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/node_modules/immutable/dist/immutable.js\n// module id = 57\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar validateFormat = function validateFormat(format) {};\n\nif (process.env.NODE_ENV !== 'production') {\n  validateFormat = function validateFormat(format) {\n    if (format === undefined) {\n      throw new Error('invariant requires an error message argument');\n    }\n  };\n}\n\nfunction invariant(condition, format, a, b, c, d, e, f) {\n  validateFormat(format);\n\n  if (!condition) {\n    var error;\n    if (format === undefined) {\n      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\n    } else {\n      var args = [a, b, c, d, e, f];\n      var argIndex = 0;\n      error = new Error(format.replace(/%s/g, function () {\n        return args[argIndex++];\n      }));\n      error.name = 'Invariant Violation';\n    }\n\n    error.framesToPop = 1; // we don't care about invariant's own frame\n    throw error;\n  }\n}\n\nmodule.exports = invariant;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/invariant.js\n// module id = 58\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule EditorState\n * @format\n * \n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar BlockTree = require('./BlockTree');\nvar ContentState = require('./ContentState');\nvar EditorBidiService = require('./EditorBidiService');\nvar Immutable = require('immutable');\nvar SelectionState = require('./SelectionState');\n\nvar OrderedSet = Immutable.OrderedSet,\n    Record = Immutable.Record,\n    Stack = Immutable.Stack;\n\n\nvar defaultRecord = {\n  allowUndo: true,\n  currentContent: null,\n  decorator: null,\n  directionMap: null,\n  forceSelection: false,\n  inCompositionMode: false,\n  inlineStyleOverride: null,\n  lastChangeType: null,\n  nativelyRenderedContent: null,\n  redoStack: Stack(),\n  selection: null,\n  treeMap: null,\n  undoStack: Stack()\n};\n\nvar EditorStateRecord = Record(defaultRecord);\n\nvar EditorState = function () {\n  EditorState.createEmpty = function createEmpty(decorator) {\n    return EditorState.createWithContent(ContentState.createFromText(''), decorator);\n  };\n\n  EditorState.createWithContent = function createWithContent(contentState, decorator) {\n    var firstKey = contentState.getBlockMap().first().getKey();\n    return EditorState.create({\n      currentContent: contentState,\n      undoStack: Stack(),\n      redoStack: Stack(),\n      decorator: decorator || null,\n      selection: SelectionState.createEmpty(firstKey)\n    });\n  };\n\n  EditorState.create = function create(config) {\n    var currentContent = config.currentContent,\n        decorator = config.decorator;\n\n    var recordConfig = _extends({}, config, {\n      treeMap: generateNewTreeMap(currentContent, decorator),\n      directionMap: EditorBidiService.getDirectionMap(currentContent)\n    });\n    return new EditorState(new EditorStateRecord(recordConfig));\n  };\n\n  EditorState.set = function set(editorState, put) {\n    var map = editorState.getImmutable().withMutations(function (state) {\n      var existingDecorator = state.get('decorator');\n      var decorator = existingDecorator;\n      if (put.decorator === null) {\n        decorator = null;\n      } else if (put.decorator) {\n        decorator = put.decorator;\n      }\n\n      var newContent = put.currentContent || editorState.getCurrentContent();\n\n      if (decorator !== existingDecorator) {\n        var treeMap = state.get('treeMap');\n        var newTreeMap;\n        if (decorator && existingDecorator) {\n          newTreeMap = regenerateTreeForNewDecorator(newContent, newContent.getBlockMap(), treeMap, decorator, existingDecorator);\n        } else {\n          newTreeMap = generateNewTreeMap(newContent, decorator);\n        }\n\n        state.merge({\n          decorator: decorator,\n          treeMap: newTreeMap,\n          nativelyRenderedContent: null\n        });\n        return;\n      }\n\n      var existingContent = editorState.getCurrentContent();\n      if (newContent !== existingContent) {\n        state.set('treeMap', regenerateTreeForNewBlocks(editorState, newContent.getBlockMap(), newContent.getEntityMap(), decorator));\n      }\n\n      state.merge(put);\n    });\n\n    return new EditorState(map);\n  };\n\n  EditorState.prototype.toJS = function toJS() {\n    return this.getImmutable().toJS();\n  };\n\n  EditorState.prototype.getAllowUndo = function getAllowUndo() {\n    return this.getImmutable().get('allowUndo');\n  };\n\n  EditorState.prototype.getCurrentContent = function getCurrentContent() {\n    return this.getImmutable().get('currentContent');\n  };\n\n  EditorState.prototype.getUndoStack = function getUndoStack() {\n    return this.getImmutable().get('undoStack');\n  };\n\n  EditorState.prototype.getRedoStack = function getRedoStack() {\n    return this.getImmutable().get('redoStack');\n  };\n\n  EditorState.prototype.getSelection = function getSelection() {\n    return this.getImmutable().get('selection');\n  };\n\n  EditorState.prototype.getDecorator = function getDecorator() {\n    return this.getImmutable().get('decorator');\n  };\n\n  EditorState.prototype.isInCompositionMode = function isInCompositionMode() {\n    return this.getImmutable().get('inCompositionMode');\n  };\n\n  EditorState.prototype.mustForceSelection = function mustForceSelection() {\n    return this.getImmutable().get('forceSelection');\n  };\n\n  EditorState.prototype.getNativelyRenderedContent = function getNativelyRenderedContent() {\n    return this.getImmutable().get('nativelyRenderedContent');\n  };\n\n  EditorState.prototype.getLastChangeType = function getLastChangeType() {\n    return this.getImmutable().get('lastChangeType');\n  };\n\n  /**\n   * While editing, the user may apply inline style commands with a collapsed\n   * cursor, intending to type text that adopts the specified style. In this\n   * case, we track the specified style as an \"override\" that takes precedence\n   * over the inline style of the text adjacent to the cursor.\n   *\n   * If null, there is no override in place.\n   */\n\n\n  EditorState.prototype.getInlineStyleOverride = function getInlineStyleOverride() {\n    return this.getImmutable().get('inlineStyleOverride');\n  };\n\n  EditorState.setInlineStyleOverride = function setInlineStyleOverride(editorState, inlineStyleOverride) {\n    return EditorState.set(editorState, { inlineStyleOverride: inlineStyleOverride });\n  };\n\n  /**\n   * Get the appropriate inline style for the editor state. If an\n   * override is in place, use it. Otherwise, the current style is\n   * based on the location of the selection state.\n   */\n\n\n  EditorState.prototype.getCurrentInlineStyle = function getCurrentInlineStyle() {\n    var override = this.getInlineStyleOverride();\n    if (override != null) {\n      return override;\n    }\n\n    var content = this.getCurrentContent();\n    var selection = this.getSelection();\n\n    if (selection.isCollapsed()) {\n      return getInlineStyleForCollapsedSelection(content, selection);\n    }\n\n    return getInlineStyleForNonCollapsedSelection(content, selection);\n  };\n\n  EditorState.prototype.getBlockTree = function getBlockTree(blockKey) {\n    return this.getImmutable().getIn(['treeMap', blockKey]);\n  };\n\n  EditorState.prototype.isSelectionAtStartOfContent = function isSelectionAtStartOfContent() {\n    var firstKey = this.getCurrentContent().getBlockMap().first().getKey();\n    return this.getSelection().hasEdgeWithin(firstKey, 0, 0);\n  };\n\n  EditorState.prototype.isSelectionAtEndOfContent = function isSelectionAtEndOfContent() {\n    var content = this.getCurrentContent();\n    var blockMap = content.getBlockMap();\n    var last = blockMap.last();\n    var end = last.getLength();\n    return this.getSelection().hasEdgeWithin(last.getKey(), end, end);\n  };\n\n  EditorState.prototype.getDirectionMap = function getDirectionMap() {\n    return this.getImmutable().get('directionMap');\n  };\n\n  /**\n   * Incorporate native DOM selection changes into the EditorState. This\n   * method can be used when we simply want to accept whatever the DOM\n   * has given us to represent selection, and we do not need to re-render\n   * the editor.\n   *\n   * To forcibly move the DOM selection, see `EditorState.forceSelection`.\n   */\n\n\n  EditorState.acceptSelection = function acceptSelection(editorState, selection) {\n    return updateSelection(editorState, selection, false);\n  };\n\n  /**\n   * At times, we need to force the DOM selection to be where we\n   * need it to be. This can occur when the anchor or focus nodes\n   * are non-text nodes, for instance. In this case, we want to trigger\n   * a re-render of the editor, which in turn forces selection into\n   * the correct place in the DOM. The `forceSelection` method\n   * accomplishes this.\n   *\n   * This method should be used in cases where you need to explicitly\n   * move the DOM selection from one place to another without a change\n   * in ContentState.\n   */\n\n\n  EditorState.forceSelection = function forceSelection(editorState, selection) {\n    if (!selection.getHasFocus()) {\n      selection = selection.set('hasFocus', true);\n    }\n    return updateSelection(editorState, selection, true);\n  };\n\n  /**\n   * Move selection to the end of the editor without forcing focus.\n   */\n\n\n  EditorState.moveSelectionToEnd = function moveSelectionToEnd(editorState) {\n    var content = editorState.getCurrentContent();\n    var lastBlock = content.getLastBlock();\n    var lastKey = lastBlock.getKey();\n    var length = lastBlock.getLength();\n\n    return EditorState.acceptSelection(editorState, new SelectionState({\n      anchorKey: lastKey,\n      anchorOffset: length,\n      focusKey: lastKey,\n      focusOffset: length,\n      isBackward: false\n    }));\n  };\n\n  /**\n   * Force focus to the end of the editor. This is useful in scenarios\n   * where we want to programmatically focus the input and it makes sense\n   * to allow the user to continue working seamlessly.\n   */\n\n\n  EditorState.moveFocusToEnd = function moveFocusToEnd(editorState) {\n    var afterSelectionMove = EditorState.moveSelectionToEnd(editorState);\n    return EditorState.forceSelection(afterSelectionMove, afterSelectionMove.getSelection());\n  };\n\n  /**\n   * Push the current ContentState onto the undo stack if it should be\n   * considered a boundary state, and set the provided ContentState as the\n   * new current content.\n   */\n\n\n  EditorState.push = function push(editorState, contentState, changeType) {\n    if (editorState.getCurrentContent() === contentState) {\n      return editorState;\n    }\n\n    var forceSelection = changeType !== 'insert-characters';\n    var directionMap = EditorBidiService.getDirectionMap(contentState, editorState.getDirectionMap());\n\n    if (!editorState.getAllowUndo()) {\n      return EditorState.set(editorState, {\n        currentContent: contentState,\n        directionMap: directionMap,\n        lastChangeType: changeType,\n        selection: contentState.getSelectionAfter(),\n        forceSelection: forceSelection,\n        inlineStyleOverride: null\n      });\n    }\n\n    var selection = editorState.getSelection();\n    var currentContent = editorState.getCurrentContent();\n    var undoStack = editorState.getUndoStack();\n    var newContent = contentState;\n\n    if (selection !== currentContent.getSelectionAfter() || mustBecomeBoundary(editorState, changeType)) {\n      undoStack = undoStack.push(currentContent);\n      newContent = newContent.set('selectionBefore', selection);\n    } else if (changeType === 'insert-characters' || changeType === 'backspace-character' || changeType === 'delete-character') {\n      // Preserve the previous selection.\n      newContent = newContent.set('selectionBefore', currentContent.getSelectionBefore());\n    }\n\n    var inlineStyleOverride = editorState.getInlineStyleOverride();\n\n    // Don't discard inline style overrides for the following change types:\n    var overrideChangeTypes = ['adjust-depth', 'change-block-type', 'split-block'];\n\n    if (overrideChangeTypes.indexOf(changeType) === -1) {\n      inlineStyleOverride = null;\n    }\n\n    var editorStateChanges = {\n      currentContent: newContent,\n      directionMap: directionMap,\n      undoStack: undoStack,\n      redoStack: Stack(),\n      lastChangeType: changeType,\n      selection: contentState.getSelectionAfter(),\n      forceSelection: forceSelection,\n      inlineStyleOverride: inlineStyleOverride\n    };\n\n    return EditorState.set(editorState, editorStateChanges);\n  };\n\n  /**\n   * Make the top ContentState in the undo stack the new current content and\n   * push the current content onto the redo stack.\n   */\n\n\n  EditorState.undo = function undo(editorState) {\n    if (!editorState.getAllowUndo()) {\n      return editorState;\n    }\n\n    var undoStack = editorState.getUndoStack();\n    var newCurrentContent = undoStack.peek();\n    if (!newCurrentContent) {\n      return editorState;\n    }\n\n    var currentContent = editorState.getCurrentContent();\n    var directionMap = EditorBidiService.getDirectionMap(newCurrentContent, editorState.getDirectionMap());\n\n    return EditorState.set(editorState, {\n      currentContent: newCurrentContent,\n      directionMap: directionMap,\n      undoStack: undoStack.shift(),\n      redoStack: editorState.getRedoStack().push(currentContent),\n      forceSelection: true,\n      inlineStyleOverride: null,\n      lastChangeType: 'undo',\n      nativelyRenderedContent: null,\n      selection: currentContent.getSelectionBefore()\n    });\n  };\n\n  /**\n   * Make the top ContentState in the redo stack the new current content and\n   * push the current content onto the undo stack.\n   */\n\n\n  EditorState.redo = function redo(editorState) {\n    if (!editorState.getAllowUndo()) {\n      return editorState;\n    }\n\n    var redoStack = editorState.getRedoStack();\n    var newCurrentContent = redoStack.peek();\n    if (!newCurrentContent) {\n      return editorState;\n    }\n\n    var currentContent = editorState.getCurrentContent();\n    var directionMap = EditorBidiService.getDirectionMap(newCurrentContent, editorState.getDirectionMap());\n\n    return EditorState.set(editorState, {\n      currentContent: newCurrentContent,\n      directionMap: directionMap,\n      undoStack: editorState.getUndoStack().push(currentContent),\n      redoStack: redoStack.shift(),\n      forceSelection: true,\n      inlineStyleOverride: null,\n      lastChangeType: 'redo',\n      nativelyRenderedContent: null,\n      selection: newCurrentContent.getSelectionAfter()\n    });\n  };\n\n  /**\n   * Not for public consumption.\n   */\n\n\n  function EditorState(immutable) {\n    _classCallCheck(this, EditorState);\n\n    this._immutable = immutable;\n  }\n\n  /**\n   * Not for public consumption.\n   */\n\n\n  EditorState.prototype.getImmutable = function getImmutable() {\n    return this._immutable;\n  };\n\n  return EditorState;\n}();\n\n/**\n * Set the supplied SelectionState as the new current selection, and set\n * the `force` flag to trigger manual selection placement by the view.\n */\n\n\nfunction updateSelection(editorState, selection, forceSelection) {\n  return EditorState.set(editorState, {\n    selection: selection,\n    forceSelection: forceSelection,\n    nativelyRenderedContent: null,\n    inlineStyleOverride: null\n  });\n}\n\n/**\n * Regenerate the entire tree map for a given ContentState and decorator.\n * Returns an OrderedMap that maps all available ContentBlock objects.\n */\nfunction generateNewTreeMap(contentState, decorator) {\n  return contentState.getBlockMap().map(function (block) {\n    return BlockTree.generate(contentState, block, decorator);\n  }).toOrderedMap();\n}\n\n/**\n * Regenerate tree map objects for all ContentBlocks that have changed\n * between the current editorState and newContent. Returns an OrderedMap\n * with only changed regenerated tree map objects.\n */\nfunction regenerateTreeForNewBlocks(editorState, newBlockMap, newEntityMap, decorator) {\n  var contentState = editorState.getCurrentContent().set('entityMap', newEntityMap);\n  var prevBlockMap = contentState.getBlockMap();\n  var prevTreeMap = editorState.getImmutable().get('treeMap');\n  return prevTreeMap.merge(newBlockMap.toSeq().filter(function (block, key) {\n    return block !== prevBlockMap.get(key);\n  }).map(function (block) {\n    return BlockTree.generate(contentState, block, decorator);\n  }));\n}\n\n/**\n * Generate tree map objects for a new decorator object, preserving any\n * decorations that are unchanged from the previous decorator.\n *\n * Note that in order for this to perform optimally, decoration Lists for\n * decorators should be preserved when possible to allow for direct immutable\n * List comparison.\n */\nfunction regenerateTreeForNewDecorator(content, blockMap, previousTreeMap, decorator, existingDecorator) {\n  return previousTreeMap.merge(blockMap.toSeq().filter(function (block) {\n    return decorator.getDecorations(block, content) !== existingDecorator.getDecorations(block, content);\n  }).map(function (block) {\n    return BlockTree.generate(content, block, decorator);\n  }));\n}\n\n/**\n * Return whether a change should be considered a boundary state, given\n * the previous change type. Allows us to discard potential boundary states\n * during standard typing or deletion behavior.\n */\nfunction mustBecomeBoundary(editorState, changeType) {\n  var lastChangeType = editorState.getLastChangeType();\n  return changeType !== lastChangeType || changeType !== 'insert-characters' && changeType !== 'backspace-character' && changeType !== 'delete-character';\n}\n\nfunction getInlineStyleForCollapsedSelection(content, selection) {\n  var startKey = selection.getStartKey();\n  var startOffset = selection.getStartOffset();\n  var startBlock = content.getBlockForKey(startKey);\n\n  // If the cursor is not at the start of the block, look backward to\n  // preserve the style of the preceding character.\n  if (startOffset > 0) {\n    return startBlock.getInlineStyleAt(startOffset - 1);\n  }\n\n  // The caret is at position zero in this block. If the block has any\n  // text at all, use the style of the first character.\n  if (startBlock.getLength()) {\n    return startBlock.getInlineStyleAt(0);\n  }\n\n  // Otherwise, look upward in the document to find the closest character.\n  return lookUpwardForInlineStyle(content, startKey);\n}\n\nfunction getInlineStyleForNonCollapsedSelection(content, selection) {\n  var startKey = selection.getStartKey();\n  var startOffset = selection.getStartOffset();\n  var startBlock = content.getBlockForKey(startKey);\n\n  // If there is a character just inside the selection, use its style.\n  if (startOffset < startBlock.getLength()) {\n    return startBlock.getInlineStyleAt(startOffset);\n  }\n\n  // Check if the selection at the end of a non-empty block. Use the last\n  // style in the block.\n  if (startOffset > 0) {\n    return startBlock.getInlineStyleAt(startOffset - 1);\n  }\n\n  // Otherwise, look upward in the document to find the closest character.\n  return lookUpwardForInlineStyle(content, startKey);\n}\n\nfunction lookUpwardForInlineStyle(content, fromKey) {\n  var lastNonEmpty = content.getBlockMap().reverse().skipUntil(function (_, k) {\n    return k === fromKey;\n  }).skip(1).skipUntil(function (block, _) {\n    return block.getLength();\n  }).first();\n\n  if (lastNonEmpty) return lastNonEmpty.getInlineStyleAt(lastNonEmpty.getLength() - 1);\n  return OrderedSet();\n}\n\nmodule.exports = EditorState;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/EditorState.js\n// module id = 59\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftModifier\n * @format\n * \n */\n\n'use strict';\n\nvar CharacterMetadata = require('./CharacterMetadata');\nvar ContentStateInlineStyle = require('./ContentStateInlineStyle');\nvar DraftFeatureFlags = require('./DraftFeatureFlags');\nvar Immutable = require('immutable');\n\nvar applyEntityToContentState = require('./applyEntityToContentState');\nvar getCharacterRemovalRange = require('./getCharacterRemovalRange');\nvar getContentStateFragment = require('./getContentStateFragment');\nvar insertFragmentIntoContentState = require('./insertFragmentIntoContentState');\nvar insertTextIntoContentState = require('./insertTextIntoContentState');\nvar invariant = require('fbjs/lib/invariant');\nvar modifyBlockForContentState = require('./modifyBlockForContentState');\nvar removeEntitiesAtEdges = require('./removeEntitiesAtEdges');\nvar removeRangeFromContentState = require('./removeRangeFromContentState');\nvar splitBlockInContentState = require('./splitBlockInContentState');\n\nvar OrderedSet = Immutable.OrderedSet;\n\n/**\n * `DraftModifier` provides a set of convenience methods that apply\n * modifications to a `ContentState` object based on a target `SelectionState`.\n *\n * Any change to a `ContentState` should be decomposable into a series of\n * transaction functions that apply the required changes and return output\n * `ContentState` objects.\n *\n * These functions encapsulate some of the most common transaction sequences.\n */\n\nvar DraftModifier = {\n  replaceText: function replaceText(contentState, rangeToReplace, text, inlineStyle, entityKey) {\n    var withoutEntities = removeEntitiesAtEdges(contentState, rangeToReplace);\n    var withoutText = removeRangeFromContentState(withoutEntities, rangeToReplace);\n\n    var character = CharacterMetadata.create({\n      style: inlineStyle || OrderedSet(),\n      entity: entityKey || null\n    });\n\n    return insertTextIntoContentState(withoutText, withoutText.getSelectionAfter(), text, character);\n  },\n\n  insertText: function insertText(contentState, targetRange, text, inlineStyle, entityKey) {\n    !targetRange.isCollapsed() ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Target range must be collapsed for `insertText`.') : invariant(false) : void 0;\n    return DraftModifier.replaceText(contentState, targetRange, text, inlineStyle, entityKey);\n  },\n\n  moveText: function moveText(contentState, removalRange, targetRange) {\n    var movedFragment = getContentStateFragment(contentState, removalRange);\n\n    var afterRemoval = DraftModifier.removeRange(contentState, removalRange, 'backward');\n\n    return DraftModifier.replaceWithFragment(afterRemoval, targetRange, movedFragment);\n  },\n\n  replaceWithFragment: function replaceWithFragment(contentState, targetRange, fragment) {\n    var withoutEntities = removeEntitiesAtEdges(contentState, targetRange);\n    var withoutText = removeRangeFromContentState(withoutEntities, targetRange);\n\n    return insertFragmentIntoContentState(withoutText, withoutText.getSelectionAfter(), fragment);\n  },\n\n  removeRange: function removeRange(contentState, rangeToRemove, removalDirection) {\n    var startKey = void 0,\n        endKey = void 0,\n        startBlock = void 0,\n        endBlock = void 0;\n    if (rangeToRemove.getIsBackward()) {\n      rangeToRemove = rangeToRemove.merge({\n        anchorKey: rangeToRemove.getFocusKey(),\n        anchorOffset: rangeToRemove.getFocusOffset(),\n        focusKey: rangeToRemove.getAnchorKey(),\n        focusOffset: rangeToRemove.getAnchorOffset(),\n        isBackward: false\n      });\n    }\n    startKey = rangeToRemove.getAnchorKey();\n    endKey = rangeToRemove.getFocusKey();\n    startBlock = contentState.getBlockForKey(startKey);\n    endBlock = contentState.getBlockForKey(endKey);\n    var startOffset = rangeToRemove.getStartOffset();\n    var endOffset = rangeToRemove.getEndOffset();\n\n    var startEntityKey = startBlock.getEntityAt(startOffset);\n    var endEntityKey = endBlock.getEntityAt(endOffset - 1);\n\n    // Check whether the selection state overlaps with a single entity.\n    // If so, try to remove the appropriate substring of the entity text.\n    if (startKey === endKey) {\n      if (startEntityKey && startEntityKey === endEntityKey) {\n        var _adjustedRemovalRange = getCharacterRemovalRange(contentState.getEntityMap(), startBlock, endBlock, rangeToRemove, removalDirection);\n        return removeRangeFromContentState(contentState, _adjustedRemovalRange);\n      }\n    }\n    var adjustedRemovalRange = rangeToRemove;\n    if (DraftFeatureFlags.draft_segmented_entities_behavior) {\n      // Adjust the selection to properly delete segemented and immutable\n      // entities\n      adjustedRemovalRange = getCharacterRemovalRange(contentState.getEntityMap(), startBlock, endBlock, rangeToRemove, removalDirection);\n    }\n\n    var withoutEntities = removeEntitiesAtEdges(contentState, adjustedRemovalRange);\n    return removeRangeFromContentState(withoutEntities, adjustedRemovalRange);\n  },\n\n  splitBlock: function splitBlock(contentState, selectionState) {\n    var withoutEntities = removeEntitiesAtEdges(contentState, selectionState);\n    var withoutText = removeRangeFromContentState(withoutEntities, selectionState);\n\n    return splitBlockInContentState(withoutText, withoutText.getSelectionAfter());\n  },\n\n  applyInlineStyle: function applyInlineStyle(contentState, selectionState, inlineStyle) {\n    return ContentStateInlineStyle.add(contentState, selectionState, inlineStyle);\n  },\n\n  removeInlineStyle: function removeInlineStyle(contentState, selectionState, inlineStyle) {\n    return ContentStateInlineStyle.remove(contentState, selectionState, inlineStyle);\n  },\n\n  setBlockType: function setBlockType(contentState, selectionState, blockType) {\n    return modifyBlockForContentState(contentState, selectionState, function (block) {\n      return block.merge({ type: blockType, depth: 0 });\n    });\n  },\n\n  setBlockData: function setBlockData(contentState, selectionState, blockData) {\n    return modifyBlockForContentState(contentState, selectionState, function (block) {\n      return block.merge({ data: blockData });\n    });\n  },\n\n  mergeBlockData: function mergeBlockData(contentState, selectionState, blockData) {\n    return modifyBlockForContentState(contentState, selectionState, function (block) {\n      return block.merge({ data: block.getData().merge(blockData) });\n    });\n  },\n\n  applyEntity: function applyEntity(contentState, selectionState, entityKey) {\n    var withoutEntities = removeEntitiesAtEdges(contentState, selectionState);\n    return applyEntityToContentState(withoutEntities, selectionState, entityKey);\n  }\n};\n\nmodule.exports = DraftModifier;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftModifier.js\n// module id = 62\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule CharacterMetadata\n * @format\n * \n */\n\n'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar _require = require('immutable'),\n    Map = _require.Map,\n    OrderedSet = _require.OrderedSet,\n    Record = _require.Record;\n\n// Immutable.map is typed such that the value for every key in the map\n// must be the same type\n\n\nvar EMPTY_SET = OrderedSet();\n\nvar defaultRecord = {\n  style: EMPTY_SET,\n  entity: null\n};\n\nvar CharacterMetadataRecord = Record(defaultRecord);\n\nvar CharacterMetadata = function (_CharacterMetadataRec) {\n  _inherits(CharacterMetadata, _CharacterMetadataRec);\n\n  function CharacterMetadata() {\n    _classCallCheck(this, CharacterMetadata);\n\n    return _possibleConstructorReturn(this, _CharacterMetadataRec.apply(this, arguments));\n  }\n\n  CharacterMetadata.prototype.getStyle = function getStyle() {\n    return this.get('style');\n  };\n\n  CharacterMetadata.prototype.getEntity = function getEntity() {\n    return this.get('entity');\n  };\n\n  CharacterMetadata.prototype.hasStyle = function hasStyle(style) {\n    return this.getStyle().includes(style);\n  };\n\n  CharacterMetadata.applyStyle = function applyStyle(record, style) {\n    var withStyle = record.set('style', record.getStyle().add(style));\n    return CharacterMetadata.create(withStyle);\n  };\n\n  CharacterMetadata.removeStyle = function removeStyle(record, style) {\n    var withoutStyle = record.set('style', record.getStyle().remove(style));\n    return CharacterMetadata.create(withoutStyle);\n  };\n\n  CharacterMetadata.applyEntity = function applyEntity(record, entityKey) {\n    var withEntity = record.getEntity() === entityKey ? record : record.set('entity', entityKey);\n    return CharacterMetadata.create(withEntity);\n  };\n\n  /**\n   * Use this function instead of the `CharacterMetadata` constructor.\n   * Since most content generally uses only a very small number of\n   * style/entity permutations, we can reuse these objects as often as\n   * possible.\n   */\n\n\n  CharacterMetadata.create = function create(config) {\n    if (!config) {\n      return EMPTY;\n    }\n\n    var defaultConfig = {\n      style: EMPTY_SET,\n      entity: null\n    };\n\n    // Fill in unspecified properties, if necessary.\n    var configMap = Map(defaultConfig).merge(config);\n\n    var existing = pool.get(configMap);\n    if (existing) {\n      return existing;\n    }\n\n    var newCharacter = new CharacterMetadata(configMap);\n    pool = pool.set(configMap, newCharacter);\n    return newCharacter;\n  };\n\n  return CharacterMetadata;\n}(CharacterMetadataRecord);\n\nvar EMPTY = new CharacterMetadata();\nvar pool = Map([[Map(defaultRecord), EMPTY]]);\n\nCharacterMetadata.EMPTY = EMPTY;\n\nmodule.exports = CharacterMetadata;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/CharacterMetadata.js\n// module id = 63\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ContentBlockNode\n * @format\n * \n *\n * This file is a fork of ContentBlock adding support for nesting references by\n * providing links to children, parent, prevSibling, and nextSibling.\n *\n * This is unstable and not part of the public API and should not be used by\n * production systems. This file may be update/removed without notice.\n */\n\n'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar CharacterMetadata = require('./CharacterMetadata');\nvar Immutable = require('immutable');\n\nvar findRangesImmutable = require('./findRangesImmutable');\n\nvar List = Immutable.List,\n    Map = Immutable.Map,\n    OrderedSet = Immutable.OrderedSet,\n    Record = Immutable.Record,\n    Repeat = Immutable.Repeat;\n\n\nvar EMPTY_SET = OrderedSet();\n\nvar defaultRecord = {\n  parent: null,\n  characterList: List(),\n  data: Map(),\n  depth: 0,\n  key: '',\n  text: '',\n  type: 'unstyled',\n  children: List(),\n  prevSibling: null,\n  nextSibling: null\n};\n\nvar haveEqualStyle = function haveEqualStyle(charA, charB) {\n  return charA.getStyle() === charB.getStyle();\n};\n\nvar haveEqualEntity = function haveEqualEntity(charA, charB) {\n  return charA.getEntity() === charB.getEntity();\n};\n\nvar decorateCharacterList = function decorateCharacterList(config) {\n  if (!config) {\n    return config;\n  }\n\n  var characterList = config.characterList,\n      text = config.text;\n\n\n  if (text && !characterList) {\n    config.characterList = List(Repeat(CharacterMetadata.EMPTY, text.length));\n  }\n\n  return config;\n};\n\nvar ContentBlockNode = function (_Record) {\n  _inherits(ContentBlockNode, _Record);\n\n  function ContentBlockNode() {\n    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultRecord;\n\n    _classCallCheck(this, ContentBlockNode);\n\n    return _possibleConstructorReturn(this, _Record.call(this, decorateCharacterList(props)));\n  }\n\n  ContentBlockNode.prototype.getKey = function getKey() {\n    return this.get('key');\n  };\n\n  ContentBlockNode.prototype.getType = function getType() {\n    return this.get('type');\n  };\n\n  ContentBlockNode.prototype.getText = function getText() {\n    return this.get('text');\n  };\n\n  ContentBlockNode.prototype.getCharacterList = function getCharacterList() {\n    return this.get('characterList');\n  };\n\n  ContentBlockNode.prototype.getLength = function getLength() {\n    return this.getText().length;\n  };\n\n  ContentBlockNode.prototype.getDepth = function getDepth() {\n    return this.get('depth');\n  };\n\n  ContentBlockNode.prototype.getData = function getData() {\n    return this.get('data');\n  };\n\n  ContentBlockNode.prototype.getInlineStyleAt = function getInlineStyleAt(offset) {\n    var character = this.getCharacterList().get(offset);\n    return character ? character.getStyle() : EMPTY_SET;\n  };\n\n  ContentBlockNode.prototype.getEntityAt = function getEntityAt(offset) {\n    var character = this.getCharacterList().get(offset);\n    return character ? character.getEntity() : null;\n  };\n\n  ContentBlockNode.prototype.getChildKeys = function getChildKeys() {\n    return this.get('children');\n  };\n\n  ContentBlockNode.prototype.getParentKey = function getParentKey() {\n    return this.get('parent');\n  };\n\n  ContentBlockNode.prototype.getPrevSiblingKey = function getPrevSiblingKey() {\n    return this.get('prevSibling');\n  };\n\n  ContentBlockNode.prototype.getNextSiblingKey = function getNextSiblingKey() {\n    return this.get('nextSibling');\n  };\n\n  ContentBlockNode.prototype.findStyleRanges = function findStyleRanges(filterFn, callback) {\n    findRangesImmutable(this.getCharacterList(), haveEqualStyle, filterFn, callback);\n  };\n\n  ContentBlockNode.prototype.findEntityRanges = function findEntityRanges(filterFn, callback) {\n    findRangesImmutable(this.getCharacterList(), haveEqualEntity, filterFn, callback);\n  };\n\n  return ContentBlockNode;\n}(Record(defaultRecord));\n\nmodule.exports = ContentBlockNode;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/ContentBlockNode.js\n// module id = 64\n// module chunks = 2","\"use strict\";\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\nvar nullthrows = function nullthrows(x) {\n  if (x != null) {\n    return x;\n  }\n  throw new Error(\"Got unexpected null or undefined\");\n};\n\nmodule.exports = nullthrows;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/nullthrows.js\n// module id = 65\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar UserAgentData = require('./UserAgentData');\nvar VersionRange = require('./VersionRange');\n\nvar mapObject = require('./mapObject');\nvar memoizeStringOnly = require('./memoizeStringOnly');\n\n/**\n * Checks to see whether `name` and `version` satisfy `query`.\n *\n * @param {string} name Name of the browser, device, engine or platform\n * @param {?string} version Version of the browser, engine or platform\n * @param {string} query Query of form \"Name [range expression]\"\n * @param {?function} normalizer Optional pre-processor for range expression\n * @return {boolean}\n */\nfunction compare(name, version, query, normalizer) {\n  // check for exact match with no version\n  if (name === query) {\n    return true;\n  }\n\n  // check for non-matching names\n  if (!query.startsWith(name)) {\n    return false;\n  }\n\n  // full comparison with version\n  var range = query.slice(name.length);\n  if (version) {\n    range = normalizer ? normalizer(range) : range;\n    return VersionRange.contains(range, version);\n  }\n\n  return false;\n}\n\n/**\n * Normalizes `version` by stripping any \"NT\" prefix, but only on the Windows\n * platform.\n *\n * Mimics the stripping performed by the `UserAgentWindowsPlatform` PHP class.\n *\n * @param {string} version\n * @return {string}\n */\nfunction normalizePlatformVersion(version) {\n  if (UserAgentData.platformName === 'Windows') {\n    return version.replace(/^\\s*NT/, '');\n  }\n\n  return version;\n}\n\n/**\n * Provides client-side access to the authoritative PHP-generated User Agent\n * information supplied by the server.\n */\nvar UserAgent = {\n  /**\n   * Check if the User Agent browser matches `query`.\n   *\n   * `query` should be a string like \"Chrome\" or \"Chrome > 33\".\n   *\n   * Valid browser names include:\n   *\n   * - ACCESS NetFront\n   * - AOL\n   * - Amazon Silk\n   * - Android\n   * - BlackBerry\n   * - BlackBerry PlayBook\n   * - Chrome\n   * - Chrome for iOS\n   * - Chrome frame\n   * - Facebook PHP SDK\n   * - Facebook for iOS\n   * - Firefox\n   * - IE\n   * - IE Mobile\n   * - Mobile Safari\n   * - Motorola Internet Browser\n   * - Nokia\n   * - Openwave Mobile Browser\n   * - Opera\n   * - Opera Mini\n   * - Opera Mobile\n   * - Safari\n   * - UIWebView\n   * - Unknown\n   * - webOS\n   * - etc...\n   *\n   * An authoritative list can be found in the PHP `BrowserDetector` class and\n   * related classes in the same file (see calls to `new UserAgentBrowser` here:\n   * https://fburl.com/50728104).\n   *\n   * @note Function results are memoized\n   *\n   * @param {string} query Query of the form \"Name [range expression]\"\n   * @return {boolean}\n   */\n  isBrowser: function isBrowser(query) {\n    return compare(UserAgentData.browserName, UserAgentData.browserFullVersion, query);\n  },\n\n\n  /**\n   * Check if the User Agent browser uses a 32 or 64 bit architecture.\n   *\n   * @note Function results are memoized\n   *\n   * @param {string} query Query of the form \"32\" or \"64\".\n   * @return {boolean}\n   */\n  isBrowserArchitecture: function isBrowserArchitecture(query) {\n    return compare(UserAgentData.browserArchitecture, null, query);\n  },\n\n\n  /**\n   * Check if the User Agent device matches `query`.\n   *\n   * `query` should be a string like \"iPhone\" or \"iPad\".\n   *\n   * Valid device names include:\n   *\n   * - Kindle\n   * - Kindle Fire\n   * - Unknown\n   * - iPad\n   * - iPhone\n   * - iPod\n   * - etc...\n   *\n   * An authoritative list can be found in the PHP `DeviceDetector` class and\n   * related classes in the same file (see calls to `new UserAgentDevice` here:\n   * https://fburl.com/50728332).\n   *\n   * @note Function results are memoized\n   *\n   * @param {string} query Query of the form \"Name\"\n   * @return {boolean}\n   */\n  isDevice: function isDevice(query) {\n    return compare(UserAgentData.deviceName, null, query);\n  },\n\n\n  /**\n   * Check if the User Agent rendering engine matches `query`.\n   *\n   * `query` should be a string like \"WebKit\" or \"WebKit >= 537\".\n   *\n   * Valid engine names include:\n   *\n   * - Gecko\n   * - Presto\n   * - Trident\n   * - WebKit\n   * - etc...\n   *\n   * An authoritative list can be found in the PHP `RenderingEngineDetector`\n   * class related classes in the same file (see calls to `new\n   * UserAgentRenderingEngine` here: https://fburl.com/50728617).\n   *\n   * @note Function results are memoized\n   *\n   * @param {string} query Query of the form \"Name [range expression]\"\n   * @return {boolean}\n   */\n  isEngine: function isEngine(query) {\n    return compare(UserAgentData.engineName, UserAgentData.engineVersion, query);\n  },\n\n\n  /**\n   * Check if the User Agent platform matches `query`.\n   *\n   * `query` should be a string like \"Windows\" or \"iOS 5 - 6\".\n   *\n   * Valid platform names include:\n   *\n   * - Android\n   * - BlackBerry OS\n   * - Java ME\n   * - Linux\n   * - Mac OS X\n   * - Mac OS X Calendar\n   * - Mac OS X Internet Account\n   * - Symbian\n   * - SymbianOS\n   * - Windows\n   * - Windows Mobile\n   * - Windows Phone\n   * - iOS\n   * - iOS Facebook Integration Account\n   * - iOS Facebook Social Sharing UI\n   * - webOS\n   * - Chrome OS\n   * - etc...\n   *\n   * An authoritative list can be found in the PHP `PlatformDetector` class and\n   * related classes in the same file (see calls to `new UserAgentPlatform`\n   * here: https://fburl.com/50729226).\n   *\n   * @note Function results are memoized\n   *\n   * @param {string} query Query of the form \"Name [range expression]\"\n   * @return {boolean}\n   */\n  isPlatform: function isPlatform(query) {\n    return compare(UserAgentData.platformName, UserAgentData.platformFullVersion, query, normalizePlatformVersion);\n  },\n\n\n  /**\n   * Check if the User Agent platform is a 32 or 64 bit architecture.\n   *\n   * @note Function results are memoized\n   *\n   * @param {string} query Query of the form \"32\" or \"64\".\n   * @return {boolean}\n   */\n  isPlatformArchitecture: function isPlatformArchitecture(query) {\n    return compare(UserAgentData.platformArchitecture, null, query);\n  }\n};\n\nmodule.exports = mapObject(UserAgent, memoizeStringOnly);\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/UserAgent.js\n// module id = 67\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule generateRandomKey\n * @format\n * \n */\n\n'use strict';\n\nvar seenKeys = {};\nvar MULTIPLIER = Math.pow(2, 24);\n\nfunction generateRandomKey() {\n  var key = void 0;\n  while (key === undefined || seenKeys.hasOwnProperty(key) || !isNaN(+key)) {\n    key = Math.floor(Math.random() * MULTIPLIER).toString(32);\n  }\n  seenKeys[key] = true;\n  return key;\n}\n\nmodule.exports = generateRandomKey;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/generateRandomKey.js\n// module id = 70\n// module chunks = 2","/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftFeatureFlags\n * @format\n * \n */\n\n'use strict';\n\nvar DraftFeatureFlags = require('./DraftFeatureFlags-core');\n\nmodule.exports = DraftFeatureFlags;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftFeatureFlags.js\n// module id = 71\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ContentBlock\n * @format\n * \n */\n\n'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar CharacterMetadata = require('./CharacterMetadata');\nvar Immutable = require('immutable');\n\nvar findRangesImmutable = require('./findRangesImmutable');\n\nvar List = Immutable.List,\n    Map = Immutable.Map,\n    OrderedSet = Immutable.OrderedSet,\n    Record = Immutable.Record,\n    Repeat = Immutable.Repeat;\n\n\nvar EMPTY_SET = OrderedSet();\n\nvar defaultRecord = {\n  key: '',\n  type: 'unstyled',\n  text: '',\n  characterList: List(),\n  depth: 0,\n  data: Map()\n};\n\nvar ContentBlockRecord = Record(defaultRecord);\n\nvar decorateCharacterList = function decorateCharacterList(config) {\n  if (!config) {\n    return config;\n  }\n\n  var characterList = config.characterList,\n      text = config.text;\n\n\n  if (text && !characterList) {\n    config.characterList = List(Repeat(CharacterMetadata.EMPTY, text.length));\n  }\n\n  return config;\n};\n\nvar ContentBlock = function (_ContentBlockRecord) {\n  _inherits(ContentBlock, _ContentBlockRecord);\n\n  function ContentBlock(config) {\n    _classCallCheck(this, ContentBlock);\n\n    return _possibleConstructorReturn(this, _ContentBlockRecord.call(this, decorateCharacterList(config)));\n  }\n\n  ContentBlock.prototype.getKey = function getKey() {\n    return this.get('key');\n  };\n\n  ContentBlock.prototype.getType = function getType() {\n    return this.get('type');\n  };\n\n  ContentBlock.prototype.getText = function getText() {\n    return this.get('text');\n  };\n\n  ContentBlock.prototype.getCharacterList = function getCharacterList() {\n    return this.get('characterList');\n  };\n\n  ContentBlock.prototype.getLength = function getLength() {\n    return this.getText().length;\n  };\n\n  ContentBlock.prototype.getDepth = function getDepth() {\n    return this.get('depth');\n  };\n\n  ContentBlock.prototype.getData = function getData() {\n    return this.get('data');\n  };\n\n  ContentBlock.prototype.getInlineStyleAt = function getInlineStyleAt(offset) {\n    var character = this.getCharacterList().get(offset);\n    return character ? character.getStyle() : EMPTY_SET;\n  };\n\n  ContentBlock.prototype.getEntityAt = function getEntityAt(offset) {\n    var character = this.getCharacterList().get(offset);\n    return character ? character.getEntity() : null;\n  };\n\n  /**\n   * Execute a callback for every contiguous range of styles within the block.\n   */\n\n\n  ContentBlock.prototype.findStyleRanges = function findStyleRanges(filterFn, callback) {\n    findRangesImmutable(this.getCharacterList(), haveEqualStyle, filterFn, callback);\n  };\n\n  /**\n   * Execute a callback for every contiguous range of entities within the block.\n   */\n\n\n  ContentBlock.prototype.findEntityRanges = function findEntityRanges(filterFn, callback) {\n    findRangesImmutable(this.getCharacterList(), haveEqualEntity, filterFn, callback);\n  };\n\n  return ContentBlock;\n}(ContentBlockRecord);\n\nfunction haveEqualStyle(charA, charB) {\n  return charA.getStyle() === charB.getStyle();\n}\n\nfunction haveEqualEntity(charA, charB) {\n  return charA.getEntity() === charB.getEntity();\n}\n\nmodule.exports = ContentBlock;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/ContentBlock.js\n// module id = 76\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n/**\n * Unicode-enabled replacesments for basic String functions.\n *\n * All the functions in this module assume that the input string is a valid\n * UTF-16 encoding of a Unicode sequence. If it's not the case, the behavior\n * will be undefined.\n *\n * WARNING: Since this module is typechecks-enforced, you may find new bugs\n * when replacing normal String functions with ones provided here.\n */\n\n'use strict';\n\nvar invariant = require('./invariant');\n\n// These two ranges are consecutive so anything in [HIGH_START, LOW_END] is a\n// surrogate code unit.\nvar SURROGATE_HIGH_START = 0xD800;\nvar SURROGATE_HIGH_END = 0xDBFF;\nvar SURROGATE_LOW_START = 0xDC00;\nvar SURROGATE_LOW_END = 0xDFFF;\nvar SURROGATE_UNITS_REGEX = /[\\uD800-\\uDFFF]/;\n\n/**\n * @param {number} codeUnit   A Unicode code-unit, in range [0, 0x10FFFF]\n * @return {boolean}          Whether code-unit is in a surrogate (hi/low) range\n */\nfunction isCodeUnitInSurrogateRange(codeUnit) {\n  return SURROGATE_HIGH_START <= codeUnit && codeUnit <= SURROGATE_LOW_END;\n}\n\n/**\n * Returns whether the two characters starting at `index` form a surrogate pair.\n * For example, given the string s = \"\\uD83D\\uDE0A\", (s, 0) returns true and\n * (s, 1) returns false.\n *\n * @param {string} str\n * @param {number} index\n * @return {boolean}\n */\nfunction isSurrogatePair(str, index) {\n  !(0 <= index && index < str.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'isSurrogatePair: Invalid index %s for string length %s.', index, str.length) : invariant(false) : void 0;\n  if (index + 1 === str.length) {\n    return false;\n  }\n  var first = str.charCodeAt(index);\n  var second = str.charCodeAt(index + 1);\n  return SURROGATE_HIGH_START <= first && first <= SURROGATE_HIGH_END && SURROGATE_LOW_START <= second && second <= SURROGATE_LOW_END;\n}\n\n/**\n * @param {string} str  Non-empty string\n * @return {boolean}    True if the input includes any surrogate code units\n */\nfunction hasSurrogateUnit(str) {\n  return SURROGATE_UNITS_REGEX.test(str);\n}\n\n/**\n * Return the length of the original Unicode character at given position in the\n * String by looking into the UTF-16 code unit; that is equal to 1 for any\n * non-surrogate characters in BMP ([U+0000..U+D7FF] and [U+E000, U+FFFF]); and\n * returns 2 for the hi/low surrogates ([U+D800..U+DFFF]), which are in fact\n * representing non-BMP characters ([U+10000..U+10FFFF]).\n *\n * Examples:\n * - '\\u0020' => 1\n * - '\\u3020' => 1\n * - '\\uD835' => 2\n * - '\\uD835\\uDDEF' => 2\n * - '\\uDDEF' => 2\n *\n * @param {string} str  Non-empty string\n * @param {number} pos  Position in the string to look for one code unit\n * @return {number}      Number 1 or 2\n */\nfunction getUTF16Length(str, pos) {\n  return 1 + isCodeUnitInSurrogateRange(str.charCodeAt(pos));\n}\n\n/**\n * Fully Unicode-enabled replacement for String#length\n *\n * @param {string} str  Valid Unicode string\n * @return {number}     The number of Unicode characters in the string\n */\nfunction strlen(str) {\n  // Call the native functions if there's no surrogate char\n  if (!hasSurrogateUnit(str)) {\n    return str.length;\n  }\n\n  var len = 0;\n  for (var pos = 0; pos < str.length; pos += getUTF16Length(str, pos)) {\n    len++;\n  }\n  return len;\n}\n\n/**\n * Fully Unicode-enabled replacement for String#substr()\n *\n * @param {string} str      Valid Unicode string\n * @param {number} start    Location in Unicode sequence to begin extracting\n * @param {?number} length  The number of Unicode characters to extract\n *                          (default: to the end of the string)\n * @return {string}         Extracted sub-string\n */\nfunction substr(str, start, length) {\n  start = start || 0;\n  length = length === undefined ? Infinity : length || 0;\n\n  // Call the native functions if there's no surrogate char\n  if (!hasSurrogateUnit(str)) {\n    return str.substr(start, length);\n  }\n\n  // Obvious cases\n  var size = str.length;\n  if (size <= 0 || start > size || length <= 0) {\n    return '';\n  }\n\n  // Find the actual starting position\n  var posA = 0;\n  if (start > 0) {\n    for (; start > 0 && posA < size; start--) {\n      posA += getUTF16Length(str, posA);\n    }\n    if (posA >= size) {\n      return '';\n    }\n  } else if (start < 0) {\n    for (posA = size; start < 0 && 0 < posA; start++) {\n      posA -= getUTF16Length(str, posA - 1);\n    }\n    if (posA < 0) {\n      posA = 0;\n    }\n  }\n\n  // Find the actual ending position\n  var posB = size;\n  if (length < size) {\n    for (posB = posA; length > 0 && posB < size; length--) {\n      posB += getUTF16Length(str, posB);\n    }\n  }\n\n  return str.substring(posA, posB);\n}\n\n/**\n * Fully Unicode-enabled replacement for String#substring()\n *\n * @param {string} str    Valid Unicode string\n * @param {number} start  Location in Unicode sequence to begin extracting\n * @param {?number} end   Location in Unicode sequence to end extracting\n *                        (default: end of the string)\n * @return {string}       Extracted sub-string\n */\nfunction substring(str, start, end) {\n  start = start || 0;\n  end = end === undefined ? Infinity : end || 0;\n\n  if (start < 0) {\n    start = 0;\n  }\n  if (end < 0) {\n    end = 0;\n  }\n\n  var length = Math.abs(end - start);\n  start = start < end ? start : end;\n  return substr(str, start, length);\n}\n\n/**\n * Get a list of Unicode code-points from a String\n *\n * @param {string} str        Valid Unicode string\n * @return {array<number>}    A list of code-points in [0..0x10FFFF]\n */\nfunction getCodePoints(str) {\n  var codePoints = [];\n  for (var pos = 0; pos < str.length; pos += getUTF16Length(str, pos)) {\n    codePoints.push(str.codePointAt(pos));\n  }\n  return codePoints;\n}\n\nvar UnicodeUtils = {\n  getCodePoints: getCodePoints,\n  getUTF16Length: getUTF16Length,\n  hasSurrogateUnit: hasSurrogateUnit,\n  isCodeUnitInSurrogateRange: isCodeUnitInSurrogateRange,\n  isSurrogatePair: isSurrogatePair,\n  strlen: strlen,\n  substring: substring,\n  substr: substr\n};\n\nmodule.exports = UnicodeUtils;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/UnicodeUtils.js\n// module id = 77\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule SelectionState\n * @format\n * \n */\n\n'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar Immutable = require('immutable');\n\nvar Record = Immutable.Record;\n\n\nvar defaultRecord = {\n  anchorKey: '',\n  anchorOffset: 0,\n  focusKey: '',\n  focusOffset: 0,\n  isBackward: false,\n  hasFocus: false\n};\n\nvar SelectionStateRecord = Record(defaultRecord);\n\nvar SelectionState = function (_SelectionStateRecord) {\n  _inherits(SelectionState, _SelectionStateRecord);\n\n  function SelectionState() {\n    _classCallCheck(this, SelectionState);\n\n    return _possibleConstructorReturn(this, _SelectionStateRecord.apply(this, arguments));\n  }\n\n  SelectionState.prototype.serialize = function serialize() {\n    return 'Anchor: ' + this.getAnchorKey() + ':' + this.getAnchorOffset() + ', ' + 'Focus: ' + this.getFocusKey() + ':' + this.getFocusOffset() + ', ' + 'Is Backward: ' + String(this.getIsBackward()) + ', ' + 'Has Focus: ' + String(this.getHasFocus());\n  };\n\n  SelectionState.prototype.getAnchorKey = function getAnchorKey() {\n    return this.get('anchorKey');\n  };\n\n  SelectionState.prototype.getAnchorOffset = function getAnchorOffset() {\n    return this.get('anchorOffset');\n  };\n\n  SelectionState.prototype.getFocusKey = function getFocusKey() {\n    return this.get('focusKey');\n  };\n\n  SelectionState.prototype.getFocusOffset = function getFocusOffset() {\n    return this.get('focusOffset');\n  };\n\n  SelectionState.prototype.getIsBackward = function getIsBackward() {\n    return this.get('isBackward');\n  };\n\n  SelectionState.prototype.getHasFocus = function getHasFocus() {\n    return this.get('hasFocus');\n  };\n\n  /**\n   * Return whether the specified range overlaps with an edge of the\n   * SelectionState.\n   */\n\n\n  SelectionState.prototype.hasEdgeWithin = function hasEdgeWithin(blockKey, start, end) {\n    var anchorKey = this.getAnchorKey();\n    var focusKey = this.getFocusKey();\n\n    if (anchorKey === focusKey && anchorKey === blockKey) {\n      var selectionStart = this.getStartOffset();\n      var selectionEnd = this.getEndOffset();\n      return start <= selectionEnd && selectionStart <= end;\n    }\n\n    if (blockKey !== anchorKey && blockKey !== focusKey) {\n      return false;\n    }\n\n    var offsetToCheck = blockKey === anchorKey ? this.getAnchorOffset() : this.getFocusOffset();\n\n    return start <= offsetToCheck && end >= offsetToCheck;\n  };\n\n  SelectionState.prototype.isCollapsed = function isCollapsed() {\n    return this.getAnchorKey() === this.getFocusKey() && this.getAnchorOffset() === this.getFocusOffset();\n  };\n\n  SelectionState.prototype.getStartKey = function getStartKey() {\n    return this.getIsBackward() ? this.getFocusKey() : this.getAnchorKey();\n  };\n\n  SelectionState.prototype.getStartOffset = function getStartOffset() {\n    return this.getIsBackward() ? this.getFocusOffset() : this.getAnchorOffset();\n  };\n\n  SelectionState.prototype.getEndKey = function getEndKey() {\n    return this.getIsBackward() ? this.getAnchorKey() : this.getFocusKey();\n  };\n\n  SelectionState.prototype.getEndOffset = function getEndOffset() {\n    return this.getIsBackward() ? this.getAnchorOffset() : this.getFocusOffset();\n  };\n\n  SelectionState.createEmpty = function createEmpty(key) {\n    return new SelectionState({\n      anchorKey: key,\n      anchorOffset: 0,\n      focusKey: key,\n      focusOffset: 0,\n      isBackward: false,\n      hasFocus: false\n    });\n  };\n\n  return SelectionState;\n}(SelectionStateRecord);\n\nmodule.exports = SelectionState;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/SelectionState.js\n// module id = 83\n// module chunks = 2","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/**\n * This function is used to mark string literals representing CSS class names\n * so that they can be transformed statically. This allows for modularization\n * and minification of CSS class names.\n *\n * In static_upstream, this function is actually implemented, but it should\n * eventually be replaced with something more descriptive, and the transform\n * that is used in the main stack should be ported for use elsewhere.\n *\n * @param string|object className to modularize, or an object of key/values.\n *                      In the object case, the values are conditions that\n *                      determine if the className keys should be included.\n * @param [string ...]  Variable list of classNames in the string case.\n * @return string       Renderable space-separated CSS className.\n */\nfunction cx(classNames) {\n  if (typeof classNames == 'object') {\n    return Object.keys(classNames).filter(function (className) {\n      return classNames[className];\n    }).map(replace).join(' ');\n  }\n  return Array.prototype.map.call(arguments, replace).join(' ');\n}\n\nfunction replace(str) {\n  return str.replace(/\\//g, '-');\n}\n\nmodule.exports = cx;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/cx.js\n// module id = 84\n// module chunks = 2","const DEFAULT_MODE_DESKTOP = true\nconst MOBILE_MAX_WIDTH = 767\nconst DESKTOP_MIN_WIDTH = 768\nconst DEFAULT_WIDTH = 768\n\nfunction isMobile() {\n  if (!global.window) return !DEFAULT_MODE_DESKTOP\n  return window.innerWidth < DESKTOP_MIN_WIDTH\n}\nfunction isDesktop() {\n  if (!global.window) return DEFAULT_MODE_DESKTOP\n  return window.innerWidth > MOBILE_MAX_WIDTH\n}\n\nexport default {\n  defaultWidth: DEFAULT_WIDTH,\n  desktopWidth: DESKTOP_MIN_WIDTH,\n  mobileWidth: MOBILE_MAX_WIDTH,\n  isDesktop,\n  isMobile,\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/utils/responsive.js","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule BlockMapBuilder\n * @format\n * \n */\n\n'use strict';\n\nvar Immutable = require('immutable');\n\nvar OrderedMap = Immutable.OrderedMap;\n\n\nvar BlockMapBuilder = {\n  createFromArray: function createFromArray(blocks) {\n    return OrderedMap(blocks.map(function (block) {\n      return [block.getKey(), block];\n    }));\n  }\n};\n\nmodule.exports = BlockMapBuilder;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/BlockMapBuilder.js\n// module id = 91\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule findRangesImmutable\n * @format\n * \n */\n\n'use strict';\n\n/**\n * Search through an array to find contiguous stretches of elements that\n * match a specified filter function.\n *\n * When ranges are found, execute a specified `found` function to supply\n * the values to the caller.\n */\nfunction findRangesImmutable(haystack, areEqualFn, filterFn, foundFn) {\n  if (!haystack.size) {\n    return;\n  }\n\n  var cursor = 0;\n\n  haystack.reduce(function (value, nextValue, nextIndex) {\n    if (!areEqualFn(value, nextValue)) {\n      if (filterFn(value)) {\n        foundFn(cursor, nextIndex);\n      }\n      cursor = nextIndex;\n    }\n    return nextValue;\n  });\n\n  filterFn(haystack.last()) && foundFn(cursor, haystack.count());\n}\n\nmodule.exports = findRangesImmutable;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/findRangesImmutable.js\n// module id = 92\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule isEventHandled\n * @format\n * \n */\n\n'use strict';\n\n/**\n * Utility method for determining whether or not the value returned\n * from a handler indicates that it was handled.\n */\nfunction isEventHandled(value) {\n  return value === 'handled' || value === true;\n}\n\nmodule.exports = isEventHandled;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/isEventHandled.js\n// module id = 93\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule removeTextWithStrategy\n * @format\n * \n */\n\n'use strict';\n\nvar DraftModifier = require('./DraftModifier');\n\n/**\n * For a collapsed selection state, remove text based on the specified strategy.\n * If the selection state is not collapsed, remove the entire selected range.\n */\nfunction removeTextWithStrategy(editorState, strategy, direction) {\n  var selection = editorState.getSelection();\n  var content = editorState.getCurrentContent();\n  var target = selection;\n  if (selection.isCollapsed()) {\n    if (direction === 'forward') {\n      if (editorState.isSelectionAtEndOfContent()) {\n        return content;\n      }\n    } else if (editorState.isSelectionAtStartOfContent()) {\n      return content;\n    }\n\n    target = strategy(editorState);\n    if (target === selection) {\n      return content;\n    }\n  }\n  return DraftModifier.removeRange(content, target, direction);\n}\n\nmodule.exports = removeTextWithStrategy;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/removeTextWithStrategy.js\n// module id = 94\n// module chunks = 2","// removed by extract-text-webpack-plugin\nmodule.exports = {\"preview\":\"lQq327\",\"date\":\"t2Ob9m\",\"header\":\"_2kk3hN\",\"title\":\"Cfb3RR\",\"votes\":\"_3at1A7\",\"info\":\"_2-6RI9\",\"progressContainer\":\"ssLhPH\",\"progress\":\"_2KXwjO\",\"finished\":\"_25moSc\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/components/Preview/preview-style.css\n// module id = 113\n// module chunks = 2 3","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getContentStateFragment\n * @format\n * \n */\n\n'use strict';\n\nvar randomizeBlockMapKeys = require('./randomizeBlockMapKeys');\nvar removeEntitiesAtEdges = require('./removeEntitiesAtEdges');\n\nvar getContentStateFragment = function getContentStateFragment(contentState, selectionState) {\n  var startKey = selectionState.getStartKey();\n  var startOffset = selectionState.getStartOffset();\n  var endKey = selectionState.getEndKey();\n  var endOffset = selectionState.getEndOffset();\n\n  // Edge entities should be stripped to ensure that we don't preserve\n  // invalid partial entities when the fragment is reused. We do, however,\n  // preserve entities that are entirely within the selection range.\n  var contentWithoutEdgeEntities = removeEntitiesAtEdges(contentState, selectionState);\n\n  var blockMap = contentWithoutEdgeEntities.getBlockMap();\n  var blockKeys = blockMap.keySeq();\n  var startIndex = blockKeys.indexOf(startKey);\n  var endIndex = blockKeys.indexOf(endKey) + 1;\n\n  return randomizeBlockMapKeys(blockMap.slice(startIndex, endIndex).map(function (block, blockKey) {\n    var text = block.getText();\n    var chars = block.getCharacterList();\n\n    if (startKey === endKey) {\n      return block.merge({\n        text: text.slice(startOffset, endOffset),\n        characterList: chars.slice(startOffset, endOffset)\n      });\n    }\n\n    if (blockKey === startKey) {\n      return block.merge({\n        text: text.slice(startOffset),\n        characterList: chars.slice(startOffset)\n      });\n    }\n\n    if (blockKey === endKey) {\n      return block.merge({\n        text: text.slice(0, endOffset),\n        characterList: chars.slice(0, endOffset)\n      });\n    }\n\n    return block;\n  }));\n};\n\nmodule.exports = getContentStateFragment;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getContentStateFragment.js\n// module id = 114\n// module chunks = 2","'use strict';\n\nvar _assign = require('object-assign');\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEntity\n * @format\n * \n */\n\nvar DraftEntityInstance = require('./DraftEntityInstance');\nvar Immutable = require('immutable');\n\nvar invariant = require('fbjs/lib/invariant');\n\nvar Map = Immutable.Map;\n\n\nvar instances = Map();\nvar instanceKey = 0;\n\n/**\n * Temporary utility for generating the warnings\n */\nfunction logWarning(oldMethodCall, newMethodCall) {\n  console.warn('WARNING: ' + oldMethodCall + ' will be deprecated soon!\\nPlease use \"' + newMethodCall + '\" instead.');\n}\n\n/**\n * A \"document entity\" is an object containing metadata associated with a\n * piece of text in a ContentBlock.\n *\n * For example, a `link` entity might include a `uri` property. When a\n * ContentBlock is rendered in the browser, text that refers to that link\n * entity may be rendered as an anchor, with the `uri` as the href value.\n *\n * In a ContentBlock, every position in the text may correspond to zero\n * or one entities. This correspondence is tracked using a key string,\n * generated via DraftEntity.create() and used to obtain entity metadata\n * via DraftEntity.get().\n */\nvar DraftEntity = {\n  /**\n   * WARNING: This method will be deprecated soon!\n   * Please use 'contentState.getLastCreatedEntityKey' instead.\n   * ---\n   * Get the random key string from whatever entity was last created.\n   * We need this to support the new API, as part of transitioning to put Entity\n   * storage in contentState.\n   */\n  getLastCreatedEntityKey: function getLastCreatedEntityKey() {\n    logWarning('DraftEntity.getLastCreatedEntityKey', 'contentState.getLastCreatedEntityKey');\n    return DraftEntity.__getLastCreatedEntityKey();\n  },\n\n  /**\n   * WARNING: This method will be deprecated soon!\n   * Please use 'contentState.createEntity' instead.\n   * ---\n   * Create a DraftEntityInstance and store it for later retrieval.\n   *\n   * A random key string will be generated and returned. This key may\n   * be used to track the entity's usage in a ContentBlock, and for\n   * retrieving data about the entity at render time.\n   */\n  create: function create(type, mutability, data) {\n    logWarning('DraftEntity.create', 'contentState.createEntity');\n    return DraftEntity.__create(type, mutability, data);\n  },\n\n  /**\n   * WARNING: This method will be deprecated soon!\n   * Please use 'contentState.addEntity' instead.\n   * ---\n   * Add an existing DraftEntityInstance to the DraftEntity map. This is\n   * useful when restoring instances from the server.\n   */\n  add: function add(instance) {\n    logWarning('DraftEntity.add', 'contentState.addEntity');\n    return DraftEntity.__add(instance);\n  },\n\n  /**\n   * WARNING: This method will be deprecated soon!\n   * Please use 'contentState.getEntity' instead.\n   * ---\n   * Retrieve the entity corresponding to the supplied key string.\n   */\n  get: function get(key) {\n    logWarning('DraftEntity.get', 'contentState.getEntity');\n    return DraftEntity.__get(key);\n  },\n\n  /**\n   * WARNING: This method will be deprecated soon!\n   * Please use 'contentState.mergeEntityData' instead.\n   * ---\n   * Entity instances are immutable. If you need to update the data for an\n   * instance, this method will merge your data updates and return a new\n   * instance.\n   */\n  mergeData: function mergeData(key, toMerge) {\n    logWarning('DraftEntity.mergeData', 'contentState.mergeEntityData');\n    return DraftEntity.__mergeData(key, toMerge);\n  },\n\n  /**\n   * WARNING: This method will be deprecated soon!\n   * Please use 'contentState.replaceEntityData' instead.\n   * ---\n   * Completely replace the data for a given instance.\n   */\n  replaceData: function replaceData(key, newData) {\n    logWarning('DraftEntity.replaceData', 'contentState.replaceEntityData');\n    return DraftEntity.__replaceData(key, newData);\n  },\n\n  // ***********************************WARNING******************************\n  // --- the above public API will be deprecated in the next version of Draft!\n  // The methods below this line are private - don't call them directly.\n\n  /**\n   * Get the random key string from whatever entity was last created.\n   * We need this to support the new API, as part of transitioning to put Entity\n   * storage in contentState.\n   */\n  __getLastCreatedEntityKey: function __getLastCreatedEntityKey() {\n    return '' + instanceKey;\n  },\n\n  /**\n   * Create a DraftEntityInstance and store it for later retrieval.\n   *\n   * A random key string will be generated and returned. This key may\n   * be used to track the entity's usage in a ContentBlock, and for\n   * retrieving data about the entity at render time.\n   */\n  __create: function __create(type, mutability, data) {\n    return DraftEntity.__add(new DraftEntityInstance({ type: type, mutability: mutability, data: data || {} }));\n  },\n\n  /**\n   * Add an existing DraftEntityInstance to the DraftEntity map. This is\n   * useful when restoring instances from the server.\n   */\n  __add: function __add(instance) {\n    var key = '' + ++instanceKey;\n    instances = instances.set(key, instance);\n    return key;\n  },\n\n  /**\n   * Retrieve the entity corresponding to the supplied key string.\n   */\n  __get: function __get(key) {\n    var instance = instances.get(key);\n    !!!instance ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Unknown DraftEntity key: %s.', key) : invariant(false) : void 0;\n    return instance;\n  },\n\n  /**\n   * Entity instances are immutable. If you need to update the data for an\n   * instance, this method will merge your data updates and return a new\n   * instance.\n   */\n  __mergeData: function __mergeData(key, toMerge) {\n    var instance = DraftEntity.__get(key);\n    var newData = _extends({}, instance.getData(), toMerge);\n    var newInstance = instance.set('data', newData);\n    instances = instances.set(key, newInstance);\n    return newInstance;\n  },\n\n  /**\n   * Completely replace the data for a given instance.\n   */\n  __replaceData: function __replaceData(key, newData) {\n    var instance = DraftEntity.__get(key);\n    var newInstance = instance.set('data', newData);\n    instances = instances.set(key, newInstance);\n    return newInstance;\n  }\n};\n\nmodule.exports = DraftEntity;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftEntity.js\n// module id = 115\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftOffsetKey\n * @format\n * \n */\n\n'use strict';\n\nvar KEY_DELIMITER = '-';\n\nvar DraftOffsetKey = {\n  encode: function encode(blockKey, decoratorKey, leafKey) {\n    return blockKey + KEY_DELIMITER + decoratorKey + KEY_DELIMITER + leafKey;\n  },\n\n  decode: function decode(offsetKey) {\n    var _offsetKey$split = offsetKey.split(KEY_DELIMITER),\n        blockKey = _offsetKey$split[0],\n        decoratorKey = _offsetKey$split[1],\n        leafKey = _offsetKey$split[2];\n\n    return {\n      blockKey: blockKey,\n      decoratorKey: parseInt(decoratorKey, 10),\n      leafKey: parseInt(leafKey, 10)\n    };\n  }\n};\n\nmodule.exports = DraftOffsetKey;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftOffsetKey.js\n// module id = 116\n// module chunks = 2","export default [\n  {\n    errorType: 'fieldIsRequired',\n    errorMessage: 'Dette felt skal udfyldes',\n  },\n  {\n    errorType: 'maxLengthExceeded',\n    errorMessage: 'Der er brugt for mange tegn',\n  },\n  {\n    errorType: 'isLessThanMinLength',\n    errorMessage: 'Dette felt er ikke langt nok',\n  },\n  {\n    errorType: 'isNotPhoneNumber',\n    errorMessage: 'Ikke valid telefonnummer',\n  },\n  {\n    errorType: 'isNotValidEmail',\n    errorMessage: 'Ikke valid email',\n  },\n  {\n    errorType: 'isNotValidTitle',\n    errorMessage: 'Titel er allerede brugt',\n  },\n  {\n    errorType: 'somethingWentWrong',\n    errorMessage: 'Der skete en fejl, prøv igen',\n  },\n]\n\n\n\n// WEBPACK FOOTER //\n// ./src/modules/Form/defaultErrors.js","import React from 'react'\nimport PropTypes from 'prop-types' // eslint-disable-line no-unused-vars\nimport styles from '../preview-style.css'\n\nconst propTypes = {\n  votes: PropTypes.number.isRequired,\n  votesLimit: PropTypes.number.isRequired,\n}\n\n// Add any default values for props\nconst defaultProps = {\n  votes: 10000,\n  votesLimit: 50000,\n}\n\nconst getWidth = (votes, limit) => {\n  /*\n   * If there are less than 5% the votes needed,\n   * represent the progress by using Math.sqrt\n   */\n  if (votes / limit * 100 <= 5) return Math.sqrt(votes) / Math.sqrt(limit) * 50\n  if (votes / limit * 100 <= 15) return Math.sqrt(votes) / Math.sqrt(limit) * 55\n  /*\n   * Else use a linear representation\n   */\n  return votes / limit * 100\n}\n\nfunction VotesIndicator({ votes = 20356, votesLimit }) {\n  const progress = parseInt(votes, 10)\n  return (\n    <div className={styles.progressContainer}>\n      <div\n        className={styles.progress}\n        style={{ width: `${getWidth(progress, votesLimit)}%` }}\n      />\n    </div>\n  )\n}\n\nVotesIndicator.displayName = 'VotesIndicator'\nVotesIndicator.propTypes = propTypes\nVotesIndicator.defaultProps = defaultProps\n\nexport default VotesIndicator\n\n\n\n// WEBPACK FOOTER //\n// ./src/components/Preview/VotesIndicator/VotesIndicator.js","\"use strict\";\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\nfunction makeEmptyFunction(arg) {\n  return function () {\n    return arg;\n  };\n}\n\n/**\n * This function accepts and discards inputs; it has no side effects. This is\n * primarily useful idiomatically for overridable function endpoints which\n * always need to be callable, since JS lacks a null-call idiom ala Cocoa.\n */\nvar emptyFunction = function emptyFunction() {};\n\nemptyFunction.thatReturns = makeEmptyFunction;\nemptyFunction.thatReturnsFalse = makeEmptyFunction(false);\nemptyFunction.thatReturnsTrue = makeEmptyFunction(true);\nemptyFunction.thatReturnsNull = makeEmptyFunction(null);\nemptyFunction.thatReturnsThis = function () {\n  return this;\n};\nemptyFunction.thatReturnsArgument = function (arg) {\n  return arg;\n};\n\nmodule.exports = emptyFunction;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/emptyFunction.js\n// module id = 156\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ContentState\n * @format\n * \n */\n\n'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar BlockMapBuilder = require('./BlockMapBuilder');\nvar CharacterMetadata = require('./CharacterMetadata');\nvar ContentBlock = require('./ContentBlock');\nvar ContentBlockNode = require('./ContentBlockNode');\nvar DraftEntity = require('./DraftEntity');\nvar DraftFeatureFlags = require('./DraftFeatureFlags');\nvar Immutable = require('immutable');\nvar SelectionState = require('./SelectionState');\n\nvar generateRandomKey = require('./generateRandomKey');\nvar sanitizeDraftText = require('./sanitizeDraftText');\n\nvar List = Immutable.List,\n    Record = Immutable.Record,\n    Repeat = Immutable.Repeat;\n\n\nvar experimentalTreeDataSupport = DraftFeatureFlags.draft_tree_data_support;\n\nvar defaultRecord = {\n  entityMap: null,\n  blockMap: null,\n  selectionBefore: null,\n  selectionAfter: null\n};\n\nvar ContentBlockNodeRecord = experimentalTreeDataSupport ? ContentBlockNode : ContentBlock;\n\nvar ContentStateRecord = Record(defaultRecord);\n\nvar ContentState = function (_ContentStateRecord) {\n  _inherits(ContentState, _ContentStateRecord);\n\n  function ContentState() {\n    _classCallCheck(this, ContentState);\n\n    return _possibleConstructorReturn(this, _ContentStateRecord.apply(this, arguments));\n  }\n\n  ContentState.prototype.getEntityMap = function getEntityMap() {\n    // TODO: update this when we fully remove DraftEntity\n    return DraftEntity;\n  };\n\n  ContentState.prototype.getBlockMap = function getBlockMap() {\n    return this.get('blockMap');\n  };\n\n  ContentState.prototype.getSelectionBefore = function getSelectionBefore() {\n    return this.get('selectionBefore');\n  };\n\n  ContentState.prototype.getSelectionAfter = function getSelectionAfter() {\n    return this.get('selectionAfter');\n  };\n\n  ContentState.prototype.getBlockForKey = function getBlockForKey(key) {\n    var block = this.getBlockMap().get(key);\n    return block;\n  };\n\n  ContentState.prototype.getKeyBefore = function getKeyBefore(key) {\n    return this.getBlockMap().reverse().keySeq().skipUntil(function (v) {\n      return v === key;\n    }).skip(1).first();\n  };\n\n  ContentState.prototype.getKeyAfter = function getKeyAfter(key) {\n    return this.getBlockMap().keySeq().skipUntil(function (v) {\n      return v === key;\n    }).skip(1).first();\n  };\n\n  ContentState.prototype.getBlockAfter = function getBlockAfter(key) {\n    return this.getBlockMap().skipUntil(function (_, k) {\n      return k === key;\n    }).skip(1).first();\n  };\n\n  ContentState.prototype.getBlockBefore = function getBlockBefore(key) {\n    return this.getBlockMap().reverse().skipUntil(function (_, k) {\n      return k === key;\n    }).skip(1).first();\n  };\n\n  ContentState.prototype.getBlocksAsArray = function getBlocksAsArray() {\n    return this.getBlockMap().toArray();\n  };\n\n  ContentState.prototype.getFirstBlock = function getFirstBlock() {\n    return this.getBlockMap().first();\n  };\n\n  ContentState.prototype.getLastBlock = function getLastBlock() {\n    return this.getBlockMap().last();\n  };\n\n  ContentState.prototype.getPlainText = function getPlainText(delimiter) {\n    return this.getBlockMap().map(function (block) {\n      return block ? block.getText() : '';\n    }).join(delimiter || '\\n');\n  };\n\n  ContentState.prototype.getLastCreatedEntityKey = function getLastCreatedEntityKey() {\n    // TODO: update this when we fully remove DraftEntity\n    return DraftEntity.__getLastCreatedEntityKey();\n  };\n\n  ContentState.prototype.hasText = function hasText() {\n    var blockMap = this.getBlockMap();\n    return blockMap.size > 1 || blockMap.first().getLength() > 0;\n  };\n\n  ContentState.prototype.createEntity = function createEntity(type, mutability, data) {\n    // TODO: update this when we fully remove DraftEntity\n    DraftEntity.__create(type, mutability, data);\n    return this;\n  };\n\n  ContentState.prototype.mergeEntityData = function mergeEntityData(key, toMerge) {\n    // TODO: update this when we fully remove DraftEntity\n    DraftEntity.__mergeData(key, toMerge);\n    return this;\n  };\n\n  ContentState.prototype.replaceEntityData = function replaceEntityData(key, newData) {\n    // TODO: update this when we fully remove DraftEntity\n    DraftEntity.__replaceData(key, newData);\n    return this;\n  };\n\n  ContentState.prototype.addEntity = function addEntity(instance) {\n    // TODO: update this when we fully remove DraftEntity\n    DraftEntity.__add(instance);\n    return this;\n  };\n\n  ContentState.prototype.getEntity = function getEntity(key) {\n    // TODO: update this when we fully remove DraftEntity\n    return DraftEntity.__get(key);\n  };\n\n  ContentState.createFromBlockArray = function createFromBlockArray(\n  // TODO: update flow type when we completely deprecate the old entity API\n  blocks, entityMap) {\n    // TODO: remove this when we completely deprecate the old entity API\n    var theBlocks = Array.isArray(blocks) ? blocks : blocks.contentBlocks;\n    var blockMap = BlockMapBuilder.createFromArray(theBlocks);\n    var selectionState = blockMap.isEmpty() ? new SelectionState() : SelectionState.createEmpty(blockMap.first().getKey());\n    return new ContentState({\n      blockMap: blockMap,\n      entityMap: entityMap || DraftEntity,\n      selectionBefore: selectionState,\n      selectionAfter: selectionState\n    });\n  };\n\n  ContentState.createFromText = function createFromText(text) {\n    var delimiter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : /\\r\\n?|\\n/g;\n\n    var strings = text.split(delimiter);\n    var blocks = strings.map(function (block) {\n      block = sanitizeDraftText(block);\n      return new ContentBlockNodeRecord({\n        key: generateRandomKey(),\n        text: block,\n        type: 'unstyled',\n        characterList: List(Repeat(CharacterMetadata.EMPTY, block.length))\n      });\n    });\n    return ContentState.createFromBlockArray(blocks);\n  };\n\n  return ContentState;\n}(ContentStateRecord);\n\nmodule.exports = ContentState;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/ContentState.js\n// module id = 157\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule sanitizeDraftText\n * @format\n * \n */\n\n'use strict';\n\nvar REGEX_BLOCK_DELIMITER = new RegExp('\\r', 'g');\n\nfunction sanitizeDraftText(input) {\n  return input.replace(REGEX_BLOCK_DELIMITER, '');\n}\n\nmodule.exports = sanitizeDraftText;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/sanitizeDraftText.js\n// module id = 158\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n * \n */\n\n/**\n * Constants to represent text directionality\n *\n * Also defines a *global* direciton, to be used in bidi algorithms as a\n * default fallback direciton, when no better direction is found or provided.\n *\n * NOTE: Use `setGlobalDir()`, or update `initGlobalDir()`, to set the initial\n *       global direction value based on the application.\n *\n * Part of the implementation of Unicode Bidirectional Algorithm (UBA)\n * Unicode Standard Annex #9 (UAX9)\n * http://www.unicode.org/reports/tr9/\n */\n\n'use strict';\n\nvar invariant = require('./invariant');\n\nvar NEUTRAL = 'NEUTRAL'; // No strong direction\nvar LTR = 'LTR'; // Left-to-Right direction\nvar RTL = 'RTL'; // Right-to-Left direction\n\nvar globalDir = null;\n\n// == Helpers ==\n\n/**\n * Check if a directionality value is a Strong one\n */\nfunction isStrong(dir) {\n  return dir === LTR || dir === RTL;\n}\n\n/**\n * Get string value to be used for `dir` HTML attribute or `direction` CSS\n * property.\n */\nfunction getHTMLDir(dir) {\n  !isStrong(dir) ? process.env.NODE_ENV !== 'production' ? invariant(false, '`dir` must be a strong direction to be converted to HTML Direction') : invariant(false) : void 0;\n  return dir === LTR ? 'ltr' : 'rtl';\n}\n\n/**\n * Get string value to be used for `dir` HTML attribute or `direction` CSS\n * property, but returns null if `dir` has same value as `otherDir`.\n * `null`.\n */\nfunction getHTMLDirIfDifferent(dir, otherDir) {\n  !isStrong(dir) ? process.env.NODE_ENV !== 'production' ? invariant(false, '`dir` must be a strong direction to be converted to HTML Direction') : invariant(false) : void 0;\n  !isStrong(otherDir) ? process.env.NODE_ENV !== 'production' ? invariant(false, '`otherDir` must be a strong direction to be converted to HTML Direction') : invariant(false) : void 0;\n  return dir === otherDir ? null : getHTMLDir(dir);\n}\n\n// == Global Direction ==\n\n/**\n * Set the global direction.\n */\nfunction setGlobalDir(dir) {\n  globalDir = dir;\n}\n\n/**\n * Initialize the global direction\n */\nfunction initGlobalDir() {\n  setGlobalDir(LTR);\n}\n\n/**\n * Get the global direction\n */\nfunction getGlobalDir() {\n  if (!globalDir) {\n    this.initGlobalDir();\n  }\n  !globalDir ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Global direction not set.') : invariant(false) : void 0;\n  return globalDir;\n}\n\nvar UnicodeBidiDirection = {\n  // Values\n  NEUTRAL: NEUTRAL,\n  LTR: LTR,\n  RTL: RTL,\n  // Helpers\n  isStrong: isStrong,\n  getHTMLDir: getHTMLDir,\n  getHTMLDirIfDifferent: getHTMLDirIfDifferent,\n  // Global Direction\n  setGlobalDir: setGlobalDir,\n  initGlobalDir: initGlobalDir,\n  getGlobalDir: getGlobalDir\n};\n\nmodule.exports = UnicodeBidiDirection;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/UnicodeBidiDirection.js\n// module id = 159\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DefaultDraftBlockRenderMap\n * @format\n * \n */\n\n'use strict';\n\nvar _require = require('immutable'),\n    Map = _require.Map;\n\nvar React = require('react');\n\nvar cx = require('fbjs/lib/cx');\n\nvar UL_WRAP = React.createElement('ul', { className: cx('public/DraftStyleDefault/ul') });\nvar OL_WRAP = React.createElement('ol', { className: cx('public/DraftStyleDefault/ol') });\nvar PRE_WRAP = React.createElement('pre', { className: cx('public/DraftStyleDefault/pre') });\n\nvar DefaultDraftBlockRenderMap = Map({\n  'header-one': {\n    element: 'h1'\n  },\n  'header-two': {\n    element: 'h2'\n  },\n  'header-three': {\n    element: 'h3'\n  },\n  'header-four': {\n    element: 'h4'\n  },\n  'header-five': {\n    element: 'h5'\n  },\n  'header-six': {\n    element: 'h6'\n  },\n  'unordered-list-item': {\n    element: 'li',\n    wrapper: UL_WRAP\n  },\n  'ordered-list-item': {\n    element: 'li',\n    wrapper: OL_WRAP\n  },\n  blockquote: {\n    element: 'blockquote'\n  },\n  atomic: {\n    element: 'figure'\n  },\n  'code-block': {\n    element: 'pre',\n    wrapper: PRE_WRAP\n  },\n  unstyled: {\n    element: 'div',\n    aliasedElements: ['p']\n  }\n});\n\nmodule.exports = DefaultDraftBlockRenderMap;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DefaultDraftBlockRenderMap.js\n// module id = 160\n// module chunks = 2","\"use strict\";\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nmodule.exports = {\n  BACKSPACE: 8,\n  TAB: 9,\n  RETURN: 13,\n  ALT: 18,\n  ESC: 27,\n  SPACE: 32,\n  PAGE_UP: 33,\n  PAGE_DOWN: 34,\n  END: 35,\n  HOME: 36,\n  LEFT: 37,\n  UP: 38,\n  RIGHT: 39,\n  DOWN: 40,\n  DELETE: 46,\n  COMMA: 188,\n  PERIOD: 190,\n  A: 65,\n  Z: 90,\n  ZERO: 48,\n  NUMPAD_0: 96,\n  NUMPAD_9: 105\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/Keys.js\n// module id = 161\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getEntityKeyForSelection\n * @format\n * \n */\n\n'use strict';\n\n/**\n * Return the entity key that should be used when inserting text for the\n * specified target selection, only if the entity is `MUTABLE`. `IMMUTABLE`\n * and `SEGMENTED` entities should not be used for insertion behavior.\n */\nfunction getEntityKeyForSelection(contentState, targetSelection) {\n  var entityKey;\n\n  if (targetSelection.isCollapsed()) {\n    var key = targetSelection.getAnchorKey();\n    var offset = targetSelection.getAnchorOffset();\n    if (offset > 0) {\n      entityKey = contentState.getBlockForKey(key).getEntityAt(offset - 1);\n      if (entityKey !== contentState.getBlockForKey(key).getEntityAt(offset)) {\n        return null;\n      }\n      return filterKey(contentState.getEntityMap(), entityKey);\n    }\n    return null;\n  }\n\n  var startKey = targetSelection.getStartKey();\n  var startOffset = targetSelection.getStartOffset();\n  var startBlock = contentState.getBlockForKey(startKey);\n\n  entityKey = startOffset === startBlock.getLength() ? null : startBlock.getEntityAt(startOffset);\n\n  return filterKey(contentState.getEntityMap(), entityKey);\n}\n\n/**\n * Determine whether an entity key corresponds to a `MUTABLE` entity. If so,\n * return it. If not, return null.\n */\nfunction filterKey(entityMap, entityKey) {\n  if (entityKey) {\n    var entity = entityMap.__get(entityKey);\n    return entity.getMutability() === 'MUTABLE' ? entityKey : null;\n  }\n  return null;\n}\n\nmodule.exports = getEntityKeyForSelection;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getEntityKeyForSelection.js\n// module id = 162\n// module chunks = 2","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\nvar isTextNode = require('./isTextNode');\n\n/*eslint-disable no-bitwise */\n\n/**\n * Checks if a given DOM node contains or is another DOM node.\n */\nfunction containsNode(outerNode, innerNode) {\n  if (!outerNode || !innerNode) {\n    return false;\n  } else if (outerNode === innerNode) {\n    return true;\n  } else if (isTextNode(outerNode)) {\n    return false;\n  } else if (isTextNode(innerNode)) {\n    return containsNode(outerNode, innerNode.parentNode);\n  } else if ('contains' in outerNode) {\n    return outerNode.contains(innerNode);\n  } else if (outerNode.compareDocumentPosition) {\n    return !!(outerNode.compareDocumentPosition(innerNode) & 16);\n  } else {\n    return false;\n  }\n}\n\nmodule.exports = containsNode;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/containsNode.js\n// module id = 163\n// module chunks = 2","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar getStyleProperty = require('./getStyleProperty');\n\n/**\n * @param {DOMNode} element [description]\n * @param {string} name Overflow style property name.\n * @return {boolean} True if the supplied ndoe is scrollable.\n */\nfunction _isNodeScrollable(element, name) {\n  var overflow = Style.get(element, name);\n  return overflow === 'auto' || overflow === 'scroll';\n}\n\n/**\n * Utilities for querying and mutating style properties.\n */\nvar Style = {\n  /**\n   * Gets the style property for the supplied node. This will return either the\n   * computed style, if available, or the declared style.\n   *\n   * @param {DOMNode} node\n   * @param {string} name Style property name.\n   * @return {?string} Style property value.\n   */\n  get: getStyleProperty,\n\n  /**\n   * Determines the nearest ancestor of a node that is scrollable.\n   *\n   * NOTE: This can be expensive if used repeatedly or on a node nested deeply.\n   *\n   * @param {?DOMNode} node Node from which to start searching.\n   * @return {?DOMWindow|DOMElement} Scroll parent of the supplied node.\n   */\n  getScrollParent: function getScrollParent(node) {\n    if (!node) {\n      return null;\n    }\n    var ownerDocument = node.ownerDocument;\n    while (node && node !== ownerDocument.body) {\n      if (_isNodeScrollable(node, 'overflow') || _isNodeScrollable(node, 'overflowY') || _isNodeScrollable(node, 'overflowX')) {\n        return node;\n      }\n      node = node.parentNode;\n    }\n    return ownerDocument.defaultView || ownerDocument.parentWindow;\n  }\n\n};\n\nmodule.exports = Style;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/Style.js\n// module id = 164\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n'use strict';\n\nvar getDocumentScrollElement = require('./getDocumentScrollElement');\nvar getUnboundedScrollPosition = require('./getUnboundedScrollPosition');\n\n/**\n * Gets the scroll position of the supplied element or window.\n *\n * The return values are bounded. This means that if the scroll position is\n * negative or exceeds the element boundaries (which is possible using inertial\n * scrolling), you will get zero or the maximum scroll position, respectively.\n *\n * If you need the unbound scroll position, use `getUnboundedScrollPosition`.\n *\n * @param {DOMWindow|DOMElement} scrollable\n * @return {object} Map with `x` and `y` keys.\n */\nfunction getScrollPosition(scrollable) {\n  var documentScrollElement = getDocumentScrollElement(scrollable.ownerDocument || scrollable.document);\n  if (scrollable.Window && scrollable instanceof scrollable.Window) {\n    scrollable = documentScrollElement;\n  }\n  var scrollPosition = getUnboundedScrollPosition(scrollable);\n\n  var viewport = scrollable === documentScrollElement ? scrollable.ownerDocument.documentElement : scrollable;\n\n  var xMax = scrollable.scrollWidth - viewport.clientWidth;\n  var yMax = scrollable.scrollHeight - viewport.clientHeight;\n\n  scrollPosition.x = Math.max(0, Math.min(scrollPosition.x, xMax));\n  scrollPosition.y = Math.max(0, Math.min(scrollPosition.y, yMax));\n\n  return scrollPosition;\n}\n\nmodule.exports = getScrollPosition;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/getScrollPosition.js\n// module id = 165\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule findAncestorOffsetKey\n * @format\n * \n */\n\n'use strict';\n\nvar getSelectionOffsetKeyForNode = require('./getSelectionOffsetKeyForNode');\n\n/**\n * Get the key from the node's nearest offset-aware ancestor.\n */\nfunction findAncestorOffsetKey(node) {\n  var searchNode = node;\n  while (searchNode && searchNode !== document.documentElement) {\n    var key = getSelectionOffsetKeyForNode(searchNode);\n    if (key != null) {\n      return key;\n    }\n    searchNode = searchNode.parentNode;\n  }\n  return null;\n}\n\nmodule.exports = findAncestorOffsetKey;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/findAncestorOffsetKey.js\n// module id = 166\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule KeyBindingUtil\n * @format\n * \n */\n\n'use strict';\n\nvar UserAgent = require('fbjs/lib/UserAgent');\n\nvar isOSX = UserAgent.isPlatform('Mac OS X');\n\nvar KeyBindingUtil = {\n  /**\n   * Check whether the ctrlKey modifier is *not* being used in conjunction with\n   * the altKey modifier. If they are combined, the result is an `altGraph`\n   * key modifier, which should not be handled by this set of key bindings.\n   */\n  isCtrlKeyCommand: function isCtrlKeyCommand(e) {\n    return !!e.ctrlKey && !e.altKey;\n  },\n\n  isOptionKeyCommand: function isOptionKeyCommand(e) {\n    return isOSX && e.altKey;\n  },\n\n  hasCommandModifier: function hasCommandModifier(e) {\n    return isOSX ? !!e.metaKey && !e.altKey : KeyBindingUtil.isCtrlKeyCommand(e);\n  }\n};\n\nmodule.exports = KeyBindingUtil;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/KeyBindingUtil.js\n// module id = 167\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule moveSelectionBackward\n * @format\n * \n */\n\n'use strict';\n\n/**\n * Given a collapsed selection, move the focus `maxDistance` backward within\n * the selected block. If the selection will go beyond the start of the block,\n * move focus to the end of the previous block, but no further.\n *\n * This function is not Unicode-aware, so surrogate pairs will be treated\n * as having length 2.\n */\nfunction moveSelectionBackward(editorState, maxDistance) {\n  var selection = editorState.getSelection();\n  var content = editorState.getCurrentContent();\n  var key = selection.getStartKey();\n  var offset = selection.getStartOffset();\n\n  var focusKey = key;\n  var focusOffset = 0;\n\n  if (maxDistance > offset) {\n    var keyBefore = content.getKeyBefore(key);\n    if (keyBefore == null) {\n      focusKey = key;\n    } else {\n      focusKey = keyBefore;\n      var blockBefore = content.getBlockForKey(keyBefore);\n      focusOffset = blockBefore.getText().length;\n    }\n  } else {\n    focusOffset = offset - maxDistance;\n  }\n\n  return selection.merge({\n    focusKey: focusKey,\n    focusOffset: focusOffset,\n    isBackward: true\n  });\n}\n\nmodule.exports = moveSelectionBackward;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/moveSelectionBackward.js\n// module id = 168\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule Draft\n * @format\n * \n */\n\n'use strict';\n\nvar AtomicBlockUtils = require('./AtomicBlockUtils');\nvar BlockMapBuilder = require('./BlockMapBuilder');\nvar CharacterMetadata = require('./CharacterMetadata');\nvar CompositeDraftDecorator = require('./CompositeDraftDecorator');\nvar ContentBlock = require('./ContentBlock');\nvar ContentState = require('./ContentState');\nvar DefaultDraftBlockRenderMap = require('./DefaultDraftBlockRenderMap');\nvar DefaultDraftInlineStyle = require('./DefaultDraftInlineStyle');\nvar DraftEditor = require('./DraftEditor.react');\nvar DraftEditorBlock = require('./DraftEditorBlock.react');\nvar DraftEntity = require('./DraftEntity');\nvar DraftModifier = require('./DraftModifier');\nvar DraftEntityInstance = require('./DraftEntityInstance');\nvar EditorState = require('./EditorState');\nvar KeyBindingUtil = require('./KeyBindingUtil');\nvar RichTextEditorUtil = require('./RichTextEditorUtil');\nvar SelectionState = require('./SelectionState');\n\nvar convertFromDraftStateToRaw = require('./convertFromDraftStateToRaw');\nvar convertFromHTMLToContentBlocks = require('./convertFromHTMLToContentBlocks');\nvar convertFromRawToDraftState = require('./convertFromRawToDraftState');\nvar generateRandomKey = require('./generateRandomKey');\nvar getDefaultKeyBinding = require('./getDefaultKeyBinding');\nvar getVisibleSelectionRect = require('./getVisibleSelectionRect');\n\nvar DraftPublic = {\n  Editor: DraftEditor,\n  EditorBlock: DraftEditorBlock,\n  EditorState: EditorState,\n\n  CompositeDecorator: CompositeDraftDecorator,\n  Entity: DraftEntity,\n  EntityInstance: DraftEntityInstance,\n\n  BlockMapBuilder: BlockMapBuilder,\n  CharacterMetadata: CharacterMetadata,\n  ContentBlock: ContentBlock,\n  ContentState: ContentState,\n  SelectionState: SelectionState,\n\n  AtomicBlockUtils: AtomicBlockUtils,\n  KeyBindingUtil: KeyBindingUtil,\n  Modifier: DraftModifier,\n  RichUtils: RichTextEditorUtil,\n\n  DefaultDraftBlockRenderMap: DefaultDraftBlockRenderMap,\n  DefaultDraftInlineStyle: DefaultDraftInlineStyle,\n\n  convertFromHTML: convertFromHTMLToContentBlocks,\n  convertFromRaw: convertFromRawToDraftState,\n  convertToRaw: convertFromDraftStateToRaw,\n  genKey: generateRandomKey,\n  getDefaultKeyBinding: getDefaultKeyBinding,\n  getVisibleSelectionRect: getVisibleSelectionRect\n};\n\nmodule.exports = DraftPublic;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/Draft.js\n// module id = 217\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule randomizeBlockMapKeys\n * @format\n * \n */\n\n'use strict';\n\nvar ContentBlockNode = require('./ContentBlockNode');\nvar Immutable = require('immutable');\n\nvar generateRandomKey = require('./generateRandomKey');\n\nvar OrderedMap = Immutable.OrderedMap;\n\n\nvar randomizeContentBlockNodeKeys = function randomizeContentBlockNodeKeys(blockMap) {\n  var newKeysRef = {};\n\n  // we keep track of root blocks in order to update subsequent sibling links\n  var lastRootBlock = void 0;\n\n  return OrderedMap(blockMap.withMutations(function (blockMapState) {\n    blockMapState.forEach(function (block, index) {\n      var oldKey = block.getKey();\n      var nextKey = block.getNextSiblingKey();\n      var prevKey = block.getPrevSiblingKey();\n      var childrenKeys = block.getChildKeys();\n      var parentKey = block.getParentKey();\n\n      // new key that we will use to build linking\n      var key = generateRandomKey();\n\n      // we will add it here to re-use it later\n      newKeysRef[oldKey] = key;\n\n      if (nextKey) {\n        var nextBlock = blockMapState.get(nextKey);\n        if (nextBlock) {\n          blockMapState.setIn([nextKey, 'prevSibling'], key);\n        } else {\n          // this can happen when generating random keys for fragments\n          blockMapState.setIn([oldKey, 'nextSibling'], null);\n        }\n      }\n\n      if (prevKey) {\n        var prevBlock = blockMapState.get(prevKey);\n        if (prevBlock) {\n          blockMapState.setIn([prevKey, 'nextSibling'], key);\n        } else {\n          // this can happen when generating random keys for fragments\n          blockMapState.setIn([oldKey, 'prevSibling'], null);\n        }\n      }\n\n      if (parentKey && blockMapState.get(parentKey)) {\n        var parentBlock = blockMapState.get(parentKey);\n        var parentChildrenList = parentBlock.getChildKeys();\n        blockMapState.setIn([parentKey, 'children'], parentChildrenList.set(parentChildrenList.indexOf(block.getKey()), key));\n      } else {\n        // blocks will then be treated as root block nodes\n        blockMapState.setIn([oldKey, 'parent'], null);\n\n        if (lastRootBlock) {\n          blockMapState.setIn([lastRootBlock.getKey(), 'nextSibling'], key);\n          blockMapState.setIn([oldKey, 'prevSibling'], newKeysRef[lastRootBlock.getKey()]);\n        }\n\n        lastRootBlock = blockMapState.get(oldKey);\n      }\n\n      childrenKeys.forEach(function (childKey) {\n        var childBlock = blockMapState.get(childKey);\n        if (childBlock) {\n          blockMapState.setIn([childKey, 'parent'], key);\n        } else {\n          blockMapState.setIn([oldKey, 'children'], block.getChildKeys().filter(function (child) {\n            return child !== childKey;\n          }));\n        }\n      });\n    });\n  }).toArray().map(function (block) {\n    return [newKeysRef[block.getKey()], block.set('key', newKeysRef[block.getKey()])];\n  }));\n};\n\nvar randomizeContentBlockKeys = function randomizeContentBlockKeys(blockMap) {\n  return OrderedMap(blockMap.toArray().map(function (block) {\n    var key = generateRandomKey();\n    return [key, block.set('key', key)];\n  }));\n};\n\nvar randomizeBlockMapKeys = function randomizeBlockMapKeys(blockMap) {\n  var isTreeBasedBlockMap = blockMap.first() instanceof ContentBlockNode;\n\n  if (!isTreeBasedBlockMap) {\n    return randomizeContentBlockKeys(blockMap);\n  }\n\n  return randomizeContentBlockNodeKeys(blockMap);\n};\n\nmodule.exports = randomizeBlockMapKeys;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/randomizeBlockMapKeys.js\n// module id = 218\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule removeEntitiesAtEdges\n * @format\n * \n */\n\n'use strict';\n\nvar CharacterMetadata = require('./CharacterMetadata');\n\nvar findRangesImmutable = require('./findRangesImmutable');\nvar invariant = require('fbjs/lib/invariant');\n\nfunction removeEntitiesAtEdges(contentState, selectionState) {\n  var blockMap = contentState.getBlockMap();\n  var entityMap = contentState.getEntityMap();\n\n  var updatedBlocks = {};\n\n  var startKey = selectionState.getStartKey();\n  var startOffset = selectionState.getStartOffset();\n  var startBlock = blockMap.get(startKey);\n  var updatedStart = removeForBlock(entityMap, startBlock, startOffset);\n\n  if (updatedStart !== startBlock) {\n    updatedBlocks[startKey] = updatedStart;\n  }\n\n  var endKey = selectionState.getEndKey();\n  var endOffset = selectionState.getEndOffset();\n  var endBlock = blockMap.get(endKey);\n  if (startKey === endKey) {\n    endBlock = updatedStart;\n  }\n\n  var updatedEnd = removeForBlock(entityMap, endBlock, endOffset);\n\n  if (updatedEnd !== endBlock) {\n    updatedBlocks[endKey] = updatedEnd;\n  }\n\n  if (!Object.keys(updatedBlocks).length) {\n    return contentState.set('selectionAfter', selectionState);\n  }\n\n  return contentState.merge({\n    blockMap: blockMap.merge(updatedBlocks),\n    selectionAfter: selectionState\n  });\n}\n\nfunction getRemovalRange(characters, key, offset) {\n  var removalRange;\n  findRangesImmutable(characters, function (a, b) {\n    return a.getEntity() === b.getEntity();\n  }, function (element) {\n    return element.getEntity() === key;\n  }, function (start, end) {\n    if (start <= offset && end >= offset) {\n      removalRange = { start: start, end: end };\n    }\n  });\n  !(typeof removalRange === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Removal range must exist within character list.') : invariant(false) : void 0;\n  return removalRange;\n}\n\nfunction removeForBlock(entityMap, block, offset) {\n  var chars = block.getCharacterList();\n  var charBefore = offset > 0 ? chars.get(offset - 1) : undefined;\n  var charAfter = offset < chars.count() ? chars.get(offset) : undefined;\n  var entityBeforeCursor = charBefore ? charBefore.getEntity() : undefined;\n  var entityAfterCursor = charAfter ? charAfter.getEntity() : undefined;\n\n  if (entityAfterCursor && entityAfterCursor === entityBeforeCursor) {\n    var entity = entityMap.__get(entityAfterCursor);\n    if (entity.getMutability() !== 'MUTABLE') {\n      var _getRemovalRange = getRemovalRange(chars, entityAfterCursor, offset),\n          start = _getRemovalRange.start,\n          end = _getRemovalRange.end;\n\n      var current;\n      while (start < end) {\n        current = chars.get(start);\n        chars = chars.set(start, CharacterMetadata.applyEntity(current, null));\n        start++;\n      }\n      return block.set('characterList', chars);\n    }\n  }\n\n  return block;\n}\n\nmodule.exports = removeEntitiesAtEdges;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/removeEntitiesAtEdges.js\n// module id = 219\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule insertIntoList\n * @format\n * \n */\n\n'use strict';\n\n/**\n * Maintain persistence for target list when appending and prepending.\n */\nfunction insertIntoList(targetList, toInsert, offset) {\n  if (offset === targetList.count()) {\n    toInsert.forEach(function (c) {\n      targetList = targetList.push(c);\n    });\n  } else if (offset === 0) {\n    toInsert.reverse().forEach(function (c) {\n      targetList = targetList.unshift(c);\n    });\n  } else {\n    var head = targetList.slice(0, offset);\n    var tail = targetList.slice(offset);\n    targetList = head.concat(toInsert, tail).toList();\n  }\n  return targetList;\n}\n\nmodule.exports = insertIntoList;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/insertIntoList.js\n// module id = 220\n// module chunks = 2","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getNextDelimiterBlockKey\n * @format\n * \n *\n * This is unstable and not part of the public API and should not be used by\n * production systems. This file may be update/removed without notice.\n */\n\nvar ContentBlockNode = require('./ContentBlockNode');\n\nvar getNextDelimiterBlockKey = function getNextDelimiterBlockKey(block, blockMap) {\n  var isExperimentalTreeBlock = block instanceof ContentBlockNode;\n\n  if (!isExperimentalTreeBlock) {\n    return null;\n  }\n\n  var nextSiblingKey = block.getNextSiblingKey();\n\n  if (nextSiblingKey) {\n    return nextSiblingKey;\n  }\n\n  var parent = block.getParentKey();\n\n  if (!parent) {\n    return null;\n  }\n\n  var nextNonDescendantBlock = blockMap.get(parent);\n  while (nextNonDescendantBlock && !nextNonDescendantBlock.getNextSiblingKey()) {\n    var parentKey = nextNonDescendantBlock.getParentKey();\n    nextNonDescendantBlock = parentKey ? blockMap.get(parentKey) : null;\n  }\n\n  if (!nextNonDescendantBlock) {\n    return null;\n  }\n\n  return nextNonDescendantBlock.getNextSiblingKey();\n};\n\nmodule.exports = getNextDelimiterBlockKey;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getNextDelimiterBlockKey.js\n// module id = 221\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule BlockTree\n * @format\n * \n */\n\n'use strict';\n\nvar Immutable = require('immutable');\n\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar findRangesImmutable = require('./findRangesImmutable');\n\nvar List = Immutable.List,\n    Repeat = Immutable.Repeat,\n    Record = Immutable.Record;\n\n\nvar returnTrue = emptyFunction.thatReturnsTrue;\n\nvar FINGERPRINT_DELIMITER = '-';\n\nvar defaultLeafRange = {\n  start: null,\n  end: null\n};\n\nvar LeafRange = Record(defaultLeafRange);\n\nvar defaultDecoratorRange = {\n  start: null,\n  end: null,\n  decoratorKey: null,\n  leaves: null\n};\n\nvar DecoratorRange = Record(defaultDecoratorRange);\n\nvar BlockTree = {\n  /**\n   * Generate a block tree for a given ContentBlock/decorator pair.\n   */\n  generate: function generate(contentState, block, decorator) {\n    var textLength = block.getLength();\n    if (!textLength) {\n      return List.of(new DecoratorRange({\n        start: 0,\n        end: 0,\n        decoratorKey: null,\n        leaves: List.of(new LeafRange({ start: 0, end: 0 }))\n      }));\n    }\n\n    var leafSets = [];\n    var decorations = decorator ? decorator.getDecorations(block, contentState) : List(Repeat(null, textLength));\n\n    var chars = block.getCharacterList();\n\n    findRangesImmutable(decorations, areEqual, returnTrue, function (start, end) {\n      leafSets.push(new DecoratorRange({\n        start: start,\n        end: end,\n        decoratorKey: decorations.get(start),\n        leaves: generateLeaves(chars.slice(start, end).toList(), start)\n      }));\n    });\n\n    return List(leafSets);\n  },\n\n  /**\n   * Create a string representation of the given tree map. This allows us\n   * to rapidly determine whether a tree has undergone a significant\n   * structural change.\n   */\n  getFingerprint: function getFingerprint(tree) {\n    return tree.map(function (leafSet) {\n      var decoratorKey = leafSet.get('decoratorKey');\n      var fingerprintString = decoratorKey !== null ? decoratorKey + '.' + (leafSet.get('end') - leafSet.get('start')) : '';\n      return '' + fingerprintString + '.' + leafSet.get('leaves').size;\n    }).join(FINGERPRINT_DELIMITER);\n  }\n};\n\n/**\n * Generate LeafRange records for a given character list.\n */\nfunction generateLeaves(characters, offset) {\n  var leaves = [];\n  var inlineStyles = characters.map(function (c) {\n    return c.getStyle();\n  }).toList();\n  findRangesImmutable(inlineStyles, areEqual, returnTrue, function (start, end) {\n    leaves.push(new LeafRange({\n      start: start + offset,\n      end: end + offset\n    }));\n  });\n  return List(leaves);\n}\n\nfunction areEqual(a, b) {\n  return a === b;\n}\n\nmodule.exports = BlockTree;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/BlockTree.js\n// module id = 222\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEntityInstance\n * @legacyServerCallableInstance\n * @format\n * \n */\n\n'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar Immutable = require('immutable');\n\nvar Record = Immutable.Record;\n\n\nvar DraftEntityInstanceRecord = Record({\n  type: 'TOKEN',\n  mutability: 'IMMUTABLE',\n  data: Object\n});\n\n/**\n * An instance of a document entity, consisting of a `type` and relevant\n * `data`, metadata about the entity.\n *\n * For instance, a \"link\" entity might provide a URI, and a \"mention\"\n * entity might provide the mentioned user's ID. These pieces of data\n * may be used when rendering the entity as part of a ContentBlock DOM\n * representation. For a link, the data would be used as an href for\n * the rendered anchor. For a mention, the ID could be used to retrieve\n * a hovercard.\n */\n\nvar DraftEntityInstance = function (_DraftEntityInstanceR) {\n  _inherits(DraftEntityInstance, _DraftEntityInstanceR);\n\n  function DraftEntityInstance() {\n    _classCallCheck(this, DraftEntityInstance);\n\n    return _possibleConstructorReturn(this, _DraftEntityInstanceR.apply(this, arguments));\n  }\n\n  DraftEntityInstance.prototype.getType = function getType() {\n    return this.get('type');\n  };\n\n  DraftEntityInstance.prototype.getMutability = function getMutability() {\n    return this.get('mutability');\n  };\n\n  DraftEntityInstance.prototype.getData = function getData() {\n    return this.get('data');\n  };\n\n  return DraftEntityInstance;\n}(DraftEntityInstanceRecord);\n\nmodule.exports = DraftEntityInstance;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftEntityInstance.js\n// module id = 223\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n * \n */\n\n/**\n * Basic (stateless) API for text direction detection\n *\n * Part of our implementation of Unicode Bidirectional Algorithm (UBA)\n * Unicode Standard Annex #9 (UAX9)\n * http://www.unicode.org/reports/tr9/\n */\n\n'use strict';\n\nvar UnicodeBidiDirection = require('./UnicodeBidiDirection');\n\nvar invariant = require('./invariant');\n\n/**\n * RegExp ranges of characters with a *Strong* Bidi_Class value.\n *\n * Data is based on DerivedBidiClass.txt in UCD version 7.0.0.\n *\n * NOTE: For performance reasons, we only support Unicode's\n *       Basic Multilingual Plane (BMP) for now.\n */\nvar RANGE_BY_BIDI_TYPE = {\n\n  L: 'A-Za-z\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u01BA\\u01BB' + '\\u01BC-\\u01BF\\u01C0-\\u01C3\\u01C4-\\u0293\\u0294\\u0295-\\u02AF\\u02B0-\\u02B8' + '\\u02BB-\\u02C1\\u02D0-\\u02D1\\u02E0-\\u02E4\\u02EE\\u0370-\\u0373\\u0376-\\u0377' + '\\u037A\\u037B-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1' + '\\u03A3-\\u03F5\\u03F7-\\u0481\\u0482\\u048A-\\u052F\\u0531-\\u0556\\u0559' + '\\u055A-\\u055F\\u0561-\\u0587\\u0589\\u0903\\u0904-\\u0939\\u093B\\u093D' + '\\u093E-\\u0940\\u0949-\\u094C\\u094E-\\u094F\\u0950\\u0958-\\u0961\\u0964-\\u0965' + '\\u0966-\\u096F\\u0970\\u0971\\u0972-\\u0980\\u0982-\\u0983\\u0985-\\u098C' + '\\u098F-\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD' + '\\u09BE-\\u09C0\\u09C7-\\u09C8\\u09CB-\\u09CC\\u09CE\\u09D7\\u09DC-\\u09DD' + '\\u09DF-\\u09E1\\u09E6-\\u09EF\\u09F0-\\u09F1\\u09F4-\\u09F9\\u09FA\\u0A03' + '\\u0A05-\\u0A0A\\u0A0F-\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32-\\u0A33' + '\\u0A35-\\u0A36\\u0A38-\\u0A39\\u0A3E-\\u0A40\\u0A59-\\u0A5C\\u0A5E\\u0A66-\\u0A6F' + '\\u0A72-\\u0A74\\u0A83\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0' + '\\u0AB2-\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0ABE-\\u0AC0\\u0AC9\\u0ACB-\\u0ACC\\u0AD0' + '\\u0AE0-\\u0AE1\\u0AE6-\\u0AEF\\u0AF0\\u0B02-\\u0B03\\u0B05-\\u0B0C\\u0B0F-\\u0B10' + '\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32-\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B3E\\u0B40' + '\\u0B47-\\u0B48\\u0B4B-\\u0B4C\\u0B57\\u0B5C-\\u0B5D\\u0B5F-\\u0B61\\u0B66-\\u0B6F' + '\\u0B70\\u0B71\\u0B72-\\u0B77\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95' + '\\u0B99-\\u0B9A\\u0B9C\\u0B9E-\\u0B9F\\u0BA3-\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9' + '\\u0BBE-\\u0BBF\\u0BC1-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCC\\u0BD0\\u0BD7' + '\\u0BE6-\\u0BEF\\u0BF0-\\u0BF2\\u0C01-\\u0C03\\u0C05-\\u0C0C\\u0C0E-\\u0C10' + '\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C41-\\u0C44\\u0C58-\\u0C59\\u0C60-\\u0C61' + '\\u0C66-\\u0C6F\\u0C7F\\u0C82-\\u0C83\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8' + '\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CBE\\u0CBF\\u0CC0-\\u0CC4\\u0CC6' + '\\u0CC7-\\u0CC8\\u0CCA-\\u0CCB\\u0CD5-\\u0CD6\\u0CDE\\u0CE0-\\u0CE1\\u0CE6-\\u0CEF' + '\\u0CF1-\\u0CF2\\u0D02-\\u0D03\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D' + '\\u0D3E-\\u0D40\\u0D46-\\u0D48\\u0D4A-\\u0D4C\\u0D4E\\u0D57\\u0D60-\\u0D61' + '\\u0D66-\\u0D6F\\u0D70-\\u0D75\\u0D79\\u0D7A-\\u0D7F\\u0D82-\\u0D83\\u0D85-\\u0D96' + '\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0DCF-\\u0DD1\\u0DD8-\\u0DDF' + '\\u0DE6-\\u0DEF\\u0DF2-\\u0DF3\\u0DF4\\u0E01-\\u0E30\\u0E32-\\u0E33\\u0E40-\\u0E45' + '\\u0E46\\u0E4F\\u0E50-\\u0E59\\u0E5A-\\u0E5B\\u0E81-\\u0E82\\u0E84\\u0E87-\\u0E88' + '\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7' + '\\u0EAA-\\u0EAB\\u0EAD-\\u0EB0\\u0EB2-\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6' + '\\u0ED0-\\u0ED9\\u0EDC-\\u0EDF\\u0F00\\u0F01-\\u0F03\\u0F04-\\u0F12\\u0F13\\u0F14' + '\\u0F15-\\u0F17\\u0F1A-\\u0F1F\\u0F20-\\u0F29\\u0F2A-\\u0F33\\u0F34\\u0F36\\u0F38' + '\\u0F3E-\\u0F3F\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F7F\\u0F85\\u0F88-\\u0F8C' + '\\u0FBE-\\u0FC5\\u0FC7-\\u0FCC\\u0FCE-\\u0FCF\\u0FD0-\\u0FD4\\u0FD5-\\u0FD8' + '\\u0FD9-\\u0FDA\\u1000-\\u102A\\u102B-\\u102C\\u1031\\u1038\\u103B-\\u103C\\u103F' + '\\u1040-\\u1049\\u104A-\\u104F\\u1050-\\u1055\\u1056-\\u1057\\u105A-\\u105D\\u1061' + '\\u1062-\\u1064\\u1065-\\u1066\\u1067-\\u106D\\u106E-\\u1070\\u1075-\\u1081' + '\\u1083-\\u1084\\u1087-\\u108C\\u108E\\u108F\\u1090-\\u1099\\u109A-\\u109C' + '\\u109E-\\u109F\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FB\\u10FC' + '\\u10FD-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288' + '\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5' + '\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1360-\\u1368' + '\\u1369-\\u137C\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166D-\\u166E' + '\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EB-\\u16ED\\u16EE-\\u16F0' + '\\u16F1-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1735-\\u1736' + '\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17B6\\u17BE-\\u17C5' + '\\u17C7-\\u17C8\\u17D4-\\u17D6\\u17D7\\u17D8-\\u17DA\\u17DC\\u17E0-\\u17E9' + '\\u1810-\\u1819\\u1820-\\u1842\\u1843\\u1844-\\u1877\\u1880-\\u18A8\\u18AA' + '\\u18B0-\\u18F5\\u1900-\\u191E\\u1923-\\u1926\\u1929-\\u192B\\u1930-\\u1931' + '\\u1933-\\u1938\\u1946-\\u194F\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB' + '\\u19B0-\\u19C0\\u19C1-\\u19C7\\u19C8-\\u19C9\\u19D0-\\u19D9\\u19DA\\u1A00-\\u1A16' + '\\u1A19-\\u1A1A\\u1A1E-\\u1A1F\\u1A20-\\u1A54\\u1A55\\u1A57\\u1A61\\u1A63-\\u1A64' + '\\u1A6D-\\u1A72\\u1A80-\\u1A89\\u1A90-\\u1A99\\u1AA0-\\u1AA6\\u1AA7\\u1AA8-\\u1AAD' + '\\u1B04\\u1B05-\\u1B33\\u1B35\\u1B3B\\u1B3D-\\u1B41\\u1B43-\\u1B44\\u1B45-\\u1B4B' + '\\u1B50-\\u1B59\\u1B5A-\\u1B60\\u1B61-\\u1B6A\\u1B74-\\u1B7C\\u1B82\\u1B83-\\u1BA0' + '\\u1BA1\\u1BA6-\\u1BA7\\u1BAA\\u1BAE-\\u1BAF\\u1BB0-\\u1BB9\\u1BBA-\\u1BE5\\u1BE7' + '\\u1BEA-\\u1BEC\\u1BEE\\u1BF2-\\u1BF3\\u1BFC-\\u1BFF\\u1C00-\\u1C23\\u1C24-\\u1C2B' + '\\u1C34-\\u1C35\\u1C3B-\\u1C3F\\u1C40-\\u1C49\\u1C4D-\\u1C4F\\u1C50-\\u1C59' + '\\u1C5A-\\u1C77\\u1C78-\\u1C7D\\u1C7E-\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u1CE1' + '\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF2-\\u1CF3\\u1CF5-\\u1CF6\\u1D00-\\u1D2B' + '\\u1D2C-\\u1D6A\\u1D6B-\\u1D77\\u1D78\\u1D79-\\u1D9A\\u1D9B-\\u1DBF\\u1E00-\\u1F15' + '\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D' + '\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC' + '\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u200E' + '\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D' + '\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2134\\u2135-\\u2138\\u2139' + '\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u214F\\u2160-\\u2182\\u2183-\\u2184' + '\\u2185-\\u2188\\u2336-\\u237A\\u2395\\u249C-\\u24E9\\u26AC\\u2800-\\u28FF' + '\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2C7B\\u2C7C-\\u2C7D\\u2C7E-\\u2CE4' + '\\u2CEB-\\u2CEE\\u2CF2-\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F' + '\\u2D70\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE' + '\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u3005\\u3006\\u3007' + '\\u3021-\\u3029\\u302E-\\u302F\\u3031-\\u3035\\u3038-\\u303A\\u303B\\u303C' + '\\u3041-\\u3096\\u309D-\\u309E\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FE\\u30FF' + '\\u3105-\\u312D\\u3131-\\u318E\\u3190-\\u3191\\u3192-\\u3195\\u3196-\\u319F' + '\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3200-\\u321C\\u3220-\\u3229\\u322A-\\u3247' + '\\u3248-\\u324F\\u3260-\\u327B\\u327F\\u3280-\\u3289\\u328A-\\u32B0\\u32C0-\\u32CB' + '\\u32D0-\\u32FE\\u3300-\\u3376\\u337B-\\u33DD\\u33E0-\\u33FE\\u3400-\\u4DB5' + '\\u4E00-\\u9FCC\\uA000-\\uA014\\uA015\\uA016-\\uA48C\\uA4D0-\\uA4F7\\uA4F8-\\uA4FD' + '\\uA4FE-\\uA4FF\\uA500-\\uA60B\\uA60C\\uA610-\\uA61F\\uA620-\\uA629\\uA62A-\\uA62B' + '\\uA640-\\uA66D\\uA66E\\uA680-\\uA69B\\uA69C-\\uA69D\\uA6A0-\\uA6E5\\uA6E6-\\uA6EF' + '\\uA6F2-\\uA6F7\\uA722-\\uA76F\\uA770\\uA771-\\uA787\\uA789-\\uA78A\\uA78B-\\uA78E' + '\\uA790-\\uA7AD\\uA7B0-\\uA7B1\\uA7F7\\uA7F8-\\uA7F9\\uA7FA\\uA7FB-\\uA801' + '\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA823-\\uA824\\uA827\\uA830-\\uA835' + '\\uA836-\\uA837\\uA840-\\uA873\\uA880-\\uA881\\uA882-\\uA8B3\\uA8B4-\\uA8C3' + '\\uA8CE-\\uA8CF\\uA8D0-\\uA8D9\\uA8F2-\\uA8F7\\uA8F8-\\uA8FA\\uA8FB\\uA900-\\uA909' + '\\uA90A-\\uA925\\uA92E-\\uA92F\\uA930-\\uA946\\uA952-\\uA953\\uA95F\\uA960-\\uA97C' + '\\uA983\\uA984-\\uA9B2\\uA9B4-\\uA9B5\\uA9BA-\\uA9BB\\uA9BD-\\uA9C0\\uA9C1-\\uA9CD' + '\\uA9CF\\uA9D0-\\uA9D9\\uA9DE-\\uA9DF\\uA9E0-\\uA9E4\\uA9E6\\uA9E7-\\uA9EF' + '\\uA9F0-\\uA9F9\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA2F-\\uAA30\\uAA33-\\uAA34' + '\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA4D\\uAA50-\\uAA59\\uAA5C-\\uAA5F\\uAA60-\\uAA6F' + '\\uAA70\\uAA71-\\uAA76\\uAA77-\\uAA79\\uAA7A\\uAA7B\\uAA7D\\uAA7E-\\uAAAF\\uAAB1' + '\\uAAB5-\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADC\\uAADD\\uAADE-\\uAADF' + '\\uAAE0-\\uAAEA\\uAAEB\\uAAEE-\\uAAEF\\uAAF0-\\uAAF1\\uAAF2\\uAAF3-\\uAAF4\\uAAF5' + '\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E' + '\\uAB30-\\uAB5A\\uAB5B\\uAB5C-\\uAB5F\\uAB64-\\uAB65\\uABC0-\\uABE2\\uABE3-\\uABE4' + '\\uABE6-\\uABE7\\uABE9-\\uABEA\\uABEB\\uABEC\\uABF0-\\uABF9\\uAC00-\\uD7A3' + '\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uE000-\\uF8FF\\uF900-\\uFA6D\\uFA70-\\uFAD9' + '\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFF6F\\uFF70' + '\\uFF71-\\uFF9D\\uFF9E-\\uFF9F\\uFFA0-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF' + '\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC',\n\n  R: '\\u0590\\u05BE\\u05C0\\u05C3\\u05C6\\u05C8-\\u05CF\\u05D0-\\u05EA\\u05EB-\\u05EF' + '\\u05F0-\\u05F2\\u05F3-\\u05F4\\u05F5-\\u05FF\\u07C0-\\u07C9\\u07CA-\\u07EA' + '\\u07F4-\\u07F5\\u07FA\\u07FB-\\u07FF\\u0800-\\u0815\\u081A\\u0824\\u0828' + '\\u082E-\\u082F\\u0830-\\u083E\\u083F\\u0840-\\u0858\\u085C-\\u085D\\u085E' + '\\u085F-\\u089F\\u200F\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB37\\uFB38-\\uFB3C' + '\\uFB3D\\uFB3E\\uFB3F\\uFB40-\\uFB41\\uFB42\\uFB43-\\uFB44\\uFB45\\uFB46-\\uFB4F',\n\n  AL: '\\u0608\\u060B\\u060D\\u061B\\u061C\\u061D\\u061E-\\u061F\\u0620-\\u063F\\u0640' + '\\u0641-\\u064A\\u066D\\u066E-\\u066F\\u0671-\\u06D3\\u06D4\\u06D5\\u06E5-\\u06E6' + '\\u06EE-\\u06EF\\u06FA-\\u06FC\\u06FD-\\u06FE\\u06FF\\u0700-\\u070D\\u070E\\u070F' + '\\u0710\\u0712-\\u072F\\u074B-\\u074C\\u074D-\\u07A5\\u07B1\\u07B2-\\u07BF' + '\\u08A0-\\u08B2\\u08B3-\\u08E3\\uFB50-\\uFBB1\\uFBB2-\\uFBC1\\uFBC2-\\uFBD2' + '\\uFBD3-\\uFD3D\\uFD40-\\uFD4F\\uFD50-\\uFD8F\\uFD90-\\uFD91\\uFD92-\\uFDC7' + '\\uFDC8-\\uFDCF\\uFDF0-\\uFDFB\\uFDFC\\uFDFE-\\uFDFF\\uFE70-\\uFE74\\uFE75' + '\\uFE76-\\uFEFC\\uFEFD-\\uFEFE'\n\n};\n\nvar REGEX_STRONG = new RegExp('[' + RANGE_BY_BIDI_TYPE.L + RANGE_BY_BIDI_TYPE.R + RANGE_BY_BIDI_TYPE.AL + ']');\n\nvar REGEX_RTL = new RegExp('[' + RANGE_BY_BIDI_TYPE.R + RANGE_BY_BIDI_TYPE.AL + ']');\n\n/**\n * Returns the first strong character (has Bidi_Class value of L, R, or AL).\n *\n * @param str  A text block; e.g. paragraph, table cell, tag\n * @return     A character with strong bidi direction, or null if not found\n */\nfunction firstStrongChar(str) {\n  var match = REGEX_STRONG.exec(str);\n  return match == null ? null : match[0];\n}\n\n/**\n * Returns the direction of a block of text, based on the direction of its\n * first strong character (has Bidi_Class value of L, R, or AL).\n *\n * @param str  A text block; e.g. paragraph, table cell, tag\n * @return     The resolved direction\n */\nfunction firstStrongCharDir(str) {\n  var strongChar = firstStrongChar(str);\n  if (strongChar == null) {\n    return UnicodeBidiDirection.NEUTRAL;\n  }\n  return REGEX_RTL.exec(strongChar) ? UnicodeBidiDirection.RTL : UnicodeBidiDirection.LTR;\n}\n\n/**\n * Returns the direction of a block of text, based on the direction of its\n * first strong character (has Bidi_Class value of L, R, or AL), or a fallback\n * direction, if no strong character is found.\n *\n * This function is supposed to be used in respect to Higher-Level Protocol\n * rule HL1. (http://www.unicode.org/reports/tr9/#HL1)\n *\n * @param str       A text block; e.g. paragraph, table cell, tag\n * @param fallback  Fallback direction, used if no strong direction detected\n *                  for the block (default = NEUTRAL)\n * @return          The resolved direction\n */\nfunction resolveBlockDir(str, fallback) {\n  fallback = fallback || UnicodeBidiDirection.NEUTRAL;\n  if (!str.length) {\n    return fallback;\n  }\n  var blockDir = firstStrongCharDir(str);\n  return blockDir === UnicodeBidiDirection.NEUTRAL ? fallback : blockDir;\n}\n\n/**\n * Returns the direction of a block of text, based on the direction of its\n * first strong character (has Bidi_Class value of L, R, or AL), or a fallback\n * direction, if no strong character is found.\n *\n * NOTE: This function is similar to resolveBlockDir(), but uses the global\n * direction as the fallback, so it *always* returns a Strong direction,\n * making it useful for integration in places that you need to make the final\n * decision, like setting some CSS class.\n *\n * This function is supposed to be used in respect to Higher-Level Protocol\n * rule HL1. (http://www.unicode.org/reports/tr9/#HL1)\n *\n * @param str             A text block; e.g. paragraph, table cell\n * @param strongFallback  Fallback direction, used if no strong direction\n *                        detected for the block (default = global direction)\n * @return                The resolved Strong direction\n */\nfunction getDirection(str, strongFallback) {\n  if (!strongFallback) {\n    strongFallback = UnicodeBidiDirection.getGlobalDir();\n  }\n  !UnicodeBidiDirection.isStrong(strongFallback) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Fallback direction must be a strong direction') : invariant(false) : void 0;\n  return resolveBlockDir(str, strongFallback);\n}\n\n/**\n * Returns true if getDirection(arguments...) returns LTR.\n *\n * @param str             A text block; e.g. paragraph, table cell\n * @param strongFallback  Fallback direction, used if no strong direction\n *                        detected for the block (default = global direction)\n * @return                True if the resolved direction is LTR\n */\nfunction isDirectionLTR(str, strongFallback) {\n  return getDirection(str, strongFallback) === UnicodeBidiDirection.LTR;\n}\n\n/**\n * Returns true if getDirection(arguments...) returns RTL.\n *\n * @param str             A text block; e.g. paragraph, table cell\n * @param strongFallback  Fallback direction, used if no strong direction\n *                        detected for the block (default = global direction)\n * @return                True if the resolved direction is RTL\n */\nfunction isDirectionRTL(str, strongFallback) {\n  return getDirection(str, strongFallback) === UnicodeBidiDirection.RTL;\n}\n\nvar UnicodeBidi = {\n  firstStrongChar: firstStrongChar,\n  firstStrongCharDir: firstStrongCharDir,\n  resolveBlockDir: resolveBlockDir,\n  getDirection: getDirection,\n  isDirectionLTR: isDirectionLTR,\n  isDirectionRTL: isDirectionRTL\n};\n\nmodule.exports = UnicodeBidi;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/UnicodeBidi.js\n// module id = 224\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DefaultDraftInlineStyle\n * @format\n * \n */\n\n'use strict';\n\nmodule.exports = {\n  BOLD: {\n    fontWeight: 'bold'\n  },\n\n  CODE: {\n    fontFamily: 'monospace',\n    wordWrap: 'break-word'\n  },\n\n  ITALIC: {\n    fontStyle: 'italic'\n  },\n\n  STRIKETHROUGH: {\n    textDecoration: 'line-through'\n  },\n\n  UNDERLINE: {\n    textDecoration: 'underline'\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DefaultDraftInlineStyle.js\n// module id = 225\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule isSelectionAtLeafStart\n * @format\n * \n */\n\n'use strict';\n\nfunction isSelectionAtLeafStart(editorState) {\n  var selection = editorState.getSelection();\n  var anchorKey = selection.getAnchorKey();\n  var blockTree = editorState.getBlockTree(anchorKey);\n  var offset = selection.getStartOffset();\n\n  var isAtStart = false;\n\n  blockTree.some(function (leafSet) {\n    if (offset === leafSet.get('start')) {\n      isAtStart = true;\n      return true;\n    }\n\n    if (offset < leafSet.get('end')) {\n      return leafSet.get('leaves').some(function (leaf) {\n        var leafStart = leaf.get('start');\n        if (offset === leafStart) {\n          isAtStart = true;\n          return true;\n        }\n\n        return false;\n      });\n    }\n\n    return false;\n  });\n\n  return isAtStart;\n}\n\nmodule.exports = isSelectionAtLeafStart;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/isSelectionAtLeafStart.js\n// module id = 226\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorBlock.react\n * @format\n * \n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar DraftEditorLeaf = require('./DraftEditorLeaf.react');\nvar DraftOffsetKey = require('./DraftOffsetKey');\nvar React = require('react');\nvar ReactDOM = require('react-dom');\nvar Scroll = require('fbjs/lib/Scroll');\nvar Style = require('fbjs/lib/Style');\nvar UnicodeBidi = require('fbjs/lib/UnicodeBidi');\nvar UnicodeBidiDirection = require('fbjs/lib/UnicodeBidiDirection');\n\nvar cx = require('fbjs/lib/cx');\nvar getElementPosition = require('fbjs/lib/getElementPosition');\nvar getScrollPosition = require('fbjs/lib/getScrollPosition');\nvar getViewportDimensions = require('fbjs/lib/getViewportDimensions');\nvar invariant = require('fbjs/lib/invariant');\nvar nullthrows = require('fbjs/lib/nullthrows');\n\nvar SCROLL_BUFFER = 10;\n\n/**\n * Return whether a block overlaps with either edge of the `SelectionState`.\n */\nvar isBlockOnSelectionEdge = function isBlockOnSelectionEdge(selection, key) {\n  return selection.getAnchorKey() === key || selection.getFocusKey() === key;\n};\n\n/**\n * The default block renderer for a `DraftEditor` component.\n *\n * A `DraftEditorBlock` is able to render a given `ContentBlock` to its\n * appropriate decorator and inline style components.\n */\n\nvar DraftEditorBlock = function (_React$Component) {\n  _inherits(DraftEditorBlock, _React$Component);\n\n  function DraftEditorBlock() {\n    _classCallCheck(this, DraftEditorBlock);\n\n    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));\n  }\n\n  DraftEditorBlock.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n    return this.props.block !== nextProps.block || this.props.tree !== nextProps.tree || this.props.direction !== nextProps.direction || isBlockOnSelectionEdge(nextProps.selection, nextProps.block.getKey()) && nextProps.forceSelection;\n  };\n\n  /**\n   * When a block is mounted and overlaps the selection state, we need to make\n   * sure that the cursor is visible to match native behavior. This may not\n   * be the case if the user has pressed `RETURN` or pasted some content, since\n   * programatically creating these new blocks and setting the DOM selection\n   * will miss out on the browser natively scrolling to that position.\n   *\n   * To replicate native behavior, if the block overlaps the selection state\n   * on mount, force the scroll position. Check the scroll state of the scroll\n   * parent, and adjust it to align the entire block to the bottom of the\n   * scroll parent.\n   */\n\n\n  DraftEditorBlock.prototype.componentDidMount = function componentDidMount() {\n    var selection = this.props.selection;\n    var endKey = selection.getEndKey();\n    if (!selection.getHasFocus() || endKey !== this.props.block.getKey()) {\n      return;\n    }\n\n    var blockNode = ReactDOM.findDOMNode(this);\n    var scrollParent = Style.getScrollParent(blockNode);\n    var scrollPosition = getScrollPosition(scrollParent);\n    var scrollDelta = void 0;\n\n    if (scrollParent === window) {\n      var nodePosition = getElementPosition(blockNode);\n      var nodeBottom = nodePosition.y + nodePosition.height;\n      var viewportHeight = getViewportDimensions().height;\n      scrollDelta = nodeBottom - viewportHeight;\n      if (scrollDelta > 0) {\n        window.scrollTo(scrollPosition.x, scrollPosition.y + scrollDelta + SCROLL_BUFFER);\n      }\n    } else {\n      !(blockNode instanceof HTMLElement) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'blockNode is not an HTMLElement') : invariant(false) : void 0;\n      var blockBottom = blockNode.offsetHeight + blockNode.offsetTop;\n      var scrollBottom = scrollParent.offsetHeight + scrollPosition.y;\n      scrollDelta = blockBottom - scrollBottom;\n      if (scrollDelta > 0) {\n        Scroll.setTop(scrollParent, Scroll.getTop(scrollParent) + scrollDelta + SCROLL_BUFFER);\n      }\n    }\n  };\n\n  DraftEditorBlock.prototype._renderChildren = function _renderChildren() {\n    var _this2 = this;\n\n    var block = this.props.block;\n    var blockKey = block.getKey();\n    var text = block.getText();\n    var lastLeafSet = this.props.tree.size - 1;\n    var hasSelection = isBlockOnSelectionEdge(this.props.selection, blockKey);\n\n    return this.props.tree.map(function (leafSet, ii) {\n      var leavesForLeafSet = leafSet.get('leaves');\n      var lastLeaf = leavesForLeafSet.size - 1;\n      var leaves = leavesForLeafSet.map(function (leaf, jj) {\n        var offsetKey = DraftOffsetKey.encode(blockKey, ii, jj);\n        var start = leaf.get('start');\n        var end = leaf.get('end');\n        return React.createElement(DraftEditorLeaf, {\n          key: offsetKey,\n          offsetKey: offsetKey,\n          block: block,\n          start: start,\n          selection: hasSelection ? _this2.props.selection : null,\n          forceSelection: _this2.props.forceSelection,\n          text: text.slice(start, end),\n          styleSet: block.getInlineStyleAt(start),\n          customStyleMap: _this2.props.customStyleMap,\n          customStyleFn: _this2.props.customStyleFn,\n          isLast: ii === lastLeafSet && jj === lastLeaf\n        });\n      }).toArray();\n\n      var decoratorKey = leafSet.get('decoratorKey');\n      if (decoratorKey == null) {\n        return leaves;\n      }\n\n      if (!_this2.props.decorator) {\n        return leaves;\n      }\n\n      var decorator = nullthrows(_this2.props.decorator);\n\n      var DecoratorComponent = decorator.getComponentForKey(decoratorKey);\n      if (!DecoratorComponent) {\n        return leaves;\n      }\n\n      var decoratorProps = decorator.getPropsForKey(decoratorKey);\n      var decoratorOffsetKey = DraftOffsetKey.encode(blockKey, ii, 0);\n      var decoratedText = text.slice(leavesForLeafSet.first().get('start'), leavesForLeafSet.last().get('end'));\n\n      // Resetting dir to the same value on a child node makes Chrome/Firefox\n      // confused on cursor movement. See http://jsfiddle.net/d157kLck/3/\n      var dir = UnicodeBidiDirection.getHTMLDirIfDifferent(UnicodeBidi.getDirection(decoratedText), _this2.props.direction);\n\n      return React.createElement(\n        DecoratorComponent,\n        _extends({}, decoratorProps, {\n          contentState: _this2.props.contentState,\n          decoratedText: decoratedText,\n          dir: dir,\n          key: decoratorOffsetKey,\n          entityKey: block.getEntityAt(leafSet.get('start')),\n          offsetKey: decoratorOffsetKey }),\n        leaves\n      );\n    }).toArray();\n  };\n\n  DraftEditorBlock.prototype.render = function render() {\n    var _props = this.props,\n        direction = _props.direction,\n        offsetKey = _props.offsetKey;\n\n    var className = cx({\n      'public/DraftStyleDefault/block': true,\n      'public/DraftStyleDefault/ltr': direction === 'LTR',\n      'public/DraftStyleDefault/rtl': direction === 'RTL'\n    });\n\n    return React.createElement(\n      'div',\n      { 'data-offset-key': offsetKey, className: className },\n      this._renderChildren()\n    );\n  };\n\n  return DraftEditorBlock;\n}(React.Component);\n\nmodule.exports = DraftEditorBlock;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftEditorBlock.react.js\n// module id = 227\n// module chunks = 2","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n/* eslint-disable fb-www/typeof-undefined */\n\n/**\n * Same as document.activeElement but wraps in a try-catch block. In IE it is\n * not safe to call document.activeElement if there is nothing focused.\n *\n * The activeElement will be null only if the document or document body is not\n * yet defined.\n *\n * @param {?DOMDocument} doc Defaults to current document.\n * @return {?DOMElement}\n */\nfunction getActiveElement(doc) /*?DOMElement*/{\n  doc = doc || (typeof document !== 'undefined' ? document : undefined);\n  if (typeof doc === 'undefined') {\n    return null;\n  }\n  try {\n    return doc.activeElement || doc.body;\n  } catch (e) {\n    return doc.body;\n  }\n}\n\nmodule.exports = getActiveElement;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/getActiveElement.js\n// module id = 228\n// module chunks = 2","\"use strict\";\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/**\n * @param {DOMElement} element\n * @param {DOMDocument} doc\n * @return {boolean}\n */\nfunction _isViewportScrollElement(element, doc) {\n  return !!doc && (element === doc.documentElement || element === doc.body);\n}\n\n/**\n * Scroll Module. This class contains 4 simple static functions\n * to be used to access Element.scrollTop/scrollLeft properties.\n * To solve the inconsistencies between browsers when either\n * document.body or document.documentElement is supplied,\n * below logic will be used to alleviate the issue:\n *\n * 1. If 'element' is either 'document.body' or 'document.documentElement,\n *    get whichever element's 'scroll{Top,Left}' is larger.\n * 2. If 'element' is either 'document.body' or 'document.documentElement',\n *    set the 'scroll{Top,Left}' on both elements.\n */\n\nvar Scroll = {\n  /**\n   * @param {DOMElement} element\n   * @return {number}\n   */\n  getTop: function getTop(element) {\n    var doc = element.ownerDocument;\n    return _isViewportScrollElement(element, doc) ?\n    // In practice, they will either both have the same value,\n    // or one will be zero and the other will be the scroll position\n    // of the viewport. So we can use `X || Y` instead of `Math.max(X, Y)`\n    doc.body.scrollTop || doc.documentElement.scrollTop : element.scrollTop;\n  },\n\n  /**\n   * @param {DOMElement} element\n   * @param {number} newTop\n   */\n  setTop: function setTop(element, newTop) {\n    var doc = element.ownerDocument;\n    if (_isViewportScrollElement(element, doc)) {\n      doc.body.scrollTop = doc.documentElement.scrollTop = newTop;\n    } else {\n      element.scrollTop = newTop;\n    }\n  },\n\n  /**\n   * @param {DOMElement} element\n   * @return {number}\n   */\n  getLeft: function getLeft(element) {\n    var doc = element.ownerDocument;\n    return _isViewportScrollElement(element, doc) ? doc.body.scrollLeft || doc.documentElement.scrollLeft : element.scrollLeft;\n  },\n\n  /**\n   * @param {DOMElement} element\n   * @param {number} newLeft\n   */\n  setLeft: function setLeft(element, newLeft) {\n    var doc = element.ownerDocument;\n    if (_isViewportScrollElement(element, doc)) {\n      doc.body.scrollLeft = doc.documentElement.scrollLeft = newLeft;\n    } else {\n      element.scrollLeft = newLeft;\n    }\n  }\n};\n\nmodule.exports = Scroll;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/Scroll.js\n// module id = 229\n// module chunks = 2","'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar PhotosMimeType = require('./PhotosMimeType');\n\nvar createArrayFromMixed = require('./createArrayFromMixed');\nvar emptyFunction = require('./emptyFunction');\n\nvar CR_LF_REGEX = new RegExp('\\r\\n', 'g');\nvar LF_ONLY = '\\n';\n\nvar RICH_TEXT_TYPES = {\n  'text/rtf': 1,\n  'text/html': 1\n};\n\n/**\n * If DataTransferItem is a file then return the Blob of data.\n *\n * @param {object} item\n * @return {?blob}\n */\nfunction getFileFromDataTransfer(item) {\n  if (item.kind == 'file') {\n    return item.getAsFile();\n  }\n}\n\nvar DataTransfer = function () {\n  /**\n   * @param {object} data\n   */\n  function DataTransfer(data) {\n    _classCallCheck(this, DataTransfer);\n\n    this.data = data;\n\n    // Types could be DOMStringList or array\n    this.types = data.types ? createArrayFromMixed(data.types) : [];\n  }\n\n  /**\n   * Is this likely to be a rich text data transfer?\n   *\n   * @return {boolean}\n   */\n\n\n  DataTransfer.prototype.isRichText = function isRichText() {\n    // If HTML is available, treat this data as rich text. This way, we avoid\n    // using a pasted image if it is packaged with HTML -- this may occur with\n    // pastes from MS Word, for example.  However this is only rich text if\n    // there's accompanying text.\n    if (this.getHTML() && this.getText()) {\n      return true;\n    }\n\n    // When an image is copied from a preview window, you end up with two\n    // DataTransferItems one of which is a file's metadata as text.  Skip those.\n    if (this.isImage()) {\n      return false;\n    }\n\n    return this.types.some(function (type) {\n      return RICH_TEXT_TYPES[type];\n    });\n  };\n\n  /**\n   * Get raw text.\n   *\n   * @return {?string}\n   */\n\n\n  DataTransfer.prototype.getText = function getText() {\n    var text;\n    if (this.data.getData) {\n      if (!this.types.length) {\n        text = this.data.getData('Text');\n      } else if (this.types.indexOf('text/plain') != -1) {\n        text = this.data.getData('text/plain');\n      }\n    }\n    return text ? text.replace(CR_LF_REGEX, LF_ONLY) : null;\n  };\n\n  /**\n   * Get HTML paste data\n   *\n   * @return {?string}\n   */\n\n\n  DataTransfer.prototype.getHTML = function getHTML() {\n    if (this.data.getData) {\n      if (!this.types.length) {\n        return this.data.getData('Text');\n      } else if (this.types.indexOf('text/html') != -1) {\n        return this.data.getData('text/html');\n      }\n    }\n  };\n\n  /**\n   * Is this a link data transfer?\n   *\n   * @return {boolean}\n   */\n\n\n  DataTransfer.prototype.isLink = function isLink() {\n    return this.types.some(function (type) {\n      return type.indexOf('Url') != -1 || type.indexOf('text/uri-list') != -1 || type.indexOf('text/x-moz-url');\n    });\n  };\n\n  /**\n   * Get a link url.\n   *\n   * @return {?string}\n   */\n\n\n  DataTransfer.prototype.getLink = function getLink() {\n    if (this.data.getData) {\n      if (this.types.indexOf('text/x-moz-url') != -1) {\n        var url = this.data.getData('text/x-moz-url').split('\\n');\n        return url[0];\n      }\n      return this.types.indexOf('text/uri-list') != -1 ? this.data.getData('text/uri-list') : this.data.getData('url');\n    }\n\n    return null;\n  };\n\n  /**\n   * Is this an image data transfer?\n   *\n   * @return {boolean}\n   */\n\n\n  DataTransfer.prototype.isImage = function isImage() {\n    var isImage = this.types.some(function (type) {\n      // Firefox will have a type of application/x-moz-file for images during\n      // dragging\n      return type.indexOf('application/x-moz-file') != -1;\n    });\n\n    if (isImage) {\n      return true;\n    }\n\n    var items = this.getFiles();\n    for (var i = 0; i < items.length; i++) {\n      var type = items[i].type;\n      if (!PhotosMimeType.isImage(type)) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n\n  DataTransfer.prototype.getCount = function getCount() {\n    if (this.data.hasOwnProperty('items')) {\n      return this.data.items.length;\n    } else if (this.data.hasOwnProperty('mozItemCount')) {\n      return this.data.mozItemCount;\n    } else if (this.data.files) {\n      return this.data.files.length;\n    }\n    return null;\n  };\n\n  /**\n   * Get files.\n   *\n   * @return {array}\n   */\n\n\n  DataTransfer.prototype.getFiles = function getFiles() {\n    if (this.data.items) {\n      // createArrayFromMixed doesn't properly handle DataTransferItemLists.\n      return Array.prototype.slice.call(this.data.items).map(getFileFromDataTransfer).filter(emptyFunction.thatReturnsArgument);\n    } else if (this.data.files) {\n      return Array.prototype.slice.call(this.data.files);\n    } else {\n      return [];\n    }\n  };\n\n  /**\n   * Are there any files to fetch?\n   *\n   * @return {boolean}\n   */\n\n\n  DataTransfer.prototype.hasFiles = function hasFiles() {\n    return this.getFiles().length > 0;\n  };\n\n  return DataTransfer;\n}();\n\nmodule.exports = DataTransfer;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/DataTransfer.js\n// module id = 230\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getSelectionOffsetKeyForNode\n * @format\n * \n */\n\n'use strict';\n\n/**\n * Get offset key from a node or it's child nodes. Return the first offset key\n * found on the DOM tree of given node.\n */\n\nfunction getSelectionOffsetKeyForNode(node) {\n  if (node instanceof Element) {\n    var offsetKey = node.getAttribute('data-offset-key');\n    if (offsetKey) {\n      return offsetKey;\n    }\n    for (var ii = 0; ii < node.childNodes.length; ii++) {\n      var childOffsetKey = getSelectionOffsetKeyForNode(node.childNodes[ii]);\n      if (childOffsetKey) {\n        return childOffsetKey;\n      }\n    }\n  }\n  return null;\n}\n\nmodule.exports = getSelectionOffsetKeyForNode;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getSelectionOffsetKeyForNode.js\n// module id = 231\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getTextContentFromFiles\n * @format\n * \n */\n\n'use strict';\n\nvar invariant = require('fbjs/lib/invariant');\n\nvar TEXT_CLIPPING_REGEX = /\\.textClipping$/;\n\nvar TEXT_TYPES = {\n  'text/plain': true,\n  'text/html': true,\n  'text/rtf': true\n};\n\n// Somewhat arbitrary upper bound on text size. Let's not lock up the browser.\nvar TEXT_SIZE_UPPER_BOUND = 5000;\n\n/**\n * Extract the text content from a file list.\n */\nfunction getTextContentFromFiles(files, callback) {\n  var readCount = 0;\n  var results = [];\n  files.forEach(function ( /*blob*/file) {\n    readFile(file, function ( /*string*/text) {\n      readCount++;\n      text && results.push(text.slice(0, TEXT_SIZE_UPPER_BOUND));\n      if (readCount == files.length) {\n        callback(results.join('\\r'));\n      }\n    });\n  });\n}\n\n/**\n * todo isaac: Do work to turn html/rtf into a content fragment.\n */\nfunction readFile(file, callback) {\n  if (!global.FileReader || file.type && !(file.type in TEXT_TYPES)) {\n    callback('');\n    return;\n  }\n\n  if (file.type === '') {\n    var contents = '';\n    // Special-case text clippings, which have an empty type but include\n    // `.textClipping` in the file name. `readAsText` results in an empty\n    // string for text clippings, so we force the file name to serve\n    // as the text value for the file.\n    if (TEXT_CLIPPING_REGEX.test(file.name)) {\n      contents = file.name.replace(TEXT_CLIPPING_REGEX, '');\n    }\n    callback(contents);\n    return;\n  }\n\n  var reader = new FileReader();\n  reader.onload = function () {\n    var result = reader.result;\n    !(typeof result === 'string') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'We should be calling \"FileReader.readAsText\" which returns a string') : invariant(false) : void 0;\n    callback(result);\n  };\n  reader.onerror = function () {\n    callback('');\n  };\n  reader.readAsText(file);\n}\n\nmodule.exports = getTextContentFromFiles;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getTextContentFromFiles.js\n// module id = 232\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getUpdatedSelectionState\n * @format\n * \n */\n\n'use strict';\n\nvar DraftOffsetKey = require('./DraftOffsetKey');\n\nvar nullthrows = require('fbjs/lib/nullthrows');\n\nfunction getUpdatedSelectionState(editorState, anchorKey, anchorOffset, focusKey, focusOffset) {\n  var selection = nullthrows(editorState.getSelection());\n  if (process.env.NODE_ENV !== 'production') {\n    if (!anchorKey || !focusKey) {\n      /*eslint-disable no-console */\n      console.warn('Invalid selection state.', arguments, editorState.toJS());\n      /*eslint-enable no-console */\n      return selection;\n    }\n  }\n\n  var anchorPath = DraftOffsetKey.decode(anchorKey);\n  var anchorBlockKey = anchorPath.blockKey;\n  var anchorLeaf = editorState.getBlockTree(anchorBlockKey).getIn([anchorPath.decoratorKey, 'leaves', anchorPath.leafKey]);\n\n  var focusPath = DraftOffsetKey.decode(focusKey);\n  var focusBlockKey = focusPath.blockKey;\n  var focusLeaf = editorState.getBlockTree(focusBlockKey).getIn([focusPath.decoratorKey, 'leaves', focusPath.leafKey]);\n\n  var anchorLeafStart = anchorLeaf.get('start');\n  var focusLeafStart = focusLeaf.get('start');\n\n  var anchorBlockOffset = anchorLeaf ? anchorLeafStart + anchorOffset : null;\n  var focusBlockOffset = focusLeaf ? focusLeafStart + focusOffset : null;\n\n  var areEqual = selection.getAnchorKey() === anchorBlockKey && selection.getAnchorOffset() === anchorBlockOffset && selection.getFocusKey() === focusBlockKey && selection.getFocusOffset() === focusBlockOffset;\n\n  if (areEqual) {\n    return selection;\n  }\n\n  var isBackward = false;\n  if (anchorBlockKey === focusBlockKey) {\n    var anchorLeafEnd = anchorLeaf.get('end');\n    var focusLeafEnd = focusLeaf.get('end');\n    if (focusLeafStart === anchorLeafStart && focusLeafEnd === anchorLeafEnd) {\n      isBackward = focusOffset < anchorOffset;\n    } else {\n      isBackward = focusLeafStart < anchorLeafStart;\n    }\n  } else {\n    var startKey = editorState.getCurrentContent().getBlockMap().keySeq().skipUntil(function (v) {\n      return v === anchorBlockKey || v === focusBlockKey;\n    }).first();\n    isBackward = startKey === focusBlockKey;\n  }\n\n  return selection.merge({\n    anchorKey: anchorBlockKey,\n    anchorOffset: anchorBlockOffset,\n    focusKey: focusBlockKey,\n    focusOffset: focusBlockOffset,\n    isBackward: isBackward\n  });\n}\n\nmodule.exports = getUpdatedSelectionState;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getUpdatedSelectionState.js\n// module id = 233\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getFragmentFromSelection\n * @format\n * \n */\n\n'use strict';\n\nvar getContentStateFragment = require('./getContentStateFragment');\n\nfunction getFragmentFromSelection(editorState) {\n  var selectionState = editorState.getSelection();\n\n  if (selectionState.isCollapsed()) {\n    return null;\n  }\n\n  return getContentStateFragment(editorState.getCurrentContent(), selectionState);\n}\n\nmodule.exports = getFragmentFromSelection;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getFragmentFromSelection.js\n// module id = 234\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getRangeClientRects\n * @format\n * \n */\n\n'use strict';\n\nvar UserAgent = require('fbjs/lib/UserAgent');\n\nvar invariant = require('fbjs/lib/invariant');\n\nvar isChrome = UserAgent.isBrowser('Chrome');\n\n// In Chrome, the client rects will include the entire bounds of all nodes that\n// begin (have a start tag) within the selection, even if the selection does\n// not overlap the entire node. To resolve this, we split the range at each\n// start tag and join the client rects together.\n// https://code.google.com/p/chromium/issues/detail?id=324437\n/* eslint-disable consistent-return */\nfunction getRangeClientRectsChrome(range) {\n  var tempRange = range.cloneRange();\n  var clientRects = [];\n\n  for (var ancestor = range.endContainer; ancestor != null; ancestor = ancestor.parentNode) {\n    // If we've climbed up to the common ancestor, we can now use the\n    // original start point and stop climbing the tree.\n    var atCommonAncestor = ancestor === range.commonAncestorContainer;\n    if (atCommonAncestor) {\n      tempRange.setStart(range.startContainer, range.startOffset);\n    } else {\n      tempRange.setStart(tempRange.endContainer, 0);\n    }\n    var rects = Array.from(tempRange.getClientRects());\n    clientRects.push(rects);\n    if (atCommonAncestor) {\n      var _ref;\n\n      clientRects.reverse();\n      return (_ref = []).concat.apply(_ref, clientRects);\n    }\n    tempRange.setEndBefore(ancestor);\n  }\n\n  !false ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Found an unexpected detached subtree when getting range client rects.') : invariant(false) : void 0;\n}\n/* eslint-enable consistent-return */\n\n/**\n * Like range.getClientRects() but normalizes for browser bugs.\n */\nvar getRangeClientRects = isChrome ? getRangeClientRectsChrome : function (range) {\n  return Array.from(range.getClientRects());\n};\n\nmodule.exports = getRangeClientRects;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getRangeClientRects.js\n// module id = 235\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getDraftEditorSelectionWithNodes\n * @format\n * \n */\n\n'use strict';\n\nvar findAncestorOffsetKey = require('./findAncestorOffsetKey');\nvar getSelectionOffsetKeyForNode = require('./getSelectionOffsetKeyForNode');\nvar getUpdatedSelectionState = require('./getUpdatedSelectionState');\nvar invariant = require('fbjs/lib/invariant');\nvar nullthrows = require('fbjs/lib/nullthrows');\n\n/**\n * Convert the current selection range to an anchor/focus pair of offset keys\n * and values that can be interpreted by components.\n */\nfunction getDraftEditorSelectionWithNodes(editorState, root, anchorNode, anchorOffset, focusNode, focusOffset) {\n  var anchorIsTextNode = anchorNode.nodeType === Node.TEXT_NODE;\n  var focusIsTextNode = focusNode.nodeType === Node.TEXT_NODE;\n\n  // If the selection range lies only on text nodes, the task is simple.\n  // Find the nearest offset-aware elements and use the\n  // offset values supplied by the selection range.\n  if (anchorIsTextNode && focusIsTextNode) {\n    return {\n      selectionState: getUpdatedSelectionState(editorState, nullthrows(findAncestorOffsetKey(anchorNode)), anchorOffset, nullthrows(findAncestorOffsetKey(focusNode)), focusOffset),\n      needsRecovery: false\n    };\n  }\n\n  var anchorPoint = null;\n  var focusPoint = null;\n  var needsRecovery = true;\n\n  // An element is selected. Convert this selection range into leaf offset\n  // keys and offset values for consumption at the component level. This\n  // is common in Firefox, where select-all and triple click behavior leads\n  // to entire elements being selected.\n  //\n  // Note that we use the `needsRecovery` parameter in the callback here. This\n  // is because when certain elements are selected, the behavior for subsequent\n  // cursor movement (e.g. via arrow keys) is uncertain and may not match\n  // expectations at the component level. For example, if an entire <div> is\n  // selected and the user presses the right arrow, Firefox keeps the selection\n  // on the <div>. If we allow subsequent keypresses to insert characters\n  // natively, they will be inserted into a browser-created text node to the\n  // right of that <div>. This is obviously undesirable.\n  //\n  // With the `needsRecovery` flag, we inform the caller that it is responsible\n  // for manually setting the selection state on the rendered document to\n  // ensure proper selection state maintenance.\n\n  if (anchorIsTextNode) {\n    anchorPoint = {\n      key: nullthrows(findAncestorOffsetKey(anchorNode)),\n      offset: anchorOffset\n    };\n    focusPoint = getPointForNonTextNode(root, focusNode, focusOffset);\n  } else if (focusIsTextNode) {\n    focusPoint = {\n      key: nullthrows(findAncestorOffsetKey(focusNode)),\n      offset: focusOffset\n    };\n    anchorPoint = getPointForNonTextNode(root, anchorNode, anchorOffset);\n  } else {\n    anchorPoint = getPointForNonTextNode(root, anchorNode, anchorOffset);\n    focusPoint = getPointForNonTextNode(root, focusNode, focusOffset);\n\n    // If the selection is collapsed on an empty block, don't force recovery.\n    // This way, on arrow key selection changes, the browser can move the\n    // cursor from a non-zero offset on one block, through empty blocks,\n    // to a matching non-zero offset on other text blocks.\n    if (anchorNode === focusNode && anchorOffset === focusOffset) {\n      needsRecovery = !!anchorNode.firstChild && anchorNode.firstChild.nodeName !== 'BR';\n    }\n  }\n\n  return {\n    selectionState: getUpdatedSelectionState(editorState, anchorPoint.key, anchorPoint.offset, focusPoint.key, focusPoint.offset),\n    needsRecovery: needsRecovery\n  };\n}\n\n/**\n * Identify the first leaf descendant for the given node.\n */\nfunction getFirstLeaf(node) {\n  while (node.firstChild && (\n  // data-blocks has no offset\n  node.firstChild instanceof Element && node.firstChild.getAttribute('data-blocks') === 'true' || getSelectionOffsetKeyForNode(node.firstChild))) {\n    node = node.firstChild;\n  }\n  return node;\n}\n\n/**\n * Identify the last leaf descendant for the given node.\n */\nfunction getLastLeaf(node) {\n  while (node.lastChild && (\n  // data-blocks has no offset\n  node.lastChild instanceof Element && node.lastChild.getAttribute('data-blocks') === 'true' || getSelectionOffsetKeyForNode(node.lastChild))) {\n    node = node.lastChild;\n  }\n  return node;\n}\n\nfunction getPointForNonTextNode(editorRoot, startNode, childOffset) {\n  var node = startNode;\n  var offsetKey = findAncestorOffsetKey(node);\n\n  !(offsetKey != null || editorRoot && (editorRoot === node || editorRoot.firstChild === node)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Unknown node in selection range.') : invariant(false) : void 0;\n\n  // If the editorRoot is the selection, step downward into the content\n  // wrapper.\n  if (editorRoot === node) {\n    node = node.firstChild;\n    !(node instanceof Element && node.getAttribute('data-contents') === 'true') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Invalid DraftEditorContents structure.') : invariant(false) : void 0;\n    if (childOffset > 0) {\n      childOffset = node.childNodes.length;\n    }\n  }\n\n  // If the child offset is zero and we have an offset key, we're done.\n  // If there's no offset key because the entire editor is selected,\n  // find the leftmost (\"first\") leaf in the tree and use that as the offset\n  // key.\n  if (childOffset === 0) {\n    var key = null;\n    if (offsetKey != null) {\n      key = offsetKey;\n    } else {\n      var firstLeaf = getFirstLeaf(node);\n      key = nullthrows(getSelectionOffsetKeyForNode(firstLeaf));\n    }\n    return { key: key, offset: 0 };\n  }\n\n  var nodeBeforeCursor = node.childNodes[childOffset - 1];\n  var leafKey = null;\n  var textLength = null;\n\n  if (!getSelectionOffsetKeyForNode(nodeBeforeCursor)) {\n    // Our target node may be a leaf or a text node, in which case we're\n    // already where we want to be and can just use the child's length as\n    // our offset.\n    leafKey = nullthrows(offsetKey);\n    textLength = getTextContentLength(nodeBeforeCursor);\n  } else {\n    // Otherwise, we'll look at the child to the left of the cursor and find\n    // the last leaf node in its subtree.\n    var lastLeaf = getLastLeaf(nodeBeforeCursor);\n    leafKey = nullthrows(getSelectionOffsetKeyForNode(lastLeaf));\n    textLength = getTextContentLength(lastLeaf);\n  }\n\n  return {\n    key: leafKey,\n    offset: textLength\n  };\n}\n\n/**\n * Return the length of a node's textContent, regarding single newline\n * characters as zero-length. This allows us to avoid problems with identifying\n * the correct selection offset for empty blocks in IE, in which we\n * render newlines instead of break tags.\n */\nfunction getTextContentLength(node) {\n  var textContent = node.textContent;\n  return textContent === '\\n' ? 0 : textContent.length;\n}\n\nmodule.exports = getDraftEditorSelectionWithNodes;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getDraftEditorSelectionWithNodes.js\n// module id = 236\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftRemovableWord\n * @format\n * \n */\n\n'use strict';\n\nvar TokenizeUtil = require('fbjs/lib/TokenizeUtil');\n\nvar punctuation = TokenizeUtil.getPunctuation();\n\n// The apostrophe and curly single quotes behave in a curious way: when\n// surrounded on both sides by word characters, they behave as word chars; when\n// either neighbor is punctuation or an end of the string, they behave as\n// punctuation.\nvar CHAMELEON_CHARS = '[\\'\\u2018\\u2019]';\n\n// Remove the underscore, which should count as part of the removable word. The\n// \"chameleon chars\" also count as punctuation in this regex.\nvar WHITESPACE_AND_PUNCTUATION = '\\\\s|(?![_])' + punctuation;\n\nvar DELETE_STRING = '^' + '(?:' + WHITESPACE_AND_PUNCTUATION + ')*' + '(?:' + CHAMELEON_CHARS + '|(?!' + WHITESPACE_AND_PUNCTUATION + ').)*' + '(?:(?!' + WHITESPACE_AND_PUNCTUATION + ').)';\nvar DELETE_REGEX = new RegExp(DELETE_STRING);\n\nvar BACKSPACE_STRING = '(?:(?!' + WHITESPACE_AND_PUNCTUATION + ').)' + '(?:' + CHAMELEON_CHARS + '|(?!' + WHITESPACE_AND_PUNCTUATION + ').)*' + '(?:' + WHITESPACE_AND_PUNCTUATION + ')*' + '$';\nvar BACKSPACE_REGEX = new RegExp(BACKSPACE_STRING);\n\nfunction getRemovableWord(text, isBackward) {\n  var matches = isBackward ? BACKSPACE_REGEX.exec(text) : DELETE_REGEX.exec(text);\n  return matches ? matches[0] : text;\n}\n\nvar DraftRemovableWord = {\n  getBackward: function getBackward(text) {\n    return getRemovableWord(text, true);\n  },\n\n  getForward: function getForward(text) {\n    return getRemovableWord(text, false);\n  }\n};\n\nmodule.exports = DraftRemovableWord;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftRemovableWord.js\n// module id = 237\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule moveSelectionForward\n * @format\n * \n */\n\n'use strict';\n\n/**\n * Given a collapsed selection, move the focus `maxDistance` forward within\n * the selected block. If the selection will go beyond the end of the block,\n * move focus to the start of the next block, but no further.\n *\n * This function is not Unicode-aware, so surrogate pairs will be treated\n * as having length 2.\n */\nfunction moveSelectionForward(editorState, maxDistance) {\n  var selection = editorState.getSelection();\n  var key = selection.getStartKey();\n  var offset = selection.getStartOffset();\n  var content = editorState.getCurrentContent();\n\n  var focusKey = key;\n  var focusOffset;\n\n  var block = content.getBlockForKey(key);\n\n  if (maxDistance > block.getText().length - offset) {\n    focusKey = content.getKeyAfter(key);\n    focusOffset = 0;\n  } else {\n    focusOffset = offset + maxDistance;\n  }\n\n  return selection.merge({ focusKey: focusKey, focusOffset: focusOffset });\n}\n\nmodule.exports = moveSelectionForward;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/moveSelectionForward.js\n// module id = 238\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule convertFromHTMLToContentBlocks\n * @format\n * \n */\n\n'use strict';\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _knownListItemDepthCl,\n    _assign = require('object-assign');\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar CharacterMetadata = require('./CharacterMetadata');\nvar ContentBlock = require('./ContentBlock');\nvar ContentBlockNode = require('./ContentBlockNode');\nvar DefaultDraftBlockRenderMap = require('./DefaultDraftBlockRenderMap');\nvar DraftEntity = require('./DraftEntity');\nvar DraftFeatureFlags = require('./DraftFeatureFlags');\nvar Immutable = require('immutable');\n\nvar _require = require('immutable'),\n    Set = _require.Set;\n\nvar URI = require('fbjs/lib/URI');\n\nvar cx = require('fbjs/lib/cx');\nvar generateRandomKey = require('./generateRandomKey');\nvar getSafeBodyFromHTML = require('./getSafeBodyFromHTML');\nvar invariant = require('fbjs/lib/invariant');\nvar sanitizeDraftText = require('./sanitizeDraftText');\n\nvar experimentalTreeDataSupport = DraftFeatureFlags.draft_tree_data_support;\n\nvar List = Immutable.List,\n    OrderedSet = Immutable.OrderedSet;\n\n\nvar NBSP = '&nbsp;';\nvar SPACE = ' ';\n\n// Arbitrary max indent\nvar MAX_DEPTH = 4;\n\n// used for replacing characters in HTML\nvar REGEX_CR = new RegExp('\\r', 'g');\nvar REGEX_LF = new RegExp('\\n', 'g');\nvar REGEX_NBSP = new RegExp(NBSP, 'g');\nvar REGEX_CARRIAGE = new RegExp('&#13;?', 'g');\nvar REGEX_ZWS = new RegExp('&#8203;?', 'g');\n\n// https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight\nvar boldValues = ['bold', 'bolder', '500', '600', '700', '800', '900'];\nvar notBoldValues = ['light', 'lighter', '100', '200', '300', '400'];\n\n// Block tag flow is different because LIs do not have\n// a deterministic style ;_;\nvar inlineTags = {\n  b: 'BOLD',\n  code: 'CODE',\n  del: 'STRIKETHROUGH',\n  em: 'ITALIC',\n  i: 'ITALIC',\n  s: 'STRIKETHROUGH',\n  strike: 'STRIKETHROUGH',\n  strong: 'BOLD',\n  u: 'UNDERLINE'\n};\n\nvar knownListItemDepthClasses = (_knownListItemDepthCl = {}, _defineProperty(_knownListItemDepthCl, cx('public/DraftStyleDefault/depth0'), 0), _defineProperty(_knownListItemDepthCl, cx('public/DraftStyleDefault/depth1'), 1), _defineProperty(_knownListItemDepthCl, cx('public/DraftStyleDefault/depth2'), 2), _defineProperty(_knownListItemDepthCl, cx('public/DraftStyleDefault/depth3'), 3), _defineProperty(_knownListItemDepthCl, cx('public/DraftStyleDefault/depth4'), 4), _knownListItemDepthCl);\n\nvar anchorAttr = ['className', 'href', 'rel', 'target', 'title'];\n\nvar imgAttr = ['alt', 'className', 'height', 'src', 'width'];\n\nvar lastBlock = void 0;\n\nvar EMPTY_CHUNK = {\n  text: '',\n  inlines: [],\n  entities: [],\n  blocks: []\n};\n\nvar EMPTY_BLOCK = {\n  children: List(),\n  depth: 0,\n  key: '',\n  type: ''\n};\n\nvar getListBlockType = function getListBlockType(tag, lastList) {\n  if (tag === 'li') {\n    return lastList === 'ol' ? 'ordered-list-item' : 'unordered-list-item';\n  }\n  return null;\n};\n\nvar getBlockMapSupportedTags = function getBlockMapSupportedTags(blockRenderMap) {\n  var unstyledElement = blockRenderMap.get('unstyled').element;\n  var tags = Set([]);\n\n  blockRenderMap.forEach(function (draftBlock) {\n    if (draftBlock.aliasedElements) {\n      draftBlock.aliasedElements.forEach(function (tag) {\n        tags = tags.add(tag);\n      });\n    }\n\n    tags = tags.add(draftBlock.element);\n  });\n\n  return tags.filter(function (tag) {\n    return tag && tag !== unstyledElement;\n  }).toArray().sort();\n};\n\n// custom element conversions\nvar getMultiMatchedType = function getMultiMatchedType(tag, lastList, multiMatchExtractor) {\n  for (var ii = 0; ii < multiMatchExtractor.length; ii++) {\n    var matchType = multiMatchExtractor[ii](tag, lastList);\n    if (matchType) {\n      return matchType;\n    }\n  }\n  return null;\n};\n\nvar getBlockTypeForTag = function getBlockTypeForTag(tag, lastList, blockRenderMap) {\n  var matchedTypes = blockRenderMap.filter(function (draftBlock) {\n    return draftBlock.element === tag || draftBlock.wrapper === tag || draftBlock.aliasedElements && draftBlock.aliasedElements.some(function (alias) {\n      return alias === tag;\n    });\n  }).keySeq().toSet().toArray().sort();\n\n  // if we dont have any matched type, return unstyled\n  // if we have one matched type return it\n  // if we have multi matched types use the multi-match function to gather type\n  switch (matchedTypes.length) {\n    case 0:\n      return 'unstyled';\n    case 1:\n      return matchedTypes[0];\n    default:\n      return getMultiMatchedType(tag, lastList, [getListBlockType]) || 'unstyled';\n  }\n};\n\nvar processInlineTag = function processInlineTag(tag, node, currentStyle) {\n  var styleToCheck = inlineTags[tag];\n  if (styleToCheck) {\n    currentStyle = currentStyle.add(styleToCheck).toOrderedSet();\n  } else if (node instanceof HTMLElement) {\n    var htmlElement = node;\n    currentStyle = currentStyle.withMutations(function (style) {\n      var fontWeight = htmlElement.style.fontWeight;\n      var fontStyle = htmlElement.style.fontStyle;\n      var textDecoration = htmlElement.style.textDecoration;\n\n      if (boldValues.indexOf(fontWeight) >= 0) {\n        style.add('BOLD');\n      } else if (notBoldValues.indexOf(fontWeight) >= 0) {\n        style.remove('BOLD');\n      }\n\n      if (fontStyle === 'italic') {\n        style.add('ITALIC');\n      } else if (fontStyle === 'normal') {\n        style.remove('ITALIC');\n      }\n\n      if (textDecoration === 'underline') {\n        style.add('UNDERLINE');\n      }\n      if (textDecoration === 'line-through') {\n        style.add('STRIKETHROUGH');\n      }\n      if (textDecoration === 'none') {\n        style.remove('UNDERLINE');\n        style.remove('STRIKETHROUGH');\n      }\n    }).toOrderedSet();\n  }\n  return currentStyle;\n};\n\nvar joinChunks = function joinChunks(A, B, experimentalHasNestedBlocks) {\n  // Sometimes two blocks will touch in the DOM and we need to strip the\n  // extra delimiter to preserve niceness.\n  var lastInA = A.text.slice(-1);\n  var firstInB = B.text.slice(0, 1);\n\n  if (lastInA === '\\r' && firstInB === '\\r' && !experimentalHasNestedBlocks) {\n    A.text = A.text.slice(0, -1);\n    A.inlines.pop();\n    A.entities.pop();\n    A.blocks.pop();\n  }\n\n  // Kill whitespace after blocks\n  if (lastInA === '\\r') {\n    if (B.text === SPACE || B.text === '\\n') {\n      return A;\n    } else if (firstInB === SPACE || firstInB === '\\n') {\n      B.text = B.text.slice(1);\n      B.inlines.shift();\n      B.entities.shift();\n    }\n  }\n\n  return {\n    text: A.text + B.text,\n    inlines: A.inlines.concat(B.inlines),\n    entities: A.entities.concat(B.entities),\n    blocks: A.blocks.concat(B.blocks)\n  };\n};\n\n/**\n * Check to see if we have anything like <p> <blockquote> <h1>... to create\n * block tags from. If we do, we can use those and ignore <div> tags. If we\n * don't, we can treat <div> tags as meaningful (unstyled) blocks.\n */\nvar containsSemanticBlockMarkup = function containsSemanticBlockMarkup(html, blockTags) {\n  return blockTags.some(function (tag) {\n    return html.indexOf('<' + tag) !== -1;\n  });\n};\n\nvar hasValidLinkText = function hasValidLinkText(link) {\n  !(link instanceof HTMLAnchorElement) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Link must be an HTMLAnchorElement.') : invariant(false) : void 0;\n  var protocol = link.protocol;\n  return protocol === 'http:' || protocol === 'https:' || protocol === 'mailto:';\n};\n\nvar getWhitespaceChunk = function getWhitespaceChunk(inEntity) {\n  var entities = new Array(1);\n  if (inEntity) {\n    entities[0] = inEntity;\n  }\n  return _extends({}, EMPTY_CHUNK, {\n    text: SPACE,\n    inlines: [OrderedSet()],\n    entities: entities\n  });\n};\n\nvar getSoftNewlineChunk = function getSoftNewlineChunk() {\n  return _extends({}, EMPTY_CHUNK, {\n    text: '\\n',\n    inlines: [OrderedSet()],\n    entities: new Array(1)\n  });\n};\n\nvar getChunkedBlock = function getChunkedBlock() {\n  var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n  return _extends({}, EMPTY_BLOCK, props);\n};\n\nvar getBlockDividerChunk = function getBlockDividerChunk(block, depth) {\n  var parentKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n\n  return {\n    text: '\\r',\n    inlines: [OrderedSet()],\n    entities: new Array(1),\n    blocks: [getChunkedBlock({\n      parent: parentKey,\n      key: generateRandomKey(),\n      type: block,\n      depth: Math.max(0, Math.min(MAX_DEPTH, depth))\n    })]\n  };\n};\n\n/**\n *  If we're pasting from one DraftEditor to another we can check to see if\n *  existing list item depth classes are being used and preserve this style\n */\nvar getListItemDepth = function getListItemDepth(node) {\n  var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n  Object.keys(knownListItemDepthClasses).some(function (depthClass) {\n    if (node.classList.contains(depthClass)) {\n      depth = knownListItemDepthClasses[depthClass];\n    }\n  });\n  return depth;\n};\n\nvar genFragment = function genFragment(entityMap, node, inlineStyle, lastList, inBlock, blockTags, depth, blockRenderMap, inEntity, parentKey) {\n  var lastLastBlock = lastBlock;\n  var nodeName = node.nodeName.toLowerCase();\n  var newEntityMap = entityMap;\n  var nextBlockType = 'unstyled';\n  var newBlock = false;\n  var inBlockType = inBlock && getBlockTypeForTag(inBlock, lastList, blockRenderMap);\n  var chunk = _extends({}, EMPTY_CHUNK);\n  var newChunk = null;\n  var blockKey = void 0;\n\n  // Base Case\n  if (nodeName === '#text') {\n    var _text = node.textContent;\n    var nodeTextContent = _text.trim();\n\n    // We should not create blocks for leading spaces that are\n    // existing around ol/ul and their children list items\n    if (lastList && nodeTextContent === '' && node.parentElement) {\n      var parentNodeName = node.parentElement.nodeName.toLowerCase();\n      if (parentNodeName === 'ol' || parentNodeName === 'ul') {\n        return { chunk: _extends({}, EMPTY_CHUNK), entityMap: entityMap };\n      }\n    }\n\n    if (nodeTextContent === '' && inBlock !== 'pre') {\n      return { chunk: getWhitespaceChunk(inEntity), entityMap: entityMap };\n    }\n    if (inBlock !== 'pre') {\n      // Can't use empty string because MSWord\n      _text = _text.replace(REGEX_LF, SPACE);\n    }\n\n    // save the last block so we can use it later\n    lastBlock = nodeName;\n\n    return {\n      chunk: {\n        text: _text,\n        inlines: Array(_text.length).fill(inlineStyle),\n        entities: Array(_text.length).fill(inEntity),\n        blocks: []\n      },\n      entityMap: entityMap\n    };\n  }\n\n  // save the last block so we can use it later\n  lastBlock = nodeName;\n\n  // BR tags\n  if (nodeName === 'br') {\n    if (lastLastBlock === 'br' && (!inBlock || inBlockType === 'unstyled')) {\n      return {\n        chunk: getBlockDividerChunk('unstyled', depth, parentKey),\n        entityMap: entityMap\n      };\n    }\n    return { chunk: getSoftNewlineChunk(), entityMap: entityMap };\n  }\n\n  // IMG tags\n  if (nodeName === 'img' && node instanceof HTMLImageElement && node.attributes.getNamedItem('src') && node.attributes.getNamedItem('src').value) {\n    var image = node;\n    var entityConfig = {};\n\n    imgAttr.forEach(function (attr) {\n      var imageAttribute = image.getAttribute(attr);\n      if (imageAttribute) {\n        entityConfig[attr] = imageAttribute;\n      }\n    });\n    // Forcing this node to have children because otherwise no entity will be\n    // created for this node.\n    // The child text node cannot just have a space or return as content -\n    // we strip those out.\n    // See https://github.com/facebook/draft-js/issues/231 for some context.\n    node.textContent = '\\uD83D\\uDCF7';\n\n    // TODO: update this when we remove DraftEntity entirely\n    inEntity = DraftEntity.__create('IMAGE', 'MUTABLE', entityConfig || {});\n  }\n\n  // Inline tags\n  inlineStyle = processInlineTag(nodeName, node, inlineStyle);\n\n  // Handle lists\n  if (nodeName === 'ul' || nodeName === 'ol') {\n    if (lastList) {\n      depth += 1;\n    }\n    lastList = nodeName;\n  }\n\n  if (!experimentalTreeDataSupport && nodeName === 'li' && node instanceof HTMLElement) {\n    depth = getListItemDepth(node, depth);\n  }\n\n  var blockType = getBlockTypeForTag(nodeName, lastList, blockRenderMap);\n  var inListBlock = lastList && inBlock === 'li' && nodeName === 'li';\n  var inBlockOrHasNestedBlocks = (!inBlock || experimentalTreeDataSupport) && blockTags.indexOf(nodeName) !== -1;\n\n  // Block Tags\n  if (inListBlock || inBlockOrHasNestedBlocks) {\n    chunk = getBlockDividerChunk(blockType, depth, parentKey);\n    blockKey = chunk.blocks[0].key;\n    inBlock = nodeName;\n    newBlock = !experimentalTreeDataSupport;\n  }\n\n  // this is required so that we can handle 'ul' and 'ol'\n  if (inListBlock) {\n    nextBlockType = lastList === 'ul' ? 'unordered-list-item' : 'ordered-list-item';\n  }\n\n  // Recurse through children\n  var child = node.firstChild;\n  if (child != null) {\n    nodeName = child.nodeName.toLowerCase();\n  }\n\n  var entityId = null;\n\n  while (child) {\n    if (child instanceof HTMLAnchorElement && child.href && hasValidLinkText(child)) {\n      (function () {\n        var anchor = child;\n        var entityConfig = {};\n\n        anchorAttr.forEach(function (attr) {\n          var anchorAttribute = anchor.getAttribute(attr);\n          if (anchorAttribute) {\n            entityConfig[attr] = anchorAttribute;\n          }\n        });\n\n        entityConfig.url = new URI(anchor.href).toString();\n        // TODO: update this when we remove DraftEntity completely\n        entityId = DraftEntity.__create('LINK', 'MUTABLE', entityConfig || {});\n      })();\n    } else {\n      entityId = undefined;\n    }\n\n    var _genFragment = genFragment(newEntityMap, child, inlineStyle, lastList, inBlock, blockTags, depth, blockRenderMap, entityId || inEntity, experimentalTreeDataSupport ? blockKey : null),\n        generatedChunk = _genFragment.chunk,\n        maybeUpdatedEntityMap = _genFragment.entityMap;\n\n    newChunk = generatedChunk;\n    newEntityMap = maybeUpdatedEntityMap;\n\n    chunk = joinChunks(chunk, newChunk, experimentalTreeDataSupport);\n    var sibling = child.nextSibling;\n\n    // Put in a newline to break up blocks inside blocks\n    if (!parentKey && sibling && blockTags.indexOf(nodeName) >= 0 && inBlock) {\n      chunk = joinChunks(chunk, getSoftNewlineChunk());\n    }\n    if (sibling) {\n      nodeName = sibling.nodeName.toLowerCase();\n    }\n    child = sibling;\n  }\n\n  if (newBlock) {\n    chunk = joinChunks(chunk, getBlockDividerChunk(nextBlockType, depth, parentKey));\n  }\n\n  return { chunk: chunk, entityMap: newEntityMap };\n};\n\nvar getChunkForHTML = function getChunkForHTML(html, DOMBuilder, blockRenderMap, entityMap) {\n  html = html.trim().replace(REGEX_CR, '').replace(REGEX_NBSP, SPACE).replace(REGEX_CARRIAGE, '').replace(REGEX_ZWS, '');\n\n  var supportedBlockTags = getBlockMapSupportedTags(blockRenderMap);\n\n  var safeBody = DOMBuilder(html);\n  if (!safeBody) {\n    return null;\n  }\n  lastBlock = null;\n\n  // Sometimes we aren't dealing with content that contains nice semantic\n  // tags. In this case, use divs to separate everything out into paragraphs\n  // and hope for the best.\n  var workingBlocks = containsSemanticBlockMarkup(html, supportedBlockTags) ? supportedBlockTags : ['div'];\n\n  // Start with -1 block depth to offset the fact that we are passing in a fake\n  // UL block to start with.\n  var fragment = genFragment(entityMap, safeBody, OrderedSet(), 'ul', null, workingBlocks, -1, blockRenderMap);\n\n  var chunk = fragment.chunk;\n  var newEntityMap = fragment.entityMap;\n\n  // join with previous block to prevent weirdness on paste\n  if (chunk.text.indexOf('\\r') === 0) {\n    chunk = {\n      text: chunk.text.slice(1),\n      inlines: chunk.inlines.slice(1),\n      entities: chunk.entities.slice(1),\n      blocks: chunk.blocks\n    };\n  }\n\n  // Kill block delimiter at the end\n  if (chunk.text.slice(-1) === '\\r') {\n    chunk.text = chunk.text.slice(0, -1);\n    chunk.inlines = chunk.inlines.slice(0, -1);\n    chunk.entities = chunk.entities.slice(0, -1);\n    chunk.blocks.pop();\n  }\n\n  // If we saw no block tags, put an unstyled one in\n  if (chunk.blocks.length === 0) {\n    chunk.blocks.push(_extends({}, EMPTY_CHUNK, {\n      type: 'unstyled',\n      depth: 0\n    }));\n  }\n\n  // Sometimes we start with text that isn't in a block, which is then\n  // followed by blocks. Need to fix up the blocks to add in\n  // an unstyled block for this content\n  if (chunk.text.split('\\r').length === chunk.blocks.length + 1) {\n    chunk.blocks.unshift({ type: 'unstyled', depth: 0 });\n  }\n\n  return { chunk: chunk, entityMap: newEntityMap };\n};\n\nvar convertChunkToContentBlocks = function convertChunkToContentBlocks(chunk) {\n  if (!chunk || !chunk.text || !Array.isArray(chunk.blocks)) {\n    return null;\n  }\n\n  var initialState = {\n    cacheRef: {},\n    contentBlocks: []\n  };\n\n  var start = 0;\n\n  var rawBlocks = chunk.blocks,\n      rawInlines = chunk.inlines,\n      rawEntities = chunk.entities;\n\n\n  var BlockNodeRecord = experimentalTreeDataSupport ? ContentBlockNode : ContentBlock;\n\n  return chunk.text.split('\\r').reduce(function (acc, textBlock, index) {\n    // Make absolutely certain that our text is acceptable.\n    textBlock = sanitizeDraftText(textBlock);\n\n    var block = rawBlocks[index];\n    var end = start + textBlock.length;\n    var inlines = rawInlines.slice(start, end);\n    var entities = rawEntities.slice(start, end);\n    var characterList = List(inlines.map(function (style, index) {\n      var data = { style: style, entity: null };\n      if (entities[index]) {\n        data.entity = entities[index];\n      }\n      return CharacterMetadata.create(data);\n    }));\n    start = end + 1;\n\n    var depth = block.depth,\n        type = block.type,\n        parent = block.parent;\n\n\n    var key = block.key || generateRandomKey();\n    var parentTextNodeKey = null; // will be used to store container text nodes\n\n    // childrens add themselves to their parents since we are iterating in order\n    if (parent) {\n      var parentIndex = acc.cacheRef[parent];\n      var parentRecord = acc.contentBlocks[parentIndex];\n\n      // if parent has text we need to split it into a separate unstyled element\n      if (parentRecord.getChildKeys().isEmpty() && parentRecord.getText()) {\n        var parentCharacterList = parentRecord.getCharacterList();\n        var parentText = parentRecord.getText();\n        parentTextNodeKey = generateRandomKey();\n\n        var textNode = new ContentBlockNode({\n          key: parentTextNodeKey,\n          text: parentText,\n          characterList: parentCharacterList,\n          parent: parent,\n          nextSibling: key\n        });\n\n        acc.contentBlocks.push(textNode);\n\n        parentRecord = parentRecord.withMutations(function (block) {\n          block.set('characterList', List()).set('text', '').set('children', parentRecord.children.push(textNode.getKey()));\n        });\n      }\n\n      acc.contentBlocks[parentIndex] = parentRecord.set('children', parentRecord.children.push(key));\n    }\n\n    var blockNode = new BlockNodeRecord({\n      key: key,\n      parent: parent,\n      type: type,\n      depth: depth,\n      text: textBlock,\n      characterList: characterList,\n      prevSibling: parentTextNodeKey || (index === 0 || rawBlocks[index - 1].parent !== parent ? null : rawBlocks[index - 1].key),\n      nextSibling: index === rawBlocks.length - 1 || rawBlocks[index + 1].parent !== parent ? null : rawBlocks[index + 1].key\n    });\n\n    // insert node\n    acc.contentBlocks.push(blockNode);\n\n    // cache ref for building links\n    acc.cacheRef[blockNode.key] = index;\n\n    return acc;\n  }, initialState).contentBlocks;\n};\n\nvar convertFromHTMLtoContentBlocks = function convertFromHTMLtoContentBlocks(html) {\n  var DOMBuilder = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : getSafeBodyFromHTML;\n  var blockRenderMap = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DefaultDraftBlockRenderMap;\n\n  // Be ABSOLUTELY SURE that the dom builder you pass here won't execute\n  // arbitrary code in whatever environment you're running this in. For an\n  // example of how we try to do this in-browser, see getSafeBodyFromHTML.\n\n  // TODO: replace DraftEntity with an OrderedMap here\n  var chunkData = getChunkForHTML(html, DOMBuilder, blockRenderMap, DraftEntity);\n\n  if (chunkData == null) {\n    return null;\n  }\n\n  var chunk = chunkData.chunk,\n      entityMap = chunkData.entityMap;\n\n  var contentBlocks = convertChunkToContentBlocks(chunk);\n\n  return {\n    contentBlocks: contentBlocks,\n    entityMap: entityMap\n  };\n};\n\nmodule.exports = convertFromHTMLtoContentBlocks;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/convertFromHTMLToContentBlocks.js\n// module id = 239\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getSafeBodyFromHTML\n * @format\n * \n */\n\n'use strict';\n\nvar UserAgent = require('fbjs/lib/UserAgent');\n\nvar invariant = require('fbjs/lib/invariant');\n\nvar isOldIE = UserAgent.isBrowser('IE <= 9');\n\n// Provides a dom node that will not execute scripts\n// https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation.createHTMLDocument\n// https://developer.mozilla.org/en-US/Add-ons/Code_snippets/HTML_to_DOM\n\nfunction getSafeBodyFromHTML(html) {\n  var doc;\n  var root = null;\n  // Provides a safe context\n  if (!isOldIE && document.implementation && document.implementation.createHTMLDocument) {\n    doc = document.implementation.createHTMLDocument('foo');\n    !doc.documentElement ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Missing doc.documentElement') : invariant(false) : void 0;\n    doc.documentElement.innerHTML = html;\n    root = doc.getElementsByTagName('body')[0];\n  }\n  return root;\n}\n\nmodule.exports = getSafeBodyFromHTML;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getSafeBodyFromHTML.js\n// module id = 240\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule RichTextEditorUtil\n * @format\n * \n */\n\n'use strict';\n\nvar DraftModifier = require('./DraftModifier');\nvar EditorState = require('./EditorState');\nvar SelectionState = require('./SelectionState');\n\nvar adjustBlockDepthForContentState = require('./adjustBlockDepthForContentState');\nvar nullthrows = require('fbjs/lib/nullthrows');\n\nvar RichTextEditorUtil = {\n  currentBlockContainsLink: function currentBlockContainsLink(editorState) {\n    var selection = editorState.getSelection();\n    var contentState = editorState.getCurrentContent();\n    var entityMap = contentState.getEntityMap();\n    return contentState.getBlockForKey(selection.getAnchorKey()).getCharacterList().slice(selection.getStartOffset(), selection.getEndOffset()).some(function (v) {\n      var entity = v.getEntity();\n      return !!entity && entityMap.__get(entity).getType() === 'LINK';\n    });\n  },\n\n  getCurrentBlockType: function getCurrentBlockType(editorState) {\n    var selection = editorState.getSelection();\n    return editorState.getCurrentContent().getBlockForKey(selection.getStartKey()).getType();\n  },\n\n  getDataObjectForLinkURL: function getDataObjectForLinkURL(uri) {\n    return { url: uri.toString() };\n  },\n\n  handleKeyCommand: function handleKeyCommand(editorState, command) {\n    switch (command) {\n      case 'bold':\n        return RichTextEditorUtil.toggleInlineStyle(editorState, 'BOLD');\n      case 'italic':\n        return RichTextEditorUtil.toggleInlineStyle(editorState, 'ITALIC');\n      case 'underline':\n        return RichTextEditorUtil.toggleInlineStyle(editorState, 'UNDERLINE');\n      case 'code':\n        return RichTextEditorUtil.toggleCode(editorState);\n      case 'backspace':\n      case 'backspace-word':\n      case 'backspace-to-start-of-line':\n        return RichTextEditorUtil.onBackspace(editorState);\n      case 'delete':\n      case 'delete-word':\n      case 'delete-to-end-of-block':\n        return RichTextEditorUtil.onDelete(editorState);\n      default:\n        // they may have custom editor commands; ignore those\n        return null;\n    }\n  },\n\n  insertSoftNewline: function insertSoftNewline(editorState) {\n    var contentState = DraftModifier.insertText(editorState.getCurrentContent(), editorState.getSelection(), '\\n', editorState.getCurrentInlineStyle(), null);\n\n    var newEditorState = EditorState.push(editorState, contentState, 'insert-characters');\n\n    return EditorState.forceSelection(newEditorState, contentState.getSelectionAfter());\n  },\n\n  /**\n   * For collapsed selections at the start of styled blocks, backspace should\n   * just remove the existing style.\n   */\n  onBackspace: function onBackspace(editorState) {\n    var selection = editorState.getSelection();\n    if (!selection.isCollapsed() || selection.getAnchorOffset() || selection.getFocusOffset()) {\n      return null;\n    }\n\n    // First, try to remove a preceding atomic block.\n    var content = editorState.getCurrentContent();\n    var startKey = selection.getStartKey();\n    var blockBefore = content.getBlockBefore(startKey);\n\n    if (blockBefore && blockBefore.getType() === 'atomic') {\n      var blockMap = content.getBlockMap()['delete'](blockBefore.getKey());\n      var withoutAtomicBlock = content.merge({\n        blockMap: blockMap,\n        selectionAfter: selection\n      });\n      if (withoutAtomicBlock !== content) {\n        return EditorState.push(editorState, withoutAtomicBlock, 'remove-range');\n      }\n    }\n\n    // If that doesn't succeed, try to remove the current block style.\n    var withoutBlockStyle = RichTextEditorUtil.tryToRemoveBlockStyle(editorState);\n\n    if (withoutBlockStyle) {\n      return EditorState.push(editorState, withoutBlockStyle, 'change-block-type');\n    }\n\n    return null;\n  },\n\n  onDelete: function onDelete(editorState) {\n    var selection = editorState.getSelection();\n    if (!selection.isCollapsed()) {\n      return null;\n    }\n\n    var content = editorState.getCurrentContent();\n    var startKey = selection.getStartKey();\n    var block = content.getBlockForKey(startKey);\n    var length = block.getLength();\n\n    // The cursor is somewhere within the text. Behave normally.\n    if (selection.getStartOffset() < length) {\n      return null;\n    }\n\n    var blockAfter = content.getBlockAfter(startKey);\n\n    if (!blockAfter || blockAfter.getType() !== 'atomic') {\n      return null;\n    }\n\n    var atomicBlockTarget = selection.merge({\n      focusKey: blockAfter.getKey(),\n      focusOffset: blockAfter.getLength()\n    });\n\n    var withoutAtomicBlock = DraftModifier.removeRange(content, atomicBlockTarget, 'forward');\n\n    if (withoutAtomicBlock !== content) {\n      return EditorState.push(editorState, withoutAtomicBlock, 'remove-range');\n    }\n\n    return null;\n  },\n\n  onTab: function onTab(event, editorState, maxDepth) {\n    var selection = editorState.getSelection();\n    var key = selection.getAnchorKey();\n    if (key !== selection.getFocusKey()) {\n      return editorState;\n    }\n\n    var content = editorState.getCurrentContent();\n    var block = content.getBlockForKey(key);\n    var type = block.getType();\n    if (type !== 'unordered-list-item' && type !== 'ordered-list-item') {\n      return editorState;\n    }\n\n    event.preventDefault();\n\n    // Only allow indenting one level beyond the block above, and only if\n    // the block above is a list item as well.\n    var blockAbove = content.getBlockBefore(key);\n    if (!blockAbove) {\n      return editorState;\n    }\n\n    var typeAbove = blockAbove.getType();\n    if (typeAbove !== 'unordered-list-item' && typeAbove !== 'ordered-list-item') {\n      return editorState;\n    }\n\n    var depth = block.getDepth();\n    if (!event.shiftKey && depth === maxDepth) {\n      return editorState;\n    }\n\n    maxDepth = Math.min(blockAbove.getDepth() + 1, maxDepth);\n\n    var withAdjustment = adjustBlockDepthForContentState(content, selection, event.shiftKey ? -1 : 1, maxDepth);\n\n    return EditorState.push(editorState, withAdjustment, 'adjust-depth');\n  },\n\n  toggleBlockType: function toggleBlockType(editorState, blockType) {\n    var selection = editorState.getSelection();\n    var startKey = selection.getStartKey();\n    var endKey = selection.getEndKey();\n    var content = editorState.getCurrentContent();\n    var target = selection;\n\n    // Triple-click can lead to a selection that includes offset 0 of the\n    // following block. The `SelectionState` for this case is accurate, but\n    // we should avoid toggling block type for the trailing block because it\n    // is a confusing interaction.\n    if (startKey !== endKey && selection.getEndOffset() === 0) {\n      var blockBefore = nullthrows(content.getBlockBefore(endKey));\n      endKey = blockBefore.getKey();\n      target = target.merge({\n        anchorKey: startKey,\n        anchorOffset: selection.getStartOffset(),\n        focusKey: endKey,\n        focusOffset: blockBefore.getLength(),\n        isBackward: false\n      });\n    }\n\n    var hasAtomicBlock = content.getBlockMap().skipWhile(function (_, k) {\n      return k !== startKey;\n    }).reverse().skipWhile(function (_, k) {\n      return k !== endKey;\n    }).some(function (v) {\n      return v.getType() === 'atomic';\n    });\n\n    if (hasAtomicBlock) {\n      return editorState;\n    }\n\n    var typeToSet = content.getBlockForKey(startKey).getType() === blockType ? 'unstyled' : blockType;\n\n    return EditorState.push(editorState, DraftModifier.setBlockType(content, target, typeToSet), 'change-block-type');\n  },\n\n  toggleCode: function toggleCode(editorState) {\n    var selection = editorState.getSelection();\n    var anchorKey = selection.getAnchorKey();\n    var focusKey = selection.getFocusKey();\n\n    if (selection.isCollapsed() || anchorKey !== focusKey) {\n      return RichTextEditorUtil.toggleBlockType(editorState, 'code-block');\n    }\n\n    return RichTextEditorUtil.toggleInlineStyle(editorState, 'CODE');\n  },\n\n  /**\n   * Toggle the specified inline style for the selection. If the\n   * user's selection is collapsed, apply or remove the style for the\n   * internal state. If it is not collapsed, apply the change directly\n   * to the document state.\n   */\n  toggleInlineStyle: function toggleInlineStyle(editorState, inlineStyle) {\n    var selection = editorState.getSelection();\n    var currentStyle = editorState.getCurrentInlineStyle();\n\n    // If the selection is collapsed, toggle the specified style on or off and\n    // set the result as the new inline style override. This will then be\n    // used as the inline style for the next character to be inserted.\n    if (selection.isCollapsed()) {\n      return EditorState.setInlineStyleOverride(editorState, currentStyle.has(inlineStyle) ? currentStyle.remove(inlineStyle) : currentStyle.add(inlineStyle));\n    }\n\n    // If characters are selected, immediately apply or remove the\n    // inline style on the document state itself.\n    var content = editorState.getCurrentContent();\n    var newContent;\n\n    // If the style is already present for the selection range, remove it.\n    // Otherwise, apply it.\n    if (currentStyle.has(inlineStyle)) {\n      newContent = DraftModifier.removeInlineStyle(content, selection, inlineStyle);\n    } else {\n      newContent = DraftModifier.applyInlineStyle(content, selection, inlineStyle);\n    }\n\n    return EditorState.push(editorState, newContent, 'change-inline-style');\n  },\n\n  toggleLink: function toggleLink(editorState, targetSelection, entityKey) {\n    var withoutLink = DraftModifier.applyEntity(editorState.getCurrentContent(), targetSelection, entityKey);\n\n    return EditorState.push(editorState, withoutLink, 'apply-entity');\n  },\n\n  /**\n   * When a collapsed cursor is at the start of the first styled block, or\n   * an empty styled block, changes block to 'unstyled'. Returns null if\n   * block or selection does not meet that criteria.\n   */\n  tryToRemoveBlockStyle: function tryToRemoveBlockStyle(editorState) {\n    var selection = editorState.getSelection();\n    var offset = selection.getAnchorOffset();\n    if (selection.isCollapsed() && offset === 0) {\n      var key = selection.getAnchorKey();\n      var content = editorState.getCurrentContent();\n      var block = content.getBlockForKey(key);\n\n      var firstBlock = content.getFirstBlock();\n      if (block.getLength() > 0 && block !== firstBlock) {\n        return null;\n      }\n\n      var type = block.getType();\n      var blockBefore = content.getBlockBefore(key);\n      if (type === 'code-block' && blockBefore && blockBefore.getType() === 'code-block' && blockBefore.getLength() !== 0) {\n        return null;\n      }\n\n      if (type !== 'unstyled') {\n        return DraftModifier.setBlockType(content, selection, 'unstyled');\n      }\n    }\n    return null;\n  }\n};\n\nmodule.exports = RichTextEditorUtil;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/RichTextEditorUtil.js\n// module id = 241\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getDefaultKeyBinding\n * @format\n * \n */\n\n'use strict';\n\nvar KeyBindingUtil = require('./KeyBindingUtil');\nvar Keys = require('fbjs/lib/Keys');\nvar UserAgent = require('fbjs/lib/UserAgent');\n\nvar isOSX = UserAgent.isPlatform('Mac OS X');\nvar isWindows = UserAgent.isPlatform('Windows');\n\n// Firefox on OSX had a bug resulting in navigation instead of cursor movement.\n// This bug was fixed in Firefox 29. Feature detection is virtually impossible\n// so we just check the version number. See #342765.\nvar shouldFixFirefoxMovement = isOSX && UserAgent.isBrowser('Firefox < 29');\n\nvar hasCommandModifier = KeyBindingUtil.hasCommandModifier,\n    isCtrlKeyCommand = KeyBindingUtil.isCtrlKeyCommand;\n\n\nfunction shouldRemoveWord(e) {\n  return isOSX && e.altKey || isCtrlKeyCommand(e);\n}\n\n/**\n * Get the appropriate undo/redo command for a Z key command.\n */\nfunction getZCommand(e) {\n  if (!hasCommandModifier(e)) {\n    return null;\n  }\n  return e.shiftKey ? 'redo' : 'undo';\n}\n\nfunction getDeleteCommand(e) {\n  // Allow default \"cut\" behavior for Windows on Shift + Delete.\n  if (isWindows && e.shiftKey) {\n    return null;\n  }\n  return shouldRemoveWord(e) ? 'delete-word' : 'delete';\n}\n\nfunction getBackspaceCommand(e) {\n  if (hasCommandModifier(e) && isOSX) {\n    return 'backspace-to-start-of-line';\n  }\n  return shouldRemoveWord(e) ? 'backspace-word' : 'backspace';\n}\n\n/**\n * Retrieve a bound key command for the given event.\n */\nfunction getDefaultKeyBinding(e) {\n  switch (e.keyCode) {\n    case 66:\n      // B\n      return hasCommandModifier(e) ? 'bold' : null;\n    case 68:\n      // D\n      return isCtrlKeyCommand(e) ? 'delete' : null;\n    case 72:\n      // H\n      return isCtrlKeyCommand(e) ? 'backspace' : null;\n    case 73:\n      // I\n      return hasCommandModifier(e) ? 'italic' : null;\n    case 74:\n      // J\n      return hasCommandModifier(e) ? 'code' : null;\n    case 75:\n      // K\n      return !isWindows && isCtrlKeyCommand(e) ? 'secondary-cut' : null;\n    case 77:\n      // M\n      return isCtrlKeyCommand(e) ? 'split-block' : null;\n    case 79:\n      // O\n      return isCtrlKeyCommand(e) ? 'split-block' : null;\n    case 84:\n      // T\n      return isOSX && isCtrlKeyCommand(e) ? 'transpose-characters' : null;\n    case 85:\n      // U\n      return hasCommandModifier(e) ? 'underline' : null;\n    case 87:\n      // W\n      return isOSX && isCtrlKeyCommand(e) ? 'backspace-word' : null;\n    case 89:\n      // Y\n      if (isCtrlKeyCommand(e)) {\n        return isWindows ? 'redo' : 'secondary-paste';\n      }\n      return null;\n    case 90:\n      // Z\n      return getZCommand(e) || null;\n    case Keys.RETURN:\n      return 'split-block';\n    case Keys.DELETE:\n      return getDeleteCommand(e);\n    case Keys.BACKSPACE:\n      return getBackspaceCommand(e);\n    // LEFT/RIGHT handlers serve as a workaround for a Firefox bug.\n    case Keys.LEFT:\n      return shouldFixFirefoxMovement && hasCommandModifier(e) ? 'move-selection-to-start-of-block' : null;\n    case Keys.RIGHT:\n      return shouldFixFirefoxMovement && hasCommandModifier(e) ? 'move-selection-to-end-of-block' : null;\n    default:\n      return null;\n  }\n}\n\nmodule.exports = getDefaultKeyBinding;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getDefaultKeyBinding.js\n// module id = 242\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftStringKey\n * @format\n * \n */\n\n'use strict';\n\nvar DraftStringKey = {\n  stringify: function stringify(key) {\n    return '_' + String(key);\n  },\n\n  unstringify: function unstringify(key) {\n    return key.slice(1);\n  }\n};\n\nmodule.exports = DraftStringKey;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftStringKey.js\n// module id = 243\n// module chunks = 2","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global.Immutable = factory());\n}(this, function () { 'use strict';var SLICE$0 = Array.prototype.slice;\n\n  function createClass(ctor, superClass) {\n    if (superClass) {\n      ctor.prototype = Object.create(superClass.prototype);\n    }\n    ctor.prototype.constructor = ctor;\n  }\n\n  function Iterable(value) {\n      return isIterable(value) ? value : Seq(value);\n    }\n\n\n  createClass(KeyedIterable, Iterable);\n    function KeyedIterable(value) {\n      return isKeyed(value) ? value : KeyedSeq(value);\n    }\n\n\n  createClass(IndexedIterable, Iterable);\n    function IndexedIterable(value) {\n      return isIndexed(value) ? value : IndexedSeq(value);\n    }\n\n\n  createClass(SetIterable, Iterable);\n    function SetIterable(value) {\n      return isIterable(value) && !isAssociative(value) ? value : SetSeq(value);\n    }\n\n\n\n  function isIterable(maybeIterable) {\n    return !!(maybeIterable && maybeIterable[IS_ITERABLE_SENTINEL]);\n  }\n\n  function isKeyed(maybeKeyed) {\n    return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL]);\n  }\n\n  function isIndexed(maybeIndexed) {\n    return !!(maybeIndexed && maybeIndexed[IS_INDEXED_SENTINEL]);\n  }\n\n  function isAssociative(maybeAssociative) {\n    return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);\n  }\n\n  function isOrdered(maybeOrdered) {\n    return !!(maybeOrdered && maybeOrdered[IS_ORDERED_SENTINEL]);\n  }\n\n  Iterable.isIterable = isIterable;\n  Iterable.isKeyed = isKeyed;\n  Iterable.isIndexed = isIndexed;\n  Iterable.isAssociative = isAssociative;\n  Iterable.isOrdered = isOrdered;\n\n  Iterable.Keyed = KeyedIterable;\n  Iterable.Indexed = IndexedIterable;\n  Iterable.Set = SetIterable;\n\n\n  var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';\n  var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';\n  var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';\n  var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';\n\n  // Used for setting prototype methods that IE8 chokes on.\n  var DELETE = 'delete';\n\n  // Constants describing the size of trie nodes.\n  var SHIFT = 5; // Resulted in best performance after ______?\n  var SIZE = 1 << SHIFT;\n  var MASK = SIZE - 1;\n\n  // A consistent shared value representing \"not set\" which equals nothing other\n  // than itself, and nothing that could be provided externally.\n  var NOT_SET = {};\n\n  // Boolean references, Rough equivalent of `bool &`.\n  var CHANGE_LENGTH = { value: false };\n  var DID_ALTER = { value: false };\n\n  function MakeRef(ref) {\n    ref.value = false;\n    return ref;\n  }\n\n  function SetRef(ref) {\n    ref && (ref.value = true);\n  }\n\n  // A function which returns a value representing an \"owner\" for transient writes\n  // to tries. The return value will only ever equal itself, and will not equal\n  // the return of any subsequent call of this function.\n  function OwnerID() {}\n\n  // http://jsperf.com/copy-array-inline\n  function arrCopy(arr, offset) {\n    offset = offset || 0;\n    var len = Math.max(0, arr.length - offset);\n    var newArr = new Array(len);\n    for (var ii = 0; ii < len; ii++) {\n      newArr[ii] = arr[ii + offset];\n    }\n    return newArr;\n  }\n\n  function ensureSize(iter) {\n    if (iter.size === undefined) {\n      iter.size = iter.__iterate(returnTrue);\n    }\n    return iter.size;\n  }\n\n  function wrapIndex(iter, index) {\n    // This implements \"is array index\" which the ECMAString spec defines as:\n    //\n    //     A String property name P is an array index if and only if\n    //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal\n    //     to 2^32−1.\n    //\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects\n    if (typeof index !== 'number') {\n      var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32\n      if ('' + uint32Index !== index || uint32Index === 4294967295) {\n        return NaN;\n      }\n      index = uint32Index;\n    }\n    return index < 0 ? ensureSize(iter) + index : index;\n  }\n\n  function returnTrue() {\n    return true;\n  }\n\n  function wholeSlice(begin, end, size) {\n    return (begin === 0 || (size !== undefined && begin <= -size)) &&\n      (end === undefined || (size !== undefined && end >= size));\n  }\n\n  function resolveBegin(begin, size) {\n    return resolveIndex(begin, size, 0);\n  }\n\n  function resolveEnd(end, size) {\n    return resolveIndex(end, size, size);\n  }\n\n  function resolveIndex(index, size, defaultIndex) {\n    return index === undefined ?\n      defaultIndex :\n      index < 0 ?\n        Math.max(0, size + index) :\n        size === undefined ?\n          index :\n          Math.min(size, index);\n  }\n\n  /* global Symbol */\n\n  var ITERATE_KEYS = 0;\n  var ITERATE_VALUES = 1;\n  var ITERATE_ENTRIES = 2;\n\n  var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n  var FAUX_ITERATOR_SYMBOL = '@@iterator';\n\n  var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;\n\n\n  function Iterator(next) {\n      this.next = next;\n    }\n\n    Iterator.prototype.toString = function() {\n      return '[Iterator]';\n    };\n\n\n  Iterator.KEYS = ITERATE_KEYS;\n  Iterator.VALUES = ITERATE_VALUES;\n  Iterator.ENTRIES = ITERATE_ENTRIES;\n\n  Iterator.prototype.inspect =\n  Iterator.prototype.toSource = function () { return this.toString(); }\n  Iterator.prototype[ITERATOR_SYMBOL] = function () {\n    return this;\n  };\n\n\n  function iteratorValue(type, k, v, iteratorResult) {\n    var value = type === 0 ? k : type === 1 ? v : [k, v];\n    iteratorResult ? (iteratorResult.value = value) : (iteratorResult = {\n      value: value, done: false\n    });\n    return iteratorResult;\n  }\n\n  function iteratorDone() {\n    return { value: undefined, done: true };\n  }\n\n  function hasIterator(maybeIterable) {\n    return !!getIteratorFn(maybeIterable);\n  }\n\n  function isIterator(maybeIterator) {\n    return maybeIterator && typeof maybeIterator.next === 'function';\n  }\n\n  function getIterator(iterable) {\n    var iteratorFn = getIteratorFn(iterable);\n    return iteratorFn && iteratorFn.call(iterable);\n  }\n\n  function getIteratorFn(iterable) {\n    var iteratorFn = iterable && (\n      (REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||\n      iterable[FAUX_ITERATOR_SYMBOL]\n    );\n    if (typeof iteratorFn === 'function') {\n      return iteratorFn;\n    }\n  }\n\n  function isArrayLike(value) {\n    return value && typeof value.length === 'number';\n  }\n\n  createClass(Seq, Iterable);\n    function Seq(value) {\n      return value === null || value === undefined ? emptySequence() :\n        isIterable(value) ? value.toSeq() : seqFromValue(value);\n    }\n\n    Seq.of = function(/*...values*/) {\n      return Seq(arguments);\n    };\n\n    Seq.prototype.toSeq = function() {\n      return this;\n    };\n\n    Seq.prototype.toString = function() {\n      return this.__toString('Seq {', '}');\n    };\n\n    Seq.prototype.cacheResult = function() {\n      if (!this._cache && this.__iterateUncached) {\n        this._cache = this.entrySeq().toArray();\n        this.size = this._cache.length;\n      }\n      return this;\n    };\n\n    // abstract __iterateUncached(fn, reverse)\n\n    Seq.prototype.__iterate = function(fn, reverse) {\n      return seqIterate(this, fn, reverse, true);\n    };\n\n    // abstract __iteratorUncached(type, reverse)\n\n    Seq.prototype.__iterator = function(type, reverse) {\n      return seqIterator(this, type, reverse, true);\n    };\n\n\n\n  createClass(KeyedSeq, Seq);\n    function KeyedSeq(value) {\n      return value === null || value === undefined ?\n        emptySequence().toKeyedSeq() :\n        isIterable(value) ?\n          (isKeyed(value) ? value.toSeq() : value.fromEntrySeq()) :\n          keyedSeqFromValue(value);\n    }\n\n    KeyedSeq.prototype.toKeyedSeq = function() {\n      return this;\n    };\n\n\n\n  createClass(IndexedSeq, Seq);\n    function IndexedSeq(value) {\n      return value === null || value === undefined ? emptySequence() :\n        !isIterable(value) ? indexedSeqFromValue(value) :\n        isKeyed(value) ? value.entrySeq() : value.toIndexedSeq();\n    }\n\n    IndexedSeq.of = function(/*...values*/) {\n      return IndexedSeq(arguments);\n    };\n\n    IndexedSeq.prototype.toIndexedSeq = function() {\n      return this;\n    };\n\n    IndexedSeq.prototype.toString = function() {\n      return this.__toString('Seq [', ']');\n    };\n\n    IndexedSeq.prototype.__iterate = function(fn, reverse) {\n      return seqIterate(this, fn, reverse, false);\n    };\n\n    IndexedSeq.prototype.__iterator = function(type, reverse) {\n      return seqIterator(this, type, reverse, false);\n    };\n\n\n\n  createClass(SetSeq, Seq);\n    function SetSeq(value) {\n      return (\n        value === null || value === undefined ? emptySequence() :\n        !isIterable(value) ? indexedSeqFromValue(value) :\n        isKeyed(value) ? value.entrySeq() : value\n      ).toSetSeq();\n    }\n\n    SetSeq.of = function(/*...values*/) {\n      return SetSeq(arguments);\n    };\n\n    SetSeq.prototype.toSetSeq = function() {\n      return this;\n    };\n\n\n\n  Seq.isSeq = isSeq;\n  Seq.Keyed = KeyedSeq;\n  Seq.Set = SetSeq;\n  Seq.Indexed = IndexedSeq;\n\n  var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';\n\n  Seq.prototype[IS_SEQ_SENTINEL] = true;\n\n\n\n  createClass(ArraySeq, IndexedSeq);\n    function ArraySeq(array) {\n      this._array = array;\n      this.size = array.length;\n    }\n\n    ArraySeq.prototype.get = function(index, notSetValue) {\n      return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue;\n    };\n\n    ArraySeq.prototype.__iterate = function(fn, reverse) {\n      var array = this._array;\n      var maxIndex = array.length - 1;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        if (fn(array[reverse ? maxIndex - ii : ii], ii, this) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    };\n\n    ArraySeq.prototype.__iterator = function(type, reverse) {\n      var array = this._array;\n      var maxIndex = array.length - 1;\n      var ii = 0;\n      return new Iterator(function() \n        {return ii > maxIndex ?\n          iteratorDone() :\n          iteratorValue(type, ii, array[reverse ? maxIndex - ii++ : ii++])}\n      );\n    };\n\n\n\n  createClass(ObjectSeq, KeyedSeq);\n    function ObjectSeq(object) {\n      var keys = Object.keys(object);\n      this._object = object;\n      this._keys = keys;\n      this.size = keys.length;\n    }\n\n    ObjectSeq.prototype.get = function(key, notSetValue) {\n      if (notSetValue !== undefined && !this.has(key)) {\n        return notSetValue;\n      }\n      return this._object[key];\n    };\n\n    ObjectSeq.prototype.has = function(key) {\n      return this._object.hasOwnProperty(key);\n    };\n\n    ObjectSeq.prototype.__iterate = function(fn, reverse) {\n      var object = this._object;\n      var keys = this._keys;\n      var maxIndex = keys.length - 1;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        var key = keys[reverse ? maxIndex - ii : ii];\n        if (fn(object[key], key, this) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    };\n\n    ObjectSeq.prototype.__iterator = function(type, reverse) {\n      var object = this._object;\n      var keys = this._keys;\n      var maxIndex = keys.length - 1;\n      var ii = 0;\n      return new Iterator(function()  {\n        var key = keys[reverse ? maxIndex - ii : ii];\n        return ii++ > maxIndex ?\n          iteratorDone() :\n          iteratorValue(type, key, object[key]);\n      });\n    };\n\n  ObjectSeq.prototype[IS_ORDERED_SENTINEL] = true;\n\n\n  createClass(IterableSeq, IndexedSeq);\n    function IterableSeq(iterable) {\n      this._iterable = iterable;\n      this.size = iterable.length || iterable.size;\n    }\n\n    IterableSeq.prototype.__iterateUncached = function(fn, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterable = this._iterable;\n      var iterator = getIterator(iterable);\n      var iterations = 0;\n      if (isIterator(iterator)) {\n        var step;\n        while (!(step = iterator.next()).done) {\n          if (fn(step.value, iterations++, this) === false) {\n            break;\n          }\n        }\n      }\n      return iterations;\n    };\n\n    IterableSeq.prototype.__iteratorUncached = function(type, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterable = this._iterable;\n      var iterator = getIterator(iterable);\n      if (!isIterator(iterator)) {\n        return new Iterator(iteratorDone);\n      }\n      var iterations = 0;\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step : iteratorValue(type, iterations++, step.value);\n      });\n    };\n\n\n\n  createClass(IteratorSeq, IndexedSeq);\n    function IteratorSeq(iterator) {\n      this._iterator = iterator;\n      this._iteratorCache = [];\n    }\n\n    IteratorSeq.prototype.__iterateUncached = function(fn, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterator = this._iterator;\n      var cache = this._iteratorCache;\n      var iterations = 0;\n      while (iterations < cache.length) {\n        if (fn(cache[iterations], iterations++, this) === false) {\n          return iterations;\n        }\n      }\n      var step;\n      while (!(step = iterator.next()).done) {\n        var val = step.value;\n        cache[iterations] = val;\n        if (fn(val, iterations++, this) === false) {\n          break;\n        }\n      }\n      return iterations;\n    };\n\n    IteratorSeq.prototype.__iteratorUncached = function(type, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = this._iterator;\n      var cache = this._iteratorCache;\n      var iterations = 0;\n      return new Iterator(function()  {\n        if (iterations >= cache.length) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          cache[iterations] = step.value;\n        }\n        return iteratorValue(type, iterations, cache[iterations++]);\n      });\n    };\n\n\n\n\n  // # pragma Helper functions\n\n  function isSeq(maybeSeq) {\n    return !!(maybeSeq && maybeSeq[IS_SEQ_SENTINEL]);\n  }\n\n  var EMPTY_SEQ;\n\n  function emptySequence() {\n    return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));\n  }\n\n  function keyedSeqFromValue(value) {\n    var seq =\n      Array.isArray(value) ? new ArraySeq(value).fromEntrySeq() :\n      isIterator(value) ? new IteratorSeq(value).fromEntrySeq() :\n      hasIterator(value) ? new IterableSeq(value).fromEntrySeq() :\n      typeof value === 'object' ? new ObjectSeq(value) :\n      undefined;\n    if (!seq) {\n      throw new TypeError(\n        'Expected Array or iterable object of [k, v] entries, '+\n        'or keyed object: ' + value\n      );\n    }\n    return seq;\n  }\n\n  function indexedSeqFromValue(value) {\n    var seq = maybeIndexedSeqFromValue(value);\n    if (!seq) {\n      throw new TypeError(\n        'Expected Array or iterable object of values: ' + value\n      );\n    }\n    return seq;\n  }\n\n  function seqFromValue(value) {\n    var seq = maybeIndexedSeqFromValue(value) ||\n      (typeof value === 'object' && new ObjectSeq(value));\n    if (!seq) {\n      throw new TypeError(\n        'Expected Array or iterable object of values, or keyed object: ' + value\n      );\n    }\n    return seq;\n  }\n\n  function maybeIndexedSeqFromValue(value) {\n    return (\n      isArrayLike(value) ? new ArraySeq(value) :\n      isIterator(value) ? new IteratorSeq(value) :\n      hasIterator(value) ? new IterableSeq(value) :\n      undefined\n    );\n  }\n\n  function seqIterate(seq, fn, reverse, useKeys) {\n    var cache = seq._cache;\n    if (cache) {\n      var maxIndex = cache.length - 1;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        var entry = cache[reverse ? maxIndex - ii : ii];\n        if (fn(entry[1], useKeys ? entry[0] : ii, seq) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    }\n    return seq.__iterateUncached(fn, reverse);\n  }\n\n  function seqIterator(seq, type, reverse, useKeys) {\n    var cache = seq._cache;\n    if (cache) {\n      var maxIndex = cache.length - 1;\n      var ii = 0;\n      return new Iterator(function()  {\n        var entry = cache[reverse ? maxIndex - ii : ii];\n        return ii++ > maxIndex ?\n          iteratorDone() :\n          iteratorValue(type, useKeys ? entry[0] : ii - 1, entry[1]);\n      });\n    }\n    return seq.__iteratorUncached(type, reverse);\n  }\n\n  function fromJS(json, converter) {\n    return converter ?\n      fromJSWith(converter, json, '', {'': json}) :\n      fromJSDefault(json);\n  }\n\n  function fromJSWith(converter, json, key, parentJSON) {\n    if (Array.isArray(json)) {\n      return converter.call(parentJSON, key, IndexedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));\n    }\n    if (isPlainObj(json)) {\n      return converter.call(parentJSON, key, KeyedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));\n    }\n    return json;\n  }\n\n  function fromJSDefault(json) {\n    if (Array.isArray(json)) {\n      return IndexedSeq(json).map(fromJSDefault).toList();\n    }\n    if (isPlainObj(json)) {\n      return KeyedSeq(json).map(fromJSDefault).toMap();\n    }\n    return json;\n  }\n\n  function isPlainObj(value) {\n    return value && (value.constructor === Object || value.constructor === undefined);\n  }\n\n  /**\n   * An extension of the \"same-value\" algorithm as [described for use by ES6 Map\n   * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)\n   *\n   * NaN is considered the same as NaN, however -0 and 0 are considered the same\n   * value, which is different from the algorithm described by\n   * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).\n   *\n   * This is extended further to allow Objects to describe the values they\n   * represent, by way of `valueOf` or `equals` (and `hashCode`).\n   *\n   * Note: because of this extension, the key equality of Immutable.Map and the\n   * value equality of Immutable.Set will differ from ES6 Map and Set.\n   *\n   * ### Defining custom values\n   *\n   * The easiest way to describe the value an object represents is by implementing\n   * `valueOf`. For example, `Date` represents a value by returning a unix\n   * timestamp for `valueOf`:\n   *\n   *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...\n   *     var date2 = new Date(1234567890000);\n   *     date1.valueOf(); // 1234567890000\n   *     assert( date1 !== date2 );\n   *     assert( Immutable.is( date1, date2 ) );\n   *\n   * Note: overriding `valueOf` may have other implications if you use this object\n   * where JavaScript expects a primitive, such as implicit string coercion.\n   *\n   * For more complex types, especially collections, implementing `valueOf` may\n   * not be performant. An alternative is to implement `equals` and `hashCode`.\n   *\n   * `equals` takes another object, presumably of similar type, and returns true\n   * if the it is equal. Equality is symmetrical, so the same result should be\n   * returned if this and the argument are flipped.\n   *\n   *     assert( a.equals(b) === b.equals(a) );\n   *\n   * `hashCode` returns a 32bit integer number representing the object which will\n   * be used to determine how to store the value object in a Map or Set. You must\n   * provide both or neither methods, one must not exist without the other.\n   *\n   * Also, an important relationship between these methods must be upheld: if two\n   * values are equal, they *must* return the same hashCode. If the values are not\n   * equal, they might have the same hashCode; this is called a hash collision,\n   * and while undesirable for performance reasons, it is acceptable.\n   *\n   *     if (a.equals(b)) {\n   *       assert( a.hashCode() === b.hashCode() );\n   *     }\n   *\n   * All Immutable collections implement `equals` and `hashCode`.\n   *\n   */\n  function is(valueA, valueB) {\n    if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n      return true;\n    }\n    if (!valueA || !valueB) {\n      return false;\n    }\n    if (typeof valueA.valueOf === 'function' &&\n        typeof valueB.valueOf === 'function') {\n      valueA = valueA.valueOf();\n      valueB = valueB.valueOf();\n      if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n        return true;\n      }\n      if (!valueA || !valueB) {\n        return false;\n      }\n    }\n    if (typeof valueA.equals === 'function' &&\n        typeof valueB.equals === 'function' &&\n        valueA.equals(valueB)) {\n      return true;\n    }\n    return false;\n  }\n\n  function deepEqual(a, b) {\n    if (a === b) {\n      return true;\n    }\n\n    if (\n      !isIterable(b) ||\n      a.size !== undefined && b.size !== undefined && a.size !== b.size ||\n      a.__hash !== undefined && b.__hash !== undefined && a.__hash !== b.__hash ||\n      isKeyed(a) !== isKeyed(b) ||\n      isIndexed(a) !== isIndexed(b) ||\n      isOrdered(a) !== isOrdered(b)\n    ) {\n      return false;\n    }\n\n    if (a.size === 0 && b.size === 0) {\n      return true;\n    }\n\n    var notAssociative = !isAssociative(a);\n\n    if (isOrdered(a)) {\n      var entries = a.entries();\n      return b.every(function(v, k)  {\n        var entry = entries.next().value;\n        return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));\n      }) && entries.next().done;\n    }\n\n    var flipped = false;\n\n    if (a.size === undefined) {\n      if (b.size === undefined) {\n        if (typeof a.cacheResult === 'function') {\n          a.cacheResult();\n        }\n      } else {\n        flipped = true;\n        var _ = a;\n        a = b;\n        b = _;\n      }\n    }\n\n    var allEqual = true;\n    var bSize = b.__iterate(function(v, k)  {\n      if (notAssociative ? !a.has(v) :\n          flipped ? !is(v, a.get(k, NOT_SET)) : !is(a.get(k, NOT_SET), v)) {\n        allEqual = false;\n        return false;\n      }\n    });\n\n    return allEqual && a.size === bSize;\n  }\n\n  createClass(Repeat, IndexedSeq);\n\n    function Repeat(value, times) {\n      if (!(this instanceof Repeat)) {\n        return new Repeat(value, times);\n      }\n      this._value = value;\n      this.size = times === undefined ? Infinity : Math.max(0, times);\n      if (this.size === 0) {\n        if (EMPTY_REPEAT) {\n          return EMPTY_REPEAT;\n        }\n        EMPTY_REPEAT = this;\n      }\n    }\n\n    Repeat.prototype.toString = function() {\n      if (this.size === 0) {\n        return 'Repeat []';\n      }\n      return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]';\n    };\n\n    Repeat.prototype.get = function(index, notSetValue) {\n      return this.has(index) ? this._value : notSetValue;\n    };\n\n    Repeat.prototype.includes = function(searchValue) {\n      return is(this._value, searchValue);\n    };\n\n    Repeat.prototype.slice = function(begin, end) {\n      var size = this.size;\n      return wholeSlice(begin, end, size) ? this :\n        new Repeat(this._value, resolveEnd(end, size) - resolveBegin(begin, size));\n    };\n\n    Repeat.prototype.reverse = function() {\n      return this;\n    };\n\n    Repeat.prototype.indexOf = function(searchValue) {\n      if (is(this._value, searchValue)) {\n        return 0;\n      }\n      return -1;\n    };\n\n    Repeat.prototype.lastIndexOf = function(searchValue) {\n      if (is(this._value, searchValue)) {\n        return this.size;\n      }\n      return -1;\n    };\n\n    Repeat.prototype.__iterate = function(fn, reverse) {\n      for (var ii = 0; ii < this.size; ii++) {\n        if (fn(this._value, ii, this) === false) {\n          return ii + 1;\n        }\n      }\n      return ii;\n    };\n\n    Repeat.prototype.__iterator = function(type, reverse) {var this$0 = this;\n      var ii = 0;\n      return new Iterator(function() \n        {return ii < this$0.size ? iteratorValue(type, ii++, this$0._value) : iteratorDone()}\n      );\n    };\n\n    Repeat.prototype.equals = function(other) {\n      return other instanceof Repeat ?\n        is(this._value, other._value) :\n        deepEqual(other);\n    };\n\n\n  var EMPTY_REPEAT;\n\n  function invariant(condition, error) {\n    if (!condition) throw new Error(error);\n  }\n\n  createClass(Range, IndexedSeq);\n\n    function Range(start, end, step) {\n      if (!(this instanceof Range)) {\n        return new Range(start, end, step);\n      }\n      invariant(step !== 0, 'Cannot step a Range by 0');\n      start = start || 0;\n      if (end === undefined) {\n        end = Infinity;\n      }\n      step = step === undefined ? 1 : Math.abs(step);\n      if (end < start) {\n        step = -step;\n      }\n      this._start = start;\n      this._end = end;\n      this._step = step;\n      this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);\n      if (this.size === 0) {\n        if (EMPTY_RANGE) {\n          return EMPTY_RANGE;\n        }\n        EMPTY_RANGE = this;\n      }\n    }\n\n    Range.prototype.toString = function() {\n      if (this.size === 0) {\n        return 'Range []';\n      }\n      return 'Range [ ' +\n        this._start + '...' + this._end +\n        (this._step !== 1 ? ' by ' + this._step : '') +\n      ' ]';\n    };\n\n    Range.prototype.get = function(index, notSetValue) {\n      return this.has(index) ?\n        this._start + wrapIndex(this, index) * this._step :\n        notSetValue;\n    };\n\n    Range.prototype.includes = function(searchValue) {\n      var possibleIndex = (searchValue - this._start) / this._step;\n      return possibleIndex >= 0 &&\n        possibleIndex < this.size &&\n        possibleIndex === Math.floor(possibleIndex);\n    };\n\n    Range.prototype.slice = function(begin, end) {\n      if (wholeSlice(begin, end, this.size)) {\n        return this;\n      }\n      begin = resolveBegin(begin, this.size);\n      end = resolveEnd(end, this.size);\n      if (end <= begin) {\n        return new Range(0, 0);\n      }\n      return new Range(this.get(begin, this._end), this.get(end, this._end), this._step);\n    };\n\n    Range.prototype.indexOf = function(searchValue) {\n      var offsetValue = searchValue - this._start;\n      if (offsetValue % this._step === 0) {\n        var index = offsetValue / this._step;\n        if (index >= 0 && index < this.size) {\n          return index\n        }\n      }\n      return -1;\n    };\n\n    Range.prototype.lastIndexOf = function(searchValue) {\n      return this.indexOf(searchValue);\n    };\n\n    Range.prototype.__iterate = function(fn, reverse) {\n      var maxIndex = this.size - 1;\n      var step = this._step;\n      var value = reverse ? this._start + maxIndex * step : this._start;\n      for (var ii = 0; ii <= maxIndex; ii++) {\n        if (fn(value, ii, this) === false) {\n          return ii + 1;\n        }\n        value += reverse ? -step : step;\n      }\n      return ii;\n    };\n\n    Range.prototype.__iterator = function(type, reverse) {\n      var maxIndex = this.size - 1;\n      var step = this._step;\n      var value = reverse ? this._start + maxIndex * step : this._start;\n      var ii = 0;\n      return new Iterator(function()  {\n        var v = value;\n        value += reverse ? -step : step;\n        return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii++, v);\n      });\n    };\n\n    Range.prototype.equals = function(other) {\n      return other instanceof Range ?\n        this._start === other._start &&\n        this._end === other._end &&\n        this._step === other._step :\n        deepEqual(this, other);\n    };\n\n\n  var EMPTY_RANGE;\n\n  createClass(Collection, Iterable);\n    function Collection() {\n      throw TypeError('Abstract');\n    }\n\n\n  createClass(KeyedCollection, Collection);function KeyedCollection() {}\n\n  createClass(IndexedCollection, Collection);function IndexedCollection() {}\n\n  createClass(SetCollection, Collection);function SetCollection() {}\n\n\n  Collection.Keyed = KeyedCollection;\n  Collection.Indexed = IndexedCollection;\n  Collection.Set = SetCollection;\n\n  var imul =\n    typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2 ?\n    Math.imul :\n    function imul(a, b) {\n      a = a | 0; // int\n      b = b | 0; // int\n      var c = a & 0xffff;\n      var d = b & 0xffff;\n      // Shift by 0 fixes the sign on the high part.\n      return (c * d) + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0) | 0; // int\n    };\n\n  // v8 has an optimization for storing 31-bit signed numbers.\n  // Values which have either 00 or 11 as the high order bits qualify.\n  // This function drops the highest order bit in a signed number, maintaining\n  // the sign bit.\n  function smi(i32) {\n    return ((i32 >>> 1) & 0x40000000) | (i32 & 0xBFFFFFFF);\n  }\n\n  function hash(o) {\n    if (o === false || o === null || o === undefined) {\n      return 0;\n    }\n    if (typeof o.valueOf === 'function') {\n      o = o.valueOf();\n      if (o === false || o === null || o === undefined) {\n        return 0;\n      }\n    }\n    if (o === true) {\n      return 1;\n    }\n    var type = typeof o;\n    if (type === 'number') {\n      if (o !== o || o === Infinity) {\n        return 0;\n      }\n      var h = o | 0;\n      if (h !== o) {\n        h ^= o * 0xFFFFFFFF;\n      }\n      while (o > 0xFFFFFFFF) {\n        o /= 0xFFFFFFFF;\n        h ^= o;\n      }\n      return smi(h);\n    }\n    if (type === 'string') {\n      return o.length > STRING_HASH_CACHE_MIN_STRLEN ? cachedHashString(o) : hashString(o);\n    }\n    if (typeof o.hashCode === 'function') {\n      return o.hashCode();\n    }\n    if (type === 'object') {\n      return hashJSObj(o);\n    }\n    if (typeof o.toString === 'function') {\n      return hashString(o.toString());\n    }\n    throw new Error('Value type ' + type + ' cannot be hashed.');\n  }\n\n  function cachedHashString(string) {\n    var hash = stringHashCache[string];\n    if (hash === undefined) {\n      hash = hashString(string);\n      if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {\n        STRING_HASH_CACHE_SIZE = 0;\n        stringHashCache = {};\n      }\n      STRING_HASH_CACHE_SIZE++;\n      stringHashCache[string] = hash;\n    }\n    return hash;\n  }\n\n  // http://jsperf.com/hashing-strings\n  function hashString(string) {\n    // This is the hash from JVM\n    // The hash code for a string is computed as\n    // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],\n    // where s[i] is the ith character of the string and n is the length of\n    // the string. We \"mod\" the result to make it between 0 (inclusive) and 2^31\n    // (exclusive) by dropping high bits.\n    var hash = 0;\n    for (var ii = 0; ii < string.length; ii++) {\n      hash = 31 * hash + string.charCodeAt(ii) | 0;\n    }\n    return smi(hash);\n  }\n\n  function hashJSObj(obj) {\n    var hash;\n    if (usingWeakMap) {\n      hash = weakMap.get(obj);\n      if (hash !== undefined) {\n        return hash;\n      }\n    }\n\n    hash = obj[UID_HASH_KEY];\n    if (hash !== undefined) {\n      return hash;\n    }\n\n    if (!canDefineProperty) {\n      hash = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];\n      if (hash !== undefined) {\n        return hash;\n      }\n\n      hash = getIENodeHash(obj);\n      if (hash !== undefined) {\n        return hash;\n      }\n    }\n\n    hash = ++objHashUID;\n    if (objHashUID & 0x40000000) {\n      objHashUID = 0;\n    }\n\n    if (usingWeakMap) {\n      weakMap.set(obj, hash);\n    } else if (isExtensible !== undefined && isExtensible(obj) === false) {\n      throw new Error('Non-extensible objects are not allowed as keys.');\n    } else if (canDefineProperty) {\n      Object.defineProperty(obj, UID_HASH_KEY, {\n        'enumerable': false,\n        'configurable': false,\n        'writable': false,\n        'value': hash\n      });\n    } else if (obj.propertyIsEnumerable !== undefined &&\n               obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable) {\n      // Since we can't define a non-enumerable property on the object\n      // we'll hijack one of the less-used non-enumerable properties to\n      // save our hash on it. Since this is a function it will not show up in\n      // `JSON.stringify` which is what we want.\n      obj.propertyIsEnumerable = function() {\n        return this.constructor.prototype.propertyIsEnumerable.apply(this, arguments);\n      };\n      obj.propertyIsEnumerable[UID_HASH_KEY] = hash;\n    } else if (obj.nodeType !== undefined) {\n      // At this point we couldn't get the IE `uniqueID` to use as a hash\n      // and we couldn't use a non-enumerable property to exploit the\n      // dontEnum bug so we simply add the `UID_HASH_KEY` on the node\n      // itself.\n      obj[UID_HASH_KEY] = hash;\n    } else {\n      throw new Error('Unable to set a non-enumerable property on object.');\n    }\n\n    return hash;\n  }\n\n  // Get references to ES5 object methods.\n  var isExtensible = Object.isExtensible;\n\n  // True if Object.defineProperty works as expected. IE8 fails this test.\n  var canDefineProperty = (function() {\n    try {\n      Object.defineProperty({}, '@', {});\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }());\n\n  // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it\n  // and avoid memory leaks from the IE cloneNode bug.\n  function getIENodeHash(node) {\n    if (node && node.nodeType > 0) {\n      switch (node.nodeType) {\n        case 1: // Element\n          return node.uniqueID;\n        case 9: // Document\n          return node.documentElement && node.documentElement.uniqueID;\n      }\n    }\n  }\n\n  // If possible, use a WeakMap.\n  var usingWeakMap = typeof WeakMap === 'function';\n  var weakMap;\n  if (usingWeakMap) {\n    weakMap = new WeakMap();\n  }\n\n  var objHashUID = 0;\n\n  var UID_HASH_KEY = '__immutablehash__';\n  if (typeof Symbol === 'function') {\n    UID_HASH_KEY = Symbol(UID_HASH_KEY);\n  }\n\n  var STRING_HASH_CACHE_MIN_STRLEN = 16;\n  var STRING_HASH_CACHE_MAX_SIZE = 255;\n  var STRING_HASH_CACHE_SIZE = 0;\n  var stringHashCache = {};\n\n  function assertNotInfinite(size) {\n    invariant(\n      size !== Infinity,\n      'Cannot perform this action with an infinite size.'\n    );\n  }\n\n  createClass(Map, KeyedCollection);\n\n    // @pragma Construction\n\n    function Map(value) {\n      return value === null || value === undefined ? emptyMap() :\n        isMap(value) && !isOrdered(value) ? value :\n        emptyMap().withMutations(function(map ) {\n          var iter = KeyedIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v, k)  {return map.set(k, v)});\n        });\n    }\n\n    Map.of = function() {var keyValues = SLICE$0.call(arguments, 0);\n      return emptyMap().withMutations(function(map ) {\n        for (var i = 0; i < keyValues.length; i += 2) {\n          if (i + 1 >= keyValues.length) {\n            throw new Error('Missing value for key: ' + keyValues[i]);\n          }\n          map.set(keyValues[i], keyValues[i + 1]);\n        }\n      });\n    };\n\n    Map.prototype.toString = function() {\n      return this.__toString('Map {', '}');\n    };\n\n    // @pragma Access\n\n    Map.prototype.get = function(k, notSetValue) {\n      return this._root ?\n        this._root.get(0, undefined, k, notSetValue) :\n        notSetValue;\n    };\n\n    // @pragma Modification\n\n    Map.prototype.set = function(k, v) {\n      return updateMap(this, k, v);\n    };\n\n    Map.prototype.setIn = function(keyPath, v) {\n      return this.updateIn(keyPath, NOT_SET, function()  {return v});\n    };\n\n    Map.prototype.remove = function(k) {\n      return updateMap(this, k, NOT_SET);\n    };\n\n    Map.prototype.deleteIn = function(keyPath) {\n      return this.updateIn(keyPath, function()  {return NOT_SET});\n    };\n\n    Map.prototype.update = function(k, notSetValue, updater) {\n      return arguments.length === 1 ?\n        k(this) :\n        this.updateIn([k], notSetValue, updater);\n    };\n\n    Map.prototype.updateIn = function(keyPath, notSetValue, updater) {\n      if (!updater) {\n        updater = notSetValue;\n        notSetValue = undefined;\n      }\n      var updatedValue = updateInDeepMap(\n        this,\n        forceIterator(keyPath),\n        notSetValue,\n        updater\n      );\n      return updatedValue === NOT_SET ? undefined : updatedValue;\n    };\n\n    Map.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._root = null;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyMap();\n    };\n\n    // @pragma Composition\n\n    Map.prototype.merge = function(/*...iters*/) {\n      return mergeIntoMapWith(this, undefined, arguments);\n    };\n\n    Map.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoMapWith(this, merger, iters);\n    };\n\n    Map.prototype.mergeIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);\n      return this.updateIn(\n        keyPath,\n        emptyMap(),\n        function(m ) {return typeof m.merge === 'function' ?\n          m.merge.apply(m, iters) :\n          iters[iters.length - 1]}\n      );\n    };\n\n    Map.prototype.mergeDeep = function(/*...iters*/) {\n      return mergeIntoMapWith(this, deepMerger, arguments);\n    };\n\n    Map.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoMapWith(this, deepMergerWith(merger), iters);\n    };\n\n    Map.prototype.mergeDeepIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);\n      return this.updateIn(\n        keyPath,\n        emptyMap(),\n        function(m ) {return typeof m.mergeDeep === 'function' ?\n          m.mergeDeep.apply(m, iters) :\n          iters[iters.length - 1]}\n      );\n    };\n\n    Map.prototype.sort = function(comparator) {\n      // Late binding\n      return OrderedMap(sortFactory(this, comparator));\n    };\n\n    Map.prototype.sortBy = function(mapper, comparator) {\n      // Late binding\n      return OrderedMap(sortFactory(this, comparator, mapper));\n    };\n\n    // @pragma Mutability\n\n    Map.prototype.withMutations = function(fn) {\n      var mutable = this.asMutable();\n      fn(mutable);\n      return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;\n    };\n\n    Map.prototype.asMutable = function() {\n      return this.__ownerID ? this : this.__ensureOwner(new OwnerID());\n    };\n\n    Map.prototype.asImmutable = function() {\n      return this.__ensureOwner();\n    };\n\n    Map.prototype.wasAltered = function() {\n      return this.__altered;\n    };\n\n    Map.prototype.__iterator = function(type, reverse) {\n      return new MapIterator(this, type, reverse);\n    };\n\n    Map.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      this._root && this._root.iterate(function(entry ) {\n        iterations++;\n        return fn(entry[1], entry[0], this$0);\n      }, reverse);\n      return iterations;\n    };\n\n    Map.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this.__altered = false;\n        return this;\n      }\n      return makeMap(this.size, this._root, ownerID, this.__hash);\n    };\n\n\n  function isMap(maybeMap) {\n    return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]);\n  }\n\n  Map.isMap = isMap;\n\n  var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';\n\n  var MapPrototype = Map.prototype;\n  MapPrototype[IS_MAP_SENTINEL] = true;\n  MapPrototype[DELETE] = MapPrototype.remove;\n  MapPrototype.removeIn = MapPrototype.deleteIn;\n\n\n  // #pragma Trie Nodes\n\n\n\n    function ArrayMapNode(ownerID, entries) {\n      this.ownerID = ownerID;\n      this.entries = entries;\n    }\n\n    ArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      var entries = this.entries;\n      for (var ii = 0, len = entries.length; ii < len; ii++) {\n        if (is(key, entries[ii][0])) {\n          return entries[ii][1];\n        }\n      }\n      return notSetValue;\n    };\n\n    ArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      var removed = value === NOT_SET;\n\n      var entries = this.entries;\n      var idx = 0;\n      for (var len = entries.length; idx < len; idx++) {\n        if (is(key, entries[idx][0])) {\n          break;\n        }\n      }\n      var exists = idx < len;\n\n      if (exists ? entries[idx][1] === value : removed) {\n        return this;\n      }\n\n      SetRef(didAlter);\n      (removed || !exists) && SetRef(didChangeSize);\n\n      if (removed && entries.length === 1) {\n        return; // undefined\n      }\n\n      if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {\n        return createNodes(ownerID, entries, key, value);\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newEntries = isEditable ? entries : arrCopy(entries);\n\n      if (exists) {\n        if (removed) {\n          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());\n        } else {\n          newEntries[idx] = [key, value];\n        }\n      } else {\n        newEntries.push([key, value]);\n      }\n\n      if (isEditable) {\n        this.entries = newEntries;\n        return this;\n      }\n\n      return new ArrayMapNode(ownerID, newEntries);\n    };\n\n\n\n\n    function BitmapIndexedNode(ownerID, bitmap, nodes) {\n      this.ownerID = ownerID;\n      this.bitmap = bitmap;\n      this.nodes = nodes;\n    }\n\n    BitmapIndexedNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var bit = (1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK));\n      var bitmap = this.bitmap;\n      return (bitmap & bit) === 0 ? notSetValue :\n        this.nodes[popCount(bitmap & (bit - 1))].get(shift + SHIFT, keyHash, key, notSetValue);\n    };\n\n    BitmapIndexedNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n      var bit = 1 << keyHashFrag;\n      var bitmap = this.bitmap;\n      var exists = (bitmap & bit) !== 0;\n\n      if (!exists && value === NOT_SET) {\n        return this;\n      }\n\n      var idx = popCount(bitmap & (bit - 1));\n      var nodes = this.nodes;\n      var node = exists ? nodes[idx] : undefined;\n      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);\n\n      if (newNode === node) {\n        return this;\n      }\n\n      if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {\n        return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);\n      }\n\n      if (exists && !newNode && nodes.length === 2 && isLeafNode(nodes[idx ^ 1])) {\n        return nodes[idx ^ 1];\n      }\n\n      if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {\n        return newNode;\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newBitmap = exists ? newNode ? bitmap : bitmap ^ bit : bitmap | bit;\n      var newNodes = exists ? newNode ?\n        setIn(nodes, idx, newNode, isEditable) :\n        spliceOut(nodes, idx, isEditable) :\n        spliceIn(nodes, idx, newNode, isEditable);\n\n      if (isEditable) {\n        this.bitmap = newBitmap;\n        this.nodes = newNodes;\n        return this;\n      }\n\n      return new BitmapIndexedNode(ownerID, newBitmap, newNodes);\n    };\n\n\n\n\n    function HashArrayMapNode(ownerID, count, nodes) {\n      this.ownerID = ownerID;\n      this.count = count;\n      this.nodes = nodes;\n    }\n\n    HashArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n      var node = this.nodes[idx];\n      return node ? node.get(shift + SHIFT, keyHash, key, notSetValue) : notSetValue;\n    };\n\n    HashArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n      var removed = value === NOT_SET;\n      var nodes = this.nodes;\n      var node = nodes[idx];\n\n      if (removed && !node) {\n        return this;\n      }\n\n      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);\n      if (newNode === node) {\n        return this;\n      }\n\n      var newCount = this.count;\n      if (!node) {\n        newCount++;\n      } else if (!newNode) {\n        newCount--;\n        if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {\n          return packNodes(ownerID, nodes, newCount, idx);\n        }\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newNodes = setIn(nodes, idx, newNode, isEditable);\n\n      if (isEditable) {\n        this.count = newCount;\n        this.nodes = newNodes;\n        return this;\n      }\n\n      return new HashArrayMapNode(ownerID, newCount, newNodes);\n    };\n\n\n\n\n    function HashCollisionNode(ownerID, keyHash, entries) {\n      this.ownerID = ownerID;\n      this.keyHash = keyHash;\n      this.entries = entries;\n    }\n\n    HashCollisionNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      var entries = this.entries;\n      for (var ii = 0, len = entries.length; ii < len; ii++) {\n        if (is(key, entries[ii][0])) {\n          return entries[ii][1];\n        }\n      }\n      return notSetValue;\n    };\n\n    HashCollisionNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      if (keyHash === undefined) {\n        keyHash = hash(key);\n      }\n\n      var removed = value === NOT_SET;\n\n      if (keyHash !== this.keyHash) {\n        if (removed) {\n          return this;\n        }\n        SetRef(didAlter);\n        SetRef(didChangeSize);\n        return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);\n      }\n\n      var entries = this.entries;\n      var idx = 0;\n      for (var len = entries.length; idx < len; idx++) {\n        if (is(key, entries[idx][0])) {\n          break;\n        }\n      }\n      var exists = idx < len;\n\n      if (exists ? entries[idx][1] === value : removed) {\n        return this;\n      }\n\n      SetRef(didAlter);\n      (removed || !exists) && SetRef(didChangeSize);\n\n      if (removed && len === 2) {\n        return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);\n      }\n\n      var isEditable = ownerID && ownerID === this.ownerID;\n      var newEntries = isEditable ? entries : arrCopy(entries);\n\n      if (exists) {\n        if (removed) {\n          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());\n        } else {\n          newEntries[idx] = [key, value];\n        }\n      } else {\n        newEntries.push([key, value]);\n      }\n\n      if (isEditable) {\n        this.entries = newEntries;\n        return this;\n      }\n\n      return new HashCollisionNode(ownerID, this.keyHash, newEntries);\n    };\n\n\n\n\n    function ValueNode(ownerID, keyHash, entry) {\n      this.ownerID = ownerID;\n      this.keyHash = keyHash;\n      this.entry = entry;\n    }\n\n    ValueNode.prototype.get = function(shift, keyHash, key, notSetValue) {\n      return is(key, this.entry[0]) ? this.entry[1] : notSetValue;\n    };\n\n    ValueNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n      var removed = value === NOT_SET;\n      var keyMatch = is(key, this.entry[0]);\n      if (keyMatch ? value === this.entry[1] : removed) {\n        return this;\n      }\n\n      SetRef(didAlter);\n\n      if (removed) {\n        SetRef(didChangeSize);\n        return; // undefined\n      }\n\n      if (keyMatch) {\n        if (ownerID && ownerID === this.ownerID) {\n          this.entry[1] = value;\n          return this;\n        }\n        return new ValueNode(ownerID, this.keyHash, [key, value]);\n      }\n\n      SetRef(didChangeSize);\n      return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);\n    };\n\n\n\n  // #pragma Iterators\n\n  ArrayMapNode.prototype.iterate =\n  HashCollisionNode.prototype.iterate = function (fn, reverse) {\n    var entries = this.entries;\n    for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {\n      if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {\n        return false;\n      }\n    }\n  }\n\n  BitmapIndexedNode.prototype.iterate =\n  HashArrayMapNode.prototype.iterate = function (fn, reverse) {\n    var nodes = this.nodes;\n    for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {\n      var node = nodes[reverse ? maxIndex - ii : ii];\n      if (node && node.iterate(fn, reverse) === false) {\n        return false;\n      }\n    }\n  }\n\n  ValueNode.prototype.iterate = function (fn, reverse) {\n    return fn(this.entry);\n  }\n\n  createClass(MapIterator, Iterator);\n\n    function MapIterator(map, type, reverse) {\n      this._type = type;\n      this._reverse = reverse;\n      this._stack = map._root && mapIteratorFrame(map._root);\n    }\n\n    MapIterator.prototype.next = function() {\n      var type = this._type;\n      var stack = this._stack;\n      while (stack) {\n        var node = stack.node;\n        var index = stack.index++;\n        var maxIndex;\n        if (node.entry) {\n          if (index === 0) {\n            return mapIteratorValue(type, node.entry);\n          }\n        } else if (node.entries) {\n          maxIndex = node.entries.length - 1;\n          if (index <= maxIndex) {\n            return mapIteratorValue(type, node.entries[this._reverse ? maxIndex - index : index]);\n          }\n        } else {\n          maxIndex = node.nodes.length - 1;\n          if (index <= maxIndex) {\n            var subNode = node.nodes[this._reverse ? maxIndex - index : index];\n            if (subNode) {\n              if (subNode.entry) {\n                return mapIteratorValue(type, subNode.entry);\n              }\n              stack = this._stack = mapIteratorFrame(subNode, stack);\n            }\n            continue;\n          }\n        }\n        stack = this._stack = this._stack.__prev;\n      }\n      return iteratorDone();\n    };\n\n\n  function mapIteratorValue(type, entry) {\n    return iteratorValue(type, entry[0], entry[1]);\n  }\n\n  function mapIteratorFrame(node, prev) {\n    return {\n      node: node,\n      index: 0,\n      __prev: prev\n    };\n  }\n\n  function makeMap(size, root, ownerID, hash) {\n    var map = Object.create(MapPrototype);\n    map.size = size;\n    map._root = root;\n    map.__ownerID = ownerID;\n    map.__hash = hash;\n    map.__altered = false;\n    return map;\n  }\n\n  var EMPTY_MAP;\n  function emptyMap() {\n    return EMPTY_MAP || (EMPTY_MAP = makeMap(0));\n  }\n\n  function updateMap(map, k, v) {\n    var newRoot;\n    var newSize;\n    if (!map._root) {\n      if (v === NOT_SET) {\n        return map;\n      }\n      newSize = 1;\n      newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);\n    } else {\n      var didChangeSize = MakeRef(CHANGE_LENGTH);\n      var didAlter = MakeRef(DID_ALTER);\n      newRoot = updateNode(map._root, map.__ownerID, 0, undefined, k, v, didChangeSize, didAlter);\n      if (!didAlter.value) {\n        return map;\n      }\n      newSize = map.size + (didChangeSize.value ? v === NOT_SET ? -1 : 1 : 0);\n    }\n    if (map.__ownerID) {\n      map.size = newSize;\n      map._root = newRoot;\n      map.__hash = undefined;\n      map.__altered = true;\n      return map;\n    }\n    return newRoot ? makeMap(newSize, newRoot) : emptyMap();\n  }\n\n  function updateNode(node, ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n    if (!node) {\n      if (value === NOT_SET) {\n        return node;\n      }\n      SetRef(didAlter);\n      SetRef(didChangeSize);\n      return new ValueNode(ownerID, keyHash, [key, value]);\n    }\n    return node.update(ownerID, shift, keyHash, key, value, didChangeSize, didAlter);\n  }\n\n  function isLeafNode(node) {\n    return node.constructor === ValueNode || node.constructor === HashCollisionNode;\n  }\n\n  function mergeIntoNode(node, ownerID, shift, keyHash, entry) {\n    if (node.keyHash === keyHash) {\n      return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);\n    }\n\n    var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;\n    var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n\n    var newNode;\n    var nodes = idx1 === idx2 ?\n      [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)] :\n      ((newNode = new ValueNode(ownerID, keyHash, entry)), idx1 < idx2 ? [node, newNode] : [newNode, node]);\n\n    return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);\n  }\n\n  function createNodes(ownerID, entries, key, value) {\n    if (!ownerID) {\n      ownerID = new OwnerID();\n    }\n    var node = new ValueNode(ownerID, hash(key), [key, value]);\n    for (var ii = 0; ii < entries.length; ii++) {\n      var entry = entries[ii];\n      node = node.update(ownerID, 0, undefined, entry[0], entry[1]);\n    }\n    return node;\n  }\n\n  function packNodes(ownerID, nodes, count, excluding) {\n    var bitmap = 0;\n    var packedII = 0;\n    var packedNodes = new Array(count);\n    for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {\n      var node = nodes[ii];\n      if (node !== undefined && ii !== excluding) {\n        bitmap |= bit;\n        packedNodes[packedII++] = node;\n      }\n    }\n    return new BitmapIndexedNode(ownerID, bitmap, packedNodes);\n  }\n\n  function expandNodes(ownerID, nodes, bitmap, including, node) {\n    var count = 0;\n    var expandedNodes = new Array(SIZE);\n    for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {\n      expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;\n    }\n    expandedNodes[including] = node;\n    return new HashArrayMapNode(ownerID, count + 1, expandedNodes);\n  }\n\n  function mergeIntoMapWith(map, merger, iterables) {\n    var iters = [];\n    for (var ii = 0; ii < iterables.length; ii++) {\n      var value = iterables[ii];\n      var iter = KeyedIterable(value);\n      if (!isIterable(value)) {\n        iter = iter.map(function(v ) {return fromJS(v)});\n      }\n      iters.push(iter);\n    }\n    return mergeIntoCollectionWith(map, merger, iters);\n  }\n\n  function deepMerger(existing, value, key) {\n    return existing && existing.mergeDeep && isIterable(value) ?\n      existing.mergeDeep(value) :\n      is(existing, value) ? existing : value;\n  }\n\n  function deepMergerWith(merger) {\n    return function(existing, value, key)  {\n      if (existing && existing.mergeDeepWith && isIterable(value)) {\n        return existing.mergeDeepWith(merger, value);\n      }\n      var nextValue = merger(existing, value, key);\n      return is(existing, nextValue) ? existing : nextValue;\n    };\n  }\n\n  function mergeIntoCollectionWith(collection, merger, iters) {\n    iters = iters.filter(function(x ) {return x.size !== 0});\n    if (iters.length === 0) {\n      return collection;\n    }\n    if (collection.size === 0 && !collection.__ownerID && iters.length === 1) {\n      return collection.constructor(iters[0]);\n    }\n    return collection.withMutations(function(collection ) {\n      var mergeIntoMap = merger ?\n        function(value, key)  {\n          collection.update(key, NOT_SET, function(existing )\n            {return existing === NOT_SET ? value : merger(existing, value, key)}\n          );\n        } :\n        function(value, key)  {\n          collection.set(key, value);\n        }\n      for (var ii = 0; ii < iters.length; ii++) {\n        iters[ii].forEach(mergeIntoMap);\n      }\n    });\n  }\n\n  function updateInDeepMap(existing, keyPathIter, notSetValue, updater) {\n    var isNotSet = existing === NOT_SET;\n    var step = keyPathIter.next();\n    if (step.done) {\n      var existingValue = isNotSet ? notSetValue : existing;\n      var newValue = updater(existingValue);\n      return newValue === existingValue ? existing : newValue;\n    }\n    invariant(\n      isNotSet || (existing && existing.set),\n      'invalid keyPath'\n    );\n    var key = step.value;\n    var nextExisting = isNotSet ? NOT_SET : existing.get(key, NOT_SET);\n    var nextUpdated = updateInDeepMap(\n      nextExisting,\n      keyPathIter,\n      notSetValue,\n      updater\n    );\n    return nextUpdated === nextExisting ? existing :\n      nextUpdated === NOT_SET ? existing.remove(key) :\n      (isNotSet ? emptyMap() : existing).set(key, nextUpdated);\n  }\n\n  function popCount(x) {\n    x = x - ((x >> 1) & 0x55555555);\n    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);\n    x = (x + (x >> 4)) & 0x0f0f0f0f;\n    x = x + (x >> 8);\n    x = x + (x >> 16);\n    return x & 0x7f;\n  }\n\n  function setIn(array, idx, val, canEdit) {\n    var newArray = canEdit ? array : arrCopy(array);\n    newArray[idx] = val;\n    return newArray;\n  }\n\n  function spliceIn(array, idx, val, canEdit) {\n    var newLen = array.length + 1;\n    if (canEdit && idx + 1 === newLen) {\n      array[idx] = val;\n      return array;\n    }\n    var newArray = new Array(newLen);\n    var after = 0;\n    for (var ii = 0; ii < newLen; ii++) {\n      if (ii === idx) {\n        newArray[ii] = val;\n        after = -1;\n      } else {\n        newArray[ii] = array[ii + after];\n      }\n    }\n    return newArray;\n  }\n\n  function spliceOut(array, idx, canEdit) {\n    var newLen = array.length - 1;\n    if (canEdit && idx === newLen) {\n      array.pop();\n      return array;\n    }\n    var newArray = new Array(newLen);\n    var after = 0;\n    for (var ii = 0; ii < newLen; ii++) {\n      if (ii === idx) {\n        after = 1;\n      }\n      newArray[ii] = array[ii + after];\n    }\n    return newArray;\n  }\n\n  var MAX_ARRAY_MAP_SIZE = SIZE / 4;\n  var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;\n  var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;\n\n  createClass(List, IndexedCollection);\n\n    // @pragma Construction\n\n    function List(value) {\n      var empty = emptyList();\n      if (value === null || value === undefined) {\n        return empty;\n      }\n      if (isList(value)) {\n        return value;\n      }\n      var iter = IndexedIterable(value);\n      var size = iter.size;\n      if (size === 0) {\n        return empty;\n      }\n      assertNotInfinite(size);\n      if (size > 0 && size < SIZE) {\n        return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));\n      }\n      return empty.withMutations(function(list ) {\n        list.setSize(size);\n        iter.forEach(function(v, i)  {return list.set(i, v)});\n      });\n    }\n\n    List.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    List.prototype.toString = function() {\n      return this.__toString('List [', ']');\n    };\n\n    // @pragma Access\n\n    List.prototype.get = function(index, notSetValue) {\n      index = wrapIndex(this, index);\n      if (index >= 0 && index < this.size) {\n        index += this._origin;\n        var node = listNodeFor(this, index);\n        return node && node.array[index & MASK];\n      }\n      return notSetValue;\n    };\n\n    // @pragma Modification\n\n    List.prototype.set = function(index, value) {\n      return updateList(this, index, value);\n    };\n\n    List.prototype.remove = function(index) {\n      return !this.has(index) ? this :\n        index === 0 ? this.shift() :\n        index === this.size - 1 ? this.pop() :\n        this.splice(index, 1);\n    };\n\n    List.prototype.insert = function(index, value) {\n      return this.splice(index, 0, value);\n    };\n\n    List.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = this._origin = this._capacity = 0;\n        this._level = SHIFT;\n        this._root = this._tail = null;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyList();\n    };\n\n    List.prototype.push = function(/*...values*/) {\n      var values = arguments;\n      var oldSize = this.size;\n      return this.withMutations(function(list ) {\n        setListBounds(list, 0, oldSize + values.length);\n        for (var ii = 0; ii < values.length; ii++) {\n          list.set(oldSize + ii, values[ii]);\n        }\n      });\n    };\n\n    List.prototype.pop = function() {\n      return setListBounds(this, 0, -1);\n    };\n\n    List.prototype.unshift = function(/*...values*/) {\n      var values = arguments;\n      return this.withMutations(function(list ) {\n        setListBounds(list, -values.length);\n        for (var ii = 0; ii < values.length; ii++) {\n          list.set(ii, values[ii]);\n        }\n      });\n    };\n\n    List.prototype.shift = function() {\n      return setListBounds(this, 1);\n    };\n\n    // @pragma Composition\n\n    List.prototype.merge = function(/*...iters*/) {\n      return mergeIntoListWith(this, undefined, arguments);\n    };\n\n    List.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoListWith(this, merger, iters);\n    };\n\n    List.prototype.mergeDeep = function(/*...iters*/) {\n      return mergeIntoListWith(this, deepMerger, arguments);\n    };\n\n    List.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return mergeIntoListWith(this, deepMergerWith(merger), iters);\n    };\n\n    List.prototype.setSize = function(size) {\n      return setListBounds(this, 0, size);\n    };\n\n    // @pragma Iteration\n\n    List.prototype.slice = function(begin, end) {\n      var size = this.size;\n      if (wholeSlice(begin, end, size)) {\n        return this;\n      }\n      return setListBounds(\n        this,\n        resolveBegin(begin, size),\n        resolveEnd(end, size)\n      );\n    };\n\n    List.prototype.__iterator = function(type, reverse) {\n      var index = 0;\n      var values = iterateList(this, reverse);\n      return new Iterator(function()  {\n        var value = values();\n        return value === DONE ?\n          iteratorDone() :\n          iteratorValue(type, index++, value);\n      });\n    };\n\n    List.prototype.__iterate = function(fn, reverse) {\n      var index = 0;\n      var values = iterateList(this, reverse);\n      var value;\n      while ((value = values()) !== DONE) {\n        if (fn(value, index++, this) === false) {\n          break;\n        }\n      }\n      return index;\n    };\n\n    List.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        return this;\n      }\n      return makeList(this._origin, this._capacity, this._level, this._root, this._tail, ownerID, this.__hash);\n    };\n\n\n  function isList(maybeList) {\n    return !!(maybeList && maybeList[IS_LIST_SENTINEL]);\n  }\n\n  List.isList = isList;\n\n  var IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';\n\n  var ListPrototype = List.prototype;\n  ListPrototype[IS_LIST_SENTINEL] = true;\n  ListPrototype[DELETE] = ListPrototype.remove;\n  ListPrototype.setIn = MapPrototype.setIn;\n  ListPrototype.deleteIn =\n  ListPrototype.removeIn = MapPrototype.removeIn;\n  ListPrototype.update = MapPrototype.update;\n  ListPrototype.updateIn = MapPrototype.updateIn;\n  ListPrototype.mergeIn = MapPrototype.mergeIn;\n  ListPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;\n  ListPrototype.withMutations = MapPrototype.withMutations;\n  ListPrototype.asMutable = MapPrototype.asMutable;\n  ListPrototype.asImmutable = MapPrototype.asImmutable;\n  ListPrototype.wasAltered = MapPrototype.wasAltered;\n\n\n\n    function VNode(array, ownerID) {\n      this.array = array;\n      this.ownerID = ownerID;\n    }\n\n    // TODO: seems like these methods are very similar\n\n    VNode.prototype.removeBefore = function(ownerID, level, index) {\n      if (index === level ? 1 << level : 0 || this.array.length === 0) {\n        return this;\n      }\n      var originIndex = (index >>> level) & MASK;\n      if (originIndex >= this.array.length) {\n        return new VNode([], ownerID);\n      }\n      var removingFirst = originIndex === 0;\n      var newChild;\n      if (level > 0) {\n        var oldChild = this.array[originIndex];\n        newChild = oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);\n        if (newChild === oldChild && removingFirst) {\n          return this;\n        }\n      }\n      if (removingFirst && !newChild) {\n        return this;\n      }\n      var editable = editableVNode(this, ownerID);\n      if (!removingFirst) {\n        for (var ii = 0; ii < originIndex; ii++) {\n          editable.array[ii] = undefined;\n        }\n      }\n      if (newChild) {\n        editable.array[originIndex] = newChild;\n      }\n      return editable;\n    };\n\n    VNode.prototype.removeAfter = function(ownerID, level, index) {\n      if (index === (level ? 1 << level : 0) || this.array.length === 0) {\n        return this;\n      }\n      var sizeIndex = ((index - 1) >>> level) & MASK;\n      if (sizeIndex >= this.array.length) {\n        return this;\n      }\n\n      var newChild;\n      if (level > 0) {\n        var oldChild = this.array[sizeIndex];\n        newChild = oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);\n        if (newChild === oldChild && sizeIndex === this.array.length - 1) {\n          return this;\n        }\n      }\n\n      var editable = editableVNode(this, ownerID);\n      editable.array.splice(sizeIndex + 1);\n      if (newChild) {\n        editable.array[sizeIndex] = newChild;\n      }\n      return editable;\n    };\n\n\n\n  var DONE = {};\n\n  function iterateList(list, reverse) {\n    var left = list._origin;\n    var right = list._capacity;\n    var tailPos = getTailOffset(right);\n    var tail = list._tail;\n\n    return iterateNodeOrLeaf(list._root, list._level, 0);\n\n    function iterateNodeOrLeaf(node, level, offset) {\n      return level === 0 ?\n        iterateLeaf(node, offset) :\n        iterateNode(node, level, offset);\n    }\n\n    function iterateLeaf(node, offset) {\n      var array = offset === tailPos ? tail && tail.array : node && node.array;\n      var from = offset > left ? 0 : left - offset;\n      var to = right - offset;\n      if (to > SIZE) {\n        to = SIZE;\n      }\n      return function()  {\n        if (from === to) {\n          return DONE;\n        }\n        var idx = reverse ? --to : from++;\n        return array && array[idx];\n      };\n    }\n\n    function iterateNode(node, level, offset) {\n      var values;\n      var array = node && node.array;\n      var from = offset > left ? 0 : (left - offset) >> level;\n      var to = ((right - offset) >> level) + 1;\n      if (to > SIZE) {\n        to = SIZE;\n      }\n      return function()  {\n        do {\n          if (values) {\n            var value = values();\n            if (value !== DONE) {\n              return value;\n            }\n            values = null;\n          }\n          if (from === to) {\n            return DONE;\n          }\n          var idx = reverse ? --to : from++;\n          values = iterateNodeOrLeaf(\n            array && array[idx], level - SHIFT, offset + (idx << level)\n          );\n        } while (true);\n      };\n    }\n  }\n\n  function makeList(origin, capacity, level, root, tail, ownerID, hash) {\n    var list = Object.create(ListPrototype);\n    list.size = capacity - origin;\n    list._origin = origin;\n    list._capacity = capacity;\n    list._level = level;\n    list._root = root;\n    list._tail = tail;\n    list.__ownerID = ownerID;\n    list.__hash = hash;\n    list.__altered = false;\n    return list;\n  }\n\n  var EMPTY_LIST;\n  function emptyList() {\n    return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));\n  }\n\n  function updateList(list, index, value) {\n    index = wrapIndex(list, index);\n\n    if (index !== index) {\n      return list;\n    }\n\n    if (index >= list.size || index < 0) {\n      return list.withMutations(function(list ) {\n        index < 0 ?\n          setListBounds(list, index).set(0, value) :\n          setListBounds(list, 0, index + 1).set(index, value)\n      });\n    }\n\n    index += list._origin;\n\n    var newTail = list._tail;\n    var newRoot = list._root;\n    var didAlter = MakeRef(DID_ALTER);\n    if (index >= getTailOffset(list._capacity)) {\n      newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter);\n    } else {\n      newRoot = updateVNode(newRoot, list.__ownerID, list._level, index, value, didAlter);\n    }\n\n    if (!didAlter.value) {\n      return list;\n    }\n\n    if (list.__ownerID) {\n      list._root = newRoot;\n      list._tail = newTail;\n      list.__hash = undefined;\n      list.__altered = true;\n      return list;\n    }\n    return makeList(list._origin, list._capacity, list._level, newRoot, newTail);\n  }\n\n  function updateVNode(node, ownerID, level, index, value, didAlter) {\n    var idx = (index >>> level) & MASK;\n    var nodeHas = node && idx < node.array.length;\n    if (!nodeHas && value === undefined) {\n      return node;\n    }\n\n    var newNode;\n\n    if (level > 0) {\n      var lowerNode = node && node.array[idx];\n      var newLowerNode = updateVNode(lowerNode, ownerID, level - SHIFT, index, value, didAlter);\n      if (newLowerNode === lowerNode) {\n        return node;\n      }\n      newNode = editableVNode(node, ownerID);\n      newNode.array[idx] = newLowerNode;\n      return newNode;\n    }\n\n    if (nodeHas && node.array[idx] === value) {\n      return node;\n    }\n\n    SetRef(didAlter);\n\n    newNode = editableVNode(node, ownerID);\n    if (value === undefined && idx === newNode.array.length - 1) {\n      newNode.array.pop();\n    } else {\n      newNode.array[idx] = value;\n    }\n    return newNode;\n  }\n\n  function editableVNode(node, ownerID) {\n    if (ownerID && node && ownerID === node.ownerID) {\n      return node;\n    }\n    return new VNode(node ? node.array.slice() : [], ownerID);\n  }\n\n  function listNodeFor(list, rawIndex) {\n    if (rawIndex >= getTailOffset(list._capacity)) {\n      return list._tail;\n    }\n    if (rawIndex < 1 << (list._level + SHIFT)) {\n      var node = list._root;\n      var level = list._level;\n      while (node && level > 0) {\n        node = node.array[(rawIndex >>> level) & MASK];\n        level -= SHIFT;\n      }\n      return node;\n    }\n  }\n\n  function setListBounds(list, begin, end) {\n    // Sanitize begin & end using this shorthand for ToInt32(argument)\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n    if (begin !== undefined) {\n      begin = begin | 0;\n    }\n    if (end !== undefined) {\n      end = end | 0;\n    }\n    var owner = list.__ownerID || new OwnerID();\n    var oldOrigin = list._origin;\n    var oldCapacity = list._capacity;\n    var newOrigin = oldOrigin + begin;\n    var newCapacity = end === undefined ? oldCapacity : end < 0 ? oldCapacity + end : oldOrigin + end;\n    if (newOrigin === oldOrigin && newCapacity === oldCapacity) {\n      return list;\n    }\n\n    // If it's going to end after it starts, it's empty.\n    if (newOrigin >= newCapacity) {\n      return list.clear();\n    }\n\n    var newLevel = list._level;\n    var newRoot = list._root;\n\n    // New origin might need creating a higher root.\n    var offsetShift = 0;\n    while (newOrigin + offsetShift < 0) {\n      newRoot = new VNode(newRoot && newRoot.array.length ? [undefined, newRoot] : [], owner);\n      newLevel += SHIFT;\n      offsetShift += 1 << newLevel;\n    }\n    if (offsetShift) {\n      newOrigin += offsetShift;\n      oldOrigin += offsetShift;\n      newCapacity += offsetShift;\n      oldCapacity += offsetShift;\n    }\n\n    var oldTailOffset = getTailOffset(oldCapacity);\n    var newTailOffset = getTailOffset(newCapacity);\n\n    // New size might need creating a higher root.\n    while (newTailOffset >= 1 << (newLevel + SHIFT)) {\n      newRoot = new VNode(newRoot && newRoot.array.length ? [newRoot] : [], owner);\n      newLevel += SHIFT;\n    }\n\n    // Locate or create the new tail.\n    var oldTail = list._tail;\n    var newTail = newTailOffset < oldTailOffset ?\n      listNodeFor(list, newCapacity - 1) :\n      newTailOffset > oldTailOffset ? new VNode([], owner) : oldTail;\n\n    // Merge Tail into tree.\n    if (oldTail && newTailOffset > oldTailOffset && newOrigin < oldCapacity && oldTail.array.length) {\n      newRoot = editableVNode(newRoot, owner);\n      var node = newRoot;\n      for (var level = newLevel; level > SHIFT; level -= SHIFT) {\n        var idx = (oldTailOffset >>> level) & MASK;\n        node = node.array[idx] = editableVNode(node.array[idx], owner);\n      }\n      node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;\n    }\n\n    // If the size has been reduced, there's a chance the tail needs to be trimmed.\n    if (newCapacity < oldCapacity) {\n      newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);\n    }\n\n    // If the new origin is within the tail, then we do not need a root.\n    if (newOrigin >= newTailOffset) {\n      newOrigin -= newTailOffset;\n      newCapacity -= newTailOffset;\n      newLevel = SHIFT;\n      newRoot = null;\n      newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);\n\n    // Otherwise, if the root has been trimmed, garbage collect.\n    } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {\n      offsetShift = 0;\n\n      // Identify the new top root node of the subtree of the old root.\n      while (newRoot) {\n        var beginIndex = (newOrigin >>> newLevel) & MASK;\n        if (beginIndex !== (newTailOffset >>> newLevel) & MASK) {\n          break;\n        }\n        if (beginIndex) {\n          offsetShift += (1 << newLevel) * beginIndex;\n        }\n        newLevel -= SHIFT;\n        newRoot = newRoot.array[beginIndex];\n      }\n\n      // Trim the new sides of the new root.\n      if (newRoot && newOrigin > oldOrigin) {\n        newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift);\n      }\n      if (newRoot && newTailOffset < oldTailOffset) {\n        newRoot = newRoot.removeAfter(owner, newLevel, newTailOffset - offsetShift);\n      }\n      if (offsetShift) {\n        newOrigin -= offsetShift;\n        newCapacity -= offsetShift;\n      }\n    }\n\n    if (list.__ownerID) {\n      list.size = newCapacity - newOrigin;\n      list._origin = newOrigin;\n      list._capacity = newCapacity;\n      list._level = newLevel;\n      list._root = newRoot;\n      list._tail = newTail;\n      list.__hash = undefined;\n      list.__altered = true;\n      return list;\n    }\n    return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);\n  }\n\n  function mergeIntoListWith(list, merger, iterables) {\n    var iters = [];\n    var maxSize = 0;\n    for (var ii = 0; ii < iterables.length; ii++) {\n      var value = iterables[ii];\n      var iter = IndexedIterable(value);\n      if (iter.size > maxSize) {\n        maxSize = iter.size;\n      }\n      if (!isIterable(value)) {\n        iter = iter.map(function(v ) {return fromJS(v)});\n      }\n      iters.push(iter);\n    }\n    if (maxSize > list.size) {\n      list = list.setSize(maxSize);\n    }\n    return mergeIntoCollectionWith(list, merger, iters);\n  }\n\n  function getTailOffset(size) {\n    return size < SIZE ? 0 : (((size - 1) >>> SHIFT) << SHIFT);\n  }\n\n  createClass(OrderedMap, Map);\n\n    // @pragma Construction\n\n    function OrderedMap(value) {\n      return value === null || value === undefined ? emptyOrderedMap() :\n        isOrderedMap(value) ? value :\n        emptyOrderedMap().withMutations(function(map ) {\n          var iter = KeyedIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v, k)  {return map.set(k, v)});\n        });\n    }\n\n    OrderedMap.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    OrderedMap.prototype.toString = function() {\n      return this.__toString('OrderedMap {', '}');\n    };\n\n    // @pragma Access\n\n    OrderedMap.prototype.get = function(k, notSetValue) {\n      var index = this._map.get(k);\n      return index !== undefined ? this._list.get(index)[1] : notSetValue;\n    };\n\n    // @pragma Modification\n\n    OrderedMap.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._map.clear();\n        this._list.clear();\n        return this;\n      }\n      return emptyOrderedMap();\n    };\n\n    OrderedMap.prototype.set = function(k, v) {\n      return updateOrderedMap(this, k, v);\n    };\n\n    OrderedMap.prototype.remove = function(k) {\n      return updateOrderedMap(this, k, NOT_SET);\n    };\n\n    OrderedMap.prototype.wasAltered = function() {\n      return this._map.wasAltered() || this._list.wasAltered();\n    };\n\n    OrderedMap.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._list.__iterate(\n        function(entry ) {return entry && fn(entry[1], entry[0], this$0)},\n        reverse\n      );\n    };\n\n    OrderedMap.prototype.__iterator = function(type, reverse) {\n      return this._list.fromEntrySeq().__iterator(type, reverse);\n    };\n\n    OrderedMap.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map.__ensureOwner(ownerID);\n      var newList = this._list.__ensureOwner(ownerID);\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        this._list = newList;\n        return this;\n      }\n      return makeOrderedMap(newMap, newList, ownerID, this.__hash);\n    };\n\n\n  function isOrderedMap(maybeOrderedMap) {\n    return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);\n  }\n\n  OrderedMap.isOrderedMap = isOrderedMap;\n\n  OrderedMap.prototype[IS_ORDERED_SENTINEL] = true;\n  OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;\n\n\n\n  function makeOrderedMap(map, list, ownerID, hash) {\n    var omap = Object.create(OrderedMap.prototype);\n    omap.size = map ? map.size : 0;\n    omap._map = map;\n    omap._list = list;\n    omap.__ownerID = ownerID;\n    omap.__hash = hash;\n    return omap;\n  }\n\n  var EMPTY_ORDERED_MAP;\n  function emptyOrderedMap() {\n    return EMPTY_ORDERED_MAP || (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()));\n  }\n\n  function updateOrderedMap(omap, k, v) {\n    var map = omap._map;\n    var list = omap._list;\n    var i = map.get(k);\n    var has = i !== undefined;\n    var newMap;\n    var newList;\n    if (v === NOT_SET) { // removed\n      if (!has) {\n        return omap;\n      }\n      if (list.size >= SIZE && list.size >= map.size * 2) {\n        newList = list.filter(function(entry, idx)  {return entry !== undefined && i !== idx});\n        newMap = newList.toKeyedSeq().map(function(entry ) {return entry[0]}).flip().toMap();\n        if (omap.__ownerID) {\n          newMap.__ownerID = newList.__ownerID = omap.__ownerID;\n        }\n      } else {\n        newMap = map.remove(k);\n        newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);\n      }\n    } else {\n      if (has) {\n        if (v === list.get(i)[1]) {\n          return omap;\n        }\n        newMap = map;\n        newList = list.set(i, [k, v]);\n      } else {\n        newMap = map.set(k, list.size);\n        newList = list.set(list.size, [k, v]);\n      }\n    }\n    if (omap.__ownerID) {\n      omap.size = newMap.size;\n      omap._map = newMap;\n      omap._list = newList;\n      omap.__hash = undefined;\n      return omap;\n    }\n    return makeOrderedMap(newMap, newList);\n  }\n\n  createClass(ToKeyedSequence, KeyedSeq);\n    function ToKeyedSequence(indexed, useKeys) {\n      this._iter = indexed;\n      this._useKeys = useKeys;\n      this.size = indexed.size;\n    }\n\n    ToKeyedSequence.prototype.get = function(key, notSetValue) {\n      return this._iter.get(key, notSetValue);\n    };\n\n    ToKeyedSequence.prototype.has = function(key) {\n      return this._iter.has(key);\n    };\n\n    ToKeyedSequence.prototype.valueSeq = function() {\n      return this._iter.valueSeq();\n    };\n\n    ToKeyedSequence.prototype.reverse = function() {var this$0 = this;\n      var reversedSequence = reverseFactory(this, true);\n      if (!this._useKeys) {\n        reversedSequence.valueSeq = function()  {return this$0._iter.toSeq().reverse()};\n      }\n      return reversedSequence;\n    };\n\n    ToKeyedSequence.prototype.map = function(mapper, context) {var this$0 = this;\n      var mappedSequence = mapFactory(this, mapper, context);\n      if (!this._useKeys) {\n        mappedSequence.valueSeq = function()  {return this$0._iter.toSeq().map(mapper, context)};\n      }\n      return mappedSequence;\n    };\n\n    ToKeyedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      var ii;\n      return this._iter.__iterate(\n        this._useKeys ?\n          function(v, k)  {return fn(v, k, this$0)} :\n          ((ii = reverse ? resolveSize(this) : 0),\n            function(v ) {return fn(v, reverse ? --ii : ii++, this$0)}),\n        reverse\n      );\n    };\n\n    ToKeyedSequence.prototype.__iterator = function(type, reverse) {\n      if (this._useKeys) {\n        return this._iter.__iterator(type, reverse);\n      }\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      var ii = reverse ? resolveSize(this) : 0;\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step :\n          iteratorValue(type, reverse ? --ii : ii++, step.value, step);\n      });\n    };\n\n  ToKeyedSequence.prototype[IS_ORDERED_SENTINEL] = true;\n\n\n  createClass(ToIndexedSequence, IndexedSeq);\n    function ToIndexedSequence(iter) {\n      this._iter = iter;\n      this.size = iter.size;\n    }\n\n    ToIndexedSequence.prototype.includes = function(value) {\n      return this._iter.includes(value);\n    };\n\n    ToIndexedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      return this._iter.__iterate(function(v ) {return fn(v, iterations++, this$0)}, reverse);\n    };\n\n    ToIndexedSequence.prototype.__iterator = function(type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      var iterations = 0;\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step :\n          iteratorValue(type, iterations++, step.value, step)\n      });\n    };\n\n\n\n  createClass(ToSetSequence, SetSeq);\n    function ToSetSequence(iter) {\n      this._iter = iter;\n      this.size = iter.size;\n    }\n\n    ToSetSequence.prototype.has = function(key) {\n      return this._iter.includes(key);\n    };\n\n    ToSetSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._iter.__iterate(function(v ) {return fn(v, v, this$0)}, reverse);\n    };\n\n    ToSetSequence.prototype.__iterator = function(type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      return new Iterator(function()  {\n        var step = iterator.next();\n        return step.done ? step :\n          iteratorValue(type, step.value, step.value, step);\n      });\n    };\n\n\n\n  createClass(FromEntriesSequence, KeyedSeq);\n    function FromEntriesSequence(entries) {\n      this._iter = entries;\n      this.size = entries.size;\n    }\n\n    FromEntriesSequence.prototype.entrySeq = function() {\n      return this._iter.toSeq();\n    };\n\n    FromEntriesSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._iter.__iterate(function(entry ) {\n        // Check if entry exists first so array access doesn't throw for holes\n        // in the parent iteration.\n        if (entry) {\n          validateEntry(entry);\n          var indexedIterable = isIterable(entry);\n          return fn(\n            indexedIterable ? entry.get(1) : entry[1],\n            indexedIterable ? entry.get(0) : entry[0],\n            this$0\n          );\n        }\n      }, reverse);\n    };\n\n    FromEntriesSequence.prototype.__iterator = function(type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      return new Iterator(function()  {\n        while (true) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          var entry = step.value;\n          // Check if entry exists first so array access doesn't throw for holes\n          // in the parent iteration.\n          if (entry) {\n            validateEntry(entry);\n            var indexedIterable = isIterable(entry);\n            return iteratorValue(\n              type,\n              indexedIterable ? entry.get(0) : entry[0],\n              indexedIterable ? entry.get(1) : entry[1],\n              step\n            );\n          }\n        }\n      });\n    };\n\n\n  ToIndexedSequence.prototype.cacheResult =\n  ToKeyedSequence.prototype.cacheResult =\n  ToSetSequence.prototype.cacheResult =\n  FromEntriesSequence.prototype.cacheResult =\n    cacheResultThrough;\n\n\n  function flipFactory(iterable) {\n    var flipSequence = makeSequence(iterable);\n    flipSequence._iter = iterable;\n    flipSequence.size = iterable.size;\n    flipSequence.flip = function()  {return iterable};\n    flipSequence.reverse = function () {\n      var reversedSequence = iterable.reverse.apply(this); // super.reverse()\n      reversedSequence.flip = function()  {return iterable.reverse()};\n      return reversedSequence;\n    };\n    flipSequence.has = function(key ) {return iterable.includes(key)};\n    flipSequence.includes = function(key ) {return iterable.has(key)};\n    flipSequence.cacheResult = cacheResultThrough;\n    flipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      return iterable.__iterate(function(v, k)  {return fn(k, v, this$0) !== false}, reverse);\n    }\n    flipSequence.__iteratorUncached = function(type, reverse) {\n      if (type === ITERATE_ENTRIES) {\n        var iterator = iterable.__iterator(type, reverse);\n        return new Iterator(function()  {\n          var step = iterator.next();\n          if (!step.done) {\n            var k = step.value[0];\n            step.value[0] = step.value[1];\n            step.value[1] = k;\n          }\n          return step;\n        });\n      }\n      return iterable.__iterator(\n        type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,\n        reverse\n      );\n    }\n    return flipSequence;\n  }\n\n\n  function mapFactory(iterable, mapper, context) {\n    var mappedSequence = makeSequence(iterable);\n    mappedSequence.size = iterable.size;\n    mappedSequence.has = function(key ) {return iterable.has(key)};\n    mappedSequence.get = function(key, notSetValue)  {\n      var v = iterable.get(key, NOT_SET);\n      return v === NOT_SET ?\n        notSetValue :\n        mapper.call(context, v, key, iterable);\n    };\n    mappedSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      return iterable.__iterate(\n        function(v, k, c)  {return fn(mapper.call(context, v, k, c), k, this$0) !== false},\n        reverse\n      );\n    }\n    mappedSequence.__iteratorUncached = function (type, reverse) {\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      return new Iterator(function()  {\n        var step = iterator.next();\n        if (step.done) {\n          return step;\n        }\n        var entry = step.value;\n        var key = entry[0];\n        return iteratorValue(\n          type,\n          key,\n          mapper.call(context, entry[1], key, iterable),\n          step\n        );\n      });\n    }\n    return mappedSequence;\n  }\n\n\n  function reverseFactory(iterable, useKeys) {\n    var reversedSequence = makeSequence(iterable);\n    reversedSequence._iter = iterable;\n    reversedSequence.size = iterable.size;\n    reversedSequence.reverse = function()  {return iterable};\n    if (iterable.flip) {\n      reversedSequence.flip = function () {\n        var flipSequence = flipFactory(iterable);\n        flipSequence.reverse = function()  {return iterable.flip()};\n        return flipSequence;\n      };\n    }\n    reversedSequence.get = function(key, notSetValue) \n      {return iterable.get(useKeys ? key : -1 - key, notSetValue)};\n    reversedSequence.has = function(key )\n      {return iterable.has(useKeys ? key : -1 - key)};\n    reversedSequence.includes = function(value ) {return iterable.includes(value)};\n    reversedSequence.cacheResult = cacheResultThrough;\n    reversedSequence.__iterate = function (fn, reverse) {var this$0 = this;\n      return iterable.__iterate(function(v, k)  {return fn(v, k, this$0)}, !reverse);\n    };\n    reversedSequence.__iterator =\n      function(type, reverse)  {return iterable.__iterator(type, !reverse)};\n    return reversedSequence;\n  }\n\n\n  function filterFactory(iterable, predicate, context, useKeys) {\n    var filterSequence = makeSequence(iterable);\n    if (useKeys) {\n      filterSequence.has = function(key ) {\n        var v = iterable.get(key, NOT_SET);\n        return v !== NOT_SET && !!predicate.call(context, v, key, iterable);\n      };\n      filterSequence.get = function(key, notSetValue)  {\n        var v = iterable.get(key, NOT_SET);\n        return v !== NOT_SET && predicate.call(context, v, key, iterable) ?\n          v : notSetValue;\n      };\n    }\n    filterSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      iterable.__iterate(function(v, k, c)  {\n        if (predicate.call(context, v, k, c)) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$0);\n        }\n      }, reverse);\n      return iterations;\n    };\n    filterSequence.__iteratorUncached = function (type, reverse) {\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      var iterations = 0;\n      return new Iterator(function()  {\n        while (true) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          var entry = step.value;\n          var key = entry[0];\n          var value = entry[1];\n          if (predicate.call(context, value, key, iterable)) {\n            return iteratorValue(type, useKeys ? key : iterations++, value, step);\n          }\n        }\n      });\n    }\n    return filterSequence;\n  }\n\n\n  function countByFactory(iterable, grouper, context) {\n    var groups = Map().asMutable();\n    iterable.__iterate(function(v, k)  {\n      groups.update(\n        grouper.call(context, v, k, iterable),\n        0,\n        function(a ) {return a + 1}\n      );\n    });\n    return groups.asImmutable();\n  }\n\n\n  function groupByFactory(iterable, grouper, context) {\n    var isKeyedIter = isKeyed(iterable);\n    var groups = (isOrdered(iterable) ? OrderedMap() : Map()).asMutable();\n    iterable.__iterate(function(v, k)  {\n      groups.update(\n        grouper.call(context, v, k, iterable),\n        function(a ) {return (a = a || [], a.push(isKeyedIter ? [k, v] : v), a)}\n      );\n    });\n    var coerce = iterableClass(iterable);\n    return groups.map(function(arr ) {return reify(iterable, coerce(arr))});\n  }\n\n\n  function sliceFactory(iterable, begin, end, useKeys) {\n    var originalSize = iterable.size;\n\n    // Sanitize begin & end using this shorthand for ToInt32(argument)\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n    if (begin !== undefined) {\n      begin = begin | 0;\n    }\n    if (end !== undefined) {\n      if (end === Infinity) {\n        end = originalSize;\n      } else {\n        end = end | 0;\n      }\n    }\n\n    if (wholeSlice(begin, end, originalSize)) {\n      return iterable;\n    }\n\n    var resolvedBegin = resolveBegin(begin, originalSize);\n    var resolvedEnd = resolveEnd(end, originalSize);\n\n    // begin or end will be NaN if they were provided as negative numbers and\n    // this iterable's size is unknown. In that case, cache first so there is\n    // a known size and these do not resolve to NaN.\n    if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {\n      return sliceFactory(iterable.toSeq().cacheResult(), begin, end, useKeys);\n    }\n\n    // Note: resolvedEnd is undefined when the original sequence's length is\n    // unknown and this slice did not supply an end and should contain all\n    // elements after resolvedBegin.\n    // In that case, resolvedSize will be NaN and sliceSize will remain undefined.\n    var resolvedSize = resolvedEnd - resolvedBegin;\n    var sliceSize;\n    if (resolvedSize === resolvedSize) {\n      sliceSize = resolvedSize < 0 ? 0 : resolvedSize;\n    }\n\n    var sliceSeq = makeSequence(iterable);\n\n    // If iterable.size is undefined, the size of the realized sliceSeq is\n    // unknown at this point unless the number of items to slice is 0\n    sliceSeq.size = sliceSize === 0 ? sliceSize : iterable.size && sliceSize || undefined;\n\n    if (!useKeys && isSeq(iterable) && sliceSize >= 0) {\n      sliceSeq.get = function (index, notSetValue) {\n        index = wrapIndex(this, index);\n        return index >= 0 && index < sliceSize ?\n          iterable.get(index + resolvedBegin, notSetValue) :\n          notSetValue;\n      }\n    }\n\n    sliceSeq.__iterateUncached = function(fn, reverse) {var this$0 = this;\n      if (sliceSize === 0) {\n        return 0;\n      }\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var skipped = 0;\n      var isSkipping = true;\n      var iterations = 0;\n      iterable.__iterate(function(v, k)  {\n        if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$0) !== false &&\n                 iterations !== sliceSize;\n        }\n      });\n      return iterations;\n    };\n\n    sliceSeq.__iteratorUncached = function(type, reverse) {\n      if (sliceSize !== 0 && reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      // Don't bother instantiating parent iterator if taking 0.\n      var iterator = sliceSize !== 0 && iterable.__iterator(type, reverse);\n      var skipped = 0;\n      var iterations = 0;\n      return new Iterator(function()  {\n        while (skipped++ < resolvedBegin) {\n          iterator.next();\n        }\n        if (++iterations > sliceSize) {\n          return iteratorDone();\n        }\n        var step = iterator.next();\n        if (useKeys || type === ITERATE_VALUES) {\n          return step;\n        } else if (type === ITERATE_KEYS) {\n          return iteratorValue(type, iterations - 1, undefined, step);\n        } else {\n          return iteratorValue(type, iterations - 1, step.value[1], step);\n        }\n      });\n    }\n\n    return sliceSeq;\n  }\n\n\n  function takeWhileFactory(iterable, predicate, context) {\n    var takeSequence = makeSequence(iterable);\n    takeSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterations = 0;\n      iterable.__iterate(function(v, k, c) \n        {return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$0)}\n      );\n      return iterations;\n    };\n    takeSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      var iterating = true;\n      return new Iterator(function()  {\n        if (!iterating) {\n          return iteratorDone();\n        }\n        var step = iterator.next();\n        if (step.done) {\n          return step;\n        }\n        var entry = step.value;\n        var k = entry[0];\n        var v = entry[1];\n        if (!predicate.call(context, v, k, this$0)) {\n          iterating = false;\n          return iteratorDone();\n        }\n        return type === ITERATE_ENTRIES ? step :\n          iteratorValue(type, k, v, step);\n      });\n    };\n    return takeSequence;\n  }\n\n\n  function skipWhileFactory(iterable, predicate, context, useKeys) {\n    var skipSequence = makeSequence(iterable);\n    skipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var isSkipping = true;\n      var iterations = 0;\n      iterable.__iterate(function(v, k, c)  {\n        if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$0);\n        }\n      });\n      return iterations;\n    };\n    skipSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);\n      var skipping = true;\n      var iterations = 0;\n      return new Iterator(function()  {\n        var step, k, v;\n        do {\n          step = iterator.next();\n          if (step.done) {\n            if (useKeys || type === ITERATE_VALUES) {\n              return step;\n            } else if (type === ITERATE_KEYS) {\n              return iteratorValue(type, iterations++, undefined, step);\n            } else {\n              return iteratorValue(type, iterations++, step.value[1], step);\n            }\n          }\n          var entry = step.value;\n          k = entry[0];\n          v = entry[1];\n          skipping && (skipping = predicate.call(context, v, k, this$0));\n        } while (skipping);\n        return type === ITERATE_ENTRIES ? step :\n          iteratorValue(type, k, v, step);\n      });\n    };\n    return skipSequence;\n  }\n\n\n  function concatFactory(iterable, values) {\n    var isKeyedIterable = isKeyed(iterable);\n    var iters = [iterable].concat(values).map(function(v ) {\n      if (!isIterable(v)) {\n        v = isKeyedIterable ?\n          keyedSeqFromValue(v) :\n          indexedSeqFromValue(Array.isArray(v) ? v : [v]);\n      } else if (isKeyedIterable) {\n        v = KeyedIterable(v);\n      }\n      return v;\n    }).filter(function(v ) {return v.size !== 0});\n\n    if (iters.length === 0) {\n      return iterable;\n    }\n\n    if (iters.length === 1) {\n      var singleton = iters[0];\n      if (singleton === iterable ||\n          isKeyedIterable && isKeyed(singleton) ||\n          isIndexed(iterable) && isIndexed(singleton)) {\n        return singleton;\n      }\n    }\n\n    var concatSeq = new ArraySeq(iters);\n    if (isKeyedIterable) {\n      concatSeq = concatSeq.toKeyedSeq();\n    } else if (!isIndexed(iterable)) {\n      concatSeq = concatSeq.toSetSeq();\n    }\n    concatSeq = concatSeq.flatten(true);\n    concatSeq.size = iters.reduce(\n      function(sum, seq)  {\n        if (sum !== undefined) {\n          var size = seq.size;\n          if (size !== undefined) {\n            return sum + size;\n          }\n        }\n      },\n      0\n    );\n    return concatSeq;\n  }\n\n\n  function flattenFactory(iterable, depth, useKeys) {\n    var flatSequence = makeSequence(iterable);\n    flatSequence.__iterateUncached = function(fn, reverse) {\n      var iterations = 0;\n      var stopped = false;\n      function flatDeep(iter, currentDepth) {var this$0 = this;\n        iter.__iterate(function(v, k)  {\n          if ((!depth || currentDepth < depth) && isIterable(v)) {\n            flatDeep(v, currentDepth + 1);\n          } else if (fn(v, useKeys ? k : iterations++, this$0) === false) {\n            stopped = true;\n          }\n          return !stopped;\n        }, reverse);\n      }\n      flatDeep(iterable, 0);\n      return iterations;\n    }\n    flatSequence.__iteratorUncached = function(type, reverse) {\n      var iterator = iterable.__iterator(type, reverse);\n      var stack = [];\n      var iterations = 0;\n      return new Iterator(function()  {\n        while (iterator) {\n          var step = iterator.next();\n          if (step.done !== false) {\n            iterator = stack.pop();\n            continue;\n          }\n          var v = step.value;\n          if (type === ITERATE_ENTRIES) {\n            v = v[1];\n          }\n          if ((!depth || stack.length < depth) && isIterable(v)) {\n            stack.push(iterator);\n            iterator = v.__iterator(type, reverse);\n          } else {\n            return useKeys ? step : iteratorValue(type, iterations++, v, step);\n          }\n        }\n        return iteratorDone();\n      });\n    }\n    return flatSequence;\n  }\n\n\n  function flatMapFactory(iterable, mapper, context) {\n    var coerce = iterableClass(iterable);\n    return iterable.toSeq().map(\n      function(v, k)  {return coerce(mapper.call(context, v, k, iterable))}\n    ).flatten(true);\n  }\n\n\n  function interposeFactory(iterable, separator) {\n    var interposedSequence = makeSequence(iterable);\n    interposedSequence.size = iterable.size && iterable.size * 2 -1;\n    interposedSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;\n      var iterations = 0;\n      iterable.__iterate(function(v, k) \n        {return (!iterations || fn(separator, iterations++, this$0) !== false) &&\n        fn(v, iterations++, this$0) !== false},\n        reverse\n      );\n      return iterations;\n    };\n    interposedSequence.__iteratorUncached = function(type, reverse) {\n      var iterator = iterable.__iterator(ITERATE_VALUES, reverse);\n      var iterations = 0;\n      var step;\n      return new Iterator(function()  {\n        if (!step || iterations % 2) {\n          step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n        }\n        return iterations % 2 ?\n          iteratorValue(type, iterations++, separator) :\n          iteratorValue(type, iterations++, step.value, step);\n      });\n    };\n    return interposedSequence;\n  }\n\n\n  function sortFactory(iterable, comparator, mapper) {\n    if (!comparator) {\n      comparator = defaultComparator;\n    }\n    var isKeyedIterable = isKeyed(iterable);\n    var index = 0;\n    var entries = iterable.toSeq().map(\n      function(v, k)  {return [k, v, index++, mapper ? mapper(v, k, iterable) : v]}\n    ).toArray();\n    entries.sort(function(a, b)  {return comparator(a[3], b[3]) || a[2] - b[2]}).forEach(\n      isKeyedIterable ?\n      function(v, i)  { entries[i].length = 2; } :\n      function(v, i)  { entries[i] = v[1]; }\n    );\n    return isKeyedIterable ? KeyedSeq(entries) :\n      isIndexed(iterable) ? IndexedSeq(entries) :\n      SetSeq(entries);\n  }\n\n\n  function maxFactory(iterable, comparator, mapper) {\n    if (!comparator) {\n      comparator = defaultComparator;\n    }\n    if (mapper) {\n      var entry = iterable.toSeq()\n        .map(function(v, k)  {return [v, mapper(v, k, iterable)]})\n        .reduce(function(a, b)  {return maxCompare(comparator, a[1], b[1]) ? b : a});\n      return entry && entry[0];\n    } else {\n      return iterable.reduce(function(a, b)  {return maxCompare(comparator, a, b) ? b : a});\n    }\n  }\n\n  function maxCompare(comparator, a, b) {\n    var comp = comparator(b, a);\n    // b is considered the new max if the comparator declares them equal, but\n    // they are not equal and b is in fact a nullish value.\n    return (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) || comp > 0;\n  }\n\n\n  function zipWithFactory(keyIter, zipper, iters) {\n    var zipSequence = makeSequence(keyIter);\n    zipSequence.size = new ArraySeq(iters).map(function(i ) {return i.size}).min();\n    // Note: this a generic base implementation of __iterate in terms of\n    // __iterator which may be more generically useful in the future.\n    zipSequence.__iterate = function(fn, reverse) {\n      /* generic:\n      var iterator = this.__iterator(ITERATE_ENTRIES, reverse);\n      var step;\n      var iterations = 0;\n      while (!(step = iterator.next()).done) {\n        iterations++;\n        if (fn(step.value[1], step.value[0], this) === false) {\n          break;\n        }\n      }\n      return iterations;\n      */\n      // indexed:\n      var iterator = this.__iterator(ITERATE_VALUES, reverse);\n      var step;\n      var iterations = 0;\n      while (!(step = iterator.next()).done) {\n        if (fn(step.value, iterations++, this) === false) {\n          break;\n        }\n      }\n      return iterations;\n    };\n    zipSequence.__iteratorUncached = function(type, reverse) {\n      var iterators = iters.map(function(i )\n        {return (i = Iterable(i), getIterator(reverse ? i.reverse() : i))}\n      );\n      var iterations = 0;\n      var isDone = false;\n      return new Iterator(function()  {\n        var steps;\n        if (!isDone) {\n          steps = iterators.map(function(i ) {return i.next()});\n          isDone = steps.some(function(s ) {return s.done});\n        }\n        if (isDone) {\n          return iteratorDone();\n        }\n        return iteratorValue(\n          type,\n          iterations++,\n          zipper.apply(null, steps.map(function(s ) {return s.value}))\n        );\n      });\n    };\n    return zipSequence\n  }\n\n\n  // #pragma Helper Functions\n\n  function reify(iter, seq) {\n    return isSeq(iter) ? seq : iter.constructor(seq);\n  }\n\n  function validateEntry(entry) {\n    if (entry !== Object(entry)) {\n      throw new TypeError('Expected [K, V] tuple: ' + entry);\n    }\n  }\n\n  function resolveSize(iter) {\n    assertNotInfinite(iter.size);\n    return ensureSize(iter);\n  }\n\n  function iterableClass(iterable) {\n    return isKeyed(iterable) ? KeyedIterable :\n      isIndexed(iterable) ? IndexedIterable :\n      SetIterable;\n  }\n\n  function makeSequence(iterable) {\n    return Object.create(\n      (\n        isKeyed(iterable) ? KeyedSeq :\n        isIndexed(iterable) ? IndexedSeq :\n        SetSeq\n      ).prototype\n    );\n  }\n\n  function cacheResultThrough() {\n    if (this._iter.cacheResult) {\n      this._iter.cacheResult();\n      this.size = this._iter.size;\n      return this;\n    } else {\n      return Seq.prototype.cacheResult.call(this);\n    }\n  }\n\n  function defaultComparator(a, b) {\n    return a > b ? 1 : a < b ? -1 : 0;\n  }\n\n  function forceIterator(keyPath) {\n    var iter = getIterator(keyPath);\n    if (!iter) {\n      // Array might not be iterable in this environment, so we need a fallback\n      // to our wrapped type.\n      if (!isArrayLike(keyPath)) {\n        throw new TypeError('Expected iterable or array-like: ' + keyPath);\n      }\n      iter = getIterator(Iterable(keyPath));\n    }\n    return iter;\n  }\n\n  createClass(Record, KeyedCollection);\n\n    function Record(defaultValues, name) {\n      var hasInitialized;\n\n      var RecordType = function Record(values) {\n        if (values instanceof RecordType) {\n          return values;\n        }\n        if (!(this instanceof RecordType)) {\n          return new RecordType(values);\n        }\n        if (!hasInitialized) {\n          hasInitialized = true;\n          var keys = Object.keys(defaultValues);\n          setProps(RecordTypePrototype, keys);\n          RecordTypePrototype.size = keys.length;\n          RecordTypePrototype._name = name;\n          RecordTypePrototype._keys = keys;\n          RecordTypePrototype._defaultValues = defaultValues;\n        }\n        this._map = Map(values);\n      };\n\n      var RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype);\n      RecordTypePrototype.constructor = RecordType;\n\n      return RecordType;\n    }\n\n    Record.prototype.toString = function() {\n      return this.__toString(recordName(this) + ' {', '}');\n    };\n\n    // @pragma Access\n\n    Record.prototype.has = function(k) {\n      return this._defaultValues.hasOwnProperty(k);\n    };\n\n    Record.prototype.get = function(k, notSetValue) {\n      if (!this.has(k)) {\n        return notSetValue;\n      }\n      var defaultVal = this._defaultValues[k];\n      return this._map ? this._map.get(k, defaultVal) : defaultVal;\n    };\n\n    // @pragma Modification\n\n    Record.prototype.clear = function() {\n      if (this.__ownerID) {\n        this._map && this._map.clear();\n        return this;\n      }\n      var RecordType = this.constructor;\n      return RecordType._empty || (RecordType._empty = makeRecord(this, emptyMap()));\n    };\n\n    Record.prototype.set = function(k, v) {\n      if (!this.has(k)) {\n        throw new Error('Cannot set unknown key \"' + k + '\" on ' + recordName(this));\n      }\n      if (this._map && !this._map.has(k)) {\n        var defaultVal = this._defaultValues[k];\n        if (v === defaultVal) {\n          return this;\n        }\n      }\n      var newMap = this._map && this._map.set(k, v);\n      if (this.__ownerID || newMap === this._map) {\n        return this;\n      }\n      return makeRecord(this, newMap);\n    };\n\n    Record.prototype.remove = function(k) {\n      if (!this.has(k)) {\n        return this;\n      }\n      var newMap = this._map && this._map.remove(k);\n      if (this.__ownerID || newMap === this._map) {\n        return this;\n      }\n      return makeRecord(this, newMap);\n    };\n\n    Record.prototype.wasAltered = function() {\n      return this._map.wasAltered();\n    };\n\n    Record.prototype.__iterator = function(type, reverse) {var this$0 = this;\n      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterator(type, reverse);\n    };\n\n    Record.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterate(fn, reverse);\n    };\n\n    Record.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map && this._map.__ensureOwner(ownerID);\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        return this;\n      }\n      return makeRecord(this, newMap, ownerID);\n    };\n\n\n  var RecordPrototype = Record.prototype;\n  RecordPrototype[DELETE] = RecordPrototype.remove;\n  RecordPrototype.deleteIn =\n  RecordPrototype.removeIn = MapPrototype.removeIn;\n  RecordPrototype.merge = MapPrototype.merge;\n  RecordPrototype.mergeWith = MapPrototype.mergeWith;\n  RecordPrototype.mergeIn = MapPrototype.mergeIn;\n  RecordPrototype.mergeDeep = MapPrototype.mergeDeep;\n  RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith;\n  RecordPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;\n  RecordPrototype.setIn = MapPrototype.setIn;\n  RecordPrototype.update = MapPrototype.update;\n  RecordPrototype.updateIn = MapPrototype.updateIn;\n  RecordPrototype.withMutations = MapPrototype.withMutations;\n  RecordPrototype.asMutable = MapPrototype.asMutable;\n  RecordPrototype.asImmutable = MapPrototype.asImmutable;\n\n\n  function makeRecord(likeRecord, map, ownerID) {\n    var record = Object.create(Object.getPrototypeOf(likeRecord));\n    record._map = map;\n    record.__ownerID = ownerID;\n    return record;\n  }\n\n  function recordName(record) {\n    return record._name || record.constructor.name || 'Record';\n  }\n\n  function setProps(prototype, names) {\n    try {\n      names.forEach(setProp.bind(undefined, prototype));\n    } catch (error) {\n      // Object.defineProperty failed. Probably IE8.\n    }\n  }\n\n  function setProp(prototype, name) {\n    Object.defineProperty(prototype, name, {\n      get: function() {\n        return this.get(name);\n      },\n      set: function(value) {\n        invariant(this.__ownerID, 'Cannot set on an immutable record.');\n        this.set(name, value);\n      }\n    });\n  }\n\n  createClass(Set, SetCollection);\n\n    // @pragma Construction\n\n    function Set(value) {\n      return value === null || value === undefined ? emptySet() :\n        isSet(value) && !isOrdered(value) ? value :\n        emptySet().withMutations(function(set ) {\n          var iter = SetIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v ) {return set.add(v)});\n        });\n    }\n\n    Set.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    Set.fromKeys = function(value) {\n      return this(KeyedIterable(value).keySeq());\n    };\n\n    Set.prototype.toString = function() {\n      return this.__toString('Set {', '}');\n    };\n\n    // @pragma Access\n\n    Set.prototype.has = function(value) {\n      return this._map.has(value);\n    };\n\n    // @pragma Modification\n\n    Set.prototype.add = function(value) {\n      return updateSet(this, this._map.set(value, true));\n    };\n\n    Set.prototype.remove = function(value) {\n      return updateSet(this, this._map.remove(value));\n    };\n\n    Set.prototype.clear = function() {\n      return updateSet(this, this._map.clear());\n    };\n\n    // @pragma Composition\n\n    Set.prototype.union = function() {var iters = SLICE$0.call(arguments, 0);\n      iters = iters.filter(function(x ) {return x.size !== 0});\n      if (iters.length === 0) {\n        return this;\n      }\n      if (this.size === 0 && !this.__ownerID && iters.length === 1) {\n        return this.constructor(iters[0]);\n      }\n      return this.withMutations(function(set ) {\n        for (var ii = 0; ii < iters.length; ii++) {\n          SetIterable(iters[ii]).forEach(function(value ) {return set.add(value)});\n        }\n      });\n    };\n\n    Set.prototype.intersect = function() {var iters = SLICE$0.call(arguments, 0);\n      if (iters.length === 0) {\n        return this;\n      }\n      iters = iters.map(function(iter ) {return SetIterable(iter)});\n      var originalSet = this;\n      return this.withMutations(function(set ) {\n        originalSet.forEach(function(value ) {\n          if (!iters.every(function(iter ) {return iter.includes(value)})) {\n            set.remove(value);\n          }\n        });\n      });\n    };\n\n    Set.prototype.subtract = function() {var iters = SLICE$0.call(arguments, 0);\n      if (iters.length === 0) {\n        return this;\n      }\n      iters = iters.map(function(iter ) {return SetIterable(iter)});\n      var originalSet = this;\n      return this.withMutations(function(set ) {\n        originalSet.forEach(function(value ) {\n          if (iters.some(function(iter ) {return iter.includes(value)})) {\n            set.remove(value);\n          }\n        });\n      });\n    };\n\n    Set.prototype.merge = function() {\n      return this.union.apply(this, arguments);\n    };\n\n    Set.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);\n      return this.union.apply(this, iters);\n    };\n\n    Set.prototype.sort = function(comparator) {\n      // Late binding\n      return OrderedSet(sortFactory(this, comparator));\n    };\n\n    Set.prototype.sortBy = function(mapper, comparator) {\n      // Late binding\n      return OrderedSet(sortFactory(this, comparator, mapper));\n    };\n\n    Set.prototype.wasAltered = function() {\n      return this._map.wasAltered();\n    };\n\n    Set.prototype.__iterate = function(fn, reverse) {var this$0 = this;\n      return this._map.__iterate(function(_, k)  {return fn(k, k, this$0)}, reverse);\n    };\n\n    Set.prototype.__iterator = function(type, reverse) {\n      return this._map.map(function(_, k)  {return k}).__iterator(type, reverse);\n    };\n\n    Set.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map.__ensureOwner(ownerID);\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        return this;\n      }\n      return this.__make(newMap, ownerID);\n    };\n\n\n  function isSet(maybeSet) {\n    return !!(maybeSet && maybeSet[IS_SET_SENTINEL]);\n  }\n\n  Set.isSet = isSet;\n\n  var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';\n\n  var SetPrototype = Set.prototype;\n  SetPrototype[IS_SET_SENTINEL] = true;\n  SetPrototype[DELETE] = SetPrototype.remove;\n  SetPrototype.mergeDeep = SetPrototype.merge;\n  SetPrototype.mergeDeepWith = SetPrototype.mergeWith;\n  SetPrototype.withMutations = MapPrototype.withMutations;\n  SetPrototype.asMutable = MapPrototype.asMutable;\n  SetPrototype.asImmutable = MapPrototype.asImmutable;\n\n  SetPrototype.__empty = emptySet;\n  SetPrototype.__make = makeSet;\n\n  function updateSet(set, newMap) {\n    if (set.__ownerID) {\n      set.size = newMap.size;\n      set._map = newMap;\n      return set;\n    }\n    return newMap === set._map ? set :\n      newMap.size === 0 ? set.__empty() :\n      set.__make(newMap);\n  }\n\n  function makeSet(map, ownerID) {\n    var set = Object.create(SetPrototype);\n    set.size = map ? map.size : 0;\n    set._map = map;\n    set.__ownerID = ownerID;\n    return set;\n  }\n\n  var EMPTY_SET;\n  function emptySet() {\n    return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));\n  }\n\n  createClass(OrderedSet, Set);\n\n    // @pragma Construction\n\n    function OrderedSet(value) {\n      return value === null || value === undefined ? emptyOrderedSet() :\n        isOrderedSet(value) ? value :\n        emptyOrderedSet().withMutations(function(set ) {\n          var iter = SetIterable(value);\n          assertNotInfinite(iter.size);\n          iter.forEach(function(v ) {return set.add(v)});\n        });\n    }\n\n    OrderedSet.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    OrderedSet.fromKeys = function(value) {\n      return this(KeyedIterable(value).keySeq());\n    };\n\n    OrderedSet.prototype.toString = function() {\n      return this.__toString('OrderedSet {', '}');\n    };\n\n\n  function isOrderedSet(maybeOrderedSet) {\n    return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);\n  }\n\n  OrderedSet.isOrderedSet = isOrderedSet;\n\n  var OrderedSetPrototype = OrderedSet.prototype;\n  OrderedSetPrototype[IS_ORDERED_SENTINEL] = true;\n\n  OrderedSetPrototype.__empty = emptyOrderedSet;\n  OrderedSetPrototype.__make = makeOrderedSet;\n\n  function makeOrderedSet(map, ownerID) {\n    var set = Object.create(OrderedSetPrototype);\n    set.size = map ? map.size : 0;\n    set._map = map;\n    set.__ownerID = ownerID;\n    return set;\n  }\n\n  var EMPTY_ORDERED_SET;\n  function emptyOrderedSet() {\n    return EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()));\n  }\n\n  createClass(Stack, IndexedCollection);\n\n    // @pragma Construction\n\n    function Stack(value) {\n      return value === null || value === undefined ? emptyStack() :\n        isStack(value) ? value :\n        emptyStack().unshiftAll(value);\n    }\n\n    Stack.of = function(/*...values*/) {\n      return this(arguments);\n    };\n\n    Stack.prototype.toString = function() {\n      return this.__toString('Stack [', ']');\n    };\n\n    // @pragma Access\n\n    Stack.prototype.get = function(index, notSetValue) {\n      var head = this._head;\n      index = wrapIndex(this, index);\n      while (head && index--) {\n        head = head.next;\n      }\n      return head ? head.value : notSetValue;\n    };\n\n    Stack.prototype.peek = function() {\n      return this._head && this._head.value;\n    };\n\n    // @pragma Modification\n\n    Stack.prototype.push = function(/*...values*/) {\n      if (arguments.length === 0) {\n        return this;\n      }\n      var newSize = this.size + arguments.length;\n      var head = this._head;\n      for (var ii = arguments.length - 1; ii >= 0; ii--) {\n        head = {\n          value: arguments[ii],\n          next: head\n        };\n      }\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    Stack.prototype.pushAll = function(iter) {\n      iter = IndexedIterable(iter);\n      if (iter.size === 0) {\n        return this;\n      }\n      assertNotInfinite(iter.size);\n      var newSize = this.size;\n      var head = this._head;\n      iter.reverse().forEach(function(value ) {\n        newSize++;\n        head = {\n          value: value,\n          next: head\n        };\n      });\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    Stack.prototype.pop = function() {\n      return this.slice(1);\n    };\n\n    Stack.prototype.unshift = function(/*...values*/) {\n      return this.push.apply(this, arguments);\n    };\n\n    Stack.prototype.unshiftAll = function(iter) {\n      return this.pushAll(iter);\n    };\n\n    Stack.prototype.shift = function() {\n      return this.pop.apply(this, arguments);\n    };\n\n    Stack.prototype.clear = function() {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._head = undefined;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyStack();\n    };\n\n    Stack.prototype.slice = function(begin, end) {\n      if (wholeSlice(begin, end, this.size)) {\n        return this;\n      }\n      var resolvedBegin = resolveBegin(begin, this.size);\n      var resolvedEnd = resolveEnd(end, this.size);\n      if (resolvedEnd !== this.size) {\n        // super.slice(begin, end);\n        return IndexedCollection.prototype.slice.call(this, begin, end);\n      }\n      var newSize = this.size - resolvedBegin;\n      var head = this._head;\n      while (resolvedBegin--) {\n        head = head.next;\n      }\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    // @pragma Mutability\n\n    Stack.prototype.__ensureOwner = function(ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        this.__ownerID = ownerID;\n        this.__altered = false;\n        return this;\n      }\n      return makeStack(this.size, this._head, ownerID, this.__hash);\n    };\n\n    // @pragma Iteration\n\n    Stack.prototype.__iterate = function(fn, reverse) {\n      if (reverse) {\n        return this.reverse().__iterate(fn);\n      }\n      var iterations = 0;\n      var node = this._head;\n      while (node) {\n        if (fn(node.value, iterations++, this) === false) {\n          break;\n        }\n        node = node.next;\n      }\n      return iterations;\n    };\n\n    Stack.prototype.__iterator = function(type, reverse) {\n      if (reverse) {\n        return this.reverse().__iterator(type);\n      }\n      var iterations = 0;\n      var node = this._head;\n      return new Iterator(function()  {\n        if (node) {\n          var value = node.value;\n          node = node.next;\n          return iteratorValue(type, iterations++, value);\n        }\n        return iteratorDone();\n      });\n    };\n\n\n  function isStack(maybeStack) {\n    return !!(maybeStack && maybeStack[IS_STACK_SENTINEL]);\n  }\n\n  Stack.isStack = isStack;\n\n  var IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';\n\n  var StackPrototype = Stack.prototype;\n  StackPrototype[IS_STACK_SENTINEL] = true;\n  StackPrototype.withMutations = MapPrototype.withMutations;\n  StackPrototype.asMutable = MapPrototype.asMutable;\n  StackPrototype.asImmutable = MapPrototype.asImmutable;\n  StackPrototype.wasAltered = MapPrototype.wasAltered;\n\n\n  function makeStack(size, head, ownerID, hash) {\n    var map = Object.create(StackPrototype);\n    map.size = size;\n    map._head = head;\n    map.__ownerID = ownerID;\n    map.__hash = hash;\n    map.__altered = false;\n    return map;\n  }\n\n  var EMPTY_STACK;\n  function emptyStack() {\n    return EMPTY_STACK || (EMPTY_STACK = makeStack(0));\n  }\n\n  /**\n   * Contributes additional methods to a constructor\n   */\n  function mixin(ctor, methods) {\n    var keyCopier = function(key ) { ctor.prototype[key] = methods[key]; };\n    Object.keys(methods).forEach(keyCopier);\n    Object.getOwnPropertySymbols &&\n      Object.getOwnPropertySymbols(methods).forEach(keyCopier);\n    return ctor;\n  }\n\n  Iterable.Iterator = Iterator;\n\n  mixin(Iterable, {\n\n    // ### Conversion to other types\n\n    toArray: function() {\n      assertNotInfinite(this.size);\n      var array = new Array(this.size || 0);\n      this.valueSeq().__iterate(function(v, i)  { array[i] = v; });\n      return array;\n    },\n\n    toIndexedSeq: function() {\n      return new ToIndexedSequence(this);\n    },\n\n    toJS: function() {\n      return this.toSeq().map(\n        function(value ) {return value && typeof value.toJS === 'function' ? value.toJS() : value}\n      ).__toJS();\n    },\n\n    toJSON: function() {\n      return this.toSeq().map(\n        function(value ) {return value && typeof value.toJSON === 'function' ? value.toJSON() : value}\n      ).__toJS();\n    },\n\n    toKeyedSeq: function() {\n      return new ToKeyedSequence(this, true);\n    },\n\n    toMap: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return Map(this.toKeyedSeq());\n    },\n\n    toObject: function() {\n      assertNotInfinite(this.size);\n      var object = {};\n      this.__iterate(function(v, k)  { object[k] = v; });\n      return object;\n    },\n\n    toOrderedMap: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return OrderedMap(this.toKeyedSeq());\n    },\n\n    toOrderedSet: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return OrderedSet(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toSet: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return Set(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toSetSeq: function() {\n      return new ToSetSequence(this);\n    },\n\n    toSeq: function() {\n      return isIndexed(this) ? this.toIndexedSeq() :\n        isKeyed(this) ? this.toKeyedSeq() :\n        this.toSetSeq();\n    },\n\n    toStack: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return Stack(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toList: function() {\n      // Use Late Binding here to solve the circular dependency.\n      return List(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n\n    // ### Common JavaScript methods and properties\n\n    toString: function() {\n      return '[Iterable]';\n    },\n\n    __toString: function(head, tail) {\n      if (this.size === 0) {\n        return head + tail;\n      }\n      return head + ' ' + this.toSeq().map(this.__toStringMapper).join(', ') + ' ' + tail;\n    },\n\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    concat: function() {var values = SLICE$0.call(arguments, 0);\n      return reify(this, concatFactory(this, values));\n    },\n\n    includes: function(searchValue) {\n      return this.some(function(value ) {return is(value, searchValue)});\n    },\n\n    entries: function() {\n      return this.__iterator(ITERATE_ENTRIES);\n    },\n\n    every: function(predicate, context) {\n      assertNotInfinite(this.size);\n      var returnValue = true;\n      this.__iterate(function(v, k, c)  {\n        if (!predicate.call(context, v, k, c)) {\n          returnValue = false;\n          return false;\n        }\n      });\n      return returnValue;\n    },\n\n    filter: function(predicate, context) {\n      return reify(this, filterFactory(this, predicate, context, true));\n    },\n\n    find: function(predicate, context, notSetValue) {\n      var entry = this.findEntry(predicate, context);\n      return entry ? entry[1] : notSetValue;\n    },\n\n    forEach: function(sideEffect, context) {\n      assertNotInfinite(this.size);\n      return this.__iterate(context ? sideEffect.bind(context) : sideEffect);\n    },\n\n    join: function(separator) {\n      assertNotInfinite(this.size);\n      separator = separator !== undefined ? '' + separator : ',';\n      var joined = '';\n      var isFirst = true;\n      this.__iterate(function(v ) {\n        isFirst ? (isFirst = false) : (joined += separator);\n        joined += v !== null && v !== undefined ? v.toString() : '';\n      });\n      return joined;\n    },\n\n    keys: function() {\n      return this.__iterator(ITERATE_KEYS);\n    },\n\n    map: function(mapper, context) {\n      return reify(this, mapFactory(this, mapper, context));\n    },\n\n    reduce: function(reducer, initialReduction, context) {\n      assertNotInfinite(this.size);\n      var reduction;\n      var useFirst;\n      if (arguments.length < 2) {\n        useFirst = true;\n      } else {\n        reduction = initialReduction;\n      }\n      this.__iterate(function(v, k, c)  {\n        if (useFirst) {\n          useFirst = false;\n          reduction = v;\n        } else {\n          reduction = reducer.call(context, reduction, v, k, c);\n        }\n      });\n      return reduction;\n    },\n\n    reduceRight: function(reducer, initialReduction, context) {\n      var reversed = this.toKeyedSeq().reverse();\n      return reversed.reduce.apply(reversed, arguments);\n    },\n\n    reverse: function() {\n      return reify(this, reverseFactory(this, true));\n    },\n\n    slice: function(begin, end) {\n      return reify(this, sliceFactory(this, begin, end, true));\n    },\n\n    some: function(predicate, context) {\n      return !this.every(not(predicate), context);\n    },\n\n    sort: function(comparator) {\n      return reify(this, sortFactory(this, comparator));\n    },\n\n    values: function() {\n      return this.__iterator(ITERATE_VALUES);\n    },\n\n\n    // ### More sequential methods\n\n    butLast: function() {\n      return this.slice(0, -1);\n    },\n\n    isEmpty: function() {\n      return this.size !== undefined ? this.size === 0 : !this.some(function()  {return true});\n    },\n\n    count: function(predicate, context) {\n      return ensureSize(\n        predicate ? this.toSeq().filter(predicate, context) : this\n      );\n    },\n\n    countBy: function(grouper, context) {\n      return countByFactory(this, grouper, context);\n    },\n\n    equals: function(other) {\n      return deepEqual(this, other);\n    },\n\n    entrySeq: function() {\n      var iterable = this;\n      if (iterable._cache) {\n        // We cache as an entries array, so we can just return the cache!\n        return new ArraySeq(iterable._cache);\n      }\n      var entriesSequence = iterable.toSeq().map(entryMapper).toIndexedSeq();\n      entriesSequence.fromEntrySeq = function()  {return iterable.toSeq()};\n      return entriesSequence;\n    },\n\n    filterNot: function(predicate, context) {\n      return this.filter(not(predicate), context);\n    },\n\n    findEntry: function(predicate, context, notSetValue) {\n      var found = notSetValue;\n      this.__iterate(function(v, k, c)  {\n        if (predicate.call(context, v, k, c)) {\n          found = [k, v];\n          return false;\n        }\n      });\n      return found;\n    },\n\n    findKey: function(predicate, context) {\n      var entry = this.findEntry(predicate, context);\n      return entry && entry[0];\n    },\n\n    findLast: function(predicate, context, notSetValue) {\n      return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);\n    },\n\n    findLastEntry: function(predicate, context, notSetValue) {\n      return this.toKeyedSeq().reverse().findEntry(predicate, context, notSetValue);\n    },\n\n    findLastKey: function(predicate, context) {\n      return this.toKeyedSeq().reverse().findKey(predicate, context);\n    },\n\n    first: function() {\n      return this.find(returnTrue);\n    },\n\n    flatMap: function(mapper, context) {\n      return reify(this, flatMapFactory(this, mapper, context));\n    },\n\n    flatten: function(depth) {\n      return reify(this, flattenFactory(this, depth, true));\n    },\n\n    fromEntrySeq: function() {\n      return new FromEntriesSequence(this);\n    },\n\n    get: function(searchKey, notSetValue) {\n      return this.find(function(_, key)  {return is(key, searchKey)}, undefined, notSetValue);\n    },\n\n    getIn: function(searchKeyPath, notSetValue) {\n      var nested = this;\n      // Note: in an ES6 environment, we would prefer:\n      // for (var key of searchKeyPath) {\n      var iter = forceIterator(searchKeyPath);\n      var step;\n      while (!(step = iter.next()).done) {\n        var key = step.value;\n        nested = nested && nested.get ? nested.get(key, NOT_SET) : NOT_SET;\n        if (nested === NOT_SET) {\n          return notSetValue;\n        }\n      }\n      return nested;\n    },\n\n    groupBy: function(grouper, context) {\n      return groupByFactory(this, grouper, context);\n    },\n\n    has: function(searchKey) {\n      return this.get(searchKey, NOT_SET) !== NOT_SET;\n    },\n\n    hasIn: function(searchKeyPath) {\n      return this.getIn(searchKeyPath, NOT_SET) !== NOT_SET;\n    },\n\n    isSubset: function(iter) {\n      iter = typeof iter.includes === 'function' ? iter : Iterable(iter);\n      return this.every(function(value ) {return iter.includes(value)});\n    },\n\n    isSuperset: function(iter) {\n      iter = typeof iter.isSubset === 'function' ? iter : Iterable(iter);\n      return iter.isSubset(this);\n    },\n\n    keyOf: function(searchValue) {\n      return this.findKey(function(value ) {return is(value, searchValue)});\n    },\n\n    keySeq: function() {\n      return this.toSeq().map(keyMapper).toIndexedSeq();\n    },\n\n    last: function() {\n      return this.toSeq().reverse().first();\n    },\n\n    lastKeyOf: function(searchValue) {\n      return this.toKeyedSeq().reverse().keyOf(searchValue);\n    },\n\n    max: function(comparator) {\n      return maxFactory(this, comparator);\n    },\n\n    maxBy: function(mapper, comparator) {\n      return maxFactory(this, comparator, mapper);\n    },\n\n    min: function(comparator) {\n      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator);\n    },\n\n    minBy: function(mapper, comparator) {\n      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator, mapper);\n    },\n\n    rest: function() {\n      return this.slice(1);\n    },\n\n    skip: function(amount) {\n      return this.slice(Math.max(0, amount));\n    },\n\n    skipLast: function(amount) {\n      return reify(this, this.toSeq().reverse().skip(amount).reverse());\n    },\n\n    skipWhile: function(predicate, context) {\n      return reify(this, skipWhileFactory(this, predicate, context, true));\n    },\n\n    skipUntil: function(predicate, context) {\n      return this.skipWhile(not(predicate), context);\n    },\n\n    sortBy: function(mapper, comparator) {\n      return reify(this, sortFactory(this, comparator, mapper));\n    },\n\n    take: function(amount) {\n      return this.slice(0, Math.max(0, amount));\n    },\n\n    takeLast: function(amount) {\n      return reify(this, this.toSeq().reverse().take(amount).reverse());\n    },\n\n    takeWhile: function(predicate, context) {\n      return reify(this, takeWhileFactory(this, predicate, context));\n    },\n\n    takeUntil: function(predicate, context) {\n      return this.takeWhile(not(predicate), context);\n    },\n\n    valueSeq: function() {\n      return this.toIndexedSeq();\n    },\n\n\n    // ### Hashable Object\n\n    hashCode: function() {\n      return this.__hash || (this.__hash = hashIterable(this));\n    }\n\n\n    // ### Internal\n\n    // abstract __iterate(fn, reverse)\n\n    // abstract __iterator(type, reverse)\n  });\n\n  // var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';\n  // var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';\n  // var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';\n  // var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';\n\n  var IterablePrototype = Iterable.prototype;\n  IterablePrototype[IS_ITERABLE_SENTINEL] = true;\n  IterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.values;\n  IterablePrototype.__toJS = IterablePrototype.toArray;\n  IterablePrototype.__toStringMapper = quoteString;\n  IterablePrototype.inspect =\n  IterablePrototype.toSource = function() { return this.toString(); };\n  IterablePrototype.chain = IterablePrototype.flatMap;\n  IterablePrototype.contains = IterablePrototype.includes;\n\n  mixin(KeyedIterable, {\n\n    // ### More sequential methods\n\n    flip: function() {\n      return reify(this, flipFactory(this));\n    },\n\n    mapEntries: function(mapper, context) {var this$0 = this;\n      var iterations = 0;\n      return reify(this,\n        this.toSeq().map(\n          function(v, k)  {return mapper.call(context, [k, v], iterations++, this$0)}\n        ).fromEntrySeq()\n      );\n    },\n\n    mapKeys: function(mapper, context) {var this$0 = this;\n      return reify(this,\n        this.toSeq().flip().map(\n          function(k, v)  {return mapper.call(context, k, v, this$0)}\n        ).flip()\n      );\n    }\n\n  });\n\n  var KeyedIterablePrototype = KeyedIterable.prototype;\n  KeyedIterablePrototype[IS_KEYED_SENTINEL] = true;\n  KeyedIterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.entries;\n  KeyedIterablePrototype.__toJS = IterablePrototype.toObject;\n  KeyedIterablePrototype.__toStringMapper = function(v, k)  {return JSON.stringify(k) + ': ' + quoteString(v)};\n\n\n\n  mixin(IndexedIterable, {\n\n    // ### Conversion to other types\n\n    toKeyedSeq: function() {\n      return new ToKeyedSequence(this, false);\n    },\n\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    filter: function(predicate, context) {\n      return reify(this, filterFactory(this, predicate, context, false));\n    },\n\n    findIndex: function(predicate, context) {\n      var entry = this.findEntry(predicate, context);\n      return entry ? entry[0] : -1;\n    },\n\n    indexOf: function(searchValue) {\n      var key = this.keyOf(searchValue);\n      return key === undefined ? -1 : key;\n    },\n\n    lastIndexOf: function(searchValue) {\n      var key = this.lastKeyOf(searchValue);\n      return key === undefined ? -1 : key;\n    },\n\n    reverse: function() {\n      return reify(this, reverseFactory(this, false));\n    },\n\n    slice: function(begin, end) {\n      return reify(this, sliceFactory(this, begin, end, false));\n    },\n\n    splice: function(index, removeNum /*, ...values*/) {\n      var numArgs = arguments.length;\n      removeNum = Math.max(removeNum | 0, 0);\n      if (numArgs === 0 || (numArgs === 2 && !removeNum)) {\n        return this;\n      }\n      // If index is negative, it should resolve relative to the size of the\n      // collection. However size may be expensive to compute if not cached, so\n      // only call count() if the number is in fact negative.\n      index = resolveBegin(index, index < 0 ? this.count() : this.size);\n      var spliced = this.slice(0, index);\n      return reify(\n        this,\n        numArgs === 1 ?\n          spliced :\n          spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum))\n      );\n    },\n\n\n    // ### More collection methods\n\n    findLastIndex: function(predicate, context) {\n      var entry = this.findLastEntry(predicate, context);\n      return entry ? entry[0] : -1;\n    },\n\n    first: function() {\n      return this.get(0);\n    },\n\n    flatten: function(depth) {\n      return reify(this, flattenFactory(this, depth, false));\n    },\n\n    get: function(index, notSetValue) {\n      index = wrapIndex(this, index);\n      return (index < 0 || (this.size === Infinity ||\n          (this.size !== undefined && index > this.size))) ?\n        notSetValue :\n        this.find(function(_, key)  {return key === index}, undefined, notSetValue);\n    },\n\n    has: function(index) {\n      index = wrapIndex(this, index);\n      return index >= 0 && (this.size !== undefined ?\n        this.size === Infinity || index < this.size :\n        this.indexOf(index) !== -1\n      );\n    },\n\n    interpose: function(separator) {\n      return reify(this, interposeFactory(this, separator));\n    },\n\n    interleave: function(/*...iterables*/) {\n      var iterables = [this].concat(arrCopy(arguments));\n      var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, iterables);\n      var interleaved = zipped.flatten(true);\n      if (zipped.size) {\n        interleaved.size = zipped.size * iterables.length;\n      }\n      return reify(this, interleaved);\n    },\n\n    keySeq: function() {\n      return Range(0, this.size);\n    },\n\n    last: function() {\n      return this.get(-1);\n    },\n\n    skipWhile: function(predicate, context) {\n      return reify(this, skipWhileFactory(this, predicate, context, false));\n    },\n\n    zip: function(/*, ...iterables */) {\n      var iterables = [this].concat(arrCopy(arguments));\n      return reify(this, zipWithFactory(this, defaultZipper, iterables));\n    },\n\n    zipWith: function(zipper/*, ...iterables */) {\n      var iterables = arrCopy(arguments);\n      iterables[0] = this;\n      return reify(this, zipWithFactory(this, zipper, iterables));\n    }\n\n  });\n\n  IndexedIterable.prototype[IS_INDEXED_SENTINEL] = true;\n  IndexedIterable.prototype[IS_ORDERED_SENTINEL] = true;\n\n\n\n  mixin(SetIterable, {\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    get: function(value, notSetValue) {\n      return this.has(value) ? value : notSetValue;\n    },\n\n    includes: function(value) {\n      return this.has(value);\n    },\n\n\n    // ### More sequential methods\n\n    keySeq: function() {\n      return this.valueSeq();\n    }\n\n  });\n\n  SetIterable.prototype.has = IterablePrototype.includes;\n  SetIterable.prototype.contains = SetIterable.prototype.includes;\n\n\n  // Mixin subclasses\n\n  mixin(KeyedSeq, KeyedIterable.prototype);\n  mixin(IndexedSeq, IndexedIterable.prototype);\n  mixin(SetSeq, SetIterable.prototype);\n\n  mixin(KeyedCollection, KeyedIterable.prototype);\n  mixin(IndexedCollection, IndexedIterable.prototype);\n  mixin(SetCollection, SetIterable.prototype);\n\n\n  // #pragma Helper functions\n\n  function keyMapper(v, k) {\n    return k;\n  }\n\n  function entryMapper(v, k) {\n    return [k, v];\n  }\n\n  function not(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    }\n  }\n\n  function neg(predicate) {\n    return function() {\n      return -predicate.apply(this, arguments);\n    }\n  }\n\n  function quoteString(value) {\n    return typeof value === 'string' ? JSON.stringify(value) : String(value);\n  }\n\n  function defaultZipper() {\n    return arrCopy(arguments);\n  }\n\n  function defaultNegComparator(a, b) {\n    return a < b ? 1 : a > b ? -1 : 0;\n  }\n\n  function hashIterable(iterable) {\n    if (iterable.size === Infinity) {\n      return 0;\n    }\n    var ordered = isOrdered(iterable);\n    var keyed = isKeyed(iterable);\n    var h = ordered ? 1 : 0;\n    var size = iterable.__iterate(\n      keyed ?\n        ordered ?\n          function(v, k)  { h = 31 * h + hashMerge(hash(v), hash(k)) | 0; } :\n          function(v, k)  { h = h + hashMerge(hash(v), hash(k)) | 0; } :\n        ordered ?\n          function(v ) { h = 31 * h + hash(v) | 0; } :\n          function(v ) { h = h + hash(v) | 0; }\n    );\n    return murmurHashOfSize(size, h);\n  }\n\n  function murmurHashOfSize(size, h) {\n    h = imul(h, 0xCC9E2D51);\n    h = imul(h << 15 | h >>> -15, 0x1B873593);\n    h = imul(h << 13 | h >>> -13, 5);\n    h = (h + 0xE6546B64 | 0) ^ size;\n    h = imul(h ^ h >>> 16, 0x85EBCA6B);\n    h = imul(h ^ h >>> 13, 0xC2B2AE35);\n    h = smi(h ^ h >>> 16);\n    return h;\n  }\n\n  function hashMerge(a, b) {\n    return a ^ b + 0x9E3779B9 + (a << 6) + (a >> 2) | 0; // int\n  }\n\n  var Immutable = {\n\n    Iterable: Iterable,\n\n    Seq: Seq,\n    Collection: Collection,\n    Map: Map,\n    OrderedMap: OrderedMap,\n    List: List,\n    Stack: Stack,\n    Set: Set,\n    OrderedSet: OrderedSet,\n\n    Record: Record,\n    Range: Range,\n    Repeat: Repeat,\n\n    is: is,\n    fromJS: fromJS\n\n  };\n\n  return Immutable;\n\n}));\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/immutable/dist/immutable.js\n// module id = 244\n// module chunks = 2","import React from 'react'\nimport PropTypes from 'prop-types' // eslint-disable-line no-unused-vars\nimport styles from './conditionslabel-style.css'\n\nconst propTypes = {\n  label: PropTypes.string,\n  scrollTo: PropTypes.string,\n}\n\n// Add any default values for props\nconst defaultProps = null\n\nfunction ConditionsLabel({ label, scrollTo }) {\n  const scrollToCondition = e => {\n    e.preventDefault()\n    if (!scrollTo) return\n    const el = document.querySelector(`#${scrollTo}`)\n    if (el) {\n      el.scrollIntoView({\n        behavior: 'smooth',\n        block: 'start',\n        inline: 'nearest',\n      })\n    }\n  }\n  if (!label) return null\n\n  if (scrollTo !== undefined) {\n    return (\n      <div className={styles.container}>\n        {/* eslint-disable jsx-a11y/no-interactive-element-to-noninteractive-role */}\n        <a role=\"navigation\" href={`#${scrollTo}`} onClick={scrollToCondition}>\n          <span className={styles.label}>{label}</span>\n        </a>\n      </div>\n    )\n  }\n\n  return (\n    <div>\n      {/* eslint-disable jsx-a11y/no-interactive-element-to-noninteractive-role */}\n      <span className={styles.label}>{label}</span>\n    </div>\n  )\n}\n\nConditionsLabel.displayName = 'ConditionsLabel'\nConditionsLabel.propTypes = propTypes\nConditionsLabel.defaultProps = defaultProps\n\nexport default ConditionsLabel\n\n\n\n// WEBPACK FOOTER //\n// ./src/components/ConditionsLabel/ConditionsLabel.js","import React, { Component } from 'react'\nimport PropTypes from 'prop-types' // eslint-disable-line no-unused-vars\nimport { EditorState, ContentState } from 'draft-js'\nimport { Map } from 'immutable'\nimport cx from 'classnames'\nimport throttle from 'lodash/throttle'\nimport responsive from 'utils/responsive'\nimport ReactModal from 'react-modal'\nimport MyEditor from 'components/MyEditor/MyEditor'\nimport AuthorInfo from 'components/AuthorInfo/AuthorInfo'\nimport TopBar from 'components/TopBar/TopBar'\nimport Button from 'components/BaseButton/BaseButton'\nimport ConditionsLabel from 'components/ConditionsLabel/ConditionsLabel'\nimport ProposalStats from 'components/ProposalStats/ProposalStats'\nimport ErrorMessage from 'components/ErrorMessage/ErrorMessage'\nimport styles from './proposalEditor-style.css'\nimport formStyles from 'modules/Form/Form-style.css'\nimport modalStyles from '../../components/Modal/modal-style.css'\nimport RichText from 'components/RichText/RichText'\nimport defaultProps from './proposalEditor.defaultProps'\nimport request from 'utils/request'\nimport ReadAloudPopover from '../../components/ReadAloudPopover/ReadAloudPopover'\nimport ReadAloudButton from '../../components/ReadAloudButton/ReadAloudButton'\n\nclass ProposalEditor extends Component {\n  static displayName = 'ProposalEditor'\n  static defaultProps = defaultProps\n\n  state = {\n    showConfirm: false,\n  }\n\n  componentWillMount() {\n    this.loadProposal()\n  }\n\n  componentDidMount() {\n    const {\n      proposalCreationViewModel: {\n        proposal: { displayStatus },\n      },\n    } = this.props\n\n    if (displayStatus === 'edit')\n      this.autosave = setInterval(this.handleSave, 5000)\n\n    if (displayStatus === 'available') {\n      document.addEventListener('scroll', throttle(this.handleScroll, 400))\n    }\n  }\n\n  componentWillUnmount() {\n    const {\n      proposalCreationViewModel: {\n        proposal: { displayStatus },\n      },\n    } = this.props\n\n    if (displayStatus === 'edit') clearInterval(this.autosave)\n\n    if (displayStatus === 'available')\n      document.addEventListener('scroll', this.handleScroll)\n  }\n\n  handleScroll = () => {\n    this.setState(() => ({ showTopBar: global.pageYOffset > 400 }))\n  }\n\n  /* Specify which fields where validation also occurs clientside */\n  validateFields = ['title', 'remarks', 'proposalContent']\n\n  loadProposal = () => {\n    const {\n      proposalCreationViewModel: { proposal },\n    } = this.props\n    let draft = {}\n\n    Object.keys(proposal).forEach(section => {\n      if (this.validateFields.includes(section)) {\n        const content = ContentState.createFromText(proposal[section])\n        draft[section] = EditorState.createWithContent(content)\n      }\n      draft.author = proposal.author\n      draft.coAuthors = proposal.coAuthors\n    })\n\n    this.setState(state => ({ proposal: draft }))\n  }\n\n  validateProposal = async (data, event) => {\n    // event is used to see if it is the user, trying to submit\n    const { pageStructure, defaultErrors } = this.props\n    let errors = {}\n    const validTitle =\n      data.title &&\n      (await this.checkTitle(data.title.getCurrentContent().getPlainText()))\n\n    Object.keys(data).forEach(section => {\n      if (this.validateFields.includes(section)) {\n        const maxLength = pageStructure[`${section}Section`].maxLength\n        const blockMap = data[section].getCurrentContent().getBlockMap()\n        const totalChars = blockMap.reduce(\n          (arr, block) => block.getLength() + arr,\n          0,\n        )\n\n        if (!data[section].getCurrentContent().hasText() || !data[section]) {\n          errors[section] = defaultErrors.find(\n            err => err.errorType === 'fieldIsRequired',\n          ).errorMessage\n        } else if (totalChars > maxLength) {\n          errors[section] = defaultErrors.find(\n            err => err.errorType === 'maxLengthExceeded',\n          ).errorMessage\n        } else if (!validTitle) {\n          errors.title = defaultErrors.find(\n            err => err.errorType === 'isNotValidTitle',\n          ).errorMessage\n        }\n      }\n    })\n\n    this.validateFields.forEach(section => {\n      if (!data[section]) {\n        errors[section] = defaultErrors.find(\n          err => err.errorType === 'fieldIsRequired',\n        ).errorMessage\n      }\n    })\n\n    // only show the errors if the user is trying to submit\n    event && this.setState(() => ({ errors }))\n\n    if (Object.keys(errors).length !== 0) {\n      this.setState({ isValid: false })\n      return errors\n    }\n\n    return null\n  }\n\n  checkTitle = title => {\n    if (!title) return\n\n    const { checkTitleApi } = this.props\n    const proposal = {\n      title,\n    }\n\n    this.setState({ checkingTitle: true })\n\n    if (process.env.NODE_ENV === 'production') {\n      /* Production api  */\n      return request(checkTitleApi, {\n        method: 'post',\n        headers: {\n          'content-type': 'application/json',\n        },\n        body: JSON.stringify(proposal),\n        credentials: 'include',\n      })\n        .then(response => {\n          this.setState({\n            checkingTitle: false,\n            errors: {\n              ...this.state.errors,\n              title: null,\n            },\n          })\n\n          return true\n        })\n        .catch(err => {\n          this.setState({ checkingTitle: false })\n\n          return false\n        })\n    }\n\n    if (process.env.NODE_ENV === 'development') {\n      /* Used for debugging */\n      const localCheck = new Promise((resovle, reject) => {\n        const titles = ['foo', 'bar', 'baz']\n\n        if (titles.includes(title)) {\n          reject(title)\n        } else {\n          resovle()\n        }\n      })\n\n      return localCheck\n        .then(response => {\n          this.setState({\n            checkingTitle: false,\n            errors: {\n              ...this.state.errors,\n              title: null,\n            },\n          })\n\n          return true\n        })\n        .catch(err => {\n          this.setState({ checkingTitle: false })\n\n          return false\n        })\n    }\n  }\n\n  formatProposal(proposal) {\n    let data = Object.apply({}, proposal)\n\n    Object.keys(proposal).forEach(p => {\n      if (proposal[p] instanceof EditorState) {\n        data[p] = proposal[p].getCurrentContent().getPlainText()\n      }\n    })\n    data.author = proposal.author\n    data.coAuthors = proposal.coAuthors\n\n    return data\n  }\n\n  focusInputOnError(pageStructure, errors) {\n    if (!pageStructure || !errors) {\n      return\n    }\n\n    const form = Object.keys(pageStructure)\n\n    for (let i = 0; i < form.length; i++) {\n      // remove 'section' of string to compare to error object\n      const section = form[i].replace('Section', '')\n\n      // if error obj contains that section scrollToView and then focus on that section and break out of loop\n      if (errors.hasOwnProperty(section)) {\n        const refSelector = `${section}Editor`\n        if (refSelector) this[refSelector].handleFocus()\n        break\n      }\n    }\n  }\n\n  handleSave = async event => {\n    const { proposal } = this.state\n    const {\n      proposalCreationViewModel: {\n        proposal: { displayStatus },\n      },\n      pageStructure,\n    } = this.props\n\n    if (event && displayStatus === 'edit') {\n      // if user is trying to submit\n      event.preventDefault()\n\n      const hasErrors = await this.validateProposal(proposal, event)\n\n      if (hasErrors) {\n        this.focusInputOnError(pageStructure, hasErrors)\n        return\n      } // do not try and submit\n      this.setState(() => ({ isSubmitting: true }))\n    }\n\n    if (proposal && (displayStatus === 'edit' || displayStatus === 'preview')) {\n      const data = this.formatProposal(proposal)\n\n      if (data && displayStatus === 'edit') {\n        // if submitting, use the submitApi provided\n\n        return request(event ? this.props.submitApi : this.props.api, {\n          method: 'post',\n          headers: {\n            'content-type': 'application/json',\n          },\n          body: JSON.stringify(data),\n          credentials: 'include',\n        })\n          .then(response => {\n            // only redirect on submit\n            if (event) global.location.href = this.props.next.href\n            this.setState(state => ({\n              data,\n              isSubmitting: false,\n              showConfirm: false,\n            }))\n          })\n          .catch(error => {\n            this.setState(state => ({\n              data,\n              isSubmitting: false,\n              showConfirm: false,\n            }))\n            // if the server throws an error after submitting, display the error.\n            event && this.setState(() => ({ error }))\n          })\n      }\n\n      global.location.href = this.props.next.href\n    }\n  }\n\n  handleBlur = async (key, value) => {\n    const errors = { ...this.state.errors }\n    const proposalErrors = await this.validateProposal(this.state.proposal)\n\n    if (proposalErrors !== null) {\n      this.setState({\n        errors: {\n          ...errors,\n          [key]: proposalErrors[key],\n        },\n        isValid: false,\n      })\n    }\n\n    if (proposalErrors === null) {\n      this.setState({ isValid: true, errors: null })\n    }\n  }\n\n  onFormChange = async (editorState, section) => {\n    const {\n      proposalCreationViewModel: {\n        proposal: { displayStatus },\n      },\n    } = this.props\n\n    if (displayStatus === 'edit') {\n      const { proposal } = this.state\n      proposal[section] = editorState\n      this.setState(state => ({ proposal }))\n    }\n  }\n\n  getEditorState(section) {\n    const { proposal } = this.state\n\n    return proposal[section]\n  }\n\n  handleConfirm = async e => {\n    if (e) e.preventDefault()\n    const { proposal } = this.state\n    const {\n      proposalCreationViewModel: {\n        proposal: { displayStatus },\n      },\n      next,\n    } = this.props\n\n    let errors\n\n    if (displayStatus === 'edit') {\n      errors = await this.validateProposal(proposal)\n    }\n\n    if (errors && displayStatus === 'edit') {\n      this.setState({ errors })\n\n      return\n    }\n\n    if (displayStatus === 'edit' && !errors) global.location.href = next.href\n\n    if (displayStatus === 'preview') {\n      this.setState(state => ({ showConfirm: !state.showConfirm }))\n    }\n  }\n\n  render() {\n    const {\n      pageStructure: {\n        completeProposalHintSection,\n        titleSection,\n        proposalContentSection,\n        remarksSection,\n        overlaySection,\n      },\n      proposalCreationViewModel,\n      proposalCreationViewModel: {\n        proposal: { displayStatus, conditionsHtml, conditionsHint, externalId },\n        proposalSupportersAcceptThreshold,\n      },\n      next,\n      back,\n      voteButton,\n      readAloud,\n    } = this.props\n\n    const {\n      showTopBar,\n      proposal,\n      errors,\n      error,\n      isSubmitting,\n      checkingTitle,\n      showConfirm,\n    } = this.state\n\n    const preview =\n      displayStatus === 'preview' ||\n      displayStatus === 'plainview' ||\n      displayStatus === 'available'\n\n    return (\n      <div\n        className={cx(preview && styles.preview, styles.proposalEditor)}\n        data-readaloud-ancestor\n      >\n        {displayStatus === 'available' && (\n          <TopBar\n            show={showTopBar}\n            title={proposalCreationViewModel.proposal.title}\n            voteButton={voteButton}\n            conditionsHint={\n              conditionsHtml\n                ? { label: conditionsHint, scrollTo: 'conditions' }\n                : false\n            }\n          />\n        )}\n\n        {displayStatus !== 'edit' && (\n          <ProposalStats\n            {...proposalCreationViewModel.proposal}\n            votesLimit={proposalSupportersAcceptThreshold}\n          />\n        )}\n\n        {responsive.isMobile() && displayStatus === 'available' && voteButton && (\n          <div\n            className={cx(styles.voteButton)}\n            style={{ marginBottom: '10px' }}\n          >\n            <Button primary {...voteButton} fullwidth />\n          </div>\n        )}\n\n        {conditionsHtml && (\n          <ConditionsLabel scrollTo=\"conditions\" label={conditionsHint} />\n        )}\n\n        {/* Proposal title */}\n        <section data-readaloud>\n          <MyEditor\n            readOnly={preview}\n            {...titleSection}\n            editorState={proposal.title}\n            ref={node => (this.titleEditor = node)}\n            id=\"title\"\n            handleChange={this.onFormChange}\n            blockRenderMap={Map({\n              unstyled: { element: preview ? 'h1' : 'div' },\n            })}\n            errors={errors}\n            onBlur={this.handleBlur}\n            checkingValue={checkingTitle}\n          />\n\n          {displayStatus === 'available' && (\n            <span className={styles.proposalId}>ID: {externalId}</span>\n          )}\n        </section>\n\n        {preview && readAloud ? (\n          <React.Fragment>\n            <ReadAloudButton />\n            <ReadAloudPopover />{' '}\n          </React.Fragment>\n        ) : null}\n\n        {/* Proposal description */}\n        <section data-readaloud>\n          <MyEditor\n            readOnly={preview}\n            {...proposalContentSection}\n            editorState={proposal.proposalContent}\n            ref={node => (this.proposalContentEditor = node)}\n            id=\"proposalContent\"\n            minHeight={200}\n            handleChange={this.onFormChange}\n            errors={errors}\n            onBlur={this.handleBlur}\n          />\n        </section>\n\n        {/* Proposal remarks*/}\n        <section data-readaloud>\n          <MyEditor\n            readOnly={preview}\n            {...remarksSection}\n            editorState={proposal.remarks}\n            minHeight={400}\n            ref={node => (this.remarksEditor = node)}\n            id=\"remarks\"\n            handleChange={this.onFormChange}\n            errors={errors}\n            onBlur={this.handleBlur}\n          />\n        </section>\n\n        {!preview && (\n          <p style={{ fontSize: '14px' }}>* = Felter skal udfyldes</p>\n        )}\n\n        {preview && (\n          <section>\n            <AuthorInfo author={proposalCreationViewModel.proposal.author} />\n            {proposal.coAuthors && (\n              <AuthorInfo coAuthors={proposal.coAuthors} />\n            )}\n          </section>\n        )}\n\n        {conditionsHtml && (\n          <section id=\"conditions\">\n            <ConditionsLabel label=\"Anmærkning fra Folketingets Administration\" />\n            <RichText html={conditionsHtml} />\n          </section>\n        )}\n\n        {completeProposalHintSection && (\n          <section className={cx('no-print', styles.hint)} data-readaloud>\n            <strong>{completeProposalHintSection.title}</strong>\n            <p>{completeProposalHintSection.description}</p>\n          </section>\n        )}\n\n        {(back || next) && (\n          <div\n            className={cx(\n              'no-print',\n              styles.buttonGroup,\n              'vFact_DoNotReadAloud',\n            )}\n          >\n            {back && (\n              <Button\n                onClick={this.handleGoBack}\n                flat\n                icon=\"back\"\n                label={back.label}\n                href={back.href}\n                expands\n              />\n            )}\n\n            {next && (\n              <Button\n                primary\n                label={next.label} // onClick={this.handleSave}\n                onClick={preview ? this.handleConfirm : this.handleSave}\n                loading={isSubmitting}\n                type=\"submit\"\n                expands\n              />\n            )}\n          </div>\n        )}\n\n        <ErrorMessage error={error} />\n\n        {showConfirm && (\n          <ReactModal\n            isOpen={showConfirm}\n            contentLabel=\"confirm\"\n            appElement={document.querySelector('body')}\n            overlayClassName={{\n              base: modalStyles.overlay,\n              afterOpen: modalStyles.overlayAfteropen,\n              beforeClose: '',\n            }}\n            className={{\n              base: modalStyles.modalContent,\n              afterOpen: modalStyles.afterOpen,\n              beforeClose: '',\n            }}\n            onRequestClose={this.handleToggle}\n          >\n            <div>\n              <h2 style={{ marginTop: '0px' }}>\n                {(overlaySection && overlaySection.overlayTitle) || ''}\n              </h2>\n\n              <strong>{(overlaySection && overlaySection.title) || ''}</strong>\n\n              <p>{(overlaySection && overlaySection.description) || ''}</p>\n\n              <div className={formStyles.buttonGroup}>\n                <Button\n                  flat\n                  onClick={this.handleConfirm}\n                  label={overlaySection && overlaySection.back.label}\n                  expands\n                />\n\n                <Button\n                  primary\n                  href={next.href}\n                  label={overlaySection && overlaySection.next.label}\n                  expands\n                />\n              </div>\n\n              {error && <ErrorMessage error={error} />}\n            </div>\n          </ReactModal>\n        )}\n      </div>\n    )\n  }\n}\n\nconst propTypes = {\n  checkTitleApi: PropTypes.string.isRequired,\n  proposalSupportersAcceptThreshold: PropTypes.number,\n  proposalCreationViewModel: PropTypes.shape({\n    proposal: PropTypes.shape({\n      externalId: PropTypes.string,\n      title: PropTypes.string,\n      proposalContent: PropTypes.string,\n      /** html content, comments from FT */\n      conditionsHtml: PropTypes.string,\n      conditionsHint: PropTypes.string,\n      remarks: PropTypes.string,\n      author: PropTypes.shape({\n        name: PropTypes.string,\n        email: PropTypes.string,\n        location: PropTypes.string,\n      }),\n      coAuthors: PropTypes.array,\n      potentialCoAuthors: PropTypes.arrayOf(\n        PropTypes.shape({\n          name: PropTypes.string,\n          email: PropTypes.string,\n        }),\n      ),\n      startDate: PropTypes.string,\n      endDate: PropTypes.string,\n      votes: PropTypes.number,\n      displayStatus: PropTypes.oneOf([\n        'edit',\n        'preview',\n        'plainview',\n        'available',\n      ]).isRequired,\n    }),\n    errors: PropTypes.object,\n  }).isRequired,\n  back: PropTypes.shape({\n    label: PropTypes.string,\n    href: PropTypes.string,\n  }),\n  next: PropTypes.shape({\n    label: PropTypes.string,\n    href: PropTypes.string,\n  }),\n  preview: PropTypes.bool,\n  onFormChange: PropTypes.func,\n  saveContent: PropTypes.func,\n  pageStructure: PropTypes.shape({\n    titleSection: PropTypes.shape({\n      title: PropTypes.string,\n      description: PropTypes.string,\n      maxLength: PropTypes.number,\n      error: PropTypes.string,\n    }),\n    proposalContentSection: PropTypes.shape({\n      title: PropTypes.string,\n      description: PropTypes.string,\n      maxLength: PropTypes.number,\n      error: PropTypes.string,\n    }),\n    remarksSection: PropTypes.shape({\n      title: PropTypes.string,\n      description: PropTypes.string,\n      maxLength: PropTypes.number,\n      error: PropTypes.string,\n    }),\n    overlaySection: PropTypes.shape({\n      overlayTitle: PropTypes.string,\n      title: PropTypes.string,\n      description: PropTypes.string,\n      confirmLabel: PropTypes.string,\n      cancelLabel: PropTypes.string,\n    }),\n  }),\n  voteButton: PropTypes.shape({\n    link: PropTypes.shape({\n      label: PropTypes.string.isRequired,\n      href: PropTypes.string.isRequired,\n    }),\n  }),\n  completeProposalHintSection: PropTypes.shape({\n    title: PropTypes.string,\n    description: PropTypes.string,\n  }),\n  status: PropTypes.number,\n  readAloud: PropTypes.bool,\n}\n\nProposalEditor.propTypes = propTypes\n\nexport default ProposalEditor\n\n\n\n// WEBPACK FOOTER //\n// ./src/modules/ProposalEditor/ProposalEditor.js","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule AtomicBlockUtils\n * @format\n * \n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar BlockMapBuilder = require('./BlockMapBuilder');\nvar CharacterMetadata = require('./CharacterMetadata');\nvar ContentBlock = require('./ContentBlock');\nvar ContentBlockNode = require('./ContentBlockNode');\nvar DraftFeatureFlags = require('./DraftFeatureFlags');\nvar DraftModifier = require('./DraftModifier');\nvar EditorState = require('./EditorState');\nvar Immutable = require('immutable');\nvar SelectionState = require('./SelectionState');\n\nvar generateRandomKey = require('./generateRandomKey');\nvar moveBlockInContentState = require('./moveBlockInContentState');\n\nvar experimentalTreeDataSupport = DraftFeatureFlags.draft_tree_data_support;\nvar ContentBlockRecord = experimentalTreeDataSupport ? ContentBlockNode : ContentBlock;\n\nvar List = Immutable.List,\n    Repeat = Immutable.Repeat;\n\n\nvar AtomicBlockUtils = {\n  insertAtomicBlock: function insertAtomicBlock(editorState, entityKey, character) {\n    var contentState = editorState.getCurrentContent();\n    var selectionState = editorState.getSelection();\n\n    var afterRemoval = DraftModifier.removeRange(contentState, selectionState, 'backward');\n\n    var targetSelection = afterRemoval.getSelectionAfter();\n    var afterSplit = DraftModifier.splitBlock(afterRemoval, targetSelection);\n    var insertionTarget = afterSplit.getSelectionAfter();\n\n    var asAtomicBlock = DraftModifier.setBlockType(afterSplit, insertionTarget, 'atomic');\n\n    var charData = CharacterMetadata.create({ entity: entityKey });\n\n    var atomicBlockConfig = {\n      key: generateRandomKey(),\n      type: 'atomic',\n      text: character,\n      characterList: List(Repeat(charData, character.length))\n    };\n\n    var atomicDividerBlockConfig = {\n      key: generateRandomKey(),\n      type: 'unstyled'\n    };\n\n    if (experimentalTreeDataSupport) {\n      atomicBlockConfig = _extends({}, atomicBlockConfig, {\n        nextSibling: atomicDividerBlockConfig.key\n      });\n      atomicDividerBlockConfig = _extends({}, atomicDividerBlockConfig, {\n        prevSibling: atomicBlockConfig.key\n      });\n    }\n\n    var fragmentArray = [new ContentBlockRecord(atomicBlockConfig), new ContentBlockRecord(atomicDividerBlockConfig)];\n\n    var fragment = BlockMapBuilder.createFromArray(fragmentArray);\n\n    var withAtomicBlock = DraftModifier.replaceWithFragment(asAtomicBlock, insertionTarget, fragment);\n\n    var newContent = withAtomicBlock.merge({\n      selectionBefore: selectionState,\n      selectionAfter: withAtomicBlock.getSelectionAfter().set('hasFocus', true)\n    });\n\n    return EditorState.push(editorState, newContent, 'insert-fragment');\n  },\n\n  moveAtomicBlock: function moveAtomicBlock(editorState, atomicBlock, targetRange, insertionMode) {\n    var contentState = editorState.getCurrentContent();\n    var selectionState = editorState.getSelection();\n\n    var withMovedAtomicBlock = void 0;\n\n    if (insertionMode === 'before' || insertionMode === 'after') {\n      var targetBlock = contentState.getBlockForKey(insertionMode === 'before' ? targetRange.getStartKey() : targetRange.getEndKey());\n\n      withMovedAtomicBlock = moveBlockInContentState(contentState, atomicBlock, targetBlock, insertionMode);\n    } else {\n      var afterRemoval = DraftModifier.removeRange(contentState, targetRange, 'backward');\n\n      var selectionAfterRemoval = afterRemoval.getSelectionAfter();\n      var _targetBlock = afterRemoval.getBlockForKey(selectionAfterRemoval.getFocusKey());\n\n      if (selectionAfterRemoval.getStartOffset() === 0) {\n        withMovedAtomicBlock = moveBlockInContentState(afterRemoval, atomicBlock, _targetBlock, 'before');\n      } else if (selectionAfterRemoval.getEndOffset() === _targetBlock.getLength()) {\n        withMovedAtomicBlock = moveBlockInContentState(afterRemoval, atomicBlock, _targetBlock, 'after');\n      } else {\n        var afterSplit = DraftModifier.splitBlock(afterRemoval, selectionAfterRemoval);\n\n        var selectionAfterSplit = afterSplit.getSelectionAfter();\n        var _targetBlock2 = afterSplit.getBlockForKey(selectionAfterSplit.getFocusKey());\n\n        withMovedAtomicBlock = moveBlockInContentState(afterSplit, atomicBlock, _targetBlock2, 'before');\n      }\n    }\n\n    var newContent = withMovedAtomicBlock.merge({\n      selectionBefore: selectionState,\n      selectionAfter: withMovedAtomicBlock.getSelectionAfter().set('hasFocus', true)\n    });\n\n    return EditorState.push(editorState, newContent, 'move-block');\n  }\n};\n\nmodule.exports = AtomicBlockUtils;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/AtomicBlockUtils.js\n// module id = 422\n// module chunks = 2","/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftFeatureFlags-core\n * @format\n * \n */\n\n'use strict';\n\nvar DraftFeatureFlags = {\n  draft_killswitch_allow_nontextnodes: false,\n  draft_segmented_entities_behavior: false,\n  draft_handlebeforeinput_composed_text: false,\n  draft_tree_data_support: false\n};\n\nmodule.exports = DraftFeatureFlags;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftFeatureFlags-core.js\n// module id = 423\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ContentStateInlineStyle\n * @format\n * \n */\n\n'use strict';\n\nvar CharacterMetadata = require('./CharacterMetadata');\n\nvar _require = require('immutable'),\n    Map = _require.Map;\n\nvar ContentStateInlineStyle = {\n  add: function add(contentState, selectionState, inlineStyle) {\n    return modifyInlineStyle(contentState, selectionState, inlineStyle, true);\n  },\n\n  remove: function remove(contentState, selectionState, inlineStyle) {\n    return modifyInlineStyle(contentState, selectionState, inlineStyle, false);\n  }\n};\n\nfunction modifyInlineStyle(contentState, selectionState, inlineStyle, addOrRemove) {\n  var blockMap = contentState.getBlockMap();\n  var startKey = selectionState.getStartKey();\n  var startOffset = selectionState.getStartOffset();\n  var endKey = selectionState.getEndKey();\n  var endOffset = selectionState.getEndOffset();\n\n  var newBlocks = blockMap.skipUntil(function (_, k) {\n    return k === startKey;\n  }).takeUntil(function (_, k) {\n    return k === endKey;\n  }).concat(Map([[endKey, blockMap.get(endKey)]])).map(function (block, blockKey) {\n    var sliceStart;\n    var sliceEnd;\n\n    if (startKey === endKey) {\n      sliceStart = startOffset;\n      sliceEnd = endOffset;\n    } else {\n      sliceStart = blockKey === startKey ? startOffset : 0;\n      sliceEnd = blockKey === endKey ? endOffset : block.getLength();\n    }\n\n    var chars = block.getCharacterList();\n    var current;\n    while (sliceStart < sliceEnd) {\n      current = chars.get(sliceStart);\n      chars = chars.set(sliceStart, addOrRemove ? CharacterMetadata.applyStyle(current, inlineStyle) : CharacterMetadata.removeStyle(current, inlineStyle));\n      sliceStart++;\n    }\n\n    return block.set('characterList', chars);\n  });\n\n  return contentState.merge({\n    blockMap: blockMap.merge(newBlocks),\n    selectionBefore: selectionState,\n    selectionAfter: selectionState\n  });\n}\n\nmodule.exports = ContentStateInlineStyle;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/ContentStateInlineStyle.js\n// module id = 424\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule applyEntityToContentState\n * @format\n * \n */\n\n'use strict';\n\nvar Immutable = require('immutable');\n\nvar applyEntityToContentBlock = require('./applyEntityToContentBlock');\n\nfunction applyEntityToContentState(contentState, selectionState, entityKey) {\n  var blockMap = contentState.getBlockMap();\n  var startKey = selectionState.getStartKey();\n  var startOffset = selectionState.getStartOffset();\n  var endKey = selectionState.getEndKey();\n  var endOffset = selectionState.getEndOffset();\n\n  var newBlocks = blockMap.skipUntil(function (_, k) {\n    return k === startKey;\n  }).takeUntil(function (_, k) {\n    return k === endKey;\n  }).toOrderedMap().merge(Immutable.OrderedMap([[endKey, blockMap.get(endKey)]])).map(function (block, blockKey) {\n    var sliceStart = blockKey === startKey ? startOffset : 0;\n    var sliceEnd = blockKey === endKey ? endOffset : block.getLength();\n    return applyEntityToContentBlock(block, sliceStart, sliceEnd, entityKey);\n  });\n\n  return contentState.merge({\n    blockMap: blockMap.merge(newBlocks),\n    selectionBefore: selectionState,\n    selectionAfter: selectionState\n  });\n}\n\nmodule.exports = applyEntityToContentState;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/applyEntityToContentState.js\n// module id = 425\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule applyEntityToContentBlock\n * @format\n * \n */\n\n'use strict';\n\nvar CharacterMetadata = require('./CharacterMetadata');\n\nfunction applyEntityToContentBlock(contentBlock, start, end, entityKey) {\n  var characterList = contentBlock.getCharacterList();\n  while (start < end) {\n    characterList = characterList.set(start, CharacterMetadata.applyEntity(characterList.get(start), entityKey));\n    start++;\n  }\n  return contentBlock.set('characterList', characterList);\n}\n\nmodule.exports = applyEntityToContentBlock;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/applyEntityToContentBlock.js\n// module id = 426\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getCharacterRemovalRange\n * @format\n * \n */\n\n'use strict';\n\nvar DraftEntitySegments = require('./DraftEntitySegments');\n\nvar getRangesForDraftEntity = require('./getRangesForDraftEntity');\nvar invariant = require('fbjs/lib/invariant');\n\n/**\n * Given a SelectionState and a removal direction, determine the entire range\n * that should be removed from a ContentState. This is based on any entities\n * within the target, with their `mutability` values taken into account.\n *\n * For instance, if we are attempting to remove part of an \"immutable\" entity\n * range, the entire entity must be removed. The returned `SelectionState`\n * will be adjusted accordingly.\n */\nfunction getCharacterRemovalRange(entityMap, startBlock, endBlock, selectionState, direction) {\n  var start = selectionState.getStartOffset();\n  var end = selectionState.getEndOffset();\n  var startEntityKey = startBlock.getEntityAt(start);\n  var endEntityKey = endBlock.getEntityAt(end - 1);\n  if (!startEntityKey && !endEntityKey) {\n    return selectionState;\n  }\n  var newSelectionState = selectionState;\n  if (startEntityKey && startEntityKey === endEntityKey) {\n    newSelectionState = getEntityRemovalRange(entityMap, startBlock, newSelectionState, direction, startEntityKey, true, true);\n  } else if (startEntityKey && endEntityKey) {\n    var startSelectionState = getEntityRemovalRange(entityMap, startBlock, newSelectionState, direction, startEntityKey, false, true);\n    var endSelectionState = getEntityRemovalRange(entityMap, endBlock, newSelectionState, direction, endEntityKey, false, false);\n    newSelectionState = newSelectionState.merge({\n      anchorOffset: startSelectionState.getAnchorOffset(),\n      focusOffset: endSelectionState.getFocusOffset(),\n      isBackward: false\n    });\n  } else if (startEntityKey) {\n    var _startSelectionState = getEntityRemovalRange(entityMap, startBlock, newSelectionState, direction, startEntityKey, false, true);\n    newSelectionState = newSelectionState.merge({\n      anchorOffset: _startSelectionState.getStartOffset(),\n      isBackward: false\n    });\n  } else if (endEntityKey) {\n    var _endSelectionState = getEntityRemovalRange(entityMap, endBlock, newSelectionState, direction, endEntityKey, false, false);\n    newSelectionState = newSelectionState.merge({\n      focusOffset: _endSelectionState.getEndOffset(),\n      isBackward: false\n    });\n  }\n  return newSelectionState;\n}\n\nfunction getEntityRemovalRange(entityMap, block, selectionState, direction, entityKey, isEntireSelectionWithinEntity, isEntityAtStart) {\n  var start = selectionState.getStartOffset();\n  var end = selectionState.getEndOffset();\n  var entity = entityMap.__get(entityKey);\n  var mutability = entity.getMutability();\n  var sideToConsider = isEntityAtStart ? start : end;\n\n  // `MUTABLE` entities can just have the specified range of text removed\n  // directly. No adjustments are needed.\n  if (mutability === 'MUTABLE') {\n    return selectionState;\n  }\n\n  // Find the entity range that overlaps with our removal range.\n  var entityRanges = getRangesForDraftEntity(block, entityKey).filter(function (range) {\n    return sideToConsider <= range.end && sideToConsider >= range.start;\n  });\n\n  !(entityRanges.length == 1) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'There should only be one entity range within this removal range.') : invariant(false) : void 0;\n\n  var entityRange = entityRanges[0];\n\n  // For `IMMUTABLE` entity types, we will remove the entire entity range.\n  if (mutability === 'IMMUTABLE') {\n    return selectionState.merge({\n      anchorOffset: entityRange.start,\n      focusOffset: entityRange.end,\n      isBackward: false\n    });\n  }\n\n  // For `SEGMENTED` entity types, determine the appropriate segment to\n  // remove.\n  if (!isEntireSelectionWithinEntity) {\n    if (isEntityAtStart) {\n      end = entityRange.end;\n    } else {\n      start = entityRange.start;\n    }\n  }\n\n  var removalRange = DraftEntitySegments.getRemovalRange(start, end, block.getText().slice(entityRange.start, entityRange.end), entityRange.start, direction);\n\n  return selectionState.merge({\n    anchorOffset: removalRange.start,\n    focusOffset: removalRange.end,\n    isBackward: false\n  });\n}\n\nmodule.exports = getCharacterRemovalRange;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getCharacterRemovalRange.js\n// module id = 427\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEntitySegments\n * @format\n * \n */\n\n'use strict';\n\n/**\n * Identify the range to delete from a segmented entity.\n *\n * Rules:\n *\n *  Example: 'John F. Kennedy'\n *\n *   - Deletion from within any non-whitespace (i.e. ['John', 'F.', 'Kennedy'])\n *     will return the range of that text.\n *\n *       'John F. Kennedy' -> 'John F.'\n *                  ^\n *\n *   - Forward deletion of whitespace will remove the following section:\n *\n *       'John F. Kennedy' -> 'John Kennedy'\n *            ^\n *\n *   - Backward deletion of whitespace will remove the previous section:\n *\n *       'John F. Kennedy' -> 'F. Kennedy'\n *            ^\n */\nvar DraftEntitySegments = {\n  getRemovalRange: function getRemovalRange(selectionStart, selectionEnd, text, entityStart, direction) {\n    var segments = text.split(' ');\n    segments = segments.map(function ( /*string*/segment, /*number*/ii) {\n      if (direction === 'forward') {\n        if (ii > 0) {\n          return ' ' + segment;\n        }\n      } else if (ii < segments.length - 1) {\n        return segment + ' ';\n      }\n      return segment;\n    });\n\n    var segmentStart = entityStart;\n    var segmentEnd;\n    var segment;\n    var removalStart = null;\n    var removalEnd = null;\n\n    for (var jj = 0; jj < segments.length; jj++) {\n      segment = segments[jj];\n      segmentEnd = segmentStart + segment.length;\n\n      // Our selection overlaps this segment.\n      if (selectionStart < segmentEnd && segmentStart < selectionEnd) {\n        if (removalStart !== null) {\n          removalEnd = segmentEnd;\n        } else {\n          removalStart = segmentStart;\n          removalEnd = segmentEnd;\n        }\n      } else if (removalStart !== null) {\n        break;\n      }\n\n      segmentStart = segmentEnd;\n    }\n\n    var entityEnd = entityStart + text.length;\n    var atStart = removalStart === entityStart;\n    var atEnd = removalEnd === entityEnd;\n\n    if (!atStart && atEnd || atStart && !atEnd) {\n      if (direction === 'forward') {\n        if (removalEnd !== entityEnd) {\n          removalEnd++;\n        }\n      } else if (removalStart !== entityStart) {\n        removalStart--;\n      }\n    }\n\n    return {\n      start: removalStart,\n      end: removalEnd\n    };\n  }\n};\n\nmodule.exports = DraftEntitySegments;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftEntitySegments.js\n// module id = 428\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getRangesForDraftEntity\n * @format\n * \n */\n\n'use strict';\n\nvar invariant = require('fbjs/lib/invariant');\n\n/**\n * Obtain the start and end positions of the range that has the\n * specified entity applied to it.\n *\n * Entity keys are applied only to contiguous stretches of text, so this\n * method searches for the first instance of the entity key and returns\n * the subsequent range.\n */\nfunction getRangesForDraftEntity(block, key) {\n  var ranges = [];\n  block.findEntityRanges(function (c) {\n    return c.getEntity() === key;\n  }, function (start, end) {\n    ranges.push({ start: start, end: end });\n  });\n\n  !!!ranges.length ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Entity key not found in this range.') : invariant(false) : void 0;\n\n  return ranges;\n}\n\nmodule.exports = getRangesForDraftEntity;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getRangesForDraftEntity.js\n// module id = 429\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule insertFragmentIntoContentState\n * @format\n * \n */\n\n'use strict';\n\nvar BlockMapBuilder = require('./BlockMapBuilder');\nvar ContentBlockNode = require('./ContentBlockNode');\nvar Immutable = require('immutable');\n\nvar insertIntoList = require('./insertIntoList');\nvar invariant = require('fbjs/lib/invariant');\nvar randomizeBlockMapKeys = require('./randomizeBlockMapKeys');\n\nvar List = Immutable.List;\n\n\nvar updateExistingBlock = function updateExistingBlock(contentState, selectionState, blockMap, fragmentBlock, targetKey, targetOffset) {\n  var targetBlock = blockMap.get(targetKey);\n  var text = targetBlock.getText();\n  var chars = targetBlock.getCharacterList();\n  var finalKey = targetKey;\n  var finalOffset = targetOffset + fragmentBlock.getText().length;\n\n  var newBlock = targetBlock.merge({\n    text: text.slice(0, targetOffset) + fragmentBlock.getText() + text.slice(targetOffset),\n    characterList: insertIntoList(chars, fragmentBlock.getCharacterList(), targetOffset),\n    data: fragmentBlock.getData()\n  });\n\n  return contentState.merge({\n    blockMap: blockMap.set(targetKey, newBlock),\n    selectionBefore: selectionState,\n    selectionAfter: selectionState.merge({\n      anchorKey: finalKey,\n      anchorOffset: finalOffset,\n      focusKey: finalKey,\n      focusOffset: finalOffset,\n      isBackward: false\n    })\n  });\n};\n\n/**\n * Appends text/characterList from the fragment first block to\n * target block.\n */\nvar updateHead = function updateHead(block, targetOffset, fragment) {\n  var text = block.getText();\n  var chars = block.getCharacterList();\n\n  // Modify head portion of block.\n  var headText = text.slice(0, targetOffset);\n  var headCharacters = chars.slice(0, targetOffset);\n  var appendToHead = fragment.first();\n\n  return block.merge({\n    text: headText + appendToHead.getText(),\n    characterList: headCharacters.concat(appendToHead.getCharacterList()),\n    type: headText ? block.getType() : appendToHead.getType(),\n    data: appendToHead.getData()\n  });\n};\n\n/**\n * Appends offset text/characterList from the target block to the last\n * fragment block.\n */\nvar updateTail = function updateTail(block, targetOffset, fragment) {\n  // Modify tail portion of block.\n  var text = block.getText();\n  var chars = block.getCharacterList();\n\n  // Modify head portion of block.\n  var blockSize = text.length;\n  var tailText = text.slice(targetOffset, blockSize);\n  var tailCharacters = chars.slice(targetOffset, blockSize);\n  var prependToTail = fragment.last();\n\n  return prependToTail.merge({\n    text: prependToTail.getText() + tailText,\n    characterList: prependToTail.getCharacterList().concat(tailCharacters),\n    data: prependToTail.getData()\n  });\n};\n\nvar getRootBlocks = function getRootBlocks(block, blockMap) {\n  var headKey = block.getKey();\n  var rootBlock = block;\n  var rootBlocks = [];\n\n  // sometimes the fragment head block will not be part of the blockMap itself this can happen when\n  // the fragment head is used to update the target block, however when this does not happen we need\n  // to make sure that we include it on the rootBlocks since the first block of a fragment is always a\n  // fragment root block\n  if (blockMap.get(headKey)) {\n    rootBlocks.push(headKey);\n  }\n\n  while (rootBlock && rootBlock.getNextSiblingKey()) {\n    var lastSiblingKey = rootBlock.getNextSiblingKey();\n\n    if (!lastSiblingKey) {\n      break;\n    }\n\n    rootBlocks.push(lastSiblingKey);\n    rootBlock = blockMap.get(lastSiblingKey);\n  }\n\n  return rootBlocks;\n};\n\nvar updateBlockMapLinks = function updateBlockMapLinks(blockMap, originalBlockMap, targetBlock, fragmentHeadBlock) {\n  return blockMap.withMutations(function (blockMapState) {\n    var targetKey = targetBlock.getKey();\n    var headKey = fragmentHeadBlock.getKey();\n    var targetNextKey = targetBlock.getNextSiblingKey();\n    var targetParentKey = targetBlock.getParentKey();\n    var fragmentRootBlocks = getRootBlocks(fragmentHeadBlock, blockMap);\n    var lastRootFragmentBlockKey = fragmentRootBlocks[fragmentRootBlocks.length - 1];\n\n    if (blockMapState.get(headKey)) {\n      // update the fragment head when it is part of the blockMap otherwise\n      blockMapState.setIn([targetKey, 'nextSibling'], headKey);\n      blockMapState.setIn([headKey, 'prevSibling'], targetKey);\n    } else {\n      // update the target block that had the fragment head contents merged into it\n      blockMapState.setIn([targetKey, 'nextSibling'], fragmentHeadBlock.getNextSiblingKey());\n      blockMapState.setIn([fragmentHeadBlock.getNextSiblingKey(), 'prevSibling'], targetKey);\n    }\n\n    // update the last root block fragment\n    blockMapState.setIn([lastRootFragmentBlockKey, 'nextSibling'], targetNextKey);\n\n    // update the original target next block\n    if (targetNextKey) {\n      blockMapState.setIn([targetNextKey, 'prevSibling'], lastRootFragmentBlockKey);\n    }\n\n    // update fragment parent links\n    fragmentRootBlocks.forEach(function (blockKey) {\n      return blockMapState.setIn([blockKey, 'parent'], targetParentKey);\n    });\n\n    // update targetBlock parent child links\n    if (targetParentKey) {\n      var targetParent = blockMap.get(targetParentKey);\n      var originalTargetParentChildKeys = targetParent.getChildKeys();\n\n      var targetBlockIndex = originalTargetParentChildKeys.indexOf(targetKey);\n      var insertionIndex = targetBlockIndex + 1;\n\n      var newChildrenKeysArray = originalTargetParentChildKeys.toArray();\n\n      // insert fragment children\n      newChildrenKeysArray.splice.apply(newChildrenKeysArray, [insertionIndex, 0].concat(fragmentRootBlocks));\n\n      blockMapState.setIn([targetParentKey, 'children'], List(newChildrenKeysArray));\n    }\n  });\n};\n\nvar insertFragment = function insertFragment(contentState, selectionState, blockMap, fragment, targetKey, targetOffset) {\n  var isTreeBasedBlockMap = blockMap.first() instanceof ContentBlockNode;\n  var newBlockArr = [];\n  var fragmentSize = fragment.size;\n  var target = blockMap.get(targetKey);\n  var head = fragment.first();\n  var tail = fragment.last();\n  var finalOffset = tail.getLength();\n  var finalKey = tail.getKey();\n  var shouldNotUpdateFromFragmentBlock = isTreeBasedBlockMap && (!target.getChildKeys().isEmpty() || !head.getChildKeys().isEmpty());\n\n  blockMap.forEach(function (block, blockKey) {\n    if (blockKey !== targetKey) {\n      newBlockArr.push(block);\n      return;\n    }\n\n    if (shouldNotUpdateFromFragmentBlock) {\n      newBlockArr.push(block);\n    } else {\n      newBlockArr.push(updateHead(block, targetOffset, fragment));\n    }\n\n    // Insert fragment blocks after the head and before the tail.\n    fragment\n    // when we are updating the target block with the head fragment block we skip the first fragment\n    // head since its contents have already been merged with the target block otherwise we include\n    // the whole fragment\n    .slice(shouldNotUpdateFromFragmentBlock ? 0 : 1, fragmentSize - 1).forEach(function (fragmentBlock) {\n      return newBlockArr.push(fragmentBlock);\n    });\n\n    // update tail\n    newBlockArr.push(updateTail(block, targetOffset, fragment));\n  });\n\n  var updatedBlockMap = BlockMapBuilder.createFromArray(newBlockArr);\n\n  if (isTreeBasedBlockMap) {\n    updatedBlockMap = updateBlockMapLinks(updatedBlockMap, blockMap, target, head);\n  }\n\n  return contentState.merge({\n    blockMap: updatedBlockMap,\n    selectionBefore: selectionState,\n    selectionAfter: selectionState.merge({\n      anchorKey: finalKey,\n      anchorOffset: finalOffset,\n      focusKey: finalKey,\n      focusOffset: finalOffset,\n      isBackward: false\n    })\n  });\n};\n\nvar insertFragmentIntoContentState = function insertFragmentIntoContentState(contentState, selectionState, fragmentBlockMap) {\n  !selectionState.isCollapsed() ? process.env.NODE_ENV !== 'production' ? invariant(false, '`insertFragment` should only be called with a collapsed selection state.') : invariant(false) : void 0;\n\n  var blockMap = contentState.getBlockMap();\n  var fragment = randomizeBlockMapKeys(fragmentBlockMap);\n  var targetKey = selectionState.getStartKey();\n  var targetOffset = selectionState.getStartOffset();\n\n  var targetBlock = blockMap.get(targetKey);\n\n  if (targetBlock instanceof ContentBlockNode) {\n    !targetBlock.getChildKeys().isEmpty() ? process.env.NODE_ENV !== 'production' ? invariant(false, '`insertFragment` should not be called when a container node is selected.') : invariant(false) : void 0;\n  }\n\n  // When we insert a fragment with a single block we simply update the target block\n  // with the contents of the inserted fragment block\n  if (fragment.size === 1) {\n    return updateExistingBlock(contentState, selectionState, blockMap, fragment.first(), targetKey, targetOffset);\n  }\n\n  return insertFragment(contentState, selectionState, blockMap, fragment, targetKey, targetOffset);\n};\n\nmodule.exports = insertFragmentIntoContentState;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/insertFragmentIntoContentState.js\n// module id = 430\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule insertTextIntoContentState\n * @format\n * \n */\n\n'use strict';\n\nvar Immutable = require('immutable');\n\nvar insertIntoList = require('./insertIntoList');\nvar invariant = require('fbjs/lib/invariant');\n\nvar Repeat = Immutable.Repeat;\n\n\nfunction insertTextIntoContentState(contentState, selectionState, text, characterMetadata) {\n  !selectionState.isCollapsed() ? process.env.NODE_ENV !== 'production' ? invariant(false, '`insertText` should only be called with a collapsed range.') : invariant(false) : void 0;\n\n  var len = text.length;\n  if (!len) {\n    return contentState;\n  }\n\n  var blockMap = contentState.getBlockMap();\n  var key = selectionState.getStartKey();\n  var offset = selectionState.getStartOffset();\n  var block = blockMap.get(key);\n  var blockText = block.getText();\n\n  var newBlock = block.merge({\n    text: blockText.slice(0, offset) + text + blockText.slice(offset, block.getLength()),\n    characterList: insertIntoList(block.getCharacterList(), Repeat(characterMetadata, len).toList(), offset)\n  });\n\n  var newOffset = offset + len;\n\n  return contentState.merge({\n    blockMap: blockMap.set(key, newBlock),\n    selectionAfter: selectionState.merge({\n      anchorOffset: newOffset,\n      focusOffset: newOffset\n    })\n  });\n}\n\nmodule.exports = insertTextIntoContentState;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/insertTextIntoContentState.js\n// module id = 431\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule modifyBlockForContentState\n * @format\n * \n */\n\n'use strict';\n\nvar Immutable = require('immutable');\n\nvar Map = Immutable.Map;\n\n\nfunction modifyBlockForContentState(contentState, selectionState, operation) {\n  var startKey = selectionState.getStartKey();\n  var endKey = selectionState.getEndKey();\n  var blockMap = contentState.getBlockMap();\n  var newBlocks = blockMap.toSeq().skipUntil(function (_, k) {\n    return k === startKey;\n  }).takeUntil(function (_, k) {\n    return k === endKey;\n  }).concat(Map([[endKey, blockMap.get(endKey)]])).map(operation);\n\n  return contentState.merge({\n    blockMap: blockMap.merge(newBlocks),\n    selectionBefore: selectionState,\n    selectionAfter: selectionState\n  });\n}\n\nmodule.exports = modifyBlockForContentState;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/modifyBlockForContentState.js\n// module id = 432\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule removeRangeFromContentState\n * @format\n * \n */\n\n'use strict';\n\nvar ContentBlockNode = require('./ContentBlockNode');\nvar Immutable = require('immutable');\n\nvar getNextDelimiterBlockKey = require('./getNextDelimiterBlockKey');\n\nvar List = Immutable.List,\n    Map = Immutable.Map;\n\n\nvar transformBlock = function transformBlock(key, blockMap, func) {\n  if (!key) {\n    return;\n  }\n\n  var block = blockMap.get(key);\n\n  if (!block) {\n    return;\n  }\n\n  blockMap.set(key, func(block));\n};\n\n/**\n * Ancestors needs to be preserved when there are non selected\n * children to make sure we do not leave any orphans behind\n */\nvar getAncestorsKeys = function getAncestorsKeys(blockKey, blockMap) {\n  var parents = [];\n\n  if (!blockKey) {\n    return parents;\n  }\n\n  var blockNode = blockMap.get(blockKey);\n  while (blockNode && blockNode.getParentKey()) {\n    var parentKey = blockNode.getParentKey();\n    if (parentKey) {\n      parents.push(parentKey);\n    }\n    blockNode = parentKey ? blockMap.get(parentKey) : null;\n  }\n\n  return parents;\n};\n\n/**\n * Get all next delimiter keys until we hit a root delimiter and return\n * an array of key references\n */\nvar getNextDelimitersBlockKeys = function getNextDelimitersBlockKeys(block, blockMap) {\n  var nextDelimiters = [];\n\n  if (!block) {\n    return nextDelimiters;\n  }\n\n  var nextDelimiter = getNextDelimiterBlockKey(block, blockMap);\n  while (nextDelimiter && blockMap.get(nextDelimiter)) {\n    var _block = blockMap.get(nextDelimiter);\n    nextDelimiters.push(nextDelimiter);\n\n    // we do not need to keep checking all root node siblings, just the first occurance\n    nextDelimiter = _block.getParentKey() ? getNextDelimiterBlockKey(_block, blockMap) : null;\n  }\n\n  return nextDelimiters;\n};\n\nvar getNextValidSibling = function getNextValidSibling(block, blockMap, originalBlockMap) {\n  if (!block) {\n    return null;\n  }\n\n  // note that we need to make sure we refer to the original block since this\n  // function is called within a withMutations\n  var nextValidSiblingKey = originalBlockMap.get(block.getKey()).getNextSiblingKey();\n\n  while (nextValidSiblingKey && !blockMap.get(nextValidSiblingKey)) {\n    nextValidSiblingKey = originalBlockMap.get(nextValidSiblingKey).getNextSiblingKey() || null;\n  }\n\n  return nextValidSiblingKey;\n};\n\nvar getPrevValidSibling = function getPrevValidSibling(block, blockMap, originalBlockMap) {\n  if (!block) {\n    return null;\n  }\n\n  // note that we need to make sure we refer to the original block since this\n  // function is called within a withMutations\n  var prevValidSiblingKey = originalBlockMap.get(block.getKey()).getPrevSiblingKey();\n\n  while (prevValidSiblingKey && !blockMap.get(prevValidSiblingKey)) {\n    prevValidSiblingKey = originalBlockMap.get(prevValidSiblingKey).getPrevSiblingKey() || null;\n  }\n\n  return prevValidSiblingKey;\n};\n\nvar updateBlockMapLinks = function updateBlockMapLinks(blockMap, startBlock, endBlock, originalBlockMap) {\n  return blockMap.withMutations(function (blocks) {\n    // update start block if its retained\n    transformBlock(startBlock.getKey(), blocks, function (block) {\n      return block.merge({\n        nextSibling: getNextValidSibling(startBlock, blocks, originalBlockMap),\n        prevSibling: getPrevValidSibling(startBlock, blocks, originalBlockMap)\n      });\n    });\n\n    // update endblock if its retained\n    transformBlock(endBlock.getKey(), blocks, function (block) {\n      return block.merge({\n        nextSibling: getNextValidSibling(endBlock, blocks, originalBlockMap),\n        prevSibling: getPrevValidSibling(endBlock, blocks, originalBlockMap)\n      });\n    });\n\n    // update start block parent ancestors\n    getAncestorsKeys(startBlock.getKey(), originalBlockMap).forEach(function (parentKey) {\n      return transformBlock(parentKey, blocks, function (block) {\n        return block.merge({\n          children: block.getChildKeys().filter(function (key) {\n            return blocks.get(key);\n          }),\n          nextSibling: getNextValidSibling(block, blocks, originalBlockMap),\n          prevSibling: getPrevValidSibling(block, blocks, originalBlockMap)\n        });\n      });\n    });\n\n    // update start block next - can only happen if startBlock == endBlock\n    transformBlock(startBlock.getNextSiblingKey(), blocks, function (block) {\n      return block.merge({\n        prevSibling: startBlock.getPrevSiblingKey()\n      });\n    });\n\n    // update start block prev\n    transformBlock(startBlock.getPrevSiblingKey(), blocks, function (block) {\n      return block.merge({\n        nextSibling: getNextValidSibling(startBlock, blocks, originalBlockMap)\n      });\n    });\n\n    // update end block next\n    transformBlock(endBlock.getNextSiblingKey(), blocks, function (block) {\n      return block.merge({\n        prevSibling: getPrevValidSibling(endBlock, blocks, originalBlockMap)\n      });\n    });\n\n    // update end block prev\n    transformBlock(endBlock.getPrevSiblingKey(), blocks, function (block) {\n      return block.merge({\n        nextSibling: endBlock.getNextSiblingKey()\n      });\n    });\n\n    // update end block parent ancestors\n    getAncestorsKeys(endBlock.getKey(), originalBlockMap).forEach(function (parentKey) {\n      transformBlock(parentKey, blocks, function (block) {\n        return block.merge({\n          children: block.getChildKeys().filter(function (key) {\n            return blocks.get(key);\n          }),\n          nextSibling: getNextValidSibling(block, blocks, originalBlockMap),\n          prevSibling: getPrevValidSibling(block, blocks, originalBlockMap)\n        });\n      });\n    });\n\n    // update next delimiters all the way to a root delimiter\n    getNextDelimitersBlockKeys(endBlock, originalBlockMap).forEach(function (delimiterKey) {\n      return transformBlock(delimiterKey, blocks, function (block) {\n        return block.merge({\n          nextSibling: getNextValidSibling(block, blocks, originalBlockMap),\n          prevSibling: getPrevValidSibling(block, blocks, originalBlockMap)\n        });\n      });\n    });\n  });\n};\n\nvar removeRangeFromContentState = function removeRangeFromContentState(contentState, selectionState) {\n  if (selectionState.isCollapsed()) {\n    return contentState;\n  }\n\n  var blockMap = contentState.getBlockMap();\n  var startKey = selectionState.getStartKey();\n  var startOffset = selectionState.getStartOffset();\n  var endKey = selectionState.getEndKey();\n  var endOffset = selectionState.getEndOffset();\n\n  var startBlock = blockMap.get(startKey);\n  var endBlock = blockMap.get(endKey);\n\n  // we assume that ContentBlockNode and ContentBlocks are not mixed together\n  var isExperimentalTreeBlock = startBlock instanceof ContentBlockNode;\n\n  // used to retain blocks that should not be deleted to avoid orphan children\n  var parentAncestors = [];\n\n  if (isExperimentalTreeBlock) {\n    var endBlockchildrenKeys = endBlock.getChildKeys();\n    var endBlockAncestors = getAncestorsKeys(endKey, blockMap);\n\n    // endBlock has unselected sibblings so we can not remove its ancestors parents\n    if (endBlock.getNextSiblingKey()) {\n      parentAncestors = parentAncestors.concat(endBlockAncestors);\n    }\n\n    // endBlock has children so can not remove this block or any of its ancestors\n    if (!endBlockchildrenKeys.isEmpty()) {\n      parentAncestors = parentAncestors.concat(endBlockAncestors.concat([endKey]));\n    }\n\n    // we need to retain all ancestors of the next delimiter block\n    parentAncestors = parentAncestors.concat(getAncestorsKeys(getNextDelimiterBlockKey(endBlock, blockMap), blockMap));\n  }\n\n  var characterList = void 0;\n\n  if (startBlock === endBlock) {\n    characterList = removeFromList(startBlock.getCharacterList(), startOffset, endOffset);\n  } else {\n    characterList = startBlock.getCharacterList().slice(0, startOffset).concat(endBlock.getCharacterList().slice(endOffset));\n  }\n\n  var modifiedStart = startBlock.merge({\n    text: startBlock.getText().slice(0, startOffset) + endBlock.getText().slice(endOffset),\n    characterList: characterList\n  });\n\n  var newBlocks = blockMap.toSeq().skipUntil(function (_, k) {\n    return k === startKey;\n  }).takeUntil(function (_, k) {\n    return k === endKey;\n  }).filter(function (_, k) {\n    return parentAncestors.indexOf(k) === -1;\n  }).concat(Map([[endKey, null]])).map(function (_, k) {\n    return k === startKey ? modifiedStart : null;\n  });\n\n  var updatedBlockMap = blockMap.merge(newBlocks).filter(function (block) {\n    return !!block;\n  });\n\n  if (isExperimentalTreeBlock) {\n    updatedBlockMap = updateBlockMapLinks(updatedBlockMap, startBlock, endBlock, blockMap);\n  }\n\n  return contentState.merge({\n    blockMap: updatedBlockMap,\n    selectionBefore: selectionState,\n    selectionAfter: selectionState.merge({\n      anchorKey: startKey,\n      anchorOffset: startOffset,\n      focusKey: startKey,\n      focusOffset: startOffset,\n      isBackward: false\n    })\n  });\n};\n\n/**\n * Maintain persistence for target list when removing characters on the\n * head and tail of the character list.\n */\nvar removeFromList = function removeFromList(targetList, startOffset, endOffset) {\n  if (startOffset === 0) {\n    while (startOffset < endOffset) {\n      targetList = targetList.shift();\n      startOffset++;\n    }\n  } else if (endOffset === targetList.count()) {\n    while (endOffset > startOffset) {\n      targetList = targetList.pop();\n      endOffset--;\n    }\n  } else {\n    var head = targetList.slice(0, startOffset);\n    var tail = targetList.slice(endOffset);\n    targetList = head.concat(tail).toList();\n  }\n  return targetList;\n};\n\nmodule.exports = removeRangeFromContentState;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/removeRangeFromContentState.js\n// module id = 433\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule splitBlockInContentState\n * @format\n * \n */\n\n'use strict';\n\nvar ContentBlockNode = require('./ContentBlockNode');\nvar Immutable = require('immutable');\n\nvar generateRandomKey = require('./generateRandomKey');\nvar invariant = require('fbjs/lib/invariant');\n\nvar List = Immutable.List,\n    Map = Immutable.Map;\n\n\nvar transformBlock = function transformBlock(key, blockMap, func) {\n  if (!key) {\n    return;\n  }\n\n  var block = blockMap.get(key);\n\n  if (!block) {\n    return;\n  }\n\n  blockMap.set(key, func(block));\n};\n\nvar updateBlockMapLinks = function updateBlockMapLinks(blockMap, originalBlock, belowBlock) {\n  return blockMap.withMutations(function (blocks) {\n    var originalBlockKey = originalBlock.getKey();\n    var belowBlockKey = belowBlock.getKey();\n\n    // update block parent\n    transformBlock(originalBlock.getParentKey(), blocks, function (block) {\n      var parentChildrenList = block.getChildKeys();\n      var insertionIndex = parentChildrenList.indexOf(originalBlockKey) + 1;\n      var newChildrenArray = parentChildrenList.toArray();\n\n      newChildrenArray.splice(insertionIndex, 0, belowBlockKey);\n\n      return block.merge({\n        children: List(newChildrenArray)\n      });\n    });\n\n    // update original next block\n    transformBlock(originalBlock.getNextSiblingKey(), blocks, function (block) {\n      return block.merge({\n        prevSibling: belowBlockKey\n      });\n    });\n\n    // update original block\n    transformBlock(originalBlockKey, blocks, function (block) {\n      return block.merge({\n        nextSibling: belowBlockKey\n      });\n    });\n\n    // update below block\n    transformBlock(belowBlockKey, blocks, function (block) {\n      return block.merge({\n        prevSibling: originalBlockKey\n      });\n    });\n  });\n};\n\nvar splitBlockInContentState = function splitBlockInContentState(contentState, selectionState) {\n  !selectionState.isCollapsed() ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Selection range must be collapsed.') : invariant(false) : void 0;\n\n  var key = selectionState.getAnchorKey();\n  var offset = selectionState.getAnchorOffset();\n  var blockMap = contentState.getBlockMap();\n  var blockToSplit = blockMap.get(key);\n  var text = blockToSplit.getText();\n  var chars = blockToSplit.getCharacterList();\n  var keyBelow = generateRandomKey();\n  var isExperimentalTreeBlock = blockToSplit instanceof ContentBlockNode;\n\n  var blockAbove = blockToSplit.merge({\n    text: text.slice(0, offset),\n    characterList: chars.slice(0, offset)\n  });\n  var blockBelow = blockAbove.merge({\n    key: keyBelow,\n    text: text.slice(offset),\n    characterList: chars.slice(offset),\n    data: Map()\n  });\n\n  var blocksBefore = blockMap.toSeq().takeUntil(function (v) {\n    return v === blockToSplit;\n  });\n  var blocksAfter = blockMap.toSeq().skipUntil(function (v) {\n    return v === blockToSplit;\n  }).rest();\n  var newBlocks = blocksBefore.concat([[key, blockAbove], [keyBelow, blockBelow]], blocksAfter).toOrderedMap();\n\n  if (isExperimentalTreeBlock) {\n    !blockToSplit.getChildKeys().isEmpty() ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ContentBlockNode must not have children') : invariant(false) : void 0;\n\n    newBlocks = updateBlockMapLinks(newBlocks, blockAbove, blockBelow);\n  }\n\n  return contentState.merge({\n    blockMap: newBlocks,\n    selectionBefore: selectionState,\n    selectionAfter: selectionState.merge({\n      anchorKey: keyBelow,\n      anchorOffset: 0,\n      focusKey: keyBelow,\n      focusOffset: 0,\n      isBackward: false\n    })\n  });\n};\n\nmodule.exports = splitBlockInContentState;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/splitBlockInContentState.js\n// module id = 434\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule EditorBidiService\n * @format\n * \n */\n\n'use strict';\n\nvar Immutable = require('immutable');\nvar UnicodeBidiService = require('fbjs/lib/UnicodeBidiService');\n\nvar nullthrows = require('fbjs/lib/nullthrows');\n\nvar OrderedMap = Immutable.OrderedMap;\n\n\nvar bidiService;\n\nvar EditorBidiService = {\n  getDirectionMap: function getDirectionMap(content, prevBidiMap) {\n    if (!bidiService) {\n      bidiService = new UnicodeBidiService();\n    } else {\n      bidiService.reset();\n    }\n\n    var blockMap = content.getBlockMap();\n    var nextBidi = blockMap.valueSeq().map(function (block) {\n      return nullthrows(bidiService).getDirection(block.getText());\n    });\n    var bidiMap = OrderedMap(blockMap.keySeq().zip(nextBidi));\n\n    if (prevBidiMap != null && Immutable.is(prevBidiMap, bidiMap)) {\n      return prevBidiMap;\n    }\n\n    return bidiMap;\n  }\n};\n\nmodule.exports = EditorBidiService;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/EditorBidiService.js\n// module id = 435\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n * \n */\n\n/**\n * Stateful API for text direction detection\n *\n * This class can be used in applications where you need to detect the\n * direction of a sequence of text blocks, where each direction shall be used\n * as the fallback direction for the next one.\n *\n * NOTE: A default direction, if not provided, is set based on the global\n *       direction, as defined by `UnicodeBidiDirection`.\n *\n * == Example ==\n * ```\n * var UnicodeBidiService = require('UnicodeBidiService');\n *\n * var bidiService = new UnicodeBidiService();\n *\n * ...\n *\n * bidiService.reset();\n * for (var para in paragraphs) {\n *   var dir = bidiService.getDirection(para);\n *   ...\n * }\n * ```\n *\n * Part of our implementation of Unicode Bidirectional Algorithm (UBA)\n * Unicode Standard Annex #9 (UAX9)\n * http://www.unicode.org/reports/tr9/\n */\n\n'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar UnicodeBidi = require('./UnicodeBidi');\nvar UnicodeBidiDirection = require('./UnicodeBidiDirection');\n\nvar invariant = require('./invariant');\n\nvar UnicodeBidiService = function () {\n\n  /**\n   * Stateful class for paragraph direction detection\n   *\n   * @param defaultDir  Default direction of the service\n   */\n  function UnicodeBidiService(defaultDir) {\n    _classCallCheck(this, UnicodeBidiService);\n\n    if (!defaultDir) {\n      defaultDir = UnicodeBidiDirection.getGlobalDir();\n    } else {\n      !UnicodeBidiDirection.isStrong(defaultDir) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Default direction must be a strong direction (LTR or RTL)') : invariant(false) : void 0;\n    }\n    this._defaultDir = defaultDir;\n    this.reset();\n  }\n\n  /**\n   * Reset the internal state\n   *\n   * Instead of creating a new instance, you can just reset() your instance\n   * everytime you start a new loop.\n   */\n\n\n  UnicodeBidiService.prototype.reset = function reset() {\n    this._lastDir = this._defaultDir;\n  };\n\n  /**\n   * Returns the direction of a block of text, and remembers it as the\n   * fall-back direction for the next paragraph.\n   *\n   * @param str  A text block, e.g. paragraph, table cell, tag\n   * @return     The resolved direction\n   */\n\n\n  UnicodeBidiService.prototype.getDirection = function getDirection(str) {\n    this._lastDir = UnicodeBidi.getDirection(str, this._lastDir);\n    return this._lastDir;\n  };\n\n  return UnicodeBidiService;\n}();\n\nmodule.exports = UnicodeBidiService;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/UnicodeBidiService.js\n// module id = 436\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule moveBlockInContentState\n * @format\n * \n */\n\n'use strict';\n\nvar ContentBlockNode = require('./ContentBlockNode');\nvar Immutable = require('immutable');\n\nvar getNextDelimiterBlockKey = require('./getNextDelimiterBlockKey');\nvar invariant = require('fbjs/lib/invariant');\n\nvar OrderedMap = Immutable.OrderedMap,\n    List = Immutable.List;\n\n\nvar transformBlock = function transformBlock(key, blockMap, func) {\n  if (!key) {\n    return;\n  }\n\n  var block = blockMap.get(key);\n\n  if (!block) {\n    return;\n  }\n\n  blockMap.set(key, func(block));\n};\n\nvar updateBlockMapLinks = function updateBlockMapLinks(blockMap, originalBlockToBeMoved, originalTargetBlock, insertionMode, isExperimentalTreeBlock) {\n  if (!isExperimentalTreeBlock) {\n    return blockMap;\n  }\n  // possible values of 'insertionMode' are: 'after', 'before'\n  var isInsertedAfterTarget = insertionMode === 'after';\n\n  var originalBlockKey = originalBlockToBeMoved.getKey();\n  var originalTargetKey = originalTargetBlock.getKey();\n  var originalParentKey = originalBlockToBeMoved.getParentKey();\n  var originalNextSiblingKey = originalBlockToBeMoved.getNextSiblingKey();\n  var originalPrevSiblingKey = originalBlockToBeMoved.getPrevSiblingKey();\n  var newParentKey = originalTargetBlock.getParentKey();\n  var newNextSiblingKey = isInsertedAfterTarget ? originalTargetBlock.getNextSiblingKey() : originalTargetKey;\n  var newPrevSiblingKey = isInsertedAfterTarget ? originalTargetKey : originalTargetBlock.getPrevSiblingKey();\n\n  return blockMap.withMutations(function (blocks) {\n    // update old parent\n    transformBlock(originalParentKey, blocks, function (block) {\n      var parentChildrenList = block.getChildKeys();\n      return block.merge({\n        children: parentChildrenList['delete'](parentChildrenList.indexOf(originalBlockKey))\n      });\n    });\n\n    // update old prev\n    transformBlock(originalPrevSiblingKey, blocks, function (block) {\n      return block.merge({\n        nextSibling: originalNextSiblingKey\n      });\n    });\n\n    // update old next\n    transformBlock(originalNextSiblingKey, blocks, function (block) {\n      return block.merge({\n        prevSibling: originalPrevSiblingKey\n      });\n    });\n\n    // update new next\n    transformBlock(newNextSiblingKey, blocks, function (block) {\n      return block.merge({\n        prevSibling: originalBlockKey\n      });\n    });\n\n    // update new prev\n    transformBlock(newPrevSiblingKey, blocks, function (block) {\n      return block.merge({\n        nextSibling: originalBlockKey\n      });\n    });\n\n    // update new parent\n    transformBlock(newParentKey, blocks, function (block) {\n      var newParentChildrenList = block.getChildKeys();\n      var targetBlockIndex = newParentChildrenList.indexOf(originalTargetKey);\n\n      var insertionIndex = isInsertedAfterTarget ? targetBlockIndex + 1 : targetBlockIndex !== 0 ? targetBlockIndex - 1 : 0;\n\n      var newChildrenArray = newParentChildrenList.toArray();\n      newChildrenArray.splice(insertionIndex, 0, originalBlockKey);\n\n      return block.merge({\n        children: List(newChildrenArray)\n      });\n    });\n\n    // update block\n    transformBlock(originalBlockKey, blocks, function (block) {\n      return block.merge({\n        nextSibling: newNextSiblingKey,\n        prevSibling: newPrevSiblingKey,\n        parent: newParentKey\n      });\n    });\n  });\n};\n\nvar moveBlockInContentState = function moveBlockInContentState(contentState, blockToBeMoved, targetBlock, insertionMode) {\n  !(insertionMode !== 'replace') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Replacing blocks is not supported.') : invariant(false) : void 0;\n\n  var targetKey = targetBlock.getKey();\n  var blockKey = blockToBeMoved.getKey();\n\n  !(blockKey !== targetKey) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Block cannot be moved next to itself.') : invariant(false) : void 0;\n\n  var blockMap = contentState.getBlockMap();\n  var isExperimentalTreeBlock = blockToBeMoved instanceof ContentBlockNode;\n\n  var blocksToBeMoved = [blockToBeMoved];\n  var blockMapWithoutBlocksToBeMoved = blockMap['delete'](blockKey);\n\n  if (isExperimentalTreeBlock) {\n    blocksToBeMoved = [];\n    blockMapWithoutBlocksToBeMoved = blockMap.withMutations(function (blocks) {\n      var nextSiblingKey = blockToBeMoved.getNextSiblingKey();\n      var nextDelimiterBlockKey = getNextDelimiterBlockKey(blockToBeMoved, blocks);\n\n      blocks.toSeq().skipUntil(function (block) {\n        return block.getKey() === blockKey;\n      }).takeWhile(function (block) {\n        var key = block.getKey();\n        var isBlockToBeMoved = key === blockKey;\n        var hasNextSiblingAndIsNotNextSibling = nextSiblingKey && key !== nextSiblingKey;\n        var doesNotHaveNextSiblingAndIsNotDelimiter = !nextSiblingKey && block.getParentKey() && (!nextDelimiterBlockKey || key !== nextDelimiterBlockKey);\n\n        return !!(isBlockToBeMoved || hasNextSiblingAndIsNotNextSibling || doesNotHaveNextSiblingAndIsNotDelimiter);\n      }).forEach(function (block) {\n        blocksToBeMoved.push(block);\n        blocks['delete'](block.getKey());\n      });\n    });\n  }\n\n  var blocksBefore = blockMapWithoutBlocksToBeMoved.toSeq().takeUntil(function (v) {\n    return v === targetBlock;\n  });\n\n  var blocksAfter = blockMapWithoutBlocksToBeMoved.toSeq().skipUntil(function (v) {\n    return v === targetBlock;\n  }).skip(1);\n\n  var slicedBlocks = blocksToBeMoved.map(function (block) {\n    return [block.getKey(), block];\n  });\n\n  var newBlocks = OrderedMap();\n\n  if (insertionMode === 'before') {\n    var blockBefore = contentState.getBlockBefore(targetKey);\n\n    !(!blockBefore || blockBefore.getKey() !== blockToBeMoved.getKey()) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Block cannot be moved next to itself.') : invariant(false) : void 0;\n\n    newBlocks = blocksBefore.concat([].concat(slicedBlocks, [[targetKey, targetBlock]]), blocksAfter).toOrderedMap();\n  } else if (insertionMode === 'after') {\n    var blockAfter = contentState.getBlockAfter(targetKey);\n\n    !(!blockAfter || blockAfter.getKey() !== blockKey) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Block cannot be moved next to itself.') : invariant(false) : void 0;\n\n    newBlocks = blocksBefore.concat([[targetKey, targetBlock]].concat(slicedBlocks), blocksAfter).toOrderedMap();\n  }\n\n  return contentState.merge({\n    blockMap: updateBlockMapLinks(newBlocks, blockToBeMoved, targetBlock, insertionMode, isExperimentalTreeBlock),\n    selectionBefore: contentState.getSelectionAfter(),\n    selectionAfter: contentState.getSelectionAfter().merge({\n      anchorKey: blockKey,\n      focusKey: blockKey\n    })\n  });\n};\n\nmodule.exports = moveBlockInContentState;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/moveBlockInContentState.js\n// module id = 437\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule CompositeDraftDecorator\n * @format\n * \n */\n\n'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Immutable = require('immutable');\n\nvar List = Immutable.List;\n\n\nvar DELIMITER = '.';\n\n/**\n * A CompositeDraftDecorator traverses through a list of DraftDecorator\n * instances to identify sections of a ContentBlock that should be rendered\n * in a \"decorated\" manner. For example, hashtags, mentions, and links may\n * be intended to stand out visually, be rendered as anchors, etc.\n *\n * The list of decorators supplied to the constructor will be used in the\n * order they are provided. This allows the caller to specify a priority for\n * string matching, in case of match collisions among decorators.\n *\n * For instance, I may have a link with a `#` in its text. Though this section\n * of text may match our hashtag decorator, it should not be treated as a\n * hashtag. I should therefore list my link DraftDecorator\n * before my hashtag DraftDecorator when constructing this composite\n * decorator instance.\n *\n * Thus, when a collision like this is encountered, the earlier match is\n * preserved and the new match is discarded.\n */\n\nvar CompositeDraftDecorator = function () {\n  function CompositeDraftDecorator(decorators) {\n    _classCallCheck(this, CompositeDraftDecorator);\n\n    // Copy the decorator array, since we use this array order to determine\n    // precedence of decoration matching. If the array is mutated externally,\n    // we don't want to be affected here.\n    this._decorators = decorators.slice();\n  }\n\n  CompositeDraftDecorator.prototype.getDecorations = function getDecorations(block, contentState) {\n    var decorations = Array(block.getText().length).fill(null);\n\n    this._decorators.forEach(function ( /*object*/decorator, /*number*/ii) {\n      var counter = 0;\n      var strategy = decorator.strategy;\n      var callback = function callback( /*number*/start, /*number*/end) {\n        // Find out if any of our matching range is already occupied\n        // by another decorator. If so, discard the match. Otherwise, store\n        // the component key for rendering.\n        if (canOccupySlice(decorations, start, end)) {\n          occupySlice(decorations, start, end, ii + DELIMITER + counter);\n          counter++;\n        }\n      };\n      strategy(block, callback, contentState);\n    });\n\n    return List(decorations);\n  };\n\n  CompositeDraftDecorator.prototype.getComponentForKey = function getComponentForKey(key) {\n    var componentKey = parseInt(key.split(DELIMITER)[0], 10);\n    return this._decorators[componentKey].component;\n  };\n\n  CompositeDraftDecorator.prototype.getPropsForKey = function getPropsForKey(key) {\n    var componentKey = parseInt(key.split(DELIMITER)[0], 10);\n    return this._decorators[componentKey].props;\n  };\n\n  return CompositeDraftDecorator;\n}();\n\n/**\n * Determine whether we can occupy the specified slice of the decorations\n * array.\n */\n\n\nfunction canOccupySlice(decorations, start, end) {\n  for (var ii = start; ii < end; ii++) {\n    if (decorations[ii] != null) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Splice the specified component into our decoration array at the desired\n * range.\n */\nfunction occupySlice(targetArr, start, end, componentKey) {\n  for (var ii = start; ii < end; ii++) {\n    targetArr[ii] = componentKey;\n  }\n}\n\nmodule.exports = CompositeDraftDecorator;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/CompositeDraftDecorator.js\n// module id = 438\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditor.react\n * @format\n * \n * @preventMunge\n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar DefaultDraftBlockRenderMap = require('./DefaultDraftBlockRenderMap');\nvar DefaultDraftInlineStyle = require('./DefaultDraftInlineStyle');\nvar DraftEditorCompositionHandler = require('./DraftEditorCompositionHandler');\nvar DraftEditorContents = require('./DraftEditorContents.react');\nvar DraftEditorDragHandler = require('./DraftEditorDragHandler');\nvar DraftEditorEditHandler = require('./DraftEditorEditHandler');\nvar DraftEditorPlaceholder = require('./DraftEditorPlaceholder.react');\nvar EditorState = require('./EditorState');\nvar React = require('react');\nvar ReactDOM = require('react-dom');\nvar Scroll = require('fbjs/lib/Scroll');\nvar Style = require('fbjs/lib/Style');\nvar UserAgent = require('fbjs/lib/UserAgent');\n\nvar cx = require('fbjs/lib/cx');\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar generateRandomKey = require('./generateRandomKey');\nvar getDefaultKeyBinding = require('./getDefaultKeyBinding');\nvar getScrollPosition = require('fbjs/lib/getScrollPosition');\nvar invariant = require('fbjs/lib/invariant');\nvar nullthrows = require('fbjs/lib/nullthrows');\n\nvar isIE = UserAgent.isBrowser('IE');\n\n// IE does not support the `input` event on contentEditable, so we can't\n// observe spellcheck behavior.\nvar allowSpellCheck = !isIE;\n\n// Define a set of handler objects to correspond to each possible `mode`\n// of editor behavior.\nvar handlerMap = {\n  edit: DraftEditorEditHandler,\n  composite: DraftEditorCompositionHandler,\n  drag: DraftEditorDragHandler,\n  cut: null,\n  render: null\n};\n\n/**\n * `DraftEditor` is the root editor component. It composes a `contentEditable`\n * div, and provides a wide variety of useful function props for managing the\n * state of the editor. See `DraftEditorProps` for details.\n */\nvar DraftEditor = function (_React$Component) {\n  _inherits(DraftEditor, _React$Component);\n\n  function DraftEditor(props) {\n    _classCallCheck(this, DraftEditor);\n\n    var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));\n\n    _this.focus = function (scrollPosition) {\n      var editorState = _this.props.editorState;\n\n      var alreadyHasFocus = editorState.getSelection().getHasFocus();\n      var editorNode = ReactDOM.findDOMNode(_this.editor);\n\n      if (!editorNode) {\n        // once in a while people call 'focus' in a setTimeout, and the node has\n        // been deleted, so it can be null in that case.\n        return;\n      }\n\n      var scrollParent = Style.getScrollParent(editorNode);\n\n      var _ref = scrollPosition || getScrollPosition(scrollParent),\n          x = _ref.x,\n          y = _ref.y;\n\n      !(editorNode instanceof HTMLElement) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'editorNode is not an HTMLElement') : invariant(false) : void 0;\n      editorNode.focus();\n\n      // Restore scroll position\n      if (scrollParent === window) {\n        window.scrollTo(x, y);\n      } else {\n        Scroll.setTop(scrollParent, y);\n      }\n\n      // On Chrome and Safari, calling focus on contenteditable focuses the\n      // cursor at the first character. This is something you don't expect when\n      // you're clicking on an input element but not directly on a character.\n      // Put the cursor back where it was before the blur.\n      if (!alreadyHasFocus) {\n        _this.update(EditorState.forceSelection(editorState, editorState.getSelection()));\n      }\n    };\n\n    _this.blur = function () {\n      var editorNode = ReactDOM.findDOMNode(_this.editor);\n      !(editorNode instanceof HTMLElement) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'editorNode is not an HTMLElement') : invariant(false) : void 0;\n      editorNode.blur();\n    };\n\n    _this.setMode = function (mode) {\n      _this._handler = handlerMap[mode];\n    };\n\n    _this.exitCurrentMode = function () {\n      _this.setMode('edit');\n    };\n\n    _this.restoreEditorDOM = function (scrollPosition) {\n      _this.setState({ contentsKey: _this.state.contentsKey + 1 }, function () {\n        _this.focus(scrollPosition);\n      });\n    };\n\n    _this.setClipboard = function (clipboard) {\n      _this._clipboard = clipboard;\n    };\n\n    _this.getClipboard = function () {\n      return _this._clipboard;\n    };\n\n    _this.update = function (editorState) {\n      _this._latestEditorState = editorState;\n      _this.props.onChange(editorState);\n    };\n\n    _this.onDragEnter = function () {\n      _this._dragCount++;\n    };\n\n    _this.onDragLeave = function () {\n      _this._dragCount--;\n      if (_this._dragCount === 0) {\n        _this.exitCurrentMode();\n      }\n    };\n\n    _this._blockSelectEvents = false;\n    _this._clipboard = null;\n    _this._handler = null;\n    _this._dragCount = 0;\n    _this._editorKey = props.editorKey || generateRandomKey();\n    _this._placeholderAccessibilityID = 'placeholder-' + _this._editorKey;\n    _this._latestEditorState = props.editorState;\n    _this._latestCommittedEditorState = props.editorState;\n\n    _this._onBeforeInput = _this._buildHandler('onBeforeInput');\n    _this._onBlur = _this._buildHandler('onBlur');\n    _this._onCharacterData = _this._buildHandler('onCharacterData');\n    _this._onCompositionEnd = _this._buildHandler('onCompositionEnd');\n    _this._onCompositionStart = _this._buildHandler('onCompositionStart');\n    _this._onCopy = _this._buildHandler('onCopy');\n    _this._onCut = _this._buildHandler('onCut');\n    _this._onDragEnd = _this._buildHandler('onDragEnd');\n    _this._onDragOver = _this._buildHandler('onDragOver');\n    _this._onDragStart = _this._buildHandler('onDragStart');\n    _this._onDrop = _this._buildHandler('onDrop');\n    _this._onInput = _this._buildHandler('onInput');\n    _this._onFocus = _this._buildHandler('onFocus');\n    _this._onKeyDown = _this._buildHandler('onKeyDown');\n    _this._onKeyPress = _this._buildHandler('onKeyPress');\n    _this._onKeyUp = _this._buildHandler('onKeyUp');\n    _this._onMouseDown = _this._buildHandler('onMouseDown');\n    _this._onMouseUp = _this._buildHandler('onMouseUp');\n    _this._onPaste = _this._buildHandler('onPaste');\n    _this._onSelect = _this._buildHandler('onSelect');\n\n    _this.getEditorKey = function () {\n      return _this._editorKey;\n    };\n\n    // See `restoreEditorDOM()`.\n    _this.state = { contentsKey: 0 };\n    return _this;\n  }\n\n  /**\n   * Build a method that will pass the event to the specified handler method.\n   * This allows us to look up the correct handler function for the current\n   * editor mode, if any has been specified.\n   */\n\n\n  /**\n   * Define proxies that can route events to the current handler.\n   */\n\n\n  DraftEditor.prototype._buildHandler = function _buildHandler(eventName) {\n    var _this2 = this;\n\n    return function (e) {\n      if (!_this2.props.readOnly) {\n        var method = _this2._handler && _this2._handler[eventName];\n        method && method(_this2, e);\n      }\n    };\n  };\n\n  DraftEditor.prototype._showPlaceholder = function _showPlaceholder() {\n    return !!this.props.placeholder && !this.props.editorState.isInCompositionMode() && !this.props.editorState.getCurrentContent().hasText();\n  };\n\n  DraftEditor.prototype._renderPlaceholder = function _renderPlaceholder() {\n    if (this._showPlaceholder()) {\n      var placeHolderProps = {\n        text: nullthrows(this.props.placeholder),\n        editorState: this.props.editorState,\n        textAlignment: this.props.textAlignment,\n        accessibilityID: this._placeholderAccessibilityID\n      };\n\n      return React.createElement(DraftEditorPlaceholder, placeHolderProps);\n    }\n    return null;\n  };\n\n  DraftEditor.prototype.render = function render() {\n    var _this3 = this;\n\n    var _props = this.props,\n        blockRenderMap = _props.blockRenderMap,\n        blockRendererFn = _props.blockRendererFn,\n        blockStyleFn = _props.blockStyleFn,\n        customStyleFn = _props.customStyleFn,\n        customStyleMap = _props.customStyleMap,\n        editorState = _props.editorState,\n        readOnly = _props.readOnly,\n        textAlignment = _props.textAlignment,\n        textDirectionality = _props.textDirectionality;\n\n\n    var rootClass = cx({\n      'DraftEditor/root': true,\n      'DraftEditor/alignLeft': textAlignment === 'left',\n      'DraftEditor/alignRight': textAlignment === 'right',\n      'DraftEditor/alignCenter': textAlignment === 'center'\n    });\n\n    var contentStyle = {\n      outline: 'none',\n      // fix parent-draggable Safari bug. #1326\n      userSelect: 'text',\n      WebkitUserSelect: 'text',\n      whiteSpace: 'pre-wrap',\n      wordWrap: 'break-word'\n    };\n\n    // The aria-expanded and aria-haspopup properties should only be rendered\n    // for a combobox.\n    var ariaRole = this.props.role || 'textbox';\n    var ariaExpanded = ariaRole === 'combobox' ? !!this.props.ariaExpanded : null;\n\n    var editorContentsProps = {\n      blockRenderMap: blockRenderMap,\n      blockRendererFn: blockRendererFn,\n      blockStyleFn: blockStyleFn,\n      customStyleMap: _extends({}, DefaultDraftInlineStyle, customStyleMap),\n      customStyleFn: customStyleFn,\n      editorKey: this._editorKey,\n      editorState: editorState,\n      key: 'contents' + this.state.contentsKey,\n      textDirectionality: textDirectionality\n    };\n\n    return React.createElement(\n      'div',\n      { className: rootClass },\n      this._renderPlaceholder(),\n      React.createElement(\n        'div',\n        {\n          className: cx('DraftEditor/editorContainer'),\n          ref: function ref(_ref3) {\n            return _this3.editorContainer = _ref3;\n          } },\n        React.createElement(\n          'div',\n          {\n            'aria-activedescendant': readOnly ? null : this.props.ariaActiveDescendantID,\n            'aria-autocomplete': readOnly ? null : this.props.ariaAutoComplete,\n            'aria-controls': readOnly ? null : this.props.ariaControls,\n            'aria-describedby': this.props.ariaDescribedBy || this._placeholderAccessibilityID,\n            'aria-expanded': readOnly ? null : ariaExpanded,\n            'aria-label': this.props.ariaLabel,\n            'aria-labelledby': this.props.ariaLabelledBy,\n            'aria-multiline': this.props.ariaMultiline,\n            autoCapitalize: this.props.autoCapitalize,\n            autoComplete: this.props.autoComplete,\n            autoCorrect: this.props.autoCorrect,\n            className: cx({\n              // Chrome's built-in translation feature mutates the DOM in ways\n              // that Draft doesn't expect (ex: adding <font> tags inside\n              // DraftEditorLeaf spans) and causes problems. We add notranslate\n              // here which makes its autotranslation skip over this subtree.\n              notranslate: !readOnly,\n              'public/DraftEditor/content': true\n            }),\n            contentEditable: !readOnly,\n            'data-testid': this.props.webDriverTestID,\n            onBeforeInput: this._onBeforeInput,\n            onBlur: this._onBlur,\n            onCompositionEnd: this._onCompositionEnd,\n            onCompositionStart: this._onCompositionStart,\n            onCopy: this._onCopy,\n            onCut: this._onCut,\n            onDragEnd: this._onDragEnd,\n            onDragEnter: this.onDragEnter,\n            onDragLeave: this.onDragLeave,\n            onDragOver: this._onDragOver,\n            onDragStart: this._onDragStart,\n            onDrop: this._onDrop,\n            onFocus: this._onFocus,\n            onInput: this._onInput,\n            onKeyDown: this._onKeyDown,\n            onKeyPress: this._onKeyPress,\n            onKeyUp: this._onKeyUp,\n            onMouseUp: this._onMouseUp,\n            onPaste: this._onPaste,\n            onSelect: this._onSelect,\n            ref: function ref(_ref2) {\n              return _this3.editor = _ref2;\n            },\n            role: readOnly ? null : ariaRole,\n            spellCheck: allowSpellCheck && this.props.spellCheck,\n            style: contentStyle,\n            suppressContentEditableWarning: true,\n            tabIndex: this.props.tabIndex },\n          React.createElement(DraftEditorContents, editorContentsProps)\n        )\n      )\n    );\n  };\n\n  DraftEditor.prototype.componentDidMount = function componentDidMount() {\n    this.setMode('edit');\n\n    /**\n     * IE has a hardcoded \"feature\" that attempts to convert link text into\n     * anchors in contentEditable DOM. This breaks the editor's expectations of\n     * the DOM, and control is lost. Disable it to make IE behave.\n     * See: http://blogs.msdn.com/b/ieinternals/archive/2010/09/15/\n     * ie9-beta-minor-change-list.aspx\n     */\n    if (isIE) {\n      document.execCommand('AutoUrlDetect', false, false);\n    }\n  };\n\n  /**\n   * Prevent selection events from affecting the current editor state. This\n   * is mostly intended to defend against IE, which fires off `selectionchange`\n   * events regardless of whether the selection is set via the browser or\n   * programmatically. We only care about selection events that occur because\n   * of browser interaction, not re-renders and forced selections.\n   */\n\n\n  DraftEditor.prototype.componentWillUpdate = function componentWillUpdate(nextProps) {\n    this._blockSelectEvents = true;\n    this._latestEditorState = nextProps.editorState;\n  };\n\n  DraftEditor.prototype.componentDidUpdate = function componentDidUpdate() {\n    this._blockSelectEvents = false;\n    this._latestCommittedEditorState = this.props.editorState;\n  };\n\n  /**\n   * Used via `this.focus()`.\n   *\n   * Force focus back onto the editor node.\n   *\n   * We attempt to preserve scroll position when focusing. You can also pass\n   * a specified scroll position (for cases like `cut` behavior where it should\n   * be restored to a known position).\n   */\n\n\n  /**\n   * Used via `this.setMode(...)`.\n   *\n   * Set the behavior mode for the editor component. This switches the current\n   * handler module to ensure that DOM events are managed appropriately for\n   * the active mode.\n   */\n\n\n  /**\n   * Used via `this.restoreEditorDOM()`.\n   *\n   * Force a complete re-render of the DraftEditorContents based on the current\n   * EditorState. This is useful when we know we are going to lose control of\n   * the DOM state (cut command, IME) and we want to make sure that\n   * reconciliation occurs on a version of the DOM that is synchronized with\n   * our EditorState.\n   */\n\n\n  /**\n   * Used via `this.setClipboard(...)`.\n   *\n   * Set the clipboard state for a cut/copy event.\n   */\n\n\n  /**\n   * Used via `this.getClipboard()`.\n   *\n   * Retrieve the clipboard state for a cut/copy event.\n   */\n\n\n  /**\n   * Used via `this.update(...)`.\n   *\n   * Propagate a new `EditorState` object to higher-level components. This is\n   * the method by which event handlers inform the `DraftEditor` component of\n   * state changes. A component that composes a `DraftEditor` **must** provide\n   * an `onChange` prop to receive state updates passed along from this\n   * function.\n   */\n\n\n  /**\n   * Used in conjunction with `onDragLeave()`, by counting the number of times\n   * a dragged element enters and leaves the editor (or any of its children),\n   * to determine when the dragged element absolutely leaves the editor.\n   */\n\n\n  /**\n   * See `onDragEnter()`.\n   */\n\n\n  return DraftEditor;\n}(React.Component);\n\nDraftEditor.defaultProps = {\n  blockRenderMap: DefaultDraftBlockRenderMap,\n  blockRendererFn: emptyFunction.thatReturnsNull,\n  blockStyleFn: emptyFunction.thatReturns(''),\n  keyBindingFn: getDefaultKeyBinding,\n  readOnly: false,\n  spellCheck: false,\n  stripPastedStyles: false\n};\n\n\nmodule.exports = DraftEditor;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftEditor.react.js\n// module id = 439\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorCompositionHandler\n * @format\n * \n */\n\n'use strict';\n\nvar DraftFeatureFlags = require('./DraftFeatureFlags');\nvar DraftModifier = require('./DraftModifier');\nvar EditorState = require('./EditorState');\nvar Keys = require('fbjs/lib/Keys');\n\nvar getEntityKeyForSelection = require('./getEntityKeyForSelection');\nvar isEventHandled = require('./isEventHandled');\nvar isSelectionAtLeafStart = require('./isSelectionAtLeafStart');\n\n/**\n * Millisecond delay to allow `compositionstart` to fire again upon\n * `compositionend`.\n *\n * This is used for Korean input to ensure that typing can continue without\n * the editor trying to render too quickly. More specifically, Safari 7.1+\n * triggers `compositionstart` a little slower than Chrome/FF, which\n * leads to composed characters being resolved and re-render occurring\n * sooner than we want.\n */\nvar RESOLVE_DELAY = 20;\n\n/**\n * A handful of variables used to track the current composition and its\n * resolution status. These exist at the module level because it is not\n * possible to have compositions occurring in multiple editors simultaneously,\n * and it simplifies state management with respect to the DraftEditor component.\n */\nvar resolved = false;\nvar stillComposing = false;\nvar textInputData = '';\n\nvar DraftEditorCompositionHandler = {\n  onBeforeInput: function onBeforeInput(editor, e) {\n    textInputData = (textInputData || '') + e.data;\n  },\n\n  /**\n   * A `compositionstart` event has fired while we're still in composition\n   * mode. Continue the current composition session to prevent a re-render.\n   */\n  onCompositionStart: function onCompositionStart(editor) {\n    stillComposing = true;\n  },\n\n  /**\n   * Attempt to end the current composition session.\n   *\n   * Defer handling because browser will still insert the chars into active\n   * element after `compositionend`. If a `compositionstart` event fires\n   * before `resolveComposition` executes, our composition session will\n   * continue.\n   *\n   * The `resolved` flag is useful because certain IME interfaces fire the\n   * `compositionend` event multiple times, thus queueing up multiple attempts\n   * at handling the composition. Since handling the same composition event\n   * twice could break the DOM, we only use the first event. Example: Arabic\n   * Google Input Tools on Windows 8.1 fires `compositionend` three times.\n   */\n  onCompositionEnd: function onCompositionEnd(editor) {\n    resolved = false;\n    stillComposing = false;\n    setTimeout(function () {\n      if (!resolved) {\n        DraftEditorCompositionHandler.resolveComposition(editor);\n      }\n    }, RESOLVE_DELAY);\n  },\n\n  /**\n   * In Safari, keydown events may fire when committing compositions. If\n   * the arrow keys are used to commit, prevent default so that the cursor\n   * doesn't move, otherwise it will jump back noticeably on re-render.\n   */\n  onKeyDown: function onKeyDown(editor, e) {\n    if (!stillComposing) {\n      // If a keydown event is received after compositionend but before the\n      // 20ms timer expires (ex: type option-E then backspace, or type A then\n      // backspace in 2-Set Korean), we should immediately resolve the\n      // composition and reinterpret the key press in edit mode.\n      DraftEditorCompositionHandler.resolveComposition(editor);\n      editor._onKeyDown(e);\n      return;\n    }\n    if (e.which === Keys.RIGHT || e.which === Keys.LEFT) {\n      e.preventDefault();\n    }\n  },\n\n  /**\n   * Keypress events may fire when committing compositions. In Firefox,\n   * pressing RETURN commits the composition and inserts extra newline\n   * characters that we do not want. `preventDefault` allows the composition\n   * to be committed while preventing the extra characters.\n   */\n  onKeyPress: function onKeyPress(editor, e) {\n    if (e.which === Keys.RETURN) {\n      e.preventDefault();\n    }\n  },\n\n  /**\n   * Attempt to insert composed characters into the document.\n   *\n   * If we are still in a composition session, do nothing. Otherwise, insert\n   * the characters into the document and terminate the composition session.\n   *\n   * If no characters were composed -- for instance, the user\n   * deleted all composed characters and committed nothing new --\n   * force a re-render. We also re-render when the composition occurs\n   * at the beginning of a leaf, to ensure that if the browser has\n   * created a new text node for the composition, we will discard it.\n   *\n   * Resetting innerHTML will move focus to the beginning of the editor,\n   * so we update to force it back to the correct place.\n   */\n  resolveComposition: function resolveComposition(editor) {\n    if (stillComposing) {\n      return;\n    }\n\n    resolved = true;\n    var composedChars = textInputData;\n    textInputData = '';\n\n    var editorState = EditorState.set(editor._latestEditorState, {\n      inCompositionMode: false\n    });\n\n    var currentStyle = editorState.getCurrentInlineStyle();\n    var entityKey = getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection());\n\n    var mustReset = !composedChars || isSelectionAtLeafStart(editorState) || currentStyle.size > 0 || entityKey !== null;\n\n    if (mustReset) {\n      editor.restoreEditorDOM();\n    }\n\n    editor.exitCurrentMode();\n\n    if (composedChars) {\n      if (DraftFeatureFlags.draft_handlebeforeinput_composed_text && editor.props.handleBeforeInput && isEventHandled(editor.props.handleBeforeInput(composedChars, editorState))) {\n        return;\n      }\n      // If characters have been composed, re-rendering with the update\n      // is sufficient to reset the editor.\n      var contentState = DraftModifier.replaceText(editorState.getCurrentContent(), editorState.getSelection(), composedChars, currentStyle, entityKey);\n      editor.update(EditorState.push(editorState, contentState, 'insert-characters'));\n      return;\n    }\n\n    if (mustReset) {\n      editor.update(EditorState.set(editorState, {\n        nativelyRenderedContent: null,\n        forceSelection: true\n      }));\n    }\n  }\n};\n\nmodule.exports = DraftEditorCompositionHandler;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftEditorCompositionHandler.js\n// module id = 440\n// module chunks = 2","/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorContents.react\n * @format\n * \n */\n\n'use strict';\n\nvar DraftEditorContents = require('./DraftEditorContents-core.react');\n\nmodule.exports = DraftEditorContents;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftEditorContents.react.js\n// module id = 441\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorContents-core.react\n * @format\n * \n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar DraftEditorBlock = require('./DraftEditorBlock.react');\nvar DraftOffsetKey = require('./DraftOffsetKey');\nvar EditorState = require('./EditorState');\nvar React = require('react');\n\nvar cx = require('fbjs/lib/cx');\nvar joinClasses = require('fbjs/lib/joinClasses');\nvar nullthrows = require('fbjs/lib/nullthrows');\n\n/**\n * Provide default styling for list items. This way, lists will be styled with\n * proper counters and indentation even if the caller does not specify\n * their own styling at all. If more than five levels of nesting are needed,\n * the necessary CSS classes can be provided via `blockStyleFn` configuration.\n */\nvar getListItemClasses = function getListItemClasses(type, depth, shouldResetCount, direction) {\n  return cx({\n    'public/DraftStyleDefault/unorderedListItem': type === 'unordered-list-item',\n    'public/DraftStyleDefault/orderedListItem': type === 'ordered-list-item',\n    'public/DraftStyleDefault/reset': shouldResetCount,\n    'public/DraftStyleDefault/depth0': depth === 0,\n    'public/DraftStyleDefault/depth1': depth === 1,\n    'public/DraftStyleDefault/depth2': depth === 2,\n    'public/DraftStyleDefault/depth3': depth === 3,\n    'public/DraftStyleDefault/depth4': depth === 4,\n    'public/DraftStyleDefault/listLTR': direction === 'LTR',\n    'public/DraftStyleDefault/listRTL': direction === 'RTL'\n  });\n};\n\n/**\n * `DraftEditorContents` is the container component for all block components\n * rendered for a `DraftEditor`. It is optimized to aggressively avoid\n * re-rendering blocks whenever possible.\n *\n * This component is separate from `DraftEditor` because certain props\n * (for instance, ARIA props) must be allowed to update without affecting\n * the contents of the editor.\n */\n\nvar DraftEditorContents = function (_React$Component) {\n  _inherits(DraftEditorContents, _React$Component);\n\n  function DraftEditorContents() {\n    _classCallCheck(this, DraftEditorContents);\n\n    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));\n  }\n\n  DraftEditorContents.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n    var prevEditorState = this.props.editorState;\n    var nextEditorState = nextProps.editorState;\n\n    var prevDirectionMap = prevEditorState.getDirectionMap();\n    var nextDirectionMap = nextEditorState.getDirectionMap();\n\n    // Text direction has changed for one or more blocks. We must re-render.\n    if (prevDirectionMap !== nextDirectionMap) {\n      return true;\n    }\n\n    var didHaveFocus = prevEditorState.getSelection().getHasFocus();\n    var nowHasFocus = nextEditorState.getSelection().getHasFocus();\n\n    if (didHaveFocus !== nowHasFocus) {\n      return true;\n    }\n\n    var nextNativeContent = nextEditorState.getNativelyRenderedContent();\n\n    var wasComposing = prevEditorState.isInCompositionMode();\n    var nowComposing = nextEditorState.isInCompositionMode();\n\n    // If the state is unchanged or we're currently rendering a natively\n    // rendered state, there's nothing new to be done.\n    if (prevEditorState === nextEditorState || nextNativeContent !== null && nextEditorState.getCurrentContent() === nextNativeContent || wasComposing && nowComposing) {\n      return false;\n    }\n\n    var prevContent = prevEditorState.getCurrentContent();\n    var nextContent = nextEditorState.getCurrentContent();\n    var prevDecorator = prevEditorState.getDecorator();\n    var nextDecorator = nextEditorState.getDecorator();\n    return wasComposing !== nowComposing || prevContent !== nextContent || prevDecorator !== nextDecorator || nextEditorState.mustForceSelection();\n  };\n\n  DraftEditorContents.prototype.render = function render() {\n    var _props = this.props,\n        blockRenderMap = _props.blockRenderMap,\n        blockRendererFn = _props.blockRendererFn,\n        blockStyleFn = _props.blockStyleFn,\n        customStyleMap = _props.customStyleMap,\n        customStyleFn = _props.customStyleFn,\n        editorState = _props.editorState,\n        editorKey = _props.editorKey,\n        textDirectionality = _props.textDirectionality;\n\n\n    var content = editorState.getCurrentContent();\n    var selection = editorState.getSelection();\n    var forceSelection = editorState.mustForceSelection();\n    var decorator = editorState.getDecorator();\n    var directionMap = nullthrows(editorState.getDirectionMap());\n\n    var blocksAsArray = content.getBlocksAsArray();\n    var processedBlocks = [];\n\n    var currentDepth = null;\n    var lastWrapperTemplate = null;\n\n    for (var ii = 0; ii < blocksAsArray.length; ii++) {\n      var _block = blocksAsArray[ii];\n      var key = _block.getKey();\n      var blockType = _block.getType();\n\n      var customRenderer = blockRendererFn(_block);\n      var CustomComponent = void 0,\n          customProps = void 0,\n          customEditable = void 0;\n      if (customRenderer) {\n        CustomComponent = customRenderer.component;\n        customProps = customRenderer.props;\n        customEditable = customRenderer.editable;\n      }\n\n      var direction = textDirectionality ? textDirectionality : directionMap.get(key);\n      var offsetKey = DraftOffsetKey.encode(key, 0, 0);\n      var componentProps = {\n        contentState: content,\n        block: _block,\n        blockProps: customProps,\n        blockStyleFn: blockStyleFn,\n        customStyleMap: customStyleMap,\n        customStyleFn: customStyleFn,\n        decorator: decorator,\n        direction: direction,\n        forceSelection: forceSelection,\n        key: key,\n        offsetKey: offsetKey,\n        selection: selection,\n        tree: editorState.getBlockTree(key)\n      };\n\n      var configForType = blockRenderMap.get(blockType) || blockRenderMap.get('unstyled');\n      var wrapperTemplate = configForType.wrapper;\n\n      var Element = configForType.element || blockRenderMap.get('unstyled').element;\n\n      var depth = _block.getDepth();\n      var className = '';\n      if (blockStyleFn) {\n        className = blockStyleFn(_block);\n      }\n\n      // List items are special snowflakes, since we handle nesting and\n      // counters manually.\n      if (Element === 'li') {\n        var shouldResetCount = lastWrapperTemplate !== wrapperTemplate || currentDepth === null || depth > currentDepth;\n        className = joinClasses(className, getListItemClasses(blockType, depth, shouldResetCount, direction));\n      }\n\n      var Component = CustomComponent || DraftEditorBlock;\n      var childProps = {\n        className: className,\n        'data-block': true,\n        'data-editor': editorKey,\n        'data-offset-key': offsetKey,\n        key: key\n      };\n      if (customEditable !== undefined) {\n        childProps = _extends({}, childProps, {\n          contentEditable: customEditable,\n          suppressContentEditableWarning: true\n        });\n      }\n\n      var child = React.createElement(Element, childProps, React.createElement(Component, componentProps));\n\n      processedBlocks.push({\n        block: child,\n        wrapperTemplate: wrapperTemplate,\n        key: key,\n        offsetKey: offsetKey\n      });\n\n      if (wrapperTemplate) {\n        currentDepth = _block.getDepth();\n      } else {\n        currentDepth = null;\n      }\n      lastWrapperTemplate = wrapperTemplate;\n    }\n\n    // Group contiguous runs of blocks that have the same wrapperTemplate\n    var outputBlocks = [];\n    for (var _ii = 0; _ii < processedBlocks.length;) {\n      var info = processedBlocks[_ii];\n      if (info.wrapperTemplate) {\n        var blocks = [];\n        do {\n          blocks.push(processedBlocks[_ii].block);\n          _ii++;\n        } while (_ii < processedBlocks.length && processedBlocks[_ii].wrapperTemplate === info.wrapperTemplate);\n        var wrapperElement = React.cloneElement(info.wrapperTemplate, {\n          key: info.key + '-wrap',\n          'data-offset-key': info.offsetKey\n        }, blocks);\n        outputBlocks.push(wrapperElement);\n      } else {\n        outputBlocks.push(info.block);\n        _ii++;\n      }\n    }\n\n    return React.createElement(\n      'div',\n      { 'data-contents': 'true' },\n      outputBlocks\n    );\n  };\n\n  return DraftEditorContents;\n}(React.Component);\n\nmodule.exports = DraftEditorContents;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftEditorContents-core.react.js\n// module id = 442\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorLeaf.react\n * @format\n * \n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar DraftEditorTextNode = require('./DraftEditorTextNode.react');\nvar React = require('react');\nvar ReactDOM = require('react-dom');\n\nvar invariant = require('fbjs/lib/invariant');\nvar setDraftEditorSelection = require('./setDraftEditorSelection');\n\n/**\n * All leaf nodes in the editor are spans with single text nodes. Leaf\n * elements are styled based on the merging of an optional custom style map\n * and a default style map.\n *\n * `DraftEditorLeaf` also provides a wrapper for calling into the imperative\n * DOM Selection API. In this way, top-level components can declaratively\n * maintain the selection state.\n */\nvar DraftEditorLeaf = function (_React$Component) {\n  _inherits(DraftEditorLeaf, _React$Component);\n\n  function DraftEditorLeaf() {\n    _classCallCheck(this, DraftEditorLeaf);\n\n    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));\n  }\n\n  DraftEditorLeaf.prototype._setSelection = function _setSelection() {\n    var selection = this.props.selection;\n\n    // If selection state is irrelevant to the parent block, no-op.\n\n    if (selection == null || !selection.getHasFocus()) {\n      return;\n    }\n\n    var _props = this.props,\n        block = _props.block,\n        start = _props.start,\n        text = _props.text;\n\n    var blockKey = block.getKey();\n    var end = start + text.length;\n    if (!selection.hasEdgeWithin(blockKey, start, end)) {\n      return;\n    }\n\n    // Determine the appropriate target node for selection. If the child\n    // is not a text node, it is a <br /> spacer. In this case, use the\n    // <span> itself as the selection target.\n    var node = ReactDOM.findDOMNode(this);\n    !node ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Missing node') : invariant(false) : void 0;\n    var child = node.firstChild;\n    !child ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Missing child') : invariant(false) : void 0;\n    var targetNode = void 0;\n\n    if (child.nodeType === Node.TEXT_NODE) {\n      targetNode = child;\n    } else if (child.tagName === 'BR') {\n      targetNode = node;\n    } else {\n      targetNode = child.firstChild;\n      !targetNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Missing targetNode') : invariant(false) : void 0;\n    }\n\n    setDraftEditorSelection(selection, targetNode, blockKey, start, end);\n  };\n  /**\n   * By making individual leaf instances aware of their context within\n   * the text of the editor, we can set our selection range more\n   * easily than we could in the non-React world.\n   *\n   * Note that this depends on our maintaining tight control over the\n   * DOM structure of the DraftEditor component. If leaves had multiple\n   * text nodes, this would be harder.\n   */\n\n  DraftEditorLeaf.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n    var leafNode = ReactDOM.findDOMNode(this.leaf);\n    !leafNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Missing leafNode') : invariant(false) : void 0;\n    return leafNode.textContent !== nextProps.text || nextProps.styleSet !== this.props.styleSet || nextProps.forceSelection;\n  };\n\n  DraftEditorLeaf.prototype.componentDidUpdate = function componentDidUpdate() {\n    this._setSelection();\n  };\n\n  DraftEditorLeaf.prototype.componentDidMount = function componentDidMount() {\n    this._setSelection();\n  };\n\n  DraftEditorLeaf.prototype.render = function render() {\n    var _this2 = this;\n\n    var block = this.props.block;\n    var text = this.props.text;\n\n    // If the leaf is at the end of its block and ends in a soft newline, append\n    // an extra line feed character. Browsers collapse trailing newline\n    // characters, which leaves the cursor in the wrong place after a\n    // shift+enter. The extra character repairs this.\n\n    if (text.endsWith('\\n') && this.props.isLast) {\n      text += '\\n';\n    }\n\n    var _props2 = this.props,\n        customStyleMap = _props2.customStyleMap,\n        customStyleFn = _props2.customStyleFn,\n        offsetKey = _props2.offsetKey,\n        styleSet = _props2.styleSet;\n\n    var styleObj = styleSet.reduce(function (map, styleName) {\n      var mergedStyles = {};\n      var style = customStyleMap[styleName];\n\n      if (style !== undefined && map.textDecoration !== style.textDecoration) {\n        // .trim() is necessary for IE9/10/11 and Edge\n        mergedStyles.textDecoration = [map.textDecoration, style.textDecoration].join(' ').trim();\n      }\n\n      return _assign(map, style, mergedStyles);\n    }, {});\n\n    if (customStyleFn) {\n      var newStyles = customStyleFn(styleSet, block);\n      styleObj = _assign(styleObj, newStyles);\n    }\n\n    return React.createElement(\n      'span',\n      {\n        'data-offset-key': offsetKey,\n        ref: function ref(_ref) {\n          return _this2.leaf = _ref;\n        },\n        style: styleObj },\n      React.createElement(\n        DraftEditorTextNode,\n        null,\n        text\n      )\n    );\n  };\n\n  return DraftEditorLeaf;\n}(React.Component);\n\nmodule.exports = DraftEditorLeaf;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftEditorLeaf.react.js\n// module id = 443\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorTextNode.react\n * @format\n * \n */\n\n'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar React = require('react');\nvar ReactDOM = require('react-dom');\nvar UserAgent = require('fbjs/lib/UserAgent');\n\nvar invariant = require('fbjs/lib/invariant');\n\n// In IE, spans with <br> tags render as two newlines. By rendering a span\n// with only a newline character, we can be sure to render a single line.\nvar useNewlineChar = UserAgent.isBrowser('IE <= 11');\n\n/**\n * Check whether the node should be considered a newline.\n */\nfunction isNewline(node) {\n  return useNewlineChar ? node.textContent === '\\n' : node.tagName === 'BR';\n}\n\n/**\n * Placeholder elements for empty text content.\n *\n * What is this `data-text` attribute, anyway? It turns out that we need to\n * put an attribute on the lowest-level text node in order to preserve correct\n * spellcheck handling. If the <span> is naked, Chrome and Safari may do\n * bizarre things to do the DOM -- split text nodes, create extra spans, etc.\n * If the <span> has an attribute, this appears not to happen.\n * See http://jsfiddle.net/9khdavod/ for the failure case, and\n * http://jsfiddle.net/7pg143f7/ for the fixed case.\n */\nvar NEWLINE_A = useNewlineChar ? React.createElement(\n  'span',\n  { key: 'A', 'data-text': 'true' },\n  '\\n'\n) : React.createElement('br', { key: 'A', 'data-text': 'true' });\n\nvar NEWLINE_B = useNewlineChar ? React.createElement(\n  'span',\n  { key: 'B', 'data-text': 'true' },\n  '\\n'\n) : React.createElement('br', { key: 'B', 'data-text': 'true' });\n\n/**\n * The lowest-level component in a `DraftEditor`, the text node component\n * replaces the default React text node implementation. This allows us to\n * perform custom handling of newline behavior and avoid re-rendering text\n * nodes with DOM state that already matches the expectations of our immutable\n * editor state.\n */\nvar DraftEditorTextNode = function (_React$Component) {\n  _inherits(DraftEditorTextNode, _React$Component);\n\n  function DraftEditorTextNode(props) {\n    _classCallCheck(this, DraftEditorTextNode);\n\n    // By flipping this flag, we also keep flipping keys which forces\n    // React to remount this node every time it rerenders.\n    var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));\n\n    _this._forceFlag = false;\n    return _this;\n  }\n\n  DraftEditorTextNode.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n    var node = ReactDOM.findDOMNode(this);\n    var shouldBeNewline = nextProps.children === '';\n    !(node instanceof Element) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'node is not an Element') : invariant(false) : void 0;\n    if (shouldBeNewline) {\n      return !isNewline(node);\n    }\n    return node.textContent !== nextProps.children;\n  };\n\n  DraftEditorTextNode.prototype.componentDidMount = function componentDidMount() {\n    this._forceFlag = !this._forceFlag;\n  };\n\n  DraftEditorTextNode.prototype.componentDidUpdate = function componentDidUpdate() {\n    this._forceFlag = !this._forceFlag;\n  };\n\n  DraftEditorTextNode.prototype.render = function render() {\n    if (this.props.children === '') {\n      return this._forceFlag ? NEWLINE_A : NEWLINE_B;\n    }\n    return React.createElement(\n      'span',\n      { key: this._forceFlag ? 'A' : 'B', 'data-text': 'true' },\n      this.props.children\n    );\n  };\n\n  return DraftEditorTextNode;\n}(React.Component);\n\nmodule.exports = DraftEditorTextNode;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftEditorTextNode.react.js\n// module id = 444\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/**\n * Usage note:\n * This module makes a best effort to export the same data we would internally.\n * At Facebook we use a server-generated module that does the parsing and\n * exports the data for the client to use. We can't rely on a server-side\n * implementation in open source so instead we make use of an open source\n * library to do the heavy lifting and then make some adjustments as necessary.\n * It's likely there will be some differences. Some we can smooth over.\n * Others are going to be harder.\n */\n\n'use strict';\n\nvar UAParser = require('ua-parser-js');\n\nvar UNKNOWN = 'Unknown';\n\nvar PLATFORM_MAP = {\n  'Mac OS': 'Mac OS X'\n};\n\n/**\n * Convert from UAParser platform name to what we expect.\n */\nfunction convertPlatformName(name) {\n  return PLATFORM_MAP[name] || name;\n}\n\n/**\n * Get the version number in parts. This is very naive. We actually get major\n * version as a part of UAParser already, which is generally good enough, but\n * let's get the minor just in case.\n */\nfunction getBrowserVersion(version) {\n  if (!version) {\n    return {\n      major: '',\n      minor: ''\n    };\n  }\n  var parts = version.split('.');\n  return {\n    major: parts[0],\n    minor: parts[1]\n  };\n}\n\n/**\n * Get the UA data fom UAParser and then convert it to the format we're\n * expecting for our APIS.\n */\nvar parser = new UAParser();\nvar results = parser.getResult();\n\n// Do some conversion first.\nvar browserVersionData = getBrowserVersion(results.browser.version);\nvar uaData = {\n  browserArchitecture: results.cpu.architecture || UNKNOWN,\n  browserFullVersion: results.browser.version || UNKNOWN,\n  browserMinorVersion: browserVersionData.minor || UNKNOWN,\n  browserName: results.browser.name || UNKNOWN,\n  browserVersion: results.browser.major || UNKNOWN,\n  deviceName: results.device.model || UNKNOWN,\n  engineName: results.engine.name || UNKNOWN,\n  engineVersion: results.engine.version || UNKNOWN,\n  platformArchitecture: results.cpu.architecture || UNKNOWN,\n  platformName: convertPlatformName(results.os.name) || UNKNOWN,\n  platformVersion: results.os.version || UNKNOWN,\n  platformFullVersion: results.os.version || UNKNOWN\n};\n\nmodule.exports = uaData;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/UserAgentData.js\n// module id = 445\n// module chunks = 2","/////////////////////////////////////////////////////////////////////////////////\n/* UAParser.js v0.7.37\n   Copyright © 2012-2021 Faisal Salman <f@faisalman.com>\n   MIT License *//*\n   Detect Browser, Engine, OS, CPU, and Device type/model from User-Agent data.\n   Supports browser & node.js environment. \n   Demo   : https://faisalman.github.io/ua-parser-js\n   Source : https://github.com/faisalman/ua-parser-js */\n/////////////////////////////////////////////////////////////////////////////////\n\n(function (window, undefined) {\n\n    'use strict';\n\n    //////////////\n    // Constants\n    /////////////\n\n\n    var LIBVERSION  = '0.7.37',\n        EMPTY       = '',\n        UNKNOWN     = '?',\n        FUNC_TYPE   = 'function',\n        UNDEF_TYPE  = 'undefined',\n        OBJ_TYPE    = 'object',\n        STR_TYPE    = 'string',\n        MAJOR       = 'major',\n        MODEL       = 'model',\n        NAME        = 'name',\n        TYPE        = 'type',\n        VENDOR      = 'vendor',\n        VERSION     = 'version',\n        ARCHITECTURE= 'architecture',\n        CONSOLE     = 'console',\n        MOBILE      = 'mobile',\n        TABLET      = 'tablet',\n        SMARTTV     = 'smarttv',\n        WEARABLE    = 'wearable',\n        EMBEDDED    = 'embedded',\n        UA_MAX_LENGTH = 500;\n\n    var AMAZON  = 'Amazon',\n        APPLE   = 'Apple',\n        ASUS    = 'ASUS',\n        BLACKBERRY = 'BlackBerry',\n        BROWSER = 'Browser',\n        CHROME  = 'Chrome',\n        EDGE    = 'Edge',\n        FIREFOX = 'Firefox',\n        GOOGLE  = 'Google',\n        HUAWEI  = 'Huawei',\n        LG      = 'LG',\n        MICROSOFT = 'Microsoft',\n        MOTOROLA  = 'Motorola',\n        OPERA   = 'Opera',\n        SAMSUNG = 'Samsung',\n        SHARP   = 'Sharp',\n        SONY    = 'Sony',\n        XIAOMI  = 'Xiaomi',\n        ZEBRA   = 'Zebra',\n        FACEBOOK    = 'Facebook',\n        CHROMIUM_OS = 'Chromium OS',\n        MAC_OS  = 'Mac OS';\n\n    ///////////\n    // Helper\n    //////////\n\n    var extend = function (regexes, extensions) {\n            var mergedRegexes = {};\n            for (var i in regexes) {\n                if (extensions[i] && extensions[i].length % 2 === 0) {\n                    mergedRegexes[i] = extensions[i].concat(regexes[i]);\n                } else {\n                    mergedRegexes[i] = regexes[i];\n                }\n            }\n            return mergedRegexes;\n        },\n        enumerize = function (arr) {\n            var enums = {};\n            for (var i=0; i<arr.length; i++) {\n                enums[arr[i].toUpperCase()] = arr[i];\n            }\n            return enums;\n        },\n        has = function (str1, str2) {\n            return typeof str1 === STR_TYPE ? lowerize(str2).indexOf(lowerize(str1)) !== -1 : false;\n        },\n        lowerize = function (str) {\n            return str.toLowerCase();\n        },\n        majorize = function (version) {\n            return typeof(version) === STR_TYPE ? version.replace(/[^\\d\\.]/g, EMPTY).split('.')[0] : undefined;\n        },\n        trim = function (str, len) {\n            if (typeof(str) === STR_TYPE) {\n                str = str.replace(/^\\s\\s*/, EMPTY);\n                return typeof(len) === UNDEF_TYPE ? str : str.substring(0, UA_MAX_LENGTH);\n            }\n    };\n\n    ///////////////\n    // Map helper\n    //////////////\n\n    var rgxMapper = function (ua, arrays) {\n\n            var i = 0, j, k, p, q, matches, match;\n\n            // loop through all regexes maps\n            while (i < arrays.length && !matches) {\n\n                var regex = arrays[i],       // even sequence (0,2,4,..)\n                    props = arrays[i + 1];   // odd sequence (1,3,5,..)\n                j = k = 0;\n\n                // try matching uastring with regexes\n                while (j < regex.length && !matches) {\n\n                    if (!regex[j]) { break; }\n                    matches = regex[j++].exec(ua);\n\n                    if (!!matches) {\n                        for (p = 0; p < props.length; p++) {\n                            match = matches[++k];\n                            q = props[p];\n                            // check if given property is actually array\n                            if (typeof q === OBJ_TYPE && q.length > 0) {\n                                if (q.length === 2) {\n                                    if (typeof q[1] == FUNC_TYPE) {\n                                        // assign modified match\n                                        this[q[0]] = q[1].call(this, match);\n                                    } else {\n                                        // assign given value, ignore regex match\n                                        this[q[0]] = q[1];\n                                    }\n                                } else if (q.length === 3) {\n                                    // check whether function or regex\n                                    if (typeof q[1] === FUNC_TYPE && !(q[1].exec && q[1].test)) {\n                                        // call function (usually string mapper)\n                                        this[q[0]] = match ? q[1].call(this, match, q[2]) : undefined;\n                                    } else {\n                                        // sanitize match using given regex\n                                        this[q[0]] = match ? match.replace(q[1], q[2]) : undefined;\n                                    }\n                                } else if (q.length === 4) {\n                                        this[q[0]] = match ? q[3].call(this, match.replace(q[1], q[2])) : undefined;\n                                }\n                            } else {\n                                this[q] = match ? match : undefined;\n                            }\n                        }\n                    }\n                }\n                i += 2;\n            }\n        },\n\n        strMapper = function (str, map) {\n\n            for (var i in map) {\n                // check if current value is array\n                if (typeof map[i] === OBJ_TYPE && map[i].length > 0) {\n                    for (var j = 0; j < map[i].length; j++) {\n                        if (has(map[i][j], str)) {\n                            return (i === UNKNOWN) ? undefined : i;\n                        }\n                    }\n                } else if (has(map[i], str)) {\n                    return (i === UNKNOWN) ? undefined : i;\n                }\n            }\n            return str;\n    };\n\n    ///////////////\n    // String map\n    //////////////\n\n    // Safari < 3.0\n    var oldSafariMap = {\n            '1.0'   : '/8',\n            '1.2'   : '/1',\n            '1.3'   : '/3',\n            '2.0'   : '/412',\n            '2.0.2' : '/416',\n            '2.0.3' : '/417',\n            '2.0.4' : '/419',\n            '?'     : '/'\n        },\n        windowsVersionMap = {\n            'ME'        : '4.90',\n            'NT 3.11'   : 'NT3.51',\n            'NT 4.0'    : 'NT4.0',\n            '2000'      : 'NT 5.0',\n            'XP'        : ['NT 5.1', 'NT 5.2'],\n            'Vista'     : 'NT 6.0',\n            '7'         : 'NT 6.1',\n            '8'         : 'NT 6.2',\n            '8.1'       : 'NT 6.3',\n            '10'        : ['NT 6.4', 'NT 10.0'],\n            'RT'        : 'ARM'\n    };\n\n    //////////////\n    // Regex map\n    /////////////\n\n    var regexes = {\n\n        browser : [[\n\n            /\\b(?:crmo|crios)\\/([\\w\\.]+)/i                                      // Chrome for Android/iOS\n            ], [VERSION, [NAME, 'Chrome']], [\n            /edg(?:e|ios|a)?\\/([\\w\\.]+)/i                                       // Microsoft Edge\n            ], [VERSION, [NAME, 'Edge']], [\n\n            // Presto based\n            /(opera mini)\\/([-\\w\\.]+)/i,                                        // Opera Mini\n            /(opera [mobiletab]{3,6})\\b.+version\\/([-\\w\\.]+)/i,                 // Opera Mobi/Tablet\n            /(opera)(?:.+version\\/|[\\/ ]+)([\\w\\.]+)/i                           // Opera\n            ], [NAME, VERSION], [\n            /opios[\\/ ]+([\\w\\.]+)/i                                             // Opera mini on iphone >= 8.0\n            ], [VERSION, [NAME, OPERA+' Mini']], [\n            /\\bopr\\/([\\w\\.]+)/i                                                 // Opera Webkit\n            ], [VERSION, [NAME, OPERA]], [\n\n            // Mixed\n            /\\bb[ai]*d(?:uhd|[ub]*[aekoprswx]{5,6})[\\/ ]?([\\w\\.]+)/i            // Baidu\n            ], [VERSION, [NAME, 'Baidu']], [\n            /(kindle)\\/([\\w\\.]+)/i,                                             // Kindle\n            /(lunascape|maxthon|netfront|jasmine|blazer)[\\/ ]?([\\w\\.]*)/i,      // Lunascape/Maxthon/Netfront/Jasmine/Blazer\n            // Trident based\n            /(avant|iemobile|slim)\\s?(?:browser)?[\\/ ]?([\\w\\.]*)/i,             // Avant/IEMobile/SlimBrowser\n            /(?:ms|\\()(ie) ([\\w\\.]+)/i,                                         // Internet Explorer\n\n            // Webkit/KHTML based                                               // Flock/RockMelt/Midori/Epiphany/Silk/Skyfire/Bolt/Iron/Iridium/PhantomJS/Bowser/QupZilla/Falkon\n            /(flock|rockmelt|midori|epiphany|silk|skyfire|bolt|iron|vivaldi|iridium|phantomjs|bowser|quark|qupzilla|falkon|rekonq|puffin|brave|whale(?!.+naver)|qqbrowserlite|qq|duckduckgo)\\/([-\\w\\.]+)/i,\n                                                                                // Rekonq/Puffin/Brave/Whale/QQBrowserLite/QQ, aka ShouQ\n            /(heytap|ovi)browser\\/([\\d\\.]+)/i,                                  // Heytap/Ovi\n            /(weibo)__([\\d\\.]+)/i                                               // Weibo\n            ], [NAME, VERSION], [\n            /(?:\\buc? ?browser|(?:juc.+)ucweb)[\\/ ]?([\\w\\.]+)/i                 // UCBrowser\n            ], [VERSION, [NAME, 'UC'+BROWSER]], [\n            /microm.+\\bqbcore\\/([\\w\\.]+)/i,                                     // WeChat Desktop for Windows Built-in Browser\n            /\\bqbcore\\/([\\w\\.]+).+microm/i,\n            /micromessenger\\/([\\w\\.]+)/i                                        // WeChat\n            ], [VERSION, [NAME, 'WeChat']], [\n            /konqueror\\/([\\w\\.]+)/i                                             // Konqueror\n            ], [VERSION, [NAME, 'Konqueror']], [\n            /trident.+rv[: ]([\\w\\.]{1,9})\\b.+like gecko/i                       // IE11\n            ], [VERSION, [NAME, 'IE']], [\n            /ya(?:search)?browser\\/([\\w\\.]+)/i                                  // Yandex\n            ], [VERSION, [NAME, 'Yandex']], [\n            /slbrowser\\/([\\w\\.]+)/i                                             // Smart Lenovo Browser\n            ], [VERSION, [NAME, 'Smart Lenovo '+BROWSER]], [\n            /(avast|avg)\\/([\\w\\.]+)/i                                           // Avast/AVG Secure Browser\n            ], [[NAME, /(.+)/, '$1 Secure '+BROWSER], VERSION], [\n            /\\bfocus\\/([\\w\\.]+)/i                                               // Firefox Focus\n            ], [VERSION, [NAME, FIREFOX+' Focus']], [\n            /\\bopt\\/([\\w\\.]+)/i                                                 // Opera Touch\n            ], [VERSION, [NAME, OPERA+' Touch']], [\n            /coc_coc\\w+\\/([\\w\\.]+)/i                                            // Coc Coc Browser\n            ], [VERSION, [NAME, 'Coc Coc']], [\n            /dolfin\\/([\\w\\.]+)/i                                                // Dolphin\n            ], [VERSION, [NAME, 'Dolphin']], [\n            /coast\\/([\\w\\.]+)/i                                                 // Opera Coast\n            ], [VERSION, [NAME, OPERA+' Coast']], [\n            /miuibrowser\\/([\\w\\.]+)/i                                           // MIUI Browser\n            ], [VERSION, [NAME, 'MIUI '+BROWSER]], [\n            /fxios\\/([-\\w\\.]+)/i                                                // Firefox for iOS\n            ], [VERSION, [NAME, FIREFOX]], [\n            /\\bqihu|(qi?ho?o?|360)browser/i                                     // 360\n            ], [[NAME, '360 ' + BROWSER]], [\n            /(oculus|sailfish|huawei|vivo)browser\\/([\\w\\.]+)/i\n            ], [[NAME, /(.+)/, '$1 ' + BROWSER], VERSION], [                    // Oculus/Sailfish/HuaweiBrowser/VivoBrowser\n            /samsungbrowser\\/([\\w\\.]+)/i                                        // Samsung Internet\n            ], [VERSION, [NAME, SAMSUNG + ' Internet']], [\n            /(comodo_dragon)\\/([\\w\\.]+)/i                                       // Comodo Dragon\n            ], [[NAME, /_/g, ' '], VERSION], [\n            /metasr[\\/ ]?([\\d\\.]+)/i                                            // Sogou Explorer\n            ], [VERSION, [NAME, 'Sogou Explorer']], [\n            /(sogou)mo\\w+\\/([\\d\\.]+)/i                                          // Sogou Mobile\n            ], [[NAME, 'Sogou Mobile'], VERSION], [\n            /(electron)\\/([\\w\\.]+) safari/i,                                    // Electron-based App\n            /(tesla)(?: qtcarbrowser|\\/(20\\d\\d\\.[-\\w\\.]+))/i,                   // Tesla\n            /m?(qqbrowser|2345Explorer)[\\/ ]?([\\w\\.]+)/i                        // QQBrowser/2345 Browser\n            ], [NAME, VERSION], [\n            /(lbbrowser)/i,                                                     // LieBao Browser\n            /\\[(linkedin)app\\]/i                                                // LinkedIn App for iOS & Android\n            ], [NAME], [\n\n            // WebView\n            /((?:fban\\/fbios|fb_iab\\/fb4a)(?!.+fbav)|;fbav\\/([\\w\\.]+);)/i       // Facebook App for iOS & Android\n            ], [[NAME, FACEBOOK], VERSION], [\n            /(Klarna)\\/([\\w\\.]+)/i,                                             // Klarna Shopping Browser for iOS & Android\n            /(kakao(?:talk|story))[\\/ ]([\\w\\.]+)/i,                             // Kakao App\n            /(naver)\\(.*?(\\d+\\.[\\w\\.]+).*\\)/i,                                  // Naver InApp\n            /safari (line)\\/([\\w\\.]+)/i,                                        // Line App for iOS\n            /\\b(line)\\/([\\w\\.]+)\\/iab/i,                                        // Line App for Android\n            /(alipay)client\\/([\\w\\.]+)/i,                                       // Alipay\n            /(chromium|instagram|snapchat)[\\/ ]([-\\w\\.]+)/i                     // Chromium/Instagram/Snapchat\n            ], [NAME, VERSION], [\n            /\\bgsa\\/([\\w\\.]+) .*safari\\//i                                      // Google Search Appliance on iOS\n            ], [VERSION, [NAME, 'GSA']], [\n            /musical_ly(?:.+app_?version\\/|_)([\\w\\.]+)/i                        // TikTok\n            ], [VERSION, [NAME, 'TikTok']], [\n\n            /headlesschrome(?:\\/([\\w\\.]+)| )/i                                  // Chrome Headless\n            ], [VERSION, [NAME, CHROME+' Headless']], [\n\n            / wv\\).+(chrome)\\/([\\w\\.]+)/i                                       // Chrome WebView\n            ], [[NAME, CHROME+' WebView'], VERSION], [\n\n            /droid.+ version\\/([\\w\\.]+)\\b.+(?:mobile safari|safari)/i           // Android Browser\n            ], [VERSION, [NAME, 'Android '+BROWSER]], [\n\n            /(chrome|omniweb|arora|[tizenoka]{5} ?browser)\\/v?([\\w\\.]+)/i       // Chrome/OmniWeb/Arora/Tizen/Nokia\n            ], [NAME, VERSION], [\n\n            /version\\/([\\w\\.\\,]+) .*mobile\\/\\w+ (safari)/i                      // Mobile Safari\n            ], [VERSION, [NAME, 'Mobile Safari']], [\n            /version\\/([\\w(\\.|\\,)]+) .*(mobile ?safari|safari)/i                // Safari & Safari Mobile\n            ], [VERSION, NAME], [\n            /webkit.+?(mobile ?safari|safari)(\\/[\\w\\.]+)/i                      // Safari < 3.0\n            ], [NAME, [VERSION, strMapper, oldSafariMap]], [\n\n            /(webkit|khtml)\\/([\\w\\.]+)/i\n            ], [NAME, VERSION], [\n\n            // Gecko based\n            /(navigator|netscape\\d?)\\/([-\\w\\.]+)/i                              // Netscape\n            ], [[NAME, 'Netscape'], VERSION], [\n            /mobile vr; rv:([\\w\\.]+)\\).+firefox/i                               // Firefox Reality\n            ], [VERSION, [NAME, FIREFOX+' Reality']], [\n            /ekiohf.+(flow)\\/([\\w\\.]+)/i,                                       // Flow\n            /(swiftfox)/i,                                                      // Swiftfox\n            /(icedragon|iceweasel|camino|chimera|fennec|maemo browser|minimo|conkeror|klar)[\\/ ]?([\\w\\.\\+]+)/i,\n                                                                                // IceDragon/Iceweasel/Camino/Chimera/Fennec/Maemo/Minimo/Conkeror/Klar\n            /(seamonkey|k-meleon|icecat|iceape|firebird|phoenix|palemoon|basilisk|waterfox)\\/([-\\w\\.]+)$/i,\n                                                                                // Firefox/SeaMonkey/K-Meleon/IceCat/IceApe/Firebird/Phoenix\n            /(firefox)\\/([\\w\\.]+)/i,                                            // Other Firefox-based\n            /(mozilla)\\/([\\w\\.]+) .+rv\\:.+gecko\\/\\d+/i,                         // Mozilla\n\n            // Other\n            /(polaris|lynx|dillo|icab|doris|amaya|w3m|netsurf|sleipnir|obigo|mosaic|(?:go|ice|up)[\\. ]?browser)[-\\/ ]?v?([\\w\\.]+)/i,\n                                                                                // Polaris/Lynx/Dillo/iCab/Doris/Amaya/w3m/NetSurf/Sleipnir/Obigo/Mosaic/Go/ICE/UP.Browser\n            /(links) \\(([\\w\\.]+)/i,                                             // Links\n            /panasonic;(viera)/i                                                // Panasonic Viera\n            ], [NAME, VERSION], [\n            \n            /(cobalt)\\/([\\w\\.]+)/i                                              // Cobalt\n            ], [NAME, [VERSION, /master.|lts./, \"\"]]\n        ],\n\n        cpu : [[\n\n            /(?:(amd|x(?:(?:86|64)[-_])?|wow|win)64)[;\\)]/i                     // AMD64 (x64)\n            ], [[ARCHITECTURE, 'amd64']], [\n\n            /(ia32(?=;))/i                                                      // IA32 (quicktime)\n            ], [[ARCHITECTURE, lowerize]], [\n\n            /((?:i[346]|x)86)[;\\)]/i                                            // IA32 (x86)\n            ], [[ARCHITECTURE, 'ia32']], [\n\n            /\\b(aarch64|arm(v?8e?l?|_?64))\\b/i                                 // ARM64\n            ], [[ARCHITECTURE, 'arm64']], [\n\n            /\\b(arm(?:v[67])?ht?n?[fl]p?)\\b/i                                   // ARMHF\n            ], [[ARCHITECTURE, 'armhf']], [\n\n            // PocketPC mistakenly identified as PowerPC\n            /windows (ce|mobile); ppc;/i\n            ], [[ARCHITECTURE, 'arm']], [\n\n            /((?:ppc|powerpc)(?:64)?)(?: mac|;|\\))/i                            // PowerPC\n            ], [[ARCHITECTURE, /ower/, EMPTY, lowerize]], [\n\n            /(sun4\\w)[;\\)]/i                                                    // SPARC\n            ], [[ARCHITECTURE, 'sparc']], [\n\n            /((?:avr32|ia64(?=;))|68k(?=\\))|\\barm(?=v(?:[1-7]|[5-7]1)l?|;|eabi)|(?=atmel )avr|(?:irix|mips|sparc)(?:64)?\\b|pa-risc)/i\n                                                                                // IA64, 68K, ARM/64, AVR/32, IRIX/64, MIPS/64, SPARC/64, PA-RISC\n            ], [[ARCHITECTURE, lowerize]]\n        ],\n\n        device : [[\n\n            //////////////////////////\n            // MOBILES & TABLETS\n            /////////////////////////\n\n            // Samsung\n            /\\b(sch-i[89]0\\d|shw-m380s|sm-[ptx]\\w{2,4}|gt-[pn]\\d{2,4}|sgh-t8[56]9|nexus 10)/i\n            ], [MODEL, [VENDOR, SAMSUNG], [TYPE, TABLET]], [\n            /\\b((?:s[cgp]h|gt|sm)-\\w+|sc[g-]?[\\d]+a?|galaxy nexus)/i,\n            /samsung[- ]([-\\w]+)/i,\n            /sec-(sgh\\w+)/i\n            ], [MODEL, [VENDOR, SAMSUNG], [TYPE, MOBILE]], [\n\n            // Apple\n            /(?:\\/|\\()(ip(?:hone|od)[\\w, ]*)(?:\\/|;)/i                          // iPod/iPhone\n            ], [MODEL, [VENDOR, APPLE], [TYPE, MOBILE]], [\n            /\\((ipad);[-\\w\\),; ]+apple/i,                                       // iPad\n            /applecoremedia\\/[\\w\\.]+ \\((ipad)/i,\n            /\\b(ipad)\\d\\d?,\\d\\d?[;\\]].+ios/i\n            ], [MODEL, [VENDOR, APPLE], [TYPE, TABLET]], [\n            /(macintosh);/i\n            ], [MODEL, [VENDOR, APPLE]], [\n\n            // Sharp\n            /\\b(sh-?[altvz]?\\d\\d[a-ekm]?)/i\n            ], [MODEL, [VENDOR, SHARP], [TYPE, MOBILE]], [\n\n            // Huawei\n            /\\b((?:ag[rs][23]?|bah2?|sht?|btv)-a?[lw]\\d{2})\\b(?!.+d\\/s)/i\n            ], [MODEL, [VENDOR, HUAWEI], [TYPE, TABLET]], [\n            /(?:huawei|honor)([-\\w ]+)[;\\)]/i,\n            /\\b(nexus 6p|\\w{2,4}e?-[atu]?[ln][\\dx][012359c][adn]?)\\b(?!.+d\\/s)/i\n            ], [MODEL, [VENDOR, HUAWEI], [TYPE, MOBILE]], [\n\n            // Xiaomi\n            /\\b(poco[\\w ]+|m2\\d{3}j\\d\\d[a-z]{2})(?: bui|\\))/i,                  // Xiaomi POCO\n            /\\b; (\\w+) build\\/hm\\1/i,                                           // Xiaomi Hongmi 'numeric' models\n            /\\b(hm[-_ ]?note?[_ ]?(?:\\d\\w)?) bui/i,                             // Xiaomi Hongmi\n            /\\b(redmi[\\-_ ]?(?:note|k)?[\\w_ ]+)(?: bui|\\))/i,                   // Xiaomi Redmi\n            /oid[^\\)]+; (m?[12][0-389][01]\\w{3,6}[c-y])( bui|; wv|\\))/i,        // Xiaomi Redmi 'numeric' models\n            /\\b(mi[-_ ]?(?:a\\d|one|one[_ ]plus|note lte|max|cc)?[_ ]?(?:\\d?\\w?)[_ ]?(?:plus|se|lite)?)(?: bui|\\))/i // Xiaomi Mi\n            ], [[MODEL, /_/g, ' '], [VENDOR, XIAOMI], [TYPE, MOBILE]], [\n            /oid[^\\)]+; (2\\d{4}(283|rpbf)[cgl])( bui|\\))/i,                     // Redmi Pad\n            /\\b(mi[-_ ]?(?:pad)(?:[\\w_ ]+))(?: bui|\\))/i                        // Mi Pad tablets\n            ],[[MODEL, /_/g, ' '], [VENDOR, XIAOMI], [TYPE, TABLET]], [\n\n            // OPPO\n            /; (\\w+) bui.+ oppo/i,\n            /\\b(cph[12]\\d{3}|p(?:af|c[al]|d\\w|e[ar])[mt]\\d0|x9007|a101op)\\b/i\n            ], [MODEL, [VENDOR, 'OPPO'], [TYPE, MOBILE]], [\n\n            // Vivo\n            /vivo (\\w+)(?: bui|\\))/i,\n            /\\b(v[12]\\d{3}\\w?[at])(?: bui|;)/i\n            ], [MODEL, [VENDOR, 'Vivo'], [TYPE, MOBILE]], [\n\n            // Realme\n            /\\b(rmx[1-3]\\d{3})(?: bui|;|\\))/i\n            ], [MODEL, [VENDOR, 'Realme'], [TYPE, MOBILE]], [\n\n            // Motorola\n            /\\b(milestone|droid(?:[2-4x]| (?:bionic|x2|pro|razr))?:?( 4g)?)\\b[\\w ]+build\\//i,\n            /\\bmot(?:orola)?[- ](\\w*)/i,\n            /((?:moto[\\w\\(\\) ]+|xt\\d{3,4}|nexus 6)(?= bui|\\)))/i\n            ], [MODEL, [VENDOR, MOTOROLA], [TYPE, MOBILE]], [\n            /\\b(mz60\\d|xoom[2 ]{0,2}) build\\//i\n            ], [MODEL, [VENDOR, MOTOROLA], [TYPE, TABLET]], [\n\n            // LG\n            /((?=lg)?[vl]k\\-?\\d{3}) bui| 3\\.[-\\w; ]{10}lg?-([06cv9]{3,4})/i\n            ], [MODEL, [VENDOR, LG], [TYPE, TABLET]], [\n            /(lm(?:-?f100[nv]?|-[\\w\\.]+)(?= bui|\\))|nexus [45])/i,\n            /\\blg[-e;\\/ ]+((?!browser|netcast|android tv)\\w+)/i,\n            /\\blg-?([\\d\\w]+) bui/i\n            ], [MODEL, [VENDOR, LG], [TYPE, MOBILE]], [\n\n            // Lenovo\n            /(ideatab[-\\w ]+)/i,\n            /lenovo ?(s[56]000[-\\w]+|tab(?:[\\w ]+)|yt[-\\d\\w]{6}|tb[-\\d\\w]{6})/i\n            ], [MODEL, [VENDOR, 'Lenovo'], [TYPE, TABLET]], [\n\n            // Nokia\n            /(?:maemo|nokia).*(n900|lumia \\d+)/i,\n            /nokia[-_ ]?([-\\w\\.]*)/i\n            ], [[MODEL, /_/g, ' '], [VENDOR, 'Nokia'], [TYPE, MOBILE]], [\n\n            // Google\n            /(pixel c)\\b/i                                                      // Google Pixel C\n            ], [MODEL, [VENDOR, GOOGLE], [TYPE, TABLET]], [\n            /droid.+; (pixel[\\daxl ]{0,6})(?: bui|\\))/i                         // Google Pixel\n            ], [MODEL, [VENDOR, GOOGLE], [TYPE, MOBILE]], [\n\n            // Sony\n            /droid.+ (a?\\d[0-2]{2}so|[c-g]\\d{4}|so[-gl]\\w+|xq-a\\w[4-7][12])(?= bui|\\).+chrome\\/(?![1-6]{0,1}\\d\\.))/i\n            ], [MODEL, [VENDOR, SONY], [TYPE, MOBILE]], [\n            /sony tablet [ps]/i,\n            /\\b(?:sony)?sgp\\w+(?: bui|\\))/i\n            ], [[MODEL, 'Xperia Tablet'], [VENDOR, SONY], [TYPE, TABLET]], [\n\n            // OnePlus\n            / (kb2005|in20[12]5|be20[12][59])\\b/i,\n            /(?:one)?(?:plus)? (a\\d0\\d\\d)(?: b|\\))/i\n            ], [MODEL, [VENDOR, 'OnePlus'], [TYPE, MOBILE]], [\n\n            // Amazon\n            /(alexa)webm/i,\n            /(kf[a-z]{2}wi|aeo[c-r]{2})( bui|\\))/i,                             // Kindle Fire without Silk / Echo Show\n            /(kf[a-z]+)( bui|\\)).+silk\\//i                                      // Kindle Fire HD\n            ], [MODEL, [VENDOR, AMAZON], [TYPE, TABLET]], [\n            /((?:sd|kf)[0349hijorstuw]+)( bui|\\)).+silk\\//i                     // Fire Phone\n            ], [[MODEL, /(.+)/g, 'Fire Phone $1'], [VENDOR, AMAZON], [TYPE, MOBILE]], [\n\n            // BlackBerry\n            /(playbook);[-\\w\\),; ]+(rim)/i                                      // BlackBerry PlayBook\n            ], [MODEL, VENDOR, [TYPE, TABLET]], [\n            /\\b((?:bb[a-f]|st[hv])100-\\d)/i,\n            /\\(bb10; (\\w+)/i                                                    // BlackBerry 10\n            ], [MODEL, [VENDOR, BLACKBERRY], [TYPE, MOBILE]], [\n\n            // Asus\n            /(?:\\b|asus_)(transfo[prime ]{4,10} \\w+|eeepc|slider \\w+|nexus 7|padfone|p00[cj])/i\n            ], [MODEL, [VENDOR, ASUS], [TYPE, TABLET]], [\n            / (z[bes]6[027][012][km][ls]|zenfone \\d\\w?)\\b/i\n            ], [MODEL, [VENDOR, ASUS], [TYPE, MOBILE]], [\n\n            // HTC\n            /(nexus 9)/i                                                        // HTC Nexus 9\n            ], [MODEL, [VENDOR, 'HTC'], [TYPE, TABLET]], [\n            /(htc)[-;_ ]{1,2}([\\w ]+(?=\\)| bui)|\\w+)/i,                         // HTC\n\n            // ZTE\n            /(zte)[- ]([\\w ]+?)(?: bui|\\/|\\))/i,\n            /(alcatel|geeksphone|nexian|panasonic(?!(?:;|\\.))|sony(?!-bra))[-_ ]?([-\\w]*)/i         // Alcatel/GeeksPhone/Nexian/Panasonic/Sony\n            ], [VENDOR, [MODEL, /_/g, ' '], [TYPE, MOBILE]], [\n\n            // Acer\n            /droid.+; ([ab][1-7]-?[0178a]\\d\\d?)/i\n            ], [MODEL, [VENDOR, 'Acer'], [TYPE, TABLET]], [\n\n            // Meizu\n            /droid.+; (m[1-5] note) bui/i,\n            /\\bmz-([-\\w]{2,})/i\n            ], [MODEL, [VENDOR, 'Meizu'], [TYPE, MOBILE]], [\n                \n            // Ulefone\n            /; ((?:power )?armor(?:[\\w ]{0,8}))(?: bui|\\))/i\n            ], [MODEL, [VENDOR, 'Ulefone'], [TYPE, MOBILE]], [\n\n            // MIXED\n            /(blackberry|benq|palm(?=\\-)|sonyericsson|acer|asus|dell|meizu|motorola|polytron|infinix|tecno)[-_ ]?([-\\w]*)/i,\n                                                                                // BlackBerry/BenQ/Palm/Sony-Ericsson/Acer/Asus/Dell/Meizu/Motorola/Polytron\n            /(hp) ([\\w ]+\\w)/i,                                                 // HP iPAQ\n            /(asus)-?(\\w+)/i,                                                   // Asus\n            /(microsoft); (lumia[\\w ]+)/i,                                      // Microsoft Lumia\n            /(lenovo)[-_ ]?([-\\w]+)/i,                                          // Lenovo\n            /(jolla)/i,                                                         // Jolla\n            /(oppo) ?([\\w ]+) bui/i                                             // OPPO\n            ], [VENDOR, MODEL, [TYPE, MOBILE]], [\n\n            /(kobo)\\s(ereader|touch)/i,                                         // Kobo\n            /(archos) (gamepad2?)/i,                                            // Archos\n            /(hp).+(touchpad(?!.+tablet)|tablet)/i,                             // HP TouchPad\n            /(kindle)\\/([\\w\\.]+)/i,                                             // Kindle\n            /(nook)[\\w ]+build\\/(\\w+)/i,                                        // Nook\n            /(dell) (strea[kpr\\d ]*[\\dko])/i,                                   // Dell Streak\n            /(le[- ]+pan)[- ]+(\\w{1,9}) bui/i,                                  // Le Pan Tablets\n            /(trinity)[- ]*(t\\d{3}) bui/i,                                      // Trinity Tablets\n            /(gigaset)[- ]+(q\\w{1,9}) bui/i,                                    // Gigaset Tablets\n            /(vodafone) ([\\w ]+)(?:\\)| bui)/i                                   // Vodafone\n            ], [VENDOR, MODEL, [TYPE, TABLET]], [\n\n            /(surface duo)/i                                                    // Surface Duo\n            ], [MODEL, [VENDOR, MICROSOFT], [TYPE, TABLET]], [\n            /droid [\\d\\.]+; (fp\\du?)(?: b|\\))/i                                 // Fairphone\n            ], [MODEL, [VENDOR, 'Fairphone'], [TYPE, MOBILE]], [\n            /(u304aa)/i                                                         // AT&T\n            ], [MODEL, [VENDOR, 'AT&T'], [TYPE, MOBILE]], [\n            /\\bsie-(\\w*)/i                                                      // Siemens\n            ], [MODEL, [VENDOR, 'Siemens'], [TYPE, MOBILE]], [\n            /\\b(rct\\w+) b/i                                                     // RCA Tablets\n            ], [MODEL, [VENDOR, 'RCA'], [TYPE, TABLET]], [\n            /\\b(venue[\\d ]{2,7}) b/i                                            // Dell Venue Tablets\n            ], [MODEL, [VENDOR, 'Dell'], [TYPE, TABLET]], [\n            /\\b(q(?:mv|ta)\\w+) b/i                                              // Verizon Tablet\n            ], [MODEL, [VENDOR, 'Verizon'], [TYPE, TABLET]], [\n            /\\b(?:barnes[& ]+noble |bn[rt])([\\w\\+ ]*) b/i                       // Barnes & Noble Tablet\n            ], [MODEL, [VENDOR, 'Barnes & Noble'], [TYPE, TABLET]], [\n            /\\b(tm\\d{3}\\w+) b/i\n            ], [MODEL, [VENDOR, 'NuVision'], [TYPE, TABLET]], [\n            /\\b(k88) b/i                                                        // ZTE K Series Tablet\n            ], [MODEL, [VENDOR, 'ZTE'], [TYPE, TABLET]], [\n            /\\b(nx\\d{3}j) b/i                                                   // ZTE Nubia\n            ], [MODEL, [VENDOR, 'ZTE'], [TYPE, MOBILE]], [\n            /\\b(gen\\d{3}) b.+49h/i                                              // Swiss GEN Mobile\n            ], [MODEL, [VENDOR, 'Swiss'], [TYPE, MOBILE]], [\n            /\\b(zur\\d{3}) b/i                                                   // Swiss ZUR Tablet\n            ], [MODEL, [VENDOR, 'Swiss'], [TYPE, TABLET]], [\n            /\\b((zeki)?tb.*\\b) b/i                                              // Zeki Tablets\n            ], [MODEL, [VENDOR, 'Zeki'], [TYPE, TABLET]], [\n            /\\b([yr]\\d{2}) b/i,\n            /\\b(dragon[- ]+touch |dt)(\\w{5}) b/i                                // Dragon Touch Tablet\n            ], [[VENDOR, 'Dragon Touch'], MODEL, [TYPE, TABLET]], [\n            /\\b(ns-?\\w{0,9}) b/i                                                // Insignia Tablets\n            ], [MODEL, [VENDOR, 'Insignia'], [TYPE, TABLET]], [\n            /\\b((nxa|next)-?\\w{0,9}) b/i                                        // NextBook Tablets\n            ], [MODEL, [VENDOR, 'NextBook'], [TYPE, TABLET]], [\n            /\\b(xtreme\\_)?(v(1[045]|2[015]|[3469]0|7[05])) b/i                  // Voice Xtreme Phones\n            ], [[VENDOR, 'Voice'], MODEL, [TYPE, MOBILE]], [\n            /\\b(lvtel\\-)?(v1[12]) b/i                                           // LvTel Phones\n            ], [[VENDOR, 'LvTel'], MODEL, [TYPE, MOBILE]], [\n            /\\b(ph-1) /i                                                        // Essential PH-1\n            ], [MODEL, [VENDOR, 'Essential'], [TYPE, MOBILE]], [\n            /\\b(v(100md|700na|7011|917g).*\\b) b/i                               // Envizen Tablets\n            ], [MODEL, [VENDOR, 'Envizen'], [TYPE, TABLET]], [\n            /\\b(trio[-\\w\\. ]+) b/i                                              // MachSpeed Tablets\n            ], [MODEL, [VENDOR, 'MachSpeed'], [TYPE, TABLET]], [\n            /\\btu_(1491) b/i                                                    // Rotor Tablets\n            ], [MODEL, [VENDOR, 'Rotor'], [TYPE, TABLET]], [\n            /(shield[\\w ]+) b/i                                                 // Nvidia Shield Tablets\n            ], [MODEL, [VENDOR, 'Nvidia'], [TYPE, TABLET]], [\n            /(sprint) (\\w+)/i                                                   // Sprint Phones\n            ], [VENDOR, MODEL, [TYPE, MOBILE]], [\n            /(kin\\.[onetw]{3})/i                                                // Microsoft Kin\n            ], [[MODEL, /\\./g, ' '], [VENDOR, MICROSOFT], [TYPE, MOBILE]], [\n            /droid.+; (cc6666?|et5[16]|mc[239][23]x?|vc8[03]x?)\\)/i             // Zebra\n            ], [MODEL, [VENDOR, ZEBRA], [TYPE, TABLET]], [\n            /droid.+; (ec30|ps20|tc[2-8]\\d[kx])\\)/i\n            ], [MODEL, [VENDOR, ZEBRA], [TYPE, MOBILE]], [\n\n            ///////////////////\n            // SMARTTVS\n            ///////////////////\n\n            /smart-tv.+(samsung)/i                                              // Samsung\n            ], [VENDOR, [TYPE, SMARTTV]], [\n            /hbbtv.+maple;(\\d+)/i\n            ], [[MODEL, /^/, 'SmartTV'], [VENDOR, SAMSUNG], [TYPE, SMARTTV]], [\n            /(nux; netcast.+smarttv|lg (netcast\\.tv-201\\d|android tv))/i        // LG SmartTV\n            ], [[VENDOR, LG], [TYPE, SMARTTV]], [\n            /(apple) ?tv/i                                                      // Apple TV\n            ], [VENDOR, [MODEL, APPLE+' TV'], [TYPE, SMARTTV]], [\n            /crkey/i                                                            // Google Chromecast\n            ], [[MODEL, CHROME+'cast'], [VENDOR, GOOGLE], [TYPE, SMARTTV]], [\n            /droid.+aft(\\w+)( bui|\\))/i                                         // Fire TV\n            ], [MODEL, [VENDOR, AMAZON], [TYPE, SMARTTV]], [\n            /\\(dtv[\\);].+(aquos)/i,\n            /(aquos-tv[\\w ]+)\\)/i                                               // Sharp\n            ], [MODEL, [VENDOR, SHARP], [TYPE, SMARTTV]],[\n            /(bravia[\\w ]+)( bui|\\))/i                                              // Sony\n            ], [MODEL, [VENDOR, SONY], [TYPE, SMARTTV]], [\n            /(mitv-\\w{5}) bui/i                                                 // Xiaomi\n            ], [MODEL, [VENDOR, XIAOMI], [TYPE, SMARTTV]], [\n            /Hbbtv.*(technisat) (.*);/i                                         // TechniSAT\n            ], [VENDOR, MODEL, [TYPE, SMARTTV]], [\n            /\\b(roku)[\\dx]*[\\)\\/]((?:dvp-)?[\\d\\.]*)/i,                          // Roku\n            /hbbtv\\/\\d+\\.\\d+\\.\\d+ +\\([\\w\\+ ]*; *([\\w\\d][^;]*);([^;]*)/i         // HbbTV devices\n            ], [[VENDOR, trim], [MODEL, trim], [TYPE, SMARTTV]], [\n            /\\b(android tv|smart[- ]?tv|opera tv|tv; rv:)\\b/i                   // SmartTV from Unidentified Vendors\n            ], [[TYPE, SMARTTV]], [\n\n            ///////////////////\n            // CONSOLES\n            ///////////////////\n\n            /(ouya)/i,                                                          // Ouya\n            /(nintendo) ([wids3utch]+)/i                                        // Nintendo\n            ], [VENDOR, MODEL, [TYPE, CONSOLE]], [\n            /droid.+; (shield) bui/i                                            // Nvidia\n            ], [MODEL, [VENDOR, 'Nvidia'], [TYPE, CONSOLE]], [\n            /(playstation [345portablevi]+)/i                                   // Playstation\n            ], [MODEL, [VENDOR, SONY], [TYPE, CONSOLE]], [\n            /\\b(xbox(?: one)?(?!; xbox))[\\); ]/i                                // Microsoft Xbox\n            ], [MODEL, [VENDOR, MICROSOFT], [TYPE, CONSOLE]], [\n\n            ///////////////////\n            // WEARABLES\n            ///////////////////\n\n            /((pebble))app/i                                                    // Pebble\n            ], [VENDOR, MODEL, [TYPE, WEARABLE]], [\n            /(watch)(?: ?os[,\\/]|\\d,\\d\\/)[\\d\\.]+/i                              // Apple Watch\n            ], [MODEL, [VENDOR, APPLE], [TYPE, WEARABLE]], [\n            /droid.+; (glass) \\d/i                                              // Google Glass\n            ], [MODEL, [VENDOR, GOOGLE], [TYPE, WEARABLE]], [\n            /droid.+; (wt63?0{2,3})\\)/i\n            ], [MODEL, [VENDOR, ZEBRA], [TYPE, WEARABLE]], [\n            /(quest( 2| pro)?)/i                                                // Oculus Quest\n            ], [MODEL, [VENDOR, FACEBOOK], [TYPE, WEARABLE]], [\n\n            ///////////////////\n            // EMBEDDED\n            ///////////////////\n\n            /(tesla)(?: qtcarbrowser|\\/[-\\w\\.]+)/i                              // Tesla\n            ], [VENDOR, [TYPE, EMBEDDED]], [\n            /(aeobc)\\b/i                                                        // Echo Dot\n            ], [MODEL, [VENDOR, AMAZON], [TYPE, EMBEDDED]], [\n\n            ////////////////////\n            // MIXED (GENERIC)\n            ///////////////////\n\n            /droid .+?; ([^;]+?)(?: bui|; wv\\)|\\) applew).+? mobile safari/i    // Android Phones from Unidentified Vendors\n            ], [MODEL, [TYPE, MOBILE]], [\n            /droid .+?; ([^;]+?)(?: bui|\\) applew).+?(?! mobile) safari/i       // Android Tablets from Unidentified Vendors\n            ], [MODEL, [TYPE, TABLET]], [\n            /\\b((tablet|tab)[;\\/]|focus\\/\\d(?!.+mobile))/i                      // Unidentifiable Tablet\n            ], [[TYPE, TABLET]], [\n            /(phone|mobile(?:[;\\/]| [ \\w\\/\\.]*safari)|pda(?=.+windows ce))/i    // Unidentifiable Mobile\n            ], [[TYPE, MOBILE]], [\n            /(android[-\\w\\. ]{0,9});.+buil/i                                    // Generic Android Device\n            ], [MODEL, [VENDOR, 'Generic']]\n        ],\n\n        engine : [[\n\n            /windows.+ edge\\/([\\w\\.]+)/i                                       // EdgeHTML\n            ], [VERSION, [NAME, EDGE+'HTML']], [\n\n            /webkit\\/537\\.36.+chrome\\/(?!27)([\\w\\.]+)/i                         // Blink\n            ], [VERSION, [NAME, 'Blink']], [\n\n            /(presto)\\/([\\w\\.]+)/i,                                             // Presto\n            /(webkit|trident|netfront|netsurf|amaya|lynx|w3m|goanna)\\/([\\w\\.]+)/i, // WebKit/Trident/NetFront/NetSurf/Amaya/Lynx/w3m/Goanna\n            /ekioh(flow)\\/([\\w\\.]+)/i,                                          // Flow\n            /(khtml|tasman|links)[\\/ ]\\(?([\\w\\.]+)/i,                           // KHTML/Tasman/Links\n            /(icab)[\\/ ]([23]\\.[\\d\\.]+)/i,                                      // iCab\n            /\\b(libweb)/i\n            ], [NAME, VERSION], [\n\n            /rv\\:([\\w\\.]{1,9})\\b.+(gecko)/i                                     // Gecko\n            ], [VERSION, NAME]\n        ],\n\n        os : [[\n\n            // Windows\n            /microsoft (windows) (vista|xp)/i                                   // Windows (iTunes)\n            ], [NAME, VERSION], [\n            /(windows (?:phone(?: os)?|mobile))[\\/ ]?([\\d\\.\\w ]*)/i             // Windows Phone\n            ], [NAME, [VERSION, strMapper, windowsVersionMap]], [\n            /windows nt 6\\.2; (arm)/i,                                        // Windows RT\n            /windows[\\/ ]?([ntce\\d\\. ]+\\w)(?!.+xbox)/i,\n            /(?:win(?=3|9|n)|win 9x )([nt\\d\\.]+)/i\n            ], [[VERSION, strMapper, windowsVersionMap], [NAME, 'Windows']], [\n\n            // iOS/macOS\n            /ip[honead]{2,4}\\b(?:.*os ([\\w]+) like mac|; opera)/i,              // iOS\n            /(?:ios;fbsv\\/|iphone.+ios[\\/ ])([\\d\\.]+)/i,\n            /cfnetwork\\/.+darwin/i\n            ], [[VERSION, /_/g, '.'], [NAME, 'iOS']], [\n            /(mac os x) ?([\\w\\. ]*)/i,\n            /(macintosh|mac_powerpc\\b)(?!.+haiku)/i                             // Mac OS\n            ], [[NAME, MAC_OS], [VERSION, /_/g, '.']], [\n\n            // Mobile OSes\n            /droid ([\\w\\.]+)\\b.+(android[- ]x86|harmonyos)/i                    // Android-x86/HarmonyOS\n            ], [VERSION, NAME], [                                               // Android/WebOS/QNX/Bada/RIM/Maemo/MeeGo/Sailfish OS\n            /(android|webos|qnx|bada|rim tablet os|maemo|meego|sailfish)[-\\/ ]?([\\w\\.]*)/i,\n            /(blackberry)\\w*\\/([\\w\\.]*)/i,                                      // Blackberry\n            /(tizen|kaios)[\\/ ]([\\w\\.]+)/i,                                     // Tizen/KaiOS\n            /\\((series40);/i                                                    // Series 40\n            ], [NAME, VERSION], [\n            /\\(bb(10);/i                                                        // BlackBerry 10\n            ], [VERSION, [NAME, BLACKBERRY]], [\n            /(?:symbian ?os|symbos|s60(?=;)|series60)[-\\/ ]?([\\w\\.]*)/i         // Symbian\n            ], [VERSION, [NAME, 'Symbian']], [\n            /mozilla\\/[\\d\\.]+ \\((?:mobile|tablet|tv|mobile; [\\w ]+); rv:.+ gecko\\/([\\w\\.]+)/i // Firefox OS\n            ], [VERSION, [NAME, FIREFOX+' OS']], [\n            /web0s;.+rt(tv)/i,\n            /\\b(?:hp)?wos(?:browser)?\\/([\\w\\.]+)/i                              // WebOS\n            ], [VERSION, [NAME, 'webOS']], [\n            /watch(?: ?os[,\\/]|\\d,\\d\\/)([\\d\\.]+)/i                              // watchOS\n            ], [VERSION, [NAME, 'watchOS']], [\n\n            // Google Chromecast\n            /crkey\\/([\\d\\.]+)/i                                                 // Google Chromecast\n            ], [VERSION, [NAME, CHROME+'cast']], [\n            /(cros) [\\w]+(?:\\)| ([\\w\\.]+)\\b)/i                                  // Chromium OS\n            ], [[NAME, CHROMIUM_OS], VERSION],[\n\n            // Smart TVs\n            /panasonic;(viera)/i,                                               // Panasonic Viera\n            /(netrange)mmh/i,                                                   // Netrange\n            /(nettv)\\/(\\d+\\.[\\w\\.]+)/i,                                         // NetTV\n\n            // Console\n            /(nintendo|playstation) ([wids345portablevuch]+)/i,                 // Nintendo/Playstation\n            /(xbox); +xbox ([^\\);]+)/i,                                         // Microsoft Xbox (360, One, X, S, Series X, Series S)\n\n            // Other\n            /\\b(joli|palm)\\b ?(?:os)?\\/?([\\w\\.]*)/i,                            // Joli/Palm\n            /(mint)[\\/\\(\\) ]?(\\w*)/i,                                           // Mint\n            /(mageia|vectorlinux)[; ]/i,                                        // Mageia/VectorLinux\n            /([kxln]?ubuntu|debian|suse|opensuse|gentoo|arch(?= linux)|slackware|fedora|mandriva|centos|pclinuxos|red ?hat|zenwalk|linpus|raspbian|plan 9|minix|risc os|contiki|deepin|manjaro|elementary os|sabayon|linspire)(?: gnu\\/linux)?(?: enterprise)?(?:[- ]linux)?(?:-gnu)?[-\\/ ]?(?!chrom|package)([-\\w\\.]*)/i,\n                                                                                // Ubuntu/Debian/SUSE/Gentoo/Arch/Slackware/Fedora/Mandriva/CentOS/PCLinuxOS/RedHat/Zenwalk/Linpus/Raspbian/Plan9/Minix/RISCOS/Contiki/Deepin/Manjaro/elementary/Sabayon/Linspire\n            /(hurd|linux) ?([\\w\\.]*)/i,                                         // Hurd/Linux\n            /(gnu) ?([\\w\\.]*)/i,                                                // GNU\n            /\\b([-frentopcghs]{0,5}bsd|dragonfly)[\\/ ]?(?!amd|[ix346]{1,2}86)([\\w\\.]*)/i, // FreeBSD/NetBSD/OpenBSD/PC-BSD/GhostBSD/DragonFly\n            /(haiku) (\\w+)/i                                                    // Haiku\n            ], [NAME, VERSION], [\n            /(sunos) ?([\\w\\.\\d]*)/i                                             // Solaris\n            ], [[NAME, 'Solaris'], VERSION], [\n            /((?:open)?solaris)[-\\/ ]?([\\w\\.]*)/i,                              // Solaris\n            /(aix) ((\\d)(?=\\.|\\)| )[\\w\\.])*/i,                                  // AIX\n            /\\b(beos|os\\/2|amigaos|morphos|openvms|fuchsia|hp-ux|serenityos)/i, // BeOS/OS2/AmigaOS/MorphOS/OpenVMS/Fuchsia/HP-UX/SerenityOS\n            /(unix) ?([\\w\\.]*)/i                                                // UNIX\n            ], [NAME, VERSION]\n        ]\n    };\n\n    /////////////////\n    // Constructor\n    ////////////////\n\n    var UAParser = function (ua, extensions) {\n\n        if (typeof ua === OBJ_TYPE) {\n            extensions = ua;\n            ua = undefined;\n        }\n\n        if (!(this instanceof UAParser)) {\n            return new UAParser(ua, extensions).getResult();\n        }\n\n        var _navigator = (typeof window !== UNDEF_TYPE && window.navigator) ? window.navigator : undefined;\n        var _ua = ua || ((_navigator && _navigator.userAgent) ? _navigator.userAgent : EMPTY);\n        var _uach = (_navigator && _navigator.userAgentData) ? _navigator.userAgentData : undefined;\n        var _rgxmap = extensions ? extend(regexes, extensions) : regexes;\n        var _isSelfNav = _navigator && _navigator.userAgent == _ua;\n\n        this.getBrowser = function () {\n            var _browser = {};\n            _browser[NAME] = undefined;\n            _browser[VERSION] = undefined;\n            rgxMapper.call(_browser, _ua, _rgxmap.browser);\n            _browser[MAJOR] = majorize(_browser[VERSION]);\n            // Brave-specific detection\n            if (_isSelfNav && _navigator && _navigator.brave && typeof _navigator.brave.isBrave == FUNC_TYPE) {\n                _browser[NAME] = 'Brave';\n            }\n            return _browser;\n        };\n        this.getCPU = function () {\n            var _cpu = {};\n            _cpu[ARCHITECTURE] = undefined;\n            rgxMapper.call(_cpu, _ua, _rgxmap.cpu);\n            return _cpu;\n        };\n        this.getDevice = function () {\n            var _device = {};\n            _device[VENDOR] = undefined;\n            _device[MODEL] = undefined;\n            _device[TYPE] = undefined;\n            rgxMapper.call(_device, _ua, _rgxmap.device);\n            if (_isSelfNav && !_device[TYPE] && _uach && _uach.mobile) {\n                _device[TYPE] = MOBILE;\n            }\n            // iPadOS-specific detection: identified as Mac, but has some iOS-only properties\n            if (_isSelfNav && _device[MODEL] == 'Macintosh' && _navigator && typeof _navigator.standalone !== UNDEF_TYPE && _navigator.maxTouchPoints && _navigator.maxTouchPoints > 2) {\n                _device[MODEL] = 'iPad';\n                _device[TYPE] = TABLET;\n            }\n            return _device;\n        };\n        this.getEngine = function () {\n            var _engine = {};\n            _engine[NAME] = undefined;\n            _engine[VERSION] = undefined;\n            rgxMapper.call(_engine, _ua, _rgxmap.engine);\n            return _engine;\n        };\n        this.getOS = function () {\n            var _os = {};\n            _os[NAME] = undefined;\n            _os[VERSION] = undefined;\n            rgxMapper.call(_os, _ua, _rgxmap.os);\n            if (_isSelfNav && !_os[NAME] && _uach && _uach.platform != 'Unknown') {\n                _os[NAME] = _uach.platform  \n                                    .replace(/chrome os/i, CHROMIUM_OS)\n                                    .replace(/macos/i, MAC_OS);           // backward compatibility\n            }\n            return _os;\n        };\n        this.getResult = function () {\n            return {\n                ua      : this.getUA(),\n                browser : this.getBrowser(),\n                engine  : this.getEngine(),\n                os      : this.getOS(),\n                device  : this.getDevice(),\n                cpu     : this.getCPU()\n            };\n        };\n        this.getUA = function () {\n            return _ua;\n        };\n        this.setUA = function (ua) {\n            _ua = (typeof ua === STR_TYPE && ua.length > UA_MAX_LENGTH) ? trim(ua, UA_MAX_LENGTH) : ua;\n            return this;\n        };\n        this.setUA(_ua);\n        return this;\n    };\n\n    UAParser.VERSION = LIBVERSION;\n    UAParser.BROWSER =  enumerize([NAME, VERSION, MAJOR]);\n    UAParser.CPU = enumerize([ARCHITECTURE]);\n    UAParser.DEVICE = enumerize([MODEL, VENDOR, TYPE, CONSOLE, MOBILE, SMARTTV, TABLET, WEARABLE, EMBEDDED]);\n    UAParser.ENGINE = UAParser.OS = enumerize([NAME, VERSION]);\n\n    ///////////\n    // Export\n    //////////\n\n    // check js environment\n    if (typeof(exports) !== UNDEF_TYPE) {\n        // nodejs env\n        if (typeof module !== UNDEF_TYPE && module.exports) {\n            exports = module.exports = UAParser;\n        }\n        exports.UAParser = UAParser;\n    } else {\n        // requirejs env (optional)\n        if (typeof(define) === FUNC_TYPE && define.amd) {\n            define(function () {\n                return UAParser;\n            });\n        } else if (typeof window !== UNDEF_TYPE) {\n            // browser env\n            window.UAParser = UAParser;\n        }\n    }\n\n    // jQuery/Zepto specific (optional)\n    // Note:\n    //   In AMD env the global scope should be kept clean, but jQuery is an exception.\n    //   jQuery always exports to global scope, unless jQuery.noConflict(true) is used,\n    //   and we should catch that.\n    var $ = typeof window !== UNDEF_TYPE && (window.jQuery || window.Zepto);\n    if ($ && !$.ua) {\n        var parser = new UAParser();\n        $.ua = parser.getResult();\n        $.ua.get = function () {\n            return parser.getUA();\n        };\n        $.ua.set = function (ua) {\n            parser.setUA(ua);\n            var result = parser.getResult();\n            for (var prop in result) {\n                $.ua[prop] = result[prop];\n            }\n        };\n    }\n\n})(typeof window === 'object' ? window : this);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/node_modules/ua-parser-js/src/ua-parser.js\n// module id = 446\n// module chunks = 2","/* globals __webpack_amd_options__ */\r\nmodule.exports = __webpack_amd_options__;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/amd-options.js\n// module id = 447\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar invariant = require('./invariant');\n\nvar componentRegex = /\\./;\nvar orRegex = /\\|\\|/;\nvar rangeRegex = /\\s+\\-\\s+/;\nvar modifierRegex = /^(<=|<|=|>=|~>|~|>|)?\\s*(.+)/;\nvar numericRegex = /^(\\d*)(.*)/;\n\n/**\n * Splits input `range` on \"||\" and returns true if any subrange matches\n * `version`.\n *\n * @param {string} range\n * @param {string} version\n * @returns {boolean}\n */\nfunction checkOrExpression(range, version) {\n  var expressions = range.split(orRegex);\n\n  if (expressions.length > 1) {\n    return expressions.some(function (range) {\n      return VersionRange.contains(range, version);\n    });\n  } else {\n    range = expressions[0].trim();\n    return checkRangeExpression(range, version);\n  }\n}\n\n/**\n * Splits input `range` on \" - \" (the surrounding whitespace is required) and\n * returns true if version falls between the two operands.\n *\n * @param {string} range\n * @param {string} version\n * @returns {boolean}\n */\nfunction checkRangeExpression(range, version) {\n  var expressions = range.split(rangeRegex);\n\n  !(expressions.length > 0 && expressions.length <= 2) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'the \"-\" operator expects exactly 2 operands') : invariant(false) : void 0;\n\n  if (expressions.length === 1) {\n    return checkSimpleExpression(expressions[0], version);\n  } else {\n    var startVersion = expressions[0],\n        endVersion = expressions[1];\n\n    !(isSimpleVersion(startVersion) && isSimpleVersion(endVersion)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'operands to the \"-\" operator must be simple (no modifiers)') : invariant(false) : void 0;\n\n    return checkSimpleExpression('>=' + startVersion, version) && checkSimpleExpression('<=' + endVersion, version);\n  }\n}\n\n/**\n * Checks if `range` matches `version`. `range` should be a \"simple\" range (ie.\n * not a compound range using the \" - \" or \"||\" operators).\n *\n * @param {string} range\n * @param {string} version\n * @returns {boolean}\n */\nfunction checkSimpleExpression(range, version) {\n  range = range.trim();\n  if (range === '') {\n    return true;\n  }\n\n  var versionComponents = version.split(componentRegex);\n\n  var _getModifierAndCompon = getModifierAndComponents(range),\n      modifier = _getModifierAndCompon.modifier,\n      rangeComponents = _getModifierAndCompon.rangeComponents;\n\n  switch (modifier) {\n    case '<':\n      return checkLessThan(versionComponents, rangeComponents);\n    case '<=':\n      return checkLessThanOrEqual(versionComponents, rangeComponents);\n    case '>=':\n      return checkGreaterThanOrEqual(versionComponents, rangeComponents);\n    case '>':\n      return checkGreaterThan(versionComponents, rangeComponents);\n    case '~':\n    case '~>':\n      return checkApproximateVersion(versionComponents, rangeComponents);\n    default:\n      return checkEqual(versionComponents, rangeComponents);\n  }\n}\n\n/**\n * Checks whether `a` is less than `b`.\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {boolean}\n */\nfunction checkLessThan(a, b) {\n  return compareComponents(a, b) === -1;\n}\n\n/**\n * Checks whether `a` is less than or equal to `b`.\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {boolean}\n */\nfunction checkLessThanOrEqual(a, b) {\n  var result = compareComponents(a, b);\n  return result === -1 || result === 0;\n}\n\n/**\n * Checks whether `a` is equal to `b`.\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {boolean}\n */\nfunction checkEqual(a, b) {\n  return compareComponents(a, b) === 0;\n}\n\n/**\n * Checks whether `a` is greater than or equal to `b`.\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {boolean}\n */\nfunction checkGreaterThanOrEqual(a, b) {\n  var result = compareComponents(a, b);\n  return result === 1 || result === 0;\n}\n\n/**\n * Checks whether `a` is greater than `b`.\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {boolean}\n */\nfunction checkGreaterThan(a, b) {\n  return compareComponents(a, b) === 1;\n}\n\n/**\n * Checks whether `a` is \"reasonably close\" to `b` (as described in\n * https://www.npmjs.org/doc/misc/semver.html). For example, if `b` is \"1.3.1\"\n * then \"reasonably close\" is defined as \">= 1.3.1 and < 1.4\".\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {boolean}\n */\nfunction checkApproximateVersion(a, b) {\n  var lowerBound = b.slice();\n  var upperBound = b.slice();\n\n  if (upperBound.length > 1) {\n    upperBound.pop();\n  }\n  var lastIndex = upperBound.length - 1;\n  var numeric = parseInt(upperBound[lastIndex], 10);\n  if (isNumber(numeric)) {\n    upperBound[lastIndex] = numeric + 1 + '';\n  }\n\n  return checkGreaterThanOrEqual(a, lowerBound) && checkLessThan(a, upperBound);\n}\n\n/**\n * Extracts the optional modifier (<, <=, =, >=, >, ~, ~>) and version\n * components from `range`.\n *\n * For example, given `range` \">= 1.2.3\" returns an object with a `modifier` of\n * `\">=\"` and `components` of `[1, 2, 3]`.\n *\n * @param {string} range\n * @returns {object}\n */\nfunction getModifierAndComponents(range) {\n  var rangeComponents = range.split(componentRegex);\n  var matches = rangeComponents[0].match(modifierRegex);\n  !matches ? process.env.NODE_ENV !== 'production' ? invariant(false, 'expected regex to match but it did not') : invariant(false) : void 0;\n\n  return {\n    modifier: matches[1],\n    rangeComponents: [matches[2]].concat(rangeComponents.slice(1))\n  };\n}\n\n/**\n * Determines if `number` is a number.\n *\n * @param {mixed} number\n * @returns {boolean}\n */\nfunction isNumber(number) {\n  return !isNaN(number) && isFinite(number);\n}\n\n/**\n * Tests whether `range` is a \"simple\" version number without any modifiers\n * (\">\", \"~\" etc).\n *\n * @param {string} range\n * @returns {boolean}\n */\nfunction isSimpleVersion(range) {\n  return !getModifierAndComponents(range).modifier;\n}\n\n/**\n * Zero-pads array `array` until it is at least `length` long.\n *\n * @param {array} array\n * @param {number} length\n */\nfunction zeroPad(array, length) {\n  for (var i = array.length; i < length; i++) {\n    array[i] = '0';\n  }\n}\n\n/**\n * Normalizes `a` and `b` in preparation for comparison by doing the following:\n *\n * - zero-pads `a` and `b`\n * - marks any \"x\", \"X\" or \"*\" component in `b` as equivalent by zero-ing it out\n *   in both `a` and `b`\n * - marks any final \"*\" component in `b` as a greedy wildcard by zero-ing it\n *   and all of its successors in `a`\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {array<array<string>>}\n */\nfunction normalizeVersions(a, b) {\n  a = a.slice();\n  b = b.slice();\n\n  zeroPad(a, b.length);\n\n  // mark \"x\" and \"*\" components as equal\n  for (var i = 0; i < b.length; i++) {\n    var matches = b[i].match(/^[x*]$/i);\n    if (matches) {\n      b[i] = a[i] = '0';\n\n      // final \"*\" greedily zeros all remaining components\n      if (matches[0] === '*' && i === b.length - 1) {\n        for (var j = i; j < a.length; j++) {\n          a[j] = '0';\n        }\n      }\n    }\n  }\n\n  zeroPad(b, a.length);\n\n  return [a, b];\n}\n\n/**\n * Returns the numerical -- not the lexicographical -- ordering of `a` and `b`.\n *\n * For example, `10-alpha` is greater than `2-beta`.\n *\n * @param {string} a\n * @param {string} b\n * @returns {number} -1, 0 or 1 to indicate whether `a` is less than, equal to,\n * or greater than `b`, respectively\n */\nfunction compareNumeric(a, b) {\n  var aPrefix = a.match(numericRegex)[1];\n  var bPrefix = b.match(numericRegex)[1];\n  var aNumeric = parseInt(aPrefix, 10);\n  var bNumeric = parseInt(bPrefix, 10);\n\n  if (isNumber(aNumeric) && isNumber(bNumeric) && aNumeric !== bNumeric) {\n    return compare(aNumeric, bNumeric);\n  } else {\n    return compare(a, b);\n  }\n}\n\n/**\n * Returns the ordering of `a` and `b`.\n *\n * @param {string|number} a\n * @param {string|number} b\n * @returns {number} -1, 0 or 1 to indicate whether `a` is less than, equal to,\n * or greater than `b`, respectively\n */\nfunction compare(a, b) {\n  !(typeof a === typeof b) ? process.env.NODE_ENV !== 'production' ? invariant(false, '\"a\" and \"b\" must be of the same type') : invariant(false) : void 0;\n\n  if (a > b) {\n    return 1;\n  } else if (a < b) {\n    return -1;\n  } else {\n    return 0;\n  }\n}\n\n/**\n * Compares arrays of version components.\n *\n * @param {array<string>} a\n * @param {array<string>} b\n * @returns {number} -1, 0 or 1 to indicate whether `a` is less than, equal to,\n * or greater than `b`, respectively\n */\nfunction compareComponents(a, b) {\n  var _normalizeVersions = normalizeVersions(a, b),\n      aNormalized = _normalizeVersions[0],\n      bNormalized = _normalizeVersions[1];\n\n  for (var i = 0; i < bNormalized.length; i++) {\n    var result = compareNumeric(aNormalized[i], bNormalized[i]);\n    if (result) {\n      return result;\n    }\n  }\n\n  return 0;\n}\n\nvar VersionRange = {\n  /**\n   * Checks whether `version` satisfies the `range` specification.\n   *\n   * We support a subset of the expressions defined in\n   * https://www.npmjs.org/doc/misc/semver.html:\n   *\n   *    version   Must match version exactly\n   *    =version  Same as just version\n   *    >version  Must be greater than version\n   *    >=version Must be greater than or equal to version\n   *    <version  Must be less than version\n   *    <=version Must be less than or equal to version\n   *    ~version  Must be at least version, but less than the next significant\n   *              revision above version:\n   *              \"~1.2.3\" is equivalent to \">= 1.2.3 and < 1.3\"\n   *    ~>version Equivalent to ~version\n   *    1.2.x     Must match \"1.2.x\", where \"x\" is a wildcard that matches\n   *              anything\n   *    1.2.*     Similar to \"1.2.x\", but \"*\" in the trailing position is a\n   *              \"greedy\" wildcard, so will match any number of additional\n   *              components:\n   *              \"1.2.*\" will match \"1.2.1\", \"1.2.1.1\", \"1.2.1.1.1\" etc\n   *    *         Any version\n   *    \"\"        (Empty string) Same as *\n   *    v1 - v2   Equivalent to \">= v1 and <= v2\"\n   *    r1 || r2  Passes if either r1 or r2 are satisfied\n   *\n   * @param {string} range\n   * @param {string} version\n   * @returns {boolean}\n   */\n  contains: function contains(range, version) {\n    return checkOrExpression(range.trim(), version.trim());\n  }\n};\n\nmodule.exports = VersionRange;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/VersionRange.js\n// module id = 448\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\n/**\n * Executes the provided `callback` once for each enumerable own property in the\n * object and constructs a new object from the results. The `callback` is\n * invoked with three arguments:\n *\n *  - the property value\n *  - the property name\n *  - the object being traversed\n *\n * Properties that are added after the call to `mapObject` will not be visited\n * by `callback`. If the values of existing properties are changed, the value\n * passed to `callback` will be the value at the time `mapObject` visits them.\n * Properties that are deleted before being visited are not visited.\n *\n * @grep function objectMap()\n * @grep function objMap()\n *\n * @param {?object} object\n * @param {function} callback\n * @param {*} context\n * @return {?object}\n */\nfunction mapObject(object, callback, context) {\n  if (!object) {\n    return null;\n  }\n  var result = {};\n  for (var name in object) {\n    if (hasOwnProperty.call(object, name)) {\n      result[name] = callback.call(context, object[name], name, object);\n    }\n  }\n  return result;\n}\n\nmodule.exports = mapObject;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/mapObject.js\n// module id = 449\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @typechecks static-only\n */\n\n'use strict';\n\n/**\n * Memoizes the return value of a function that accepts one string argument.\n */\n\nfunction memoizeStringOnly(callback) {\n  var cache = {};\n  return function (string) {\n    if (!cache.hasOwnProperty(string)) {\n      cache[string] = callback.call(this, string);\n    }\n    return cache[string];\n  };\n}\n\nmodule.exports = memoizeStringOnly;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/memoizeStringOnly.js\n// module id = 450\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule setDraftEditorSelection\n * @format\n * \n */\n\n'use strict';\n\nvar DraftJsDebugLogging = require('./DraftJsDebugLogging');\n\nvar containsNode = require('fbjs/lib/containsNode');\nvar getActiveElement = require('fbjs/lib/getActiveElement');\nvar invariant = require('fbjs/lib/invariant');\n\nfunction getAnonymizedDOM(node, getNodeLabels) {\n  if (!node) {\n    return '[empty]';\n  }\n\n  var anonymized = anonymizeTextWithin(node, getNodeLabels);\n  if (anonymized.nodeType === Node.TEXT_NODE) {\n    return anonymized.textContent;\n  }\n\n  !(anonymized instanceof Element) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Node must be an Element if it is not a text node.') : invariant(false) : void 0;\n  return anonymized.outerHTML;\n}\n\nfunction anonymizeTextWithin(node, getNodeLabels) {\n  var labels = getNodeLabels !== undefined ? getNodeLabels(node) : [];\n\n  if (node.nodeType === Node.TEXT_NODE) {\n    var length = node.textContent.length;\n    return document.createTextNode('[text ' + length + (labels.length ? ' | ' + labels.join(', ') : '') + ']');\n  }\n\n  var clone = node.cloneNode();\n  if (clone.nodeType === 1 && labels.length) {\n    clone.setAttribute('data-labels', labels.join(', '));\n  }\n  var childNodes = node.childNodes;\n  for (var ii = 0; ii < childNodes.length; ii++) {\n    clone.appendChild(anonymizeTextWithin(childNodes[ii], getNodeLabels));\n  }\n\n  return clone;\n}\n\nfunction getAnonymizedEditorDOM(node, getNodeLabels) {\n  // grabbing the DOM content of the Draft editor\n  var currentNode = node;\n  while (currentNode) {\n    if (currentNode instanceof Element && currentNode.hasAttribute('contenteditable')) {\n      // found the Draft editor container\n      return getAnonymizedDOM(currentNode, getNodeLabels);\n    } else {\n      currentNode = currentNode.parentNode;\n    }\n  }\n  return 'Could not find contentEditable parent of node';\n}\n\nfunction getNodeLength(node) {\n  return node.nodeValue === null ? node.childNodes.length : node.nodeValue.length;\n}\n\n/**\n * In modern non-IE browsers, we can support both forward and backward\n * selections.\n *\n * Note: IE10+ supports the Selection object, but it does not support\n * the `extend` method, which means that even in modern IE, it's not possible\n * to programatically create a backward selection. Thus, for all IE\n * versions, we use the old IE API to create our selections.\n */\nfunction setDraftEditorSelection(selectionState, node, blockKey, nodeStart, nodeEnd) {\n  // It's possible that the editor has been removed from the DOM but\n  // our selection code doesn't know it yet. Forcing selection in\n  // this case may lead to errors, so just bail now.\n  if (!containsNode(document.documentElement, node)) {\n    return;\n  }\n\n  var selection = global.getSelection();\n  var anchorKey = selectionState.getAnchorKey();\n  var anchorOffset = selectionState.getAnchorOffset();\n  var focusKey = selectionState.getFocusKey();\n  var focusOffset = selectionState.getFocusOffset();\n  var isBackward = selectionState.getIsBackward();\n\n  // IE doesn't support backward selection. Swap key/offset pairs.\n  if (!selection.extend && isBackward) {\n    var tempKey = anchorKey;\n    var tempOffset = anchorOffset;\n    anchorKey = focusKey;\n    anchorOffset = focusOffset;\n    focusKey = tempKey;\n    focusOffset = tempOffset;\n    isBackward = false;\n  }\n\n  var hasAnchor = anchorKey === blockKey && nodeStart <= anchorOffset && nodeEnd >= anchorOffset;\n\n  var hasFocus = focusKey === blockKey && nodeStart <= focusOffset && nodeEnd >= focusOffset;\n\n  // If the selection is entirely bound within this node, set the selection\n  // and be done.\n  if (hasAnchor && hasFocus) {\n    selection.removeAllRanges();\n    addPointToSelection(selection, node, anchorOffset - nodeStart, selectionState);\n    addFocusToSelection(selection, node, focusOffset - nodeStart, selectionState);\n    return;\n  }\n\n  if (!isBackward) {\n    // If the anchor is within this node, set the range start.\n    if (hasAnchor) {\n      selection.removeAllRanges();\n      addPointToSelection(selection, node, anchorOffset - nodeStart, selectionState);\n    }\n\n    // If the focus is within this node, we can assume that we have\n    // already set the appropriate start range on the selection, and\n    // can simply extend the selection.\n    if (hasFocus) {\n      addFocusToSelection(selection, node, focusOffset - nodeStart, selectionState);\n    }\n  } else {\n    // If this node has the focus, set the selection range to be a\n    // collapsed range beginning here. Later, when we encounter the anchor,\n    // we'll use this information to extend the selection.\n    if (hasFocus) {\n      selection.removeAllRanges();\n      addPointToSelection(selection, node, focusOffset - nodeStart, selectionState);\n    }\n\n    // If this node has the anchor, we may assume that the correct\n    // focus information is already stored on the selection object.\n    // We keep track of it, reset the selection range, and extend it\n    // back to the focus point.\n    if (hasAnchor) {\n      var storedFocusNode = selection.focusNode;\n      var storedFocusOffset = selection.focusOffset;\n\n      selection.removeAllRanges();\n      addPointToSelection(selection, node, anchorOffset - nodeStart, selectionState);\n      addFocusToSelection(selection, storedFocusNode, storedFocusOffset, selectionState);\n    }\n  }\n}\n\n/**\n * Extend selection towards focus point.\n */\nfunction addFocusToSelection(selection, node, offset, selectionState) {\n  var activeElement = getActiveElement();\n  if (selection.extend && containsNode(activeElement, node)) {\n    // If `extend` is called while another element has focus, an error is\n    // thrown. We therefore disable `extend` if the active element is somewhere\n    // other than the node we are selecting. This should only occur in Firefox,\n    // since it is the only browser to support multiple selections.\n    // See https://bugzilla.mozilla.org/show_bug.cgi?id=921444.\n\n    // logging to catch bug that is being reported in t16250795\n    if (offset > getNodeLength(node)) {\n      // the call to 'selection.extend' is about to throw\n      DraftJsDebugLogging.logSelectionStateFailure({\n        anonymizedDom: getAnonymizedEditorDOM(node),\n        extraParams: JSON.stringify({ offset: offset }),\n        selectionState: JSON.stringify(selectionState.toJS())\n      });\n    }\n\n    // logging to catch bug that is being reported in t18110632\n    var nodeWasFocus = node === selection.focusNode;\n    try {\n      selection.extend(node, offset);\n    } catch (e) {\n      DraftJsDebugLogging.logSelectionStateFailure({\n        anonymizedDom: getAnonymizedEditorDOM(node, function (n) {\n          var labels = [];\n          if (n === activeElement) {\n            labels.push('active element');\n          }\n          if (n === selection.anchorNode) {\n            labels.push('selection anchor node');\n          }\n          if (n === selection.focusNode) {\n            labels.push('selection focus node');\n          }\n          return labels;\n        }),\n        extraParams: JSON.stringify({\n          activeElementName: activeElement ? activeElement.nodeName : null,\n          nodeIsFocus: node === selection.focusNode,\n          nodeWasFocus: nodeWasFocus,\n          selectionRangeCount: selection.rangeCount,\n          selectionAnchorNodeName: selection.anchorNode ? selection.anchorNode.nodeName : null,\n          selectionAnchorOffset: selection.anchorOffset,\n          selectionFocusNodeName: selection.focusNode ? selection.focusNode.nodeName : null,\n          selectionFocusOffset: selection.focusOffset,\n          message: e ? '' + e : null,\n          offset: offset\n        }, null, 2),\n        selectionState: JSON.stringify(selectionState.toJS(), null, 2)\n      });\n      // allow the error to be thrown -\n      // better than continuing in a broken state\n      throw e;\n    }\n  } else {\n    // IE doesn't support extend. This will mean no backward selection.\n    // Extract the existing selection range and add focus to it.\n    // Additionally, clone the selection range. IE11 throws an\n    // InvalidStateError when attempting to access selection properties\n    // after the range is detached.\n    var range = selection.getRangeAt(0);\n    range.setEnd(node, offset);\n    selection.addRange(range.cloneRange());\n  }\n}\n\nfunction addPointToSelection(selection, node, offset, selectionState) {\n  var range = document.createRange();\n  // logging to catch bug that is being reported in t16250795\n  if (offset > getNodeLength(node)) {\n    // in this case we know that the call to 'range.setStart' is about to throw\n    DraftJsDebugLogging.logSelectionStateFailure({\n      anonymizedDom: getAnonymizedEditorDOM(node),\n      extraParams: JSON.stringify({ offset: offset }),\n      selectionState: JSON.stringify(selectionState.toJS())\n    });\n  }\n  range.setStart(node, offset);\n  selection.addRange(range);\n}\n\nmodule.exports = setDraftEditorSelection;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/setDraftEditorSelection.js\n// module id = 451\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftJsDebugLogging\n */\n\n'use strict';\n\nmodule.exports = {\n  logSelectionStateFailure: function logSelectionStateFailure() {\n    return null;\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftJsDebugLogging.js\n// module id = 452\n// module chunks = 2","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar isNode = require('./isNode');\n\n/**\n * @param {*} object The object to check.\n * @return {boolean} Whether or not the object is a DOM text node.\n */\nfunction isTextNode(object) {\n  return isNode(object) && object.nodeType == 3;\n}\n\nmodule.exports = isTextNode;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/isTextNode.js\n// module id = 453\n// module chunks = 2","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n/**\n * @param {*} object The object to check.\n * @return {boolean} Whether or not the object is a DOM node.\n */\nfunction isNode(object) {\n  var doc = object ? object.ownerDocument || object : document;\n  var defaultView = doc.defaultView || window;\n  return !!(object && (typeof defaultView.Node === 'function' ? object instanceof defaultView.Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string'));\n}\n\nmodule.exports = isNode;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/isNode.js\n// module id = 454\n// module chunks = 2","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar camelize = require('./camelize');\nvar hyphenate = require('./hyphenate');\n\nfunction asString(value) /*?string*/{\n  return value == null ? value : String(value);\n}\n\nfunction getStyleProperty( /*DOMNode*/node, /*string*/name) /*?string*/{\n  var computedStyle = void 0;\n\n  // W3C Standard\n  if (window.getComputedStyle) {\n    // In certain cases such as within an iframe in FF3, this returns null.\n    computedStyle = window.getComputedStyle(node, null);\n    if (computedStyle) {\n      return asString(computedStyle.getPropertyValue(hyphenate(name)));\n    }\n  }\n  // Safari\n  if (document.defaultView && document.defaultView.getComputedStyle) {\n    computedStyle = document.defaultView.getComputedStyle(node, null);\n    // A Safari bug causes this to return null for `display: none` elements.\n    if (computedStyle) {\n      return asString(computedStyle.getPropertyValue(hyphenate(name)));\n    }\n    if (name === 'display') {\n      return 'none';\n    }\n  }\n  // Internet Explorer\n  if (node.currentStyle) {\n    if (name === 'float') {\n      return asString(node.currentStyle.cssFloat || node.currentStyle.styleFloat);\n    }\n    return asString(node.currentStyle[camelize(name)]);\n  }\n  return asString(node.style && node.style[camelize(name)]);\n}\n\nmodule.exports = getStyleProperty;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/getStyleProperty.js\n// module id = 455\n// module chunks = 2","\"use strict\";\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar _hyphenPattern = /-(.)/g;\n\n/**\n * Camelcases a hyphenated string, for example:\n *\n *   > camelize('background-color')\n *   < \"backgroundColor\"\n *\n * @param {string} string\n * @return {string}\n */\nfunction camelize(string) {\n  return string.replace(_hyphenPattern, function (_, character) {\n    return character.toUpperCase();\n  });\n}\n\nmodule.exports = camelize;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/camelize.js\n// module id = 456\n// module chunks = 2","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar _uppercasePattern = /([A-Z])/g;\n\n/**\n * Hyphenates a camelcased string, for example:\n *\n *   > hyphenate('backgroundColor')\n *   < \"background-color\"\n *\n * For CSS style names, use `hyphenateStyleName` instead which works properly\n * with all vendor prefixes, including `ms`.\n *\n * @param {string} string\n * @return {string}\n */\nfunction hyphenate(string) {\n  return string.replace(_uppercasePattern, '-$1').toLowerCase();\n}\n\nmodule.exports = hyphenate;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/hyphenate.js\n// module id = 457\n// module chunks = 2","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar getElementRect = require('./getElementRect');\n\n/**\n * Gets an element's position in pixels relative to the viewport. The returned\n * object represents the position of the element's top left corner.\n *\n * @param {DOMElement} element\n * @return {object}\n */\nfunction getElementPosition(element) {\n  var rect = getElementRect(element);\n  return {\n    x: rect.left,\n    y: rect.top,\n    width: rect.right - rect.left,\n    height: rect.bottom - rect.top\n  };\n}\n\nmodule.exports = getElementPosition;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/getElementPosition.js\n// module id = 458\n// module chunks = 2","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar containsNode = require('./containsNode');\n\n/**\n * Gets an element's bounding rect in pixels relative to the viewport.\n *\n * @param {DOMElement} elem\n * @return {object}\n */\nfunction getElementRect(elem) {\n  var docElem = elem.ownerDocument.documentElement;\n\n  // FF 2, Safari 3 and Opera 9.5- do not support getBoundingClientRect().\n  // IE9- will throw if the element is not in the document.\n  if (!('getBoundingClientRect' in elem) || !containsNode(docElem, elem)) {\n    return {\n      left: 0,\n      right: 0,\n      top: 0,\n      bottom: 0\n    };\n  }\n\n  // Subtracts clientTop/Left because IE8- added a 2px border to the\n  // <html> element (see http://fburl.com/1493213). IE 7 in\n  // Quicksmode does not report clientLeft/clientTop so there\n  // will be an unaccounted offset of 2px when in quirksmode\n  var rect = elem.getBoundingClientRect();\n\n  return {\n    left: Math.round(rect.left) - docElem.clientLeft,\n    right: Math.round(rect.right) - docElem.clientLeft,\n    top: Math.round(rect.top) - docElem.clientTop,\n    bottom: Math.round(rect.bottom) - docElem.clientTop\n  };\n}\n\nmodule.exports = getElementRect;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/getElementRect.js\n// module id = 459\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n'use strict';\n\nvar isWebkit = typeof navigator !== 'undefined' && navigator.userAgent.indexOf('AppleWebKit') > -1;\n\n/**\n * Gets the element with the document scroll properties such as `scrollLeft` and\n * `scrollHeight`. This may differ across different browsers.\n *\n * NOTE: The return value can be null if the DOM is not yet ready.\n *\n * @param {?DOMDocument} doc Defaults to current document.\n * @return {?DOMElement}\n */\nfunction getDocumentScrollElement(doc) {\n  doc = doc || document;\n  if (doc.scrollingElement) {\n    return doc.scrollingElement;\n  }\n  return !isWebkit && doc.compatMode === 'CSS1Compat' ? doc.documentElement : doc.body;\n}\n\nmodule.exports = getDocumentScrollElement;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/getDocumentScrollElement.js\n// module id = 460\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n'use strict';\n\n/**\n * Gets the scroll position of the supplied element or window.\n *\n * The return values are unbounded, unlike `getScrollPosition`. This means they\n * may be negative or exceed the element boundaries (which is possible using\n * inertial scrolling).\n *\n * @param {DOMWindow|DOMElement} scrollable\n * @return {object} Map with `x` and `y` keys.\n */\n\nfunction getUnboundedScrollPosition(scrollable) {\n  if (scrollable.Window && scrollable instanceof scrollable.Window) {\n    return {\n      x: scrollable.pageXOffset || scrollable.document.documentElement.scrollLeft,\n      y: scrollable.pageYOffset || scrollable.document.documentElement.scrollTop\n    };\n  }\n  return {\n    x: scrollable.scrollLeft,\n    y: scrollable.scrollTop\n  };\n}\n\nmodule.exports = getUnboundedScrollPosition;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/getUnboundedScrollPosition.js\n// module id = 461\n// module chunks = 2","\"use strict\";\n\nfunction getViewportWidth() {\n  var width = void 0;\n  if (document.documentElement) {\n    width = document.documentElement.clientWidth;\n  }\n\n  if (!width && document.body) {\n    width = document.body.clientWidth;\n  }\n\n  return width || 0;\n} /**\n   * Copyright (c) 2013-present, Facebook, Inc.\n   *\n   * This source code is licensed under the MIT license found in the\n   * LICENSE file in the root directory of this source tree.\n   *\n   * \n   * @typechecks\n   */\n\nfunction getViewportHeight() {\n  var height = void 0;\n  if (document.documentElement) {\n    height = document.documentElement.clientHeight;\n  }\n\n  if (!height && document.body) {\n    height = document.body.clientHeight;\n  }\n\n  return height || 0;\n}\n\n/**\n * Gets the viewport dimensions including any scrollbars.\n */\nfunction getViewportDimensions() {\n  return {\n    width: window.innerWidth || getViewportWidth(),\n    height: window.innerHeight || getViewportHeight()\n  };\n}\n\n/**\n * Gets the viewport dimensions excluding any scrollbars.\n */\ngetViewportDimensions.withoutScrollbars = function () {\n  return {\n    width: getViewportWidth(),\n    height: getViewportHeight()\n  };\n};\n\nmodule.exports = getViewportDimensions;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/getViewportDimensions.js\n// module id = 462\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks static-only\n */\n\n'use strict';\n\n/**\n * Combines multiple className strings into one.\n * http://jsperf.com/joinclasses-args-vs-array\n *\n * @param {...?string} className\n * @return {string}\n */\n\nfunction joinClasses(className /*, ... */) {\n  if (!className) {\n    className = '';\n  }\n  var nextClass = void 0;\n  var argLength = arguments.length;\n  if (argLength > 1) {\n    for (var ii = 1; ii < argLength; ii++) {\n      nextClass = arguments[ii];\n      if (nextClass) {\n        className = (className ? className + ' ' : '') + nextClass;\n      }\n    }\n  }\n  return className;\n}\n\nmodule.exports = joinClasses;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/joinClasses.js\n// module id = 463\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorDragHandler\n * @format\n * \n */\n\n'use strict';\n\nvar DataTransfer = require('fbjs/lib/DataTransfer');\nvar DraftModifier = require('./DraftModifier');\nvar EditorState = require('./EditorState');\n\nvar findAncestorOffsetKey = require('./findAncestorOffsetKey');\nvar getTextContentFromFiles = require('./getTextContentFromFiles');\nvar getUpdatedSelectionState = require('./getUpdatedSelectionState');\nvar isEventHandled = require('./isEventHandled');\nvar nullthrows = require('fbjs/lib/nullthrows');\n\n/**\n * Get a SelectionState for the supplied mouse event.\n */\nfunction getSelectionForEvent(event, editorState) {\n  var node = null;\n  var offset = null;\n\n  if (typeof document.caretRangeFromPoint === 'function') {\n    var dropRange = document.caretRangeFromPoint(event.x, event.y);\n    node = dropRange.startContainer;\n    offset = dropRange.startOffset;\n  } else if (event.rangeParent) {\n    node = event.rangeParent;\n    offset = event.rangeOffset;\n  } else {\n    return null;\n  }\n\n  node = nullthrows(node);\n  offset = nullthrows(offset);\n  var offsetKey = nullthrows(findAncestorOffsetKey(node));\n\n  return getUpdatedSelectionState(editorState, offsetKey, offset, offsetKey, offset);\n}\n\nvar DraftEditorDragHandler = {\n  /**\n   * Drag originating from input terminated.\n   */\n  onDragEnd: function onDragEnd(editor) {\n    editor.exitCurrentMode();\n  },\n\n  /**\n   * Handle data being dropped.\n   */\n  onDrop: function onDrop(editor, e) {\n    var data = new DataTransfer(e.nativeEvent.dataTransfer);\n\n    var editorState = editor._latestEditorState;\n    var dropSelection = getSelectionForEvent(e.nativeEvent, editorState);\n\n    e.preventDefault();\n    editor.exitCurrentMode();\n\n    if (dropSelection == null) {\n      return;\n    }\n\n    var files = data.getFiles();\n    if (files.length > 0) {\n      if (editor.props.handleDroppedFiles && isEventHandled(editor.props.handleDroppedFiles(dropSelection, files))) {\n        return;\n      }\n\n      getTextContentFromFiles(files, function (fileText) {\n        fileText && editor.update(insertTextAtSelection(editorState, dropSelection, fileText));\n      });\n      return;\n    }\n\n    var dragType = editor._internalDrag ? 'internal' : 'external';\n    if (editor.props.handleDrop && isEventHandled(editor.props.handleDrop(dropSelection, data, dragType))) {\n      return;\n    }\n\n    if (editor._internalDrag) {\n      editor.update(moveText(editorState, dropSelection));\n      return;\n    }\n\n    editor.update(insertTextAtSelection(editorState, dropSelection, data.getText()));\n  }\n};\n\nfunction moveText(editorState, targetSelection) {\n  var newContentState = DraftModifier.moveText(editorState.getCurrentContent(), editorState.getSelection(), targetSelection);\n  return EditorState.push(editorState, newContentState, 'insert-fragment');\n}\n\n/**\n * Insert text at a specified selection.\n */\nfunction insertTextAtSelection(editorState, selection, text) {\n  var newContentState = DraftModifier.insertText(editorState.getCurrentContent(), selection, text, editorState.getCurrentInlineStyle());\n  return EditorState.push(editorState, newContentState, 'insert-fragment');\n}\n\nmodule.exports = DraftEditorDragHandler;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftEditorDragHandler.js\n// module id = 464\n// module chunks = 2","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nvar PhotosMimeType = {\n  isImage: function isImage(mimeString) {\n    return getParts(mimeString)[0] === 'image';\n  },\n  isJpeg: function isJpeg(mimeString) {\n    var parts = getParts(mimeString);\n    return PhotosMimeType.isImage(mimeString) && (\n    // see http://fburl.com/10972194\n    parts[1] === 'jpeg' || parts[1] === 'pjpeg');\n  }\n};\n\nfunction getParts(mimeString) {\n  return mimeString.split('/');\n}\n\nmodule.exports = PhotosMimeType;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/PhotosMimeType.js\n// module id = 465\n// module chunks = 2","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar invariant = require('./invariant');\n\n/**\n * Convert array-like objects to arrays.\n *\n * This API assumes the caller knows the contents of the data type. For less\n * well defined inputs use createArrayFromMixed.\n *\n * @param {object|function|filelist} obj\n * @return {array}\n */\nfunction toArray(obj) {\n  var length = obj.length;\n\n  // Some browsers builtin objects can report typeof 'function' (e.g. NodeList\n  // in old versions of Safari).\n  !(!Array.isArray(obj) && (typeof obj === 'object' || typeof obj === 'function')) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Array-like object expected') : invariant(false) : void 0;\n\n  !(typeof length === 'number') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object needs a length property') : invariant(false) : void 0;\n\n  !(length === 0 || length - 1 in obj) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object should have keys for indices') : invariant(false) : void 0;\n\n  !(typeof obj.callee !== 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object can\\'t be `arguments`. Use rest params ' + '(function(...args) {}) or Array.from() instead.') : invariant(false) : void 0;\n\n  // Old IE doesn't give collections access to hasOwnProperty. Assume inputs\n  // without method will throw during the slice call and skip straight to the\n  // fallback.\n  if (obj.hasOwnProperty) {\n    try {\n      return Array.prototype.slice.call(obj);\n    } catch (e) {\n      // IE < 9 does not support Array#slice on collections objects\n    }\n  }\n\n  // Fall back to copying key by key. This assumes all keys have a value,\n  // so will not preserve sparsely populated inputs.\n  var ret = Array(length);\n  for (var ii = 0; ii < length; ii++) {\n    ret[ii] = obj[ii];\n  }\n  return ret;\n}\n\n/**\n * Perform a heuristic test to determine if an object is \"array-like\".\n *\n *   A monk asked Joshu, a Zen master, \"Has a dog Buddha nature?\"\n *   Joshu replied: \"Mu.\"\n *\n * This function determines if its argument has \"array nature\": it returns\n * true if the argument is an actual array, an `arguments' object, or an\n * HTMLCollection (e.g. node.childNodes or node.getElementsByTagName()).\n *\n * It will return false for other array-like objects like Filelist.\n *\n * @param {*} obj\n * @return {boolean}\n */\nfunction hasArrayNature(obj) {\n  return (\n    // not null/false\n    !!obj && (\n    // arrays are objects, NodeLists are functions in Safari\n    typeof obj == 'object' || typeof obj == 'function') &&\n    // quacks like an array\n    'length' in obj &&\n    // not window\n    !('setInterval' in obj) &&\n    // no DOM node should be considered an array-like\n    // a 'select' element has 'length' and 'item' properties on IE8\n    typeof obj.nodeType != 'number' && (\n    // a real array\n    Array.isArray(obj) ||\n    // arguments\n    'callee' in obj ||\n    // HTMLCollection/NodeList\n    'item' in obj)\n  );\n}\n\n/**\n * Ensure that the argument is an array by wrapping it in an array if it is not.\n * Creates a copy of the argument if it is already an array.\n *\n * This is mostly useful idiomatically:\n *\n *   var createArrayFromMixed = require('createArrayFromMixed');\n *\n *   function takesOneOrMoreThings(things) {\n *     things = createArrayFromMixed(things);\n *     ...\n *   }\n *\n * This allows you to treat `things' as an array, but accept scalars in the API.\n *\n * If you need to convert an array-like object, like `arguments`, into an array\n * use toArray instead.\n *\n * @param {*} obj\n * @return {array}\n */\nfunction createArrayFromMixed(obj) {\n  if (!hasArrayNature(obj)) {\n    return [obj];\n  } else if (Array.isArray(obj)) {\n    return obj.slice();\n  } else {\n    return toArray(obj);\n  }\n}\n\nmodule.exports = createArrayFromMixed;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/createArrayFromMixed.js\n// module id = 466\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorEditHandler\n * @format\n * \n */\n\n'use strict';\n\nvar onBeforeInput = require('./editOnBeforeInput');\nvar onBlur = require('./editOnBlur');\nvar onCompositionStart = require('./editOnCompositionStart');\nvar onCopy = require('./editOnCopy');\nvar onCut = require('./editOnCut');\nvar onDragOver = require('./editOnDragOver');\nvar onDragStart = require('./editOnDragStart');\nvar onFocus = require('./editOnFocus');\nvar onInput = require('./editOnInput');\nvar onKeyDown = require('./editOnKeyDown');\nvar onPaste = require('./editOnPaste');\nvar onSelect = require('./editOnSelect');\n\nvar DraftEditorEditHandler = {\n  onBeforeInput: onBeforeInput,\n  onBlur: onBlur,\n  onCompositionStart: onCompositionStart,\n  onCopy: onCopy,\n  onCut: onCut,\n  onDragOver: onDragOver,\n  onDragStart: onDragStart,\n  onFocus: onFocus,\n  onInput: onInput,\n  onKeyDown: onKeyDown,\n  onPaste: onPaste,\n  onSelect: onSelect\n};\n\nmodule.exports = DraftEditorEditHandler;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftEditorEditHandler.js\n// module id = 467\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnBeforeInput\n * @format\n * \n */\n\n'use strict';\n\nvar BlockTree = require('./BlockTree');\nvar DraftModifier = require('./DraftModifier');\nvar EditorState = require('./EditorState');\nvar UserAgent = require('fbjs/lib/UserAgent');\n\nvar getEntityKeyForSelection = require('./getEntityKeyForSelection');\nvar isEventHandled = require('./isEventHandled');\nvar isSelectionAtLeafStart = require('./isSelectionAtLeafStart');\nvar nullthrows = require('fbjs/lib/nullthrows');\nvar setImmediate = require('fbjs/lib/setImmediate');\n\n// When nothing is focused, Firefox regards two characters, `'` and `/`, as\n// commands that should open and focus the \"quickfind\" search bar. This should\n// *never* happen while a contenteditable is focused, but as of v28, it\n// sometimes does, even when the keypress event target is the contenteditable.\n// This breaks the input. Special case these characters to ensure that when\n// they are typed, we prevent default on the event to make sure not to\n// trigger quickfind.\nvar FF_QUICKFIND_CHAR = \"'\";\nvar FF_QUICKFIND_LINK_CHAR = '/';\nvar isFirefox = UserAgent.isBrowser('Firefox');\n\nfunction mustPreventDefaultForCharacter(character) {\n  return isFirefox && (character == FF_QUICKFIND_CHAR || character == FF_QUICKFIND_LINK_CHAR);\n}\n\n/**\n * Replace the current selection with the specified text string, with the\n * inline style and entity key applied to the newly inserted text.\n */\nfunction replaceText(editorState, text, inlineStyle, entityKey) {\n  var contentState = DraftModifier.replaceText(editorState.getCurrentContent(), editorState.getSelection(), text, inlineStyle, entityKey);\n  return EditorState.push(editorState, contentState, 'insert-characters');\n}\n\n/**\n * When `onBeforeInput` executes, the browser is attempting to insert a\n * character into the editor. Apply this character data to the document,\n * allowing native insertion if possible.\n *\n * Native insertion is encouraged in order to limit re-rendering and to\n * preserve spellcheck highlighting, which disappears or flashes if re-render\n * occurs on the relevant text nodes.\n */\nfunction editOnBeforeInput(editor, e) {\n  if (editor._pendingStateFromBeforeInput !== undefined) {\n    editor.update(editor._pendingStateFromBeforeInput);\n    editor._pendingStateFromBeforeInput = undefined;\n  }\n\n  var editorState = editor._latestEditorState;\n\n  var chars = e.data;\n\n  // In some cases (ex: IE ideographic space insertion) no character data\n  // is provided. There's nothing to do when this happens.\n  if (!chars) {\n    return;\n  }\n\n  // Allow the top-level component to handle the insertion manually. This is\n  // useful when triggering interesting behaviors for a character insertion,\n  // Simple examples: replacing a raw text ':)' with a smile emoji or image\n  // decorator, or setting a block to be a list item after typing '- ' at the\n  // start of the block.\n  if (editor.props.handleBeforeInput && isEventHandled(editor.props.handleBeforeInput(chars, editorState))) {\n    e.preventDefault();\n    return;\n  }\n\n  // If selection is collapsed, conditionally allow native behavior. This\n  // reduces re-renders and preserves spellcheck highlighting. If the selection\n  // is not collapsed, we will re-render.\n  var selection = editorState.getSelection();\n  var selectionStart = selection.getStartOffset();\n  var selectionEnd = selection.getEndOffset();\n  var anchorKey = selection.getAnchorKey();\n\n  if (!selection.isCollapsed()) {\n    e.preventDefault();\n\n    // If the currently selected text matches what the user is trying to\n    // replace it with, let's just update the `SelectionState`. If not, update\n    // the `ContentState` with the new text.\n    var currentlySelectedChars = editorState.getCurrentContent().getPlainText().slice(selectionStart, selectionEnd);\n    if (chars === currentlySelectedChars) {\n      editor.update(EditorState.forceSelection(editorState, selection.merge({\n        focusOffset: selectionEnd\n      })));\n    } else {\n      editor.update(replaceText(editorState, chars, editorState.getCurrentInlineStyle(), getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection())));\n    }\n    return;\n  }\n\n  var newEditorState = replaceText(editorState, chars, editorState.getCurrentInlineStyle(), getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection()));\n\n  // Bunch of different cases follow where we need to prevent native insertion.\n  var mustPreventNative = false;\n  if (!mustPreventNative) {\n    // Browsers tend to insert text in weird places in the DOM when typing at\n    // the start of a leaf, so we'll handle it ourselves.\n    mustPreventNative = isSelectionAtLeafStart(editor._latestCommittedEditorState);\n  }\n  if (!mustPreventNative) {\n    // Chrome will also split up a node into two pieces if it contains a Tab\n    // char, for no explicable reason. Seemingly caused by this commit:\n    // https://chromium.googlesource.com/chromium/src/+/013ac5eaf3%5E%21/\n    var nativeSelection = global.getSelection();\n    // Selection is necessarily collapsed at this point due to earlier check.\n    if (nativeSelection.anchorNode && nativeSelection.anchorNode.nodeType === Node.TEXT_NODE) {\n      // See isTabHTMLSpanElement in chromium EditingUtilities.cpp.\n      var parentNode = nativeSelection.anchorNode.parentNode;\n      mustPreventNative = parentNode.nodeName === 'SPAN' && parentNode.firstChild.nodeType === Node.TEXT_NODE && parentNode.firstChild.nodeValue.indexOf('\\t') !== -1;\n    }\n  }\n  if (!mustPreventNative) {\n    // Check the old and new \"fingerprints\" of the current block to determine\n    // whether this insertion requires any addition or removal of text nodes,\n    // in which case we would prevent the native character insertion.\n    var originalFingerprint = BlockTree.getFingerprint(editorState.getBlockTree(anchorKey));\n    var newFingerprint = BlockTree.getFingerprint(newEditorState.getBlockTree(anchorKey));\n    mustPreventNative = originalFingerprint !== newFingerprint;\n  }\n  if (!mustPreventNative) {\n    mustPreventNative = mustPreventDefaultForCharacter(chars);\n  }\n  if (!mustPreventNative) {\n    mustPreventNative = nullthrows(newEditorState.getDirectionMap()).get(anchorKey) !== nullthrows(editorState.getDirectionMap()).get(anchorKey);\n  }\n\n  if (mustPreventNative) {\n    e.preventDefault();\n    editor.update(newEditorState);\n    return;\n  }\n\n  // We made it all the way! Let the browser do its thing and insert the char.\n  newEditorState = EditorState.set(newEditorState, {\n    nativelyRenderedContent: newEditorState.getCurrentContent()\n  });\n  // The native event is allowed to occur. To allow user onChange handlers to\n  // change the inserted text, we wait until the text is actually inserted\n  // before we actually update our state. That way when we rerender, the text\n  // we see in the DOM will already have been inserted properly.\n  editor._pendingStateFromBeforeInput = newEditorState;\n  setImmediate(function () {\n    if (editor._pendingStateFromBeforeInput !== undefined) {\n      editor.update(editor._pendingStateFromBeforeInput);\n      editor._pendingStateFromBeforeInput = undefined;\n    }\n  });\n}\n\nmodule.exports = editOnBeforeInput;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/editOnBeforeInput.js\n// module id = 468\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\n// setimmediate adds setImmediate to the global. We want to make sure we export\n// the actual function.\n\nrequire('setimmediate');\nmodule.exports = global.setImmediate;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/setImmediate.js\n// module id = 469\n// module chunks = 2","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/setimmediate/setImmediate.js\n// module id = 470\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnBlur\n * @format\n * \n */\n\n'use strict';\n\nvar EditorState = require('./EditorState');\n\nvar containsNode = require('fbjs/lib/containsNode');\nvar getActiveElement = require('fbjs/lib/getActiveElement');\n\nfunction editOnBlur(editor, e) {\n  // In a contentEditable element, when you select a range and then click\n  // another active element, this does trigger a `blur` event but will not\n  // remove the DOM selection from the contenteditable.\n  // This is consistent across all browsers, but we prefer that the editor\n  // behave like a textarea, where a `blur` event clears the DOM selection.\n  // We therefore force the issue to be certain, checking whether the active\n  // element is `body` to force it when blurring occurs within the window (as\n  // opposed to clicking to another tab or window).\n  if (getActiveElement() === document.body) {\n    var _selection = global.getSelection();\n    var editorNode = editor.editor;\n    if (_selection.rangeCount === 1 && containsNode(editorNode, _selection.anchorNode) && containsNode(editorNode, _selection.focusNode)) {\n      _selection.removeAllRanges();\n    }\n  }\n\n  var editorState = editor._latestEditorState;\n  var currentSelection = editorState.getSelection();\n  if (!currentSelection.getHasFocus()) {\n    return;\n  }\n\n  var selection = currentSelection.set('hasFocus', false);\n  editor.props.onBlur && editor.props.onBlur(e);\n  editor.update(EditorState.acceptSelection(editorState, selection));\n}\n\nmodule.exports = editOnBlur;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/editOnBlur.js\n// module id = 471\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnCompositionStart\n * @format\n * \n */\n\n'use strict';\n\nvar EditorState = require('./EditorState');\n\n/**\n * The user has begun using an IME input system. Switching to `composite` mode\n * allows handling composition input and disables other edit behavior.\n */\nfunction editOnCompositionStart(editor, e) {\n  editor.setMode('composite');\n  editor.update(EditorState.set(editor._latestEditorState, { inCompositionMode: true }));\n  // Allow composition handler to interpret the compositionstart event\n  editor._onCompositionStart(e);\n}\n\nmodule.exports = editOnCompositionStart;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/editOnCompositionStart.js\n// module id = 472\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnCopy\n * @format\n * \n */\n\n'use strict';\n\nvar getFragmentFromSelection = require('./getFragmentFromSelection');\n\n/**\n * If we have a selection, create a ContentState fragment and store\n * it in our internal clipboard. Subsequent paste events will use this\n * fragment if no external clipboard data is supplied.\n */\nfunction editOnCopy(editor, e) {\n  var editorState = editor._latestEditorState;\n  var selection = editorState.getSelection();\n\n  // No selection, so there's nothing to copy.\n  if (selection.isCollapsed()) {\n    e.preventDefault();\n    return;\n  }\n\n  editor.setClipboard(getFragmentFromSelection(editor._latestEditorState));\n}\n\nmodule.exports = editOnCopy;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/editOnCopy.js\n// module id = 473\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnCut\n * @format\n * \n */\n\n'use strict';\n\nvar DraftModifier = require('./DraftModifier');\nvar EditorState = require('./EditorState');\nvar Style = require('fbjs/lib/Style');\n\nvar getFragmentFromSelection = require('./getFragmentFromSelection');\nvar getScrollPosition = require('fbjs/lib/getScrollPosition');\n\n/**\n * On `cut` events, native behavior is allowed to occur so that the system\n * clipboard is set properly. This means that we need to take steps to recover\n * the editor DOM state after the `cut` has occurred in order to maintain\n * control of the component.\n *\n * In addition, we can keep a copy of the removed fragment, including all\n * styles and entities, for use as an internal paste.\n */\nfunction editOnCut(editor, e) {\n  var editorState = editor._latestEditorState;\n  var selection = editorState.getSelection();\n  var element = e.target;\n  var scrollPosition = void 0;\n\n  // No selection, so there's nothing to cut.\n  if (selection.isCollapsed()) {\n    e.preventDefault();\n    return;\n  }\n\n  // Track the current scroll position so that it can be forced back in place\n  // after the editor regains control of the DOM.\n  if (element instanceof Node) {\n    scrollPosition = getScrollPosition(Style.getScrollParent(element));\n  }\n\n  var fragment = getFragmentFromSelection(editorState);\n  editor.setClipboard(fragment);\n\n  // Set `cut` mode to disable all event handling temporarily.\n  editor.setMode('cut');\n\n  // Let native `cut` behavior occur, then recover control.\n  setTimeout(function () {\n    editor.restoreEditorDOM(scrollPosition);\n    editor.exitCurrentMode();\n    editor.update(removeFragment(editorState));\n  }, 0);\n}\n\nfunction removeFragment(editorState) {\n  var newContent = DraftModifier.removeRange(editorState.getCurrentContent(), editorState.getSelection(), 'forward');\n  return EditorState.push(editorState, newContent, 'remove-range');\n}\n\nmodule.exports = editOnCut;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/editOnCut.js\n// module id = 474\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnDragOver\n * @format\n * \n */\n\n'use strict';\n\n/**\n * Drag behavior has begun from outside the editor element.\n */\nfunction editOnDragOver(editor, e) {\n  editor._internalDrag = false;\n  editor.setMode('drag');\n  e.preventDefault();\n}\n\nmodule.exports = editOnDragOver;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/editOnDragOver.js\n// module id = 475\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnDragStart\n * @format\n * \n */\n\n'use strict';\n\n/**\n * A `dragstart` event has begun within the text editor component.\n */\nfunction editOnDragStart(editor) {\n  editor._internalDrag = true;\n  editor.setMode('drag');\n}\n\nmodule.exports = editOnDragStart;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/editOnDragStart.js\n// module id = 476\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnFocus\n * @format\n * \n */\n\n'use strict';\n\nvar EditorState = require('./EditorState');\nvar UserAgent = require('fbjs/lib/UserAgent');\n\nfunction editOnFocus(editor, e) {\n  var editorState = editor._latestEditorState;\n  var currentSelection = editorState.getSelection();\n  if (currentSelection.getHasFocus()) {\n    return;\n  }\n\n  var selection = currentSelection.set('hasFocus', true);\n  editor.props.onFocus && editor.props.onFocus(e);\n\n  // When the tab containing this text editor is hidden and the user does a\n  // find-in-page in a _different_ tab, Chrome on Mac likes to forget what the\n  // selection was right after sending this focus event and (if you let it)\n  // moves the cursor back to the beginning of the editor, so we force the\n  // selection here instead of simply accepting it in order to preserve the\n  // old cursor position. See https://crbug.com/540004.\n  // But it looks like this is fixed in Chrome 60.0.3081.0.\n  // Other browsers also don't have this bug, so we prefer to acceptSelection\n  // when possible, to ensure that unfocusing and refocusing a Draft editor\n  // doesn't preserve the selection, matching how textareas work.\n  if (UserAgent.isBrowser('Chrome < 60.0.3081.0')) {\n    editor.update(EditorState.forceSelection(editorState, selection));\n  } else {\n    editor.update(EditorState.acceptSelection(editorState, selection));\n  }\n}\n\nmodule.exports = editOnFocus;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/editOnFocus.js\n// module id = 477\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnInput\n * @format\n * \n */\n\n'use strict';\n\nvar DraftFeatureFlags = require('./DraftFeatureFlags');\nvar DraftModifier = require('./DraftModifier');\nvar DraftOffsetKey = require('./DraftOffsetKey');\nvar EditorState = require('./EditorState');\nvar UserAgent = require('fbjs/lib/UserAgent');\n\nvar findAncestorOffsetKey = require('./findAncestorOffsetKey');\nvar nullthrows = require('fbjs/lib/nullthrows');\n\nvar isGecko = UserAgent.isEngine('Gecko');\n\nvar DOUBLE_NEWLINE = '\\n\\n';\n\n/**\n * This function is intended to handle spellcheck and autocorrect changes,\n * which occur in the DOM natively without any opportunity to observe or\n * interpret the changes before they occur.\n *\n * The `input` event fires in contentEditable elements reliably for non-IE\n * browsers, immediately after changes occur to the editor DOM. Since our other\n * handlers override or otherwise handle cover other varieties of text input,\n * the DOM state should match the model in all controlled input cases. Thus,\n * when an `input` change leads to a DOM/model mismatch, the change should be\n * due to a spellcheck change, and we can incorporate it into our model.\n */\nfunction editOnInput(editor) {\n  if (editor._pendingStateFromBeforeInput !== undefined) {\n    editor.update(editor._pendingStateFromBeforeInput);\n    editor._pendingStateFromBeforeInput = undefined;\n  }\n\n  var domSelection = global.getSelection();\n\n  var anchorNode = domSelection.anchorNode,\n      isCollapsed = domSelection.isCollapsed;\n\n  var isNotTextNode = anchorNode.nodeType !== Node.TEXT_NODE;\n  var isNotTextOrElementNode = anchorNode.nodeType !== Node.TEXT_NODE && anchorNode.nodeType !== Node.ELEMENT_NODE;\n\n  if (DraftFeatureFlags.draft_killswitch_allow_nontextnodes) {\n    if (isNotTextNode) {\n      return;\n    }\n  } else {\n    if (isNotTextOrElementNode) {\n      // TODO: (t16149272) figure out context for this change\n      return;\n    }\n  }\n\n  if (anchorNode.nodeType === Node.TEXT_NODE && (anchorNode.previousSibling !== null || anchorNode.nextSibling !== null)) {\n    // When typing at the beginning of a visual line, Chrome splits the text\n    // nodes into two. Why? No one knows. This commit is suspicious:\n    // https://chromium.googlesource.com/chromium/src/+/a3b600981286b135632371477f902214c55a1724\n    // To work around, we'll merge the sibling text nodes back into this one.\n    var span = anchorNode.parentNode;\n    anchorNode.nodeValue = span.textContent;\n    for (var child = span.firstChild; child !== null; child = child.nextSibling) {\n      if (child !== anchorNode) {\n        span.removeChild(child);\n      }\n    }\n  }\n\n  var domText = anchorNode.textContent;\n  var editorState = editor._latestEditorState;\n  var offsetKey = nullthrows(findAncestorOffsetKey(anchorNode));\n\n  var _DraftOffsetKey$decod = DraftOffsetKey.decode(offsetKey),\n      blockKey = _DraftOffsetKey$decod.blockKey,\n      decoratorKey = _DraftOffsetKey$decod.decoratorKey,\n      leafKey = _DraftOffsetKey$decod.leafKey;\n\n  var _editorState$getBlock = editorState.getBlockTree(blockKey).getIn([decoratorKey, 'leaves', leafKey]),\n      start = _editorState$getBlock.start,\n      end = _editorState$getBlock.end;\n\n  var content = editorState.getCurrentContent();\n  var block = content.getBlockForKey(blockKey);\n  var modelText = block.getText().slice(start, end);\n\n  // Special-case soft newlines here. If the DOM text ends in a soft newline,\n  // we will have manually inserted an extra soft newline in DraftEditorLeaf.\n  // We want to remove this extra newline for the purpose of our comparison\n  // of DOM and model text.\n  if (domText.endsWith(DOUBLE_NEWLINE)) {\n    domText = domText.slice(0, -1);\n  }\n\n  // No change -- the DOM is up to date. Nothing to do here.\n  if (domText === modelText) {\n    // This can be buggy for some Android keyboards because they don't fire\n    // standard onkeydown/pressed events and only fired editOnInput\n    // so domText is already changed by the browser and ends up being equal\n    // to modelText unexpectedly\n    return;\n  }\n\n  var selection = editorState.getSelection();\n\n  // We'll replace the entire leaf with the text content of the target.\n  var targetRange = selection.merge({\n    anchorOffset: start,\n    focusOffset: end,\n    isBackward: false\n  });\n\n  var entityKey = block.getEntityAt(start);\n  var entity = entityKey && content.getEntity(entityKey);\n  var entityType = entity && entity.getMutability();\n  var preserveEntity = entityType === 'MUTABLE';\n\n  // Immutable or segmented entities cannot properly be handled by the\n  // default browser undo, so we have to use a different change type to\n  // force using our internal undo method instead of falling through to the\n  // native browser undo.\n  var changeType = preserveEntity ? 'spellcheck-change' : 'apply-entity';\n\n  var newContent = DraftModifier.replaceText(content, targetRange, domText, block.getInlineStyleAt(start), preserveEntity ? block.getEntityAt(start) : null);\n\n  var anchorOffset, focusOffset, startOffset, endOffset;\n\n  if (isGecko) {\n    // Firefox selection does not change while the context menu is open, so\n    // we preserve the anchor and focus values of the DOM selection.\n    anchorOffset = domSelection.anchorOffset;\n    focusOffset = domSelection.focusOffset;\n    startOffset = start + Math.min(anchorOffset, focusOffset);\n    endOffset = startOffset + Math.abs(anchorOffset - focusOffset);\n    anchorOffset = startOffset;\n    focusOffset = endOffset;\n  } else {\n    // Browsers other than Firefox may adjust DOM selection while the context\n    // menu is open, and Safari autocorrect is prone to providing an inaccurate\n    // DOM selection. Don't trust it. Instead, use our existing SelectionState\n    // and adjust it based on the number of characters changed during the\n    // mutation.\n    var charDelta = domText.length - modelText.length;\n    startOffset = selection.getStartOffset();\n    endOffset = selection.getEndOffset();\n\n    anchorOffset = isCollapsed ? endOffset + charDelta : startOffset;\n    focusOffset = endOffset + charDelta;\n  }\n\n  // Segmented entities are completely or partially removed when their\n  // text content changes. For this case we do not want any text to be selected\n  // after the change, so we are not merging the selection.\n  var contentWithAdjustedDOMSelection = newContent.merge({\n    selectionBefore: content.getSelectionAfter(),\n    selectionAfter: selection.merge({ anchorOffset: anchorOffset, focusOffset: focusOffset })\n  });\n\n  editor.update(EditorState.push(editorState, contentWithAdjustedDOMSelection, changeType));\n}\n\nmodule.exports = editOnInput;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/editOnInput.js\n// module id = 478\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnKeyDown\n * @format\n * \n */\n\n'use strict';\n\nvar DraftModifier = require('./DraftModifier');\nvar EditorState = require('./EditorState');\nvar KeyBindingUtil = require('./KeyBindingUtil');\nvar Keys = require('fbjs/lib/Keys');\nvar SecondaryClipboard = require('./SecondaryClipboard');\nvar UserAgent = require('fbjs/lib/UserAgent');\n\nvar isEventHandled = require('./isEventHandled');\nvar keyCommandBackspaceToStartOfLine = require('./keyCommandBackspaceToStartOfLine');\nvar keyCommandBackspaceWord = require('./keyCommandBackspaceWord');\nvar keyCommandDeleteWord = require('./keyCommandDeleteWord');\nvar keyCommandInsertNewline = require('./keyCommandInsertNewline');\nvar keyCommandMoveSelectionToEndOfBlock = require('./keyCommandMoveSelectionToEndOfBlock');\nvar keyCommandMoveSelectionToStartOfBlock = require('./keyCommandMoveSelectionToStartOfBlock');\nvar keyCommandPlainBackspace = require('./keyCommandPlainBackspace');\nvar keyCommandPlainDelete = require('./keyCommandPlainDelete');\nvar keyCommandTransposeCharacters = require('./keyCommandTransposeCharacters');\nvar keyCommandUndo = require('./keyCommandUndo');\n\nvar isOptionKeyCommand = KeyBindingUtil.isOptionKeyCommand;\n\nvar isChrome = UserAgent.isBrowser('Chrome');\n\n/**\n * Map a `DraftEditorCommand` command value to a corresponding function.\n */\nfunction onKeyCommand(command, editorState) {\n  switch (command) {\n    case 'redo':\n      return EditorState.redo(editorState);\n    case 'delete':\n      return keyCommandPlainDelete(editorState);\n    case 'delete-word':\n      return keyCommandDeleteWord(editorState);\n    case 'backspace':\n      return keyCommandPlainBackspace(editorState);\n    case 'backspace-word':\n      return keyCommandBackspaceWord(editorState);\n    case 'backspace-to-start-of-line':\n      return keyCommandBackspaceToStartOfLine(editorState);\n    case 'split-block':\n      return keyCommandInsertNewline(editorState);\n    case 'transpose-characters':\n      return keyCommandTransposeCharacters(editorState);\n    case 'move-selection-to-start-of-block':\n      return keyCommandMoveSelectionToStartOfBlock(editorState);\n    case 'move-selection-to-end-of-block':\n      return keyCommandMoveSelectionToEndOfBlock(editorState);\n    case 'secondary-cut':\n      return SecondaryClipboard.cut(editorState);\n    case 'secondary-paste':\n      return SecondaryClipboard.paste(editorState);\n    default:\n      return editorState;\n  }\n}\n\n/**\n * Intercept keydown behavior to handle keys and commands manually, if desired.\n *\n * Keydown combinations may be mapped to `DraftCommand` values, which may\n * correspond to command functions that modify the editor or its contents.\n *\n * See `getDefaultKeyBinding` for defaults. Alternatively, the top-level\n * component may provide a custom mapping via the `keyBindingFn` prop.\n */\nfunction editOnKeyDown(editor, e) {\n  var keyCode = e.which;\n  var editorState = editor._latestEditorState;\n\n  switch (keyCode) {\n    case Keys.RETURN:\n      e.preventDefault();\n      // The top-level component may manually handle newline insertion. If\n      // no special handling is performed, fall through to command handling.\n      if (editor.props.handleReturn && isEventHandled(editor.props.handleReturn(e, editorState))) {\n        return;\n      }\n      break;\n    case Keys.ESC:\n      e.preventDefault();\n      editor.props.onEscape && editor.props.onEscape(e);\n      return;\n    case Keys.TAB:\n      editor.props.onTab && editor.props.onTab(e);\n      return;\n    case Keys.UP:\n      editor.props.onUpArrow && editor.props.onUpArrow(e);\n      return;\n    case Keys.RIGHT:\n      editor.props.onRightArrow && editor.props.onRightArrow(e);\n      return;\n    case Keys.DOWN:\n      editor.props.onDownArrow && editor.props.onDownArrow(e);\n      return;\n    case Keys.LEFT:\n      editor.props.onLeftArrow && editor.props.onLeftArrow(e);\n      return;\n    case Keys.SPACE:\n      // Handling for OSX where option + space scrolls.\n      if (isChrome && isOptionKeyCommand(e)) {\n        e.preventDefault();\n        // Insert a nbsp into the editor.\n        var contentState = DraftModifier.replaceText(editorState.getCurrentContent(), editorState.getSelection(), '\\xA0');\n        editor.update(EditorState.push(editorState, contentState, 'insert-characters'));\n        return;\n      }\n  }\n\n  var command = editor.props.keyBindingFn(e);\n\n  // If no command is specified, allow keydown event to continue.\n  if (!command) {\n    return;\n  }\n\n  if (command === 'undo') {\n    // Since undo requires some special updating behavior to keep the editor\n    // in sync, handle it separately.\n    keyCommandUndo(e, editorState, editor.update);\n    return;\n  }\n\n  // At this point, we know that we're handling a command of some kind, so\n  // we don't want to insert a character following the keydown.\n  e.preventDefault();\n\n  // Allow components higher up the tree to handle the command first.\n  if (editor.props.handleKeyCommand && isEventHandled(editor.props.handleKeyCommand(command, editorState))) {\n    return;\n  }\n\n  var newState = onKeyCommand(command, editorState);\n  if (newState !== editorState) {\n    editor.update(newState);\n  }\n}\n\nmodule.exports = editOnKeyDown;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/editOnKeyDown.js\n// module id = 479\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule SecondaryClipboard\n * @format\n * \n */\n\n'use strict';\n\nvar DraftModifier = require('./DraftModifier');\nvar EditorState = require('./EditorState');\n\nvar getContentStateFragment = require('./getContentStateFragment');\nvar nullthrows = require('fbjs/lib/nullthrows');\n\nvar clipboard = null;\n\n/**\n * Some systems offer a \"secondary\" clipboard to allow quick internal cut\n * and paste behavior. For instance, Ctrl+K (cut) and Ctrl+Y (paste).\n */\nvar SecondaryClipboard = {\n  cut: function cut(editorState) {\n    var content = editorState.getCurrentContent();\n    var selection = editorState.getSelection();\n    var targetRange = null;\n\n    if (selection.isCollapsed()) {\n      var anchorKey = selection.getAnchorKey();\n      var blockEnd = content.getBlockForKey(anchorKey).getLength();\n\n      if (blockEnd === selection.getAnchorOffset()) {\n        return editorState;\n      }\n\n      targetRange = selection.set('focusOffset', blockEnd);\n    } else {\n      targetRange = selection;\n    }\n\n    targetRange = nullthrows(targetRange);\n    clipboard = getContentStateFragment(content, targetRange);\n\n    var afterRemoval = DraftModifier.removeRange(content, targetRange, 'forward');\n\n    if (afterRemoval === content) {\n      return editorState;\n    }\n\n    return EditorState.push(editorState, afterRemoval, 'remove-range');\n  },\n\n  paste: function paste(editorState) {\n    if (!clipboard) {\n      return editorState;\n    }\n\n    var newContent = DraftModifier.replaceWithFragment(editorState.getCurrentContent(), editorState.getSelection(), clipboard);\n\n    return EditorState.push(editorState, newContent, 'insert-fragment');\n  }\n};\n\nmodule.exports = SecondaryClipboard;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/SecondaryClipboard.js\n// module id = 480\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandBackspaceToStartOfLine\n * @format\n * \n */\n\n'use strict';\n\nvar EditorState = require('./EditorState');\n\nvar expandRangeToStartOfLine = require('./expandRangeToStartOfLine');\nvar getDraftEditorSelectionWithNodes = require('./getDraftEditorSelectionWithNodes');\nvar moveSelectionBackward = require('./moveSelectionBackward');\nvar removeTextWithStrategy = require('./removeTextWithStrategy');\n\nfunction keyCommandBackspaceToStartOfLine(editorState) {\n  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {\n    var selection = strategyState.getSelection();\n    if (selection.isCollapsed() && selection.getAnchorOffset() === 0) {\n      return moveSelectionBackward(strategyState, 1);\n    }\n\n    var domSelection = global.getSelection();\n    var range = domSelection.getRangeAt(0);\n    range = expandRangeToStartOfLine(range);\n\n    return getDraftEditorSelectionWithNodes(strategyState, null, range.endContainer, range.endOffset, range.startContainer, range.startOffset).selectionState;\n  }, 'backward');\n\n  if (afterRemoval === editorState.getCurrentContent()) {\n    return editorState;\n  }\n\n  return EditorState.push(editorState, afterRemoval, 'remove-range');\n}\n\nmodule.exports = keyCommandBackspaceToStartOfLine;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/keyCommandBackspaceToStartOfLine.js\n// module id = 481\n// module chunks = 2","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule expandRangeToStartOfLine\n * @format\n * \n */\n\nvar UnicodeUtils = require('fbjs/lib/UnicodeUtils');\n\nvar getRangeClientRects = require('./getRangeClientRects');\nvar invariant = require('fbjs/lib/invariant');\n\n/**\n * Return the computed line height, in pixels, for the provided element.\n */\nfunction getLineHeightPx(element) {\n  var computed = getComputedStyle(element);\n  var div = document.createElement('div');\n  div.style.fontFamily = computed.fontFamily;\n  div.style.fontSize = computed.fontSize;\n  div.style.fontStyle = computed.fontStyle;\n  div.style.fontWeight = computed.fontWeight;\n  div.style.lineHeight = computed.lineHeight;\n  div.style.position = 'absolute';\n  div.textContent = 'M';\n\n  var documentBody = document.body;\n  !documentBody ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Missing document.body') : invariant(false) : void 0;\n\n  // forced layout here\n  documentBody.appendChild(div);\n  var rect = div.getBoundingClientRect();\n  documentBody.removeChild(div);\n\n  return rect.height;\n}\n\n/**\n * Return whether every ClientRect in the provided list lies on the same line.\n *\n * We assume that the rects on the same line all contain the baseline, so the\n * lowest top line needs to be above the highest bottom line (i.e., if you were\n * to project the rects onto the y-axis, their intersection would be nonempty).\n *\n * In addition, we require that no two boxes are lineHeight (or more) apart at\n * either top or bottom, which helps protect against false positives for fonts\n * with extremely large glyph heights (e.g., with a font size of 17px, Zapfino\n * produces rects of height 58px!).\n */\nfunction areRectsOnOneLine(rects, lineHeight) {\n  var minTop = Infinity;\n  var minBottom = Infinity;\n  var maxTop = -Infinity;\n  var maxBottom = -Infinity;\n\n  for (var ii = 0; ii < rects.length; ii++) {\n    var rect = rects[ii];\n    if (rect.width === 0 || rect.width === 1) {\n      // When a range starts or ends a soft wrap, many browsers (Chrome, IE,\n      // Safari) include an empty rect on the previous or next line. When the\n      // text lies in a container whose position is not integral (e.g., from\n      // margin: auto), Safari makes these empty rects have width 1 (instead of\n      // 0). Having one-pixel-wide characters seems unlikely (and most browsers\n      // report widths in subpixel precision anyway) so it's relatively safe to\n      // skip over them.\n      continue;\n    }\n    minTop = Math.min(minTop, rect.top);\n    minBottom = Math.min(minBottom, rect.bottom);\n    maxTop = Math.max(maxTop, rect.top);\n    maxBottom = Math.max(maxBottom, rect.bottom);\n  }\n\n  return maxTop <= minBottom && maxTop - minTop < lineHeight && maxBottom - minBottom < lineHeight;\n}\n\n/**\n * Return the length of a node, as used by Range offsets.\n */\nfunction getNodeLength(node) {\n  // http://www.w3.org/TR/dom/#concept-node-length\n  switch (node.nodeType) {\n    case Node.DOCUMENT_TYPE_NODE:\n      return 0;\n    case Node.TEXT_NODE:\n    case Node.PROCESSING_INSTRUCTION_NODE:\n    case Node.COMMENT_NODE:\n      return node.length;\n    default:\n      return node.childNodes.length;\n  }\n}\n\n/**\n * Given a collapsed range, move the start position backwards as far as\n * possible while the range still spans only a single line.\n */\nfunction expandRangeToStartOfLine(range) {\n  !range.collapsed ? process.env.NODE_ENV !== 'production' ? invariant(false, 'expandRangeToStartOfLine: Provided range is not collapsed.') : invariant(false) : void 0;\n  range = range.cloneRange();\n\n  var containingElement = range.startContainer;\n  if (containingElement.nodeType !== 1) {\n    containingElement = containingElement.parentNode;\n  }\n  var lineHeight = getLineHeightPx(containingElement);\n\n  // Imagine our text looks like:\n  //   <div><span>once upon a time, there was a <em>boy\n  //   who lived</em> </span><q><strong>under^ the\n  //   stairs</strong> in a small closet.</q></div>\n  // where the caret represents the cursor. First, we crawl up the tree until\n  // the range spans multiple lines (setting the start point to before\n  // \"<strong>\", then before \"<div>\"), then at each level we do a search to\n  // find the latest point which is still on a previous line. We'll find that\n  // the break point is inside the span, then inside the <em>, then in its text\n  // node child, the actual break point before \"who\".\n\n  var bestContainer = range.endContainer;\n  var bestOffset = range.endOffset;\n  range.setStart(range.startContainer, 0);\n\n  while (areRectsOnOneLine(getRangeClientRects(range), lineHeight)) {\n    bestContainer = range.startContainer;\n    bestOffset = range.startOffset;\n    !bestContainer.parentNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Found unexpected detached subtree when traversing.') : invariant(false) : void 0;\n    range.setStartBefore(bestContainer);\n    if (bestContainer.nodeType === 1 && getComputedStyle(bestContainer).display !== 'inline') {\n      // The start of the line is never in a different block-level container.\n      break;\n    }\n  }\n\n  // In the above example, range now spans from \"<div>\" to \"under\",\n  // bestContainer is <div>, and bestOffset is 1 (index of <q> inside <div>)].\n  // Picking out which child to recurse into here is a special case since we\n  // don't want to check past <q> -- once we find that the final range starts\n  // in <span>, we can look at all of its children (and all of their children)\n  // to find the break point.\n\n  // At all times, (bestContainer, bestOffset) is the latest single-line start\n  // point that we know of.\n  var currentContainer = bestContainer;\n  var maxIndexToConsider = bestOffset - 1;\n\n  do {\n    var nodeValue = currentContainer.nodeValue;\n\n    for (var ii = maxIndexToConsider; ii >= 0; ii--) {\n      if (nodeValue != null && ii > 0 && UnicodeUtils.isSurrogatePair(nodeValue, ii - 1)) {\n        // We're in the middle of a surrogate pair -- skip over so we never\n        // return a range with an endpoint in the middle of a code point.\n        continue;\n      }\n\n      range.setStart(currentContainer, ii);\n      if (areRectsOnOneLine(getRangeClientRects(range), lineHeight)) {\n        bestContainer = currentContainer;\n        bestOffset = ii;\n      } else {\n        break;\n      }\n    }\n\n    if (ii === -1 || currentContainer.childNodes.length === 0) {\n      // If ii === -1, then (bestContainer, bestOffset), which is equal to\n      // (currentContainer, 0), was a single-line start point but a start\n      // point before currentContainer wasn't, so the line break seems to\n      // have occurred immediately after currentContainer's start tag\n      //\n      // If currentContainer.childNodes.length === 0, we're already at a\n      // terminal node (e.g., text node) and should return our current best.\n      break;\n    }\n\n    currentContainer = currentContainer.childNodes[ii];\n    maxIndexToConsider = getNodeLength(currentContainer);\n  } while (true);\n\n  range.setStart(bestContainer, bestOffset);\n  return range;\n}\n\nmodule.exports = expandRangeToStartOfLine;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/expandRangeToStartOfLine.js\n// module id = 482\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandBackspaceWord\n * @format\n * \n */\n\n'use strict';\n\nvar DraftRemovableWord = require('./DraftRemovableWord');\nvar EditorState = require('./EditorState');\n\nvar moveSelectionBackward = require('./moveSelectionBackward');\nvar removeTextWithStrategy = require('./removeTextWithStrategy');\n\n/**\n * Delete the word that is left of the cursor, as well as any spaces or\n * punctuation after the word.\n */\nfunction keyCommandBackspaceWord(editorState) {\n  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {\n    var selection = strategyState.getSelection();\n    var offset = selection.getStartOffset();\n    // If there are no words before the cursor, remove the preceding newline.\n    if (offset === 0) {\n      return moveSelectionBackward(strategyState, 1);\n    }\n    var key = selection.getStartKey();\n    var content = strategyState.getCurrentContent();\n    var text = content.getBlockForKey(key).getText().slice(0, offset);\n    var toRemove = DraftRemovableWord.getBackward(text);\n    return moveSelectionBackward(strategyState, toRemove.length || 1);\n  }, 'backward');\n\n  if (afterRemoval === editorState.getCurrentContent()) {\n    return editorState;\n  }\n\n  return EditorState.push(editorState, afterRemoval, 'remove-range');\n}\n\nmodule.exports = keyCommandBackspaceWord;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/keyCommandBackspaceWord.js\n// module id = 483\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n * @stub\n * \n */\n\n'use strict';\n\n// \\u00a1-\\u00b1\\u00b4-\\u00b8\\u00ba\\u00bb\\u00bf\n//             is latin supplement punctuation except fractions and superscript\n//             numbers\n// \\u2010-\\u2027\\u2030-\\u205e\n//             is punctuation from the general punctuation block:\n//             weird quotes, commas, bullets, dashes, etc.\n// \\u30fb\\u3001\\u3002\\u3008-\\u3011\\u3014-\\u301f\n//             is CJK punctuation\n// \\uff1a-\\uff1f\\uff01-\\uff0f\\uff3b-\\uff40\\uff5b-\\uff65\n//             is some full-width/half-width punctuation\n// \\u2E2E\\u061f\\u066a-\\u066c\\u061b\\u060c\\u060d\\uFD3e\\uFD3F\n//             is some Arabic punctuation marks\n// \\u1801\\u0964\\u104a\\u104b\n//             is misc. other language punctuation marks\n\nvar PUNCTUATION = '[.,+*?$|#{}()\\'\\\\^\\\\-\\\\[\\\\]\\\\\\\\\\\\/!@%\"~=<>_:;' + '\\u30FB\\u3001\\u3002\\u3008-\\u3011\\u3014-\\u301F\\uFF1A-\\uFF1F\\uFF01-\\uFF0F' + '\\uFF3B-\\uFF40\\uFF5B-\\uFF65\\u2E2E\\u061F\\u066A-\\u066C\\u061B\\u060C\\u060D' + '\\uFD3E\\uFD3F\\u1801\\u0964\\u104A\\u104B\\u2010-\\u2027\\u2030-\\u205E' + '\\xA1-\\xB1\\xB4-\\xB8\\xBA\\xBB\\xBF]';\n\nmodule.exports = {\n  getPunctuation: function getPunctuation() {\n    return PUNCTUATION;\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/TokenizeUtil.js\n// module id = 484\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandDeleteWord\n * @format\n * \n */\n\n'use strict';\n\nvar DraftRemovableWord = require('./DraftRemovableWord');\nvar EditorState = require('./EditorState');\n\nvar moveSelectionForward = require('./moveSelectionForward');\nvar removeTextWithStrategy = require('./removeTextWithStrategy');\n\n/**\n * Delete the word that is right of the cursor, as well as any spaces or\n * punctuation before the word.\n */\nfunction keyCommandDeleteWord(editorState) {\n  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {\n    var selection = strategyState.getSelection();\n    var offset = selection.getStartOffset();\n    var key = selection.getStartKey();\n    var content = strategyState.getCurrentContent();\n    var text = content.getBlockForKey(key).getText().slice(offset);\n    var toRemove = DraftRemovableWord.getForward(text);\n\n    // If there are no words in front of the cursor, remove the newline.\n    return moveSelectionForward(strategyState, toRemove.length || 1);\n  }, 'forward');\n\n  if (afterRemoval === editorState.getCurrentContent()) {\n    return editorState;\n  }\n\n  return EditorState.push(editorState, afterRemoval, 'remove-range');\n}\n\nmodule.exports = keyCommandDeleteWord;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/keyCommandDeleteWord.js\n// module id = 485\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandInsertNewline\n * @format\n * \n */\n\n'use strict';\n\nvar DraftModifier = require('./DraftModifier');\nvar EditorState = require('./EditorState');\n\nfunction keyCommandInsertNewline(editorState) {\n  var contentState = DraftModifier.splitBlock(editorState.getCurrentContent(), editorState.getSelection());\n  return EditorState.push(editorState, contentState, 'split-block');\n}\n\nmodule.exports = keyCommandInsertNewline;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/keyCommandInsertNewline.js\n// module id = 486\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandMoveSelectionToEndOfBlock\n * @format\n * \n */\n\n'use strict';\n\nvar EditorState = require('./EditorState');\n\n/**\n * See comment for `moveSelectionToStartOfBlock`.\n */\nfunction keyCommandMoveSelectionToEndOfBlock(editorState) {\n  var selection = editorState.getSelection();\n  var endKey = selection.getEndKey();\n  var content = editorState.getCurrentContent();\n  var textLength = content.getBlockForKey(endKey).getLength();\n  return EditorState.set(editorState, {\n    selection: selection.merge({\n      anchorKey: endKey,\n      anchorOffset: textLength,\n      focusKey: endKey,\n      focusOffset: textLength,\n      isBackward: false\n    }),\n    forceSelection: true\n  });\n}\n\nmodule.exports = keyCommandMoveSelectionToEndOfBlock;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/keyCommandMoveSelectionToEndOfBlock.js\n// module id = 487\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandMoveSelectionToStartOfBlock\n * @format\n * \n */\n\n'use strict';\n\nvar EditorState = require('./EditorState');\n\n/**\n * Collapse selection at the start of the first selected block. This is used\n * for Firefox versions that attempt to navigate forward/backward instead of\n * moving the cursor. Other browsers are able to move the cursor natively.\n */\nfunction keyCommandMoveSelectionToStartOfBlock(editorState) {\n  var selection = editorState.getSelection();\n  var startKey = selection.getStartKey();\n  return EditorState.set(editorState, {\n    selection: selection.merge({\n      anchorKey: startKey,\n      anchorOffset: 0,\n      focusKey: startKey,\n      focusOffset: 0,\n      isBackward: false\n    }),\n    forceSelection: true\n  });\n}\n\nmodule.exports = keyCommandMoveSelectionToStartOfBlock;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/keyCommandMoveSelectionToStartOfBlock.js\n// module id = 488\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandPlainBackspace\n * @format\n * \n */\n\n'use strict';\n\nvar EditorState = require('./EditorState');\nvar UnicodeUtils = require('fbjs/lib/UnicodeUtils');\n\nvar moveSelectionBackward = require('./moveSelectionBackward');\nvar removeTextWithStrategy = require('./removeTextWithStrategy');\n\n/**\n * Remove the selected range. If the cursor is collapsed, remove the preceding\n * character. This operation is Unicode-aware, so removing a single character\n * will remove a surrogate pair properly as well.\n */\nfunction keyCommandPlainBackspace(editorState) {\n  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {\n    var selection = strategyState.getSelection();\n    var content = strategyState.getCurrentContent();\n    var key = selection.getAnchorKey();\n    var offset = selection.getAnchorOffset();\n    var charBehind = content.getBlockForKey(key).getText()[offset - 1];\n    return moveSelectionBackward(strategyState, charBehind ? UnicodeUtils.getUTF16Length(charBehind, 0) : 1);\n  }, 'backward');\n\n  if (afterRemoval === editorState.getCurrentContent()) {\n    return editorState;\n  }\n\n  var selection = editorState.getSelection();\n  return EditorState.push(editorState, afterRemoval.set('selectionBefore', selection), selection.isCollapsed() ? 'backspace-character' : 'remove-range');\n}\n\nmodule.exports = keyCommandPlainBackspace;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/keyCommandPlainBackspace.js\n// module id = 489\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandPlainDelete\n * @format\n * \n */\n\n'use strict';\n\nvar EditorState = require('./EditorState');\nvar UnicodeUtils = require('fbjs/lib/UnicodeUtils');\n\nvar moveSelectionForward = require('./moveSelectionForward');\nvar removeTextWithStrategy = require('./removeTextWithStrategy');\n\n/**\n * Remove the selected range. If the cursor is collapsed, remove the following\n * character. This operation is Unicode-aware, so removing a single character\n * will remove a surrogate pair properly as well.\n */\nfunction keyCommandPlainDelete(editorState) {\n  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {\n    var selection = strategyState.getSelection();\n    var content = strategyState.getCurrentContent();\n    var key = selection.getAnchorKey();\n    var offset = selection.getAnchorOffset();\n    var charAhead = content.getBlockForKey(key).getText()[offset];\n    return moveSelectionForward(strategyState, charAhead ? UnicodeUtils.getUTF16Length(charAhead, 0) : 1);\n  }, 'forward');\n\n  if (afterRemoval === editorState.getCurrentContent()) {\n    return editorState;\n  }\n\n  var selection = editorState.getSelection();\n\n  return EditorState.push(editorState, afterRemoval.set('selectionBefore', selection), selection.isCollapsed() ? 'delete-character' : 'remove-range');\n}\n\nmodule.exports = keyCommandPlainDelete;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/keyCommandPlainDelete.js\n// module id = 490\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandTransposeCharacters\n * @format\n * \n */\n\n'use strict';\n\nvar DraftModifier = require('./DraftModifier');\nvar EditorState = require('./EditorState');\n\nvar getContentStateFragment = require('./getContentStateFragment');\n\n/**\n * Transpose the characters on either side of a collapsed cursor, or\n * if the cursor is at the end of the block, transpose the last two\n * characters.\n */\nfunction keyCommandTransposeCharacters(editorState) {\n  var selection = editorState.getSelection();\n  if (!selection.isCollapsed()) {\n    return editorState;\n  }\n\n  var offset = selection.getAnchorOffset();\n  if (offset === 0) {\n    return editorState;\n  }\n\n  var blockKey = selection.getAnchorKey();\n  var content = editorState.getCurrentContent();\n  var block = content.getBlockForKey(blockKey);\n  var length = block.getLength();\n\n  // Nothing to transpose if there aren't two characters.\n  if (length <= 1) {\n    return editorState;\n  }\n\n  var removalRange;\n  var finalSelection;\n\n  if (offset === length) {\n    // The cursor is at the end of the block. Swap the last two characters.\n    removalRange = selection.set('anchorOffset', offset - 1);\n    finalSelection = selection;\n  } else {\n    removalRange = selection.set('focusOffset', offset + 1);\n    finalSelection = removalRange.set('anchorOffset', offset + 1);\n  }\n\n  // Extract the character to move as a fragment. This preserves its\n  // styling and entity, if any.\n  var movedFragment = getContentStateFragment(content, removalRange);\n  var afterRemoval = DraftModifier.removeRange(content, removalRange, 'backward');\n\n  // After the removal, the insertion target is one character back.\n  var selectionAfter = afterRemoval.getSelectionAfter();\n  var targetOffset = selectionAfter.getAnchorOffset() - 1;\n  var targetRange = selectionAfter.merge({\n    anchorOffset: targetOffset,\n    focusOffset: targetOffset\n  });\n\n  var afterInsert = DraftModifier.replaceWithFragment(afterRemoval, targetRange, movedFragment);\n\n  var newEditorState = EditorState.push(editorState, afterInsert, 'insert-fragment');\n\n  return EditorState.acceptSelection(newEditorState, finalSelection);\n}\n\nmodule.exports = keyCommandTransposeCharacters;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/keyCommandTransposeCharacters.js\n// module id = 491\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyCommandUndo\n * @format\n * \n */\n\n'use strict';\n\nvar EditorState = require('./EditorState');\n\nfunction keyCommandUndo(e, editorState, updateFn) {\n  var undoneState = EditorState.undo(editorState);\n\n  // If the last change to occur was a spellcheck change, allow the undo\n  // event to fall through to the browser. This allows the browser to record\n  // the unwanted change, which should soon lead it to learn not to suggest\n  // the correction again.\n  if (editorState.getLastChangeType() === 'spellcheck-change') {\n    var nativelyRenderedContent = undoneState.getCurrentContent();\n    updateFn(EditorState.set(undoneState, { nativelyRenderedContent: nativelyRenderedContent }));\n    return;\n  }\n\n  // Otheriwse, manage the undo behavior manually.\n  e.preventDefault();\n  if (!editorState.getNativelyRenderedContent()) {\n    updateFn(undoneState);\n    return;\n  }\n\n  // Trigger a re-render with the current content state to ensure that the\n  // component tree has up-to-date props for comparison.\n  updateFn(EditorState.set(editorState, { nativelyRenderedContent: null }));\n\n  // Wait to ensure that the re-render has occurred before performing\n  // the undo action.\n  setTimeout(function () {\n    updateFn(undoneState);\n  }, 0);\n}\n\nmodule.exports = keyCommandUndo;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/keyCommandUndo.js\n// module id = 492\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnPaste\n * @format\n * \n */\n\n'use strict';\n\nvar BlockMapBuilder = require('./BlockMapBuilder');\nvar CharacterMetadata = require('./CharacterMetadata');\nvar DataTransfer = require('fbjs/lib/DataTransfer');\nvar DraftModifier = require('./DraftModifier');\nvar DraftPasteProcessor = require('./DraftPasteProcessor');\nvar EditorState = require('./EditorState');\nvar RichTextEditorUtil = require('./RichTextEditorUtil');\n\nvar getEntityKeyForSelection = require('./getEntityKeyForSelection');\nvar getTextContentFromFiles = require('./getTextContentFromFiles');\nvar isEventHandled = require('./isEventHandled');\nvar splitTextIntoTextBlocks = require('./splitTextIntoTextBlocks');\n\n/**\n * Paste content.\n */\nfunction editOnPaste(editor, e) {\n  e.preventDefault();\n  var data = new DataTransfer(e.clipboardData);\n\n  // Get files, unless this is likely to be a string the user wants inline.\n  if (!data.isRichText()) {\n    var files = data.getFiles();\n    var defaultFileText = data.getText();\n    if (files.length > 0) {\n      // Allow customized paste handling for images, etc. Otherwise, fall\n      // through to insert text contents into the editor.\n      if (editor.props.handlePastedFiles && isEventHandled(editor.props.handlePastedFiles(files))) {\n        return;\n      }\n\n      getTextContentFromFiles(files, function ( /*string*/fileText) {\n        fileText = fileText || defaultFileText;\n        if (!fileText) {\n          return;\n        }\n\n        var editorState = editor._latestEditorState;\n        var blocks = splitTextIntoTextBlocks(fileText);\n        var character = CharacterMetadata.create({\n          style: editorState.getCurrentInlineStyle(),\n          entity: getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection())\n        });\n        var currentBlockType = RichTextEditorUtil.getCurrentBlockType(editorState);\n\n        var text = DraftPasteProcessor.processText(blocks, character, currentBlockType);\n        var fragment = BlockMapBuilder.createFromArray(text);\n\n        var withInsertedText = DraftModifier.replaceWithFragment(editorState.getCurrentContent(), editorState.getSelection(), fragment);\n\n        editor.update(EditorState.push(editorState, withInsertedText, 'insert-fragment'));\n      });\n\n      return;\n    }\n  }\n\n  var textBlocks = [];\n  var text = data.getText();\n  var html = data.getHTML();\n  var editorState = editor._latestEditorState;\n\n  if (editor.props.handlePastedText && isEventHandled(editor.props.handlePastedText(text, html, editorState))) {\n    return;\n  }\n\n  if (text) {\n    textBlocks = splitTextIntoTextBlocks(text);\n  }\n\n  if (!editor.props.stripPastedStyles) {\n    // If the text from the paste event is rich content that matches what we\n    // already have on the internal clipboard, assume that we should just use\n    // the clipboard fragment for the paste. This will allow us to preserve\n    // styling and entities, if any are present. Note that newlines are\n    // stripped during comparison -- this is because copy/paste within the\n    // editor in Firefox and IE will not include empty lines. The resulting\n    // paste will preserve the newlines correctly.\n    var internalClipboard = editor.getClipboard();\n    if (data.isRichText() && internalClipboard) {\n      if (\n      // If the editorKey is present in the pasted HTML, it should be safe to\n      // assume this is an internal paste.\n      html.indexOf(editor.getEditorKey()) !== -1 ||\n      // The copy may have been made within a single block, in which case the\n      // editor key won't be part of the paste. In this case, just check\n      // whether the pasted text matches the internal clipboard.\n      textBlocks.length === 1 && internalClipboard.size === 1 && internalClipboard.first().getText() === text) {\n        editor.update(insertFragment(editor._latestEditorState, internalClipboard));\n        return;\n      }\n    } else if (internalClipboard && data.types.includes('com.apple.webarchive') && !data.types.includes('text/html') && areTextBlocksAndClipboardEqual(textBlocks, internalClipboard)) {\n      // Safari does not properly store text/html in some cases.\n      // Use the internalClipboard if present and equal to what is on\n      // the clipboard. See https://bugs.webkit.org/show_bug.cgi?id=19893.\n      editor.update(insertFragment(editor._latestEditorState, internalClipboard));\n      return;\n    }\n\n    // If there is html paste data, try to parse that.\n    if (html) {\n      var htmlFragment = DraftPasteProcessor.processHTML(html, editor.props.blockRenderMap);\n      if (htmlFragment) {\n        var contentBlocks = htmlFragment.contentBlocks,\n            entityMap = htmlFragment.entityMap;\n\n        if (contentBlocks) {\n          var htmlMap = BlockMapBuilder.createFromArray(contentBlocks);\n          editor.update(insertFragment(editor._latestEditorState, htmlMap, entityMap));\n          return;\n        }\n      }\n    }\n\n    // Otherwise, create a new fragment from our pasted text. Also\n    // empty the internal clipboard, since it's no longer valid.\n    editor.setClipboard(null);\n  }\n\n  if (textBlocks.length) {\n    var character = CharacterMetadata.create({\n      style: editorState.getCurrentInlineStyle(),\n      entity: getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection())\n    });\n\n    var currentBlockType = RichTextEditorUtil.getCurrentBlockType(editorState);\n\n    var textFragment = DraftPasteProcessor.processText(textBlocks, character, currentBlockType);\n\n    var textMap = BlockMapBuilder.createFromArray(textFragment);\n    editor.update(insertFragment(editor._latestEditorState, textMap));\n  }\n}\n\nfunction insertFragment(editorState, fragment, entityMap) {\n  var newContent = DraftModifier.replaceWithFragment(editorState.getCurrentContent(), editorState.getSelection(), fragment);\n  // TODO: merge the entity map once we stop using DraftEntity\n  // like this:\n  // const mergedEntityMap = newContent.getEntityMap().merge(entityMap);\n\n  return EditorState.push(editorState, newContent.set('entityMap', entityMap), 'insert-fragment');\n}\n\nfunction areTextBlocksAndClipboardEqual(textBlocks, blockMap) {\n  return textBlocks.length === blockMap.size && blockMap.valueSeq().every(function (block, ii) {\n    return block.getText() === textBlocks[ii];\n  });\n}\n\nmodule.exports = editOnPaste;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/editOnPaste.js\n// module id = 493\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftPasteProcessor\n * @format\n * \n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar CharacterMetadata = require('./CharacterMetadata');\nvar ContentBlock = require('./ContentBlock');\nvar ContentBlockNode = require('./ContentBlockNode');\nvar DraftFeatureFlags = require('./DraftFeatureFlags');\nvar Immutable = require('immutable');\n\nvar convertFromHTMLtoContentBlocks = require('./convertFromHTMLToContentBlocks');\nvar generateRandomKey = require('./generateRandomKey');\nvar getSafeBodyFromHTML = require('./getSafeBodyFromHTML');\nvar sanitizeDraftText = require('./sanitizeDraftText');\n\nvar List = Immutable.List,\n    Repeat = Immutable.Repeat;\n\n\nvar experimentalTreeDataSupport = DraftFeatureFlags.draft_tree_data_support;\nvar ContentBlockRecord = experimentalTreeDataSupport ? ContentBlockNode : ContentBlock;\n\nvar DraftPasteProcessor = {\n  processHTML: function processHTML(html, blockRenderMap) {\n    return convertFromHTMLtoContentBlocks(html, getSafeBodyFromHTML, blockRenderMap);\n  },\n  processText: function processText(textBlocks, character, type) {\n    return textBlocks.reduce(function (acc, textLine, index) {\n      textLine = sanitizeDraftText(textLine);\n      var key = generateRandomKey();\n\n      var blockNodeConfig = {\n        key: key,\n        type: type,\n        text: textLine,\n        characterList: List(Repeat(character, textLine.length))\n      };\n\n      // next block updates previous block\n      if (experimentalTreeDataSupport && index !== 0) {\n        var prevSiblingIndex = index - 1;\n        // update previous block\n        var previousBlock = acc[prevSiblingIndex] = acc[prevSiblingIndex].merge({\n          nextSibling: key\n        });\n        blockNodeConfig = _extends({}, blockNodeConfig, {\n          prevSibling: previousBlock.getKey()\n        });\n      }\n\n      acc.push(new ContentBlockRecord(blockNodeConfig));\n\n      return acc;\n    }, []);\n  }\n};\n\nmodule.exports = DraftPasteProcessor;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftPasteProcessor.js\n// module id = 494\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar URI = function () {\n  function URI(uri) {\n    _classCallCheck(this, URI);\n\n    this._uri = uri;\n  }\n\n  URI.prototype.toString = function toString() {\n    return this._uri;\n  };\n\n  return URI;\n}();\n\nmodule.exports = URI;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fbjs/lib/URI.js\n// module id = 495\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule adjustBlockDepthForContentState\n * @format\n * \n */\n\n'use strict';\n\nfunction adjustBlockDepthForContentState(contentState, selectionState, adjustment, maxDepth) {\n  var startKey = selectionState.getStartKey();\n  var endKey = selectionState.getEndKey();\n  var blockMap = contentState.getBlockMap();\n  var blocks = blockMap.toSeq().skipUntil(function (_, k) {\n    return k === startKey;\n  }).takeUntil(function (_, k) {\n    return k === endKey;\n  }).concat([[endKey, blockMap.get(endKey)]]).map(function (block) {\n    var depth = block.getDepth() + adjustment;\n    depth = Math.max(0, Math.min(depth, maxDepth));\n    return block.set('depth', depth);\n  });\n\n  blockMap = blockMap.merge(blocks);\n\n  return contentState.merge({\n    blockMap: blockMap,\n    selectionBefore: selectionState,\n    selectionAfter: selectionState\n  });\n}\n\nmodule.exports = adjustBlockDepthForContentState;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/adjustBlockDepthForContentState.js\n// module id = 496\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule splitTextIntoTextBlocks\n * @format\n * \n */\n\n'use strict';\n\nvar NEWLINE_REGEX = /\\r\\n?|\\n/g;\n\nfunction splitTextIntoTextBlocks(text) {\n  return text.split(NEWLINE_REGEX);\n}\n\nmodule.exports = splitTextIntoTextBlocks;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/splitTextIntoTextBlocks.js\n// module id = 497\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule editOnSelect\n * @format\n * \n */\n\n'use strict';\n\nvar EditorState = require('./EditorState');\nvar ReactDOM = require('react-dom');\n\nvar getDraftEditorSelection = require('./getDraftEditorSelection');\nvar invariant = require('fbjs/lib/invariant');\n\nfunction editOnSelect(editor) {\n  if (editor._blockSelectEvents || editor._latestEditorState !== editor.props.editorState) {\n    return;\n  }\n\n  var editorState = editor.props.editorState;\n  var editorNode = ReactDOM.findDOMNode(editor.editorContainer);\n  !editorNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Missing editorNode') : invariant(false) : void 0;\n  !(editorNode.firstChild instanceof HTMLElement) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'editorNode.firstChild is not an HTMLElement') : invariant(false) : void 0;\n  var documentSelection = getDraftEditorSelection(editorState, editorNode.firstChild);\n  var updatedSelectionState = documentSelection.selectionState;\n\n  if (updatedSelectionState !== editorState.getSelection()) {\n    if (documentSelection.needsRecovery) {\n      editorState = EditorState.forceSelection(editorState, updatedSelectionState);\n    } else {\n      editorState = EditorState.acceptSelection(editorState, updatedSelectionState);\n    }\n    editor.update(editorState);\n  }\n}\n\nmodule.exports = editOnSelect;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/editOnSelect.js\n// module id = 498\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getDraftEditorSelection\n * @format\n * \n */\n\n'use strict';\n\nvar getDraftEditorSelectionWithNodes = require('./getDraftEditorSelectionWithNodes');\n\n/**\n * Convert the current selection range to an anchor/focus pair of offset keys\n * and values that can be interpreted by components.\n */\nfunction getDraftEditorSelection(editorState, root) {\n  var selection = global.getSelection();\n\n  // No active selection.\n  if (selection.rangeCount === 0) {\n    return {\n      selectionState: editorState.getSelection().set('hasFocus', false),\n      needsRecovery: false\n    };\n  }\n\n  return getDraftEditorSelectionWithNodes(editorState, root, selection.anchorNode, selection.anchorOffset, selection.focusNode, selection.focusOffset);\n}\n\nmodule.exports = getDraftEditorSelection;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getDraftEditorSelection.js\n// module id = 499\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftEditorPlaceholder.react\n * @format\n * \n */\n\n'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar React = require('react');\n\nvar cx = require('fbjs/lib/cx');\n\n/**\n * This component is responsible for rendering placeholder text for the\n * `DraftEditor` component.\n *\n * Override placeholder style via CSS.\n */\nvar DraftEditorPlaceholder = function (_React$Component) {\n  _inherits(DraftEditorPlaceholder, _React$Component);\n\n  function DraftEditorPlaceholder() {\n    _classCallCheck(this, DraftEditorPlaceholder);\n\n    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));\n  }\n\n  DraftEditorPlaceholder.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {\n    return this.props.text !== nextProps.text || this.props.editorState.getSelection().getHasFocus() !== nextProps.editorState.getSelection().getHasFocus();\n  };\n\n  DraftEditorPlaceholder.prototype.render = function render() {\n    var hasFocus = this.props.editorState.getSelection().getHasFocus();\n\n    var className = cx({\n      'public/DraftEditorPlaceholder/root': true,\n      'public/DraftEditorPlaceholder/hasFocus': hasFocus\n    });\n\n    var contentStyle = {\n      whiteSpace: 'pre-wrap'\n    };\n\n    return React.createElement(\n      'div',\n      { className: className },\n      React.createElement(\n        'div',\n        {\n          className: cx('public/DraftEditorPlaceholder/inner'),\n          id: this.props.accessibilityID,\n          style: contentStyle },\n        this.props.text\n      )\n    );\n  };\n\n  return DraftEditorPlaceholder;\n}(React.Component);\n\nmodule.exports = DraftEditorPlaceholder;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftEditorPlaceholder.react.js\n// module id = 500\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule convertFromDraftStateToRaw\n * @format\n * \n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar ContentBlock = require('./ContentBlock');\nvar ContentBlockNode = require('./ContentBlockNode');\nvar DraftStringKey = require('./DraftStringKey');\n\nvar encodeEntityRanges = require('./encodeEntityRanges');\nvar encodeInlineStyleRanges = require('./encodeInlineStyleRanges');\nvar invariant = require('fbjs/lib/invariant');\n\nvar createRawBlock = function createRawBlock(block, entityStorageMap) {\n  return {\n    key: block.getKey(),\n    text: block.getText(),\n    type: block.getType(),\n    depth: block.getDepth(),\n    inlineStyleRanges: encodeInlineStyleRanges(block),\n    entityRanges: encodeEntityRanges(block, entityStorageMap),\n    data: block.getData().toObject()\n  };\n};\n\nvar insertRawBlock = function insertRawBlock(block, entityMap, rawBlocks, blockCacheRef) {\n  if (block instanceof ContentBlock) {\n    rawBlocks.push(createRawBlock(block, entityMap));\n    return;\n  }\n\n  !(block instanceof ContentBlockNode) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'block is not a BlockNode') : invariant(false) : void 0;\n\n  var parentKey = block.getParentKey();\n  var rawBlock = blockCacheRef[block.getKey()] = _extends({}, createRawBlock(block, entityMap), {\n    children: []\n  });\n\n  if (parentKey) {\n    blockCacheRef[parentKey].children.push(rawBlock);\n    return;\n  }\n\n  rawBlocks.push(rawBlock);\n};\n\nvar encodeRawBlocks = function encodeRawBlocks(contentState, rawState) {\n  var entityMap = rawState.entityMap;\n\n\n  var rawBlocks = [];\n\n  var blockCacheRef = {};\n  var entityCacheRef = {};\n  var entityStorageKey = 0;\n\n  contentState.getBlockMap().forEach(function (block) {\n    block.findEntityRanges(function (character) {\n      return character.getEntity() !== null;\n    }, function (start) {\n      var entityKey = block.getEntityAt(start);\n      // Stringify to maintain order of otherwise numeric keys.\n      var stringifiedEntityKey = DraftStringKey.stringify(entityKey);\n      // This makes this function resilient to two entities\n      // erroneously having the same key\n      if (entityCacheRef[stringifiedEntityKey]) {\n        return;\n      }\n      entityCacheRef[stringifiedEntityKey] = entityKey;\n      // we need the `any` casting here since this is a temporary state\n      // where we will later on flip the entity map and populate it with\n      // real entity, at this stage we just need to map back the entity\n      // key used by the BlockNode\n      entityMap[stringifiedEntityKey] = '' + entityStorageKey;\n      entityStorageKey++;\n    });\n\n    insertRawBlock(block, entityMap, rawBlocks, blockCacheRef);\n  });\n\n  return {\n    blocks: rawBlocks,\n    entityMap: entityMap\n  };\n};\n\n// Flip storage map so that our storage keys map to global\n// DraftEntity keys.\nvar encodeRawEntityMap = function encodeRawEntityMap(contentState, rawState) {\n  var blocks = rawState.blocks,\n      entityMap = rawState.entityMap;\n\n\n  var rawEntityMap = {};\n\n  Object.keys(entityMap).forEach(function (key, index) {\n    var entity = contentState.getEntity(DraftStringKey.unstringify(key));\n    rawEntityMap[index] = {\n      type: entity.getType(),\n      mutability: entity.getMutability(),\n      data: entity.getData()\n    };\n  });\n\n  return {\n    blocks: blocks,\n    entityMap: rawEntityMap\n  };\n};\n\nvar convertFromDraftStateToRaw = function convertFromDraftStateToRaw(contentState) {\n  var rawDraftContentState = {\n    entityMap: {},\n    blocks: []\n  };\n\n  // add blocks\n  rawDraftContentState = encodeRawBlocks(contentState, rawDraftContentState);\n\n  // add entities\n  rawDraftContentState = encodeRawEntityMap(contentState, rawDraftContentState);\n\n  return rawDraftContentState;\n};\n\nmodule.exports = convertFromDraftStateToRaw;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/convertFromDraftStateToRaw.js\n// module id = 501\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule encodeEntityRanges\n * @format\n * \n */\n\n'use strict';\n\nvar DraftStringKey = require('./DraftStringKey');\nvar UnicodeUtils = require('fbjs/lib/UnicodeUtils');\n\nvar strlen = UnicodeUtils.strlen;\n\n/**\n * Convert to UTF-8 character counts for storage.\n */\n\nfunction encodeEntityRanges(block, storageMap) {\n  var encoded = [];\n  block.findEntityRanges(function (character) {\n    return !!character.getEntity();\n  }, function ( /*number*/start, /*number*/end) {\n    var text = block.getText();\n    var key = block.getEntityAt(start);\n    encoded.push({\n      offset: strlen(text.slice(0, start)),\n      length: strlen(text.slice(start, end)),\n      // Encode the key as a number for range storage.\n      key: Number(storageMap[DraftStringKey.stringify(key)])\n    });\n  });\n  return encoded;\n}\n\nmodule.exports = encodeEntityRanges;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/encodeEntityRanges.js\n// module id = 502\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule encodeInlineStyleRanges\n * @format\n * \n */\n\n'use strict';\n\nvar UnicodeUtils = require('fbjs/lib/UnicodeUtils');\n\nvar findRangesImmutable = require('./findRangesImmutable');\n\nvar areEqual = function areEqual(a, b) {\n  return a === b;\n};\nvar isTruthy = function isTruthy(a) {\n  return !!a;\n};\nvar EMPTY_ARRAY = [];\n\n/**\n * Helper function for getting encoded styles for each inline style. Convert\n * to UTF-8 character counts for storage.\n */\nfunction getEncodedInlinesForType(block, styleList, styleToEncode) {\n  var ranges = [];\n\n  // Obtain an array with ranges for only the specified style.\n  var filteredInlines = styleList.map(function (style) {\n    return style.has(styleToEncode);\n  }).toList();\n\n  findRangesImmutable(filteredInlines, areEqual,\n  // We only want to keep ranges with nonzero style values.\n  isTruthy, function (start, end) {\n    var text = block.getText();\n    ranges.push({\n      offset: UnicodeUtils.strlen(text.slice(0, start)),\n      length: UnicodeUtils.strlen(text.slice(start, end)),\n      style: styleToEncode\n    });\n  });\n\n  return ranges;\n}\n\n/*\n * Retrieve the encoded arrays of inline styles, with each individual style\n * treated separately.\n */\nfunction encodeInlineStyleRanges(block) {\n  var styleList = block.getCharacterList().map(function (c) {\n    return c.getStyle();\n  }).toList();\n  var ranges = styleList.flatten().toSet().map(function (style) {\n    return getEncodedInlinesForType(block, styleList, style);\n  });\n\n  return Array.prototype.concat.apply(EMPTY_ARRAY, ranges.toJS());\n}\n\nmodule.exports = encodeInlineStyleRanges;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/encodeInlineStyleRanges.js\n// module id = 503\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule convertFromRawToDraftState\n * @format\n * \n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar ContentBlock = require('./ContentBlock');\nvar ContentBlockNode = require('./ContentBlockNode');\nvar ContentState = require('./ContentState');\nvar DraftEntity = require('./DraftEntity');\nvar DraftFeatureFlags = require('./DraftFeatureFlags');\nvar DraftTreeAdapter = require('./DraftTreeAdapter');\nvar Immutable = require('immutable');\nvar SelectionState = require('./SelectionState');\n\nvar createCharacterList = require('./createCharacterList');\nvar decodeEntityRanges = require('./decodeEntityRanges');\nvar decodeInlineStyleRanges = require('./decodeInlineStyleRanges');\nvar generateRandomKey = require('./generateRandomKey');\nvar invariant = require('fbjs/lib/invariant');\n\nvar experimentalTreeDataSupport = DraftFeatureFlags.draft_tree_data_support;\n\nvar List = Immutable.List,\n    Map = Immutable.Map,\n    OrderedMap = Immutable.OrderedMap;\n\n\nvar decodeBlockNodeConfig = function decodeBlockNodeConfig(block, entityMap) {\n  var key = block.key,\n      type = block.type,\n      data = block.data,\n      text = block.text,\n      depth = block.depth;\n\n\n  var blockNodeConfig = {\n    text: text,\n    depth: depth || 0,\n    type: type || 'unstyled',\n    key: key || generateRandomKey(),\n    data: Map(data),\n    characterList: decodeCharacterList(block, entityMap)\n  };\n\n  return blockNodeConfig;\n};\n\nvar decodeCharacterList = function decodeCharacterList(block, entityMap) {\n  var text = block.text,\n      rawEntityRanges = block.entityRanges,\n      rawInlineStyleRanges = block.inlineStyleRanges;\n\n\n  var entityRanges = rawEntityRanges || [];\n  var inlineStyleRanges = rawInlineStyleRanges || [];\n\n  // Translate entity range keys to the DraftEntity map.\n  return createCharacterList(decodeInlineStyleRanges(text, inlineStyleRanges), decodeEntityRanges(text, entityRanges.filter(function (range) {\n    return entityMap.hasOwnProperty(range.key);\n  }).map(function (range) {\n    return _extends({}, range, { key: entityMap[range.key] });\n  })));\n};\n\nvar addKeyIfMissing = function addKeyIfMissing(block) {\n  return _extends({}, block, {\n    key: block.key || generateRandomKey()\n  });\n};\n\n/**\n * Node stack is responsible to ensure we traverse the tree only once\n * in depth order, while also providing parent refs to inner nodes to\n * construct their links.\n */\nvar updateNodeStack = function updateNodeStack(stack, nodes, parentRef) {\n  var nodesWithParentRef = nodes.map(function (block) {\n    return _extends({}, block, {\n      parentRef: parentRef\n    });\n  });\n\n  // since we pop nodes from the stack we need to insert them in reverse\n  return stack.concat(nodesWithParentRef.reverse());\n};\n\n/**\n * This will build a tree draft content state by creating the node\n * reference links into a single tree walk. Each node has a link\n * reference to \"parent\", \"children\", \"nextSibling\" and \"prevSibling\"\n * blockMap will be created using depth ordering.\n */\nvar decodeContentBlockNodes = function decodeContentBlockNodes(blocks, entityMap) {\n  return blocks\n  // ensure children have valid keys to enable sibling links\n  .map(addKeyIfMissing).reduce(function (blockMap, block, index) {\n    !Array.isArray(block.children) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'invalid RawDraftContentBlock can not be converted to ContentBlockNode') : invariant(false) : void 0;\n\n    // ensure children have valid keys to enable sibling links\n    var children = block.children.map(addKeyIfMissing);\n\n    // root level nodes\n    var contentBlockNode = new ContentBlockNode(_extends({}, decodeBlockNodeConfig(block, entityMap), {\n      prevSibling: index === 0 ? null : blocks[index - 1].key,\n      nextSibling: index === blocks.length - 1 ? null : blocks[index + 1].key,\n      children: List(children.map(function (child) {\n        return child.key;\n      }))\n    }));\n\n    // push root node to blockMap\n    blockMap = blockMap.set(contentBlockNode.getKey(), contentBlockNode);\n\n    // this stack is used to ensure we visit all nodes respecting depth ordering\n    var stack = updateNodeStack([], children, contentBlockNode);\n\n    // start computing children nodes\n    while (stack.length > 0) {\n      // we pop from the stack and start processing this node\n      var node = stack.pop();\n\n      // parentRef already points to a converted ContentBlockNode\n      var parentRef = node.parentRef;\n      var siblings = parentRef.getChildKeys();\n      var _index = siblings.indexOf(node.key);\n      var isValidBlock = Array.isArray(node.children);\n\n      if (!isValidBlock) {\n        !isValidBlock ? process.env.NODE_ENV !== 'production' ? invariant(false, 'invalid RawDraftContentBlock can not be converted to ContentBlockNode') : invariant(false) : void 0;\n        break;\n      }\n\n      // ensure children have valid keys to enable sibling links\n      var _children = node.children.map(addKeyIfMissing);\n\n      var _contentBlockNode = new ContentBlockNode(_extends({}, decodeBlockNodeConfig(node, entityMap), {\n        parent: parentRef.getKey(),\n        children: List(_children.map(function (child) {\n          return child.key;\n        })),\n        prevSibling: _index === 0 ? null : siblings.get(_index - 1),\n        nextSibling: _index === siblings.size - 1 ? null : siblings.get(_index + 1)\n      }));\n\n      // push node to blockMap\n      blockMap = blockMap.set(_contentBlockNode.getKey(), _contentBlockNode);\n\n      // this stack is used to ensure we visit all nodes respecting depth ordering\n      stack = updateNodeStack(stack, _children, _contentBlockNode);\n    }\n\n    return blockMap;\n  }, OrderedMap());\n};\n\nvar decodeContentBlocks = function decodeContentBlocks(blocks, entityMap) {\n  return OrderedMap(blocks.map(function (block) {\n    var contentBlock = new ContentBlock(decodeBlockNodeConfig(block, entityMap));\n    return [contentBlock.getKey(), contentBlock];\n  }));\n};\n\nvar decodeRawBlocks = function decodeRawBlocks(rawState, entityMap) {\n  var isTreeRawBlock = Array.isArray(rawState.blocks[0].children);\n  var rawBlocks = experimentalTreeDataSupport && !isTreeRawBlock ? DraftTreeAdapter.fromRawStateToRawTreeState(rawState).blocks : rawState.blocks;\n\n  if (!experimentalTreeDataSupport) {\n    return decodeContentBlocks(isTreeRawBlock ? DraftTreeAdapter.fromRawTreeStateToRawState(rawState).blocks : rawBlocks, entityMap);\n  }\n\n  return decodeContentBlockNodes(rawBlocks, entityMap);\n};\n\nvar decodeRawEntityMap = function decodeRawEntityMap(rawState) {\n  var rawEntityMap = rawState.entityMap;\n\n  var entityMap = {};\n\n  // TODO: Update this once we completely remove DraftEntity\n  Object.keys(rawEntityMap).forEach(function (rawEntityKey) {\n    var _rawEntityMap$rawEnti = rawEntityMap[rawEntityKey],\n        type = _rawEntityMap$rawEnti.type,\n        mutability = _rawEntityMap$rawEnti.mutability,\n        data = _rawEntityMap$rawEnti.data;\n\n    // get the key reference to created entity\n\n    entityMap[rawEntityKey] = DraftEntity.__create(type, mutability, data || {});\n  });\n\n  return entityMap;\n};\n\nvar convertFromRawToDraftState = function convertFromRawToDraftState(rawState) {\n  !Array.isArray(rawState.blocks) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'invalid RawDraftContentState') : invariant(false) : void 0;\n\n  // decode entities\n  var entityMap = decodeRawEntityMap(rawState);\n\n  // decode blockMap\n  var blockMap = decodeRawBlocks(rawState, entityMap);\n\n  // create initial selection\n  var selectionState = blockMap.isEmpty() ? new SelectionState() : SelectionState.createEmpty(blockMap.first().getKey());\n\n  return new ContentState({\n    blockMap: blockMap,\n    entityMap: entityMap,\n    selectionBefore: selectionState,\n    selectionAfter: selectionState\n  });\n};\n\nmodule.exports = convertFromRawToDraftState;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/convertFromRawToDraftState.js\n// module id = 504\n// module chunks = 2","'use strict';\n\nvar _assign = require('object-assign');\n\nvar _extends = _assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DraftTreeAdapter\n * @format\n * \n *\n * This is unstable and not part of the public API and should not be used by\n * production systems. This file may be update/removed without notice.\n */\n\nvar invariant = require('fbjs/lib/invariant');\n\nvar traverseInDepthOrder = function traverseInDepthOrder(blocks, fn) {\n  var stack = [].concat(blocks).reverse();\n  while (stack.length) {\n    var _block = stack.pop();\n\n    fn(_block);\n\n    var children = _block.children;\n\n    !Array.isArray(children) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Invalid tree raw block') : invariant(false) : void 0;\n\n    stack = stack.concat([].concat(children.reverse()));\n  }\n};\n\nvar isListBlock = function isListBlock(block) {\n  if (!(block && block.type)) {\n    return false;\n  }\n  var type = block.type;\n\n  return type === 'unordered-list-item' || type === 'ordered-list-item';\n};\n\nvar addDepthToChildren = function addDepthToChildren(block) {\n  if (Array.isArray(block.children)) {\n    block.children = block.children.map(function (child) {\n      return child.type === block.type ? _extends({}, child, { depth: (block.depth || 0) + 1 }) : child;\n    });\n  }\n};\n\n/**\n * This adapter is intended to be be used as an adapter to draft tree data\n *\n * draft state <=====> draft tree state\n */\nvar DraftTreeAdapter = {\n  /**\n   * Converts from a tree raw state back to  draft raw state\n   */\n  fromRawTreeStateToRawState: function fromRawTreeStateToRawState(draftTreeState) {\n    var blocks = draftTreeState.blocks;\n\n    var transformedBlocks = [];\n\n    !Array.isArray(blocks) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Invalid raw state') : invariant(false) : void 0;\n\n    if (!Array.isArray(blocks) || !blocks.length) {\n      return draftTreeState;\n    }\n\n    traverseInDepthOrder(blocks, function (block) {\n      var newBlock = _extends({}, block);\n\n      if (isListBlock(block)) {\n        newBlock.depth = newBlock.depth || 0;\n        addDepthToChildren(block);\n      }\n\n      delete newBlock.children;\n\n      transformedBlocks.push(newBlock);\n    });\n\n    draftTreeState.blocks = transformedBlocks;\n\n    return _extends({}, draftTreeState, {\n      blocks: transformedBlocks\n    });\n  },\n\n\n  /**\n   * Converts from draft raw state to tree draft state\n   */\n  fromRawStateToRawTreeState: function fromRawStateToRawTreeState(draftState) {\n    var lastListDepthCacheRef = {};\n    var transformedBlocks = [];\n\n    draftState.blocks.forEach(function (block) {\n      var isList = isListBlock(block);\n      var depth = block.depth || 0;\n      var treeBlock = _extends({}, block, {\n        children: []\n      });\n\n      if (!isList) {\n        // reset the cache path\n        lastListDepthCacheRef = {};\n        transformedBlocks.push(treeBlock);\n        return;\n      }\n\n      // update our depth cache reference path\n      lastListDepthCacheRef[depth] = treeBlock;\n\n      // if we are greater than zero we must have seen a parent already\n      if (depth > 0) {\n        var parent = lastListDepthCacheRef[depth - 1];\n\n        !parent ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Invalid depth for RawDraftContentBlock') : invariant(false) : void 0;\n\n        // push nested list blocks\n        parent.children.push(treeBlock);\n        return;\n      }\n\n      // push root list blocks\n      transformedBlocks.push(treeBlock);\n    });\n\n    return _extends({}, draftState, {\n      blocks: transformedBlocks\n    });\n  }\n};\n\nmodule.exports = DraftTreeAdapter;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/DraftTreeAdapter.js\n// module id = 505\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule createCharacterList\n * @format\n * \n */\n\n'use strict';\n\nvar CharacterMetadata = require('./CharacterMetadata');\nvar Immutable = require('immutable');\n\nvar List = Immutable.List;\n\n\nfunction createCharacterList(inlineStyles, entities) {\n  var characterArray = inlineStyles.map(function (style, ii) {\n    var entity = entities[ii];\n    return CharacterMetadata.create({ style: style, entity: entity });\n  });\n  return List(characterArray);\n}\n\nmodule.exports = createCharacterList;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/createCharacterList.js\n// module id = 506\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule decodeEntityRanges\n * @format\n * \n */\n\n'use strict';\n\nvar UnicodeUtils = require('fbjs/lib/UnicodeUtils');\n\nvar substr = UnicodeUtils.substr;\n\n/**\n * Convert to native JavaScript string lengths to determine ranges.\n */\n\nfunction decodeEntityRanges(text, ranges) {\n  var entities = Array(text.length).fill(null);\n  if (ranges) {\n    ranges.forEach(function (range) {\n      // Using Unicode-enabled substrings converted to JavaScript lengths,\n      // fill the output array with entity keys.\n      var start = substr(text, 0, range.offset).length;\n      var end = start + substr(text, range.offset, range.length).length;\n      for (var ii = start; ii < end; ii++) {\n        entities[ii] = range.key;\n      }\n    });\n  }\n  return entities;\n}\n\nmodule.exports = decodeEntityRanges;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/decodeEntityRanges.js\n// module id = 507\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule decodeInlineStyleRanges\n * @format\n * \n */\n\n'use strict';\n\nvar _require = require('immutable'),\n    OrderedSet = _require.OrderedSet;\n\nvar UnicodeUtils = require('fbjs/lib/UnicodeUtils');\n\nvar substr = UnicodeUtils.substr;\n\n\nvar EMPTY_SET = OrderedSet();\n\n/**\n * Convert to native JavaScript string lengths to determine ranges.\n */\nfunction decodeInlineStyleRanges(text, ranges) {\n  var styles = Array(text.length).fill(EMPTY_SET);\n  if (ranges) {\n    ranges.forEach(function ( /*object*/range) {\n      var cursor = substr(text, 0, range.offset).length;\n      var end = cursor + substr(text, range.offset, range.length).length;\n      while (cursor < end) {\n        styles[cursor] = styles[cursor].add(range.style);\n        cursor++;\n      }\n    });\n  }\n  return styles;\n}\n\nmodule.exports = decodeInlineStyleRanges;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/decodeInlineStyleRanges.js\n// module id = 508\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getVisibleSelectionRect\n * @format\n * \n */\n\n'use strict';\n\nvar getRangeBoundingClientRect = require('./getRangeBoundingClientRect');\n\n/**\n * Return the bounding ClientRect for the visible DOM selection, if any.\n * In cases where there are no selected ranges or the bounding rect is\n * temporarily invalid, return null.\n */\nfunction getVisibleSelectionRect(global) {\n  var selection = global.getSelection();\n  if (!selection.rangeCount) {\n    return null;\n  }\n\n  var range = selection.getRangeAt(0);\n  var boundingRect = getRangeBoundingClientRect(range);\n  var top = boundingRect.top,\n      right = boundingRect.right,\n      bottom = boundingRect.bottom,\n      left = boundingRect.left;\n\n  // When a re-render leads to a node being removed, the DOM selection will\n  // temporarily be placed on an ancestor node, which leads to an invalid\n  // bounding rect. Discard this state.\n\n  if (top === 0 && right === 0 && bottom === 0 && left === 0) {\n    return null;\n  }\n\n  return boundingRect;\n}\n\nmodule.exports = getVisibleSelectionRect;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getVisibleSelectionRect.js\n// module id = 509\n// module chunks = 2","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getRangeBoundingClientRect\n * @format\n * \n */\n\n'use strict';\n\nvar getRangeClientRects = require('./getRangeClientRects');\n\n/**\n * Like range.getBoundingClientRect() but normalizes for browser bugs.\n */\nfunction getRangeBoundingClientRect(range) {\n  // \"Return a DOMRect object describing the smallest rectangle that includes\n  // the first rectangle in list and all of the remaining rectangles of which\n  // the height or width is not zero.\"\n  // http://www.w3.org/TR/cssom-view/#dom-range-getboundingclientrect\n  var rects = getRangeClientRects(range);\n  var top = 0;\n  var right = 0;\n  var bottom = 0;\n  var left = 0;\n\n  if (rects.length) {\n    // If the first rectangle has 0 width, we use the second, this is needed\n    // because Chrome renders a 0 width rectangle when the selection contains\n    // a line break.\n    if (rects.length > 1 && rects[0].width === 0) {\n      var _rects$ = rects[1];\n      top = _rects$.top;\n      right = _rects$.right;\n      bottom = _rects$.bottom;\n      left = _rects$.left;\n    } else {\n      var _rects$2 = rects[0];\n      top = _rects$2.top;\n      right = _rects$2.right;\n      bottom = _rects$2.bottom;\n      left = _rects$2.left;\n    }\n\n    for (var ii = 1; ii < rects.length; ii++) {\n      var rect = rects[ii];\n      if (rect.height !== 0 && rect.width !== 0) {\n        top = Math.min(top, rect.top);\n        right = Math.max(right, rect.right);\n        bottom = Math.max(bottom, rect.bottom);\n        left = Math.min(left, rect.left);\n      }\n    }\n  }\n\n  return {\n    top: top,\n    right: right,\n    bottom: bottom,\n    left: left,\n    width: right - left,\n    height: bottom - top\n  };\n}\n\nmodule.exports = getRangeBoundingClientRect;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/draft-js/lib/getRangeBoundingClientRect.js\n// module id = 510\n// module chunks = 2","/* eslint-disable react/no-did-mount-set-state */\nimport React, { Component } from 'react'\nimport PropTypes from 'prop-types' // eslint-disable-line no-unused-vars\nimport { Map } from 'immutable'\nimport format from 'format-number'\nimport cx from 'classnames'\nimport { EditorState, Editor } from 'draft-js'\nimport Spinner from 'components/Spinner'\nimport styles from './myEditor-style.css'\nimport errorStyles from '../../modules/ProposalEditor/proposalEditor-style.css'\n\nclass MyEditor extends Component {\n  static displayName = 'MyEditor'\n  static propTypes = {\n    maxLength: PropTypes.number,\n    editorState: PropTypes.instanceOf(EditorState),\n    handleChange: PropTypes.func,\n    title: PropTypes.string,\n    description: PropTypes.string,\n    minHeight: PropTypes.number,\n    id: PropTypes.string.isRequired,\n    readOnly: PropTypes.bool,\n    blockRenderStyle: PropTypes.func,\n    blockRenderMap: PropTypes.instanceOf(Map),\n    checkingValue: PropTypes.bool,\n    errors: PropTypes.object,\n  }\n\n  static defaultProps = {\n    maxLength: 4000,\n    editorState: EditorState.createEmpty(),\n  }\n\n  state = {\n    editorState: this.props.editorState,\n    readOnly: this.props.readOnly,\n    inFocus: false,\n    focus: false,\n    render: false,\n    charsLeft: this.getChars(this.props.editorState).charsLeft,\n    errorMessages: {},\n  }\n\n  componentDidMount() {\n    const { minHeight, readOnly } = this.props\n\n    this.setState({ render: true }) // eslint-disable-line\n\n    if (!process.env.NODE_ENV === 'test' || !process.env.NODE_ENV === 'server')\n      document.addEventListener('click', this.handleClick)\n\n    if (minHeight && !readOnly) {\n      setTimeout(() => {\n        // make sure DraftJS is finished setting up\n        const editorContainer = this.DomEditor.editorContainer\n\n        if (editorContainer) editorContainer.style.minHeight = `${minHeight}px`\n      }, 0)\n    }\n\n    if (!readOnly) {\n      // this.handleChange(this.state.editorState)\n    }\n  }\n\n  componentWillUnmount() {\n    document.removeEventListener('click', this.handleClick)\n  }\n\n  setEditorRef = (node) => (this.DomEditor = node)\n\n  getChars(editorState) {\n    const { maxLength } = this.props\n\n    const blockMap = editorState.getCurrentContent().getBlockMap()\n    const totalChars = blockMap.reduce(\n      (arr, block) => block.getLength() + arr,\n      0,\n    )\n\n    const charsLeft = format({ integerSeparator: '.' })(maxLength - totalChars)\n\n    return {\n      charsLeft,\n      totalChars,\n    }\n  }\n\n  getBlockRenderMap = () =>\n    this.props.blockRenderMap ||\n    Map({\n      unstyled: {\n        element: 'div',\n      },\n    })\n\n  handleClick = (e) => {\n    if (\n      e.target === this.DomEditor.editorContainer ||\n      e.target === this.DomEditor\n    ) {\n      this.DomEditor.focus()\n      this.setState(() => ({ inFocus: true }))\n    }\n  }\n\n  handleChange = (editorState) => {\n    const { maxLength, id } = this.props\n    const { errorMessages } = this.state\n    const totalChars = this.getChars(editorState).totalChars\n    const charsLeft = this.getChars(editorState).charsLeft\n\n    const showError = totalChars > maxLength\n\n    this.setState(() => ({\n      editorState,\n      totalChars,\n      charsLeft,\n      errorMessages: {\n        ...errorMessages,\n        [id]: {\n          ...errorMessages[id],\n          showError,\n        },\n      },\n    }))\n\n    if (this.props.handleChange) {\n      this.props.handleChange(editorState, this.props.id)\n    }\n  }\n\n  handleBlur = () => {\n    const { id } = this.props\n    const value = this.state.editorState.getCurrentContent().getPlainText()\n\n    this.setState(() => ({ inFocus: false }))\n\n    // An option to make a call to the server api for validations\n    if (this.props.onBlur) this.props.onBlur(id, value)\n  }\n\n  handleFocus = () => {\n    const { readOnly } = this.props\n\n    if (!readOnly) {\n      this.DomEditor.focus()\n      this.setState(() => ({ inFocus: true }))\n    }\n  }\n\n  handleMouseEnter = () => this.setState(() => ({ isHovering: true }))\n  handleMouseLeave = () => this.setState(() => ({ isHovering: false }))\n\n  render() {\n    const {\n      editorState,\n      totalChars,\n      charsLeft,\n      inFocus,\n      isHovering,\n      render,\n    } = this.state\n\n    const {\n      id,\n      maxLength,\n      title,\n      description,\n      readOnly,\n      errors,\n      checkingValue,\n    } = this.props\n\n    // make sure DraftJS is finished setting up\n    if (!render) return null\n\n    return (\n      /* eslint-disable jsx-a11y/interactive-supports-focus, jsx-a11y/click-events-have-key-events, jsx-a11y/no-static-element-interactions  */\n      /* Draft.js handles the tab functionality and key events between editors.  */\n      <div\n        className={cx(\n          styles.myEditor,\n          styles[id],\n          inFocus && !readOnly && styles.focus,\n          isHovering && !readOnly && !inFocus && styles.isHovering,\n          readOnly && styles.readOnly,\n        )}\n        ref={(node) => (this.node = node)}\n        onClick={this.handleClick}\n        onMouseEnter={this.handleMouseEnter}\n        onMouseLeave={this.handleMouseLeave}\n      >\n        {title && (\n          <h2\n            className={cx(styles.editorTitle, readOnly && styles.displayTitle)}\n          >\n            {title}\n          </h2>\n        )}\n        {description && !readOnly && (\n          <p className={styles.description}>{description}</p>\n        )}\n        <Editor\n          spellCheck\n          editorKey={id}\n          readOnly={readOnly}\n          ref={this.setEditorRef}\n          onFocus={this.handleFocus}\n          stripPastedStyles\n          blockRenderMap={this.getBlockRenderMap()}\n          editorState={this.props.editorState[id] || editorState}\n          onChange={this.handleChange}\n          blockStyleFn={(block) => {\n            if (block.getType() === 'unstyled') {\n              return !!readOnly ? styles.readOnly : styles.editorBlock\n            }\n          }}\n          onBlur={this.handleBlur}\n        />\n        {checkingValue && (\n          <div style={{ position: 'relative', left: '80%', top: '-60px' }}>\n            <Spinner size=\"small\" />\n          </div>\n        )}{' '}\n        {errors && errors[id] && (\n          <span className={errorStyles.error}>{errors[id]}</span>\n        )}\n        {!readOnly && (\n          <div\n            className={cx(\n              styles.charsLeft,\n              maxLength < totalChars && styles.error,\n            )}\n          >\n            Antal tegn tilbage: {charsLeft}\n          </div>\n        )}\n      </div>\n    )\n  }\n}\n\nexport default MyEditor\n\n\n\n// WEBPACK FOOTER //\n// ./src/components/MyEditor/MyEditor.js","// removed by extract-text-webpack-plugin\nmodule.exports = {\"myEditor\":\"hq8QYy\",\"focus\":\"_1-BR98\",\"isHovering\":\"_3jLTd5\",\"editorTitle\":\"nDpwlZ\",\"charsLeft\":\"qHVecP\",\"error\":\"_7HQkDy\",\"description\":\"_3-Valq\",\"readOnly\":\"rW7MzU\",\"editorBlock\":\"_2ABVhq\",\"proposalContent\":\"F2qutB\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/components/MyEditor/myEditor-style.css\n// module id = 512\n// module chunks = 2","import React from 'react'\nimport PropTypes from 'prop-types' // eslint-disable-line no-unused-vars\nimport styles from './authorInfo-style.css'\nimport Anchor from 'components/Anchor/Anchor'\n\nconst propTypes = {\n  author: PropTypes.shape({\n    email: PropTypes.string,\n    name: PropTypes.string.isRequired,\n    location: PropTypes.string,\n    phoneNumber: PropTypes.string,\n    recieveNotifications: PropTypes.string,\n  }),\n  coAuthors: PropTypes.arrayOf(\n    PropTypes.shape({\n      email: PropTypes.string,\n      name: PropTypes.string.isRequired,\n      phoneNumber: PropTypes.string,\n      recieveNotifications: PropTypes.string,\n      location: PropTypes.string,\n    }),\n  ),\n}\n\n// Add any default values for props\nconst defaultProps = null\n\nfunction AuthorInfo({ author, coAuthors }) {\n  if (!author && !coAuthors) return null\n\n  return (\n    <div className={styles.authorInfo} data-readaloud>\n      {author && (\n        <div>\n          <div className={styles.header}>\n            <div>\n              <strong>Forslag stillet af:</strong>\n            </div>\n            <div>\n              <strong>Kontaktoplysninger:</strong>\n            </div>\n          </div>\n          <div className={styles.entry}>\n            <div>\n              <span>{author.name}</span>\n              <span>{author.location || ''}</span>\n            </div>\n            <div>\n              <span>\n                E-mail:{' '}\n                <Anchor\n                  href={`mailto:${author.email}`}\n                  label={`${author.email}`}\n                />\n              </span>\n              {author.phoneNumber && <span>Tlf.nr.: {author.phoneNumber}</span>}\n            </div>\n          </div>\n        </div>\n      )}\n      {coAuthors && (\n        <div>\n          <div className={styles.header}>\n            <div>\n              <strong>Medstillere:</strong>\n            </div>\n            <div>\n              <strong>Kontaktoplysninger:</strong>\n            </div>\n          </div>\n          {coAuthors.map((sp, index) => (\n            <div key={index} className={styles.entry}>\n              <div>\n                <span>{sp.name}</span>\n                <span>{sp.location || ''}</span>\n              </div>\n              {sp.email && (\n                <div>\n                  <span>\n                    E-mail:{' '}\n                    <Anchor href={`mailto:${sp.email}`} label={`${sp.email}`} />\n                  </span>\n                  <span>{sp.phoneNumber && `Tlf.nr.: ${sp.phoneNumber}`}</span>\n                </div>\n              )}\n            </div>\n          ))}\n        </div>\n      )}\n    </div>\n  )\n}\n\nAuthorInfo.displayName = 'AuthorInfo'\nAuthorInfo.propTypes = propTypes\nAuthorInfo.defaultProps = defaultProps\n\nexport default AuthorInfo\n\n\n\n// WEBPACK FOOTER //\n// ./src/components/AuthorInfo/AuthorInfo.js","// removed by extract-text-webpack-plugin\nmodule.exports = {\"authorInfo\":\"IxfEwW\",\"entry\":\"_3mHEzx\",\"header\":\"N1pAd9\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/components/AuthorInfo/authorInfo-style.css\n// module id = 514\n// module chunks = 2","import React from 'react'\nimport PropTypes from 'prop-types' // eslint-disable-line no-unused-vars\nimport cx from 'classnames'\nimport Motion from 'react-motion/lib/Motion'\nimport spring from 'react-motion/lib/spring'\nimport Button from 'components/BaseButton/BaseButton'\nimport ConditionsLabel from 'components/ConditionsLabel/ConditionsLabel'\nimport styles from './topBar-style.css'\n\nconst propTypes = {\n  title: PropTypes.string.isRequired,\n  onClick: PropTypes.func,\n  show: PropTypes.bool.isRequired,\n  voteButton: PropTypes.shape({\n    href: PropTypes.string,\n    label: PropTypes.string.isRequired,\n  }).isRequired,\n  conditionsHint: PropTypes.shape({\n    label: PropTypes.string.required,\n    scrollTo: PropTypes.string,\n  }),\n}\n\n// Add any default values for props\nconst defaultProps = {\n  show: false,\n  voteButton: {\n    label: 'vote',\n  },\n}\n\nfunction TopBar({ conditionsHint, title, voteButton, show }) {\n  return (\n    <Motion defaultStyle={{ y: 0 }} style={{ y: spring(show ? 1 : 0) }}>\n      {({ y }) => (\n        <div\n          className={cx('no-print', styles.topBar, 'vFact_DoNotReadAloud')}\n          style={{ transform: `translateY(${(y - 1) * 100}%)` }}\n        >\n          <div className={styles.content}>\n            <div className={styles.titleSection}>\n              <span>{title}</span>\n              {conditionsHint && <ConditionsLabel {...conditionsHint} />}\n            </div>\n            <Button\n              expands\n              primary\n              {...voteButton}\n              style={{ minWidth: '180px' }}\n            />\n          </div>\n        </div>\n      )}\n    </Motion>\n  )\n}\n\nTopBar.displayName = 'TopBar'\nTopBar.propTypes = propTypes\nTopBar.defaultProps = defaultProps\n\nexport default TopBar\n\n\n\n// WEBPACK FOOTER //\n// ./src/components/TopBar/TopBar.js","// removed by extract-text-webpack-plugin\nmodule.exports = {\"label\":\"_1LWDQB\",\"container\":\"_2aiKhB\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/components/ConditionsLabel/conditionslabel-style.css\n// module id = 516\n// module chunks = 2","// removed by extract-text-webpack-plugin\nmodule.exports = {\"topBar\":\"_1NXxBn\",\"content\":\"_28H2Ci\",\"titleSection\":\"cc552X\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/components/TopBar/topBar-style.css\n// module id = 517\n// module chunks = 2","import React from 'react'\nimport PropTypes from 'prop-types' // eslint-disable-line no-unused-vars\nimport format from 'format-number'\nimport styles from './proposalStats-style.css'\nimport VotesIndicator from 'components/Preview/VotesIndicator/VotesIndicator'\n\nconst propTypes = {\n  votes: PropTypes.number.isRequired,\n  startDate: PropTypes.string.isRequired,\n  endDate: PropTypes.string.isRequired,\n  votesLimit: PropTypes.number.isRequired,\n}\n\n// Add any default values for props\nconst defaultProps = {\n  votes: 1000,\n  votesLimit: 50000,\n}\n\nfunction ProposalStats({ votes, startDate, votesLimit, endDate }) {\n  // const formattedVotes = new Intl.NumberFormat('da-DK').format(votes)\n  const formattedVotes = format({ integerSeparator: '.' })(votes)\n  return (\n    <div className={styles.proposalStats} data-readaloud>\n      <div>\n        <span className={styles.label}>Startdato</span>\n        <strong>{startDate}</strong>\n      </div>\n      <div>\n        <span className={styles.label}>Slutdato</span>\n        <strong>{endDate}</strong>\n      </div>\n      <div>\n        <span className={styles.label}>Antal støtter</span>\n        <strong>{formattedVotes}</strong>\n        <VotesIndicator votesLimit={votesLimit} votes={votes} />\n      </div>\n    </div>\n  )\n}\n\nProposalStats.displayName = 'ProposalStats'\nProposalStats.propTypes = propTypes\nProposalStats.defaultProps = defaultProps\n\nexport default ProposalStats\n\n\n\n// WEBPACK FOOTER //\n// ./src/components/ProposalStats/ProposalStats.js","// removed by extract-text-webpack-plugin\nmodule.exports = {\"proposalStats\":\"_3l86Vg\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/components/ProposalStats/proposalStats-style.css\n// module id = 519\n// module chunks = 2","import defaultErrors from '../Form/defaultErrors'\n\nconst defaultProps = {\n  defaultErrors,\n  checkTitleApi: '/api/checkTitle',\n  pageStructure: {},\n  proposalCreationViewModel: {\n    proposal: {\n      proposalContent: '',\n      remarks: '',\n      author: {},\n      supporters: [],\n      externalId: 'FT-007',\n    },\n    errors: {},\n  },\n  voteButton: {\n    label: 'Støt forslaget',\n    href: '/',\n  },\n}\n\nexport default defaultProps\n\n\n\n// WEBPACK FOOTER //\n// ./src/modules/ProposalEditor/proposalEditor.defaultProps.js"],"sourceRoot":""}