{"version":3,"sources":["webpack:///./node_modules/react-flip-move/dist/react-flip-move.es.js","webpack:///./node_modules/react-images-upload/UploadIcon.svg","webpack:///./node_modules/@dnd-kit/utilities/dist/utilities.esm.js","webpack:///./node_modules/autolinker/dist/es2015/utils.js","webpack:///./node_modules/autolinker/dist/es2015/html-tag.js","webpack:///./node_modules/autolinker/dist/es2015/anchor-tag-builder.js","webpack:///./node_modules/autolinker/dist/es2015/matcher/url-matcher.js","webpack:///./node_modules/autolinker/dist/es2015/truncate/truncate-smart.js","webpack:///./node_modules/autolinker/dist/es2015/truncate/truncate-middle.js","webpack:///./node_modules/autolinker/dist/es2015/truncate/truncate-end.js","webpack:///./node_modules/autolinker/dist/es2015/match/match.js","webpack:///./node_modules/autolinker/dist/es2015/match/email-match.js","webpack:///./node_modules/autolinker/dist/es2015/match/hashtag-match.js","webpack:///./node_modules/autolinker/dist/es2015/match/mention-match.js","webpack:///./node_modules/autolinker/dist/es2015/match/phone-match.js","webpack:///./node_modules/autolinker/dist/es2015/match/url-match.js","webpack:///./node_modules/autolinker/dist/es2015/matcher/matcher.js","webpack:///./node_modules/autolinker/dist/es2015/regex-lib.js","webpack:///./node_modules/autolinker/dist/es2015/matcher/tld-regex.js","webpack:///./node_modules/autolinker/dist/es2015/matcher/email-matcher.js","webpack:///./node_modules/autolinker/dist/es2015/matcher/url-match-validator.js","webpack:///./node_modules/autolinker/dist/es2015/matcher/hashtag-matcher.js","webpack:///./node_modules/autolinker/dist/es2015/matcher/phone-matcher.js","webpack:///./node_modules/autolinker/dist/es2015/matcher/mention-matcher.js","webpack:///./node_modules/autolinker/dist/es2015/htmlParser/parse-html.js","webpack:///./node_modules/autolinker/dist/es2015/autolinker.js","webpack:///./node_modules/autolinker/dist/es2015/version.js","webpack:///./node_modules/autolinker/dist/es2015/index.js","webpack:///./node_modules/@dnd-kit/accessibility/dist/accessibility.esm.js","webpack:///./node_modules/@dnd-kit/core/dist/core.esm.js","webpack:///./node_modules/tslib/tslib.es6.js","webpack:///./node_modules/@dnd-kit/sortable/dist/sortable.esm.js","webpack:///./node_modules/react-images-upload/compiled.js"],"names":["warnOnce","msg","hasWarned","console","warn","parentNodePositionStatic","childIsDisabled","enterPresets","elevator","from","transform","opacity","to","fade","accordionVertical","transformOrigin","accordionHorizontal","none","leavePresets","appearPresets","find","predicate","arr","i","length","_isArray","Array","isArray","arg","Object","prototype","toString","call","fn","cache","hyphenate","str","replace","toLowerCase","_typeof","Symbol","iterator","obj","constructor","classCallCheck","instance","Constructor","TypeError","_extends","assign","target","arguments","source","key","hasOwnProperty","inherits","subClass","superClass","create","value","enumerable","writable","configurable","setPrototypeOf","__proto__","possibleConstructorReturn","self","ReferenceError","propConverter","ComposedComponent","_class","_temp","_Component","FlipMovePropConverter","this","apply","checkChildren","children","convertProps","props","workingProps","easing","onStart","onFinish","onStartAll","onFinishAll","typeName","disableAllAnimations","getPosition","maintainContainerHeight","verticalAlignment","duration","convertTimingProp","delay","staggerDurationBy","staggerDelayBy","appearAnimation","convertAnimationProp","enterAnimation","leaveAnimation","delegated","primaryPropKeys","keys","delegatedProps","attrs","undefined","result","forEach","indexOf","omit","style","position","prop","rawValue","parseInt","isNaN","defaultProps","animation","presets","render","createElement","node","getBoundingClientRect","applyStylesToDOMNode","_ref","domNode","styles","setProperty","getPositionDelta","_ref3","childDomNode","defaultBox","top","left","right","bottom","height","width","oldRelativeBox","childBoundingBox","parentBox","parentBoundingBox","newAbsoluteBox","newRelativeBox","createTransitionString","index","map","join","transitionEnd","transitions","transition","document","el","match","t","getPropertyValue","whichTransitionEvent","noBrowserSupport","getKey","childData","getElementChildren","toArray","enhancedFlipMove","FlipMove","_this","_len","args","_key","concat","state","element","appearing","childrenData","parentData","boundingBox","heightPlaceholderData","remainingAnimations","childrenToAnimate","findDOMContainer","findDOMNode","parentNode","HTMLElement","window","getComputedStyle","runAnimation","dynamicChildren","filter","doesChildNeedToBeAnimated","childrenInitialStyles","child","computeInitialStyles","push","animateChild","callChildrenHook","getChildData","_this$props","isAppearingWithAnimation","isEnteringWithAnimation","entering","isLeavingWithAnimation","leaving","_getPositionDelta","dX","dY","componentDidMount","isAnimationDisabled","prepForAnimation","componentDidUpdate","previousProps","a","b","notBothArrays","differentLengths","every","arraysEqual","d","calculateNextSetOfChildren","nextChildren","_this2","updatedChildren","nextChild","findChildByKey","isEntering","numOfChildrenLeaving","nextChildIndex","splice","_this3","_props","leavingChild","disabled","computed","margins","reduce","acc","margin","_babelHelpers$extends","propertyVal","Number","removeNodeFromDOMFlow","_ref4","parentDomNode","reductionInHeight","updateHeightPlaceholder","UNSAFE_componentWillReceiveProps","nextProps","updateBoundingBoxCaches","setState","childInitialStyles","_this4","requestAnimationFrame","bindTransitionEndHandler","_this5","addEventListener","transitionEndHandler","ev","triggerFinishHooks","removeEventListener","removeChildData","_this6","_ref2","item","hook","_this7","elements","domNodes","childKey","hasChildData","_this8","childrenBoundingBoxes","_getPosition","getRelativeBoundingBox","setChildData","_getPositionDelta2","data","prevState","createHeightPlaceholder","_this9","placeholderType","ref","visibility","childrenWithRefs","_this10","foundNode","nodeType","Node","TEXT_NODE","getNativeNode","_this11","_props2","module","exports","ownKeys","e","r","getOwnPropertySymbols","o","getOwnPropertyDescriptor","_objectSpread","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","toPrimitive","String","_toPrimitive","_slicedToArray","_arrayWithHoles","l","n","u","f","next","done","return","_iterableToArrayLimit","minLen","_arrayLikeToArray","slice","name","test","_unsupportedIterableToArray","_nonIterableRest","len","arr2","useCombinedRefs","refs","canUseDOM","isWindow","elementString","isNode","getWindow","_target$ownerDocument","_target$ownerDocument2","ownerDocument","defaultView","isDocument","Document","isHTMLElement","isSVGElement","SVGElement","getOwnerDocument","useIsomorphicLayoutEffect","useEvent","handler","handlerRef","current","useInterval","intervalRef","listener","setInterval","clearInterval","useLatestValue","dependencies","valueRef","useLazyMemo","callback","newValue","useNodeRef","onChange","onChangeHandler","setNodeRef","usePrevious","ids","useUniqueId","prefix","id","createAdjustmentFn","modifier","object","adjustments","accumulator","adjustment","entries","valueAdjustment","add","subtract","isKeyboardEvent","event","KeyboardEvent","getEventCoordinates","TouchEvent","isTouchEvent","touches","_event$touches$","x","clientX","y","clientY","changedTouches","_event$changedTouches","hasViewportRelativeCoordinates","CSS","freeze","Translate","Math","round","Scale","scaleX","scaleY","Transform","Transition","property","SELECTOR","findFirstFocusableNode","matches","querySelector","remove","throwUnhandledCaseError","theValue","Error","HtmlTag","cfg","tagName","innerHTML","whitespaceRegex","innerHtml","setTagName","getTagName","setAttr","attrName","attrValue","getAttrs","getAttr","setAttrs","setClass","cssClass","addClass","newClass","classAttr","getClass","classes","split","newClasses","shift","removeClass","removeClasses","idx","hasClass","setInnerHTML","html","setInnerHtml","getInnerHTML","getInnerHtml","toAnchorString","attrsStr","buildAttrsStr","attrsArr","urlSuffixRegex","AnchorTagBuilder","newWindow","truncate","className","build","createAttrs","processAnchorText","getAnchorText","href","getAnchorHref","createCssClass","returnClasses","cssClassSuffixes","getCssClassSuffixes","anchorText","doTruncate","truncateLength","truncateLocation","location","url","truncateLen","ellipsisChars","ellipsisLengthBeforeParsing","ellipsisLength","buildUrl","urlObj","scheme","host","path","query","fragment","buildSegment","segment","remainingAvailableLength","remainingAvailableLengthHalf","startOffset","ceil","endOffset","floor","end","substr","availableLength","urlSub","parse_url","matchQuery","pathAndQuery","truncateSmart","truncateMiddle","substring","ellipsis","truncateEnd","Match","__jsduckDummyDocProp","matchedText","offset","tagBuilder","getMatchedText","setOffset","getOffset","getType","buildTag","_super","EmailMatch","email","getEmail","HashtagMatch","serviceName","hashtag","getServiceName","getHashtag","MentionMatch","mention","getMention","PhoneMatch","number","plusSign","getPhoneNumber","getNumber","UrlMatch","urlMatchType","protocolUrlMatch","protocolRelativeMatch","stripPrefix","www","stripTrailingSlash","decodePercentEncoding","schemePrefixRegex","wwwPrefixRegex","protocolRelativeRegex","protocolPrepended","getUrlMatchType","getUrl","stripProtocolRelativePrefix","stripSchemePrefix","stripWwwPrefix","removeTrailingSlash","removePercentEncoding","text","charAt","preProcessedEntityAnchorText","decodeURIComponent","Matcher","letterRe","digitRe","nonDigitRe","whitespaceRe","quoteRe","controlCharsRe","alphaCharsStr","alphaCharsAndMarksStr","decimalNumbersStr","alphaNumericCharsStr","alphaNumericAndMarksCharsStr","alphaNumericAndMarksCharRe","RegExp","ipStr","domainLabelStr","getDomainLabelStr","group","getDomainNameStr","domainNameCharRegex","tldRegex","EmailMatcher","localPartCharRegex","strictTldRegex","parseMatches","noCurrentEmailMatch","CurrentEmailMatch","mailtoTransitions","m","charIdx","currentEmailMatch","char","stateNonEmailAddress","stateMailTo","stateLocalPart","stateLocalPartDot","stateAtSign","stateDomainChar","stateDomainHyphen","stateDomainDot","captureMatchIfValidAndReset","beginEmailMatch","prevChar","hasMailtoPrefix","resetToNonEmailMatchState","hasDomainDot","newState","emailAddress","emailAddressNormalized","pop","doesEmailHaveValidTld","UrlMatchValidator","isValid","urlMatch","isValidUriScheme","urlMatchDoesNotHaveProtocolOrDot","urlMatchDoesNotHaveAtLeastOneWordChar","isValidIpAddress","containsMultipleDots","uriSchemeMatch","newRegex","hasFullProtocolRegex","ipRegex","stringBeforeSlash","uriSchemeMatchArr","uriSchemeRegex","uriScheme","hasWordCharAfterProtocolRegex","wordCharRegExp","UrlMatcher","matcherRegex","_loop_1","matchStr","schemeUrlMatch","wwwUrlMatch","wwwProtocolRelativeMatch","tldProtocolRelativeMatch","this_1","matchHasUnbalancedClosingParen","pos","matchHasInvalidCharAfterTld","foundCommonScheme","commonScheme","indexOfSchemeStart","exec","startChar","endChar","numOpenBraces","max","res","hashtagTextCharRe","HashtagMatcher","hashCharIdx","stateNone","stateNonHashtagWordChar","stateHashtagHashChar","stateHashtagTextChar","captureMatchIfValid","hashtagServices","phoneMatcherRegex","PhoneMatcher","cleanNumber","before","after","contextClear","testMatch","twitterRegex","instagramRegex","soundcloudRegex","tiktokRegex","MentionMatcher","matcherRegexes","twitter","instagram","soundcloud","tiktok","nonWordCharRegex","parseHtml","_a","onOpenTag","onCloseTag","onText","onComment","onDoctype","noCurrentTag","CurrentTag","currentDataIdx","currentTag","stateData","stateTagOpen","stateEndTagOpen","stateTagName","stateBeforeAttributeName","stateAttributeName","stateAfterAttributeName","stateBeforeAttributeValue","stateAttributeValueDoubleQuoted","stateAttributeValueSingleQuoted","stateAttributeValueUnquoted","stateAfterAttributeValueQuoted","stateSelfClosingStartTag","stateMarkupDeclarationOpen","stateCommentStart","stateCommentStartDash","stateComment","stateCommentEndDash","stateCommentEnd","stateCommentEndBang","stateDoctype","startNewTag","isClosing","isOpening","captureTagName","emitTagAndPreviousTextNode","resetToDataState","type","toUpperCase","textBeforeTag","startIdx","Autolinker","version","urls","phone","replaceFn","context","sanitizeHtml","matchers","normalizeUrlsCfg","normalizeStripPrefixCfg","normalizeTruncateCfg","link","textOrHtml","options","parse","schemeMatches","wwwMatches","tldMatches","dest","src","defaults","POSITIVE_INFINITY","skipTagNames","skipTagsStackCount","textSplit","splitRegex","global","lastIdx","splitAndCapture","currentOffset_1","splitText","textNodeMatches","parseText","compactMatches","removeUnwantedMatches","sort","matchedTextLength","endIdx","removeIdx","getMatchers","numMatchers","textMatches","j","numTextMatches","newHtml","lastIndex","createMatchReturnVal","replaceFnResult","getTagBuilder","matcher","Email","Hashtag","Mention","Phone","Url","hiddenStyles","display","HiddenText","LiveRegion","announcement","_ref$ariaLiveType","ariaLiveType","border","padding","overflow","clip","clipPath","whiteSpace","role","_excluded","_excluded2","_excluded3","_objectWithoutProperties","excluded","sourceKeys","_objectWithoutPropertiesLoose","sourceSymbolKeys","propertyIsEnumerable","DndMonitorContext","defaultScreenReaderInstructions","draggable","defaultAnnouncements","onDragStart","active","over","onDragCancel","Accessibility","_ref$announcements","announcements","container","hiddenTextDescribedById","_ref$screenReaderInst","screenReaderInstructions","_useAnnouncement","_useState2","setAnnouncement","announce","useAnnouncement","liveRegionId","_useState4","mounted","setMounted","registerListener","useDndMonitor","onDragMove","onDragOver","_ref5","onDragEnd","_ref6","markup","Fragment","Action","noop","useSensor","sensor","useSensors","sensors","defaultCoordinates","distanceBetween","p1","p2","sqrt","pow","getRelativeTransformOrigin","rect","eventCoordinates","sortCollisionsAsc","sortCollisionsDesc","cornersOfRectangle","getFirstCollision","collisions","firstCollision","centerOfRectangle","closestCenter","collisionRect","droppableRects","droppableContainers","centerRect","droppableContainer","get","distBetween","closestCorners","corners","rectCorners","distances","corner","effectiveDistance","toFixed","getIntersectionRatio","entry","min","targetArea","entryArea","intersectionArea","rectIntersection","intersectionRatio","getRectDelta","rect1","rect2","createRectAdjustmentFn","getAdjustedRect","parseTransform","startsWith","transformArray","defaultOptions","ignoreTransform","getClientRect","_getWindow$getCompute","parsedTransform","translateX","translateY","parseFloat","w","h","inverseTransform","_rect","getTransformAgnosticClientRect","getScrollableAncestors","limit","scrollParents","findScrollableAncestors","scrollingElement","includes","computedStyle","overflowRegex","some","isScrollable","isFixed","getFirstScrollableAncestor","firstScrollableAncestor","getScrollableElement","getScrollXCoordinate","scrollX","scrollLeft","getScrollYCoordinate","scrollY","scrollTop","getScrollCoordinates","Direction","isDocumentScrollingElement","getScrollPosition","scrollingContainer","minScroll","dimensions","innerHeight","innerWidth","clientHeight","clientWidth","maxScroll","scrollWidth","scrollHeight","isTop","isLeft","isBottom","isRight","defaultThreshold","getScrollDirectionAndSpeed","scrollContainer","scrollContainerRect","acceleration","thresholdPercentage","_getScrollPosition","direction","speed","threshold","Backward","abs","Forward","getScrollElementRect","_window","_element$getBoundingC","getScrollOffsets","scrollableAncestors","scrollIntoViewIfNeeded","measure","_measure","scrollIntoView","block","inline","Rect","scrollOffsets","_ref7","_ref8","axis","getScrollOffset","currentOffsets","scrollOffsetsDeltla","Listeners","listeners","removeAll","_this$target","eventName","_this$target2","hasExceededDistance","delta","measurement","dx","dy","EventName","KeyboardCode","preventDefault","stopPropagation","defaultKeyboardCodes","start","Space","Enter","cancel","Esc","defaultKeyboardCoordinateGetter","currentCoordinates","code","Right","Left","Down","Up","autoScrollEnabled","referenceCoordinates","windowListeners","handleKeyDown","bind","handleCancel","attach","handleStart","Resize","VisibilityChange","setTimeout","Keydown","activeNode","_this$props2","_options$keyboardCode","keyboardCodes","_options$coordinateGe","coordinateGetter","_options$scrollBehavi","scrollBehavior","handleEnd","newCoordinates","coordinatesDelta","scrollDelta","_getScrollPosition2","scrollElementRect","clampedCoordinates","canScrollX","canScrollY","newScrollCoordinates","canScrollToNewCoordinates","scrollTo","behavior","scrollBy","handleMove","coordinates","onMove","onEnd","detach","onCancel","isDistanceConstraint","constraint","Boolean","isDelayConstraint","activators","_ref$keyboardCodes","onActivation","nativeEvent","activator","activatorNode","events","listenerTarget","_getEventCoordinates","EventTarget","getEventListenerTarget","activated","initialCoordinates","timeoutId","documentListeners","handleKeydown","removeTextSelection","_this$props$options","activationConstraint","bypassActivationConstraint","move","passive","DragStart","ContextMenu","clearTimeout","Click","capture","SelectionChange","_getEventCoordinates2","tolerance","distance","cancelable","_this$document$getSel","getSelection","removeAllRanges","super","isPrimary","button","events$1","MouseButton","RightClick","events$2","AutoScrollActivator","TraversalOrder","useAutoScroller","_ref$activator","Pointer","canScroll","draggingRect","enabled","_ref$interval","interval","_ref$order","order","TreeOrder","pointerCoordinates","scrollableAncestorRects","scrollIntent","previousDelta","previousIntent","defaultScrollIntent","sign","useScrollIntent","_useInterval2","setAutoScrollInterval","clearAutoScrollInterval","scrollSpeed","scrollDirection","DraggableRect","scrollContainerRef","autoScroll","sortedScrollableAncestors","reverse","_getScrollDirectionAn","JSON","stringify","MeasuringStrategy","MeasuringFrequency","defaultValue","Map","useInitialValue","computeFn","previousValue","useResizeObserver","handleResize","resizeObserver","ResizeObserver","disconnect","defaultMeasure","useRect","fallbackRect","_useReducer2","currentRect","isConnected","newRect","measureRect","mutationObserver","handleMutations","MutationObserver","useMutationObserver","records","record","contains","observe","body","childList","subtree","defaultValue$1","useScrollOffsetsDelta","initialScrollOffsets","hasScrollOffsets","useWindowRect","getWindowClientRect","defaultValue$2","getMeasurableNode","firstChild","defaultSensors","defaultData","defaultMeasuringConfiguration","droppable","strategy","WhileDragging","frequency","Optimized","dragOverlay","DroppableContainersMap","_super$get","values","_this$get$node$curren","_this$get","defaultPublicContext","activatorEvent","activeNodeRect","containerNodeRect","draggableNodes","nodeRef","setRef","measuringConfiguration","measureDroppableContainers","windowRect","measuringScheduled","defaultInternalContext","ariaDescribedById","dispatch","InternalContext","PublicContext","getInitialState","nodes","translate","containers","action","DragMove","DragEnd","DragCancel","RegisterDroppable","set","SetDroppableDisabled","UnregisterDroppable","delete","RestoreFocus","_useContext","previousActivatorEvent","previousActiveId","activeElement","draggableNode","focusableNode","focus","applyModifiers","modifiers","ActiveDraggableContext","Status","_sensorContext$curren","_dragOverlay$nodeRef$","_dragOverlay$rect","_over$rect","accessibility","_ref$autoScroll","_ref$sensors","_ref$collisionDetecti","collisionDetection","measuring","_store","_useDndMonitorProvide","Set","_listener$type","useDndMonitorProvider","_useDndMonitorProvide2","dispatchMonitorEvent","registerMonitorListener","_useState12","Uninitialized","status","setStatus","isInitialized","Initialized","_state$draggable","activeId","activeRects","initial","translated","_node$data","activeRef","_useState14","activeSensor","setActiveSensor","_useState16","setActivatorEvent","latestProps","draggableDescribedById","enabledDroppableContainers","getEnabled","config","_useDroppableMeasurin","dragging","_useState6","queue","setQueue","containersRef","Always","BeforeDragging","isDisabled","disabledRef","useDroppableMeasuring","cachedNode","useCachedNode","activationCoordinates","autoScrollOptions","activeSensorDisablesAutoscroll","autoScrollGloballyDisabled","getAutoScrollerOptions","initialActiveNodeRect","useInitialRect","initialRect","_ref$config","initialized","_ref10","rectDelta","useLayoutShiftScrollCompensation","layoutShiftCompensation","parentElement","sensorContext","draggingNode","draggingNodeRect","scrollAdjustedTranslate","overNode","getNodeFor","_useState10","setRect","_ref9","handleNodeChange","_useNodeRef2","useDragOverlayMeasuring","usesDragOverlay","nodeRectDelta","previousNode","ancestors","useScrollableAncestors","firstElement","_useReducer4","rects","measureRects","useRects","modifiedTranslate","overlayNodeRect","_useState8","scrollCoordinates","setScrollCoordinates","prevElements","handleScroll","previousElements","cleanup","scrollableElement","useScrollOffsets","scrollAdjustment","activeNodeScrollDelta","overId","_useState18","setOver","instantiateSensor","Sensor","sensorInstance","Initializing","createHandler","async","_sensorContext$curren2","cancelDrop","Promise","resolve","getSyntheticHandler","useCombineActivators","activeDraggableNode","dndKit","defaultPrevented","activationContext","capturedBy","teardownFns","setup","teardown","useSensorSetup","_sensorContext$curren3","_sensorContext$curren4","overContainer","publicContext","internalContext","Provider","restoreFocus","NullContext","useDraggable","_ref$disabled","attributes","_useContext2","_ref11","_ref11$role","_ref11$roleDescriptio","roleDescription","_ref11$tabIndex","tabIndex","isDragging","_useNodeRef4","_useNodeRef6","setActivatorNodeRef","useSyntheticListeners","dataRef","useDndContext","defaultResizeObserverConfig","timeout","useDroppable","_ref$disabled2","resizeObserverConfig","_useContext3","previous","resizeObserverConnected","callbackId","_defaultResizeObserve","resizeObserverDisabled","updateMeasurementsFor","resizeObserverTimeout","newElement","previousElement","unobserve","_useNodeRef8","isOver","AnimationManager","_useState20","clonedChildren","setClonedChildren","_useState22","setElement","previousChildren","then","defaultTransform","NullifiedContextProvider","baseStyles","touchAction","defaultTransition","PositionedOverlay","as","adjustScale","_ref$transition","scaleAdjustedTransform","defaultDropAnimationConfiguration","keyframes","_ref2$transform","final","sideEffects","originalStyles","_ref12","_ref13","_ref14","_ref15","classList","_ref16","_ref17","defaultDropAnimationSideEffects","useDropAnimation","activeDraggable","measurableNode","_defaultDropAnimation","rest","scale","finalTransform","animationKeyframes","firstKeyframe","lastKeyframe","animate","fill","onfinish","createDefaultDropAnimation","DragOverlay","memo","_ref$adjustScale","dropAnimationConfig","dropAnimation","_ref$wrapperElement","wrapperElement","_ref$zIndex","zIndex","_useDndContext","modifiedTransform","extendStatics","p","__extends","__","__assign","s","__rest","__decorate","decorators","desc","c","Reflect","decorate","__param","paramIndex","decorator","__esDecorate","ctor","descriptorIn","contextIn","initializers","extraInitializers","accept","_","kind","descriptor","access","addInitializer","init","unshift","__runInitializers","thisArg","useValue","__propKey","__setFunctionName","description","__metadata","metadataKey","metadataValue","metadata","__awaiter","_arguments","P","generator","reject","fulfilled","step","rejected","__generator","g","label","sent","trys","ops","verb","v","op","__createBinding","k","k2","__esModule","__exportStar","__values","__read","ar","error","__spread","__spreadArrays","il","jl","__spreadArray","pack","__await","__asyncGenerator","asyncIterator","q","resume","fulfill","settle","__asyncDelegator","__asyncValues","__makeTemplateObject","cooked","raw","__setModuleDefault","__importStar","mod","__importDefault","default","__classPrivateFieldGet","receiver","has","__classPrivateFieldSet","__classPrivateFieldIn","__addDisposableResource","env","dispose","asyncDispose","stack","_SuppressedError","SuppressedError","suppressed","message","__disposeResources","fail","hasError","rec","arrayMove","array","newArray","getSortedRects","items","isValidIndex","rectSortingStrategy","activeIndex","overIndex","newRects","oldRect","defaultScale$1","verticalListSortingStrategy","_rects$activeIndex","fallbackActiveRect","overIndexRect","itemGap","clientRects","previousRect","nextRect","getItemGap$1","Context","createContext","containerId","disableTransforms","useDragOverlay","sortedRects","SortableContext","userDefinedItems","_ref$strategy","disabledProp","previousItemsRef","itemsHaveChanged","itemsEqual","normalizeDisabled","contextValue","defaultNewIndexGetter","defaultAnimateLayoutChanges","isSorting","wasDragging","newIndex","previousItems","previousContainerId","disabledTransition","defaultAttributes","useSortable","_ref$animateLayoutCha","animateLayoutChanges","userDefinedAttributes","localDisabled","customData","_ref$getNewIndex","getNewIndex","localStrategy","globalDisabled","globalStrategy","_localDisabled$dragga","_localDisabled$droppa","normalizeLocalDisabled","sortable","itemsAfterCurrentSortable","_useDroppable","setDroppableNodeRef","_useDraggable","setDraggableNodeRef","displaceItem","shouldDisplaceDragSource","dragSourceDisplacement","shouldAnimateLayoutChanges","derivedTransform","setDerivedtransform","previousIndex","useDerivedTransform","getTransition","_createClass","protoProps","staticProps","_react2","_interopRequireDefault","_propTypes2","_reactFlipMove2","_UploadIcon2","_toConsumableArray","alignItems","justifyContent","flexWrap","ERROR","ReactImageUploadComponent","_React$Component","_classCallCheck","_possibleConstructorReturn","getPrototypeOf","pictures","defaultImages","files","fileErrors","inputElement","onDropFile","onUploadClick","triggerFileUpload","_inherits","prevProps","snapshot","fileName","pattern","imgExtension","allFilePromises","file","fileError","hasExtension","size","maxFileSize","readFile","singleImage","all","newFilesData","dataURLs","newFileData","dataURL","reader","FileReader","onload","readAsDataURL","picture","removeIndex","findIndex","filteredPictures","filteredFiles","errorClass","errorStyle","fileSizeError","fileTypeError","withIcon","alt","withLabel","labelClass","labelStyles","renderPreviewPictures","onClick","removeImage","click","fileContainerStyle","renderIcon","renderLabel","renderErrors","buttonType","buttonClassName","buttonStyles","buttonText","input","multiple","withPreview","renderPreview","Component","propTypes","string","func","onDelete","bool"],"mappings":"kHAAA,4CAEA,SAASA,EAASC,GAChB,IAAIC,GAAY,EAChB,OAAO,WACAA,IACHC,QAAQC,KAAKH,GACbC,GAAY,IAIyBF,EAAS,sXACxBA,EAAS,qQADrC,IAYIK,EAA2BL,EAAS,8XACpCM,EAAkBN,EAAS,oSAC3BO,EAAe,CACjBC,SAAU,CACRC,KAAM,CACJC,UAAW,WACXC,QAAS,KAEXC,GAAI,CACFF,UAAW,GACXC,QAAS,KAGbE,KAAM,CACJJ,KAAM,CACJE,QAAS,KAEXC,GAAI,CACFD,QAAS,KAGbG,kBAAmB,CACjBL,KAAM,CACJC,UAAW,YACXK,gBAAiB,cAEnBH,GAAI,CACFF,UAAW,GACXK,gBAAiB,eAGrBC,oBAAqB,CACnBP,KAAM,CACJC,UAAW,YACXK,gBAAiB,eAEnBH,GAAI,CACFF,UAAW,GACXK,gBAAiB,gBAGrBE,KAAM,MAUJC,EAAe,CACjBV,SAAU,CACRC,KAAM,CACJC,UAAW,WACXC,QAAS,KAEXC,GAAI,CACFF,UAAW,WACXC,QAAS,MAGbE,KAAM,CACJJ,KAAM,CACJE,QAAS,KAEXC,GAAI,CACFD,QAAS,MAGbG,kBAAmB,CACjBL,KAAM,CACJC,UAAW,YACXK,gBAAiB,cAEnBH,GAAI,CACFF,UAAW,YACXK,gBAAiB,eAGrBC,oBAAqB,CACnBP,KAAM,CACJC,UAAW,YACXK,gBAAiB,eAEnBH,GAAI,CACFF,UAAW,YACXK,gBAAiB,gBAGrBE,KAAM,MAKJE,EAAgBZ,EAGhBa,EAAO,SAAcC,EAAWC,GAClC,IAAK,IAAIC,EAAI,EAAGA,EAAID,EAAIE,OAAQD,IAC9B,GAAIF,EAAUC,EAAIC,GAAIA,EAAGD,GACvB,OAAOA,EAAIC,IAebE,EAAW,SAAiBH,GAI9B,OAHAG,EAAWC,MAAMC,SAAW,SAAUC,GACpC,MAA+C,mBAAxCC,OAAOC,UAAUC,SAASC,KAAKJ,KAExBN,IA0ClB,IATuBW,EACjBC,EAQFC,GATmBF,EASO,SAAUG,GACtC,OAAOA,EAAIC,QAAQ,WAAY,OAAOC,eATlCJ,EAAQ,GACL,SAAUE,GAIf,OAHKF,EAAME,KACTF,EAAME,GAAOH,EAAGG,IAEXF,EAAME,KAMbG,EAA4B,oBAAXC,QAAoD,kBAApBA,OAAOC,SAAwB,SAAUC,GAC5F,cAAcA,GACZ,SAAUA,GACZ,OAAOA,GAAyB,oBAAXF,QAAyBE,EAAIC,cAAgBH,QAAUE,IAAQF,OAAOV,UAAY,gBAAkBY,GAEvHE,EAAiB,SAAUC,EAAUC,GACvC,KAAMD,aAAoBC,GACxB,MAAM,IAAIC,UAAU,sCAGpBC,EAAWnB,OAAOoB,QAAU,SAAUC,GACxC,IAAK,IAAI3B,EAAI,EAAGA,EAAI4B,UAAU3B,OAAQD,IAAK,CACzC,IAAI6B,EAASD,UAAU5B,GACvB,IAAK,IAAI8B,KAAOD,EACVvB,OAAOC,UAAUwB,eAAetB,KAAKoB,EAAQC,KAC/CH,EAAOG,GAAOD,EAAOC,IAI3B,OAAOH,GAELK,EAAW,SAAUC,EAAUC,GACjC,GAA0B,oBAAfA,GAA4C,OAAfA,EACtC,MAAM,IAAIV,UAAU,kEAAoEU,GAE1FD,EAAS1B,UAAYD,OAAO6B,OAAOD,GAAcA,EAAW3B,UAAW,CACrEa,YAAa,CACXgB,MAAOH,EACPI,YAAY,EACZC,UAAU,EACVC,cAAc,KAGdL,IAAY5B,OAAOkC,eAAiBlC,OAAOkC,eAAeP,EAAUC,GAAcD,EAASQ,UAAYP,IAEzGQ,EAA4B,SAAUC,EAAMlC,GAC9C,IAAKkC,EACH,MAAM,IAAIC,eAAe,6DAE3B,OAAOnC,GAAyB,kBAATA,GAAqC,oBAATA,EAA8BkC,EAAPlC,GAmB5E,SAASoC,EAAcC,GACrB,IAAIC,EAAQC,EACZ,OAAOA,EAAQD,EAAS,SAAUE,GAEhC,SAASC,IAEP,OADA7B,EAAe8B,KAAMD,GACdR,EAA0BS,KAAMF,EAAWG,MAAMD,KAAMvB,YA6HhE,OAhIAI,EAASkB,EAAuBD,GAOhCC,EAAsB3C,UAAU8C,cAAgB,SAAuBC,KA2BvEJ,EAAsB3C,UAAUgD,aAAe,SAAsBC,GACnE,IAAIC,EAAe,CAEjBH,SAAUE,EAAMF,SAChBI,OAAQF,EAAME,OACdC,QAASH,EAAMG,QACfC,SAAUJ,EAAMI,SAChBC,WAAYL,EAAMK,WAClBC,YAAaN,EAAMM,YACnBC,SAAUP,EAAMO,SAChBC,qBAAsBR,EAAMQ,qBAC5BC,YAAaT,EAAMS,YACnBC,wBAAyBV,EAAMU,wBAC/BC,kBAAmBX,EAAMW,kBAEzBC,SAAUjB,KAAKkB,kBAAkB,YACjCC,MAAOnB,KAAKkB,kBAAkB,SAC9BE,kBAAmBpB,KAAKkB,kBAAkB,qBAC1CG,eAAgBrB,KAAKkB,kBAAkB,kBAIvCI,gBAAiBtB,KAAKuB,qBAAqBlB,EAAMiB,gBAAiB7E,GAClE+E,eAAgBxB,KAAKuB,qBAAqBlB,EAAMmB,eAAgB3F,GAChE4F,eAAgBzB,KAAKuB,qBAAqBlB,EAAMoB,eAAgBjF,GAChEkF,UAAW,IAEb1B,KAAKE,cAAcI,EAAaH,UAIhC,IAAIwB,EAAkBxE,OAAOyE,KAAKtB,GAC9BuB,EAnKV,SAAc7D,GACZ,IAAI8D,EAAQrD,UAAU3B,OAAS,QAAsBiF,IAAjBtD,UAAU,GAAmBA,UAAU,GAAK,GAC5EuD,EAAS,GAMb,OALA7E,OAAOyE,KAAK5D,GAAKiE,SAAQ,SAAUtD,IACL,IAAxBmD,EAAMI,QAAQvD,KAChBqD,EAAOrD,GAAOX,EAAIW,OAGfqD,EA2JkBG,CAAKnC,KAAKK,MAAOsB,GAStC,OAJAE,EAAeO,MAAQ9D,EAAS,CAC9B+D,SAAU,YACTR,EAAeO,OAClB9B,EAAaoB,UAAYG,EAClBvB,GAETP,EAAsB3C,UAAU8D,kBAAoB,SAA2BoB,GAC7E,IAAIC,EAAWvC,KAAKK,MAAMiC,GACtBrD,EAA4B,kBAAbsD,EAAwBA,EAAWC,SAASD,EAAU,IACzE,OAAIE,MAAMxD,GACWc,EAAsB2C,aAAaJ,GAUjDrD,GAKTc,EAAsB3C,UAAUmE,qBAAuB,SAA8BoB,EAAWC,GAC9F,OAA6B,qBAAdD,EAA4B,YAAc9E,EAAQ8E,IAC/D,IAAK,UAID,OAAOC,EAAQD,EAxOP,WACA,QAyOZ,IAAK,SAGD,OAAuC,IADtBxF,OAAOyE,KAAKgB,GACdV,QAAQS,GAQdC,EAAqB,SAEvBA,EAAQD,GAEnB,QAEI,OAAOA,IAIf5C,EAAsB3C,UAAUyF,OAAS,WACvC,OAAoB,IAAMC,cAAcnD,EAAmBK,KAAKI,aAAaJ,KAAKK,SAE7EN,EAjIe,CAkItB,aAAYH,EAAO8C,aAAe,CAClCnC,OAAQ,cACRU,SAAU,IACVE,MAAO,EACPC,kBAAmB,EACnBC,eAAgB,EAChBT,SAAU,MACVY,eA1QgB,WA2QhBC,eA3QgB,WA4QhBZ,sBAAsB,EACtBC,YAAa,SAAqBiC,GAChC,OAAOA,EAAKC,yBAEdjC,yBAAyB,EACzBC,kBAAmB,OAClBnB,EAWL,SAASoD,EAAqBC,GAC5B,IAAIC,EAAUD,EAAKC,QACjBC,EAASF,EAAKE,OAIhBjG,OAAOyE,KAAKwB,GAAQnB,SAAQ,SAAUtD,GACpCwE,EAAQf,MAAMiB,YAAY5F,EAAUkB,GAAMyE,EAAOzE,OAyBrD,IA2BI2E,EAAmB,SAA0BC,GAC/C,IAAIC,EAAeD,EAAMC,aAMrBC,EAAa,CACfC,IAAK,EACLC,KAAM,EACNC,MAAO,EACPC,OAAQ,EACRC,OAAQ,EACRC,MAAO,GAKLC,EAhBiBT,EAAMU,kBAgBcR,EACrCS,EAhBkBX,EAAMY,mBAgBSV,EAMjCW,GAAiBtD,EArBLyC,EAAMzC,aAqBW0C,GAC7Ba,EACGD,EAAeV,IAAMQ,EAAUR,IADlCW,EAEID,EAAeT,KAAOO,EAAUP,KAExC,MAAO,CAACK,EAAeL,KAAOU,EAAqBL,EAAeN,IAAMW,IAqHtEC,EAAyB,SAAgCC,EAAOlE,GAClE,IAAIc,EAAQd,EAAMc,MAChBF,EAAWZ,EAAMY,SACfG,EAAoBf,EAAMe,kBAC5BC,EAAiBhB,EAAMgB,eACvBd,EAASF,EAAME,OACjBY,GAASoD,EAAQlD,EACjBJ,GAAYsD,EAAQnD,EAEpB,MADoB,CAAC,YAAa,WACboD,KAAI,SAAUlC,GACjC,OAAOA,EAAO,IAAMrB,EAAW,MAAQV,EAAS,IAAMY,EAAQ,QAC7DsD,KAAK,OAcNC,EA3NJ,WACE,IAAIC,EAAc,CAChBC,WAAY,gBACZ,gBAAiB,iBACjB,kBAAmB,gBACnB,qBAAsB,uBAKxB,GAAwB,qBAAbC,SAA0B,MAAO,GAC5C,IAAIC,EAAKD,SAAS/B,cAAc,eAC5BiC,EAAQrI,GAAK,SAAUsI,GACzB,YAAwCjD,IAAjC+C,EAAG1C,MAAM6C,iBAAiBD,KAChC7H,OAAOyE,KAAK+C,IAIf,OAAOI,EAAQJ,EAAYI,GAAS,GAyMlBG,GAChBC,GAAoBT,EACxB,SAASU,EAAOC,GACd,OAAOA,EAAU1G,KAAO,GAE1B,SAAS2G,EAAmBnF,GAG1B,OAAO,WAASoF,QAAQpF,GAE1B,IAipBIqF,EAAkC9F,EAjpBrB,SAAUI,GAEzB,SAAS2F,IACP,IAAI5F,EAAO6F,EACXxH,EAAe8B,KAAMyF,GACrB,IAAK,IAAIE,EAAOlH,UAAU3B,OAAQ8I,EAAO5I,MAAM2I,GAAOE,EAAO,EAAGA,EAAOF,EAAME,IAC3ED,EAAKC,GAAQpH,UAAUoH,GAEzB,OAAehG,EAAS6F,EAAQnG,EAA0BS,KAAMF,EAAWxC,KAAK2C,MAAMH,EAAY,CAACE,MAAM8F,OAAOF,KAAiBF,EAAMK,MAAQ,CAC7I5F,SAAUmF,EAKVI,EAAMrF,MAAQqF,EAAMrF,MAAMF,SAAW,IAAIqE,KAAI,SAAUwB,GACrD,OAAO1H,EAAS,GAAI0H,EAAS,CAC3BA,QAASA,EACTC,WAAW,QAGdP,EAAMQ,aAAe,GAAIR,EAAMS,WAAa,CAC7ChD,QAAS,KACTiD,YAAa,MACZV,EAAMW,sBAAwB,CAC/BlD,QAAS,MACRuC,EAAMY,oBAAsB,EAAGZ,EAAMa,kBAAoB,GAAIb,EAAMc,iBAAmB,WAEvF,IAAIrD,EAAU,IAASsD,YAAYf,GAC/BgB,EAAavD,GAAWA,EAAQuD,WAG/BA,GAAgBA,aAAsBC,cAOU,WAAjDC,OAAOC,iBAAiBH,GAAYrE,WACtCqE,EAAWtE,MAAMC,SAAW,WAC5B1G,KAEF+J,EAAMS,WAAWhD,QAAUuD,IAC1BhB,EAAMoB,aAAe,WACtB,IAAIC,EAAkBrB,EAAMK,MAAM5F,SAAS6G,OAAOtB,EAAMuB,2BAGpDC,EAAwBH,EAAgBvC,KAAI,SAAU2C,GACxD,OAAOzB,EAAM0B,qBAAqBD,MAEpCJ,EAAgB9E,SAAQ,SAAUkF,EAAO5C,GACvCmB,EAAMY,qBAAuB,EAC7BZ,EAAMa,kBAAkBc,KAAKjC,EAAO+B,IACpCzB,EAAM4B,aAAaH,EAAO5C,EAAO2C,EAAsB3C,OAEnB,oBAA3BmB,EAAMrF,MAAMK,YACrBgF,EAAM6B,iBAAiB7B,EAAMrF,MAAMK,aAEpCgF,EAAMuB,0BAA4B,SAAUE,GAG7C,IAAK/B,EAAO+B,GACV,OAAO,EAET,IAAI9B,EAAYK,EAAM8B,aAAapC,EAAO+B,IACtC3D,EAAe6B,EAAUlC,QACzBc,EAAmBoB,EAAUe,YAC7BjC,EAAoBuB,EAAMS,WAAWC,YACzC,IAAK5C,EACH,OAAO,EAET,IAAIiE,EAAc/B,EAAMrF,MACtBiB,EAAkBmG,EAAYnG,gBAC9BE,EAAiBiG,EAAYjG,eAC7BC,EAAiBgG,EAAYhG,eAC7BX,EAAc2G,EAAY3G,YACxB4G,EAA2BP,EAAMlB,WAAa3E,EAC9CqG,EAA0BR,EAAMS,UAAYpG,EAC5CqG,EAAyBV,EAAMW,SAAWrG,EAC9C,GAAIiG,GAA4BC,GAA2BE,EACzD,OAAO,EAMT,IAAIE,EAAoBzE,EAAiB,CACrCE,aAAcA,EACdS,iBAAkBA,EAClBE,kBAAmBA,EACnBrD,YAAaA,IAEfkH,EAAKD,EAAkB,GACvBE,EAAKF,EAAkB,GACzB,OAAc,IAAPC,GAAmB,IAAPC,GACV1I,EAA0BmG,EAAlC7F,GAgjBL,OA9oBAhB,EAAS4G,EAAU3F,GA6HnB2F,EAASrI,UAAU8K,kBAAoB,WAIT,OAAxBlI,KAAKK,MAAMO,UACbZ,KAAKwG,mBAKiBxG,KAAKK,MAAMiB,kBAAoBtB,KAAKmI,oBAAoBnI,KAAKK,SAEnFL,KAAKoI,mBACLpI,KAAK8G,iBAGTrB,EAASrI,UAAUiL,mBAAqB,SAA4BC,GACtC,OAAxBtI,KAAKK,MAAMO,UACbZ,KAAKwG,oBAnnBX,SAAqB+B,EAAGC,GAEtB,GADiBD,IAAMC,EAErB,OAAO,EAET,IAAIC,GAAiB1L,EAASwL,KAAOxL,EAASyL,GAC1CE,EAAmBH,EAAEzL,SAAW0L,EAAE1L,OACtC,OAAI2L,IAAiBC,GAxCX,SAAe/L,EAAWC,GACpC,IAAK,IAAIC,EAAI,EAAGA,EAAID,EAAIE,OAAQD,IAC9B,IAAKF,EAAUC,EAAIC,GAAIA,EAAGD,GACxB,OAAO,EAGX,OAAO,EAqCA+L,EAAM,SAAU3C,EAASzB,GAC9B,OAAOyB,IAAYwC,EAAEjE,KACpBgE,GAsnBwBK,CANHtD,EAAmBtF,KAAKK,MAAMF,UAAUqE,KAAI,SAAUqE,GAC1E,OAAOA,EAAElK,OAEY2G,EAAmBgD,EAAcnI,UAAUqE,KAAI,SAAUqE,GAC9E,OAAOA,EAAElK,UAEiEqB,KAAKmI,oBAAoBnI,KAAKK,SAExGL,KAAKoI,mBACLpI,KAAK8G,iBAGTrB,EAASrI,UAAU0L,2BAA6B,SAAoCC,GAClF,IAAIC,EAAShJ,KAUTiJ,EAAkBF,EAAavE,KAAI,SAAU0E,GAC/C,IAAI/B,EAAQ6B,EAAOG,eAAeD,EAAUvK,KAIxCyK,GAAcjC,GAASA,EAAMW,QACjC,OAAOxJ,EAAS,GAAI4K,EAAW,CAC7BlD,QAASkD,EACTtB,SAAUwB,OAkBVC,EAAuB,EAiB3B,OAhBArJ,KAAK+F,MAAM5F,SAAS8B,SAAQ,SAAUkF,EAAO5C,GAQ3C,IAPiB7H,GAAK,SAAUwG,GAE9B,OADUA,EAAKvE,MACAyG,EAAO+B,KACrB4B,IAIgBC,EAAO3I,MAAMoB,eAAhC,CACA,IAAIyH,EAAY5K,EAAS,GAAI6I,EAAO,CAClCW,SAAS,IAEPwB,EAAiB/E,EAAQ8E,EAC7BJ,EAAgBM,OAAOD,EAAgB,EAAGJ,GAC1CG,GAAwB,MAEnBJ,GAETxD,EAASrI,UAAUgL,iBAAmB,WACpC,IAAIoB,EAASxJ,KAQTyJ,EAASzJ,KAAKK,MAChBoB,EAAiBgI,EAAOhI,eACxBV,EAA0B0I,EAAO1I,wBACjCD,EAAc2I,EAAO3I,YAKnBW,IACoBzB,KAAK+F,MAAM5F,SAAS6G,QAAO,SAAUG,GACzD,OAAOA,EAAMW,WAEC7F,SAAQ,SAAUyH,GAChC,IAAIrE,EAAYmE,EAAOhC,aAAapC,EAAOsE,KAGtCF,EAAOrB,oBAAoBqB,EAAOnJ,QAAUgF,EAAUlC,SAAWkC,EAAUlC,QAAQwG,UACtF/N,IAKEyJ,EAAUe,aAvYM,SAA+Bf,EAAWrE,GACpE,IAAImC,EAAUkC,EAAUlC,QACtBiD,EAAcf,EAAUe,YAC1B,GAAKjD,GAAYiD,EAAjB,CAKA,IAAIwD,EAAWhD,OAAOC,iBAAiB1D,GAKnC0G,EADc,CAAC,aAAc,cAAe,gBACtBC,QAAO,SAAUC,EAAKC,GAC9C,IAAIC,EACAC,EAAcN,EAAS3E,iBAAiB+E,GAC5C,OAAO1L,EAAS,GAAIyL,IAAME,EAAwB,IAA0BD,GAAUG,OAAOD,EAAYvM,QAAQ,KAAM,KAAMsM,MAC5H,IAaHhH,EAAqB,CACnBE,QAASA,EACTC,OARW,CACXf,SAAU,WACVqB,KAHoC,WAAtB1C,EAAiCoF,EAAY1C,IAAM0C,EAAYtC,OAASsC,EAAY1C,KAGjFmG,EAAQ,cAAgB,KACzClG,KAAMyC,EAAYzC,KAAOkG,EAAQ,eAAiB,KAClDjG,MAAOwC,EAAYxC,MAAQiG,EAAQ,gBAAkB,SA4W/CO,CAAsB/E,EAAWmE,EAAOnJ,MAAMW,sBAG9CD,GAA2Bf,KAAKqG,sBAAsBlD,SAjWlC,SAAiCkH,GAC7D,IAAIlH,EAAUkH,EAAMlH,QAClBgD,EAAakE,EAAMlE,WACnBrF,EAAcuJ,EAAMvJ,YAClBwJ,EAAgBnE,EAAWhD,QAC3BgB,EAAoBgC,EAAWC,YACnC,GAAKkE,GAAkBnG,EAAvB,CASAlB,EAAqB,CACnBE,QAASA,EACTC,OAAQ,CACNU,OAAQ,OAOZ,IAEIyG,EAFuBpG,EAAkBL,OACjBhD,EAAYwJ,GAAexG,OASvDb,EAAqB,CACnBE,QAASA,EACTC,OALW,CACXU,OAAQyG,EAAoB,EAAIA,EAAoB,KAAO,QAiUvDC,CAAwB,CACtBrH,QAASnD,KAAKqG,sBAAsBlD,QACpCgD,WAAYnG,KAAKmG,WACjBrF,YAAaA,KAQnBd,KAAK+F,MAAM5F,SAAS8B,SAAQ,SAAUkF,GACpC,IACEhE,EADkBqG,EAAOhC,aAAapC,EAAO+B,IACrBhE,QAIrBA,IAGAgE,EAAMS,UAAaT,EAAMW,SAC5B7E,EAAqB,CACnBE,QAASA,EACTC,OAAQ,CACNwB,WAAY,WAStBa,EAASrI,UAAUqN,iCAAmC,SAA0CC,GAK9F1K,KAAK2K,0BAGL,IAAI5B,EAAezD,EAAmBoF,EAAUvK,UAQhDH,KAAK4K,SAAS,CACZzK,SAAUH,KAAKmI,oBAAoBuC,GAAa3B,EAAavE,KAAI,SAAUwB,GACzE,OAAO1H,EAAS,GAAI0H,EAAS,CAC3BA,QAASA,OAERhG,KAAK8I,2BAA2BC,MAGzCtD,EAASrI,UAAUkK,aAAe,SAAsBH,EAAO5C,EAAOsG,GACpE,IAAIC,EAAS9K,KAEXmD,EADmBnD,KAAKwH,aAAapC,EAAO+B,IACnBhE,QACtBA,IAULF,EAAqB,CACnBE,QAASA,EACTC,OAAQyH,IAIN7K,KAAKK,MAAMG,SAASR,KAAKK,MAAMG,QAAQ2G,EAAOhE,GAIlD4H,uBAAsB,WACpBA,uBAAsB,WAcpB,IAAI3H,EAAS,CACXwB,WAAYN,EAAuBC,EAAOuG,EAAOzK,OACjDrE,UAAW,GACXC,QAAS,IAEPkL,EAAMlB,WAAa6E,EAAOzK,MAAMiB,gBAClC8B,EAAS9E,EAAS,GAAI8E,EAAQ0H,EAAOzK,MAAMiB,gBAAgBpF,IAClDiL,EAAMS,UAAYkD,EAAOzK,MAAMmB,eACxC4B,EAAS9E,EAAS,GAAI8E,EAAQ0H,EAAOzK,MAAMmB,eAAetF,IACjDiL,EAAMW,SAAWgD,EAAOzK,MAAMoB,iBACvC2B,EAAS9E,EAAS,GAAI8E,EAAQ0H,EAAOzK,MAAMoB,eAAevF,KAI5D+G,EAAqB,CACnBE,QAASA,EACTC,OAAQA,UAIdpD,KAAKgL,yBAAyB7D,KAEhC1B,EAASrI,UAAU4N,yBAA2B,SAAkC7D,GAC9E,IAAI8D,EAASjL,KAEXmD,EADmBnD,KAAKwH,aAAapC,EAAO+B,IACnBhE,QAC3B,GAAKA,EAAL,CAuBAA,EAAQ+H,iBAAiBxG,GAfE,SAASyG,EAAqBC,GAGnDA,EAAG5M,SAAW2E,IAGlBA,EAAQf,MAAMwC,WAAa,GAG3BqG,EAAOI,mBAAmBlE,EAAOhE,GACjCA,EAAQmI,oBAAoB5G,EAAeyG,GACvChE,EAAMW,SACRmD,EAAOM,gBAAgBnG,EAAO+B,UAKpC1B,EAASrI,UAAUiO,mBAAqB,SAA4BlE,EAAOhE,GACzE,IAAIqI,EAASxL,KAMb,GALIA,KAAKK,MAAMI,UAAUT,KAAKK,MAAMI,SAAS0G,EAAOhE,GAIpDnD,KAAKsG,qBAAuB,EACK,IAA7BtG,KAAKsG,oBAA2B,CAElC,IAAIyC,EAAe/I,KAAK+F,MAAM5F,SAAS6G,QAAO,SAAUyE,GAEtD,OADcA,EAAM3D,WAEnBtD,KAAI,SAAUkH,GACf,OAAOpN,EAAS,GAAIoN,EAAM,CAExB1F,QAAS0F,EAAK1F,QACdC,WAAW,EACX2B,UAAU,OAGd5H,KAAK4K,SAAS,CACZzK,SAAU4I,IACT,WACuC,oBAA7ByC,EAAOnL,MAAMM,aACtB6K,EAAOjE,iBAAiBiE,EAAOnL,MAAMM,aAIvC6K,EAAOjF,kBAAoB,MAKzBvG,KAAKqG,sBAAsBlD,UAC7BnD,KAAKqG,sBAAsBlD,QAAQf,MAAM0B,OAAS,OAIxD2B,EAASrI,UAAUmK,iBAAmB,SAA0BoE,GAC9D,IAAIC,EAAS5L,KACT6L,EAAW,GACXC,EAAW,GACf9L,KAAKuG,kBAAkBtE,SAAQ,SAAU8J,GAGvC,IAAI5E,EAAQyE,EAAOzC,eAAe4C,GAC7B5E,IAGL0E,EAASxE,KAAKF,GACVyE,EAAOI,aAAaD,IACtBD,EAASzE,KAAKuE,EAAOpE,aAAauE,GAAU5I,aAGhDwI,EAAKE,EAAUC,IAEjBrG,EAASrI,UAAUuN,wBAA0B,WAC3C,IAAIsB,EAASjM,KAMTsK,EAAgBtK,KAAKmG,WAAWhD,QACpC,GAAKmH,EAAL,CAGAtK,KAAKmG,WAAWC,YAAcpG,KAAKK,MAAMS,YAAYwJ,GAGrD,IAAI4B,EAAwB,GAC5BlM,KAAK+F,MAAM5F,SAAS8B,SAAQ,SAAUkF,GACpC,IAAI4E,EAAW3G,EAAO+B,GAItB,GAAK4E,EAQL,GAAKE,EAAOD,aAAaD,GAAzB,CAIA,IAAI1G,EAAY4G,EAAOzE,aAAauE,GAI/B1G,EAAUlC,SAAYgE,EAI3B+E,EAAsB7E,KArsBC,SAAgCoE,GAC3D,IAAIjI,EAAeiI,EAAMjI,aACvB8G,EAAgBmB,EAAMnB,cACtBxJ,EAAc2K,EAAM3K,YAClBoD,EAAYpD,EAAYwJ,GACxB6B,EAAerL,EAAY0C,GAC7BE,EAAMyI,EAAazI,IACnBC,EAAOwI,EAAaxI,KACpBC,EAAQuI,EAAavI,MACrBC,EAASsI,EAAatI,OACtBE,EAAQoI,EAAapI,MACrBD,EAASqI,EAAarI,OACxB,MAAO,CACLJ,IAAKA,EAAMQ,EAAUR,IACrBC,KAAMA,EAAOO,EAAUP,KACvBC,MAAOM,EAAUN,MAAQA,EACzBC,OAAQK,EAAUL,OAASA,EAC3BE,MAAOA,EACPD,OAAQA,GAmrBqBsI,CAAuB,CAChD5I,aAAc6B,EAAUlC,QACxBmH,cAAeA,EACfxJ,YAAamL,EAAO5L,MAAMS,eAN1BoL,EAAsB7E,KAAK,WAR3B6E,EAAsB7E,KAAK,WAR3B6E,EAAsB7E,KAAK,SAyB/BrH,KAAK+F,MAAM5F,SAAS8B,SAAQ,SAAUkF,EAAO5C,GAC3C,IAAIwH,EAAW3G,EAAO+B,GAClBlD,EAAmBiI,EAAsB3H,GACxCwH,GAGLE,EAAOI,aAAaN,EAAU,CAC5B3F,YAAanC,SAInBwB,EAASrI,UAAUgK,qBAAuB,SAA8BD,GACtE,GAAIA,EAAMlB,UACR,OAAOjG,KAAKK,MAAMiB,gBAAkBtB,KAAKK,MAAMiB,gBAAgBvF,KAAO,GACjE,GAAIoL,EAAMS,SACf,OAAK5H,KAAKK,MAAMmB,eAKTlD,EAAS,CACd+D,SAAU,GACVqB,IAAK,GACLC,KAAM,GACNC,MAAO,GACPC,OAAQ,IACP7D,KAAKK,MAAMmB,eAAezF,MAVpB,GAWJ,GAAIoL,EAAMW,QACf,OAAO9H,KAAKK,MAAMoB,eAAiBzB,KAAKK,MAAMoB,eAAe1F,KAAO,GAEtE,IAAIsJ,EAAYrF,KAAKwH,aAAapC,EAAO+B,IACrC3D,EAAe6B,EAAUlC,QACzBc,EAAmBoB,EAAUe,YAC7BjC,EAAoBnE,KAAKmG,WAAWC,YACxC,IAAK5C,EACH,MAAO,GAET,IAAI8I,EAAqBhJ,EAAiB,CACtCE,aAAcA,EACdS,iBAAkBA,EAClBE,kBAAmBA,EACnBrD,YAAad,KAAKK,MAAMS,cAI5B,MAAO,CACL9E,UAAW,aAHNsQ,EAAmB,GAGO,OAF1BA,EAAmB,GAEqB,QAMjD7G,EAASrI,UAAU+K,oBAAsB,SAA6B9H,GAMpE,OAAO8E,GAAoB9E,EAAMQ,sBAA2C,IAAnBR,EAAMY,UAAkC,IAAhBZ,EAAMc,OAA2C,IAA5Bd,EAAMe,mBAAoD,IAAzBf,EAAMgB,gBAE/IoE,EAASrI,UAAU+L,eAAiB,SAAwBxK,GAC1D,OAAOjC,GAAK,SAAUyK,GACpB,OAAO/B,EAAO+B,KAAWxI,IACxBqB,KAAK+F,MAAM5F,WAEhBsF,EAASrI,UAAU4O,aAAe,SAAsBrN,GAGtD,OAAOxB,OAAOC,UAAUwB,eAAetB,KAAK0C,KAAKkG,aAAcvH,IAEjE8G,EAASrI,UAAUoK,aAAe,SAAsB7I,GACtD,OAAOqB,KAAKgM,aAAarN,GAAOqB,KAAKkG,aAAavH,GAAO,IAE3D8G,EAASrI,UAAUiP,aAAe,SAAsB1N,EAAK4N,GAC3DvM,KAAKkG,aAAavH,GAAOL,EAAS,GAAI0B,KAAKwH,aAAa7I,GAAM4N,IAEhE9G,EAASrI,UAAUmO,gBAAkB,SAAyB5M,UACrDqB,KAAKkG,aAAavH,GACzBqB,KAAK4K,UAAS,SAAU4B,GACtB,OAAOlO,EAAS,GAAIkO,EAAW,CAC7BrM,SAAUqM,EAAUrM,SAAS6G,QAAO,SAAUG,GAC5C,OAAOA,EAAMnB,QAAQrH,MAAQA,WAKrC8G,EAASrI,UAAUqP,wBAA0B,WAC3C,IAAIC,EAAS1M,KACTY,EAAWZ,KAAKK,MAAMO,SAOtB+L,EADgC,OAAb/L,GAAkC,OAAbA,EACH,KAAO,MAChD,OAAoB,wBAAc+L,EAAiB,CACjDhO,IAAK,qBACLiO,IAAK,SAAazJ,GAChBuJ,EAAOrG,sBAAsBlD,QAAUA,GAEzCf,MAAO,CACLyK,WAAY,SACZ/I,OAAQ,MAId2B,EAASrI,UAAU0P,iBAAmB,WACpC,IAAIC,EAAU/M,KAKd,OAAOA,KAAK+F,MAAM5F,SAASqE,KAAI,SAAU2C,GACvC,OAAoB,uBAAaA,EAAMnB,QAAS,CAC9C4G,IAAK,SAAa5G,GAGhB,GAAKA,EAAL,CAGA,IAAI7C,EA5qBM,SAAuB6C,GAEzC,GAA2B,qBAAhBW,YACT,OAAO,KAIT,GAAIX,aAAmBW,YACrB,OAAOX,EAMT,IAAIgH,EAAY,sBAAYhH,GAC5B,OAAIgH,GAAaA,EAAUC,WAAaC,KAAKC,UAEpC,KAGFH,EAwpBeI,CAAcpH,GAC5B+G,EAAQV,aAAajH,EAAO+B,GAAQ,CAClChE,QAASA,YAMnBsC,EAASrI,UAAUyF,OAAS,WAC1B,IAAIwK,EAAUrN,KACVsN,EAAUtN,KAAKK,MACjBO,EAAW0M,EAAQ1M,SACnBc,EAAY4L,EAAQ5L,UACpBD,EAAiB6L,EAAQ7L,eACzBV,EAA0BuM,EAAQvM,wBAChCZ,EAAWH,KAAK8M,mBAIpB,GAHIrL,GAAkBV,GACpBZ,EAASkH,KAAKrH,KAAKyM,4BAEhB7L,EAAU,OAAOT,EACtB,IAAIE,EAAQ/B,EAAS,GAAIoD,EAAW,CAClCvB,SAAUA,EACVyM,IAAK,SAAa7J,GAChBsK,EAAQlH,WAAWhD,QAAUJ,KAGjC,OAAoB,wBAAcnC,EAAUP,IAEvCoF,EA/oBQ,CAgpBf,cAQa,a,qBC7xCf8H,EAAOC,QAAU,IAA0B,qD,gCCA3C,kyBAASC,EAAQC,EAAGC,GAAK,IAAI3I,EAAI7H,OAAOyE,KAAK8L,GAAI,GAAIvQ,OAAOyQ,sBAAuB,CAAE,IAAIC,EAAI1Q,OAAOyQ,sBAAsBF,GAAIC,IAAME,EAAIA,EAAE7G,QAAO,SAAU2G,GAAK,OAAOxQ,OAAO2Q,yBAAyBJ,EAAGC,GAAGzO,eAAiB8F,EAAEqC,KAAKpH,MAAM+E,EAAG6I,GAAM,OAAO7I,EAC3P,SAAS+I,EAAcL,GAAK,IAAK,IAAIC,EAAI,EAAGA,EAAIlP,UAAU3B,OAAQ6Q,IAAK,CAAE,IAAI3I,EAAI,MAAQvG,UAAUkP,GAAKlP,UAAUkP,GAAK,GAAIA,EAAI,EAAIF,EAAQtQ,OAAO6H,IAAI,GAAI/C,SAAQ,SAAU0L,GAAKK,EAAgBN,EAAGC,EAAG3I,EAAE2I,OAAUxQ,OAAO8Q,0BAA4B9Q,OAAO+Q,iBAAiBR,EAAGvQ,OAAO8Q,0BAA0BjJ,IAAMyI,EAAQtQ,OAAO6H,IAAI/C,SAAQ,SAAU0L,GAAKxQ,OAAOgR,eAAeT,EAAGC,EAAGxQ,OAAO2Q,yBAAyB9I,EAAG2I,OAAW,OAAOD,EACnb,SAASM,EAAgBhQ,EAAKW,EAAKM,GACnC,IAAiCpC,EAD8L,OAAnL8B,EAC2B,iBAAtC9B,EACjC,SAAsBmI,EAAG2I,GAAK,GAAI,iBAAmB3I,IAAMA,EAAG,OAAOA,EAAG,IAAI0I,EAAI1I,EAAElH,OAAOsQ,aAAc,QAAI,IAAWV,EAAG,CAAE,IAAI7Q,EAAI6Q,EAAEpQ,KAAK0H,EAAG2I,GAAK,WAAY,GAAI,iBAAmB9Q,EAAG,OAAOA,EAAG,MAAM,IAAIwB,UAAU,gDAAmD,OAAQ,WAAasP,EAAIU,OAASlE,QAAQnF,GAD9QsJ,CAD4B3P,EACZ,WAAyC9B,EAAIA,EAAI,MADpBmB,EAAOb,OAAOgR,eAAenQ,EAAKW,EAAK,CAAEM,MAAOA,EAAOC,YAAY,EAAME,cAAc,EAAMD,UAAU,IAAkBnB,EAAIW,GAAOM,EAAgBjB,EAGtO,SAASuQ,EAAe3R,EAAKC,GAAK,OAKlC,SAAyBD,GAAO,GAAII,MAAMC,QAAQL,GAAM,OAAOA,EALtB4R,CAAgB5R,IAIzD,SAA+B+Q,EAAGc,GAAK,IAAIzJ,EAAI,MAAQ2I,EAAI,KAAO,oBAAsB7P,QAAU6P,EAAE7P,OAAOC,WAAa4P,EAAE,cAAe,GAAI,MAAQ3I,EAAG,CAAE,IAAI0I,EAAGgB,EAAG7R,EAAG8R,EAAGpG,EAAI,GAAIqG,GAAI,EAAIf,GAAI,EAAI,IAAM,GAAIhR,GAAKmI,EAAIA,EAAE1H,KAAKqQ,IAAIkB,KAAM,IAAMJ,EAAG,CAAE,GAAItR,OAAO6H,KAAOA,EAAG,OAAQ4J,GAAI,OAAW,OAASA,GAAKlB,EAAI7Q,EAAES,KAAK0H,IAAI8J,QAAUvG,EAAElB,KAAKqG,EAAEzO,OAAQsJ,EAAEzL,SAAW2R,GAAIG,GAAI,IAAO,MAAOjB,GAAKE,GAAI,EAAIa,EAAIf,EAAK,QAAU,IAAM,IAAKiB,GAAK,MAAQ5J,EAAE+J,SAAWJ,EAAI3J,EAAE+J,SAAU5R,OAAOwR,KAAOA,GAAI,OAAU,QAAU,GAAId,EAAG,MAAMa,GAAO,OAAOnG,GAJ7cyG,CAAsBpS,EAAKC,IAE5F,SAAqCgR,EAAGoB,GAAU,IAAKpB,EAAG,OAAQ,GAAiB,kBAANA,EAAgB,OAAOqB,EAAkBrB,EAAGoB,GAAS,IAAIP,EAAIvR,OAAOC,UAAUC,SAASC,KAAKuQ,GAAGsB,MAAM,GAAI,GAAc,WAANT,GAAkBb,EAAE5P,cAAayQ,EAAIb,EAAE5P,YAAYmR,MAAM,GAAU,QAANV,GAAqB,QAANA,EAAa,OAAO1R,MAAMjB,KAAK8R,GAAI,GAAU,cAANa,GAAqB,2CAA2CW,KAAKX,GAAI,OAAOQ,EAAkBrB,EAAGoB,GAFpTK,CAA4B1S,EAAKC,IACnI,WAA8B,MAAM,IAAIwB,UAAU,6IADuFkR,GAGzI,SAASL,EAAkBtS,EAAK4S,IAAkB,MAAPA,GAAeA,EAAM5S,EAAIE,UAAQ0S,EAAM5S,EAAIE,QAAQ,IAAK,IAAID,EAAI,EAAG4S,EAAO,IAAIzS,MAAMwS,GAAM3S,EAAI2S,EAAK3S,IAAK4S,EAAK5S,GAAKD,EAAIC,GAAI,OAAO4S,EAI5K,SAASC,IACP,IAAK,IAAI/J,EAAOlH,UAAU3B,OAAQ6S,EAAO,IAAI3S,MAAM2I,GAAOE,EAAO,EAAGA,EAAOF,EAAME,IAC/E8J,EAAK9J,GAAQpH,UAAUoH,GAEzB,OAAO,kBAAQ,IAAM9C,IACnB4M,EAAK1N,QAAQ2K,GAAOA,EAAI7J,KAG1B4M,GAIF,MAAMC,EAA8B,qBAAXhJ,QAAqD,qBAApBA,OAAO/B,UAAqE,qBAAlC+B,OAAO/B,SAAS/B,cACpH,SAAS+M,EAAS7J,GAChB,MAAM8J,EAAgB3S,OAAOC,UAAUC,SAASC,KAAK0I,GACrD,MAAyB,oBAAlB8J,GAEW,oBAAlBA,EAEF,SAASC,EAAOhN,GACd,MAAO,aAAcA,EAEvB,SAASiN,EAAUxR,GACjB,IAAIyR,EAAuBC,EAC3B,OAAK1R,EAGDqR,EAASrR,GACJA,EAEJuR,EAAOvR,IAG8H,OAAlIyR,EAA2E,OAAlDC,EAAyB1R,EAAO2R,oBAAyB,EAASD,EAAuBE,aAAuBH,EAFxIrJ,OANAA,OAUX,SAASyJ,EAAWtN,GAGlB,OAAOA,aAFYiN,EAAUjN,GACLuN,SAG1B,SAASC,EAAcxN,GACrB,OAAI8M,EAAS9M,IAGNA,aAAgBiN,EAAUjN,GAAM4D,YAEzC,SAAS6J,EAAazN,GACpB,OAAOA,aAAgBiN,EAAUjN,GAAM0N,WAEzC,SAASC,EAAiBlS,GACxB,OAAKA,EAGDqR,EAASrR,GACJA,EAAOqG,SAEXkL,EAAOvR,GAGR6R,EAAW7R,GACNA,EAEL+R,EAAc/R,IAAWgS,EAAahS,GACjCA,EAAO2R,cAETtL,SAREA,SANAA,SAsBX,MAAM8L,EAA4Bf,EAAY,kBAAkB,YAChE,SAASgB,EAASC,GAChB,MAAMC,EAAa,iBAAOD,GAI1B,OAHAF,EAA0B,KACxBG,EAAWC,QAAUF,IAEhB,uBAAY,WACjB,IAAK,IAAIlL,EAAOlH,UAAU3B,OAAQ8I,EAAO,IAAI5I,MAAM2I,GAAOE,EAAO,EAAGA,EAAOF,EAAME,IAC/ED,EAAKC,GAAQpH,UAAUoH,GAEzB,OAA6B,MAAtBiL,EAAWC,aAAkB,EAASD,EAAWC,WAAWnL,KAClE,IAEL,SAASoL,IACP,MAAMC,EAAc,iBAAO,MAU3B,MAAO,CATK,sBAAY,CAACC,EAAUjQ,KACjCgQ,EAAYF,QAAUI,YAAYD,EAAUjQ,IAC3C,IACW,sBAAY,KACI,OAAxBgQ,EAAYF,UACdK,cAAcH,EAAYF,SAC1BE,EAAYF,QAAU,OAEvB,KAGL,SAASM,EAAepS,EAAOqS,QACR,IAAjBA,IACFA,EAAe,CAACrS,IAElB,MAAMsS,EAAW,iBAAOtS,GAMxB,OALA0R,EAA0B,KACpBY,EAASR,UAAY9R,IACvBsS,EAASR,QAAU9R,IAEpBqS,GACIC,EAET,SAASC,EAAYC,EAAUH,GAC7B,MAAMC,EAAW,mBACjB,OAAO,kBAAQ,KACb,MAAMG,EAAWD,EAASF,EAASR,SAEnC,OADAQ,EAASR,QAAUW,EACZA,GAGT,IAAIJ,IAEN,SAASK,EAAWC,GAClB,MAAMC,EAAkBjB,EAASgB,GAC3B7O,EAAO,iBAAO,MACd+O,EAAa,sBAAY9L,IACzBA,IAAYjD,EAAKgO,UACA,MAAnBc,GAAmCA,EAAgB7L,EAASjD,EAAKgO,UAEnEhO,EAAKgO,QAAU/K,GAGjB,IACA,MAAO,CAACjD,EAAM+O,GAEhB,SAASC,EAAY9S,GACnB,MAAM2N,EAAM,mBAIZ,OAHA,oBAAU,KACRA,EAAImE,QAAU9R,GACb,CAACA,IACG2N,EAAImE,QAEb,IAAIiB,EAAM,GACV,SAASC,EAAYC,EAAQjT,GAC3B,OAAO,kBAAQ,KACb,GAAIA,EACF,OAAOA,EAET,MAAMkT,EAAoB,MAAfH,EAAIE,GAAkB,EAAIF,EAAIE,GAAU,EAEnD,OADAF,EAAIE,GAAUC,EACPD,EAAS,IAAMC,GACrB,CAACD,EAAQjT,IAEd,SAASmT,EAAmBC,GAC1B,OAAO,SAAUC,GACf,IAAK,IAAI3M,EAAOlH,UAAU3B,OAAQyV,EAAc,IAAIvV,MAAM2I,EAAO,EAAIA,EAAO,EAAI,GAAIE,EAAO,EAAGA,EAAOF,EAAME,IACzG0M,EAAY1M,EAAO,GAAKpH,UAAUoH,GAEpC,OAAO0M,EAAYzI,OAAO,CAAC0I,EAAaC,KACtC,MAAMC,EAAUvV,OAAOuV,QAAQD,GAC/B,IAAK,MAAMhH,KAASiH,EAAS,CAC3B,IAAInP,EAAQgL,EAAe9C,EAAO,GAClC,MAAM9M,EAAM4E,EAAM,GACZoP,EAAkBpP,EAAM,GACxBtE,EAAQuT,EAAY7T,GACb,MAATM,IACFuT,EAAY7T,GAAOM,EAAQoT,EAAWM,GAG1C,OAAOH,GACNzE,EAAc,GAAIuE,KAGzB,MAAMM,EAAmBR,EAAmB,GACtCS,EAAwBT,GAAoB,GAIlD,SAASU,EAAgBC,GACvB,IAAKA,EACH,OAAO,EAET,MACEC,EADkBhD,EAAU+C,EAAMvU,QACNwU,cAC9B,OAAOA,GAAiBD,aAAiBC,EAe3C,SAASC,EAAoBF,GAC3B,GAdF,SAAsBA,GACpB,IAAKA,EACH,OAAO,EAET,MACEG,EADkBlD,EAAU+C,EAAMvU,QACT0U,WAC3B,OAAOA,GAAcH,aAAiBG,EAQlCC,CAAaJ,GAAQ,CACvB,GAAIA,EAAMK,SAAWL,EAAMK,QAAQtW,OAAQ,CACzC,MAAMuW,EAAkBN,EAAMK,QAAQ,GAGtC,MAAO,CACLE,EAHID,EAAgBE,QAIpBC,EAHIH,EAAgBI,SAKjB,GAAIV,EAAMW,gBAAkBX,EAAMW,eAAe5W,OAAQ,CAC9D,MAAM6W,EAAwBZ,EAAMW,eAAe,GAGnD,MAAO,CACLJ,EAHIK,EAAsBJ,QAI1BC,EAHIG,EAAsBF,UAOhC,OA5CF,SAAwCV,GACtC,MAAO,YAAaA,GAAS,YAAaA,EA2CtCa,CAA+Bb,GAC1B,CACLO,EAAGP,EAAMQ,QACTC,EAAGT,EAAMU,SAGN,KAET,MAAMI,EAAmB1W,OAAO2W,OAAO,CACrCC,UAAW,CACT,SAAS/X,GACP,IAAKA,EACH,OAEF,MAAMsX,EAAItX,EAAUsX,EAClBE,EAAIxX,EAAUwX,EAChB,MAAO,gBAAkBF,EAAIU,KAAKC,MAAMX,GAAK,GAAK,QAAUE,EAAIQ,KAAKC,MAAMT,GAAK,GAAK,WAGzFU,MAAO,CACL,SAASlY,GACP,IAAKA,EACH,OAIF,MAAO,UAFQA,EAAUmY,OAEG,YADjBnY,EAAUoY,OAC8B,MAGvDC,UAAW,CACT,SAASrY,GACP,GAAKA,EAGL,MAAO,CAAC6X,EAAIE,UAAU1W,SAASrB,GAAY6X,EAAIK,MAAM7W,SAASrB,IAAYyI,KAAK,OAGnF6P,WAAY,CACVjX,SAAS6F,GACQA,EAAKqR,SAGF,IAFLrR,EAAKjC,SAEiB,MADxBiC,EAAK3C,UAKhBiU,EAAW,yIACjB,SAASC,EAAuBzO,GAC9B,OAAIA,EAAQ0O,QAAQF,GACXxO,EAEFA,EAAQ2O,cAAcH,K,iCC3OxB,SAAStS,EAAQtF,EAAKoJ,GAI3B,GAAIhJ,MAAMI,UAAU8E,QAClB,OAAOtF,EAAIsF,QAAQ8D,GAEnB,IAAK,IAAInJ,EAAI,EAAG2S,EAAM5S,EAAIE,OAAQD,EAAI2S,EAAK3S,IACzC,GAAID,EAAIC,KAAOmJ,EAAS,OAAOnJ,EAEjC,OAAQ,EAiBL,SAAS+X,EAAOhY,EAAKW,GAC1B,IAAK,IAAIV,EAAID,EAAIE,OAAS,EAAGD,GAAK,EAAGA,KAChB,IAAfU,EAAGX,EAAIC,KACTD,EAAI2M,OAAO1M,EAAG,GA4Cb,SAASgY,EAAwBC,GACtC,MAAM,IAAIC,MAAM,8BAA8BjP,OAAOgP,EAAU,MC9CjE,IAAI,EAAuB,WAKzB,SAASE,EAAQC,QACH,IAARA,IACFA,EAAM,IAURjV,KAAKkV,QAAU,GAOflV,KAAK8B,MAAQ,GAMb9B,KAAKmV,UAAY,GAOjBnV,KAAKoV,gBAAkB,MACvBpV,KAAKkV,QAAUD,EAAIC,SAAW,GAC9BlV,KAAK8B,MAAQmT,EAAInT,OAAS,GAC1B9B,KAAKmV,UAAYF,EAAII,WAAaJ,EAAIE,WAAa,GA+LrD,OAvLAH,EAAQ5X,UAAUkY,WAAa,SAAUJ,GAEvC,OADAlV,KAAKkV,QAAUA,EACRlV,MAOTgV,EAAQ5X,UAAUmY,WAAa,WAC7B,OAAOvV,KAAKkV,SAAW,IASzBF,EAAQ5X,UAAUoY,QAAU,SAAUC,EAAUC,GAG9C,OAFe1V,KAAK2V,WACXF,GAAYC,EACd1V,MAQTgV,EAAQ5X,UAAUwY,QAAU,SAAUH,GACpC,OAAOzV,KAAK2V,WAAWF,IAQzBT,EAAQ5X,UAAUyY,SAAW,SAAU/T,GAErC,OADA3E,OAAOoB,OAAOyB,KAAK2V,WAAY7T,GACxB9B,MAOTgV,EAAQ5X,UAAUuY,SAAW,WAC3B,OAAO3V,KAAK8B,QAAU9B,KAAK8B,MAAQ,KAQrCkT,EAAQ5X,UAAU0Y,SAAW,SAAUC,GACrC,OAAO/V,KAAKwV,QAAQ,QAASO,IAQ/Bf,EAAQ5X,UAAU4Y,SAAW,SAAUD,GAMrC,IALA,IAIEE,EAJEC,EAAYlW,KAAKmW,WACnBf,EAAkBpV,KAAKoV,gBACvBgB,EAAWF,EAAiBA,EAAUG,MAAMjB,GAArB,GACvBkB,EAAaP,EAASM,MAAMjB,GAEvBa,EAAWK,EAAWC,UACS,IAAhCrU,EAAQkU,EAASH,IACnBG,EAAQ/O,KAAK4O,GAIjB,OADAjW,KAAK2V,WAAkB,MAAIS,EAAQ3R,KAAK,KACjCzE,MAQTgV,EAAQ5X,UAAUoZ,YAAc,SAAUT,GAMxC,IALA,IAIES,EAJEN,EAAYlW,KAAKmW,WACnBf,EAAkBpV,KAAKoV,gBACvBgB,EAAWF,EAAiBA,EAAUG,MAAMjB,GAArB,GACvBqB,EAAgBV,EAASM,MAAMjB,GAE1BgB,EAAQtZ,SAAW0Z,EAAcC,EAAcF,UAAU,CAC9D,IAAIG,EAAMxU,EAAQkU,EAASI,IACd,IAATE,GACFN,EAAQ7M,OAAOmN,EAAK,GAIxB,OADA1W,KAAK2V,WAAkB,MAAIS,EAAQ3R,KAAK,KACjCzE,MAQTgV,EAAQ5X,UAAU+Y,SAAW,WAC3B,OAAOnW,KAAK2V,WAAkB,OAAK,IAQrCX,EAAQ5X,UAAUuZ,SAAW,SAAUZ,GACrC,OAAwE,KAAhE,IAAM/V,KAAKmW,WAAa,KAAKjU,QAAQ,IAAM6T,EAAW,MAQhEf,EAAQ5X,UAAUwZ,aAAe,SAAUC,GAEzC,OADA7W,KAAKmV,UAAY0B,EACV7W,MAQTgV,EAAQ5X,UAAU0Z,aAAe,SAAUD,GACzC,OAAO7W,KAAK4W,aAAaC,IAO3B7B,EAAQ5X,UAAU2Z,aAAe,WAC/B,OAAO/W,KAAKmV,WAAa,IAO3BH,EAAQ5X,UAAU4Z,aAAe,WAC/B,OAAOhX,KAAK+W,gBAOd/B,EAAQ5X,UAAU6Z,eAAiB,WACjC,IAAI/B,EAAUlV,KAAKuV,aACjB2B,EAAWlX,KAAKmX,gBAElB,MAAO,CAAC,IAAKjC,EADbgC,EAAWA,EAAW,IAAMA,EAAW,GACP,IAAKlX,KAAKgX,eAAgB,KAAM9B,EAAS,KAAKzQ,KAAK,KASrFuQ,EAAQ5X,UAAU+Z,cAAgB,WAChC,IAAKnX,KAAK8B,MAAO,MAAO,GACxB,IAAIA,EAAQ9B,KAAK2V,WACfyB,EAAW,GACb,IAAK,IAAI9U,KAAQR,EACXA,EAAMlD,eAAe0D,IACvB8U,EAAS/P,KAAK/E,EAAO,KAAOR,EAAMQ,GAAQ,KAG9C,OAAO8U,EAAS3S,KAAK,MAEhBuQ,EAvOkB,GC7C3B,ICXIqC,EDWA,EAAgC,WAKlC,SAASC,EAAiBrC,QACZ,IAARA,IACFA,EAAM,IAMRjV,KAAKuX,WAAY,EAKjBvX,KAAKwX,SAAW,GAKhBxX,KAAKyX,UAAY,GACjBzX,KAAKuX,UAAYtC,EAAIsC,YAAa,EAClCvX,KAAKwX,SAAWvC,EAAIuC,UAAY,GAChCxX,KAAKyX,UAAYxC,EAAIwC,WAAa,GAmHpC,OAzGAH,EAAiBla,UAAUsa,MAAQ,SAAU3S,GAC3C,OAAO,IAAI,EAAQ,CACjBmQ,QAAS,IACTpT,MAAO9B,KAAK2X,YAAY5S,GACxBsQ,UAAWrV,KAAK4X,kBAAkB7S,EAAM8S,oBAY5CP,EAAiBla,UAAUua,YAAc,SAAU5S,GACjD,IAAIjD,EAAQ,CACVgW,KAAM/S,EAAMgT,iBAEVhC,EAAW/V,KAAKgY,eAAejT,GAanC,OAZIgR,IACFjU,EAAa,MAAIiU,GAEf/V,KAAKuX,YACPzV,EAAc,OAAI,SAClBA,EAAW,IAAI,uBAEb9B,KAAKwX,UACHxX,KAAKwX,SAAS1a,QAAUkD,KAAKwX,SAAS1a,OAASiI,EAAM8S,gBAAgB/a,SACvEgF,EAAa,MAAIiD,EAAMgT,iBAGpBjW,GAsBTwV,EAAiBla,UAAU4a,eAAiB,SAAUjT,GACpD,IAAI0S,EAAYzX,KAAKyX,UACrB,GAAKA,EAEE,CAGL,IAFA,IAAIQ,EAAgB,CAACR,GACnBS,EAAmBnT,EAAMoT,sBAClBtb,EAAI,EAAG2S,EAAM0I,EAAiBpb,OAAQD,EAAI2S,EAAK3S,IACtDob,EAAc5Q,KAAKoQ,EAAY,IAAMS,EAAiBrb,IAExD,OAAOob,EAAcxT,KAAK,KAP1B,MAAO,IAmBX6S,EAAiBla,UAAUwa,kBAAoB,SAAUQ,GAEvD,OADAA,EAAapY,KAAKqY,WAAWD,IAc/Bd,EAAiBla,UAAUib,WAAa,SAAUD,GAChD,IAAIZ,EAAWxX,KAAKwX,SACpB,IAAKA,IAAaA,EAAS1a,OAAQ,OAAOsb,EAC1C,IAAIE,EAAiBd,EAAS1a,OAC5Byb,EAAmBf,EAASgB,SAC9B,MAAyB,UAArBD,EEvJD,SAAuBE,EAAKC,EAAaC,GAC9C,IAAIC,EACAC,EACiB,MAAjBF,GACFA,EAAgB,WAChBE,EAAiB,EACjBD,EAA8B,IAE9BC,EAAiBF,EAAc7b,OAC/B8b,EAA8BD,EAAc7b,QAE9C,IA+BIgc,EAAW,SAAUC,GACvB,IAAIN,EAAM,GAgBV,OAfIM,EAAOC,QAAUD,EAAOE,OAC1BR,GAAOM,EAAOC,OAAS,OAErBD,EAAOE,OACTR,GAAOM,EAAOE,MAEZF,EAAOG,OACTT,GAAO,IAAMM,EAAOG,MAElBH,EAAOI,QACTV,GAAO,IAAMM,EAAOI,OAElBJ,EAAOK,WACTX,GAAO,IAAMM,EAAOK,UAEfX,GAELY,EAAe,SAAUC,EAASC,GACpC,IAAIC,EAA+BD,EAA2B,EAC5DE,EAAczF,KAAK0F,KAAKF,GACxBG,GAAa,EAAI3F,KAAK4F,MAAMJ,GAC5BK,EAAM,GAIR,OAHIF,EAAY,IACdE,EAAMP,EAAQQ,OAAOH,IAEhBL,EAAQQ,OAAO,EAAGL,GAAed,EAAgBkB,GAE1D,GAAIpB,EAAI3b,QAAU4b,EAChB,OAAOD,EAET,IAAIsB,EAAkBrB,EAAcG,EAChCE,EAhEY,SAAUN,GAExB,IAAIM,EAAS,GACTiB,EAASvB,EACT1T,EAAQiV,EAAOjV,MAAM,mBAyBzB,OAxBIA,IACFgU,EAAOC,OAASjU,EAAM,GACtBiV,EAASA,EAAOF,OAAO/U,EAAM,GAAGjI,UAElCiI,EAAQiV,EAAOjV,MAAM,6BAEnBgU,EAAOE,KAAOlU,EAAM,GACpBiV,EAASA,EAAOF,OAAO/U,EAAM,GAAGjI,UAElCiI,EAAQiV,EAAOjV,MAAM,4BAEnBgU,EAAOG,KAAOnU,EAAM,GACpBiV,EAASA,EAAOF,OAAO/U,EAAM,GAAGjI,UAElCiI,EAAQiV,EAAOjV,MAAM,yBAEnBgU,EAAOI,MAAQpU,EAAM,GACrBiV,EAASA,EAAOF,OAAO/U,EAAM,GAAGjI,UAElCiI,EAAQiV,EAAOjV,MAAM,gBAEnBgU,EAAOK,SAAWrU,EAAM,IAGnBgU,EAmCIkB,CAAUxB,GAEvB,GAAIM,EAAOI,MAAO,CAChB,IAAIe,EAAanB,EAAOI,MAAMpU,MAAM,4BAChCmV,IAEFnB,EAAOI,MAAQJ,EAAOI,MAAMW,OAAO,EAAGI,EAAW,GAAGpd,QACpD2b,EAAMK,EAASC,IAGnB,GAAIN,EAAI3b,QAAU4b,EAChB,OAAOD,EAMT,GAJIM,EAAOE,OACTF,EAAOE,KAAOF,EAAOE,KAAKtb,QAAQ,SAAU,IAC5C8a,EAAMK,EAASC,IAEbN,EAAI3b,QAAU4b,EAChB,OAAOD,EAGT,IAAI/a,EAAM,GAIV,GAHIqb,EAAOE,OACTvb,GAAOqb,EAAOE,MAEZvb,EAAIZ,QAAUid,EAChB,OAAIhB,EAAOE,KAAKnc,QAAU4b,GAChBK,EAAOE,KAAKa,OAAO,EAAGpB,EAAcG,GAAkBF,GAAemB,OAAO,EAAGC,EAAkBnB,GAEpGS,EAAa3b,EAAKqc,GAAiBD,OAAO,EAAGC,EAAkBnB,GAExE,IAAIuB,EAAe,GAOnB,GANIpB,EAAOG,OACTiB,GAAgB,IAAMpB,EAAOG,MAE3BH,EAAOI,QACTgB,GAAgB,IAAMpB,EAAOI,OAE3BgB,EAAc,CAChB,IAAKzc,EAAMyc,GAAcrd,QAAUid,EACjC,OAAKrc,EAAMyc,GAAcrd,QAAU4b,GACzBhb,EAAMyc,GAAcL,OAAO,EAAGpB,IAGhChb,EAAM2b,EAAac,EADIJ,EAAkBrc,EAAIZ,SACegd,OAAO,EAAGC,EAAkBnB,GAEhGlb,GAAOyc,EAGX,GAAIpB,EAAOK,SAAU,CACnB,IAAIA,EAAW,IAAML,EAAOK,SAC5B,IAAK1b,EAAM0b,GAAUtc,QAAUid,EAC7B,OAAKrc,EAAM0b,GAAUtc,QAAU4b,GACrBhb,EAAM0b,GAAUU,OAAO,EAAGpB,IAG5Bhb,EAAM2b,EAAaD,EADKW,EAAkBrc,EAAIZ,SACWgd,OAAO,EAAGC,EAAkBnB,GAE7Flb,GAAO0b,EAGX,GAAIL,EAAOC,QAAUD,EAAOE,KAAM,CAChC,IAAID,EAASD,EAAOC,OAAS,MAC7B,IAAKtb,EAAMsb,GAAQlc,OAASid,EAC1B,OAAQf,EAAStb,GAAKoc,OAAO,EAAGpB,GAGpC,GAAIhb,EAAIZ,QAAU4b,EAChB,OAAOhb,EAET,IAAImc,EAAM,GAIV,OAHIE,EAAkB,IACpBF,EAAMnc,EAAIoc,QAAQ,EAAI9F,KAAK4F,MAAMG,EAAkB,MAE7Crc,EAAIoc,OAAO,EAAG9F,KAAK0F,KAAKK,EAAkB,IAAMpB,EAAgBkB,GAAKC,OAAO,EAAGC,EAAkBnB,GFG9FwB,CAAchC,EAAYE,GACH,WAArBC,EG1JR,SAAwBE,EAAKC,EAAaC,GAC/C,GAAIF,EAAI3b,QAAU4b,EAChB,OAAOD,EAET,IAAIG,EACAC,EACiB,MAAjBF,GACFA,EAAgB,WAChBC,EAA8B,EAC9BC,EAAiB,IAEjBD,EAA8BD,EAAc7b,OAC5C+b,EAAiBF,EAAc7b,QAEjC,IAAIid,EAAkBrB,EAAcG,EAChCgB,EAAM,GAIV,OAHIE,EAAkB,IACpBF,EAAMpB,EAAIqB,QAAQ,EAAI9F,KAAK4F,MAAMG,EAAkB,MAE7CtB,EAAIqB,OAAO,EAAG9F,KAAK0F,KAAKK,EAAkB,IAAMpB,EAAgBkB,GAAKC,OAAO,EAAGC,EAAkBnB,GHwI9FyB,CAAejC,EAAYE,GI7JjC,SAAqBF,EAAYM,EAAaC,GACnD,ONgBK,SAAkBjb,EAAKgb,EAAaC,GACzC,IAAIE,EAUJ,OATInb,EAAIZ,OAAS4b,IACM,MAAjBC,GACFA,EAAgB,WAChBE,EAAiB,GAEjBA,EAAiBF,EAAc7b,OAEjCY,EAAMA,EAAI4c,UAAU,EAAG5B,EAAcG,GAAkBF,GAElDjb,EM3BA6c,CAASnC,EAAYM,EAAaC,GJ8J9B6B,CAAYpC,EAAYE,IAG5BhB,EA7I2B,GKChCmD,EAAqB,WAOvB,SAASA,EAAMxF,GAQbjV,KAAK0a,qBAAuB,KAM5B1a,KAAK2a,YAAc,GAMnB3a,KAAK4a,OAAS,EACd5a,KAAK6a,WAAa5F,EAAI4F,WACtB7a,KAAK2a,YAAc1F,EAAI0F,YACvB3a,KAAK4a,OAAS3F,EAAI2F,OA0FpB,OAnFAH,EAAMrd,UAAU0d,eAAiB,WAC/B,OAAO9a,KAAK2a,aAcdF,EAAMrd,UAAU2d,UAAY,SAAUH,GACpC5a,KAAK4a,OAASA,GAQhBH,EAAMrd,UAAU4d,UAAY,WAC1B,OAAOhb,KAAK4a,QAuBdH,EAAMrd,UAAU+a,oBAAsB,WACpC,MAAO,CAACnY,KAAKib,YA+BfR,EAAMrd,UAAU8d,SAAW,WACzB,OAAOlb,KAAK6a,WAAWnD,MAAM1X,OAExBya,EAxHgB,G,QCrBrB,EAA0B,SAAUU,GAOtC,SAASC,EAAWnG,GAClB,IAAIvP,EAAQyV,EAAO7d,KAAK0C,KAAMiV,IAAQjV,KAQtC,OAFA0F,EAAM2V,MAAQ,GACd3V,EAAM2V,MAAQpG,EAAIoG,MACX3V,EAmCT,OAlDA,oBAAU0V,EAAYD,GAuBtBC,EAAWhe,UAAU6d,QAAU,WAC7B,MAAO,SAOTG,EAAWhe,UAAUke,SAAW,WAC9B,OAAOtb,KAAKqb,OAOdD,EAAWhe,UAAU2a,cAAgB,WACnC,MAAO,UAAY/X,KAAKqb,OAO1BD,EAAWhe,UAAUya,cAAgB,WACnC,OAAO7X,KAAKqb,OAEPD,EAnDqB,CAoD5BX,GClDE,EAA4B,SAAUU,GAOxC,SAASI,EAAatG,GACpB,IAAIvP,EAAQyV,EAAO7d,KAAK0C,KAAMiV,IAAQjV,KAgBtC,OATA0F,EAAM8V,YAAc,GAMpB9V,EAAM+V,QAAU,GAChB/V,EAAM8V,YAAcvG,EAAIuG,YACxB9V,EAAM+V,QAAUxG,EAAIwG,QACb/V,EA0DT,OAjFA,oBAAU6V,EAAcJ,GA+BxBI,EAAane,UAAU6d,QAAU,WAC/B,MAAO,WAQTM,EAAane,UAAUse,eAAiB,WACtC,OAAO1b,KAAKwb,aAOdD,EAAane,UAAUue,WAAa,WAClC,OAAO3b,KAAKyb,SAOdF,EAAane,UAAU2a,cAAgB,WACrC,IAAIyD,EAAcxb,KAAKwb,YACrBC,EAAUzb,KAAKyb,QACjB,OAAQD,GACN,IAAK,UACH,MAAO,+BAAiCC,EAC1C,IAAK,WACH,MAAO,oCAAsCA,EAC/C,IAAK,YACH,MAAO,sCAAwCA,EACjD,IAAK,SACH,MAAO,8BAAgCA,EACzC,QAEE,MAAM,IAAI1G,MAAM,6CAA+CyG,KAQrED,EAAane,UAAUya,cAAgB,WACrC,MAAO,IAAM7X,KAAKyb,SAEbF,EAlFuB,CAmF9Bd,GCrFE,EAA4B,SAAUU,GAOxC,SAASS,EAAa3G,GACpB,IAAIvP,EAAQyV,EAAO7d,KAAK0C,KAAMiV,IAAQjV,KAgBtC,OATA0F,EAAM8V,YAAc,UAMpB9V,EAAMmW,QAAU,GAChBnW,EAAMmW,QAAU5G,EAAI4G,QACpBnW,EAAM8V,YAAcvG,EAAIuG,YACjB9V,EAuET,OA9FA,oBAAUkW,EAAcT,GA+BxBS,EAAaxe,UAAU6d,QAAU,WAC/B,MAAO,WAOTW,EAAaxe,UAAU0e,WAAa,WAClC,OAAO9b,KAAK6b,SAQdD,EAAaxe,UAAUse,eAAiB,WACtC,OAAO1b,KAAKwb,aAOdI,EAAaxe,UAAU2a,cAAgB,WACrC,OAAQ/X,KAAKwb,aACX,IAAK,UACH,MAAO,uBAAyBxb,KAAK6b,QACvC,IAAK,YACH,MAAO,yBAA2B7b,KAAK6b,QACzC,IAAK,aACH,MAAO,0BAA4B7b,KAAK6b,QAC1C,IAAK,SACH,MAAO,2BAA6B7b,KAAK6b,QAC3C,QAEE,MAAM,IAAI9G,MAAM,6CAA+C/U,KAAKwb,eAQ1EI,EAAaxe,UAAUya,cAAgB,WACrC,MAAO,IAAM7X,KAAK6b,SASpBD,EAAaxe,UAAU+a,oBAAsB,WAC3C,IAAID,EAAmBiD,EAAO/d,UAAU+a,oBAAoB7a,KAAK0C,MAC/Dwb,EAAcxb,KAAK0b,iBAIrB,OAHIF,GACFtD,EAAiB7Q,KAAKmU,GAEjBtD,GAEF0D,EA/FuB,CAgG9BnB,GC9FE,EAA0B,SAAUU,GAOtC,SAASY,EAAW9G,GAClB,IAAIvP,EAAQyV,EAAO7d,KAAK0C,KAAMiV,IAAQjV,KAsBtC,OAbA0F,EAAMsW,OAAS,GAUftW,EAAMuW,UAAW,EACjBvW,EAAMsW,OAAS/G,EAAI+G,OACnBtW,EAAMuW,SAAWhH,EAAIgH,SACdvW,EAiDT,OA9EA,oBAAUqW,EAAYZ,GAqCtBY,EAAW3e,UAAU6d,QAAU,WAC7B,MAAO,SAUTc,EAAW3e,UAAU8e,eAAiB,WACpC,OAAOlc,KAAKgc,QAUdD,EAAW3e,UAAU+e,UAAY,WAC/B,OAAOnc,KAAKkc,kBAOdH,EAAW3e,UAAU2a,cAAgB,WACnC,MAAO,QAAU/X,KAAKic,SAAW,IAAM,IAAMjc,KAAKgc,QAOpDD,EAAW3e,UAAUya,cAAgB,WACnC,OAAO7X,KAAK2a,aAEPoB,EA/EqB,CAgF5BtB,GClFE,EAAwB,SAAUU,GAOpC,SAASiB,EAASnH,GAChB,IAAIvP,EAAQyV,EAAO7d,KAAK0C,KAAMiV,IAAQjV,KAwFtC,OAlFA0F,EAAM+S,IAAM,GASZ/S,EAAM2W,aAAe,SAOrB3W,EAAM4W,kBAAmB,EAQzB5W,EAAM6W,uBAAwB,EAM9B7W,EAAM8W,YAAc,CAClBxD,QAAQ,EACRyD,KAAK,GAMP/W,EAAMgX,oBAAqB,EAK3BhX,EAAMiX,uBAAwB,EAQ9BjX,EAAMkX,kBAAoB,mBAO1BlX,EAAMmX,eAAiB,2BAQvBnX,EAAMoX,sBAAwB,QAQ9BpX,EAAMqX,mBAAoB,EAC1BrX,EAAM2W,aAAepH,EAAIoH,aACzB3W,EAAM+S,IAAMxD,EAAIwD,IAChB/S,EAAM4W,iBAAmBrH,EAAIqH,iBAC7B5W,EAAM6W,sBAAwBtH,EAAIsH,sBAClC7W,EAAM8W,YAAcvH,EAAIuH,YACxB9W,EAAMgX,mBAAqBzH,EAAIyH,mBAC/BhX,EAAMiX,sBAAwB1H,EAAI0H,sBAC3BjX,EAuJT,OAtPA,oBAAU0W,EAAUjB,GAuGpBiB,EAAShf,UAAU6d,QAAU,WAC3B,MAAO,OAaTmB,EAAShf,UAAU4f,gBAAkB,WACnC,OAAOhd,KAAKqc,cAQdD,EAAShf,UAAU6f,OAAS,WAC1B,IAAIxE,EAAMzY,KAAKyY,IAMf,OAJKzY,KAAKuc,uBAA0Bvc,KAAKsc,kBAAqBtc,KAAK+c,oBACjEtE,EAAMzY,KAAKyY,IAAM,UAAYA,EAC7BzY,KAAK+c,mBAAoB,GAEpBtE,GAOT2D,EAAShf,UAAU2a,cAAgB,WAEjC,OADU/X,KAAKid,SACJtf,QAAQ,SAAU,MAO/Bye,EAAShf,UAAUya,cAAgB,WACjC,IAAIO,EAAapY,KAAK8a,iBAiBtB,OAhBI9a,KAAKuc,wBAEPnE,EAAapY,KAAKkd,4BAA4B9E,IAE5CpY,KAAKwc,YAAYxD,SACnBZ,EAAapY,KAAKmd,kBAAkB/E,IAElCpY,KAAKwc,YAAYC,MACnBrE,EAAapY,KAAKod,eAAehF,IAE/BpY,KAAK0c,qBACPtE,EAAapY,KAAKqd,oBAAoBjF,IAEpCpY,KAAK2c,wBACPvE,EAAapY,KAAKsd,sBAAsBlF,IAEnCA,GAaTgE,EAAShf,UAAU+f,kBAAoB,SAAU1E,GAC/C,OAAOA,EAAI9a,QAAQqC,KAAK4c,kBAAmB,KAU7CR,EAAShf,UAAUggB,eAAiB,SAAU3E,GAC5C,OAAOA,EAAI9a,QAAQqC,KAAK6c,eAAgB,OAU1CT,EAAShf,UAAU8f,4BAA8B,SAAUK,GACzD,OAAOA,EAAK5f,QAAQqC,KAAK8c,sBAAuB,KAUlDV,EAAShf,UAAUigB,oBAAsB,SAAUjF,GAIjD,MAHiD,MAA7CA,EAAWoF,OAAOpF,EAAWtb,OAAS,KACxCsb,EAAaA,EAAWjJ,MAAM,GAAI,IAE7BiJ,GAYTgE,EAAShf,UAAUkgB,sBAAwB,SAAUlF,GAInD,IAAIqF,EAA+BrF,EAAWza,QAAQ,QAAS,UAC9DA,QAAQ,QAAS,SACjBA,QAAQ,QAAS,SACjBA,QAAQ,QAAS,QACjBA,QAAQ,QAAS,QAClB,IAEE,OAAO+f,mBAAmBD,GAC1B,MAAO/P,GAEP,OAAO+P,IAGJrB,EAvPmB,CAwP1B3B,GCxPEkD,EAMF,SAAiB1I,GAQfjV,KAAK0a,qBAAuB,KAC5B1a,KAAK6a,WAAa5F,EAAI4F,YCff+C,EAAW,WAIXC,EAAU,OAIVC,EAAa,OAIbC,EAAe,KAIfC,EAAU,OAKVC,EAAiB,kBA0BjBC,EAAgB,4sIAA4sIxf,OAwC5tIyf,EAAwBD,EAnCb,4eAA4exf,OAyB5e,0hEAA0hEA,OAmCriE0f,EAAoB,0dAA0d1f,OAS9e2f,EAAuBF,EAAwBC,EAU/CE,EAA+BH,EAAwBC,EAKvDG,EAA6B,IAAIC,OAAO,IAAI1Y,OAAOwY,EAA8B,MAExFG,EAAQ,OAASL,EAAoB,iBAAmBA,EAAoB,SAG5EM,EAAiB,IAAMJ,EAA+B,QAAUA,EAA+B,eAAiBA,EAA+B,MAC/IK,EAAoB,SAAUC,GAChC,MAAO,OAASF,EAAiB,OAASE,GAOjCC,EAAmB,SAAUD,GACtC,MAAO,MAAQD,EAAkBC,GAAS,SAAWD,EAAkBC,EAAQ,GAAK,YAAcH,EAAQ,KAWjGK,GALkB,IAAIN,OAAO,IAAMF,EAA+B,UAAYA,EAA+B,QAKvFC,GC1KtBQ,EAAW,s/ZCWlB,EAAqB,IAAIP,OAAO,IAAI1Y,OAAOwY,EAA8B,yBACzE,EAAiB,IAAIE,OAAO,IAAI1Y,OAAOiZ,EAASrgB,OAAQ,MASxD,EAA4B,SAAUyc,GAExC,SAAS6D,IACP,IAAItZ,EAAmB,OAAXyV,GAAmBA,EAAOlb,MAAMD,KAAMvB,YAAcuB,KAWhE,OANA0F,EAAMuZ,mBAAqB,EAK3BvZ,EAAMwZ,eAAiB,EAChBxZ,EA4PT,OAzQA,oBAAUsZ,EAAc7D,GAkBxB6D,EAAa5hB,UAAU+hB,aAAe,SAAU5B,GAuB9C,IAtBA,IAAI1C,EAAa7a,KAAK6a,WACpBoE,EAAqBjf,KAAKif,mBAC1BC,EAAiBlf,KAAKkf,eACtBxK,EAAU,GACVlF,EAAM+N,EAAKzgB,OACXsiB,EAAsB,IAAIC,EAExBC,EAAoB,CACtBC,EAAG,IACHhX,EAAG,IACH1L,EAAG,IACH4R,EAAG,IACHzJ,EAAG,IACH6I,EAAG,KAED2R,EAAU,EACZzZ,EAAQ,EACR0Z,EAAoBL,EAKfI,EAAUhQ,GAAK,CACpB,IAAIkQ,EAAOnC,EAAKC,OAAOgC,GAKvB,OAAQzZ,GACN,KAAK,EACH4Z,EAAqBD,GACrB,MACF,KAAK,EACHE,EAAYrC,EAAKC,OAAOgC,EAAU,GAAIE,GACtC,MACF,KAAK,EACHG,EAAeH,GACf,MACF,KAAK,EACHI,EAAkBJ,GAClB,MACF,KAAK,EACHK,EAAYL,GACZ,MACF,KAAK,EACHM,EAAgBN,GAChB,MACF,KAAK,EACHO,EAAkBP,GAClB,MACF,KAAK,EACHQ,EAAeR,GACf,MACF,QACE7K,EAAwB9O,GAM5ByZ,IAMF,OAHAW,IAGOzL,EAEP,SAASiL,EAAqBD,GACf,MAATA,EACFU,EAAgB,GACPnB,EAAmB5P,KAAKqQ,IACjCU,IAMJ,SAASR,EAAYS,EAAUX,GACZ,MAAbW,EAEEpB,EAAmB5P,KAAKqQ,IAC1B3Z,EAAQ,EACR0Z,EAAoB,IAAIJ,EAAkB,mBAAS,mBAAS,GAAII,GAAoB,CAClFa,iBAAiB,MAMnBC,IAEOjB,EAAkBe,KAAcX,IAGhCT,EAAmB5P,KAAKqQ,GAGjC3Z,EAAQ,EACU,MAAT2Z,EAGT3Z,EAAQ,EACU,MAAT2Z,EAGT3Z,EAAQ,EAGRwa,KAKJ,SAASV,EAAeH,GACT,MAATA,EACF3Z,EAAQ,EACU,MAAT2Z,EACT3Z,EAAQ,EACCkZ,EAAmB5P,KAAKqQ,IAIjCa,IAIJ,SAAST,EAAkBJ,GACZ,MAATA,GAIgB,MAATA,EADTa,IAKStB,EAAmB5P,KAAKqQ,GACjC3Z,EAAQ,EAGRwa,IAGJ,SAASR,EAAYL,GACfZ,EAAoBzP,KAAKqQ,GAC3B3Z,EAAQ,EAGRwa,IAGJ,SAASP,EAAgBN,GACV,MAATA,EACF3Z,EAAQ,EACU,MAAT2Z,EACT3Z,EAAQ,EACC+Y,EAAoBzP,KAAKqQ,IAKlCS,IAGJ,SAASF,EAAkBP,GACZ,MAATA,GAAyB,MAATA,EAElBS,IACSrB,EAAoBzP,KAAKqQ,GAClC3Z,EAAQ,EAGRoa,IAGJ,SAASD,EAAeR,GACT,MAATA,GAAyB,MAATA,EAElBS,IACSrB,EAAoBzP,KAAKqQ,IAClC3Z,EAAQ,EAKR0Z,EAAoB,IAAIJ,EAAkB,mBAAS,mBAAS,GAAII,GAAoB,CAClFe,cAAc,MAIhBL,IAGJ,SAASC,EAAgBK,QACN,IAAbA,IACFA,EAAW,GAEb1a,EAAQ0a,EACRhB,EAAoB,IAAIJ,EAAkB,CACxC3I,IAAK8I,IAGT,SAASe,IACPxa,EAAQ,EACR0Z,EAAoBL,EAMtB,SAASe,IACP,GAAIV,EAAkBe,aAAc,CAElC,IAAI7F,EAAc4C,EAAKpO,MAAMsQ,EAAkB/I,IAAK8I,GAKhD,QAAQnQ,KAAKsL,KACfA,EAAcA,EAAYxL,MAAM,GAAI,IAEtC,IAAIuR,EAAejB,EAAkBa,gBAAkB3F,EAAYxL,MAAM,UAAUrS,QAAU6d,GAiB/F,SAA+B+F,GAC7B,IACIC,GADkBD,EAAarK,MAAM,KAAKuK,OAAS,IACVhjB,cAE7C,OADiBshB,EAAe7P,KAAKsR,IAlBjCE,CAAsBH,IACxBhM,EAAQrN,KAAK,IAAI,EAAW,CAC1BwT,WAAYA,EACZF,YAAaA,EACbC,OAAQ6E,EAAkB/I,IAC1B2E,MAAOqF,KAIbH,MAcGvB,EA1QuB,CA2Q9BrB,GAEE0B,EACF,SAA2BpK,QACb,IAARA,IACFA,EAAM,IAERjV,KAAK0W,SAAkB3U,IAAZkT,EAAIyB,IAAoBzB,EAAIyB,KAAO,EAC9C1W,KAAKsgB,kBAAoBrL,EAAIqL,gBAC7BtgB,KAAKwgB,eAAiBvL,EAAIuL,cC5R1B,EAAiC,WACnC,SAASM,KAiJT,OAtHAA,EAAkBC,QAAU,SAAUC,EAAU1E,GAC9C,QAAIA,IAAqBtc,KAAKihB,iBAAiB3E,IAAqBtc,KAAKkhB,iCAAiCF,EAAU1E,IAEpHtc,KAAKmhB,sCAAsCH,EAAU1E,KAEpDtc,KAAKohB,iBAAiBJ,IAEvBhhB,KAAKqhB,qBAAqBL,KAK5BF,EAAkBM,iBAAmB,SAAUE,GAC7C,IAAIC,EAAW,IAAI/C,OAAOxe,KAAKwhB,qBAAqB9iB,OAASsB,KAAKyhB,QAAQ/iB,QAE1E,OAAqB,OADL4iB,EAAevc,MAAMwc,IAGvCT,EAAkBO,qBAAuB,SAAUL,GACjD,IAAIU,EAAoBV,EAIxB,OAHIhhB,KAAKwhB,qBAAqBnS,KAAK2R,KACjCU,EAAoBV,EAAS3K,MAAM,OAAO,IAErCqL,EAAkBrL,MAAM,KAAK,GAAGnU,QAAQ,OAAS,GAW1D4e,EAAkBG,iBAAmB,SAAUK,GAC7C,IAAIK,EAAoBL,EAAevc,MAAM/E,KAAK4hB,gBAChDC,EAAYF,GAAqBA,EAAkB,GAAG/jB,cACxD,MAAqB,gBAAdikB,GAA6C,cAAdA,GAuBxCf,EAAkBI,iCAAmC,SAAUF,EAAU1E,GACvE,QAAS0E,KAAc1E,IAAqBtc,KAAKwhB,qBAAqBnS,KAAKiN,MAAiD,IAA3B0E,EAAS9e,QAAQ,MAqBpH4e,EAAkBK,sCAAwC,SAAUH,EAAU1E,GAC5E,SAAI0E,IAAY1E,MACNtc,KAAKwhB,qBAAqBnS,KAAKiN,KAAsBtc,KAAK8hB,8BAA8BzS,KAAK2R,KAWzGF,EAAkBU,qBAAuB,gCASzCV,EAAkBc,eAAiB,4BAOnCd,EAAkBgB,8BAAgC,IAAItD,OAAO,aAAeN,EAAgB,KAO5F4C,EAAkBW,QAAU,2FACrBX,EAlJ4B,GdHjC,GAOAzJ,EAAiB,IAAImH,OAAO,YAAcF,EAA+B,6CAAgDA,EAA+B,uCACnJ,IAAIE,OAAO,CAAC,MAAO,IAPR,4FAOyB9f,OAAQmgB,EAAiB,GAAI,IAAK,IAAK,IAAK,QAL1E,YAK4FngB,OAAQmgB,EAAiB,GAAI,IAAK,IAAK,IAAK,QAASA,EAAiB,IAAM,MAAOE,EAASrgB,OAAQ,QAAU2f,EAAuB,KAAM,IAAK,IAAK,eAAgB,MAAQhH,EAAe3Y,OAAS,MAC5S+F,KAAK,IAAK,OAEVsd,EAAiB,IAAIvD,OAAO,IAAMF,EAA+B,KASjE,EAA0B,SAAUnD,GAOtC,SAAS6G,EAAW/M,GAClB,IAAIvP,EAAQyV,EAAO7d,KAAK0C,KAAMiV,IAAQjV,KAwEtC,OAlEA0F,EAAM8W,YAAc,CAClBxD,QAAQ,EACRyD,KAAK,GAMP/W,EAAMgX,oBAAqB,EAK3BhX,EAAMiX,uBAAwB,EAmC9BjX,EAAMuc,aAAe,EAcrBvc,EAAMqc,eAAiBA,EACvBrc,EAAM8W,YAAcvH,EAAIuH,YACxB9W,EAAMgX,mBAAqBzH,EAAIyH,mBAC/BhX,EAAMiX,sBAAwB1H,EAAI0H,sBAC3BjX,EA+LT,OA9QA,oBAAUsc,EAAY7G,GAoFtB6G,EAAW5kB,UAAU+hB,aAAe,SAAU5B,GAoF5C,IAnFA,IAMExY,EANEkd,EAAejiB,KAAKiiB,aACtBzF,EAAcxc,KAAKwc,YACnBE,EAAqB1c,KAAK0c,mBAC1BC,EAAwB3c,KAAK2c,sBAC7B9B,EAAa7a,KAAK6a,WAClBnG,EAAU,GAERwN,EAAU,WACZ,IAAIC,EAAWpd,EAAM,GACnBqd,EAAiBrd,EAAM,GACvBsd,EAActd,EAAM,GACpBud,EAA2Bvd,EAAM,GAEjCwd,EAA2Bxd,EAAM,GACjC6V,EAAS7V,EAAMR,MACfgY,EAAwB+F,GAA4BC,EACpDlC,EAAW9C,EAAKC,OAAO5C,EAAS,GAClC,IAAK,EAAkBmG,QAAQoB,EAAUC,GACvC,MAAO,WAIT,GAAIxH,EAAS,GAAkB,MAAbyF,EAChB,MAAO,WAMT,GAAIzF,EAAS,GAAK2B,GAAyBiG,EAAOT,eAAe1S,KAAKgR,GACpE,MAAO,WAWT,GANI,MAAMhR,KAAK8S,KACbA,EAAWA,EAASrI,OAAO,EAAGqI,EAASrlB,OAAS,IAK9C0lB,EAAOC,+BAA+BN,GACxCA,EAAWA,EAASrI,OAAO,EAAGqI,EAASrlB,OAAS,OAC3C,CAEL,IAAI4lB,EAAMF,EAAOG,4BAA4BR,EAAUC,GACnDM,GAAO,IACTP,EAAWA,EAASrI,OAAO,EAAG4I,IAQlC,IAAIE,EAAoB,CAAC,UAAW,YAAYlmB,MAAK,SAAUmmB,GAC7D,QAAST,IAA4D,IAA1CA,EAAelgB,QAAQ2gB,MAEpD,GAAID,EAAmB,CAIrB,IAAIE,EAAqBX,EAASjgB,QAAQ0gB,GAC1CT,EAAWA,EAASrI,OAAOgJ,GAC3BV,EAAiBA,EAAetI,OAAOgJ,GACvClI,GAAkBkI,EAEpB,IAAIzG,EAAe+F,EAAiB,SAAWC,EAAc,MAAQ,MACnE/F,IAAqB8F,EACvB1N,EAAQrN,KAAK,IAAI,EAAS,CACxBwT,WAAYA,EACZF,YAAawH,EACbvH,OAAQA,EACRyB,aAAcA,EACd5D,IAAK0J,EACL7F,iBAAkBA,EAClBC,wBAAyBA,EACzBC,YAAaA,EACbE,mBAAoBA,EACpBC,sBAAuBA,MAGvB6F,EAASxiB,KACgC,QAArC+E,EAAQkd,EAAac,KAAKxF,KAChC2E,IAEF,OAAOxN,GA4BTsN,EAAW5kB,UAAUqlB,+BAAiC,SAAUN,GAC9D,IACIa,EADAC,EAAUd,EAAS3E,OAAO2E,EAASrlB,OAAS,GAEhD,GAAgB,MAAZmmB,EACFD,EAAY,SACP,GAAgB,MAAZC,EACTD,EAAY,QACP,IAAgB,MAAZC,EAGT,OAAO,EAFPD,EAAY,IAQd,IADA,IAAIE,EAAgB,EACXrmB,EAAI,EAAG2S,EAAM2S,EAASrlB,OAAS,EAAGD,EAAI2S,EAAK3S,IAAK,CACvD,IAAI6iB,EAAOyC,EAAS3E,OAAO3gB,GACvB6iB,IAASsD,EACXE,IACSxD,IAASuD,IAClBC,EAAgBlP,KAAKmP,IAAID,EAAgB,EAAG,IAQhD,OAAsB,IAAlBA,GAoBNlB,EAAW5kB,UAAUulB,4BAA8B,SAAU3B,EAAUoB,GACrE,IAAKpB,EACH,OAAQ,EAEV,IAAIpG,EAAS,EACTwH,IACFxH,EAASoG,EAAS9e,QAAQ,KAC1B8e,EAAWA,EAAS7R,MAAMyL,IAG5B,IACIwI,EADK,IAAI5E,OAAO,eAAmBF,EAA+B,OAASA,EAA+B,SAAWA,EAA+B,OAC3IyE,KAAK/B,GAClB,OAAY,OAARoC,GACM,GAEVxI,GAAUwI,EAAI,GAAGtmB,OACjBkkB,EAAWA,EAAS7R,MAAMiU,EAAI,GAAGtmB,QAC7B,uBAAuBuS,KAAK2R,GACvBpG,GAED,IAEHoH,EA/QqB,CAgR5BrE,GezSE0F,EAAoB,IAAI7E,OAAO,KAAK1Y,OAAOwY,EAA8B,MAOzE,EAA8B,SAAUnD,GAO1C,SAASmI,EAAerO,GACtB,IAAIvP,EAAQyV,EAAO7d,KAAK0C,KAAMiV,IAAQjV,KActC,OAFA0F,EAAM8V,YAAc,UACpB9V,EAAM8V,YAAcvG,EAAIuG,YACjB9V,EAmHT,OAxIA,oBAAU4d,EAAgBnI,GA0B1BmI,EAAelmB,UAAU+hB,aAAe,SAAU5B,GAYhD,IAXA,IAAI1C,EAAa7a,KAAK6a,WAClBW,EAAcxb,KAAKwb,YACnB9G,EAAU,GACVlF,EAAM+N,EAAKzgB,OACX0iB,EAAU,EACZ+D,GAAe,EACfxd,EAAQ,EAKHyZ,EAAUhQ,GAAK,CACpB,IAAIkQ,EAAOnC,EAAKC,OAAOgC,GAKvB,OAAQzZ,GACN,KAAK,EACHyd,EAAU9D,GACV,MACF,KAAK,EACH+D,EAAwB/D,GACxB,MACF,KAAK,EACHgE,EAAqBhE,GACrB,MACF,KAAK,EACHiE,EAAqBjE,GACrB,MACF,QACE7K,EAAwB9O,GAM5ByZ,IAMF,OAHAoE,IAGOlP,EAEP,SAAS8O,EAAU9D,GACJ,MAATA,GACF3Z,EAAQ,EACRwd,EAAc/D,GACLjB,EAA2BlP,KAAKqQ,KACzC3Z,EAAQ,GASZ,SAAS0d,EAAwB/D,GAC3BnB,EAA2BlP,KAAKqQ,KAGlC3Z,EAAQ,GAIZ,SAAS2d,EAAqBhE,GAG1B3Z,EAFEsd,EAAkBhU,KAAKqQ,GAEjB,EACCnB,EAA2BlP,KAAKqQ,GACjC,EAEA,EAIZ,SAASiE,EAAqBjE,GACxB2D,EAAkBhU,KAAKqQ,KAGzBkE,IACAL,GAAe,EAEbxd,EADEwY,EAA2BlP,KAAKqQ,GAC1B,EAEA,GAOd,SAASkE,IACP,GAAIL,GAAe,GAAK/D,EAAU+D,GAAe,IAAK,CAEpD,IAAI5I,EAAc4C,EAAKpO,MAAMoU,EAAa/D,GACtCza,EAAQ,IAAI,EAAa,CAC3B8V,WAAYA,EACZF,YAAaA,EACbC,OAAQ2I,EACR/H,YAAaA,EACbC,QAASd,EAAYxL,MAAM,KAE7BuF,EAAQrN,KAAKtC,MAIZue,EAzIyB,CA0IhC3F,GAESkG,EAAkB,CAAC,UAAW,WAAY,YAAa,UC3I9DC,EAAoB,IAAItF,OAAO,GAAG1Y,OAJf,uRAIuCpH,OAAQ,KAAKoH,OAFrD,qIAE4EpH,QAAS,KAUvG,EAA4B,SAAUyc,GAExC,SAAS4I,IACP,IAAIre,EAAmB,OAAXyV,GAAmBA,EAAOlb,MAAMD,KAAMvB,YAAcuB,KAoBhE,OADA0F,EAAMuc,aAAe6B,EACdpe,EAmCT,OAzDA,oBAAUqe,EAAc5I,GA2BxB4I,EAAa3mB,UAAU+hB,aAAe,SAAU5B,GAK9C,IAJA,IAGExY,EAHEkd,EAAejiB,KAAKiiB,aACtBpH,EAAa7a,KAAK6a,WAClBnG,EAAU,GAEiC,QAArC3P,EAAQkd,EAAac,KAAKxF,KAAiB,CAEjD,IAAI5C,EAAc5V,EAAM,GACtBif,EAAcrJ,EAAYhd,QAAQ,aAAc,IAEhDse,KAAclX,EAAM,KAAMA,EAAM,IAEhCkf,EAAwB,GAAflf,EAAMR,MAAa,GAAKgZ,EAAKzD,OAAO/U,EAAMR,MAAQ,EAAG,GAC9D2f,EAAQ3G,EAAKzD,OAAO/U,EAAMR,MAAQoW,EAAY7d,OAAQ,GACtDqnB,GAAgBF,EAAOlf,MAAM,QAAUmf,EAAMnf,MAAM,MACjD/E,KAAKokB,UAAUrf,EAAM,KAAO/E,KAAKokB,UAAUzJ,IAAgBwJ,GAC7DzP,EAAQrN,KAAK,IAAI,EAAW,CAC1BwT,WAAYA,EACZF,YAAaA,EACbC,OAAQ7V,EAAMR,MACdyX,OAAQgI,EACR/H,SAAUA,KAIhB,OAAOvH,GAETqP,EAAa3mB,UAAUgnB,UAAY,SAAU7G,GAC3C,OAAOO,EAAWzO,KAAKkO,IAElBwG,EA1DuB,CA2D9BpG,GC3EE0G,EAAe,IAAI7F,OAAO,MAAM1Y,OAAOwY,EAA8B,gBAAgBxY,OAAOwY,EAA8B,MAAO,KACjIgG,EAAiB,IAAI9F,OAAO,OAAO1Y,OAAOwY,EAA8B,gBAAgBxY,OAAOwY,EAA8B,MAAO,KACpIiG,EAAkB,IAAI/F,OAAO,QAAQ1Y,OAAOwY,EAA8B,iBAAiBxY,OAAOwY,EAA8B,MAAO,KAGvIkG,EAAc,IAAIhG,OAAO,OAAO1Y,OAAOwY,EAA8B,aAAaxY,OAAOwY,EAA8B,UAAUxY,OAAOwY,EAA8B,MAAO,KAC7K,EAAmB,IAAIE,OAAO,KAAOF,EAA+B,KAOpE,EAA8B,SAAUnD,GAO1C,SAASsJ,EAAexP,GACtB,IAAIvP,EAAQyV,EAAO7d,KAAK0C,KAAMiV,IAAQjV,KAkCtC,OA1BA0F,EAAM8V,YAAc,UASpB9V,EAAMgf,eAAiB,CACrBC,QAASN,EACTO,UAAWN,EACXO,WAAYN,EACZO,OAAQN,GAWV9e,EAAMqf,iBAAmB,EACzBrf,EAAM8V,YAAcvG,EAAIuG,YACjB9V,EAoCT,OA7EA,oBAAU+e,EAAgBtJ,GA8C1BsJ,EAAernB,UAAU+hB,aAAe,SAAU5B,GAChD,IAKExY,EALEyW,EAAcxb,KAAKwb,YACrByG,EAAejiB,KAAK0kB,eAAe1kB,KAAKwb,aACxCuJ,EAAmB/kB,KAAK+kB,iBACxBlK,EAAa7a,KAAK6a,WAClBnG,EAAU,GAEZ,IAAKuN,EACH,OAAOvN,EAET,KAA6C,QAArC3P,EAAQkd,EAAac,KAAKxF,KAAiB,CACjD,IAAI3C,EAAS7V,EAAMR,MACjB8b,EAAW9C,EAAKC,OAAO5C,EAAS,GAIlC,GAAe,IAAXA,GAAgBmK,EAAiB1V,KAAKgR,GAAW,CACnD,IAAI1F,EAAc5V,EAAM,GAAGpH,QAAQ,QAAS,IAE1Cke,EAAUlB,EAAYxL,MAAM,GAC9BuF,EAAQrN,KAAK,IAAI,EAAa,CAC5BwT,WAAYA,EACZF,YAAaA,EACbC,OAAQA,EACRY,YAAaA,EACbK,QAASA,MAIf,OAAOnH,GAEF+P,EA9EyB,CA+EhC9G,GC7CK,SAASqH,GAAUnO,EAAMoO,GAiB9B,IAhBA,IA6fM1H,EA7fF2H,EAAYD,EAAGC,UACjBC,EAAaF,EAAGE,WAChBC,EAASH,EAAGG,OACZC,EAAYJ,EAAGI,UACfC,EAAYL,EAAGK,UACbC,EAAe,IAAIC,GACnBhG,EAAU,EACZhQ,EAAMqH,EAAK/Z,OACXiJ,EAAQ,EACR0f,EAAiB,EAEjBC,EAAaH,EAKR/F,EAAUhQ,GAAK,CACpB,IAAIkQ,EAAO7I,EAAK2G,OAAOgC,GAMvB,OAAQzZ,GACN,KAAK,EACH4f,EAAUjG,GACV,MACF,KAAK,EACHkG,EAAalG,GACb,MACF,KAAK,EACHmG,EAAgBnG,GAChB,MACF,KAAK,EACHoG,EAAapG,GACb,MACF,KAAK,EACHqG,EAAyBrG,GACzB,MACF,KAAK,EACHsG,EAAmBtG,GACnB,MACF,KAAK,EACHuG,EAAwBvG,GACxB,MACF,KAAK,EACHwG,EAA0BxG,GAC1B,MACF,KAAK,EACHyG,EAAgCzG,GAChC,MACF,KAAK,EACH0G,EAAgC1G,GAChC,MACF,KAAK,GACH2G,EAA4B3G,GAC5B,MACF,KAAK,GACH4G,EAA+B5G,GAC/B,MACF,KAAK,GACH6G,EAAyB7G,GACzB,MACF,KAAK,GACH8G,EAA2B9G,GAC3B,MACF,KAAK,GACH+G,EAAkB/G,GAClB,MACF,KAAK,GACHgH,EAAsBhH,GACtB,MACF,KAAK,GACHiH,EAAajH,GACb,MACF,KAAK,GACHkH,EAAoBlH,GACpB,MACF,KAAK,GACHmH,EAAgBnH,GAChB,MACF,KAAK,GACHoH,EAAoBpH,GACpB,MACF,KAAK,GACHqH,EAAarH,GACb,MACF,QACE7K,EAAwB9O,GAO5ByZ,IASF,SAASmG,EAAUjG,GACJ,MAATA,GACFsH,IAKJ,SAASpB,EAAalG,GACP,MAATA,EACF3Z,EAAQ,GACU,MAAT2Z,GACT3Z,EAAQ,EACR2f,EAAa,IAAIF,GAAW,mBAAS,mBAAS,GAAIE,GAAa,CAC7DuB,WAAW,MAEK,MAATvH,EAETsH,IACSpJ,EAASvO,KAAKqQ,IAEvB3Z,EAAQ,EACR2f,EAAa,IAAIF,GAAW,mBAAS,mBAAS,GAAIE,GAAa,CAC7DwB,WAAW,OAIbnhB,EAAQ,EACR2f,EAAaH,GAMjB,SAASO,EAAapG,GAChB3B,EAAa1O,KAAKqQ,IACpBgG,EAAa,IAAIF,GAAW,mBAAS,mBAAS,GAAIE,GAAa,CAC7DtW,KAAM+X,OAERphB,EAAQ,GACU,MAAT2Z,EAETsH,IACkB,MAATtH,GACTgG,EAAa,IAAIF,GAAW,mBAAS,mBAAS,GAAIE,GAAa,CAC7DtW,KAAM+X,OAERphB,EAAQ,IACU,MAAT2Z,GACTgG,EAAa,IAAIF,GAAW,mBAAS,mBAAS,GAAIE,GAAa,CAC7DtW,KAAM+X,OAERC,KACUxJ,EAASvO,KAAKqQ,IAAU7B,EAAQxO,KAAKqQ,IAAkB,MAATA,GAGxD2H,IAOJ,SAASxB,EAAgBnG,GACV,MAATA,EAEF2H,IACSzJ,EAASvO,KAAKqQ,GACvB3Z,EAAQ,EAGRshB,IAIJ,SAAStB,EAAyBrG,GAC5B3B,EAAa1O,KAAKqQ,KAEF,MAATA,EACT3Z,EAAQ,GACU,MAAT2Z,EACT0H,IACkB,MAAT1H,EAETsH,IACkB,MAATtH,GAAgB1B,EAAQ3O,KAAKqQ,IAASzB,EAAe5O,KAAKqQ,GAInE2H,IAGAthB,EAAQ,GAIZ,SAASigB,EAAmBtG,GACtB3B,EAAa1O,KAAKqQ,GACpB3Z,EAAQ,EACU,MAAT2Z,EACT3Z,EAAQ,GACU,MAAT2Z,EACT3Z,EAAQ,EACU,MAAT2Z,EACT0H,IACkB,MAAT1H,EAETsH,IACShJ,EAAQ3O,KAAKqQ,IAItB2H,IAMJ,SAASpB,EAAwBvG,GAC3B3B,EAAa1O,KAAKqQ,KAEF,MAATA,EACT3Z,EAAQ,GACU,MAAT2Z,EACT3Z,EAAQ,EACU,MAAT2Z,EACT0H,IACkB,MAAT1H,EAETsH,IACShJ,EAAQ3O,KAAKqQ,GAItB2H,IAGAthB,EAAQ,GAIZ,SAASmgB,EAA0BxG,GAC7B3B,EAAa1O,KAAKqQ,KAEF,MAATA,EACT3Z,EAAQ,EACU,MAAT2Z,EACT3Z,EAAQ,EACC,QAAQsJ,KAAKqQ,GAGtB2H,IACkB,MAAT3H,EAETsH,IAGAjhB,EAAQ,IAIZ,SAASogB,EAAgCzG,GAC1B,MAATA,IAEF3Z,EAAQ,IAMZ,SAASqgB,EAAgC1G,GAC1B,MAATA,IAEF3Z,EAAQ,IAMZ,SAASsgB,EAA4B3G,GAC/B3B,EAAa1O,KAAKqQ,GACpB3Z,EAAQ,EACU,MAAT2Z,EACT0H,IACkB,MAAT1H,GAETsH,IAMJ,SAASV,EAA+B5G,GAClC3B,EAAa1O,KAAKqQ,GACpB3Z,EAAQ,EACU,MAAT2Z,EACT3Z,EAAQ,GACU,MAAT2Z,EACT0H,IACkB,MAAT1H,EAETsH,KAKAjhB,EAAQ,EA0NVyZ,KAnNF,SAAS+G,EAAyB7G,GACnB,MAATA,GACFgG,EAAa,IAAIF,GAAW,mBAAS,mBAAS,GAAIE,GAAa,CAC7DuB,WAAW,KAEbG,KAEArhB,EAAQ,EAKZ,SAASygB,EAA2B9G,GACF,OAA5B7I,EAAKiD,OAAO0F,EAAS,IAEvBA,GAAW,EACXkG,EAAa,IAAIF,GAAW,mBAAS,mBAAS,GAAIE,GAAa,CAC7D4B,KAAM,aAERvhB,EAAQ,IAC2C,YAA1C8Q,EAAKiD,OAAO0F,EAAS,GAAG+H,eACjC/H,GAAW,EACXkG,EAAa,IAAIF,GAAW,mBAAS,mBAAS,GAAIE,GAAa,CAC7D4B,KAAM,aAERvhB,EAAQ,IAORshB,IAKJ,SAASZ,EAAkB/G,GACZ,MAATA,EAEF3Z,EAAQ,GACU,MAAT2Z,EAIT2H,IAGAthB,EAAQ,GAKZ,SAAS2gB,EAAsBhH,GAChB,MAATA,EAEF3Z,EAAQ,GACU,MAAT2Z,EAIT2H,IAGAthB,EAAQ,GAKZ,SAAS4gB,EAAajH,GACP,MAATA,IACF3Z,EAAQ,IAQZ,SAAS6gB,EAAoBlH,GAEzB3Z,EADW,MAAT2Z,EACM,GAGA,GAMZ,SAASmH,EAAgBnH,GACV,MAATA,EACF0H,IACkB,MAAT1H,EACT3Z,EAAQ,GACU,MAAT2Z,IAKT3Z,EAAQ,IAKZ,SAAS+gB,EAAoBpH,GACd,MAATA,EAGF3Z,EAAQ,GACU,MAAT2Z,EAET0H,IAIArhB,EAAQ,GAaZ,SAASghB,EAAarH,GACP,MAATA,EACF0H,IACkB,MAAT1H,GACTsH,IAYJ,SAASK,IACPthB,EAAQ,EACR2f,EAAaH,EAUf,SAASyB,IACPjhB,EAAQ,EACR2f,EAAa,IAAIF,GAAW,CAC1B9O,IAAK8I,IAOT,SAAS4H,IACP,IAAII,EAAgB3Q,EAAK1H,MAAMsW,EAAgBC,EAAWhP,KACtD8Q,GAIFpC,EAAOoC,EAAe/B,GAEA,YAApBC,EAAW4B,KACbjC,EAAUK,EAAWhP,KACQ,YAApBgP,EAAW4B,KACpBhC,EAAUI,EAAWhP,MAEjBgP,EAAWwB,WACbhC,EAAUQ,EAAWtW,KAAMsW,EAAWhP,KAEpCgP,EAAWuB,WAEb9B,EAAWO,EAAWtW,KAAMsW,EAAWhP,MAI3C2Q,IACA5B,EAAiBjG,EAAU,EAW7B,SAAS2H,IACP,IAAIM,EAAW/B,EAAWhP,KAAOgP,EAAWuB,UAAY,EAAI,GAC5D,OAAOpQ,EAAK1H,MAAMsY,EAAUjI,GAAS5hB,cAtanC6nB,EAAiBjG,IA4ZfjC,EAAO1G,EAAK1H,MAAMsW,EAAgBjG,GACtC4F,EAAO7H,EAAMkI,GACbA,EAAiBjG,EAAU,GAmB/B,IAAIgG,GACF,SAAoBvQ,QACN,IAARA,IACFA,EAAM,IAERjV,KAAK0W,SAAkB3U,IAAZkT,EAAIyB,IAAoBzB,EAAIyB,KAAO,EAC9C1W,KAAKsnB,KAAOrS,EAAIqS,MAAQ,MACxBtnB,KAAKoP,KAAO6F,EAAI7F,MAAQ,GACxBpP,KAAKknB,YAAcjS,EAAIiS,UACvBlnB,KAAKinB,YAAchS,EAAIgS,WCmWZ,GA5zBe,WAM5B,SAASS,EAAWzS,QACN,IAARA,IACFA,EAAM,IAORjV,KAAK2nB,QAAUD,EAAWC,QAoC1B3nB,KAAK4nB,KAAO,GAOZ5nB,KAAKqb,OAAQ,EAObrb,KAAK6nB,OAAQ,EAab7nB,KAAKyb,SAAU,EAafzb,KAAK6b,SAAU,EAMf7b,KAAKuX,WAAY,EAkCjBvX,KAAKwc,YAAc,CACjBxD,QAAQ,EACRyD,KAAK,GAWPzc,KAAK0c,oBAAqB,EAU1B1c,KAAK2c,uBAAwB,EAgD7B3c,KAAKwX,SAAW,CACd1a,OAAQ,EACR0b,SAAU,OAkBZxY,KAAKyX,UAAY,GAkBjBzX,KAAK8nB,UAAY,KAQjB9nB,KAAK+nB,aAAUhmB,EAef/B,KAAKgoB,cAAe,EAUpBhoB,KAAKioB,SAAW,KAQhBjoB,KAAK6a,WAAa,KAGlB7a,KAAK4nB,KAAO5nB,KAAKkoB,iBAAiBjT,EAAI2S,MACtC5nB,KAAKqb,MAA6B,mBAAdpG,EAAIoG,MAAsBpG,EAAIoG,MAAQrb,KAAKqb,MAC/Drb,KAAK6nB,MAA6B,mBAAd5S,EAAI4S,MAAsB5S,EAAI4S,MAAQ7nB,KAAK6nB,MAC/D7nB,KAAKyb,QAAUxG,EAAIwG,SAAWzb,KAAKyb,QACnCzb,KAAK6b,QAAU5G,EAAI4G,SAAW7b,KAAK6b,QACnC7b,KAAKuX,UAAqC,mBAAlBtC,EAAIsC,UAA0BtC,EAAIsC,UAAYvX,KAAKuX,UAC3EvX,KAAKwc,YAAcxc,KAAKmoB,wBAAwBlT,EAAIuH,aACpDxc,KAAK0c,mBAAuD,mBAA3BzH,EAAIyH,mBAAmCzH,EAAIyH,mBAAqB1c,KAAK0c,mBACtG1c,KAAK2c,sBAA6D,mBAA9B1H,EAAI0H,sBAAsC1H,EAAI0H,sBAAwB3c,KAAK2c,sBAC/G3c,KAAKgoB,aAAe/S,EAAI+S,eAAgB,EAExC,IAAInM,EAAU7b,KAAK6b,QACnB,IAAgB,IAAZA,IAA4F,IAAvE,CAAC,UAAW,YAAa,aAAc,UAAU3Z,QAAQ2Z,GAChF,MAAM,IAAI9G,MAAM,0BAA0BjP,OAAO+V,EAAS,iBAG5D,IAAIJ,EAAUzb,KAAKyb,QACnB,IAAgB,IAAZA,IAA2D,IAAtCoI,EAAgB3hB,QAAQuZ,GAC/C,MAAM,IAAI1G,MAAM,0BAA0BjP,OAAO2V,EAAS,iBAE5Dzb,KAAKwX,SAAWxX,KAAKooB,qBAAqBnT,EAAIuC,UAC9CxX,KAAKyX,UAAYxC,EAAIwC,WAAazX,KAAKyX,UACvCzX,KAAK8nB,UAAY7S,EAAI6S,WAAa9nB,KAAK8nB,UACvC9nB,KAAK+nB,QAAU9S,EAAI8S,SAAW/nB,KAugBhC,OA/eA0nB,EAAWW,KAAO,SAAUC,EAAYC,GAEtC,OADiB,IAAIb,EAAWa,GACdF,KAAKC,IAmCzBZ,EAAWc,MAAQ,SAAUF,EAAYC,GAEvC,OADiB,IAAIb,EAAWa,GACdC,MAAMF,IAY1BZ,EAAWtqB,UAAU8qB,iBAAmB,SAAUN,GAEhD,OADY,MAARA,IAAcA,GAAO,GACL,mBAATA,EACF,CACLa,cAAeb,EACfc,WAAYd,EACZe,WAAYf,GAIP,CACLa,cAA6C,mBAAvBb,EAAKa,eAA8Bb,EAAKa,cAC9DC,WAAuC,mBAApBd,EAAKc,YAA2Bd,EAAKc,WACxDC,WAAuC,mBAApBf,EAAKe,YAA2Bf,EAAKe,aAc9DjB,EAAWtqB,UAAU+qB,wBAA0B,SAAU3L,GAEvD,OADmB,MAAfA,IAAqBA,GAAc,GACZ,mBAAhBA,EACF,CACLxD,OAAQwD,EACRC,IAAKD,GAIA,CACLxD,OAAsC,mBAAvBwD,EAAYxD,QAAuBwD,EAAYxD,OAC9DyD,IAAgC,mBAApBD,EAAYC,KAAoBD,EAAYC,MAc9DiL,EAAWtqB,UAAUgrB,qBAAuB,SAAU5Q,GACpD,MAAwB,kBAAbA,EACF,CACL1a,OAAQ0a,EACRgB,SAAU,OtBziBX,SAAkBoQ,EAAMC,GAC7B,IAAK,IAAIvmB,KAAQumB,EACXA,EAAIjqB,eAAe0D,SAAwBP,IAAf6mB,EAAKtmB,KACnCsmB,EAAKtmB,GAAQumB,EAAIvmB,IAGrB,OAAOsmB,EsBuiBIE,CAAStR,GAAY,GAAI,CAC9B1a,OAAQqN,OAAO4e,kBACfvQ,SAAU,SAmChBkP,EAAWtqB,UAAUorB,MAAQ,SAAUF,GACrC,IAAI5iB,EAAQ1F,KACRgpB,EAAe,CAAC,IAAK,QAAS,UAChCC,EAAqB,EAErBvU,EAAU,GA+CZ,OA5CAsQ,GAAUsD,EAAY,CACpBpD,UAAW,SAAUhQ,GACf8T,EAAa9mB,QAAQgT,IAAY,GACnC+T,KAGJ7D,OAAQ,SAAU7H,EAAM3C,GAEtB,GAA2B,IAAvBqO,EAA0B,CAM5B,IACIC,EtB1gBP,SAAyBxrB,EAAKyrB,GACnC,IAAKA,EAAWC,OAAQ,MAAM,IAAIrU,MAAM,2CAIxC,IAHA,IAEEhQ,EAFE/C,EAAS,GACXqnB,EAAU,EAELtkB,EAAQokB,EAAWpG,KAAKrlB,IAC7BsE,EAAOqF,KAAK3J,EAAI4c,UAAU+O,EAAStkB,EAAMR,QACzCvC,EAAOqF,KAAKtC,EAAM,IAClBskB,EAAUtkB,EAAMR,MAAQQ,EAAM,GAAGjI,OAGnC,OADAkF,EAAOqF,KAAK3J,EAAI4c,UAAU+O,IACnBrnB,EsB+fiBsnB,CAAgB/L,EADC,8DAE7BgM,EAAkB3O,EACtBsO,EAAUjnB,SAAQ,SAAUunB,EAAW3sB,GAErC,GAAIA,EAAI,IAAM,EAAG,CACf,IAAI4sB,EAAkB/jB,EAAMgkB,UAAUF,EAAWD,GACjD7U,EAAQrN,KAAKpH,MAAMyU,EAAS+U,GAE9BF,GAAmBC,EAAU1sB,YAInCqoB,WAAY,SAAUjQ,GAChB8T,EAAa9mB,QAAQgT,IAAY,IACnC+T,EAAqBjV,KAAKmP,IAAI8F,EAAqB,EAAG,KAG1D5D,UAAW,SAAUzK,KACrB0K,UAAW,SAAU1K,OAKvBlG,EAAU1U,KAAK2pB,eAAejV,GAK9BA,EAAU1U,KAAK4pB,sBAAsBlV,IAcvCgT,EAAWtqB,UAAUusB,eAAiB,SAAUjV,GAE9CA,EAAQmV,MAAK,SAAUthB,EAAGC,GACxB,OAAOD,EAAEyS,YAAcxS,EAAEwS,eAG3B,IADA,IAAIne,EAAI,EACDA,EAAI6X,EAAQ5X,OAAS,GAAG,CAC7B,IAAIiI,EAAQ2P,EAAQ7X,GAClB+d,EAAS7V,EAAMiW,YACf8O,EAAoB/kB,EAAM+V,iBAAiBhe,OAC3CitB,EAASnP,EAASkP,EACpB,GAAIjtB,EAAI,EAAI6X,EAAQ5X,OAAQ,CAE1B,GAAI4X,EAAQ7X,EAAI,GAAGme,cAAgBJ,EAAQ,CACzC,IAAIoP,EAAYtV,EAAQ7X,EAAI,GAAGie,iBAAiBhe,OAASgtB,EAAoBjtB,EAAIA,EAAI,EACrF6X,EAAQnL,OAAOygB,EAAW,GAC1B,SAGF,GAAItV,EAAQ7X,EAAI,GAAGme,YAAc+O,EAAQ,CACvCrV,EAAQnL,OAAO1M,EAAI,EAAG,GACtB,UAGJA,IAEF,OAAO6X,GAoBTgT,EAAWtqB,UAAUwsB,sBAAwB,SAAUlV,GA4BrD,OA3BK1U,KAAKyb,SAAS7G,EAAOF,GAAS,SAAU3P,GAC3C,MAA2B,YAApBA,EAAMkW,aAEVjb,KAAKqb,OAAOzG,EAAOF,GAAS,SAAU3P,GACzC,MAA2B,UAApBA,EAAMkW,aAEVjb,KAAK6nB,OAAOjT,EAAOF,GAAS,SAAU3P,GACzC,MAA2B,UAApBA,EAAMkW,aAEVjb,KAAK6b,SAASjH,EAAOF,GAAS,SAAU3P,GAC3C,MAA2B,YAApBA,EAAMkW,aAEVjb,KAAK4nB,KAAKa,eACb7T,EAAOF,GAAS,SAAU6K,GACxB,MAAuB,QAAhBA,EAAEtE,WAA+C,WAAxBsE,EAAEvC,qBAGjChd,KAAK4nB,KAAKc,YACb9T,EAAOF,GAAS,SAAU6K,GACxB,MAAuB,QAAhBA,EAAEtE,WAA+C,QAAxBsE,EAAEvC,qBAGjChd,KAAK4nB,KAAKe,YACb/T,EAAOF,GAAS,SAAU6K,GACxB,MAAuB,QAAhBA,EAAEtE,WAA+C,QAAxBsE,EAAEvC,qBAG/BtI,GAuBTgT,EAAWtqB,UAAUssB,UAAY,SAAUnM,EAAM3C,QAChC,IAAXA,IACFA,EAAS,GAEXA,EAASA,GAAU,EAGnB,IAFA,IAAIqN,EAAWjoB,KAAKiqB,cAClBvV,EAAU,GACH7X,EAAI,EAAGqtB,EAAcjC,EAASnrB,OAAQD,EAAIqtB,EAAartB,IAAK,CAMnE,IALA,IAAIstB,EAAclC,EAASprB,GAAGsiB,aAAa5B,GAKlC6M,EAAI,EAAGC,EAAiBF,EAAYrtB,OAAQstB,EAAIC,EAAgBD,IACvED,EAAYC,GAAGrP,UAAUH,EAASuP,EAAYC,GAAGpP,aAEnDtG,EAAQrN,KAAKpH,MAAMyU,EAASyV,GAE9B,OAAOzV,GAoBTgT,EAAWtqB,UAAUirB,KAAO,SAAUC,GACpC,IAAKA,EACH,MAAO,GAMLtoB,KAAKgoB,eACPM,EAAaA,EAAW3qB,QAAQ,KAAM,QAAQA,QAAQ,KAAM,SAK9D,IAHA,IAAI+W,EAAU1U,KAAKwoB,MAAMF,GACvBgC,EAAU,GACVC,EAAY,EACL1tB,EAAI,EAAG2S,EAAMkF,EAAQ5X,OAAQD,EAAI2S,EAAK3S,IAAK,CAClD,IAAIkI,EAAQ2P,EAAQ7X,GACpBytB,EAAQjjB,KAAKihB,EAAWhO,UAAUiQ,EAAWxlB,EAAMiW,cACnDsP,EAAQjjB,KAAKrH,KAAKwqB,qBAAqBzlB,IACvCwlB,EAAYxlB,EAAMiW,YAAcjW,EAAM+V,iBAAiBhe,OAGzD,OADAwtB,EAAQjjB,KAAKihB,EAAWhO,UAAUiQ,IAC3BD,EAAQ7lB,KAAK,KActBijB,EAAWtqB,UAAUotB,qBAAuB,SAAUzlB,GAEpD,IAAI0lB,EAIJ,OAHIzqB,KAAK8nB,YACP2C,EAAkBzqB,KAAK8nB,UAAUxqB,KAAK0C,KAAK+nB,QAAShjB,IAEvB,kBAApB0lB,EACFA,GACsB,IAApBA,EACF1lB,EAAM+V,iBACJ2P,aAA2B,EAC7BA,EAAgBxT,iBAIPlS,EAAMmW,WACLjE,kBAUrByQ,EAAWtqB,UAAU6sB,YAAc,WACjC,GAAKjqB,KAAKioB,SAoBR,OAAOjoB,KAAKioB,SAnBZ,IAAIpN,EAAa7a,KAAK0qB,gBAClBzC,EAAW,CAAC,IAAI,EAAe,CACjCpN,WAAYA,EACZW,YAAaxb,KAAKyb,UAChB,IAAI,EAAa,CACnBZ,WAAYA,IACV,IAAI,EAAa,CACnBA,WAAYA,IACV,IAAI,EAAe,CACrBA,WAAYA,EACZW,YAAaxb,KAAK6b,UAChB,IAAI,EAAW,CACjBhB,WAAYA,EACZ2B,YAAaxc,KAAKwc,YAClBE,mBAAoB1c,KAAK0c,mBACzBC,sBAAuB3c,KAAK2c,yBAE9B,OAAO3c,KAAKioB,SAAWA,GAY3BP,EAAWtqB,UAAUstB,cAAgB,WACnC,IAAI7P,EAAa7a,KAAK6a,WAQtB,OAPKA,IACHA,EAAa7a,KAAK6a,WAAa,IAAI,EAAiB,CAClDtD,UAAWvX,KAAKuX,UAChBC,SAAUxX,KAAKwX,SACfC,UAAWzX,KAAKyX,aAGboD,GAWT6M,EAAWC,QCh5BQ,SDq5BnBD,EAAWpQ,iBAAmB,EAK9BoQ,EAAW1S,QAAU,EAKrB0S,EAAWiD,QAAU,CACnBC,MAAO,EACPC,QAAS,EACTlN,QAASA,EACTmN,QAAS,EACTC,MAAO,EACPC,IAAK,GAMPtD,EAAW3iB,MAAQ,CACjB6lB,MAAO,EACPC,QAAS,EACTpQ,MAAOA,EACPqQ,QAAS,EACTC,MAAO,EACPC,IAAK,GAEAtD,EA1zBqB,GEtHf,Q,uiBCLf,SAASnZ,EAAe3R,EAAKC,GAAK,OAKlC,SAAyBD,GAAO,GAAII,MAAMC,QAAQL,GAAM,OAAOA,EALtB4R,CAAgB5R,IAIzD,SAA+B+Q,EAAGc,GAAK,IAAIzJ,EAAI,MAAQ2I,EAAI,KAAO,oBAAsB7P,QAAU6P,EAAE7P,OAAOC,WAAa4P,EAAE,cAAe,GAAI,MAAQ3I,EAAG,CAAE,IAAI0I,EAAGgB,EAAG7R,EAAG8R,EAAGpG,EAAI,GAAIqG,GAAI,EAAIf,GAAI,EAAI,IAAM,GAAIhR,GAAKmI,EAAIA,EAAE1H,KAAKqQ,IAAIkB,KAAM,IAAMJ,EAAG,CAAE,GAAItR,OAAO6H,KAAOA,EAAG,OAAQ4J,GAAI,OAAW,OAASA,GAAKlB,EAAI7Q,EAAES,KAAK0H,IAAI8J,QAAUvG,EAAElB,KAAKqG,EAAEzO,OAAQsJ,EAAEzL,SAAW2R,GAAIG,GAAI,IAAO,MAAOjB,GAAKE,GAAI,EAAIa,EAAIf,EAAK,QAAU,IAAM,IAAKiB,GAAK,MAAQ5J,EAAE+J,SAAWJ,EAAI3J,EAAE+J,SAAU5R,OAAOwR,KAAOA,GAAI,OAAU,QAAU,GAAId,EAAG,MAAMa,GAAO,OAAOnG,GAJ7cyG,CAAsBpS,EAAKC,IAE5F,SAAqCgR,EAAGoB,GAAU,IAAKpB,EAAG,OAAQ,GAAiB,kBAANA,EAAgB,OAAOqB,EAAkBrB,EAAGoB,GAAS,IAAIP,EAAIvR,OAAOC,UAAUC,SAASC,KAAKuQ,GAAGsB,MAAM,GAAI,GAAc,WAANT,GAAkBb,EAAE5P,cAAayQ,EAAIb,EAAE5P,YAAYmR,MAAM,GAAU,QAANV,GAAqB,QAANA,EAAa,OAAO1R,MAAMjB,KAAK8R,GAAI,GAAU,cAANa,GAAqB,2CAA2CW,KAAKX,GAAI,OAAOQ,EAAkBrB,EAAGoB,GAFpTK,CAA4B1S,EAAKC,IACnI,WAA8B,MAAM,IAAIwB,UAAU,6IADuFkR,GAGzI,SAASL,EAAkBtS,EAAK4S,IAAkB,MAAPA,GAAeA,EAAM5S,EAAIE,UAAQ0S,EAAM5S,EAAIE,QAAQ,IAAK,IAAID,EAAI,EAAG4S,EAAO,IAAIzS,MAAMwS,GAAM3S,EAAI2S,EAAK3S,IAAK4S,EAAK5S,GAAKD,EAAIC,GAAI,OAAO4S,EAI5K,MAAMwb,EAAe,CACnBC,QAAS,QAEX,SAASC,EAAWjoB,GAClB,IAAIiP,EAAKjP,EAAKiP,GACZlT,EAAQiE,EAAKjE,MACf,OAAoB,IAAM6D,cAAc,MAAO,CAC7CqP,GAAIA,EACJ/P,MAAO6oB,GACNhsB,GAEL,SAASmsB,EAAWloB,GAClB,IAAIiP,EAAKjP,EAAKiP,GACZkZ,EAAenoB,EAAKmoB,aACpBC,EAAoBpoB,EAAKqoB,aACzBA,OAAqC,IAAtBD,EAA+B,YAAcA,EAc9D,OAAoB,IAAMxoB,cAAc,MAAO,CAC7CqP,GAAIA,EACJ/P,MAdqB,CACrBC,SAAU,QACV0B,MAAO,EACPD,OAAQ,EACRkG,QAAS,EACTwhB,OAAQ,EACRC,QAAS,EACTC,SAAU,SACVC,KAAM,gBACNC,SAAU,cACVC,WAAY,UAKZC,KAAM,SACN,YAAaP,EACb,eAAe,GACdF,GC1CL,MAAMU,EAAY,CAAC,aACjBC,EAAa,CAAC,KAAM,gBAAiB,aAAc,WAAY,UAAW,qBAAsB,YAAa,aAC7GC,EAAa,CAAC,SAAU,cAAe,aACzC,SAASC,EAAyBxtB,EAAQytB,GAAY,GAAc,MAAVztB,EAAgB,MAAO,GAAI,IAAkEC,EAAK9B,EAAnE2B,EACzF,SAAuCE,EAAQytB,GAAY,GAAc,MAAVztB,EAAgB,MAAO,GAAI,IAA2DC,EAAK9B,EAA5D2B,EAAS,GAAQ4tB,EAAajvB,OAAOyE,KAAKlD,GAAqB,IAAK7B,EAAI,EAAGA,EAAIuvB,EAAWtvB,OAAQD,IAAO8B,EAAMytB,EAAWvvB,GAAQsvB,EAASjqB,QAAQvD,IAAQ,IAAaH,EAAOG,GAAOD,EAAOC,IAAQ,OAAOH,EADxM6tB,CAA8B3tB,EAAQytB,GAAuB,GAAIhvB,OAAOyQ,sBAAuB,CAAE,IAAI0e,EAAmBnvB,OAAOyQ,sBAAsBlP,GAAS,IAAK7B,EAAI,EAAGA,EAAIyvB,EAAiBxvB,OAAQD,IAAO8B,EAAM2tB,EAAiBzvB,GAAQsvB,EAASjqB,QAAQvD,IAAQ,GAAkBxB,OAAOC,UAAUmvB,qBAAqBjvB,KAAKoB,EAAQC,KAAgBH,EAAOG,GAAOD,EAAOC,IAAU,OAAOH,EAEne,SAASiP,EAAQC,EAAGC,GAAK,IAAI3I,EAAI7H,OAAOyE,KAAK8L,GAAI,GAAIvQ,OAAOyQ,sBAAuB,CAAE,IAAIC,EAAI1Q,OAAOyQ,sBAAsBF,GAAIC,IAAME,EAAIA,EAAE7G,QAAO,SAAU2G,GAAK,OAAOxQ,OAAO2Q,yBAAyBJ,EAAGC,GAAGzO,eAAiB8F,EAAEqC,KAAKpH,MAAM+E,EAAG6I,GAAM,OAAO7I,EAC3P,SAAS+I,EAAcL,GAAK,IAAK,IAAIC,EAAI,EAAGA,EAAIlP,UAAU3B,OAAQ6Q,IAAK,CAAE,IAAI3I,EAAI,MAAQvG,UAAUkP,GAAKlP,UAAUkP,GAAK,GAAIA,EAAI,EAAIF,EAAQtQ,OAAO6H,IAAI,GAAI/C,SAAQ,SAAU0L,GAAKK,EAAgBN,EAAGC,EAAG3I,EAAE2I,OAAUxQ,OAAO8Q,0BAA4B9Q,OAAO+Q,iBAAiBR,EAAGvQ,OAAO8Q,0BAA0BjJ,IAAMyI,EAAQtQ,OAAO6H,IAAI/C,SAAQ,SAAU0L,GAAKxQ,OAAOgR,eAAeT,EAAGC,EAAGxQ,OAAO2Q,yBAAyB9I,EAAG2I,OAAW,OAAOD,EACnb,SAASM,EAAgBhQ,EAAKW,EAAKM,GACnC,IAAiCpC,EAD8L,OAAnL8B,EAC2B,iBAAtC9B,EACjC,SAAsBmI,EAAG2I,GAAK,GAAI,iBAAmB3I,IAAMA,EAAG,OAAOA,EAAG,IAAI0I,EAAI1I,EAAElH,OAAOsQ,aAAc,QAAI,IAAWV,EAAG,CAAE,IAAI7Q,EAAI6Q,EAAEpQ,KAAK0H,EAAG2I,GAAK,WAAY,GAAI,iBAAmB9Q,EAAG,OAAOA,EAAG,MAAM,IAAIwB,UAAU,gDAAmD,OAAQ,WAAasP,EAAIU,OAASlE,QAAQnF,GAD9QsJ,CAD4B3P,EACZ,WAAyC9B,EAAIA,EAAI,MADpBmB,EAAOb,OAAOgR,eAAenQ,EAAKW,EAAK,CAAEM,MAAOA,EAAOC,YAAY,EAAME,cAAc,EAAMD,UAAU,IAAkBnB,EAAIW,GAAOM,EAAgBjB,EAGtO,SAAS,EAAepB,EAAKC,GAAK,OAKlC,SAAyBD,GAAO,GAAII,MAAMC,QAAQL,GAAM,OAAOA,EALtB,CAAgBA,IAIzD,SAA+B+Q,EAAGc,GAAK,IAAIzJ,EAAI,MAAQ2I,EAAI,KAAO,oBAAsB7P,QAAU6P,EAAE7P,OAAOC,WAAa4P,EAAE,cAAe,GAAI,MAAQ3I,EAAG,CAAE,IAAI0I,EAAGgB,EAAG7R,EAAG8R,EAAGpG,EAAI,GAAIqG,GAAI,EAAIf,GAAI,EAAI,IAAM,GAAIhR,GAAKmI,EAAIA,EAAE1H,KAAKqQ,IAAIkB,KAAM,IAAMJ,EAAG,CAAE,GAAItR,OAAO6H,KAAOA,EAAG,OAAQ4J,GAAI,OAAW,OAASA,GAAKlB,EAAI7Q,EAAES,KAAK0H,IAAI8J,QAAUvG,EAAElB,KAAKqG,EAAEzO,OAAQsJ,EAAEzL,SAAW2R,GAAIG,GAAI,IAAO,MAAOjB,GAAKE,GAAI,EAAIa,EAAIf,EAAK,QAAU,IAAM,IAAKiB,GAAK,MAAQ5J,EAAE+J,SAAWJ,EAAI3J,EAAE+J,SAAU5R,OAAOwR,KAAOA,GAAI,OAAU,QAAU,GAAId,EAAG,MAAMa,GAAO,OAAOnG,GAJ7c,CAAsB3L,EAAKC,IAE5F,SAAqCgR,EAAGoB,GAAU,IAAKpB,EAAG,OAAQ,GAAiB,kBAANA,EAAgB,OAAO,EAAkBA,EAAGoB,GAAS,IAAIP,EAAIvR,OAAOC,UAAUC,SAASC,KAAKuQ,GAAGsB,MAAM,GAAI,GAAc,WAANT,GAAkBb,EAAE5P,cAAayQ,EAAIb,EAAE5P,YAAYmR,MAAM,GAAU,QAANV,GAAqB,QAANA,EAAa,OAAO1R,MAAMjB,KAAK8R,GAAI,GAAU,cAANa,GAAqB,2CAA2CW,KAAKX,GAAI,OAAO,EAAkBb,EAAGoB,GAFpT,CAA4BrS,EAAKC,IACnI,WAA8B,MAAM,IAAIwB,UAAU,6IADuF,GAGzI,SAAS,EAAkBzB,EAAK4S,IAAkB,MAAPA,GAAeA,EAAM5S,EAAIE,UAAQ0S,EAAM5S,EAAIE,QAAQ,IAAK,IAAID,EAAI,EAAG4S,EAAO,IAAIzS,MAAMwS,GAAM3S,EAAI2S,EAAK3S,IAAK4S,EAAK5S,GAAKD,EAAIC,GAAI,OAAO4S,EAO5K,MAAM+c,EAAiC,wBAAc,MA6BrD,MAAMC,EAAkC,CACtCC,UAAW,iNAEPC,EAAuB,CAC3BC,YAAY1pB,GAEH,4BADMA,EAAK2pB,OAC0B1a,GAAK,IAEnD,WAAW1G,GACT,IAAIohB,EAASphB,EAAMohB,OACjBC,EAAOrhB,EAAMqhB,KACf,OAAIA,EACK,kBAAoBD,EAAO1a,GAAK,kCAAoC2a,EAAK3a,GAAK,IAEhF,kBAAoB0a,EAAO1a,GAAK,wCAEzC,UAAU5O,GACR,IAAIspB,EAAStpB,EAAMspB,OACjBC,EAAOvpB,EAAMupB,KACf,OAAIA,EACK,kBAAoBD,EAAO1a,GAAK,oCAAsC2a,EAAK3a,GAE7E,kBAAoB0a,EAAO1a,GAAK,iBAEzC4a,aAAa1iB,GAEJ,0CADMA,EAAMwiB,OACuC1a,GAAK,iBAGnE,SAAS6a,EAAc9pB,GACrB,IAAI+pB,EAAqB/pB,EAAKgqB,cAC5BA,OAAuC,IAAvBD,EAAgCN,EAAuBM,EACvEE,EAAYjqB,EAAKiqB,UACjBC,EAA0BlqB,EAAKkqB,wBAC/BC,EAAwBnqB,EAAKoqB,yBAC7BA,OAAqD,IAA1BD,EAAmCZ,EAAkCY,EAClG,MAAME,EDzCR,WACE,MACEC,EAAajf,EADG,mBAAS,IACc,GACvC8c,EAAemC,EAAW,GAC1BC,EAAkBD,EAAW,GAM/B,MAAO,CACLE,SANe,sBAAYzuB,IACd,MAATA,GACFwuB,EAAgBxuB,IAEjB,IAGDosB,gBC6BuBsC,GACvBD,EAAWH,EAAiBG,SAC5BrC,EAAekC,EAAiBlC,aAC5BuC,EAAe,YAAY,iBAE/BC,EAAa,EADI,oBAAS,GACc,GACxCC,EAAUD,EAAW,GACrBE,EAAaF,EAAW,GA8C1B,GA7CA,oBAAU,KACRE,GAAW,IACV,IA1EL,SAAuB7c,GACrB,MAAM8c,EAAmB,qBAAWxB,GACpC,oBAAU,KACR,IAAKwB,EACH,MAAM,IAAIjZ,MAAM,gEAGlB,OADoBiZ,EAAiB9c,IAEpC,CAACA,EAAU8c,IAmEdC,CAAc,kBAAQ,KAAM,CAC1B,YAAYxiB,GACV,IAAIohB,EAASphB,EAAMohB,OACnBa,EAASR,EAAcN,YAAY,CACjCC,aAGJ,WAAWtpB,GACT,IAAIspB,EAAStpB,EAAMspB,OACjBC,EAAOvpB,EAAMupB,KACXI,EAAcgB,YAChBR,EAASR,EAAcgB,WAAW,CAChCrB,SACAC,WAIN,WAAWziB,GACT,IAAIwiB,EAASxiB,EAAMwiB,OACjBC,EAAOziB,EAAMyiB,KACfY,EAASR,EAAciB,WAAW,CAChCtB,SACAC,WAGJ,UAAUsB,GACR,IAAIvB,EAASuB,EAAMvB,OACjBC,EAAOsB,EAAMtB,KACfY,EAASR,EAAcmB,UAAU,CAC/BxB,SACAC,WAGJ,aAAawB,GACX,IAAIzB,EAASyB,EAAMzB,OACjBC,EAAOwB,EAAMxB,KACfY,EAASR,EAAcH,aAAa,CAClCF,SACAC,aAGF,CAACY,EAAUR,MACVY,EACH,OAAO,KAET,MAAMS,EAAsB,IAAMzrB,cAAc,IAAM0rB,SAAU,KAAmB,IAAM1rB,cAAcqoB,EAAY,CACjHhZ,GAAIib,EACJnuB,MAAOquB,EAAyBZ,YACjB,IAAM5pB,cAAcsoB,EAAY,CAC/CjZ,GAAIyb,EACJvC,aAAcA,KAEhB,OAAO8B,EAAyB,uBAAaoB,EAAQpB,GAAaoB,EAEpE,IAAIE,EAWJ,SAASC,KACT,SAASC,EAAUC,EAAQrG,GACzB,OAAO,kBAAQ,KAAM,CACnBqG,SACArG,QAAoB,MAAXA,EAAkBA,EAAU,KAGvC,CAACqG,EAAQrG,IAEX,SAASsG,IACP,IAAK,IAAIlpB,EAAOlH,UAAU3B,OAAQgyB,EAAU,IAAI9xB,MAAM2I,GAAOE,EAAO,EAAGA,EAAOF,EAAME,IAClFipB,EAAQjpB,GAAQpH,UAAUoH,GAE5B,OAAO,kBAAQ,IAAM,IAAIipB,GAAS9nB,OAAO4nB,GAAoB,MAAVA,GAEnD,IAAIE,KAzBN,SAAWL,GACTA,EAAkB,UAAI,YACtBA,EAAiB,SAAI,WACrBA,EAAgB,QAAI,UACpBA,EAAmB,WAAI,aACvBA,EAAiB,SAAI,WACrBA,EAA0B,kBAAI,oBAC9BA,EAA6B,qBAAI,uBACjCA,EAA4B,oBAAI,sBARlC,CASGA,IAAWA,EAAS,KAkBvB,MAAMM,EAAkC5xB,OAAO2W,OAAO,CACpDR,EAAG,EACHE,EAAG,IAML,SAASwb,EAAgBC,EAAIC,GAC3B,OAAOlb,KAAKmb,KAAKnb,KAAKob,IAAIH,EAAG3b,EAAI4b,EAAG5b,EAAG,GAAKU,KAAKob,IAAIH,EAAGzb,EAAI0b,EAAG1b,EAAG,IAEpE,SAAS6b,EAA2Btc,EAAOuc,GACzC,MAAMC,EAAmB,YAAoBxc,GAC7C,IAAKwc,EACH,MAAO,MAMT,OAHMA,EAAiBjc,EAAIgc,EAAK3rB,MAAQ2rB,EAAKvrB,MAAQ,IAG1B,MAFrBwrB,EAAiB/b,EAAI8b,EAAK5rB,KAAO4rB,EAAKxrB,OAAS,IAEC,IAMxD,SAAS0rB,EAAkBtsB,EAAMuI,GAG/B,OAFQvI,EAAKqJ,KAAKtN,MACVwM,EAAMc,KAAKtN,MAOrB,SAASwwB,EAAmBlsB,EAAO8G,GACjC,IAAI9B,EAAIhF,EAAMgJ,KAAKtN,MAEnB,OADQoL,EAAMkC,KAAKtN,MACRsJ,EAOb,SAASmnB,EAAmBtB,GAC1B,IAAIzqB,EAAOyqB,EAAMzqB,KACfD,EAAM0qB,EAAM1qB,IACZI,EAASsqB,EAAMtqB,OACfC,EAAQqqB,EAAMrqB,MAChB,MAAO,CAAC,CACNuP,EAAG3P,EACH6P,EAAG9P,GACF,CACD4P,EAAG3P,EAAOI,EACVyP,EAAG9P,GACF,CACD4P,EAAG3P,EACH6P,EAAG9P,EAAMI,GACR,CACDwP,EAAG3P,EAAOI,EACVyP,EAAG9P,EAAMI,IAGb,SAAS6rB,EAAkBC,EAAYrb,GACrC,IAAKqb,GAAoC,IAAtBA,EAAW9yB,OAC5B,OAAO,KAET,MACE+yB,EADkB,EAAeD,EAAY,GAChB,GAC/B,OAAOrb,EAAWsb,EAAetb,GAAYsb,EAO/C,SAASC,EAAkBR,EAAM3rB,EAAMD,GAOrC,YANa,IAATC,IACFA,EAAO2rB,EAAK3rB,WAEF,IAARD,IACFA,EAAM4rB,EAAK5rB,KAEN,CACL4P,EAAG3P,EAAoB,GAAb2rB,EAAKvrB,MACfyP,EAAG9P,EAAoB,GAAd4rB,EAAKxrB,QAQlB,MAAMisB,EAAgB7sB,IACpB,IAAI8sB,EAAgB9sB,EAAK8sB,cACvBC,EAAiB/sB,EAAK+sB,eACtBC,EAAsBhtB,EAAKgtB,oBAC7B,MAAMC,EAAaL,EAAkBE,EAAeA,EAAcrsB,KAAMqsB,EAActsB,KAChFksB,EAAa,GACnB,IAAK,MAAMQ,KAAsBF,EAAqB,CACpD,MAAM/d,EAAKie,EAAmBje,GACxBmd,EAAOW,EAAeI,IAAIle,GAChC,GAAImd,EAAM,CACR,MAAMgB,EAActB,EAAgBc,EAAkBR,GAAOa,GAC7DP,EAAWvoB,KAAK,CACd8K,KACA5F,KAAM,CACJ6jB,qBACAnxB,MAAOqxB,MAKf,OAAOV,EAAW/F,KAAK2F,IAQnBe,EAAiBrtB,IACrB,IAAI8sB,EAAgB9sB,EAAK8sB,cACvBC,EAAiB/sB,EAAK+sB,eACtBC,EAAsBhtB,EAAKgtB,oBAC7B,MAAMM,EAAUd,EAAmBM,GAC7BJ,EAAa,GACnB,IAAK,MAAMQ,KAAsBF,EAAqB,CACpD,MAAM/d,EAAKie,EAAmBje,GACxBmd,EAAOW,EAAeI,IAAIle,GAChC,GAAImd,EAAM,CACR,MAAMmB,EAAcf,EAAmBJ,GACjCoB,EAAYF,EAAQ1mB,OAAO,CAAC0I,EAAame,EAAQpsB,IAC9CiO,EAAcwc,EAAgByB,EAAYlsB,GAAQosB,GACxD,GACGC,EAAoBzmB,QAAQumB,EAAY,GAAGG,QAAQ,IACzDjB,EAAWvoB,KAAK,CACd8K,KACA5F,KAAM,CACJ6jB,qBACAnxB,MAAO2xB,MAKf,OAAOhB,EAAW/F,KAAK2F,IAOzB,SAASsB,EAAqBC,EAAOvyB,GACnC,MAAMkF,EAAMsQ,KAAKmP,IAAI3kB,EAAOkF,IAAKqtB,EAAMrtB,KACjCC,EAAOqQ,KAAKmP,IAAI3kB,EAAOmF,KAAMotB,EAAMptB,MACnCC,EAAQoQ,KAAKgd,IAAIxyB,EAAOmF,KAAOnF,EAAOuF,MAAOgtB,EAAMptB,KAAOotB,EAAMhtB,OAChEF,EAASmQ,KAAKgd,IAAIxyB,EAAOkF,IAAMlF,EAAOsF,OAAQitB,EAAMrtB,IAAMqtB,EAAMjtB,QAChEC,EAAQH,EAAQD,EAChBG,EAASD,EAASH,EACxB,GAAIC,EAAOC,GAASF,EAAMG,EAAQ,CAChC,MAAMotB,EAAazyB,EAAOuF,MAAQvF,EAAOsF,OACnCotB,EAAYH,EAAMhtB,MAAQgtB,EAAMjtB,OAChCqtB,EAAmBptB,EAAQD,EAEjC,OAAOqG,QADmBgnB,GAAoBF,EAAaC,EAAYC,IACvCN,QAAQ,IAG1C,OAAO,EAOT,MAAMO,EAAmBluB,IACvB,IAAI8sB,EAAgB9sB,EAAK8sB,cACvBC,EAAiB/sB,EAAK+sB,eACtBC,EAAsBhtB,EAAKgtB,oBAC7B,MAAMN,EAAa,GACnB,IAAK,MAAMQ,KAAsBF,EAAqB,CACpD,MAAM/d,EAAKie,EAAmBje,GACxBmd,EAAOW,EAAeI,IAAIle,GAChC,GAAImd,EAAM,CACR,MAAM+B,EAAoBP,EAAqBxB,EAAMU,GACjDqB,EAAoB,GACtBzB,EAAWvoB,KAAK,CACd8K,KACA5F,KAAM,CACJ6jB,qBACAnxB,MAAOoyB,MAMjB,OAAOzB,EAAW/F,KAAK4F,IAyDzB,SAAS6B,EAAaC,EAAOC,GAC3B,OAAOD,GAASC,EAAQ,CACtBle,EAAGie,EAAM5tB,KAAO6tB,EAAM7tB,KACtB6P,EAAG+d,EAAM7tB,IAAM8tB,EAAM9tB,KACnBqrB,EAEN,SAAS0C,EAAuBpf,GAC9B,OAAO,SAA0Bid,GAC/B,IAAK,IAAI3pB,EAAOlH,UAAU3B,OAAQyV,EAAc,IAAIvV,MAAM2I,EAAO,EAAIA,EAAO,EAAI,GAAIE,EAAO,EAAGA,EAAOF,EAAME,IACzG0M,EAAY1M,EAAO,GAAKpH,UAAUoH,GAEpC,OAAO0M,EAAYzI,OAAO,CAACC,EAAK0I,IAAe1E,EAAcA,EAAc,GAAIhE,GAAM,GAAI,CACvFrG,IAAKqG,EAAIrG,IAAM2O,EAAWI,EAAWe,EACrC3P,OAAQkG,EAAIlG,OAASwO,EAAWI,EAAWe,EAC3C7P,KAAMoG,EAAIpG,KAAO0O,EAAWI,EAAWa,EACvC1P,MAAOmG,EAAInG,MAAQyO,EAAWI,EAAWa,IACvCvF,EAAc,GAAIuhB,KAG1B,MAAMoC,EAA+BD,EAAuB,GAC5D,SAASE,EAAe31B,GACtB,GAAIA,EAAU41B,WAAW,aAAc,CACrC,MAAMC,EAAiB71B,EAAUmT,MAAM,GAAI,GAAGkH,MAAM,MACpD,MAAO,CACL/C,GAAIue,EAAe,IACnBre,GAAIqe,EAAe,IACnB1d,QAAS0d,EAAe,GACxBzd,QAASyd,EAAe,IAErB,GAAI71B,EAAU41B,WAAW,WAAY,CAC1C,MAAMC,EAAiB71B,EAAUmT,MAAM,GAAI,GAAGkH,MAAM,MACpD,MAAO,CACL/C,GAAIue,EAAe,GACnBre,GAAIqe,EAAe,GACnB1d,QAAS0d,EAAe,GACxBzd,QAASyd,EAAe,IAG5B,OAAO,KAwBT,MAAMC,EAAiB,CACrBC,iBAAiB,GAMnB,SAASC,EAAchsB,EAASuiB,QACd,IAAZA,IACFA,EAAUuJ,GAEZ,IAAIxC,EAAOtpB,EAAQhD,wBACnB,GAAIulB,EAAQwJ,gBAAiB,CAC3B,MAAME,EAAwB,YAAUjsB,GAASa,iBAAiBb,GAChEhK,EAAYi2B,EAAsBj2B,UAClCK,EAAkB41B,EAAsB51B,gBACtCL,IACFszB,EAvCN,SAA0BA,EAAMtzB,EAAWK,GACzC,MAAM61B,EAAkBP,EAAe31B,GACvC,IAAKk2B,EACH,OAAO5C,EAET,MAAMnb,EAAS+d,EAAgB/d,OAC7BC,EAAS8d,EAAgB9d,OACzB+d,EAAaD,EAAgB5e,EAC7B8e,EAAaF,EAAgB1e,EACzBF,EAAIgc,EAAK3rB,KAAOwuB,GAAc,EAAIhe,GAAUke,WAAWh2B,GACvDmX,EAAI8b,EAAK5rB,IAAM0uB,GAAc,EAAIhe,GAAUie,WAAWh2B,EAAgB8S,MAAM9S,EAAgB6F,QAAQ,KAAO,IAC3GowB,EAAIne,EAASmb,EAAKvrB,MAAQoQ,EAASmb,EAAKvrB,MACxCwuB,EAAIne,EAASkb,EAAKxrB,OAASsQ,EAASkb,EAAKxrB,OAC/C,MAAO,CACLC,MAAOuuB,EACPxuB,OAAQyuB,EACR7uB,IAAK8P,EACL5P,MAAO0P,EAAIgf,EACXzuB,OAAQ2P,EAAI+e,EACZ5uB,KAAM2P,GAoBGkf,CAAiBlD,EAAMtzB,EAAWK,IAG7C,MAAMo2B,EAAQnD,EAOd,MAAO,CACL5rB,IAPM+uB,EAAM/uB,IAQZC,KAPO8uB,EAAM9uB,KAQbI,MAPQ0uB,EAAM1uB,MAQdD,OAPS2uB,EAAM3uB,OAQfD,OAPS4uB,EAAM5uB,OAQfD,MAPQ6uB,EAAM7uB,OAmBlB,SAAS8uB,EAA+B1sB,GACtC,OAAOgsB,EAAchsB,EAAS,CAC5B+rB,iBAAiB,IAgCrB,SAASY,EAAuB3sB,EAAS4sB,GACvC,MAAMC,EAAgB,GA6BtB,OAAK7sB,EA5BL,SAAS8sB,EAAwB/vB,GAC/B,GAAa,MAAT6vB,GAAiBC,EAAc/1B,QAAU81B,EAC3C,OAAOC,EAET,IAAK9vB,EACH,OAAO8vB,EAET,GAAI,YAAW9vB,IAAkC,MAAzBA,EAAKgwB,mBAA6BF,EAAcG,SAASjwB,EAAKgwB,kBAEpF,OADAF,EAAcxrB,KAAKtE,EAAKgwB,kBACjBF,EAET,IAAK,YAAc9vB,IAAS,YAAaA,GACvC,OAAO8vB,EAET,GAAIA,EAAcG,SAASjwB,GACzB,OAAO8vB,EAET,MAAMI,EAAgB,YAAUjtB,GAASa,iBAAiB9D,GAM1D,OALIA,IAASiD,GA/BjB,SAAsBA,EAASitB,QACP,IAAlBA,IACFA,EAAgB,YAAUjtB,GAASa,iBAAiBb,IAEtD,MAAMktB,EAAgB,wBAEtB,MADmB,CAAC,WAAY,YAAa,aAC3BC,KAAK5e,IACrB,MAAMtV,EAAQg0B,EAAc1e,GAC5B,MAAwB,kBAAVtV,GAAqBi0B,EAAc7jB,KAAKpQ,KAwBhDm0B,CAAarwB,EAAMkwB,IACrBJ,EAAcxrB,KAAKtE,GAvC3B,SAAiBA,EAAMkwB,GAIrB,YAHsB,IAAlBA,IACFA,EAAgB,YAAUlwB,GAAM8D,iBAAiB9D,IAEjB,UAA3BkwB,EAAc5wB,SAsCfgxB,CAAQtwB,EAAMkwB,GACTJ,EAEFC,EAAwB/vB,EAAK2D,YAK/BosB,CAAwB9sB,GAFtB6sB,EAIX,SAASS,EAA2BvwB,GAClC,MAEEwwB,EADyB,EADGZ,EAAuB5vB,EAAM,GACM,GACd,GACnD,OAAkC,MAA3BwwB,EAAkCA,EAA0B,KAErE,SAASC,EAAqBxtB,GAC5B,OAAK,KAAcA,EAGf,YAASA,GACJA,EAEJ,YAAOA,GAGR,YAAWA,IAAYA,IAAY,YAAiBA,GAAS+sB,iBACxDnsB,OAEL,YAAcZ,GACTA,EAEF,KARE,KANA,KAgBX,SAASytB,EAAqBztB,GAC5B,OAAI,YAASA,GACJA,EAAQ0tB,QAEV1tB,EAAQ2tB,WAEjB,SAASC,EAAqB5tB,GAC5B,OAAI,YAASA,GACJA,EAAQ6tB,QAEV7tB,EAAQ8tB,UAEjB,SAASC,EAAqB/tB,GAC5B,MAAO,CACLsN,EAAGmgB,EAAqBztB,GACxBwN,EAAGogB,EAAqB5tB,IAG5B,IAAIguB,GAKJ,SAASC,GAA2BjuB,GAClC,SAAK,MAAcA,IAGZA,IAAYnB,SAASkuB,iBAE9B,SAASmB,GAAkBC,GACzB,MAAMC,EAAY,CAChB9gB,EAAG,EACHE,EAAG,GAEC6gB,EAAaJ,GAA2BE,GAAsB,CAClErwB,OAAQ8C,OAAO0tB,YACfvwB,MAAO6C,OAAO2tB,YACZ,CACFzwB,OAAQqwB,EAAmBK,aAC3BzwB,MAAOowB,EAAmBM,aAEtBC,EAAY,CAChBphB,EAAG6gB,EAAmBQ,YAAcN,EAAWtwB,MAC/CyP,EAAG2gB,EAAmBS,aAAeP,EAAWvwB,QAMlD,MAAO,CACL+wB,MALYV,EAAmBL,WAAaM,EAAU5gB,EAMtDshB,OALaX,EAAmBR,YAAcS,EAAU9gB,EAMxDyhB,SALeZ,EAAmBL,WAAaY,EAAUlhB,EAMzDwhB,QALcb,EAAmBR,YAAce,EAAUphB,EAMzDohB,YACAN,cApCJ,SAAWJ,GACTA,EAAUA,EAAmB,QAAI,GAAK,UACtCA,EAAUA,EAAoB,UAAK,GAAK,WAF1C,CAGGA,KAAcA,GAAY,KAoC7B,MAAMiB,GAAmB,CACvB3hB,EAAG,GACHE,EAAG,IAEL,SAAS0hB,GAA2BC,EAAiBC,EAAqBlyB,EAAMmyB,EAAcC,GAC5F,IAAI5xB,EAAMR,EAAKQ,IACbC,EAAOT,EAAKS,KACZC,EAAQV,EAAKU,MACbC,EAASX,EAAKW,YACK,IAAjBwxB,IACFA,EAAe,SAEW,IAAxBC,IACFA,EAAsBL,IAExB,MAAMM,EAAqBrB,GAAkBiB,GAC3CN,EAAQU,EAAmBV,MAC3BE,EAAWQ,EAAmBR,SAC9BD,EAASS,EAAmBT,OAC5BE,EAAUO,EAAmBP,QACzBQ,EAAY,CAChBliB,EAAG,EACHE,EAAG,GAECiiB,EAAQ,CACZniB,EAAG,EACHE,EAAG,GAECkiB,EACIN,EAAoBtxB,OAASwxB,EAAoB9hB,EADrDkiB,EAEGN,EAAoBrxB,MAAQuxB,EAAoBhiB,EAoBzD,OAlBKuhB,GAASnxB,GAAO0xB,EAAoB1xB,IAAMgyB,GAE7CF,EAAUhiB,EAAIwgB,GAAU2B,SACxBF,EAAMjiB,EAAI6hB,EAAerhB,KAAK4hB,KAAKR,EAAoB1xB,IAAMgyB,EAAmBhyB,GAAOgyB,KAC7EX,GAAYlxB,GAAUuxB,EAAoBvxB,OAAS6xB,IAE7DF,EAAUhiB,EAAIwgB,GAAU6B,QACxBJ,EAAMjiB,EAAI6hB,EAAerhB,KAAK4hB,KAAKR,EAAoBvxB,OAAS6xB,EAAmB7xB,GAAU6xB,KAE1FV,GAAWpxB,GAASwxB,EAAoBxxB,MAAQ8xB,GAEnDF,EAAUliB,EAAI0gB,GAAU6B,QACxBJ,EAAMniB,EAAI+hB,EAAerhB,KAAK4hB,KAAKR,EAAoBxxB,MAAQ8xB,EAAkB9xB,GAAS8xB,KAChFZ,GAAUnxB,GAAQyxB,EAAoBzxB,KAAO+xB,IAEvDF,EAAUliB,EAAI0gB,GAAU2B,SACxBF,EAAMniB,EAAI+hB,EAAerhB,KAAK4hB,KAAKR,EAAoBzxB,KAAO+xB,EAAkB/xB,GAAQ+xB,IAEnF,CACLF,YACAC,SAGJ,SAASK,GAAqB9vB,GAC5B,GAAIA,IAAYnB,SAASkuB,iBAAkB,CACzC,MAAMgD,EAAUnvB,OACd2tB,EAAawB,EAAQxB,WACrBD,EAAcyB,EAAQzB,YACxB,MAAO,CACL5wB,IAAK,EACLC,KAAM,EACNC,MAAO2wB,EACP1wB,OAAQywB,EACRvwB,MAAOwwB,EACPzwB,OAAQwwB,GAGZ,MAAM0B,EAAwBhwB,EAAQhD,wBAKtC,MAAO,CACLU,IALMsyB,EAAsBtyB,IAM5BC,KALOqyB,EAAsBryB,KAM7BC,MALQoyB,EAAsBpyB,MAM9BC,OALSmyB,EAAsBnyB,OAM/BE,MAAOiC,EAAQyuB,YACf3wB,OAAQkC,EAAQwuB,cAGpB,SAASyB,GAAiBC,GACxB,OAAOA,EAAoBpsB,OAAO,CAACC,EAAKhH,IAC/B,YAAIgH,EAAKgqB,EAAqBhxB,IACpCgsB,GAYL,SAASoH,GAAuBnwB,EAASowB,GAIvC,QAHgB,IAAZA,IACFA,EAAUpE,IAEPhsB,EACH,OAEF,MAAMqwB,EAAWD,EAAQpwB,GACvBtC,EAAM2yB,EAAS3yB,IACfC,EAAO0yB,EAAS1yB,KAChBE,EAASwyB,EAASxyB,OAClBD,EAAQyyB,EAASzyB,MACa0vB,EAA2BttB,KAIvDnC,GAAU,GAAKD,GAAS,GAAKF,GAAOkD,OAAO0tB,aAAe3wB,GAAQiD,OAAO2tB,aAC3EvuB,EAAQswB,eAAe,CACrBC,MAAO,SACPC,OAAQ,WAId,MAAM,GAAa,CAAC,CAAC,IAAK,CAAC,OAAQ,SAjCnC,SAA0BN,GACxB,OAAOA,EAAoBpsB,OAAO,CAACC,EAAKhH,IAC/BgH,EAAM0pB,EAAqB1wB,GACjC,KA8B2D,CAAC,IAAK,CAAC,MAAO,UA5B9E,SAA0BmzB,GACxB,OAAOA,EAAoBpsB,OAAO,CAACC,EAAKhH,IAC/BgH,EAAM6pB,EAAqB7wB,GACjC,MA0BL,MAAM0zB,GACJ,YAAYnH,EAAMtpB,GAChBhG,KAAKsvB,UAAO,EACZtvB,KAAK+D,WAAQ,EACb/D,KAAK8D,YAAS,EACd9D,KAAK0D,SAAM,EACX1D,KAAK6D,YAAS,EACd7D,KAAK4D,WAAQ,EACb5D,KAAK2D,UAAO,EACZ,MAAMuyB,EAAsBvD,EAAuB3sB,GAC7C0wB,EAAgBT,GAAiBC,GACvCl2B,KAAKsvB,KAAOvhB,EAAc,GAAIuhB,GAC9BtvB,KAAK+D,MAAQurB,EAAKvrB,MAClB/D,KAAK8D,OAASwrB,EAAKxrB,OACnB,IAAK,MAAM6yB,KAAS,GAAY,CAC9B,IAAIC,EAAQ,EAAeD,EAAO,GAClC,MAAME,EAAOD,EAAM,GACbh1B,EAAOg1B,EAAM,GACbE,EAAkBF,EAAM,GAC9B,IAAK,MAAMj4B,KAAOiD,EAChBzE,OAAOgR,eAAenO,KAAMrB,EAAK,CAC/B0xB,IAAK,KACH,MAAM0G,EAAiBD,EAAgBZ,GACjCc,EAAsBN,EAAcG,GAAQE,EAClD,OAAO/2B,KAAKsvB,KAAK3wB,GAAOq4B,GAE1B93B,YAAY,IAIlB/B,OAAOgR,eAAenO,KAAM,OAAQ,CAClCd,YAAY,KAIlB,MAAM+3B,GACJ,YAAYz4B,GACVwB,KAAKxB,YAAS,EACdwB,KAAKk3B,UAAY,GACjBl3B,KAAKm3B,UAAY,KACfn3B,KAAKk3B,UAAUj1B,QAAQiP,IACrB,IAAIkmB,EACJ,OAAuC,OAA/BA,EAAep3B,KAAKxB,aAAkB,EAAS44B,EAAa9rB,uBAAuB4F,MAG/FlR,KAAKxB,OAASA,EAEhB,IAAI64B,EAAWxmB,EAAS0X,GACtB,IAAI+O,EAC6B,OAAhCA,EAAgBt3B,KAAKxB,SAA2B84B,EAAcpsB,iBAAiBmsB,EAAWxmB,EAAS0X,GACpGvoB,KAAKk3B,UAAU7vB,KAAK,CAACgwB,EAAWxmB,EAAS0X,KAa7C,SAASgP,GAAoBC,EAAOC,GAClC,MAAMC,EAAK1jB,KAAK4hB,IAAI4B,EAAMlkB,GACpBqkB,EAAK3jB,KAAK4hB,IAAI4B,EAAMhkB,GAC1B,MAA2B,kBAAhBikB,EACFzjB,KAAKmb,KAAKuI,GAAM,EAAIC,GAAM,GAAKF,EAEpC,MAAOA,GAAe,MAAOA,EACxBC,EAAKD,EAAYnkB,GAAKqkB,EAAKF,EAAYjkB,EAE5C,MAAOikB,EACFC,EAAKD,EAAYnkB,EAEtB,MAAOmkB,GACFE,EAAKF,EAAYjkB,EAI5B,IAAIokB,GAgBAC,GANJ,SAASC,GAAe/kB,GACtBA,EAAM+kB,iBAER,SAASC,GAAgBhlB,GACvBA,EAAMglB,mBAbR,SAAWH,GACTA,EAAiB,MAAI,QACrBA,EAAqB,UAAI,YACzBA,EAAmB,QAAI,UACvBA,EAAuB,YAAI,cAC3BA,EAAkB,OAAI,SACtBA,EAA2B,gBAAI,kBAC/BA,EAA4B,iBAAI,mBAPlC,CAQGA,KAAcA,GAAY,KAQ7B,SAAWC,GACTA,EAAoB,MAAI,QACxBA,EAAmB,KAAI,YACvBA,EAAoB,MAAI,aACxBA,EAAmB,KAAI,YACvBA,EAAiB,GAAI,UACrBA,EAAkB,IAAI,SACtBA,EAAoB,MAAI,QAP1B,CAQGA,KAAiBA,GAAe,KACnC,MAAMG,GAAuB,CAC3BC,MAAO,CAACJ,GAAaK,MAAOL,GAAaM,OACzCC,OAAQ,CAACP,GAAaQ,KACtBxe,IAAK,CAACge,GAAaK,MAAOL,GAAaM,QAEnCG,GAAkC,CAACvlB,EAAO7P,KAC9C,IAAIq1B,EAAqBr1B,EAAKq1B,mBAC9B,OAAQxlB,EAAMylB,MACZ,KAAKX,GAAaY,MAChB,OAAO1qB,EAAcA,EAAc,GAAIwqB,GAAqB,GAAI,CAC9DjlB,EAAGilB,EAAmBjlB,EAAI,KAE9B,KAAKukB,GAAaa,KAChB,OAAO3qB,EAAcA,EAAc,GAAIwqB,GAAqB,GAAI,CAC9DjlB,EAAGilB,EAAmBjlB,EAAI,KAE9B,KAAKukB,GAAac,KAChB,OAAO5qB,EAAcA,EAAc,GAAIwqB,GAAqB,GAAI,CAC9D/kB,EAAG+kB,EAAmB/kB,EAAI,KAE9B,KAAKqkB,GAAae,GAChB,OAAO7qB,EAAcA,EAAc,GAAIwqB,GAAqB,GAAI,CAC9D/kB,EAAG+kB,EAAmB/kB,EAAI,OAKlC,MAAM,GACJ,YAAYnT,GACVL,KAAKK,WAAQ,EACbL,KAAK64B,mBAAoB,EACzB74B,KAAK84B,0BAAuB,EAC5B94B,KAAKk3B,eAAY,EACjBl3B,KAAK+4B,qBAAkB,EACvB/4B,KAAKK,MAAQA,EACb,MAAM7B,EAAS6B,EAAM0S,MAAMvU,OAC3BwB,KAAKK,MAAQA,EACbL,KAAKk3B,UAAY,IAAID,GAAU,YAAiBz4B,IAChDwB,KAAK+4B,gBAAkB,IAAI9B,GAAU,YAAUz4B,IAC/CwB,KAAKg5B,cAAgBh5B,KAAKg5B,cAAcC,KAAKj5B,MAC7CA,KAAKk5B,aAAel5B,KAAKk5B,aAAaD,KAAKj5B,MAC3CA,KAAKm5B,SAEP,SACEn5B,KAAKo5B,cACLp5B,KAAK+4B,gBAAgBnmB,IAAIglB,GAAUyB,OAAQr5B,KAAKk5B,cAChDl5B,KAAK+4B,gBAAgBnmB,IAAIglB,GAAU0B,iBAAkBt5B,KAAKk5B,cAC1DK,WAAW,IAAMv5B,KAAKk3B,UAAUtkB,IAAIglB,GAAU4B,QAASx5B,KAAKg5B,gBAE9D,cACE,MAAMvxB,EAAczH,KAAKK,MACvBo5B,EAAahyB,EAAYgyB,WACzBj5B,EAAUiH,EAAYjH,QAClBuC,EAAO02B,EAAW12B,KAAKgO,QACzBhO,GACFozB,GAAuBpzB,GAEzBvC,EAAQuuB,GAEV,cAAchc,GACZ,GAAI,YAAgBA,GAAQ,CAC1B,MAAM2mB,EAAe15B,KAAKK,MACxBwsB,EAAS6M,EAAa7M,OACtB9E,EAAU2R,EAAa3R,QACvBQ,EAAUmR,EAAanR,QACnBoR,EAAwBpR,EAAQqR,cACpCA,OAA0C,IAA1BD,EAAmC3B,GAAuB2B,EAC1EE,EAAwBtR,EAAQuR,iBAChCA,OAA6C,IAA1BD,EAAmCvB,GAAkCuB,EACxFE,EAAwBxR,EAAQyR,eAChCA,OAA2C,IAA1BD,EAAmC,SAAWA,EAC3DvB,EAAOzlB,EAAMylB,KACnB,GAAIoB,EAAc/f,IAAImZ,SAASwF,GAE7B,YADAx4B,KAAKi6B,UAAUlnB,GAGjB,GAAI6mB,EAAcxB,OAAOpF,SAASwF,GAEhC,YADAx4B,KAAKk5B,aAAanmB,GAGpB,MAAMid,EAAgBjI,EAAQhX,QAAQif,cAChCuI,EAAqBvI,EAAgB,CACzC1c,EAAG0c,EAAcrsB,KACjB6P,EAAGwc,EAActsB,KACfqrB,EACC/uB,KAAK84B,uBACR94B,KAAK84B,qBAAuBP,GAE9B,MAAM2B,EAAiBJ,EAAiB/mB,EAAO,CAC7C8Z,SACA9E,QAASA,EAAQhX,QACjBwnB,uBAEF,GAAI2B,EAAgB,CAClB,MAAMC,EAAmB,YAASD,EAAgB3B,GAC5C6B,EAAc,CAClB9mB,EAAG,EACHE,EAAG,GAEC0iB,EAAsBnO,EAAQhX,QAAQmlB,oBAC5C,IAAK,MAAMf,KAAmBe,EAAqB,CACjD,MAAMV,EAAYziB,EAAMylB,KAClB6B,EAAsBnG,GAAkBiB,GAC5CN,EAAQwF,EAAoBxF,MAC5BG,EAAUqF,EAAoBrF,QAC9BF,EAASuF,EAAoBvF,OAC7BC,EAAWsF,EAAoBtF,SAC/BL,EAAY2F,EAAoB3F,UAChCN,EAAYiG,EAAoBjG,UAC5BkG,EAAoBxE,GAAqBX,GACzCoF,EAAqB,CACzBjnB,EAAGU,KAAKgd,IAAIwE,IAAcqC,GAAaY,MAAQ6B,EAAkB12B,MAAQ02B,EAAkBv2B,MAAQ,EAAIu2B,EAAkB12B,MAAOoQ,KAAKmP,IAAIqS,IAAcqC,GAAaY,MAAQ6B,EAAkB32B,KAAO22B,EAAkB32B,KAAO22B,EAAkBv2B,MAAQ,EAAGm2B,EAAe5mB,IAC1QE,EAAGQ,KAAKgd,IAAIwE,IAAcqC,GAAac,KAAO2B,EAAkBz2B,OAASy2B,EAAkBx2B,OAAS,EAAIw2B,EAAkBz2B,OAAQmQ,KAAKmP,IAAIqS,IAAcqC,GAAac,KAAO2B,EAAkB52B,IAAM42B,EAAkB52B,IAAM42B,EAAkBx2B,OAAS,EAAGo2B,EAAe1mB,KAEtQgnB,EAAahF,IAAcqC,GAAaY,QAAUzD,GAAWQ,IAAcqC,GAAaa,OAAS5D,EACjG2F,EAAajF,IAAcqC,GAAac,OAAS5D,GAAYS,IAAcqC,GAAae,KAAO/D,EACrG,GAAI2F,GAAcD,EAAmBjnB,IAAM4mB,EAAe5mB,EAAG,CAC3D,MAAMonB,EAAuBvF,EAAgBxB,WAAawG,EAAiB7mB,EACrEqnB,EAA4BnF,IAAcqC,GAAaY,OAASiC,GAAwBhG,EAAUphB,GAAKkiB,IAAcqC,GAAaa,MAAQgC,GAAwBtG,EAAU9gB,EAClL,GAAIqnB,IAA8BR,EAAiB3mB,EAOjD,YAJA2hB,EAAgByF,SAAS,CACvBj3B,KAAM+2B,EACNG,SAAUb,IAKZI,EAAY9mB,EADVqnB,EACcxF,EAAgBxB,WAAa+G,EAE7BlF,IAAcqC,GAAaY,MAAQtD,EAAgBxB,WAAae,EAAUphB,EAAI6hB,EAAgBxB,WAAaS,EAAU9gB,EAEnI8mB,EAAY9mB,GACd6hB,EAAgB2F,SAAS,CACvBn3B,MAAOy2B,EAAY9mB,EACnBunB,SAAUb,IAGd,MACK,GAAIS,GAAcF,EAAmB/mB,IAAM0mB,EAAe1mB,EAAG,CAClE,MAAMknB,EAAuBvF,EAAgBrB,UAAYqG,EAAiB3mB,EACpEmnB,EAA4BnF,IAAcqC,GAAac,MAAQ+B,GAAwBhG,EAAUlhB,GAAKgiB,IAAcqC,GAAae,IAAM8B,GAAwBtG,EAAU5gB,EAC/K,GAAImnB,IAA8BR,EAAiB7mB,EAOjD,YAJA6hB,EAAgByF,SAAS,CACvBl3B,IAAKg3B,EACLG,SAAUb,IAKZI,EAAY5mB,EADVmnB,EACcxF,EAAgBrB,UAAY4G,EAE5BlF,IAAcqC,GAAac,KAAOxD,EAAgBrB,UAAYY,EAAUlhB,EAAI2hB,EAAgBrB,UAAYM,EAAU5gB,EAEhI4mB,EAAY5mB,GACd2hB,EAAgB2F,SAAS,CACvBp3B,KAAM02B,EAAY5mB,EAClBqnB,SAAUb,IAGd,OAGJh6B,KAAK+6B,WAAWhoB,EAAO,YAAI,YAASmnB,EAAgBl6B,KAAK84B,sBAAuBsB,MAItF,WAAWrnB,EAAOioB,GAChB,MAAMC,EAASj7B,KAAKK,MAAM46B,OAC1BloB,EAAM+kB,iBACNmD,EAAOD,GAET,UAAUjoB,GACR,MAAMmoB,EAAQl7B,KAAKK,MAAM66B,MACzBnoB,EAAM+kB,iBACN93B,KAAKm7B,SACLD,IAEF,aAAanoB,GACX,MAAMqoB,EAAWp7B,KAAKK,MAAM+6B,SAC5BroB,EAAM+kB,iBACN93B,KAAKm7B,SACLC,IAEF,SACEp7B,KAAKk3B,UAAUC,YACfn3B,KAAK+4B,gBAAgB5B,aAyBzB,SAASkE,GAAqBC,GAC5B,OAAOC,QAAQD,GAAc,aAAcA,GAE7C,SAASE,GAAkBF,GACzB,OAAOC,QAAQD,GAAc,UAAWA,GA1B1C,GAAeG,WAAa,CAAC,CAC3BpE,UAAW,YACXxmB,QAAS,CAACkC,EAAO7P,EAAMuI,KACrB,IAAIiwB,EAAqBx4B,EAAK02B,cAC5BA,OAAuC,IAAvB8B,EAAgC1D,GAAuB0D,EACvEC,EAAez4B,EAAKy4B,aAClB9O,EAASphB,EAAMohB,OACnB,MAAM2L,EAAOzlB,EAAM6oB,YAAYpD,KAC/B,GAAIoB,EAAc3B,MAAMjF,SAASwF,GAAO,CACtC,MAAMqD,EAAYhP,EAAOiP,cAAc/qB,QACvC,QAAI8qB,GAAa9oB,EAAMvU,SAAWq9B,KAGlC9oB,EAAM+kB,iBACU,MAAhB6D,GAAgCA,EAAa,CAC3C5oB,MAAOA,EAAM6oB,eAER,GAET,OAAO,KASX,MAAM,GACJ,YAAYv7B,EAAO07B,EAAQC,GACzB,IAAIC,OACmB,IAAnBD,IACFA,EArRN,SAAgCx9B,GAQ9B,OAAOA,aAFY,YAAUA,GACF09B,YACY19B,EAAS,YAAiBA,GA6Q5C29B,CAAuB97B,EAAM0S,MAAMvU,SAEtDwB,KAAKK,WAAQ,EACbL,KAAK+7B,YAAS,EACd/7B,KAAK64B,mBAAoB,EACzB74B,KAAK6E,cAAW,EAChB7E,KAAKo8B,WAAY,EACjBp8B,KAAKq8B,wBAAqB,EAC1Br8B,KAAKs8B,UAAY,KACjBt8B,KAAKk3B,eAAY,EACjBl3B,KAAKu8B,uBAAoB,EACzBv8B,KAAK+4B,qBAAkB,EACvB/4B,KAAKK,MAAQA,EACbL,KAAK+7B,OAASA,EACd,MAAMhpB,EAAQ1S,EAAM0S,MACdvU,EAASuU,EAAMvU,OACrBwB,KAAKK,MAAQA,EACbL,KAAK+7B,OAASA,EACd/7B,KAAK6E,SAAW,YAAiBrG,GACjCwB,KAAKu8B,kBAAoB,IAAItF,GAAUj3B,KAAK6E,UAC5C7E,KAAKk3B,UAAY,IAAID,GAAU+E,GAC/Bh8B,KAAK+4B,gBAAkB,IAAI9B,GAAU,YAAUz4B,IAC/CwB,KAAKq8B,mBAA4E,OAAtDJ,EAAuB,YAAoBlpB,IAAkBkpB,EAAuBlN,EAC/G/uB,KAAKo5B,YAAcp5B,KAAKo5B,YAAYH,KAAKj5B,MACzCA,KAAK+6B,WAAa/6B,KAAK+6B,WAAW9B,KAAKj5B,MACvCA,KAAKi6B,UAAYj6B,KAAKi6B,UAAUhB,KAAKj5B,MACrCA,KAAKk5B,aAAel5B,KAAKk5B,aAAaD,KAAKj5B,MAC3CA,KAAKw8B,cAAgBx8B,KAAKw8B,cAAcvD,KAAKj5B,MAC7CA,KAAKy8B,oBAAsBz8B,KAAKy8B,oBAAoBxD,KAAKj5B,MACzDA,KAAKm5B,SAEP,SACE,MAAM4C,EAAS/7B,KAAK+7B,OAClBW,EAAsB18B,KAAKK,MAAMkoB,QACjCoU,EAAuBD,EAAoBC,qBAC3CC,EAA6BF,EAAoBE,2BAUnD,GATA58B,KAAKk3B,UAAUtkB,IAAImpB,EAAOc,KAAKztB,KAAMpP,KAAK+6B,WAAY,CACpD+B,SAAS,IAEX98B,KAAKk3B,UAAUtkB,IAAImpB,EAAOliB,IAAIzK,KAAMpP,KAAKi6B,WACzCj6B,KAAK+4B,gBAAgBnmB,IAAIglB,GAAUyB,OAAQr5B,KAAKk5B,cAChDl5B,KAAK+4B,gBAAgBnmB,IAAIglB,GAAUmF,UAAWjF,IAC9C93B,KAAK+4B,gBAAgBnmB,IAAIglB,GAAU0B,iBAAkBt5B,KAAKk5B,cAC1Dl5B,KAAK+4B,gBAAgBnmB,IAAIglB,GAAUoF,YAAalF,IAChD93B,KAAKu8B,kBAAkB3pB,IAAIglB,GAAU4B,QAASx5B,KAAKw8B,eAC/CG,EAAsB,CACxB,GAAkC,MAA9BC,GAAsCA,EAA2B,CACnE7pB,MAAO/S,KAAKK,MAAM0S,MAClB0mB,WAAYz5B,KAAKK,MAAMo5B,WACvBlR,QAASvoB,KAAKK,MAAMkoB,UAEpB,OAAOvoB,KAAKo5B,cAEd,GAAIoC,GAAkBmB,GAEpB,YADA38B,KAAKs8B,UAAY/C,WAAWv5B,KAAKo5B,YAAauD,EAAqBx7B,QAGrE,GAAIk6B,GAAqBsB,GACvB,OAGJ38B,KAAKo5B,cAEP,SACEp5B,KAAKk3B,UAAUC,YACfn3B,KAAK+4B,gBAAgB5B,YAGrBoC,WAAWv5B,KAAKu8B,kBAAkBpF,UAAW,IACtB,OAAnBn3B,KAAKs8B,YACPW,aAAaj9B,KAAKs8B,WAClBt8B,KAAKs8B,UAAY,MAGrB,cACE,MAAMD,EAAqBr8B,KAAKq8B,mBAC1B77B,EAAUR,KAAKK,MAAMG,QACvB67B,IACFr8B,KAAKo8B,WAAY,EAEjBp8B,KAAKu8B,kBAAkB3pB,IAAIglB,GAAUsF,MAAOnF,GAAiB,CAC3DoF,SAAS,IAGXn9B,KAAKy8B,sBAELz8B,KAAKu8B,kBAAkB3pB,IAAIglB,GAAUwF,gBAAiBp9B,KAAKy8B,qBAC3Dj8B,EAAQ67B,IAGZ,WAAWtpB,GACT,IAAIsqB,EACJ,MAAMjB,EAAYp8B,KAAKo8B,UACrBC,EAAqBr8B,KAAKq8B,mBAC1Bh8B,EAAQL,KAAKK,MACT46B,EAAS56B,EAAM46B,OACnB0B,EAAuBt8B,EAAMkoB,QAAQoU,qBACvC,IAAKN,EACH,OAEF,MAAMrB,EAAsE,OAAvDqC,EAAwB,YAAoBtqB,IAAkBsqB,EAAwBtO,EACrGyI,EAAQ,YAAS6E,EAAoBrB,GAE3C,IAAKoB,GAAaO,EAAsB,CACtC,GAAItB,GAAqBsB,GAAuB,CAC9C,GAAsC,MAAlCA,EAAqBW,WAAqB/F,GAAoBC,EAAOmF,EAAqBW,WAC5F,OAAOt9B,KAAKk5B,eAEd,GAAI3B,GAAoBC,EAAOmF,EAAqBY,UAClD,OAAOv9B,KAAKo5B,cAGhB,OAAIoC,GAAkBmB,IAChBpF,GAAoBC,EAAOmF,EAAqBW,WAC3Ct9B,KAAKk5B,oBAGhB,EAEEnmB,EAAMyqB,YACRzqB,EAAM+kB,iBAERmD,EAAOD,GAET,YACE,MAAME,EAAQl7B,KAAKK,MAAM66B,MACzBl7B,KAAKm7B,SACLD,IAEF,eACE,MAAME,EAAWp7B,KAAKK,MAAM+6B,SAC5Bp7B,KAAKm7B,SACLC,IAEF,cAAcroB,GACRA,EAAMylB,OAASX,GAAaQ,KAC9Br4B,KAAKk5B,eAGT,sBACE,IAAIuE,EACsD,OAAzDA,EAAwBz9B,KAAK6E,SAAS64B,iBAAmCD,EAAsBE,mBAGpG,MAAM,GAAS,CACbd,KAAM,CACJztB,KAAM,eAERyK,IAAK,CACHzK,KAAM,cAGV,MAAM,WAAsB,GAC1B,YAAY/O,GACV,MAAM0S,EAAQ1S,EAAM0S,MAGdipB,EAAiB,YAAiBjpB,EAAMvU,QAC9Co/B,MAAMv9B,EAAO,GAAQ27B,IAGzB,GAAcP,WAAa,CAAC,CAC1BpE,UAAW,gBACXxmB,QAAS,CAAC3N,EAAMuI,KACd,IAAIsH,EAAQ7P,EAAK04B,YACbD,EAAelwB,EAAMkwB,aACzB,SAAK5oB,EAAM8qB,WAA8B,IAAjB9qB,EAAM+qB,UAGd,MAAhBnC,GAAgCA,EAAa,CAC3C5oB,WAEK,MAGX,MAAMgrB,GAAW,CACflB,KAAM,CACJztB,KAAM,aAERyK,IAAK,CACHzK,KAAM,YAGV,IAAI4uB,IACJ,SAAWA,GACTA,EAAYA,EAAwB,WAAI,GAAK,aAD/C,CAEGA,KAAgBA,GAAc,MACjC,cAA0B,GACxB,YAAY39B,GACVu9B,MAAMv9B,EAAO09B,GAAU,YAAiB19B,EAAM0S,MAAMvU,YAG5Ci9B,WAAa,CAAC,CACxBpE,UAAW,cACXxmB,QAAS,CAAC3N,EAAMuI,KACd,IAAIsH,EAAQ7P,EAAK04B,YACbD,EAAelwB,EAAMkwB,aACzB,OAAI5oB,EAAM+qB,SAAWE,GAAYC,aAGjB,MAAhBtC,GAAgCA,EAAa,CAC3C5oB,WAEK,MAGX,MAAMmrB,GAAW,CACfrB,KAAM,CACJztB,KAAM,aAERyK,IAAK,CACHzK,KAAM,aAsCV,IAAI+uB,GAKAC,GAKJ,SAASC,GAAgBn7B,GACvB,IAAImyB,EAAenyB,EAAKmyB,aACtBiJ,EAAiBp7B,EAAK24B,UACtBA,OAA+B,IAAnByC,EAA4BH,GAAoBI,QAAUD,EACtEE,EAAYt7B,EAAKs7B,UACjBC,EAAev7B,EAAKu7B,aACpBC,EAAUx7B,EAAKw7B,QACfC,EAAgBz7B,EAAK07B,SACrBA,OAA6B,IAAlBD,EAA2B,EAAIA,EAC1CE,EAAa37B,EAAK47B,MAClBA,OAAuB,IAAfD,EAAwBT,GAAeW,UAAYF,EAC3DG,EAAqB97B,EAAK87B,mBAC1B9I,EAAsBhzB,EAAKgzB,oBAC3B+I,EAA0B/7B,EAAK+7B,wBAC/BzH,EAAQt0B,EAAKs0B,MACb9B,EAAYxyB,EAAKwyB,UACnB,MAAMwJ,EAqGR,SAAyBzzB,GACvB,IAAI+rB,EAAQ/rB,EAAM+rB,MAChB7tB,EAAW8B,EAAM9B,SACnB,MAAMw1B,EAAgB,YAAY3H,GAClC,OAAO,YAAY4H,IACjB,GAAIz1B,IAAaw1B,IAAkBC,EAEjC,OAAOC,GAET,MAAM7J,EACDxhB,KAAKsrB,KAAK9H,EAAMlkB,EAAI6rB,EAAc7rB,GADjCkiB,EAEDxhB,KAAKsrB,KAAK9H,EAAMhkB,EAAI2rB,EAAc3rB,GAGvC,MAAO,CACLF,EAAG,CACD,CAAC0gB,GAAU2B,UAAWyJ,EAAe9rB,EAAE0gB,GAAU2B,YAA8B,IAAjBH,EAC9D,CAACxB,GAAU6B,SAAUuJ,EAAe9rB,EAAE0gB,GAAU6B,UAA4B,IAAhBL,GAE9DhiB,EAAG,CACD,CAACwgB,GAAU2B,UAAWyJ,EAAe5rB,EAAEwgB,GAAU2B,YAA8B,IAAjBH,EAC9D,CAACxB,GAAU6B,SAAUuJ,EAAe5rB,EAAEwgB,GAAU6B,UAA4B,IAAhBL,KAG/D,CAAC7rB,EAAU6tB,EAAO2H,IA7HAI,CAAgB,CACnC/H,QACA7tB,UAAW+0B,IAGXc,EAAgB,EADG,cAC0B,GAC7CC,EAAwBD,EAAc,GACtCE,EAA0BF,EAAc,GACpCG,EAAc,iBAAO,CACzBrsB,EAAG,EACHE,EAAG,IAECosB,EAAkB,iBAAO,CAC7BtsB,EAAG,EACHE,EAAG,IAEC8b,EAAO,kBAAQ,KACnB,OAAQuM,GACN,KAAKsC,GAAoBI,QACvB,OAAOS,EAAqB,CAC1Bt7B,IAAKs7B,EAAmBxrB,EACxB3P,OAAQm7B,EAAmBxrB,EAC3B7P,KAAMq7B,EAAmB1rB,EACzB1P,MAAOo7B,EAAmB1rB,GACxB,KACN,KAAK6qB,GAAoB0B,cACvB,OAAOpB,IAEV,CAAC5C,EAAW4C,EAAcO,IACvBc,EAAqB,iBAAO,MAC5BC,EAAa,sBAAY,KAC7B,MAAM5K,EAAkB2K,EAAmB/uB,QAC3C,IAAKokB,EACH,OAEF,MAAMxB,EAAagM,EAAY5uB,QAAQuC,EAAIssB,EAAgB7uB,QAAQuC,EAC7DwgB,EAAY6L,EAAY5uB,QAAQyC,EAAIosB,EAAgB7uB,QAAQyC,EAClE2hB,EAAgB2F,SAASnH,EAAYG,IACpC,IACGkM,EAA4B,kBAAQ,IAAMlB,IAAUV,GAAeW,UAAY,IAAI7I,GAAqB+J,UAAY/J,EAAqB,CAAC4I,EAAO5I,IACvJ,oBAAU,KACR,GAAKwI,GAAYxI,EAAoBp5B,QAAWwyB,EAAhD,CAIA,IAAK,MAAM6F,KAAmB6K,EAA2B,CACvD,IAAkE,KAAhD,MAAbxB,OAAoB,EAASA,EAAUrJ,IAC1C,SAEF,MAAM5wB,EAAQ2xB,EAAoBh0B,QAAQizB,GACpCC,EAAsB6J,EAAwB16B,GACpD,IAAK6wB,EACH,SAEF,MAAM8K,EAAwBhL,GAA2BC,EAAiBC,EAAqB9F,EAAM+F,EAAcK,GACjHF,EAAY0K,EAAsB1K,UAClCC,EAAQyK,EAAsBzK,MAChC,IAAK,MAAMoB,IAAQ,CAAC,IAAK,KAClBqI,EAAarI,GAAMrB,EAAUqB,MAChCpB,EAAMoB,GAAQ,EACdrB,EAAUqB,GAAQ,GAGtB,GAAIpB,EAAMniB,EAAI,GAAKmiB,EAAMjiB,EAAI,EAM3B,OALAksB,IACAI,EAAmB/uB,QAAUokB,EAC7BsK,EAAsBM,EAAYnB,GAClCe,EAAY5uB,QAAU0kB,OACtBmK,EAAgB7uB,QAAUykB,GAI9BmK,EAAY5uB,QAAU,CACpBuC,EAAG,EACHE,EAAG,GAELosB,EAAgB7uB,QAAU,CACxBuC,EAAG,EACHE,EAAG,GAELksB,SAtCEA,KAyCJ,CAACrK,EAAc0K,EAAYvB,EAAWkB,EAAyBhB,EAASE,EAExEuB,KAAKC,UAAU9Q,GAEf6Q,KAAKC,UAAUlB,GAAeO,EAAuBvJ,EAAqB8J,EAA2Bf,EAErGkB,KAAKC,UAAU1K,MAtJjB,cAA0B,GACxB,YAAYr1B,GACVu9B,MAAMv9B,EAAO69B,IAEf,eAQE,OAJAt3B,OAAOsE,iBAAiBgzB,GAASrB,KAAKztB,KAAMsf,EAAM,CAChDyO,SAAS,EACTL,SAAS,IAEJ,WACLl2B,OAAO0E,oBAAoB4yB,GAASrB,KAAKztB,KAAMsf,IAIjD,SAASA,SAGD+M,WAAa,CAAC,CACxBpE,UAAW,eACXxmB,QAAS,CAAC3N,EAAMuI,KACd,IAAIsH,EAAQ7P,EAAK04B,YACbD,EAAelwB,EAAMkwB,aAEzB,QADgB5oB,EAAMK,QACVtW,OAAS,KAGL,MAAhB6+B,GAAgCA,EAAa,CAC3C5oB,WAEK,MAIX,SAAWorB,GACTA,EAAoBA,EAA6B,QAAI,GAAK,UAC1DA,EAAoBA,EAAmC,cAAI,GAAK,gBAFlE,CAGGA,KAAwBA,GAAsB,KAEjD,SAAWC,GACTA,EAAeA,EAA0B,UAAI,GAAK,YAClDA,EAAeA,EAAkC,kBAAI,GAAK,oBAF5D,CAGGA,KAAmBA,GAAiB,KA4GvC,MAAMiB,GAAsB,CAC1B/rB,EAAG,CACD,CAAC0gB,GAAU2B,WAAW,EACtB,CAAC3B,GAAU6B,UAAU,GAEvBriB,EAAG,CACD,CAACwgB,GAAU2B,WAAW,EACtB,CAAC3B,GAAU6B,UAAU,IAqDzB,IAAIwK,GAMAC,IALJ,SAAWD,GACTA,EAAkBA,EAA0B,OAAI,GAAK,SACrDA,EAAkBA,EAAkC,eAAI,GAAK,iBAC7DA,EAAkBA,EAAiC,cAAI,GAAK,gBAH9D,CAIGA,KAAsBA,GAAoB,KAE7C,SAAWC,GACTA,EAA8B,UAAI,YADpC,CAEGA,KAAuBA,GAAqB,KAC/C,MAAMC,GAA4B,IAAIC,IAqGtC,SAASC,GAAgBxhC,EAAOyhC,GAC9B,OAAO,YAAYC,GACZ1hC,EAGD0hC,IAGwB,oBAAdD,EAA2BA,EAAUzhC,GAASA,GALnD,KAMR,CAACyhC,EAAWzhC,IAkCjB,SAAS2hC,GAAkB19B,GACzB,IAAIuO,EAAWvO,EAAKuO,SAClB9H,EAAWzG,EAAKyG,SAClB,MAAMk3B,EAAe,YAASpvB,GACxBqvB,EAAiB,kBAAQ,KAC7B,GAAIn3B,GAA8B,qBAAX/C,QAA2D,qBAA1BA,OAAOm6B,eAC7D,OAIF,OAAO,IAAIA,EAFMn6B,OACWm6B,gBACFF,IAG5B,CAACl3B,IAID,OAHA,oBAAU,IACD,IAAwB,MAAlBm3B,OAAyB,EAASA,EAAeE,aAC7D,CAACF,IACGA,EAET,SAASG,GAAej7B,GACtB,OAAO,IAAIywB,GAAKzE,EAAchsB,GAAUA,GAE1C,SAASk7B,GAAQl7B,EAASowB,EAAS+K,QACjB,IAAZ/K,IACFA,EAAU6K,IAEZ,MACEG,EAAe,EADG,sBAoCpB,SAAiBC,GACf,IAAKr7B,EACH,OAAO,KAGP,IAAI9C,EADN,IAA4B,IAAxB8C,EAAQs7B,YAKV,OAAoE,OAA5Dp+B,EAAsB,MAAfm+B,EAAsBA,EAAcF,GAAwBj+B,EAAO,KAEpF,MAAMq+B,EAAUnL,EAAQpwB,GACxB,GAAIm6B,KAAKC,UAAUiB,KAAiBlB,KAAKC,UAAUmB,GACjD,OAAOF,EAET,OAAOE,IAnD+B,MACK,GAC3CjS,EAAO8R,EAAa,GACpBI,EAAcJ,EAAa,GACvBK,EArDR,SAA6Bv+B,GAC3B,IAAIuO,EAAWvO,EAAKuO,SAClB9H,EAAWzG,EAAKyG,SAClB,MAAM+3B,EAAkB,YAASjwB,GAC3BgwB,EAAmB,kBAAQ,KAC/B,GAAI93B,GAA8B,qBAAX/C,QAA6D,qBAA5BA,OAAO+6B,iBAC7D,OAIF,OAAO,IAAIA,EAFM/6B,OACa+6B,kBACFD,IAC3B,CAACA,EAAiB/3B,IAIrB,OAHA,oBAAU,IACD,IAA0B,MAApB83B,OAA2B,EAASA,EAAiBT,aACjE,CAACS,IACGA,EAsCkBG,CAAoB,CAC3C,SAASC,GACP,GAAK77B,EAGL,IAAK,MAAM87B,KAAUD,EAAS,CAC5B,MAAMva,EAAOwa,EAAOxa,KAClB9oB,EAASsjC,EAAOtjC,OAClB,GAAa,cAAT8oB,GAAwB9oB,aAAkBmI,aAAenI,EAAOujC,SAAS/7B,GAAU,CACrFw7B,IACA,WAKFV,EAAiBF,GAAkB,CACvCnvB,SAAU+vB,IAeZ,OAbA,YAA0B,KACxBA,IACIx7B,GACgB,MAAlB86B,GAAkCA,EAAekB,QAAQh8B,GACrC,MAApBy7B,GAAoCA,EAAiBO,QAAQn9B,SAASo9B,KAAM,CAC1EC,WAAW,EACXC,SAAS,MAGO,MAAlBrB,GAAkCA,EAAeE,aAC7B,MAApBS,GAAoCA,EAAiBT,eAEtD,CAACh7B,IACGspB,EAuBT,MAAM8S,GAAiB,GAwEvB,SAASC,GAAsB3L,EAAeplB,QACvB,IAAjBA,IACFA,EAAe,IAEjB,MAAMgxB,EAAuB,iBAAO,MAepC,OAdA,oBAAU,KACRA,EAAqBvxB,QAAU,MAGjCO,GACA,oBAAU,KACR,MAAMixB,EAAmB7L,IAAkB3H,EACvCwT,IAAqBD,EAAqBvxB,UAC5CuxB,EAAqBvxB,QAAU2lB,IAE5B6L,GAAoBD,EAAqBvxB,UAC5CuxB,EAAqBvxB,QAAU,OAEhC,CAAC2lB,IACG4L,EAAqBvxB,QAAU,YAAS2lB,EAAe4L,EAAqBvxB,SAAWge,EAoChG,SAASyT,GAAcx8B,GACrB,OAAO,kBAAQ,IAAMA,EA92CvB,SAA6BA,GAC3B,MAAMjC,EAAQiC,EAAQuuB,WAChBzwB,EAASkC,EAAQsuB,YACvB,MAAO,CACL5wB,IAAK,EACLC,KAAM,EACNC,MAAOG,EACPF,OAAQC,EACRC,QACAD,UAq2C6B2+B,CAAoBz8B,GAAW,KAAM,CAACA,IAEvE,MAAM08B,GAAiB,GAkCvB,SAASC,GAAkB5/B,GACzB,IAAKA,EACH,OAAO,KAET,GAAIA,EAAK5C,SAASrD,OAAS,EACzB,OAAOiG,EAET,MAAM6/B,EAAa7/B,EAAK5C,SAAS,GACjC,OAAO,YAAcyiC,GAAcA,EAAa7/B,EA4ClD,MAAM8/B,GAAiB,CAAC,CACtBjU,OAAQ,GACRrG,QAAS,IACR,CACDqG,OAAQ,GACRrG,QAAS,KAELua,GAAc,CAClB/xB,QAAS,IAELgyB,GAAgC,CACpCrW,UAAW,CACT0J,QAAS1D,GAEXsQ,UAAW,CACT5M,QAAS1D,EACTuQ,SAAU5C,GAAkB6C,cAC5BC,UAAW7C,GAAmB8C,WAEhCC,YAAa,CACXjN,QAASpE,IAGb,MAAMsR,WAA+B9C,IACnC,IAAIruB,GACF,IAAIoxB,EACJ,OAAa,MAANpxB,GAA6C,OAA/BoxB,EAAa3F,MAAMvN,IAAIle,IAAeoxB,OAAyBxhC,EAEtF,UACE,OAAO/E,MAAMjB,KAAKiE,KAAKwjC,UAEzB,aACE,OAAOxjC,KAAKuF,UAAUyB,OAAO9D,IACZA,EAAKyG,UAIxB,WAAWwI,GACT,IAAIsxB,EAAuBC,EAC3B,OAAyG,OAAjGD,EAAsD,OAA7BC,EAAY1jC,KAAKqwB,IAAIle,SAAe,EAASuxB,EAAU3gC,KAAKgO,SAAmB0yB,OAAwB1hC,GAG5I,MAAM4hC,GAAuB,CAC3BC,eAAgB,KAChB/W,OAAQ,KACR4M,WAAY,KACZoK,eAAgB,KAChBjU,WAAY,KACZkU,kBAAmB,KACnBC,eAA6B,IAAIvD,IACjCvQ,eAA6B,IAAIuQ,IACjCtQ,oBAAkC,IAAIoT,GACtCxW,KAAM,KACNuW,YAAa,CACXW,QAAS,CACPjzB,QAAS,MAEXue,KAAM,KACN2U,OAAQvV,GAEVwH,oBAAqB,GACrB+I,wBAAyB,GACzBiF,uBAAwBnB,GACxBoB,2BAA4BzV,EAC5B0V,WAAY,KACZC,oBAAoB,GAEhBC,GAAyB,CAC7BV,eAAgB,KAChBnI,WAAY,GACZ5O,OAAQ,KACRgX,eAAgB,KAChBU,kBAAmB,CACjB7X,UAAW,IAEb8X,SAAU9V,EACVqV,eAA6B,IAAIvD,IACjC1T,KAAM,KACNqX,2BAA4BzV,GAExB+V,GAA+B,wBAAcH,IAC7CI,GAA6B,wBAAcf,IACjD,SAASgB,KACP,MAAO,CACLjY,UAAW,CACTG,OAAQ,KACRwP,mBAAoB,CAClB/oB,EAAG,EACHE,EAAG,GAELoxB,MAAO,IAAIpE,IACXqE,UAAW,CACTvxB,EAAG,EACHE,EAAG,IAGPwvB,UAAW,CACT8B,WAAY,IAAIxB,KAItB,SAAS,GAAQv9B,EAAOg/B,GACtB,OAAQA,EAAOzd,MACb,KAAKmH,EAAOsO,UACV,OAAOhvB,EAAcA,EAAc,GAAIhI,GAAQ,GAAI,CACjD2mB,UAAW3e,EAAcA,EAAc,GAAIhI,EAAM2mB,WAAY,GAAI,CAC/D2P,mBAAoB0I,EAAO1I,mBAC3BxP,OAAQkY,EAAOlY,WAGrB,KAAK4B,EAAOuW,SACV,OAAKj/B,EAAM2mB,UAAUG,OAGd9e,EAAcA,EAAc,GAAIhI,GAAQ,GAAI,CACjD2mB,UAAW3e,EAAcA,EAAc,GAAIhI,EAAM2mB,WAAY,GAAI,CAC/DmY,UAAW,CACTvxB,EAAGyxB,EAAO/J,YAAY1nB,EAAIvN,EAAM2mB,UAAU2P,mBAAmB/oB,EAC7DE,EAAGuxB,EAAO/J,YAAYxnB,EAAIzN,EAAM2mB,UAAU2P,mBAAmB7oB,OAN1DzN,EAUX,KAAK0oB,EAAOwW,QACZ,KAAKxW,EAAOyW,WACV,OAAOn3B,EAAcA,EAAc,GAAIhI,GAAQ,GAAI,CACjD2mB,UAAW3e,EAAcA,EAAc,GAAIhI,EAAM2mB,WAAY,GAAI,CAC/DG,OAAQ,KACRwP,mBAAoB,CAClB/oB,EAAG,EACHE,EAAG,GAELqxB,UAAW,CACTvxB,EAAG,EACHE,EAAG,OAIX,KAAKib,EAAO0W,kBACV,CACE,MAAMn/B,EAAU++B,EAAO/+B,QACjBmM,EAAKnM,EAAQmM,GACb2yB,EAAa,IAAIxB,GAAuBv9B,EAAMi9B,UAAU8B,YAE9D,OADAA,EAAWM,IAAIjzB,EAAInM,GACZ+H,EAAcA,EAAc,GAAIhI,GAAQ,GAAI,CACjDi9B,UAAWj1B,EAAcA,EAAc,GAAIhI,EAAMi9B,WAAY,GAAI,CAC/D8B,iBAIR,KAAKrW,EAAO4W,qBACV,CACE,MAAMlzB,EAAK4yB,EAAO5yB,GAChBxT,EAAMomC,EAAOpmC,IACbgL,EAAWo7B,EAAOp7B,SACd3D,EAAUD,EAAMi9B,UAAU8B,WAAWzU,IAAIle,GAC/C,IAAKnM,GAAWrH,IAAQqH,EAAQrH,IAC9B,OAAOoH,EAET,MAAM++B,EAAa,IAAIxB,GAAuBv9B,EAAMi9B,UAAU8B,YAI9D,OAHAA,EAAWM,IAAIjzB,EAAIpE,EAAcA,EAAc,GAAI/H,GAAU,GAAI,CAC/D2D,cAEKoE,EAAcA,EAAc,GAAIhI,GAAQ,GAAI,CACjDi9B,UAAWj1B,EAAcA,EAAc,GAAIhI,EAAMi9B,WAAY,GAAI,CAC/D8B,iBAIR,KAAKrW,EAAO6W,oBACV,CACE,MAAMnzB,EAAK4yB,EAAO5yB,GAChBxT,EAAMomC,EAAOpmC,IACTqH,EAAUD,EAAMi9B,UAAU8B,WAAWzU,IAAIle,GAC/C,IAAKnM,GAAWrH,IAAQqH,EAAQrH,IAC9B,OAAOoH,EAET,MAAM++B,EAAa,IAAIxB,GAAuBv9B,EAAMi9B,UAAU8B,YAE9D,OADAA,EAAWS,OAAOpzB,GACXpE,EAAcA,EAAc,GAAIhI,GAAQ,GAAI,CACjDi9B,UAAWj1B,EAAcA,EAAc,GAAIhI,EAAMi9B,WAAY,GAAI,CAC/D8B,iBAIR,QAEI,OAAO/+B,GAIf,SAASy/B,GAAatiC,GACpB,IAAIyG,EAAWzG,EAAKyG,SACpB,MAAM87B,EAAc,qBAAWhB,IAC7B5X,EAAS4Y,EAAY5Y,OACrB+W,EAAiB6B,EAAY7B,eAC7BG,EAAiB0B,EAAY1B,eACzB2B,EAAyB,YAAY9B,GACrC+B,EAAmB,YAAsB,MAAV9Y,OAAiB,EAASA,EAAO1a,IAqCtE,OAnCA,oBAAU,KACR,IAAIxI,IAGCi6B,GAAkB8B,GAA8C,MAApBC,EAA0B,CACzE,IAAK,YAAgBD,GACnB,OAEF,GAAI7gC,SAAS+gC,gBAAkBF,EAAuBlnC,OAEpD,OAEF,MAAMqnC,EAAgB9B,EAAe1T,IAAIsV,GACzC,IAAKE,EACH,OAEF,MAAM/J,EAAgB+J,EAAc/J,cAClC/4B,EAAO8iC,EAAc9iC,KACvB,IAAK+4B,EAAc/qB,UAAYhO,EAAKgO,QAClC,OAEFhG,sBAAsB,KACpB,IAAK,MAAM/E,IAAW,CAAC81B,EAAc/qB,QAAShO,EAAKgO,SAAU,CAC3D,IAAK/K,EACH,SAEF,MAAM8/B,EAAgB,YAAuB9/B,GAC7C,GAAI8/B,EAAe,CACjBA,EAAcC,QACd,YAKP,CAACnC,EAAgBj6B,EAAUo6B,EAAgB4B,EAAkBD,IACzD,KAET,SAASM,GAAeC,EAAW/iC,GACjC,IAAIlH,EAAYkH,EAAKlH,UACnB4J,EAAOsmB,EAAyBhpB,EAAM6oB,GACxC,OAAoB,MAAbka,GAAqBA,EAAUnpC,OAASmpC,EAAUn8B,OAAO,CAAC0I,EAAaH,IACrEA,EAAStE,EAAc,CAC5B/R,UAAWwW,GACV5M,IACF5J,GAAaA,EA+DlB,MAAMkqC,GAAsC,wBAAcn4B,EAAcA,EAAc,GAAIghB,GAAqB,GAAI,CACjH5a,OAAQ,EACRC,OAAQ,KAEV,IAAI+xB,IACJ,SAAWA,GACTA,EAAOA,EAAsB,cAAI,GAAK,gBACtCA,EAAOA,EAAqB,aAAI,GAAK,eACrCA,EAAOA,EAAoB,YAAI,GAAK,cAHtC,CAIGA,KAAWA,GAAS,KACvB,MAAM,GAA0B,gBAAK,SAAoBjjC,GACvD,IAAIkjC,EAAuBC,EAAuBC,EAAmBC,EACrE,IAAIp0B,EAAKjP,EAAKiP,GACZq0B,EAAgBtjC,EAAKsjC,cACrBC,EAAkBvjC,EAAK68B,WACvBA,OAAiC,IAApB0G,GAAoCA,EACjDtmC,EAAW+C,EAAK/C,SAChBumC,EAAexjC,EAAK4rB,QACpBA,OAA2B,IAAjB4X,EAA0B7D,GAAiB6D,EACrDC,EAAwBzjC,EAAK0jC,mBAC7BA,OAA+C,IAA1BD,EAAmCvV,EAAmBuV,EAC3EE,EAAY3jC,EAAK2jC,UACjBZ,EAAY/iC,EAAK+iC,UACjB5lC,EAAQ6rB,EAAyBhpB,EAAM8oB,GACzC,MACM8a,EAAS,EADD,qBAAW,QAAS/kC,EAAW4iC,IACR,GACnC5+B,EAAQ+gC,EAAO,GACftC,EAAWsC,EAAO,GACdC,EApxER,WACE,MAEE7P,EADa,EADG,mBAAS,IAAM,IAAI8P,KACI,GAChB,GACnBhZ,EAAmB,sBAAY9c,IACnCgmB,EAAUtkB,IAAI1B,GACP,IAAMgmB,EAAUqO,OAAOr0B,IAC7B,CAACgmB,IASJ,MAAO,CARU,sBAAYh0B,IAC3B,IAAIokB,EAAOpkB,EAAKokB,KACdvU,EAAQ7P,EAAK6P,MACfmkB,EAAUj1B,QAAQiP,IAChB,IAAI+1B,EACJ,OAA4C,OAApCA,EAAiB/1B,EAASoW,SAAiB,EAAS2f,EAAe3pC,KAAK4T,EAAU6B,MAE3F,CAACmkB,IACclJ,GAowEYkZ,GAC5BC,EAAyB,EAAeJ,EAAuB,GAC/DK,EAAuBD,EAAuB,GAC9CE,EAA0BF,EAAuB,GAEjDG,EAAc,EADI,mBAASnB,GAAOoB,eACQ,GAC1CC,EAASF,EAAY,GACrBG,EAAYH,EAAY,GACpBI,EAAgBF,IAAWrB,GAAOwB,YAClCC,EAAmB7hC,EAAM2mB,UAC7Bmb,EAAWD,EAAiB/a,OAC5BkX,EAAiB6D,EAAiBhD,MAClCC,EAAY+C,EAAiB/C,UAC7B3U,EAAsBnqB,EAAMi9B,UAAU8B,WAClC/hC,GAAO8kC,EAAW9D,EAAe1T,IAAIwX,GAAY,KACjDC,GAAc,iBAAO,CACzBC,QAAS,KACTC,WAAY,OAERnb,GAAS,kBAAQ,KACrB,IAAIob,EACJ,OAAmB,MAAZJ,EAAmB,CACxB11B,GAAI01B,EAEJt7B,KAA0D,OAAnD07B,EAAqB,MAARllC,QAAe,EAASA,GAAKwJ,MAAgB07B,EAAanF,GAC9ExT,KAAMwY,IACJ,MACH,CAACD,EAAU9kC,KACRmlC,GAAY,iBAAO,MAEvBC,GAAc,EADI,mBAAS,MACe,GAC1CC,GAAeD,GAAY,GAC3BE,GAAkBF,GAAY,GAE9BG,GAAc,EADI,mBAAS,MACe,GAC1C1E,GAAiB0E,GAAY,GAC7BC,GAAoBD,GAAY,GAC5BE,GAAc,YAAenoC,EAAOlD,OAAOqmC,OAAOnjC,IAClDooC,GAAyB,YAAY,iBAAkBt2B,GACvDu2B,GAA6B,kBAAQ,IAAMxY,EAAoByY,aAAc,CAACzY,IAC9EgU,IAjI2B0E,GAiIwB/B,EAhIlD,kBAAQ,KAAM,CACnBna,UAAW3e,EAAcA,EAAc,GAAIg1B,GAA8BrW,WAAsB,MAAVkc,QAAiB,EAASA,GAAOlc,WACtHsW,UAAWj1B,EAAcA,EAAc,GAAIg1B,GAA8BC,WAAsB,MAAV4F,QAAiB,EAASA,GAAO5F,WACtHK,YAAat1B,EAAcA,EAAc,GAAIg1B,GAA8BM,aAAwB,MAAVuF,QAAiB,EAASA,GAAOvF,eAG5H,CAAW,MAAVuF,QAAiB,EAASA,GAAOlc,UAAqB,MAAVkc,QAAiB,EAASA,GAAO5F,UAAqB,MAAV4F,QAAiB,EAASA,GAAOvF,eAP5H,IAAmCuF,GAkIjC,MAAMC,GAlzBR,SAA+B/D,EAAY5hC,GACzC,IAAI4lC,EAAW5lC,EAAK4lC,SAClBx3B,EAAepO,EAAKoO,aACpBs3B,EAAS1lC,EAAK0lC,OAChB,MACEG,EAAa,EADI,mBAAS,MACc,GACxCC,EAAQD,EAAW,GACnBE,EAAWF,EAAW,GAClB5F,EAAYyF,EAAOzF,UACvB/M,EAAUwS,EAAOxS,QACjB6M,EAAW2F,EAAO3F,SACdiG,EAAgB,iBAAOpE,GACvBn7B,EA6EN,WACE,OAAQs5B,GACN,KAAK5C,GAAkB8I,OACrB,OAAO,EACT,KAAK9I,GAAkB+I,eACrB,OAAON,EACT,QACE,OAAQA,GApFGO,GACXC,EAAc,YAAe3/B,GAC7Bw6B,EAA6B,uBAAY,SAAUnyB,QAC3C,IAARA,IACFA,EAAM,IAEJs3B,EAAYv4B,SAGhBk4B,EAAShqC,GACO,OAAVA,EACK+S,EAEF/S,EAAM6G,OAAOkM,EAAIhL,OAAOmL,IAAOlT,EAAM+zB,SAAS7gB,QAEtD,CAACm3B,IACEhN,EAAY,iBAAO,MACnBrM,EAAiB,YAAY0Q,IACjC,GAAIh3B,IAAam/B,EACf,OAAOvI,GAET,IAAKI,GAAiBA,IAAkBJ,IAAgB2I,EAAcn4B,UAAY+zB,GAAuB,MAATkE,EAAe,CAC7G,MAAMxkC,EAAM,IAAIg8B,IAChB,IAAK,IAAIrT,KAAa2X,EAAY,CAChC,IAAK3X,EACH,SAEF,GAAI6b,GAASA,EAAMlsC,OAAS,IAAMksC,EAAMhW,SAAS7F,EAAUhb,KAAOgb,EAAUmC,KAAKve,QAAS,CAExFvM,EAAI4gC,IAAIjY,EAAUhb,GAAIgb,EAAUmC,KAAKve,SACrC,SAEF,MAAMhO,EAAOoqB,EAAUpqB,KAAKgO,QACtBue,EAAOvsB,EAAO,IAAI0zB,GAAKL,EAAQrzB,GAAOA,GAAQ,KACpDoqB,EAAUmC,KAAKve,QAAUue,EACrBA,GACF9qB,EAAI4gC,IAAIjY,EAAUhb,GAAImd,GAG1B,OAAO9qB,EAET,OAAOm8B,GACN,CAACmE,EAAYkE,EAAOF,EAAUn/B,EAAUysB,IA8B3C,OA7BA,oBAAU,KACR8S,EAAcn4B,QAAU+zB,GACvB,CAACA,IACJ,oBAAU,KACJn7B,GAGJw6B,KAGF,CAAC2E,EAAUn/B,IACX,oBAAU,KACJq/B,GAASA,EAAMlsC,OAAS,GAC1BmsC,EAAS,OAIb,CAAC9I,KAAKC,UAAU4I,KAChB,oBAAU,KACJr/B,GAAiC,kBAAdw5B,GAAgD,OAAtB7G,EAAUvrB,UAG3DurB,EAAUvrB,QAAUwoB,WAAW,KAC7B4K,IACA7H,EAAUvrB,QAAU,MACnBoyB,KAGL,CAACA,EAAWx5B,EAAUw6B,KAA+B7yB,IAC9C,CACL2e,iBACAkU,6BACAE,mBAA6B,MAAT2E,GA2tBQO,CAAsBb,GAA4B,CAC5EI,SAAUpB,EACVp2B,aAAc,CAACuzB,EAAUvxB,EAAGuxB,EAAUrxB,GACtCo1B,OAAQ1E,GAAuBlB,YAEjC/S,GAAiB4Y,GAAsB5Y,eACvCkU,GAA6B0E,GAAsB1E,2BACnDE,GAAqBwE,GAAsBxE,mBACvC5K,GA71BR,SAAuBsK,EAAgB5xB,GACrC,MAAM0zB,EAAuB,OAAP1zB,EAAc4xB,EAAe1T,IAAIle,QAAMpQ,EACvDgB,EAAO8iC,EAAgBA,EAAc9iC,KAAKgO,QAAU,KAC1D,OAAO,YAAYy4B,IACjB,IAAItmC,EACJ,OAAW,OAAPiP,EACK,KAK2C,OAA5CjP,EAAe,MAARH,EAAeA,EAAOymC,GAAsBtmC,EAAO,MACjE,CAACH,EAAMoP,IAi1BSs3B,CAAc1F,EAAgB8D,GAC3C6B,GAAwB,kBAAQ,IAAM9F,GAAiB,YAAoBA,IAAkB,KAAM,CAACA,KACpG+F,GAwXN,WACE,MAAMC,GAAsG,KAApD,MAAhBxB,QAAuB,EAASA,GAAavP,mBAC/EgR,EAAmD,kBAAf9J,GAAiD,IAAvBA,EAAWrB,SAAmC,IAAfqB,EAC7FrB,EAAUgJ,IAAkBkC,IAAmCC,EACrE,GAA0B,kBAAf9J,EACT,OAAOhyB,EAAcA,EAAc,GAAIgyB,GAAa,GAAI,CACtDrB,YAGJ,MAAO,CACLA,WAlYsBoL,GACpBC,GA9sBR,SAAwBhnC,EAAMqzB,GAC5B,OAAOqK,GAAgB19B,EAAMqzB,GA6sBC4T,CAAevQ,GAAYyK,GAAuBxX,UAAU0J,UApI5F,SAA0ClzB,GACxC,IAAIu2B,EAAav2B,EAAKu2B,WACpBrD,EAAUlzB,EAAKkzB,QACf6T,EAAc/mC,EAAK+mC,YACnBC,EAAchnC,EAAK0lC,OACnBA,OAAyB,IAAhBsB,GAAgCA,EAC3C,MAAMC,EAAc,kBAAO,GACrBC,EAA2B,mBAAXxB,EAAuB,CACzCt1B,EAAGs1B,EACHp1B,EAAGo1B,GACDA,EACJt1B,EAAI82B,EAAO92B,EACXE,EAAI42B,EAAO52B,EACb,YAA0B,KAExB,IADkBF,IAAME,IACPimB,EAEf,YADA0Q,EAAYp5B,SAAU,GAGxB,GAAIo5B,EAAYp5B,UAAYk5B,EAG1B,OAGF,MAAMlnC,EAAqB,MAAd02B,OAAqB,EAASA,EAAW12B,KAAKgO,QAC3D,IAAKhO,IAA6B,IAArBA,EAAKu+B,YAGhB,OAEF,MACM+I,EAAY/Y,EADL8E,EAAQrzB,GACgBknC,GASrC,GARK32B,IACH+2B,EAAU/2B,EAAI,GAEXE,IACH62B,EAAU72B,EAAI,GAGhB22B,EAAYp5B,SAAU,EAClBiD,KAAK4hB,IAAIyU,EAAU/2B,GAAK,GAAKU,KAAK4hB,IAAIyU,EAAU72B,GAAK,EAAG,CAC1D,MAAM+f,EAA0BD,EAA2BvwB,GACvDwwB,GACFA,EAAwBuH,SAAS,CAC/Bp3B,IAAK2mC,EAAU72B,EACf7P,KAAM0mC,EAAU/2B,MAIrB,CAACmmB,EAAYnmB,EAAGE,EAAGy2B,EAAa7T,IAmFnCkU,CAAiC,CAC/B7Q,WAAYoO,EAAW9D,EAAe1T,IAAIwX,GAAY,KACtDe,OAAQe,GAAkBY,wBAC1BN,YAAaF,GACb3T,QAAS8N,GAAuBxX,UAAU0J,UAE5C,MAAMyN,GAAiB3C,GAAQzH,GAAYyK,GAAuBxX,UAAU0J,QAAS2T,IAC/EjG,GAAoB5C,GAAQzH,GAAaA,GAAW+Q,cAAgB,MACpEC,GAAgB,iBAAO,CAC3B7G,eAAgB,KAChB/W,OAAQ,KACR4M,cACAzJ,cAAe,KACfJ,WAAY,KACZK,kBACA8T,iBACA2G,aAAc,KACdC,iBAAkB,KAClBza,sBACApD,KAAM,KACNoJ,oBAAqB,GACrB0U,wBAAyB,OAErBC,GAAW3a,EAAoB4a,WAAmE,OAAvD1E,EAAwBqE,GAAc15B,QAAQ+b,WAAgB,EAASsZ,EAAsBj0B,IACxIkxB,GArcR,SAAiCngC,GAC/B,IAAIkzB,EAAUlzB,EAAKkzB,QACnB,MACE2U,EAAc,EADG,mBAAS,MACe,GACzCzb,EAAOyb,EAAY,GACnBC,EAAUD,EAAY,GAgBlBjK,EAAiBF,GAAkB,CACvCnvB,SAhBmB,sBAAYiB,IAC/B,IAAK,MAAMu4B,KAASv4B,EAAS,CAC3B,MAAMlU,EAASysC,EAAMzsC,OACrB,GAAI,YAAcA,GAAS,CACzBwsC,EAAQ1b,IACN,MAAMiS,EAAUnL,EAAQ53B,GACxB,OAAO8wB,EAAOvhB,EAAcA,EAAc,GAAIuhB,GAAO,GAAI,CACvDvrB,MAAOw9B,EAAQx9B,MACfD,OAAQy9B,EAAQz9B,SACby9B,IAEP,SAGH,CAACnL,MAIE8U,EAAmB,sBAAYllC,IACnC,MAAMjD,EAAO4/B,GAAkB38B,GACb,MAAlB86B,GAAkCA,EAAeE,aAC7Cj+B,IACgB,MAAlB+9B,GAAkCA,EAAekB,QAAQj/B,IAE3DioC,EAAQjoC,EAAOqzB,EAAQrzB,GAAQ,OAC9B,CAACqzB,EAAS0K,IAEXqK,EAAe,EADG,YAAWD,GACc,GAC3ClH,EAAUmH,EAAa,GACvBlH,EAASkH,EAAa,GACxB,OAAO,kBAAQ,KAAM,CACnBnH,UACA1U,OACA2U,WACE,CAAC3U,EAAM0U,EAASC,IA6ZAmH,CAAwB,CAC1ChV,QAAS8N,GAAuBb,YAAYjN,UAGxCsU,GAAwE,OAAxDrE,EAAwBhD,GAAYW,QAAQjzB,SAAmBs1B,EAAwB5M,GACvGkR,GAAmBjD,EAA0D,OAAzCpB,EAAoBjD,GAAY/T,MAAgBgX,EAAoBzC,GAAiB,KACzHwH,GAAkB9P,QAAQ8H,GAAYW,QAAQjzB,SAAWsyB,GAAY/T,MAGrEgc,GA9nBCha,EAFahC,GAgoBe+b,GAAkB,KAAOxH,GA/nBxCpD,GAAgBnR,KADtC,IAAsBA,GAkoBpB,MAAM8U,GAAa5B,GAAckI,GAAe,YAAUA,IAAgB,MAEpExU,GA/nBR,SAAgCnzB,GAC9B,MAAMwoC,EAAe,iBAAOxoC,GACtByoC,EAAY,YAAY7K,GACvB59B,EAGD49B,GAAiBA,IAAkByB,IAAkBr/B,GAAQwoC,EAAax6B,SAAWhO,EAAK2D,aAAe6kC,EAAax6B,QAAQrK,WACzHi6B,EAEFhO,EAAuB5vB,GALrBq/B,GAMR,CAACr/B,IAIJ,OAHA,oBAAU,KACRwoC,EAAax6B,QAAUhO,GACtB,CAACA,IACGyoC,EAinBqBC,CAAuB/D,EAA4B,MAAZmD,GAAmBA,GAAWpR,GAAa,MACxGwF,GA9fR,SAAkBpzB,EAAUuqB,QACV,IAAZA,IACFA,EAAUpE,GAEZ,MACE0Z,EADgB,EAAe7/B,EAAU,GAChB,GACrBu4B,EAAa5B,GAAckJ,EAAe,YAAUA,GAAgB,MAExEC,EAAe,EADI,sBAmBrB,WACE,IAAK9/B,EAAS/O,OACZ,OAAO4lC,GAET,OAAO72B,EAASrH,IAAIwB,GAAWiuB,GAA2BjuB,GAAWo+B,EAAa,IAAI3N,GAAKL,EAAQpwB,GAAUA,MAvBtE08B,IACK,GAC5CkJ,EAAQD,EAAa,GACrBE,EAAeF,EAAa,GACxB7K,EAAiBF,GAAkB,CACvCnvB,SAAUo6B,IAaZ,OAXIhgC,EAAS/O,OAAS,GAAK8uC,IAAUlJ,IACnCmJ,IAEF,YAA0B,KACpBhgC,EAAS/O,OACX+O,EAAS5J,QAAQ+D,GAA6B,MAAlB86B,OAAyB,EAASA,EAAekB,QAAQh8B,KAEnE,MAAlB86B,GAAkCA,EAAeE,aACjD6K,MAED,CAAChgC,IACG+/B,EAqeyBE,CAAS5V,IAEnC6V,GAAoB/F,GAAeC,EAAW,CAClDjqC,UAAW,CACTsX,EAAGuxB,EAAUvxB,EAAIg4B,GAAch4B,EAC/BE,EAAGqxB,EAAUrxB,EAAI83B,GAAc93B,EAC/BW,OAAQ,EACRC,OAAQ,GAEVwvB,kBACA/W,UACAgX,kBACAC,qBACA6G,oBACA7d,KAAM2d,GAAc15B,QAAQ+b,KAC5Bkf,gBAAiB3I,GAAY/T,KAC7B4G,uBACA+I,2BACAmF,gBAEIpF,GAAqB0K,GAAwB,YAAIA,GAAuB7E,GAAa,KACrFnO,GAroBR,SAA0B7qB,GACxB,MACEogC,EAAa,EADI,mBAAS,MACc,GACxCC,EAAoBD,EAAW,GAC/BE,EAAuBF,EAAW,GAC9BG,EAAe,iBAAOvgC,GAEtBwgC,EAAe,sBAAYt5B,IAC/B,MAAMggB,EAAmBS,EAAqBzgB,EAAMvU,QAC/Cu0B,GAGLoZ,EAAqBD,GACdA,GAGLA,EAAkB9G,IAAIrS,EAAkBgB,EAAqBhB,IACtD,IAAIyN,IAAI0L,IAHN,OAKV,IA6BH,OA5BA,oBAAU,KACR,MAAMI,EAAmBF,EAAar7B,QACtC,GAAIlF,IAAaygC,EAAkB,CACjCC,EAAQD,GACR,MAAM55B,EAAU7G,EAASrH,IAAIwB,IAC3B,MAAMwmC,EAAoBhZ,EAAqBxtB,GAC/C,OAAIwmC,GACFA,EAAkBthC,iBAAiB,SAAUmhC,EAAc,CACzDvP,SAAS,IAEJ,CAAC0P,EAAmBzY,EAAqByY,KAE3C,OACNxlC,OAAO+pB,GAAkB,MAATA,GACnBob,EAAqBz5B,EAAQ5V,OAAS,IAAI0jC,IAAI9tB,GAAW,MACzD05B,EAAar7B,QAAUlF,EAEzB,MAAO,KACL0gC,EAAQ1gC,GACR0gC,EAAQD,IAEV,SAASC,EAAQ1gC,GACfA,EAAS5J,QAAQ+D,IACf,MAAMwmC,EAAoBhZ,EAAqBxtB,GAC1B,MAArBwmC,GAAqCA,EAAkBlhC,oBAAoB,SAAU+gC,OAGxF,CAACA,EAAcxgC,IACX,kBAAQ,IACTA,EAAS/O,OACJovC,EAAoBlvC,MAAMjB,KAAKmwC,EAAkB1I,UAAU15B,OAAO,CAACC,EAAKixB,IAAgB,YAAIjxB,EAAKixB,GAAcjM,GAAsBkH,GAAiBpqB,GAExJkjB,EACN,CAACljB,EAAUqgC,IAglBQO,CAAiBvW,IAEjCwW,GAAmBrK,GAAsB3L,IAEzCiW,GAAwBtK,GAAsB3L,GAAe,CAACmN,KAC9D+G,GAA0B,YAAImB,GAAmBW,IACjD1c,GAAgB2a,GAAmBjZ,EAAgBiZ,GAAkBoB,IAAqB,KAC1Fnc,GAAa/C,IAAUmD,GAAgB4W,EAAmB,CAC9D/Z,UACAmD,iBACAC,kBACAC,oBAAqBwY,GACrB1J,wBACG,KACC4N,GAASjd,EAAkBC,GAAY,MAE3Cid,GAAc,EADI,mBAAS,MACe,GAC1C/f,GAAO+f,GAAY,GACnBC,GAAUD,GAAY,GAIlB7wC,GAhhER,SAAqBA,EAAWu1B,EAAOC,GACrC,OAAOzjB,EAAcA,EAAc,GAAI/R,GAAY,GAAI,CACrDmY,OAAQod,GAASC,EAAQD,EAAMxtB,MAAQytB,EAAMztB,MAAQ,EACrDqQ,OAAQmd,GAASC,EAAQD,EAAMztB,OAAS0tB,EAAM1tB,OAAS,IA6gEvC,CADOunC,GAAkBU,GAAoB,YAAIA,GAAmBY,IACc,OAAnDpG,EAAqB,MAARzZ,QAAe,EAASA,GAAKwC,MAAgBiX,EAAa,KAAM1C,IACxHkJ,GAAoB,sBAAY,CAACh6B,EAAOtH,KAC5C,IAAIuhC,EAASvhC,EAAMmjB,OACjBrG,EAAU9c,EAAM8c,QAClB,GAAyB,MAArB2f,GAAUn3B,QACZ,OAEF,MAAM0oB,EAAasK,EAAe1T,IAAI6X,GAAUn3B,SAChD,IAAK0oB,EACH,OAEF,MAAMmK,EAAiB7wB,EAAM6oB,YACvBqR,EAAiB,IAAID,EAAO,CAChCngB,OAAQqb,GAAUn3B,QAClB0oB,aACA1mB,MAAO6wB,EACPrb,UAGAR,QAAS0iB,GACT,QAAQpO,GACN,MAAMlqB,EAAK+1B,GAAUn3B,QACrB,GAAU,MAANoB,EACF,OAEF,MAAM0zB,EAAgB9B,EAAe1T,IAAIle,GACzC,IAAK0zB,EACH,OAEF,MAAMjZ,EAAc4b,GAAYz3B,QAAQ6b,YAClC7Z,EAAQ,CACZ8Z,OAAQ,CACN1a,KACA5F,KAAMs5B,EAAct5B,KACpB+iB,KAAMwY,KAGV,kCAAwB,KACP,MAAflb,GAA+BA,EAAY7Z,GAC3C00B,EAAUtB,GAAO+G,cACjB1I,EAAS,CACPld,KAAMmH,EAAOsO,UACbV,qBACAxP,OAAQ1a,IAEVi1B,EAAqB,CACnB9f,KAAM,cACNvU,aAIN,OAAOioB,GACLwJ,EAAS,CACPld,KAAMmH,EAAOuW,SACbhK,iBAGJE,MAAOiS,EAAc1e,EAAOwW,SAC5B7J,SAAU+R,EAAc1e,EAAOyW,cAMjC,SAASiI,EAAc7lB,GACrB,OAAO8lB,iBACL,MAAMC,EAAyB5C,GAAc15B,QAC3C8b,EAASwgB,EAAuBxgB,OAChC+C,EAAayd,EAAuBzd,WACpC9C,EAAOugB,EAAuBvgB,KAC9B8d,EAA0ByC,EAAuBzC,wBACnD,IAAI73B,EAAQ,KACZ,GAAI8Z,GAAU+d,EAAyB,CACrC,MAAM0C,EAAa9E,GAAYz3B,QAAQu8B,WAQvC,GAPAv6B,EAAQ,CACN6wB,iBACA/W,OAAQA,EACR+C,aACA4H,MAAOoT,EACP9d,QAEExF,IAASmH,EAAOwW,SAAiC,oBAAfqI,EAA2B,OACpCC,QAAQC,QAAQF,EAAWv6B,MAEpDuU,EAAOmH,EAAOyW,aAIpBgD,GAAUn3B,QAAU,KACpB,kCAAwB,KACtByzB,EAAS,CACPld,SAEFmgB,EAAUtB,GAAOoB,eACjBuF,GAAQ,MACRzE,GAAgB,MAChBE,GAAkB,MAClB,MAAMlR,EAAY/P,IAASmH,EAAOwW,QAAU,YAAc,eAC1D,GAAIlyB,EAAO,CACT,MAAMlC,EAAU23B,GAAYz3B,QAAQsmB,GACzB,MAAXxmB,GAA2BA,EAAQkC,GACnCq0B,EAAqB,CACnB9f,KAAM+P,EACNtkB,cA3CV,kCAAwB,KACtBs1B,GAAgB4E,GAChB1E,GAAkBx1B,EAAM6oB,gBAiD5B,CAACmI,IA2BKtI,GA9iCR,SAA8B3M,EAAS2e,GACrC,OAAO,kBAAQ,IAAM3e,EAAQhlB,OAAO,CAAC0I,EAAaoc,IAMzC,IAAIpc,KALIoc,EAAOA,OACU6M,WAAWj3B,IAAIq3B,IAAa,CAC1DxE,UAAWwE,EAAUxE,UACrBxmB,QAAS48B,EAAoB5R,EAAUhrB,QAAS+d,OAGjD,IAAK,CAACE,EAAS2e,IAsiCCC,CAAqB5e,EA1BE,sBAAY,CAACje,EAAS+d,IACvD,CAAC7b,EAAO8Z,KACb,MAAM+O,EAAc7oB,EAAM6oB,YACpB+R,EAAsB5J,EAAe1T,IAAIxD,GAC/C,GAEsB,OAAtBqb,GAAUn3B,UAET48B,GAED/R,EAAYgS,QAAUhS,EAAYiS,iBAChC,OAEF,MAAMC,EAAoB,CACxBjhB,OAAQ8gB,IAGa,IADA98B,EAAQkC,EAAO6b,EAAOrG,QAASulB,KAEpDlS,EAAYgS,OAAS,CACnBG,WAAYnf,EAAOA,QAErBsZ,GAAUn3B,QAAU8b,EACpBkgB,GAAkBh6B,EAAO6b,KAG5B,CAACmV,EAAgBgJ,OAxtBtB,SAAwBje,GACtB,oBAAU,KACR,IAAK,IACH,OAEF,MAAMkf,EAAclf,EAAQtqB,IAAItB,IAC9B,IAAI0rB,EAAS1rB,EAAK0rB,OAClB,OAAuB,MAAhBA,EAAOqf,WAAgB,EAASrf,EAAOqf,UAEhD,MAAO,KACL,IAAK,MAAMC,KAAYF,EACT,MAAZE,GAA4BA,MAMlCpf,EAAQtqB,IAAIiH,GACGA,EAAMmjB,SAwsBrBuf,CAAerf,GACf,YAA0B,KACpB+U,IAAkB2D,IAAWrB,GAAO+G,cACtCzF,EAAUtB,GAAOwB,cAElB,CAAC9D,GAAgB2D,IACpB,oBAAU,KACR,MAAMtZ,EAAasa,GAAYz3B,QAAQmd,WACjCkgB,EAAyB3D,GAAc15B,QAC3C8b,EAASuhB,EAAuBvhB,OAChC+W,EAAiBwK,EAAuBxK,eACxChU,EAAawe,EAAuBxe,WACpC9C,EAAOshB,EAAuBthB,KAChC,IAAKD,IAAW+W,EACd,OAEF,MAAM7wB,EAAQ,CACZ8Z,SACA+W,iBACAhU,aACA4H,MAAO,CACLlkB,EAAGs3B,GAAwBt3B,EAC3BE,EAAGo3B,GAAwBp3B,GAE7BsZ,QAEF,kCAAwB,KACR,MAAdoB,GAA8BA,EAAWnb,GACzCq0B,EAAqB,CACnB9f,KAAM,aACNvU,aAKN,CAAC63B,GAAwBt3B,EAAGs3B,GAAwBp3B,IACpD,oBAAU,KACR,MAAM66B,EAAyB5D,GAAc15B,QAC3C8b,EAASwhB,EAAuBxhB,OAChC+W,EAAiByK,EAAuBzK,eACxChU,EAAaye,EAAuBze,WACpCM,EAAsBme,EAAuBne,oBAC7C0a,EAA0ByD,EAAuBzD,wBACnD,IAAK/d,GAA+B,MAArBqb,GAAUn3B,UAAoB6yB,IAAmBgH,EAC9D,OAEF,MAAMzc,EAAaqa,GAAYz3B,QAAQod,WACjCmgB,EAAgBpe,EAAoBG,IAAIuc,IACxC9f,EAAOwhB,GAAiBA,EAAchf,KAAKve,QAAU,CACzDoB,GAAIm8B,EAAcn8B,GAClBmd,KAAMgf,EAAchf,KAAKve,QACzBxE,KAAM+hC,EAAc/hC,KACpB5C,SAAU2kC,EAAc3kC,UACtB,KACEoJ,EAAQ,CACZ8Z,SACA+W,iBACAhU,aACA4H,MAAO,CACLlkB,EAAGs3B,EAAwBt3B,EAC3BE,EAAGo3B,EAAwBp3B,GAE7BsZ,QAEF,kCAAwB,KACtBggB,GAAQhgB,GACM,MAAdqB,GAA8BA,EAAWpb,GACzCq0B,EAAqB,CACnB9f,KAAM,aACNvU,aAKN,CAAC65B,KACD,YAA0B,KACxBnC,GAAc15B,QAAU,CACtB6yB,kBACA/W,UACA4M,cACAzJ,iBACAJ,cACAK,kBACA8T,iBACA2G,gBACAC,oBACAza,sBACApD,QACAoJ,uBACA0U,4BAEF9C,GAAY/2B,QAAU,CACpBg3B,QAAS4C,GACT3C,WAAYhY,KAEb,CAACnD,GAAQ4M,GAAY7J,GAAYI,GAAe+T,EAAgB2G,GAAcC,GAAkB1a,GAAgBC,EAAqBpD,GAAMoJ,GAAqB0U,KACnKvM,GAAgBtwB,EAAcA,EAAc,GAAI47B,IAAoB,GAAI,CACtEnS,MAAOqN,EACPpG,aAAczO,GACdgP,sBACA9I,uBACA+I,8BAEF,MAAMsP,GAAgB,kBAAQ,KACZ,CACd1hB,UACA4M,cACAoK,kBACAD,kBACAhU,cACAkU,qBACAT,eACAU,iBACA7T,sBACAD,kBACAnD,QACAqX,8BACAjO,uBACA+I,2BACAiF,0BACAG,sBACAD,gBAGD,CAACvX,GAAQ4M,GAAYoK,GAAgBD,GAAgBhU,GAAYkU,GAAmBT,GAAaU,EAAgB7T,EAAqBD,GAAgBnD,GAAMqX,GAA4BjO,GAAqB+I,GAAyBiF,GAAwBG,GAAoBD,KAC/QoK,GAAkB,kBAAQ,KACd,CACd5K,kBACAnI,cACA5O,UACAgX,kBACAU,kBAAmB,CACjB7X,UAAW+b,IAEbjE,WACAT,iBACAjX,QACAqX,gCAGD,CAACP,GAAgBnI,GAAY5O,GAAQgX,GAAgBW,EAAUiE,GAAwB1E,EAAgBjX,GAAMqX,KAChH,OAAoB,IAAMrhC,cAAc0pB,EAAkBiiB,SAAU,CAClExvC,MAAOooC,GACO,IAAMvkC,cAAc2hC,GAAgBgK,SAAU,CAC5DxvC,MAAOuvC,IACO,IAAM1rC,cAAc4hC,GAAc+J,SAAU,CAC1DxvC,MAAOsvC,IACO,IAAMzrC,cAAcojC,GAAuBuI,SAAU,CACnExvC,MAAOjD,IACNmE,IAAyB,IAAM2C,cAAc0iC,GAAc,CAC5D77B,UAA4E,KAAhD,MAAjB68B,OAAwB,EAASA,EAAckI,iBAC1C,IAAM5rC,cAAckqB,EAAejf,EAAcA,EAAc,GAAIy4B,GAAgB,GAAI,CACvGpZ,wBAAyBqb,UAgBvBkG,GAA2B,wBAAc,MAG/C,SAASC,GAAa1rC,GACpB,IAAIiP,EAAKjP,EAAKiP,GACZ5F,EAAOrJ,EAAKqJ,KACZsiC,EAAgB3rC,EAAKyG,SACrBA,OAA6B,IAAlBklC,GAAmCA,EAC9CC,EAAa5rC,EAAK4rC,WACpB,MAAMnwC,EAAM,YAPI,aAQVowC,EAAe,qBAAWtK,IAC9BhJ,EAAasT,EAAatT,WAC1BmI,EAAiBmL,EAAanL,eAC9B/W,EAASkiB,EAAaliB,OACtBgX,EAAiBkL,EAAalL,eAC9BU,EAAoBwK,EAAaxK,kBACjCR,EAAiBgL,EAAahL,eAC9BjX,EAAOiiB,EAAajiB,KAChBkiB,EAAuB,MAAdF,EAAqBA,EAAa,GAC/CG,EAAcD,EAAOljB,KACrBA,OAAuB,IAAhBmjB,EAnBS,SAmB8BA,EAC9CC,EAAwBF,EAAOG,gBAC/BA,OAA4C,IAA1BD,EAAmC,YAAcA,EACnEE,EAAkBJ,EAAOK,SACzBA,OAA+B,IAApBD,EAA6B,EAAIA,EACxCE,GAAwB,MAAVziB,OAAiB,EAASA,EAAO1a,MAAQA,EACvDnW,EAAY,qBAAWszC,EAAapJ,GAAyByI,IAEjEY,EAAe,EADI,cACyB,GAC5CxsC,EAAOwsC,EAAa,GACpBz9B,EAAay9B,EAAa,GAE1BC,EAAe,EADI,cACyB,GAC5C1T,EAAgB0T,EAAa,GAC7BC,EAAsBD,EAAa,GAC/BtY,EA/4BR,SAA+BA,EAAW/kB,GACxC,OAAO,kBAAQ,IACN+kB,EAAUptB,OAAO,CAACC,EAAK7G,KAC5B,IAAIm0B,EAAYn0B,EAAKm0B,UACnBxmB,EAAU3N,EAAK2N,QAIjB,OAHA9G,EAAIstB,GAAatkB,IACflC,EAAQkC,EAAOZ,IAEVpI,GACN,IACF,CAACmtB,EAAW/kB,IAq4BGu9B,CAAsBjU,EAAYtpB,GAC9Cw9B,EAAU,YAAepjC,GAC/B,YAA0B,KACxBw3B,EAAeqB,IAAIjzB,EAAI,CACrBA,KACAxT,MACAoE,OACA+4B,gBACAvvB,KAAMojC,IAED,KACL,MAAM5sC,EAAOghC,EAAe1T,IAAIle,GAC5BpP,GAAQA,EAAKpE,MAAQA,GACvBolC,EAAewB,OAAOpzB,KAK5B,CAAC4xB,EAAgB5xB,IASjB,MAAO,CACL0a,SACA+W,iBACAC,iBACAiL,WAZyB,kBAAQ,KAAM,CACvChjB,OACAujB,WACA,gBAAiB1lC,EACjB,kBAAgB2lC,GAzDA,WAyDcxjB,SAA8B/pB,EAC5D,uBAAwBotC,EACxB,mBAAoB5K,EAAkB7X,YACpC,CAAC/iB,EAAUmiB,EAAMujB,EAAUC,EAAYH,EAAiB5K,EAAkB7X,YAM5E4iB,aACApY,UAAWvtB,OAAW5H,EAAYm1B,EAClCn0B,OACA+pB,OACAhb,aACA29B,sBACAzzC,aAGJ,SAAS4zC,KACP,OAAO,qBAAWlL,IAEpB,MACMmL,GAA8B,CAClCC,QAAS,IAEX,SAASC,GAAa7sC,GACpB,IAAIqJ,EAAOrJ,EAAKqJ,KACdyjC,EAAiB9sC,EAAKyG,SACtBA,OAA8B,IAAnBqmC,GAAoCA,EAC/C79B,EAAKjP,EAAKiP,GACV89B,EAAuB/sC,EAAK+sC,qBAC9B,MAAMtxC,EAAM,YAVM,aAWZuxC,EAAe,qBAAWzL,IAC9B5X,EAASqjB,EAAarjB,OACtB2X,EAAW0L,EAAa1L,SACxB1X,EAAOojB,EAAapjB,KACpBqX,EAA6B+L,EAAa/L,2BACtCgM,EAAW,iBAAO,CACtBxmC,aAEIymC,EAA0B,kBAAO,GACjC9gB,EAAO,iBAAO,MACd+gB,EAAa,iBAAO,MACpBC,EAAwBviC,EAAcA,EAAc,GAAI8hC,IAA8BI,GAC1FM,EAAyBD,EAAsB3mC,SAC/C6mC,EAAwBF,EAAsBE,sBAC9CC,EAAwBH,EAAsBR,QAC1C99B,EAAM,YAAwC,MAAzBw+B,EAAgCA,EAAwBr+B,GAkB7E2uB,EAAiBF,GAAkB,CACvCnvB,SAlBmB,sBAAY,KAC1B2+B,EAAwBr/B,SAMH,MAAtBs/B,EAAWt/B,SACbksB,aAAaoT,EAAWt/B,SAE1Bs/B,EAAWt/B,QAAUwoB,WAAW,KAC9B4K,EAA2BnnC,MAAMC,QAAQ+U,EAAIjB,SAAWiB,EAAIjB,QAAU,CAACiB,EAAIjB,UAC3Es/B,EAAWt/B,QAAU,MACpB0/B,IATDL,EAAwBr/B,SAAU,GAYtC,CAAC0/B,IAGC9mC,SAAU4mC,IAA2B1jB,IAEjCqe,EAAmB,sBAAY,CAACwF,EAAYC,KAC3C7P,IAGD6P,IACF7P,EAAe8P,UAAUD,GACzBP,EAAwBr/B,SAAU,GAEhC2/B,GACF5P,EAAekB,QAAQ0O,KAExB,CAAC5P,IAEF+P,EAAe,EADI,YAAW3F,GACc,GAC5ClH,EAAU6M,EAAa,GACvB/+B,EAAa++B,EAAa,GACtBlB,EAAU,YAAepjC,GAwC/B,OAvCA,oBAAU,KACHu0B,GAAmBkD,EAAQjzB,UAGhC+vB,EAAeE,aACfoP,EAAwBr/B,SAAU,EAClC+vB,EAAekB,QAAQgC,EAAQjzB,WAC9B,CAACizB,EAASlD,IACb,YAA0B,KACxB0D,EAAS,CACPld,KAAMmH,EAAO0W,kBACbn/B,QAAS,CACPmM,KACAxT,MACAgL,WACA5G,KAAMihC,EACN1U,OACA/iB,KAAMojC,KAGH,IAAMnL,EAAS,CACpBld,KAAMmH,EAAO6W,oBACb3mC,MACAwT,QAIJ,CAACA,IACD,oBAAU,KACJxI,IAAawmC,EAASp/B,QAAQpH,WAChC66B,EAAS,CACPld,KAAMmH,EAAO4W,qBACblzB,KACAxT,MACAgL,aAEFwmC,EAASp/B,QAAQpH,SAAWA,IAE7B,CAACwI,EAAIxT,EAAKgL,EAAU66B,IAChB,CACL3X,SACAyC,OACAwhB,QAAiB,MAARhkB,OAAe,EAASA,EAAK3a,MAAQA,EAC9CpP,KAAMihC,EACNlX,OACAhb,cAGJ,SAASi/B,GAAiB7tC,GACxB,IAAIP,EAAYO,EAAKP,UACnBxC,EAAW+C,EAAK/C,SAClB,MACE6wC,EAAc,EADI,mBAAS,MACe,GAC1CC,EAAiBD,EAAY,GAC7BE,EAAoBF,EAAY,GAEhCG,EAAc,EADI,mBAAS,MACe,GAC1CnrC,EAAUmrC,EAAY,GACtBC,EAAaD,EAAY,GACrBE,EAAmB,YAAYlxC,GAkBrC,OAjBKA,GAAa8wC,IAAkBI,GAClCH,EAAkBG,GAEpB,YAA0B,KACxB,IAAKrrC,EACH,OAEF,MAAMrH,EAAwB,MAAlBsyC,OAAyB,EAASA,EAAetyC,IACvDwT,EAAuB,MAAlB8+B,OAAyB,EAASA,EAAe5wC,MAAM8R,GACvD,MAAPxT,GAAqB,MAANwT,EAInBo7B,QAAQC,QAAQ7qC,EAAUwP,EAAInM,IAAUsrC,KAAK,KAC3CJ,EAAkB,QAJlBA,EAAkB,OAMnB,CAACvuC,EAAWsuC,EAAgBjrC,IACX,IAAMlD,cAAc,IAAM0rB,SAAU,KAAMruB,EAAU8wC,EAA8B,uBAAaA,EAAgB,CACjIrkC,IAAKwkC,IACF,MAEP,MAAMG,GAAmB,CACvBj+B,EAAG,EACHE,EAAG,EACHW,OAAQ,EACRC,OAAQ,GAEV,SAASo9B,GAAyBtuC,GAChC,IAAI/C,EAAW+C,EAAK/C,SACpB,OAAoB,IAAM2C,cAAc2hC,GAAgBgK,SAAU,CAChExvC,MAAOqlC,IACO,IAAMxhC,cAAcojC,GAAuBuI,SAAU,CACnExvC,MAAOsyC,IACNpxC,IAEL,MAAMsxC,GAAa,CACjBpvC,SAAU,QACVqvC,YAAa,QAETC,GAAoB/N,GACI,YAAgBA,GACf,4BAAyB7hC,EAElD6vC,GAAiC,qBAAW,CAAC1uC,EAAM0J,KACvD,IAAIilC,EAAK3uC,EAAK2uC,GACZjO,EAAiB1gC,EAAK0gC,eACtBkO,EAAc5uC,EAAK4uC,YACnB3xC,EAAW+C,EAAK/C,SAChBsX,EAAYvU,EAAKuU,UACjB6X,EAAOpsB,EAAKosB,KACZltB,EAAQc,EAAKd,MACbpG,EAAYkH,EAAKlH,UACjB+1C,EAAkB7uC,EAAK0B,WACvBA,OAAiC,IAApBmtC,EAA6BJ,GAAoBI,EAChE,IAAKziB,EACH,OAAO,KAET,MAAM0iB,EAAyBF,EAAc91C,EAAY+R,EAAcA,EAAc,GAAI/R,GAAY,GAAI,CACvGmY,OAAQ,EACRC,OAAQ,IAEJhR,EAAS2K,EAAcA,EAAc,GAAI0jC,IAAa,GAAI,CAC9D1tC,MAAOurB,EAAKvrB,MACZD,OAAQwrB,EAAKxrB,OACbJ,IAAK4rB,EAAK5rB,IACVC,KAAM2rB,EAAK3rB,KACX3H,UAAW,IAAIqY,UAAUhX,SAAS20C,GAClC31C,gBAAiBy1C,GAAelO,EAAiBvU,EAA2BuU,EAAgBtU,QAAQvtB,EACpG6C,WAAkC,oBAAfA,EAA4BA,EAAWg/B,GAAkBh/B,GAC3ExC,GACH,OAAoB,IAAMU,cAAc+uC,EAAI,CAC1Cp6B,YACArV,MAAOgB,EACPwJ,OACCzM,KA2DC8xC,GAAoC,CACxChxC,SAAU,IACVV,OAAQ,OACR2xC,UAb8BzmC,IAC9B,IAAI0mC,EAAkB1mC,EAAMzP,UAC1B+rC,EAAUoK,EAAgBpK,QAC1BqK,EAAQD,EAAgBC,MAC1B,MAAO,CAAC,CACNp2C,UAAW,IAAIqY,UAAUhX,SAAS0qC,IACjC,CACD/rC,UAAW,IAAIqY,UAAUhX,SAAS+0C,MAOpCC,YA7DsC9pB,IAAWrlB,IACjD,IAAI2pB,EAAS3pB,EAAK2pB,OAChBwW,EAAcngC,EAAKmgC,YACrB,MAAMiP,EAAiB,GACjBlvC,EAASmlB,EAAQnlB,OACrBqU,EAAY8Q,EAAQ9Q,UACtB,GAAc,MAAVrU,GAAkBA,EAAOypB,OAC3B,IAAK,MAAM0lB,KAAUp1C,OAAOuV,QAAQtP,EAAOypB,QAAS,CAClD,IAAI2lB,EAAS,EAAeD,EAAQ,GACpC,MAAM5zC,EAAM6zC,EAAO,GACbvzC,EAAQuzC,EAAO,QACPzwC,IAAV9C,IAGJqzC,EAAe3zC,GAAOkuB,EAAO9pB,KAAKX,MAAM6C,iBAAiBtG,GACzDkuB,EAAO9pB,KAAKX,MAAMiB,YAAY1E,EAAKM,IAGvC,GAAc,MAAVmE,GAAkBA,EAAOigC,YAC3B,IAAK,MAAMoP,KAAUt1C,OAAOuV,QAAQtP,EAAOigC,aAAc,CACvD,IAAIqP,EAAS,EAAeD,EAAQ,GACpC,MAAM9zC,EAAM+zC,EAAO,GACbzzC,EAAQyzC,EAAO,QACP3wC,IAAV9C,GAGJokC,EAAYtgC,KAAKX,MAAMiB,YAAY1E,EAAKM,GAS5C,OANiB,MAAbwY,GAAqBA,EAAUoV,QACjCA,EAAO9pB,KAAK4vC,UAAU//B,IAAI6E,EAAUoV,QAErB,MAAbpV,GAAqBA,EAAU4rB,aACjCA,EAAYtgC,KAAK4vC,UAAU//B,IAAI6E,EAAU4rB,aAEpC,WACL,IAAK,MAAMuP,KAAUz1C,OAAOuV,QAAQ4/B,GAAiB,CACnD,IAAIO,EAAS,EAAeD,EAAQ,GACpC,MAAMj0C,EAAMk0C,EAAO,GACb5zC,EAAQ4zC,EAAO,GACrBhmB,EAAO9pB,KAAKX,MAAMiB,YAAY1E,EAAKM,GAEpB,MAAbwY,GAAqBA,EAAUoV,QACjCA,EAAO9pB,KAAK4vC,UAAU/9B,OAAO6C,EAAUoV,UAkBjBimB,CAAgC,CACxD1vC,OAAQ,CACNypB,OAAQ,CACN5wB,QAAS,SAKjB,SAAS82C,GAAiBxvC,GACxB,IAAIqlC,EAASrlC,EAAMqlC,OACjB7E,EAAiBxgC,EAAMwgC,eACvB7T,EAAsB3sB,EAAM2sB,oBAC5BgU,EAAyB3gC,EAAM2gC,uBACjC,OAAO,YAAS,CAAC/xB,EAAIpP,KACnB,GAAe,OAAX6lC,EACF,OAEF,MAAMoK,EAAkBjP,EAAe1T,IAAIle,GAC3C,IAAK6gC,EACH,OAEF,MAAMvZ,EAAauZ,EAAgBjwC,KAAKgO,QACxC,IAAK0oB,EACH,OAEF,MAAMwZ,EAAiBtQ,GAAkB5/B,GACzC,IAAKkwC,EACH,OAEF,MAEM/gB,EAAkBP,EAFO,YAAU5uB,GAAM8D,iBAAiB9D,GAC3B/G,WAErC,IAAKk2B,EACH,OAEF,MAAMvvB,EAA8B,oBAAXimC,EAAwBA,EAoBrD,SAAoCrgB,GAClC,MAAM2qB,EAAwBnlC,EAAcA,EAAc,GAAIkkC,IAAoC1pB,GAChGtnB,EAAWiyC,EAAsBjyC,SACjCV,EAAS2yC,EAAsB3yC,OAC/B8xC,EAAca,EAAsBb,YACpCH,EAAYgB,EAAsBhB,UACpC,OAAO7nC,IACL,IAAIwiB,EAASxiB,EAAMwiB,OACjBwW,EAAch5B,EAAMg5B,YACpBrnC,EAAYqO,EAAMrO,UAClBm3C,EAAOjnB,EAAyB7hB,EAAO4hB,GACzC,IAAKhrB,EAEH,OAEF,MAAMu2B,EACD6L,EAAY/T,KAAK3rB,KAAOkpB,EAAOyC,KAAK3rB,KADnC6zB,EAED6L,EAAY/T,KAAK5rB,IAAMmpB,EAAOyC,KAAK5rB,IAElC0vC,EAAQ,CACZj/B,OAA6B,IAArBnY,EAAUmY,OAAe0Y,EAAOyC,KAAKvrB,MAAQ/H,EAAUmY,OAASkvB,EAAY/T,KAAKvrB,MAAQ,EACjGqQ,OAA6B,IAArBpY,EAAUoY,OAAeyY,EAAOyC,KAAKxrB,OAAS9H,EAAUoY,OAASivB,EAAY/T,KAAKxrB,OAAS,GAE/FuvC,EAAiBtlC,EAAc,CACnCuF,EAAGtX,EAAUsX,EAAIkkB,EACjBhkB,EAAGxX,EAAUwX,EAAIgkB,GAChB4b,GACGE,EAAqBpB,EAAUnkC,EAAcA,EAAc,GAAIolC,GAAO,GAAI,CAC9EtmB,SACAwW,cACArnC,UAAW,CACT+rC,QAAS/rC,EACTo2C,MAAOiB,MAITE,EAD0B,EAAeD,EAAoB,GACzB,GAChCE,EAAeF,EAAmBA,EAAmBx2C,OAAS,GACpE,GAAIqjC,KAAKC,UAAUmT,KAAmBpT,KAAKC,UAAUoT,GAEnD,OAEF,MAAMjH,EAAyB,MAAf8F,OAAsB,EAASA,EAAYtkC,EAAc,CACvE8e,SACAwW,eACC8P,IACGxwC,EAAY0gC,EAAYtgC,KAAK0wC,QAAQH,EAAoB,CAC7DryC,WACAV,SACAmzC,KAAM,aAER,OAAO,IAAInG,QAAQC,IACjB7qC,EAAUgxC,SAAW,KACR,MAAXpH,GAA2BA,IAC3BiB,QA1EsDoG,CAA2BhL,GAErF,OADAzS,GAAuBsD,EAAYyK,EAAuBxX,UAAU0J,SAC7DzzB,EAAU,CACfkqB,OAAQ,CACN1a,KACA5F,KAAMymC,EAAgBzmC,KACtBxJ,KAAM02B,EACNnK,KAAM4U,EAAuBxX,UAAU0J,QAAQqD,IAEjDsK,iBACAV,YAAa,CACXtgC,OACAusB,KAAM4U,EAAuBb,YAAYjN,QAAQ6c,IAEnD/iB,sBACAgU,yBACAloC,UAAWk2B,MA+DjB,IAAI,GAAM,EAUV,MAAM2hB,GAA2B,IAAMC,KAAK5wC,IAC1C,IAAI6wC,EAAmB7wC,EAAK4uC,YAC1BA,OAAmC,IAArBiC,GAAsCA,EACpD5zC,EAAW+C,EAAK/C,SAChB6zC,EAAsB9wC,EAAK+wC,cAC3B7xC,EAAQc,EAAKd,MACbwC,EAAa1B,EAAK0B,WAClBqhC,EAAY/iC,EAAK+iC,UACjBiO,EAAsBhxC,EAAKixC,eAC3BA,OAAyC,IAAxBD,EAAiC,MAAQA,EAC1Dz8B,EAAYvU,EAAKuU,UACjB28B,EAAclxC,EAAKmxC,OACnBA,OAAyB,IAAhBD,EAAyB,IAAMA,EAC1C,MAAME,EAAiB1E,KACrBhM,EAAiB0Q,EAAe1Q,eAChC/W,EAASynB,EAAeznB,OACxBgX,EAAiByQ,EAAezQ,eAChCC,EAAoBwQ,EAAexQ,kBACnCC,EAAiBuQ,EAAevQ,eAChC7T,EAAsBokB,EAAepkB,oBACrCmT,EAAciR,EAAejR,YAC7BvW,EAAOwnB,EAAexnB,KACtBoX,EAAyBoQ,EAAepQ,uBACxChO,EAAsBoe,EAAepe,oBACrC+I,EAA0BqV,EAAerV,wBACzCmF,EAAakQ,EAAelQ,WACxBpoC,EAAY,qBAAWkqC,IACvBvnC,GApCQwT,EAoCe,MAAV0a,OAAiB,EAASA,EAAO1a,GAnC7C,kBAAQ,KACb,GAAU,MAANA,EAIJ,OADA,KACO,IACN,CAACA,KAPN,IAAgBA,EAqCd,MAAMoiC,EAAoBvO,GAAeC,EAAW,CAClDrC,iBACA/W,SACAgX,iBACAC,oBACA6G,iBAAkBtH,EAAY/T,KAC9BxC,OACAkf,gBAAiB3I,EAAY/T,KAC7B4G,sBACA+I,0BACAjjC,YACAooC,eAEI6F,EAAcxJ,GAAgBoD,GAC9BoQ,EAAgBlB,GAAiB,CACrCnK,OAAQoL,EACRjQ,iBACA7T,sBACAgU,2BAIIt3B,EAAMq9B,EAAc5G,EAAYY,YAASliC,EAC/C,OAAoB,IAAMe,cAAc0uC,GAA0B,KAAmB,IAAM1uC,cAAciuC,GAAkB,CACzHpuC,UAAWsxC,GACVpnB,GAAUluB,EAAmB,IAAMmE,cAAc8uC,GAAmB,CACrEjzC,IAAKA,EACLwT,GAAI0a,EAAO1a,GACXvF,IAAKA,EACLilC,GAAIsC,EACJvQ,eAAgBA,EAChBkO,YAAaA,EACbr6B,UAAWA,EACX7S,WAAYA,EACZ0qB,KAAM2a,EACN7nC,MAAO2L,EAAc,CACnBsmC,UACCjyC,GACHpG,UAAWu4C,GACVp0C,GAAY,U,gCChwGjB,45CAgBA,IAAIq0C,EAAgB,SAAU3rC,EAAGL,GAQ/B,OAPAgsC,EAAgBr3C,OAAOkC,gBAAkB,CACvCC,UAAW,cACAtC,OAAS,SAAU6L,EAAGL,GACjCK,EAAEvJ,UAAYkJ,IACX,SAAUK,EAAGL,GAChB,IAAK,IAAIisC,KAAKjsC,EAAOrL,OAAOC,UAAUwB,eAAetB,KAAKkL,EAAGisC,KAAI5rC,EAAE4rC,GAAKjsC,EAAEisC,MAEvD5rC,EAAGL,IAEnB,SAASksC,EAAU7rC,EAAGL,GAC3B,GAAiB,oBAANA,GAA0B,OAANA,EAAY,MAAM,IAAInK,UAAU,uBAAyBgQ,OAAO7F,GAAK,iCAEpG,SAASmsC,IACP30C,KAAK/B,YAAc4K,EAFrB2rC,EAAc3rC,EAAGL,GAIjBK,EAAEzL,UAAkB,OAANoL,EAAarL,OAAO6B,OAAOwJ,IAAMmsC,EAAGv3C,UAAYoL,EAAEpL,UAAW,IAAIu3C,GAE1E,IAAIC,EAAW,WAQpB,OAPAA,EAAWz3C,OAAOoB,QAAU,SAAkByG,GAC5C,IAAK,IAAI6vC,EAAGh4C,EAAI,EAAG6R,EAAIjQ,UAAU3B,OAAQD,EAAI6R,EAAG7R,IAE9C,IAAK,IAAI43C,KADTI,EAAIp2C,UAAU5B,GACOM,OAAOC,UAAUwB,eAAetB,KAAKu3C,EAAGJ,KAAIzvC,EAAEyvC,GAAKI,EAAEJ,IAE5E,OAAOzvC,IAEO/E,MAAMD,KAAMvB,YAEvB,SAASq2C,EAAOD,EAAGnnC,GACxB,IAAI1I,EAAI,GACR,IAAK,IAAIyvC,KAAKI,EAAO13C,OAAOC,UAAUwB,eAAetB,KAAKu3C,EAAGJ,IAAM/mC,EAAExL,QAAQuyC,GAAK,IAAGzvC,EAAEyvC,GAAKI,EAAEJ,IAC9F,GAAS,MAALI,GAAqD,oBAAjC13C,OAAOyQ,sBAA2C,KAAI/Q,EAAI,EAAb,IAAgB43C,EAAIt3C,OAAOyQ,sBAAsBinC,GAAIh4C,EAAI43C,EAAE33C,OAAQD,IAClI6Q,EAAExL,QAAQuyC,EAAE53C,IAAM,GAAKM,OAAOC,UAAUmvB,qBAAqBjvB,KAAKu3C,EAAGJ,EAAE53C,MAAKmI,EAAEyvC,EAAE53C,IAAMg4C,EAAEJ,EAAE53C,KAEhG,OAAOmI,EAEF,SAAS+vC,EAAWC,EAAYx2C,EAAQG,EAAKs2C,GAClD,IAEEpsC,EAFEqsC,EAAIz2C,UAAU3B,OAChB6Q,EAAIunC,EAAI,EAAI12C,EAAkB,OAATy2C,EAAgBA,EAAO93C,OAAO2Q,yBAAyBtP,EAAQG,GAAOs2C,EAE7F,GAAuB,kBAAZE,SAAoD,oBAArBA,QAAQC,SAAyBznC,EAAIwnC,QAAQC,SAASJ,EAAYx2C,EAAQG,EAAKs2C,QAAW,IAAK,IAAIp4C,EAAIm4C,EAAWl4C,OAAS,EAAGD,GAAK,EAAGA,KAASgM,EAAImsC,EAAWn4C,MAAI8Q,GAAKunC,EAAI,EAAIrsC,EAAE8E,GAAKunC,EAAI,EAAIrsC,EAAErK,EAAQG,EAAKgP,GAAK9E,EAAErK,EAAQG,KAASgP,GAC/Q,OAAOunC,EAAI,GAAKvnC,GAAKxQ,OAAOgR,eAAe3P,EAAQG,EAAKgP,GAAIA,EAEvD,SAAS0nC,EAAQC,EAAYC,GAClC,OAAO,SAAU/2C,EAAQG,GACvB42C,EAAU/2C,EAAQG,EAAK22C,IAGpB,SAASE,EAAaC,EAAMC,EAAcV,EAAYW,EAAWC,EAAcC,GACpF,SAASC,EAAOlnC,GACd,QAAU,IAANA,GAA6B,oBAANA,EAAkB,MAAM,IAAIvQ,UAAU,qBACjE,OAAOuQ,EAQT,IANA,IAIImnC,EAJAC,EAAOL,EAAUK,KACnBr3C,EAAe,WAATq3C,EAAoB,MAAiB,WAATA,EAAoB,MAAQ,QAC5Dx3C,GAAUk3C,GAAgBD,EAAOE,EAAkB,OAAIF,EAAOA,EAAKr4C,UAAY,KAC/E64C,EAAaP,IAAiBl3C,EAASrB,OAAO2Q,yBAAyBtP,EAAQm3C,EAAUvmC,MAAQ,IAEnGN,GAAO,EACAjS,EAAIm4C,EAAWl4C,OAAS,EAAGD,GAAK,EAAGA,IAAK,CAC/C,IAAIkrB,EAAU,GACd,IAAK,IAAI0sB,KAAKkB,EAAW5tB,EAAQ0sB,GAAW,WAANA,EAAiB,GAAKkB,EAAUlB,GACtE,IAAK,IAAIA,KAAKkB,EAAUO,OAAQnuB,EAAQmuB,OAAOzB,GAAKkB,EAAUO,OAAOzB,GACrE1sB,EAAQouB,eAAiB,SAAUvnC,GACjC,GAAIE,EAAM,MAAM,IAAIzQ,UAAU,0DAC9Bw3C,EAAkBxuC,KAAKyuC,EAAOlnC,GAAK,QAErC,IAAI5M,GAAS,EAAIgzC,EAAWn4C,IAAa,aAATm5C,EAAsB,CACpD3lB,IAAK4lB,EAAW5lB,IAChB+U,IAAK6Q,EAAW7Q,KACd6Q,EAAWt3C,GAAMopB,GACrB,GAAa,aAATiuB,EAAqB,CACvB,QAAe,IAAXh0C,EAAmB,SACvB,GAAe,OAAXA,GAAqC,kBAAXA,EAAqB,MAAM,IAAI3D,UAAU,oBACnE03C,EAAID,EAAO9zC,EAAOquB,QAAM4lB,EAAW5lB,IAAM0lB,IACzCA,EAAID,EAAO9zC,EAAOojC,QAAM6Q,EAAW7Q,IAAM2Q,IACzCA,EAAID,EAAO9zC,EAAOo0C,QAAOR,EAAaS,QAAQN,QACzCA,EAAID,EAAO9zC,MACP,UAATg0C,EAAkBJ,EAAaS,QAAQN,GAAQE,EAAWt3C,GAAOo3C,GAGrEv3C,GAAQrB,OAAOgR,eAAe3P,EAAQm3C,EAAUvmC,KAAM6mC,GAC1DnnC,GAAO,EAGF,SAASwnC,EAAkBC,EAASX,EAAc32C,GAEvD,IADA,IAAIu3C,EAAW/3C,UAAU3B,OAAS,EACzBD,EAAI,EAAGA,EAAI+4C,EAAa94C,OAAQD,IACvCoC,EAAQu3C,EAAWZ,EAAa/4C,GAAGS,KAAKi5C,EAASt3C,GAAS22C,EAAa/4C,GAAGS,KAAKi5C,GAEjF,OAAOC,EAAWv3C,OAAQ,EAGrB,SAASw3C,EAAUnjC,GACxB,MAAoB,kBAANA,EAAiBA,EAAI,GAAGxN,OAAOwN,GAGxC,SAASojC,EAAkB9nC,EAAGQ,EAAM8C,GAEzC,MADoB,kBAAT9C,IAAmBA,EAAOA,EAAKunC,YAAc,IAAI7wC,OAAOsJ,EAAKunC,YAAa,KAAO,IACrFx5C,OAAOgR,eAAeS,EAAG,OAAQ,CACtCxP,cAAc,EACdH,MAAOiT,EAAS,GAAGpM,OAAOoM,EAAQ,IAAK9C,GAAQA,IAI5C,SAASwnC,EAAWC,EAAaC,GACtC,GAAuB,kBAAZ3B,SAAoD,oBAArBA,QAAQ4B,SAAyB,OAAO5B,QAAQ4B,SAASF,EAAaC,GAE3G,SAASE,EAAUT,EAASU,EAAYC,EAAGC,GAMhD,OAAO,IAAKD,IAAMA,EAAI3J,WAAU,SAAUC,EAAS4J,GACjD,SAASC,EAAUp4C,GACjB,IACEq4C,EAAKH,EAAUtoC,KAAK5P,IACpB,MAAOyO,GACP0pC,EAAO1pC,IAGX,SAAS6pC,EAASt4C,GAChB,IACEq4C,EAAKH,EAAiB,MAAEl4C,IACxB,MAAOyO,GACP0pC,EAAO1pC,IAGX,SAAS4pC,EAAKt1C,GApBhB,IAAe/C,EAqBX+C,EAAO8M,KAAO0+B,EAAQxrC,EAAO/C,QArBlBA,EAqBiC+C,EAAO/C,MApB9CA,aAAiBi4C,EAAIj4C,EAAQ,IAAIi4C,GAAE,SAAU1J,GAClDA,EAAQvuC,OAmBkDqyC,KAAK+F,EAAWE,GAE5ED,GAAMH,EAAYA,EAAUl3C,MAAMs2C,EAASU,GAAc,KAAKpoC,WAG3D,SAAS2oC,EAAYjB,EAAStU,GACnC,IASErzB,EACA4E,EACAxO,EACAyyC,EAZE1B,EAAI,CACJ2B,MAAO,EACPC,KAAM,WACJ,GAAW,EAAP3yC,EAAE,GAAQ,MAAMA,EAAE,GACtB,OAAOA,EAAE,IAEX4yC,KAAM,GACNC,IAAK,IAMT,OAAOJ,EAAI,CACT5oC,KAAMipC,EAAK,GACX,MAASA,EAAK,GACd,OAAUA,EAAK,IACI,oBAAXh6C,SAA0B25C,EAAE35C,OAAOC,UAAY,WACvD,OAAOiC,OACLy3C,EACJ,SAASK,EAAKppC,GACZ,OAAO,SAAUqpC,GACf,OAGJ,SAAcC,GACZ,GAAIppC,EAAG,MAAM,IAAIvQ,UAAU,mCAC3B,KAAOo5C,IAAMA,EAAI,EAAGO,EAAG,KAAOjC,EAAI,IAAKA,GAAG,IACxC,GAAInnC,EAAI,EAAG4E,IAAMxO,EAAY,EAARgzC,EAAG,GAASxkC,EAAU,OAAIwkC,EAAG,GAAKxkC,EAAS,SAAOxO,EAAIwO,EAAU,SAAMxO,EAAE1H,KAAKkW,GAAI,GAAKA,EAAE3E,SAAW7J,EAAIA,EAAE1H,KAAKkW,EAAGwkC,EAAG,KAAKlpC,KAAM,OAAO9J,EAE3J,OADIwO,EAAI,EAAGxO,IAAGgzC,EAAK,CAAS,EAARA,EAAG,GAAQhzC,EAAE/F,QACzB+4C,EAAG,IACT,KAAK,EACL,KAAK,EACHhzC,EAAIgzC,EACJ,MACF,KAAK,EAEH,OADAjC,EAAE2B,QACK,CACLz4C,MAAO+4C,EAAG,GACVlpC,MAAM,GAEV,KAAK,EACHinC,EAAE2B,QACFlkC,EAAIwkC,EAAG,GACPA,EAAK,CAAC,GACN,SACF,KAAK,EACHA,EAAKjC,EAAE8B,IAAIj3B,MACXm1B,EAAE6B,KAAKh3B,MACP,SACF,QACE,KAAkB5b,GAAZA,EAAI+wC,EAAE6B,MAAY96C,OAAS,GAAKkI,EAAEA,EAAElI,OAAS,MAAkB,IAAVk7C,EAAG,IAAsB,IAAVA,EAAG,IAAW,CACtFjC,EAAI,EACJ,SAEF,GAAc,IAAViC,EAAG,MAAchzC,GAAKgzC,EAAG,GAAKhzC,EAAE,IAAMgzC,EAAG,GAAKhzC,EAAE,IAAK,CACvD+wC,EAAE2B,MAAQM,EAAG,GACb,MAEF,GAAc,IAAVA,EAAG,IAAYjC,EAAE2B,MAAQ1yC,EAAE,GAAI,CACjC+wC,EAAE2B,MAAQ1yC,EAAE,GACZA,EAAIgzC,EACJ,MAEF,GAAIhzC,GAAK+wC,EAAE2B,MAAQ1yC,EAAE,GAAI,CACvB+wC,EAAE2B,MAAQ1yC,EAAE,GACZ+wC,EAAE8B,IAAIxwC,KAAK2wC,GACX,MAEEhzC,EAAE,IAAI+wC,EAAE8B,IAAIj3B,MAChBm1B,EAAE6B,KAAKh3B,MACP,SAEJo3B,EAAK/V,EAAK3kC,KAAKi5C,EAASR,GACxB,MAAOroC,GACPsqC,EAAK,CAAC,EAAGtqC,GACT8F,EAAI,EACJ,QACA5E,EAAI5J,EAAI,EAEV,GAAY,EAARgzC,EAAG,GAAQ,MAAMA,EAAG,GACxB,MAAO,CACL/4C,MAAO+4C,EAAG,GAAKA,EAAG,QAAK,EACvBlpC,MAAM,GA7DCwoC,CAAK,CAAC5oC,EAAGqpC,MAiEf,IAAIE,EAAkB96C,OAAO6B,OAAS,SAAU6O,EAAG0R,EAAG24B,EAAGC,QACnDp2C,IAAPo2C,IAAkBA,EAAKD,GAC3B,IAAIjD,EAAO93C,OAAO2Q,yBAAyByR,EAAG24B,GACzCjD,KAAS,QAASA,GAAQ11B,EAAE64B,WAAanD,EAAK91C,UAAY81C,EAAK71C,gBAClE61C,EAAO,CACL/1C,YAAY,EACZmxB,IAAK,WACH,OAAO9Q,EAAE24B,MAIf/6C,OAAOgR,eAAeN,EAAGsqC,EAAIlD,IAC3B,SAAUpnC,EAAG0R,EAAG24B,EAAGC,QACVp2C,IAAPo2C,IAAkBA,EAAKD,GAC3BrqC,EAAEsqC,GAAM54B,EAAE24B,IAEL,SAASG,EAAa94B,EAAG1R,GAC9B,IAAK,IAAI4mC,KAAKl1B,EAAa,YAANk1B,GAAoBt3C,OAAOC,UAAUwB,eAAetB,KAAKuQ,EAAG4mC,IAAIwD,EAAgBpqC,EAAG0R,EAAGk1B,GAEtG,SAAS6D,EAASzqC,GACvB,IAAIgnC,EAAsB,oBAAX/2C,QAAyBA,OAAOC,SAC7CwhB,EAAIs1B,GAAKhnC,EAAEgnC,GACXh4C,EAAI,EACN,GAAI0iB,EAAG,OAAOA,EAAEjiB,KAAKuQ,GACrB,GAAIA,GAAyB,kBAAbA,EAAE/Q,OAAqB,MAAO,CAC5C+R,KAAM,WAEJ,OADIhB,GAAKhR,GAAKgR,EAAE/Q,SAAQ+Q,OAAI,GACrB,CACL5O,MAAO4O,GAAKA,EAAEhR,KACdiS,MAAOjB,KAIb,MAAM,IAAIxP,UAAUw2C,EAAI,0BAA4B,mCAE/C,SAAS0D,EAAO1qC,EAAGa,GACxB,IAAI6Q,EAAsB,oBAAXzhB,QAAyB+P,EAAE/P,OAAOC,UACjD,IAAKwhB,EAAG,OAAO1R,EACf,IACEF,EAEAD,EAHE7Q,EAAI0iB,EAAEjiB,KAAKuQ,GAEb2qC,EAAK,GAEP,IACE,WAAc,IAAN9pC,GAAgBA,KAAM,MAAQf,EAAI9Q,EAAEgS,QAAQC,MAAM0pC,EAAGnxC,KAAKsG,EAAE1O,OACpE,MAAOw5C,GACP/qC,EAAI,CACF+qC,MAAOA,GAET,QACA,IACM9qC,IAAMA,EAAEmB,OAASyQ,EAAI1iB,EAAU,SAAI0iB,EAAEjiB,KAAKT,GAC9C,QACA,GAAI6Q,EAAG,MAAMA,EAAE+qC,OAGnB,OAAOD,EAIF,SAASE,IACd,IAAK,IAAIF,EAAK,GAAI37C,EAAI,EAAGA,EAAI4B,UAAU3B,OAAQD,IAAK27C,EAAKA,EAAG1yC,OAAOyyC,EAAO95C,UAAU5B,KACpF,OAAO27C,EAIF,SAASG,IACd,IAAK,IAAI9D,EAAI,EAAGh4C,EAAI,EAAG+7C,EAAKn6C,UAAU3B,OAAQD,EAAI+7C,EAAI/7C,IAAKg4C,GAAKp2C,UAAU5B,GAAGC,OACxE,IAAI6Q,EAAI3Q,MAAM63C,GAAIqD,EAAI,EAA3B,IAA8Br7C,EAAI,EAAGA,EAAI+7C,EAAI/7C,IAAK,IAAK,IAAI0L,EAAI9J,UAAU5B,GAAIutB,EAAI,EAAGyuB,EAAKtwC,EAAEzL,OAAQstB,EAAIyuB,EAAIzuB,IAAK8tB,IAAKvqC,EAAEuqC,GAAK3vC,EAAE6hB,GAC9H,OAAOzc,EAEF,SAASmrC,EAAc58C,EAAIH,EAAMg9C,GACtC,GAAIA,GAA6B,IAArBt6C,UAAU3B,OAAc,IAAK,IAA4B07C,EAAxB37C,EAAI,EAAG4R,EAAI1S,EAAKe,OAAYD,EAAI4R,EAAG5R,KAC1E27C,GAAQ37C,KAAKd,IACVy8C,IAAIA,EAAKx7C,MAAMI,UAAU+R,MAAM7R,KAAKvB,EAAM,EAAGc,IAClD27C,EAAG37C,GAAKd,EAAKc,IAGjB,OAAOX,EAAG4J,OAAO0yC,GAAMx7C,MAAMI,UAAU+R,MAAM7R,KAAKvB,IAE7C,SAASi9C,EAAQjB,GACtB,OAAO/3C,gBAAgBg5C,GAAWh5C,KAAK+3C,EAAIA,EAAG/3C,MAAQ,IAAIg5C,EAAQjB,GAE7D,SAASkB,EAAiB1C,EAASU,EAAYE,GACpD,IAAKr5C,OAAOo7C,cAAe,MAAM,IAAI76C,UAAU,wCAC/C,IACExB,EADE46C,EAAIN,EAAUl3C,MAAMs2C,EAASU,GAAc,IAE7CkC,EAAI,GACN,OAAOt8C,EAAI,GAAIi7C,EAAK,QAASA,EAAK,SAAUA,EAAK,UAAWj7C,EAAEiB,OAAOo7C,eAAiB,WACpF,OAAOl5C,MACNnD,EACH,SAASi7C,EAAKppC,GACR+oC,EAAE/oC,KAAI7R,EAAE6R,GAAK,SAAUqpC,GACzB,OAAO,IAAIxK,SAAQ,SAAUhlC,EAAGC,GAC9B2wC,EAAE9xC,KAAK,CAACqH,EAAGqpC,EAAGxvC,EAAGC,IAAM,GAAK4wC,EAAO1qC,EAAGqpC,QAI5C,SAASqB,EAAO1qC,EAAGqpC,GACjB,KAMYpqC,EALL8pC,EAAE/oC,GAAGqpC,IAMV94C,iBAAiB+5C,EAAUzL,QAAQC,QAAQ7/B,EAAE1O,MAAM84C,GAAGzG,KAAK+H,EAASjC,GAAUkC,EAAOH,EAAE,GAAG,GAAIxrC,GAL9F,MAAOD,GACP4rC,EAAOH,EAAE,GAAG,GAAIzrC,GAGpB,IAAcC,EAGd,SAAS0rC,EAAQp6C,GACfm6C,EAAO,OAAQn6C,GAEjB,SAASm4C,EAAOn4C,GACdm6C,EAAO,QAASn6C,GAElB,SAASq6C,EAAO1qC,EAAGmpC,GACbnpC,EAAEmpC,GAAIoB,EAAE5iC,QAAS4iC,EAAEr8C,QAAQs8C,EAAOD,EAAE,GAAG,GAAIA,EAAE,GAAG,KAGjD,SAASI,EAAiB1rC,GAC/B,IAAIhR,EAAG43C,EACP,OAAO53C,EAAI,GAAIi7C,EAAK,QAASA,EAAK,SAAS,SAAUpqC,GACnD,MAAMA,KACJoqC,EAAK,UAAWj7C,EAAEiB,OAAOC,UAAY,WACvC,OAAOiC,MACNnD,EACH,SAASi7C,EAAKppC,EAAGE,GACf/R,EAAE6R,GAAKb,EAAEa,GAAK,SAAUqpC,GACtB,OAAQtD,GAAKA,GAAK,CAChBx1C,MAAO+5C,EAAQnrC,EAAEa,GAAGqpC,IACpBjpC,MAAM,GACJF,EAAIA,EAAEmpC,GAAKA,GACbnpC,GAGD,SAAS4qC,EAAc3rC,GAC5B,IAAK/P,OAAOo7C,cAAe,MAAM,IAAI76C,UAAU,wCAC/C,IACExB,EADE0iB,EAAI1R,EAAE/P,OAAOo7C,eAEjB,OAAO35B,EAAIA,EAAEjiB,KAAKuQ,IAAMA,EAAqCyqC,EAASzqC,GAA2BhR,EAAI,GAAIi7C,EAAK,QAASA,EAAK,SAAUA,EAAK,UAAWj7C,EAAEiB,OAAOo7C,eAAiB,WAC9K,OAAOl5C,MACNnD,GACH,SAASi7C,EAAKppC,GACZ7R,EAAE6R,GAAKb,EAAEa,IAAM,SAAUqpC,GACvB,OAAO,IAAIxK,SAAQ,SAAUC,EAAS4J,IAK1C,SAAgB5J,EAAS4J,EAAQvuC,EAAGkvC,GAClCxK,QAAQC,QAAQuK,GAAGzG,MAAK,SAAUyG,GAChCvK,EAAQ,CACNvuC,MAAO84C,EACPjpC,KAAMjG,MAEPuuC,IAVckC,CAAO9L,EAAS4J,GAA7BW,EAAIlqC,EAAEa,GAAGqpC,IAA8BjpC,KAAMipC,EAAE94C,YAahD,SAASw6C,EAAqBC,EAAQC,GAQ3C,OAPIx8C,OAAOgR,eACThR,OAAOgR,eAAeurC,EAAQ,MAAO,CACnCz6C,MAAO06C,IAGTD,EAAOC,IAAMA,EAERD,EAGT,IAAIE,EAAqBz8C,OAAO6B,OAAS,SAAU6O,EAAGkqC,GACpD56C,OAAOgR,eAAeN,EAAG,UAAW,CAClC3O,YAAY,EACZD,MAAO84C,KAEP,SAAUlqC,EAAGkqC,GACflqC,EAAW,QAAIkqC,GAEV,SAAS8B,EAAaC,GAC3B,GAAIA,GAAOA,EAAI1B,WAAY,OAAO0B,EAClC,IAAI93C,EAAS,GACb,GAAW,MAAP83C,EAAa,IAAK,IAAI5B,KAAK4B,EAAe,YAAN5B,GAAmB/6C,OAAOC,UAAUwB,eAAetB,KAAKw8C,EAAK5B,IAAID,EAAgBj2C,EAAQ83C,EAAK5B,GAEtI,OADA0B,EAAmB53C,EAAQ83C,GACpB93C,EAEF,SAAS+3C,EAAgBD,GAC9B,OAAOA,GAAOA,EAAI1B,WAAa0B,EAAM,CACnCE,QAASF,GAGN,SAASG,EAAuBC,EAAUn0C,EAAOiwC,EAAMpnC,GAC5D,GAAa,MAATonC,IAAiBpnC,EAAG,MAAM,IAAIvQ,UAAU,iDAC5C,GAAqB,oBAAV0H,EAAuBm0C,IAAan0C,IAAU6I,GAAK7I,EAAMo0C,IAAID,GAAW,MAAM,IAAI77C,UAAU,4EACvG,MAAgB,MAAT23C,EAAepnC,EAAa,MAATonC,EAAepnC,EAAEtR,KAAK48C,GAAYtrC,EAAIA,EAAE3P,MAAQ8G,EAAMsqB,IAAI6pB,GAE/E,SAASE,EAAuBF,EAAUn0C,EAAO9G,EAAO+2C,EAAMpnC,GACnE,GAAa,MAATonC,EAAc,MAAM,IAAI33C,UAAU,kCACtC,GAAa,MAAT23C,IAAiBpnC,EAAG,MAAM,IAAIvQ,UAAU,iDAC5C,GAAqB,oBAAV0H,EAAuBm0C,IAAan0C,IAAU6I,GAAK7I,EAAMo0C,IAAID,GAAW,MAAM,IAAI77C,UAAU,2EACvG,MAAgB,MAAT23C,EAAepnC,EAAEtR,KAAK48C,EAAUj7C,GAAS2P,EAAIA,EAAE3P,MAAQA,EAAQ8G,EAAMq/B,IAAI8U,EAAUj7C,GAAQA,EAE7F,SAASo7C,EAAsBt0C,EAAOm0C,GAC3C,GAAiB,OAAbA,GAAyC,kBAAbA,GAA6C,oBAAbA,EAAyB,MAAM,IAAI77C,UAAU,0CAC7G,MAAwB,oBAAV0H,EAAuBm0C,IAAan0C,EAAQA,EAAMo0C,IAAID,GAE/D,SAASI,EAAwBC,EAAKt7C,EAAOmuC,GAClD,GAAc,OAAVnuC,QAA4B,IAAVA,EAAkB,CACtC,GAAqB,kBAAVA,GAAuC,oBAAVA,EAAsB,MAAM,IAAIZ,UAAU,oBAClF,IAAIm8C,EACJ,GAAIpN,EAAO,CACT,IAAKtvC,OAAO28C,aAAc,MAAM,IAAIp8C,UAAU,uCAC9Cm8C,EAAUv7C,EAAMnB,OAAO28C,cAEzB,QAAgB,IAAZD,EAAoB,CACtB,IAAK18C,OAAO08C,QAAS,MAAM,IAAIn8C,UAAU,kCACzCm8C,EAAUv7C,EAAMnB,OAAO08C,SAEzB,GAAuB,oBAAZA,EAAwB,MAAM,IAAIn8C,UAAU,0BACvDk8C,EAAIG,MAAMrzC,KAAK,CACbpI,MAAOA,EACPu7C,QAASA,EACTpN,MAAOA,SAEAA,GACTmN,EAAIG,MAAMrzC,KAAK,CACb+lC,OAAO,IAGX,OAAOnuC,EAET,IAAI07C,EAA8C,oBAApBC,gBAAiCA,gBAAkB,SAAUnC,EAAOoC,EAAYC,GAC5G,IAAIptC,EAAI,IAAIqH,MAAM+lC,GAClB,OAAOptC,EAAE0B,KAAO,kBAAmB1B,EAAE+qC,MAAQA,EAAO/qC,EAAEmtC,WAAaA,EAAYntC,GAE1E,SAASqtC,EAAmBR,GACjC,SAASS,EAAKttC,GACZ6sC,EAAI9B,MAAQ8B,EAAIU,SAAW,IAAIN,EAAiBjtC,EAAG6sC,EAAI9B,MAAO,4CAA8C/qC,EAC5G6sC,EAAIU,UAAW,EAiBjB,OAfA,SAASpsC,IACP,KAAO0rC,EAAIG,MAAM59C,QAAQ,CACvB,IAAIo+C,EAAMX,EAAIG,MAAM95B,MACpB,IACE,IAAI5e,EAASk5C,EAAIV,SAAWU,EAAIV,QAAQl9C,KAAK49C,EAAIj8C,OACjD,GAAIi8C,EAAI9N,MAAO,OAAOG,QAAQC,QAAQxrC,GAAQsvC,KAAKziC,GAAM,SAAUnB,GAEjE,OADAstC,EAAKttC,GACEmB,OAET,MAAOnB,GACPstC,EAAKttC,IAGT,GAAI6sC,EAAIU,SAAU,MAAMV,EAAI9B,MAEvB5pC,GAEM,WACb6lC,UAAWA,EACXE,SAAUA,EACVE,OAAQA,EACRC,WAAYA,EACZM,QAASA,EACTuB,WAAYA,EACZI,UAAWA,EACXQ,YAAaA,EACbS,gBAAiBA,EACjBI,aAAcA,EACdC,SAAUA,EACVC,OAAQA,EACRG,SAAUA,EACVC,eAAgBA,EAChBG,cAAeA,EACfE,QAASA,EACTC,iBAAkBA,EAClBM,iBAAkBA,EAClBC,cAAeA,EACfC,qBAAsBA,EACtBI,aAAcA,EACdE,gBAAiBA,EACjBE,uBAAwBA,EACxBG,uBAAwBA,EACxBC,sBAAuBA,EACvBC,wBAAyBA,EACzBS,mBAAoBA,I,gCCvgBtB,qLAASxsC,EAAe3R,EAAKC,GAAK,OAKlC,SAAyBD,GAAO,GAAII,MAAMC,QAAQL,GAAM,OAAOA,EALtB4R,CAAgB5R,IAIzD,SAA+B+Q,EAAGc,GAAK,IAAIzJ,EAAI,MAAQ2I,EAAI,KAAO,oBAAsB7P,QAAU6P,EAAE7P,OAAOC,WAAa4P,EAAE,cAAe,GAAI,MAAQ3I,EAAG,CAAE,IAAI0I,EAAGgB,EAAG7R,EAAG8R,EAAGpG,EAAI,GAAIqG,GAAI,EAAIf,GAAI,EAAI,IAAM,GAAIhR,GAAKmI,EAAIA,EAAE1H,KAAKqQ,IAAIkB,KAAM,IAAMJ,EAAG,CAAE,GAAItR,OAAO6H,KAAOA,EAAG,OAAQ4J,GAAI,OAAW,OAASA,GAAKlB,EAAI7Q,EAAES,KAAK0H,IAAI8J,QAAUvG,EAAElB,KAAKqG,EAAEzO,OAAQsJ,EAAEzL,SAAW2R,GAAIG,GAAI,IAAO,MAAOjB,GAAKE,GAAI,EAAIa,EAAIf,EAAK,QAAU,IAAM,IAAKiB,GAAK,MAAQ5J,EAAE+J,SAAWJ,EAAI3J,EAAE+J,SAAU5R,OAAOwR,KAAOA,GAAI,OAAU,QAAU,GAAId,EAAG,MAAMa,GAAO,OAAOnG,GAJ7cyG,CAAsBpS,EAAKC,IAE5F,SAAqCgR,EAAGoB,GAAU,IAAKpB,EAAG,OAAQ,GAAiB,kBAANA,EAAgB,OAAOqB,EAAkBrB,EAAGoB,GAAS,IAAIP,EAAIvR,OAAOC,UAAUC,SAASC,KAAKuQ,GAAGsB,MAAM,GAAI,GAAc,WAANT,GAAkBb,EAAE5P,cAAayQ,EAAIb,EAAE5P,YAAYmR,MAAM,GAAU,QAANV,GAAqB,QAANA,EAAa,OAAO1R,MAAMjB,KAAK8R,GAAI,GAAU,cAANa,GAAqB,2CAA2CW,KAAKX,GAAI,OAAOQ,EAAkBrB,EAAGoB,GAFpTK,CAA4B1S,EAAKC,IACnI,WAA8B,MAAM,IAAIwB,UAAU,6IADuFkR,GAGzI,SAASL,EAAkBtS,EAAK4S,IAAkB,MAAPA,GAAeA,EAAM5S,EAAIE,UAAQ0S,EAAM5S,EAAIE,QAAQ,IAAK,IAAID,EAAI,EAAG4S,EAAO,IAAIzS,MAAMwS,GAAM3S,EAAI2S,EAAK3S,IAAK4S,EAAK5S,GAAKD,EAAIC,GAAI,OAAO4S,EAG5K,SAAShC,EAAQC,EAAGC,GAAK,IAAI3I,EAAI7H,OAAOyE,KAAK8L,GAAI,GAAIvQ,OAAOyQ,sBAAuB,CAAE,IAAIC,EAAI1Q,OAAOyQ,sBAAsBF,GAAIC,IAAME,EAAIA,EAAE7G,QAAO,SAAU2G,GAAK,OAAOxQ,OAAO2Q,yBAAyBJ,EAAGC,GAAGzO,eAAiB8F,EAAEqC,KAAKpH,MAAM+E,EAAG6I,GAAM,OAAO7I,EAC3P,SAAS+I,EAAcL,GAAK,IAAK,IAAIC,EAAI,EAAGA,EAAIlP,UAAU3B,OAAQ6Q,IAAK,CAAE,IAAI3I,EAAI,MAAQvG,UAAUkP,GAAKlP,UAAUkP,GAAK,GAAIA,EAAI,EAAIF,EAAQtQ,OAAO6H,IAAI,GAAI/C,SAAQ,SAAU0L,GAAKK,EAAgBN,EAAGC,EAAG3I,EAAE2I,OAAUxQ,OAAO8Q,0BAA4B9Q,OAAO+Q,iBAAiBR,EAAGvQ,OAAO8Q,0BAA0BjJ,IAAMyI,EAAQtQ,OAAO6H,IAAI/C,SAAQ,SAAU0L,GAAKxQ,OAAOgR,eAAeT,EAAGC,EAAGxQ,OAAO2Q,yBAAyB9I,EAAG2I,OAAW,OAAOD,EACnb,SAASM,EAAgBhQ,EAAKW,EAAKM,GACnC,IAAiCpC,EAD8L,OAAnL8B,EAC2B,iBAAtC9B,EACjC,SAAsBmI,EAAG2I,GAAK,GAAI,iBAAmB3I,IAAMA,EAAG,OAAOA,EAAG,IAAI0I,EAAI1I,EAAElH,OAAOsQ,aAAc,QAAI,IAAWV,EAAG,CAAE,IAAI7Q,EAAI6Q,EAAEpQ,KAAK0H,EAAG2I,GAAK,WAAY,GAAI,iBAAmB9Q,EAAG,OAAOA,EAAG,MAAM,IAAIwB,UAAU,gDAAmD,OAAQ,WAAasP,EAAIU,OAASlE,QAAQnF,GAD9QsJ,CAD4B3P,EACZ,WAAyC9B,EAAIA,EAAI,MADpBmB,EAAOb,OAAOgR,eAAenQ,EAAKW,EAAK,CAAEM,MAAOA,EAAOC,YAAY,EAAME,cAAc,EAAMD,UAAU,IAAkBnB,EAAIW,GAAOM,EAAgBjB,EAUtO,SAASm9C,EAAUC,EAAOr/C,EAAMG,GAC9B,MAAMm/C,EAAWD,EAAMjsC,QAEvB,OADAksC,EAAS9xC,OAAOrN,EAAK,EAAIm/C,EAASv+C,OAASZ,EAAKA,EAAI,EAAGm/C,EAAS9xC,OAAOxN,EAAM,GAAG,IACzEs/C,EAYT,SAASC,EAAeC,EAAO3P,GAC7B,OAAO2P,EAAMzxC,OAAO,CAAC0I,EAAaL,EAAI5N,KACpC,MAAM+qB,EAAOsc,EAAMvb,IAAIle,GAIvB,OAHImd,IACF9c,EAAYjO,GAAS+qB,GAEhB9c,GACNxV,MAAMu+C,EAAMz+C,SAEjB,SAAS0+C,EAAaj3C,GACpB,OAAiB,OAAVA,GAAkBA,GAAS,EAkFpC,MAAMk3C,EAAsBv4C,IAC1B,IAAI0oC,EAAQ1oC,EAAK0oC,MACf8P,EAAcx4C,EAAKw4C,YACnBC,EAAYz4C,EAAKy4C,UACjBp3C,EAAQrB,EAAKqB,MACf,MAAMq3C,EAAWT,EAAUvP,EAAO+P,EAAWD,GACvCG,EAAUjQ,EAAMrnC,GAChBg9B,EAAUqa,EAASr3C,GACzB,OAAKg9B,GAAYsa,EAGV,CACLvoC,EAAGiuB,EAAQ59B,KAAOk4C,EAAQl4C,KAC1B6P,EAAG+tB,EAAQ79B,IAAMm4C,EAAQn4C,IACzByQ,OAAQotB,EAAQx9B,MAAQ83C,EAAQ93C,MAChCqQ,OAAQmtB,EAAQz9B,OAAS+3C,EAAQ/3C,QAN1B,MAoCLg4C,EAAiB,CACrB3nC,OAAQ,EACRC,OAAQ,GAEJ2nC,EAA8B74C,IAClC,IAAI84C,EACJ,IAAIN,EAAcx4C,EAAKw4C,YACrBO,EAAqB/4C,EAAK2gC,eAC1Bt/B,EAAQrB,EAAKqB,MACbqnC,EAAQ1oC,EAAK0oC,MACb+P,EAAYz4C,EAAKy4C,UACnB,MAAM9X,EAA8D,OAA5CmY,EAAqBpQ,EAAM8P,IAAwBM,EAAqBC,EAChG,IAAKpY,EACH,OAAO,KAET,GAAIt/B,IAAUm3C,EAAa,CACzB,MAAMQ,EAAgBtQ,EAAM+P,GAC5B,OAAKO,EAGEnuC,EAAc,CACnBuF,EAAG,EACHE,EAAGkoC,EAAcC,EAAYO,EAAcx4C,IAAMw4C,EAAcp4C,QAAU+/B,EAAengC,IAAMmgC,EAAe//B,QAAUo4C,EAAcx4C,IAAMmgC,EAAengC,KACzJo4C,GALM,KAOX,MAAMK,EAkBR,SAAsBC,EAAa73C,EAAOm3C,GACxC,MAAMra,EAAc+a,EAAY73C,GAC1B83C,EAAeD,EAAY73C,EAAQ,GACnC+3C,EAAWF,EAAY73C,EAAQ,GACrC,IAAK88B,EACH,OAAO,EAET,GAAIqa,EAAcn3C,EAChB,OAAO83C,EAAehb,EAAY39B,KAAO24C,EAAa34C,IAAM24C,EAAav4C,QAAUw4C,EAAWA,EAAS54C,KAAO29B,EAAY39B,IAAM29B,EAAYv9B,QAAU,EAExJ,OAAOw4C,EAAWA,EAAS54C,KAAO29B,EAAY39B,IAAM29B,EAAYv9B,QAAUu4C,EAAehb,EAAY39B,KAAO24C,EAAa34C,IAAM24C,EAAav4C,QAAU,EA5BtIy4C,CAAa3Q,EAAOrnC,EAAOm3C,GAC3C,OACS3tC,EADLxJ,EAAQm3C,GAAen3C,GAASo3C,EACb,CACnBroC,EAAG,EACHE,GAAIqwB,EAAe//B,OAASq4C,GAG5B53C,EAAQm3C,GAAen3C,GAASo3C,EACb,CACnBroC,EAAG,EACHE,EAAGqwB,EAAe//B,OAASq4C,GAGV,CACnB7oC,EAAG,EACHE,EAAG,GAVAsoC,IAyBP,MACMU,EAAuB,IAAMC,cAAc,CAC/Cf,aAAc,EACdgB,YAHgB,WAIhBC,mBAAmB,EACnBpB,MAAO,GACPI,WAAY,EACZiB,gBAAgB,EAChBC,YAAa,GACb5Z,SAAUwY,EACV9xC,SAAU,CACR+iB,WAAW,EACXsW,WAAW,KAGf,SAAS8Z,EAAgB55C,GACvB,IAAI/C,EAAW+C,EAAK/C,SAClBgS,EAAKjP,EAAKiP,GACV4qC,EAAmB75C,EAAKq4C,MACxByB,EAAgB95C,EAAK+/B,SACrBA,OAA6B,IAAlB+Z,EAA2BvB,EAAsBuB,EAC5DnO,EAAgB3rC,EAAKyG,SACrBszC,OAAiC,IAAlBpO,GAAmCA,EACpD,MAAMyF,EAAiB,cACrBznB,EAASynB,EAAeznB,OACxBwW,EAAciR,EAAejR,YAC7BpT,EAAiBqkB,EAAerkB,eAChCnD,EAAOwnB,EAAexnB,KACtBqX,EAA6BmQ,EAAenQ,2BACxCuY,EAAc,YA7BJ,WA6B2BvqC,GACrCyqC,EAAiBrhB,QAA6B,OAArB8H,EAAY/T,MACrCisB,EAAQ,kBAAQ,IAAMwB,EAAiBv4C,IAAIkH,GAAwB,kBAATA,GAAqB,OAAQA,EAAOA,EAAKyG,GAAKzG,GAAO,CAACqxC,IAChHzN,EAAuB,MAAVziB,EACb6uB,EAAc7uB,EAAS0uB,EAAMr5C,QAAQ2qB,EAAO1a,KAAO,EACnDwpC,EAAY7uB,EAAOyuB,EAAMr5C,QAAQ4qB,EAAK3a,KAAO,EAC7C+qC,EAAmB,iBAAO3B,GAC1B4B,GAxNR,SAAoB50C,EAAGC,GACrB,GAAID,IAAMC,EACR,OAAO,EAET,GAAID,EAAEzL,SAAW0L,EAAE1L,OACjB,OAAO,EAET,IAAK,IAAID,EAAI,EAAGA,EAAI0L,EAAEzL,OAAQD,IAC5B,GAAI0L,EAAE1L,KAAO2L,EAAE3L,GACb,OAAO,EAGX,OAAO,EA4MmBugD,CAAW7B,EAAO2B,EAAiBnsC,SACvD4rC,GAAmC,IAAfhB,IAAqC,IAAjBD,GAAsByB,EAC9DxzC,EA5MR,SAA2BA,GACzB,MAAwB,mBAAbA,EACF,CACL+iB,UAAW/iB,EACXq5B,UAAWr5B,GAGRA,EAqMU0zC,CAAkBJ,GACnC,YAA0B,KACpBE,GAAoB7N,GACtBnL,EAA2BoX,IAE5B,CAAC4B,EAAkB5B,EAAOjM,EAAYnL,IACzC,oBAAU,KACR+Y,EAAiBnsC,QAAUwqC,GAC1B,CAACA,IACJ,MAAM+B,EAAe,kBAAQ,KAAM,CACjC5B,cACAgB,cACA/yC,WACAgzC,oBACApB,QACAI,YACAiB,iBACAC,YAAavB,EAAeC,EAAOtrB,GACnCgT,aAGF,CAACyY,EAAagB,EAAa/yC,EAAS+iB,UAAW/iB,EAASq5B,UAAW2Z,EAAmBpB,EAAOI,EAAW1rB,EAAgB2sB,EAAgB3Z,IACxI,OAAoB,IAAMngC,cAAc05C,EAAQ/N,SAAU,CACxDxvC,MAAOq+C,GACNn9C,GAEL,MAAMo9C,EAAwBr6C,IAC5B,IAAIiP,EAAKjP,EAAKiP,GAId,OAAOgpC,EAHGj4C,EAAKq4C,MACCr4C,EAAKw4C,YACPx4C,EAAKy4C,WAC6Bz5C,QAAQiQ,IAEpDqrC,EAA8B/xC,IAClC,IAAIixC,EAAcjxC,EAAMixC,YACtBe,EAAYhyC,EAAMgyC,UAClBC,EAAcjyC,EAAMiyC,YACpBn5C,EAAQkH,EAAMlH,MACdg3C,EAAQ9vC,EAAM8vC,MACdoC,EAAWlyC,EAAMkyC,SACjBC,EAAgBnyC,EAAMmyC,cACtBC,EAAsBpyC,EAAMoyC,oBAE9B,SADepyC,EAAM7G,aACD84C,MAGhBE,IAAkBrC,GAASh3C,IAAUo5C,OAGrCF,GAGGE,IAAap5C,GAASm4C,IAAgBmB,KAEzClM,EAAoB,CACxB1wC,SAAU,IACVV,OAAQ,QAGJu9C,EAAkC,IAAIxpC,WAAWjX,SAAS,CAC9DkX,SAFyB,YAGzBtT,SAAU,EACVV,OAAQ,WAEJw9C,EAAoB,CACxB5O,gBAAiB,YA+CnB,SAAS6O,EAAY96C,GACnB,IAAI+6C,EAAwB/6C,EAAKg7C,qBAC/BA,OAAiD,IAA1BD,EAAmCT,EAA8BS,EACxFE,EAAwBj7C,EAAK4rC,WAC7BsP,EAAgBl7C,EAAKyG,SACrB00C,EAAan7C,EAAKqJ,KAClB+xC,EAAmBp7C,EAAKq7C,YACxBA,OAAmC,IAArBD,EAA8Bf,EAAwBe,EACpEnsC,EAAKjP,EAAKiP,GACVqsC,EAAgBt7C,EAAK+/B,SACrBgN,EAAuB/sC,EAAK+sC,qBAC5B8B,EAAkB7uC,EAAK0B,WACvBA,OAAiC,IAApBmtC,EAA6BJ,EAAoBI,EAChE,MAAMtM,EAAc,qBAAW+W,GAC7BjB,EAAQ9V,EAAY8V,MACpBmB,EAAcjX,EAAYiX,YAC1BhB,EAAcjW,EAAYiW,YAC1B+C,EAAiBhZ,EAAY97B,SAC7BgzC,EAAoBlX,EAAYkX,kBAChCE,EAAcpX,EAAYoX,YAC1BlB,EAAYlW,EAAYkW,UACxBiB,EAAiBnX,EAAYmX,eAC7B8B,EAAiBjZ,EAAYxC,SACzBt5B,EAuJR,SAAgCy0C,EAAeK,GAC7C,IAAIE,EAAuBC,EAC3B,GAA6B,mBAAlBR,EACT,MAAO,CACL1xB,UAAW0xB,EAEXpb,WAAW,GAGf,MAAO,CACLtW,UAAiG,OAArFiyB,EAAyC,MAAjBP,OAAwB,EAASA,EAAc1xB,WAAqBiyB,EAAwBF,EAAe/xB,UAC/IsW,UAAiG,OAArF4b,EAAyC,MAAjBR,OAAwB,EAASA,EAAcpb,WAAqB4b,EAAwBH,EAAezb,WAlKhI6b,CAAuBT,EAAeK,GACjDl6C,EAAQg3C,EAAMr5C,QAAQiQ,GACtB5F,EAAO,kBAAQ,IAAMwB,EAAc,CACvC+wC,SAAU,CACRpC,cACAn4C,QACAg3C,UAED8C,GAAa,CAAC3B,EAAa2B,EAAY95C,EAAOg3C,IAC3CwD,EAA4B,kBAAQ,IAAMxD,EAAMpsC,MAAMosC,EAAMr5C,QAAQiQ,IAAM,CAACopC,EAAOppC,IAClF6sC,EAAgB,YAAa,CAC/B7sC,KACA5F,OACA5C,SAAUA,EAASq5B,UACnBiN,qBAAsBliC,EAAc,CAClCyiC,sBAAuBuO,GACtB9O,KAEL3gB,EAAO0vB,EAAc1vB,KACrBvsB,EAAOi8C,EAAcj8C,KACrB+tC,EAASkO,EAAclO,OACvBmO,EAAsBD,EAAcltC,WAChCotC,EAAgB,YAAa,CAC/B/sC,KACA5F,OACAuiC,WAAY/gC,EAAcA,EAAc,GAAIgwC,GAAoBI,GAChEx0C,SAAUA,EAAS+iB,YAErBG,EAASqyB,EAAcryB,OACvB+W,EAAiBsb,EAActb,eAC/BC,EAAiBqb,EAAcrb,eAC/BiL,EAAaoQ,EAAcpQ,WAC3BqQ,EAAsBD,EAAcptC,WACpColB,EAAYgoB,EAAchoB,UAC1BoY,EAAa4P,EAAc5P,WAC3BxiB,EAAOoyB,EAAcpyB,KACrB2iB,EAAsByP,EAAczP,oBACpCzzC,GAAYkjD,EAAcljD,UACtB8V,GAAa,YAAgBmtC,EAAqBE,GAClD1B,GAAYliB,QAAQ1O,GACpBuyB,GAAe3B,KAAcd,GAAqBnB,EAAaE,IAAgBF,EAAaG,GAC5F0D,IAA4BzC,GAAkBtN,EAC9CgQ,GAAyBD,IAA4BD,GAAepjD,GAAY,KAEhFq3C,GAAiB+L,GAAyC,MAA1BE,GAAiCA,IADrC,MAAjBd,EAAwBA,EAAgBE,GACgD,CACvG9S,MAAOiR,EACPhZ,iBACA6X,cACAC,YACAp3C,UACG,KACCo5C,GAAWnC,EAAaE,IAAgBF,EAAaG,GAAa4C,EAAY,CAClFpsC,KACAopC,QACAG,cACAC,cACGp3C,EACCsjC,GAAqB,MAAVhb,OAAiB,EAASA,EAAO1a,GAC5Cg+B,GAAW,iBAAO,CACtBtI,YACA0T,QACAoC,YACAjB,gBAEIS,GAAmB5B,IAAUpL,GAASp/B,QAAQwqC,MAC9CgE,GAA6BrB,EAAqB,CACtDrxB,SACA6vB,cACApN,aACAmO,aACAtrC,KACA5N,QACAg3C,QACAoC,SAAUxN,GAASp/B,QAAQ4sC,SAC3BC,cAAezN,GAASp/B,QAAQwqC,MAChCsC,oBAAqB1N,GAASp/B,QAAQ2rC,YACtC93C,aACA84C,YAA0C,MAA7BvN,GAASp/B,QAAQ82B,WAE1B2X,GA7IR,SAA6Bt8C,GAC3B,IAAIyG,EAAWzG,EAAKyG,SAClBpF,EAAQrB,EAAKqB,MACbxB,EAAOG,EAAKH,KACZusB,EAAOpsB,EAAKosB,KACd,MACE9B,EAAajf,EADG,mBAAS,MACc,GACvCixC,EAAmBhyB,EAAW,GAC9BiyB,EAAsBjyB,EAAW,GAC7BkyB,EAAgB,iBAAOn7C,GA4B7B,OA3BA,YAA0B,KACxB,IAAKoF,GAAYpF,IAAUm7C,EAAc3uC,SAAWhO,EAAKgO,QAAS,CAChE,MAAMg3B,EAAUzY,EAAKve,QACrB,GAAIg3B,EAAS,CACX,MAAMh3B,EAAU,YAAchO,EAAKgO,QAAS,CAC1CghB,iBAAiB,IAEbyF,EAAQ,CACZlkB,EAAGy0B,EAAQpkC,KAAOoN,EAAQpN,KAC1B6P,EAAGu0B,EAAQrkC,IAAMqN,EAAQrN,IACzByQ,OAAQ4zB,EAAQhkC,MAAQgN,EAAQhN,MAChCqQ,OAAQ2zB,EAAQjkC,OAASiN,EAAQjN,SAE/B0zB,EAAMlkB,GAAKkkB,EAAMhkB,IACnBisC,EAAoBjoB,IAItBjzB,IAAUm7C,EAAc3uC,UAC1B2uC,EAAc3uC,QAAUxM,IAEzB,CAACoF,EAAUpF,EAAOxB,EAAMusB,IAC3B,oBAAU,KACJkwB,GACFC,EAAoB,OAErB,CAACD,IACGA,EAwGkBG,CAAoB,CAC3Ch2C,UAAW41C,GACXh7C,QACAxB,OACAusB,SA0BF,OAxBA,oBAAU,KACJmuB,IAAatN,GAASp/B,QAAQ4sC,WAAaA,KAC7CxN,GAASp/B,QAAQ4sC,SAAWA,IAE1BjB,IAAgBvM,GAASp/B,QAAQ2rC,cACnCvM,GAASp/B,QAAQ2rC,YAAcA,GAE7BnB,IAAUpL,GAASp/B,QAAQwqC,QAC7BpL,GAASp/B,QAAQwqC,MAAQA,IAE1B,CAACkC,GAAWE,GAAUjB,EAAanB,IACtC,oBAAU,KACR,GAAI1T,KAAasI,GAASp/B,QAAQ82B,SAChC,OAEF,GAAIA,KAAasI,GAASp/B,QAAQ82B,SAEhC,YADAsI,GAASp/B,QAAQ82B,SAAWA,IAG9B,MAAMvL,EAAY/C,WAAW,KAC3B4W,GAASp/B,QAAQ82B,SAAWA,IAC3B,IACH,MAAO,IAAM5K,aAAaX,IACzB,CAACuL,KACG,CACLhb,SACA6uB,cACA5M,aACAviC,OACA+iB,OACA/qB,QACAo5C,YACApC,QACAzK,SACA2M,aACAnO,aACApY,YACAn0B,OACA44C,YACA7uB,OACAhb,cACA29B,sBACAwP,sBACAE,sBACAnjD,UAA+B,MAApBwjD,GAA2BA,GAAmBnM,GACzDzuC,WAEF,WACE,GAEA46C,IAEArC,IAAoBhN,GAASp/B,QAAQ4sC,WAAap5C,EAChD,OAAOu5C,EAET,GAAIuB,KAA6B,YAAgBzb,KAAoBh/B,EACnE,OAEF,GAAI64C,IAAa8B,GACf,OAAO,IAAIjrC,WAAWjX,SAAS0Q,EAAcA,EAAc,GAAInJ,GAAa,GAAI,CAC9E2P,SA9NmB,eAiOvB,OAlBYqrC,IA6CI,IAAajnB,KAAM,IAAaF,MAAO,IAAaG,GAAI,IAAaF,M,gCC3jBzFv7B,OAAOgR,eAAeX,EAAS,aAAc,CAC3CvO,OAAO,IAET,IAAI4gD,EAAe,WACjB,SAAS3xC,EAAiB1P,EAAQ6B,GAChC,IAAK,IAAIxD,EAAI,EAAGA,EAAIwD,EAAMvD,OAAQD,IAAK,CACrC,IAAIo5C,EAAa51C,EAAMxD,GACvBo5C,EAAW/2C,WAAa+2C,EAAW/2C,aAAc,EACjD+2C,EAAW72C,cAAe,EACtB,UAAW62C,IAAYA,EAAW92C,UAAW,GACjDhC,OAAOgR,eAAe3P,EAAQy3C,EAAWt3C,IAAKs3C,IAGlD,OAAO,SAAU73C,EAAa0hD,EAAYC,GAGxC,OAFID,GAAY5xC,EAAiB9P,EAAYhB,UAAW0iD,GACpDC,GAAa7xC,EAAiB9P,EAAa2hD,GACxC3hD,GAbQ,GAiBf4hD,EAAUC,EADD,EAAQ,IAGjBC,EAAcD,EADD,EAAQ,KAEzB,EAAQ,MACR,IACIE,EAAkBF,EADD,EAAQ,OAGzBG,EAAeH,EADD,EAAQ,OAE1B,SAASA,EAAuBjiD,GAC9B,OAAOA,GAAOA,EAAIo6C,WAAap6C,EAAM,CACnCg8C,QAASh8C,GAGb,SAASqiD,EAAmBzjD,GAC1B,GAAII,MAAMC,QAAQL,GAAM,CACtB,IAAK,IAAIC,EAAI,EAAG4S,EAAOzS,MAAMJ,EAAIE,QAASD,EAAID,EAAIE,OAAQD,IACxD4S,EAAK5S,GAAKD,EAAIC,GAEhB,OAAO4S,EAEP,OAAOzS,MAAMjB,KAAKa,GA4BtB,IAAIwG,EAAS,CACX8nB,QAAS,OACTo1B,WAAY,SACZC,eAAgB,SAChBC,SAAU,OACVz8C,MAAO,QAEL08C,EACuB,0BADvBA,EAEkB,qBAElBC,EAA4B,SAAUC,GAExC,SAASD,EAA0BrgD,IAtCrC,SAAyBlC,EAAUC,GACjC,KAAMD,aAAoBC,GACxB,MAAM,IAAIC,UAAU,qCAqCpBuiD,CAAgB5gD,KAAM0gD,GACtB,IAAIh7C,EAnCR,SAAoClG,EAAMlC,GACxC,IAAKkC,EACH,MAAM,IAAIC,eAAe,6DAE3B,OAAOnC,GAAyB,kBAATA,GAAqC,oBAATA,EAA8BkC,EAAPlC,EA+B5DujD,CAA2B7gD,MAAO0gD,EAA0BphD,WAAanC,OAAO2jD,eAAeJ,IAA4BpjD,KAAK0C,KAAMK,IAUlJ,OATAqF,EAAMK,MAAQ,CACZg7C,SAAU,GAAGj7C,OAAOu6C,EAAmBhgD,EAAM2gD,gBAC7CC,MAAO,GACPC,WAAY,IAEdx7C,EAAMy7C,aAAe,GACrBz7C,EAAM07C,WAAa17C,EAAM07C,WAAWnoB,KAAKvzB,GACzCA,EAAM27C,cAAgB37C,EAAM27C,cAAcpoB,KAAKvzB,GAC/CA,EAAM47C,kBAAoB57C,EAAM47C,kBAAkBroB,KAAKvzB,GAChDA,EAyQT,OAhTF,SAAmB5G,EAAUC,GAC3B,GAA0B,oBAAfA,GAA4C,OAAfA,EACtC,MAAM,IAAIV,UAAU,kEAAoEU,GAE1FD,EAAS1B,UAAYD,OAAO6B,OAAOD,GAAcA,EAAW3B,UAAW,CACrEa,YAAa,CACXgB,MAAOH,EACPI,YAAY,EACZC,UAAU,EACVC,cAAc,KAGdL,IAAY5B,OAAOkC,eAAiBlC,OAAOkC,eAAeP,EAAUC,GAAcD,EAASQ,UAAYP,GAc3GwiD,CAAUb,EAA2BC,GAerCd,EAAaa,EAA2B,CAAC,CACvC/hD,IAAK,qBACLM,MAAO,SAA4BuiD,EAAWh1C,EAAWi1C,GACnDj1C,EAAUy0C,QAAUjhD,KAAK+F,MAAMk7C,OACjCjhD,KAAKK,MAAMuR,SAAS5R,KAAK+F,MAAMk7C,MAAOjhD,KAAK+F,MAAMg7C,YAOpD,CACDpiD,IAAK,4BACLM,MAAO,SAAmCyL,GACpCA,EAAUs2C,gBAAkBhhD,KAAKK,MAAM2gD,eACzChhD,KAAK4K,SAAS,CACZm2C,SAAUr2C,EAAUs2C,kBAQzB,CACDriD,IAAK,eACLM,MAAO,SAAsByiD,GAC3B,IAAIC,EAAU,IAAM3hD,KAAKK,MAAMuhD,aAAan9C,KAAK,KAAK9G,QAAQ,MAAO,OAAS,KAC9E,OAAO,IAAI6gB,OAAOmjC,EAAS,KAAKtyC,KAAKqyC,KAMtC,CACD/iD,IAAK,aACLM,MAAO,SAAoByO,GAOzB,IANA,IAAI1E,EAAShJ,KACTihD,EAAQvzC,EAAElP,OAAOyiD,MACjBY,EAAkB,GAClBX,EAAa,GAGRrkD,EAAI,EAAGA,EAAIokD,EAAMnkD,OAAQD,IAAK,CACrC,IAAIilD,EAAOb,EAAMpkD,GACbklD,EAAY,CACd3yC,KAAM0yC,EAAK1yC,MAGRpP,KAAKgiD,aAAaF,EAAK1yC,MAQxB0yC,EAAKG,KAAOjiD,KAAKK,MAAM6hD,aACzBH,EAAY5kD,OAAOoB,OAAOwjD,EAAW,CACnCz6B,KAAMm5B,IAERS,EAAW75C,KAAK06C,IAGlBF,EAAgBx6C,KAAKrH,KAAKmiD,SAASL,KAdjCC,EAAY5kD,OAAOoB,OAAOwjD,EAAW,CACnCz6B,KAAMm5B,IAERS,EAAW75C,KAAK06C,IAapB/hD,KAAK4K,SAAS,CACZs2C,WAAYA,IAEd,IAAIkB,EAAcpiD,KAAKK,MAAM+hD,YAC7B7U,QAAQ8U,IAAIR,GAAiBvQ,MAAK,SAAUgR,GAC1C,IAAIC,EAAWH,EAAc,GAAKp5C,EAAOjD,MAAMg7C,SAAS5xC,QACpD8xC,EAAQmB,EAAc,GAAKp5C,EAAOjD,MAAMk7C,MAAM9xC,QAClDmzC,EAAargD,SAAQ,SAAUugD,GAC7BD,EAASl7C,KAAKm7C,EAAYC,SAC1BxB,EAAM55C,KAAKm7C,EAAYV,SAEzB94C,EAAO4B,SAAS,CACdm2C,SAAUwB,EACVtB,MAAOA,SAIZ,CACDtiD,IAAK,gBACLM,MAAO,SAAuByO,GAE5BA,EAAElP,OAAOS,MAAQ,OAMlB,CACDN,IAAK,WACLM,MAAO,SAAkB6iD,GACvB,OAAO,IAAIvU,SAAQ,SAAUC,EAAS4J,GACpC,IAAIsL,EAAS,IAAIC,WAGjBD,EAAOE,OAAS,SAAUl1C,GAExB,IAAI+0C,EAAU/0C,EAAElP,OAAOwD,OACvBygD,EAAUA,EAAQ9kD,QAAQ,UAAW,SAAWmkD,EAAK1yC,KAAO,WAC5Do+B,EAAQ,CACNsU,KAAMA,EACNW,QAASA,KAGbC,EAAOG,cAAcf,QAOxB,CACDnjD,IAAK,cACLM,MAAO,SAAqB6jD,GAC1B,IAAIt5C,EAASxJ,KACT+iD,EAAc/iD,KAAK+F,MAAMg7C,SAASiC,WAAU,SAAUt1C,GACxD,OAAOA,IAAMo1C,KAEXG,EAAmBjjD,KAAK+F,MAAMg7C,SAAS/5C,QAAO,SAAU0G,EAAGnJ,GAC7D,OAAOA,IAAUw+C,KAEfG,EAAgBljD,KAAK+F,MAAMk7C,MAAMj6C,QAAO,SAAU0G,EAAGnJ,GACvD,OAAOA,IAAUw+C,KAEnB/iD,KAAK4K,SAAS,CACZm2C,SAAUkC,EACVhC,MAAOiC,IACN,WACD15C,EAAOnJ,MAAMuR,SAASpI,EAAOzD,MAAMk7C,MAAOz3C,EAAOzD,MAAMg7C,eAO1D,CACDpiD,IAAK,eACLM,MAAO,WACL,IAAI6L,EAAS9K,KAEb,OADiBA,KAAK+F,MAAMm7C,WACV18C,KAAI,SAAUu9C,EAAWx9C,GACzC,OAAOy7C,EAAQhG,QAAQl3C,cAAc,MAAO,CAC1C2U,UAAW,gBAAkB3M,EAAOzK,MAAM8iD,WAC1CxkD,IAAK4F,EACLnC,MAAO0I,EAAOzK,MAAM+iD,YACnB,KAAMrB,EAAU3yC,KAAM,IAAK2yC,EAAUz6B,OAASm5B,EAA2B31C,EAAOzK,MAAMgjD,cAAgBv4C,EAAOzK,MAAMijD,oBAOzH,CACD3kD,IAAK,aACLM,MAAO,WACL,GAAIe,KAAKK,MAAMkjD,SACb,OAAOvD,EAAQhG,QAAQl3C,cAAc,MAAO,CAC1C+lB,IAAKu3B,EAAapG,QAClBviC,UAAW,aACX+rC,IAAK,kBAQV,CACD7kD,IAAK,cACLM,MAAO,WACL,GAAIe,KAAKK,MAAMojD,UACb,OAAOzD,EAAQhG,QAAQl3C,cAAc,IAAK,CACxC2U,UAAWzX,KAAKK,MAAMqjD,WACtBthD,MAAOpC,KAAKK,MAAMsjD,aACjB3jD,KAAKK,MAAMq3C,SAOjB,CACD/4C,IAAK,gBACLM,MAAO,WACL,OAAO+gD,EAAQhG,QAAQl3C,cAAc,MAAO,CAC1C2U,UAAW,yBACVuoC,EAAQhG,QAAQl3C,cAAcq9C,EAAgBnG,QAAS,CACxDx4C,eAAgB,OAChBC,eAAgB,OAChBW,MAAOgB,GACNpD,KAAK4jD,4BAET,CACDjlD,IAAK,wBACLM,MAAO,WACL,IAAIgM,EAASjL,KACb,OAAOA,KAAK+F,MAAMg7C,SAASv8C,KAAI,SAAUs+C,EAASv+C,GAChD,OAAOy7C,EAAQhG,QAAQl3C,cAAc,MAAO,CAC1CnE,IAAK4F,EACLkT,UAAW,0BACVuoC,EAAQhG,QAAQl3C,cAAc,MAAO,CACtC2U,UAAW,cACXosC,QAAS,WACP,OAAO54C,EAAO64C,YAAYhB,KAE3B,KAAM9C,EAAQhG,QAAQl3C,cAAc,MAAO,CAC5C+lB,IAAKi6B,EACLrrC,UAAW,gBACX+rC,IAAK,kBAQV,CACD7kD,IAAK,oBACLM,MAAO,WACLe,KAAKmhD,aAAa4C,UAEnB,CACDplD,IAAK,gBACLM,MAAO,WACLe,KAAK4K,SAAS,CACZm2C,SAAU,OAGb,CACDpiD,IAAK,SACLM,MAAO,WACL,IAAIuM,EAASxL,KACb,OAAOggD,EAAQhG,QAAQl3C,cAAc,MAAO,CAC1C2U,UAAW,gBAAkBzX,KAAKK,MAAMoX,UACxCrV,MAAOpC,KAAKK,MAAM+B,OACjB49C,EAAQhG,QAAQl3C,cAAc,MAAO,CACtC2U,UAAW,gBACXrV,MAAOpC,KAAKK,MAAM2jD,oBACjBhkD,KAAKikD,aAAcjkD,KAAKkkD,cAAelE,EAAQhG,QAAQl3C,cAAc,MAAO,CAC7E2U,UAAW,mBACVzX,KAAKmkD,gBAAiBnE,EAAQhG,QAAQl3C,cAAc,SAAU,CAC/DwkB,KAAMtnB,KAAKK,MAAM+jD,WACjB3sC,UAAW,oBAAsBzX,KAAKK,MAAMgkD,gBAC5CjiD,MAAOpC,KAAKK,MAAMikD,aAClBT,QAAS7jD,KAAKshD,mBACbthD,KAAKK,MAAMkkD,YAAavE,EAAQhG,QAAQl3C,cAAc,QAAS,CAChEwkB,KAAM,OACN1a,IAAK,SAAa43C,GAChB,OAAOh5C,EAAO21C,aAAeqD,GAE/Bp1C,KAAMpP,KAAKK,MAAM+O,KACjBq1C,UAAWzkD,KAAKK,MAAM+hD,YACtBxwC,SAAU5R,KAAKohD,WACfyC,QAAS7jD,KAAKqhD,cACdvL,OAAQ91C,KAAKK,MAAMy1C,SACjB91C,KAAKK,MAAMqkD,YAAc1kD,KAAK2kD,gBAAkB,WAGjDjE,EAvRuB,CAwR9BV,EAAQhG,QAAQ4K,WAClBlE,EAA0Bh+C,aAAe,CACvC+U,UAAW,GACXusC,mBAAoB,GACpBK,gBAAiB,GACjBC,aAAc,GACdI,aAAa,EACb5O,OAAQ,UACR1mC,KAAM,GACNm0C,UAAU,EACVgB,WAAY,gBACZH,WAAY,SACZX,WAAW,EACX/L,MAAO,4CACPiM,YAAa,GACbD,WAAY,GACZ9B,aAAc,CAAC,OAAQ,QAAS,OAAQ,QACxCM,YAAa,QACbmB,cAAe,wBACfC,cAAe,qCACfH,WAAY,GACZ/gD,MAAO,GACPghD,WAAY,GACZhB,aAAa,EACbxwC,SAAU,aACVovC,cAAe,IAEjBN,EAA0BmE,UAAY,CACpCziD,MAAO89C,EAAYlG,QAAQ1nC,OAC3B0xC,mBAAoB9D,EAAYlG,QAAQ1nC,OACxCmF,UAAWyoC,EAAYlG,QAAQ8K,OAC/BlzC,SAAUsuC,EAAYlG,QAAQ+K,KAC9BC,SAAU9E,EAAYlG,QAAQ+K,KAC9BV,gBAAiBnE,EAAYlG,QAAQ8K,OACrCR,aAAcpE,EAAYlG,QAAQ1nC,OAClC8xC,WAAYlE,EAAYlG,QAAQ8K,OAChCJ,YAAaxE,EAAYlG,QAAQiL,KACjCnP,OAAQoK,EAAYlG,QAAQ8K,OAC5B11C,KAAM8wC,EAAYlG,QAAQ8K,OAC1BvB,SAAUrD,EAAYlG,QAAQiL,KAC9BV,WAAYrE,EAAYlG,QAAQ8K,OAChCrB,UAAWvD,EAAYlG,QAAQiL,KAC/BvN,MAAOwI,EAAYlG,QAAQ8K,OAC3BnB,YAAazD,EAAYlG,QAAQ1nC,OACjCoxC,WAAYxD,EAAYlG,QAAQ8K,OAChClD,aAAc1B,EAAYlG,QAAQoB,MAClC8G,YAAahC,EAAYlG,QAAQh+B,OACjCqnC,cAAenD,EAAYlG,QAAQ8K,OACnCxB,cAAepD,EAAYlG,QAAQ8K,OACnC3B,WAAYjD,EAAYlG,QAAQ8K,OAChC1B,WAAYlD,EAAYlG,QAAQ1nC,OAChC8vC,YAAalC,EAAYlG,QAAQiL,KACjCjE,cAAed,EAAYlG,QAAQoB,OAErC5tC,EAAQwsC,QAAU0G","file":"js/vendors~booking~user_bot-2026ccd8c4393978628e.chunk.js","sourcesContent":["import React, { Children, Component, cloneElement, createElement } from 'react';\nimport ReactDOM, { findDOMNode } from 'react-dom';\nfunction warnOnce(msg) {\n  var hasWarned = false;\n  return function () {\n    if (!hasWarned) {\n      console.warn(msg);\n      hasWarned = true;\n    }\n  };\n}\nvar statelessFunctionalComponentSupplied = warnOnce('\\n>> Error, via react-flip-move <<\\n\\nYou provided a stateless functional component as a child to <FlipMove>. Unfortunately, SFCs aren\\'t supported, because Flip Move needs access to the backing instances via refs, and SFCs don\\'t have a public instance that holds that info.\\n\\nPlease wrap your components in a native element (eg. <div>), or a non-functional component.\\n');\nvar primitiveNodeSupplied = warnOnce('\\n>> Error, via react-flip-move <<\\n\\nYou provided a primitive (text or number) node as a child to <FlipMove>. Flip Move needs containers with unique keys to move children around.\\n\\nPlease wrap your value in a native element (eg. <span>), or a component.\\n');\nvar invalidTypeForTimingProp = function invalidTypeForTimingProp(args\n// prettier-ignore\n) {\n  return console.error('\\n>> Error, via react-flip-move <<\\n\\nThe prop you provided for \\'' + args.prop + '\\' is invalid. It needs to be a positive integer, or a string that can be resolved to a number. The value you provided is \\'' + args.value + '\\'.\\n\\nAs a result,  the default value for this parameter will be used, which is \\'' + args.defaultValue + '\\'.\\n');\n};\nvar invalidEnterLeavePreset = function invalidEnterLeavePreset(args\n// prettier-ignore\n) {\n  return console.error('\\n>> Error, via react-flip-move <<\\n\\nThe enter/leave preset you provided is invalid. We don\\'t currently have a \\'' + args.value + ' preset.\\'\\n\\nAcceptable values are ' + args.acceptableValues + '. The default value of \\'' + args.defaultValue + '\\' will be used.\\n');\n};\nvar parentNodePositionStatic = warnOnce('\\n>> Warning, via react-flip-move <<\\n\\nWhen using \"wrapperless\" mode (by supplying \\'typeName\\' of \\'null\\'), strange things happen when the direct parent has the default \"static\" position.\\n\\nFlipMove has added \\'position: relative\\' to this node, to ensure Flip Move animates correctly.\\n\\nTo avoid seeing this warning, simply apply a non-static position to that parent node.\\n');\nvar childIsDisabled = warnOnce('\\n>> Warning, via react-flip-move <<\\n\\nOne or more of Flip Move\\'s child elements have the html attribute \\'disabled\\' set to true.\\n\\nPlease note that this will cause animations to break in Internet Explorer 11 and below. Either remove the disabled attribute or set \\'animation\\' to false.\\n');\nvar enterPresets = {\n  elevator: {\n    from: {\n      transform: 'scale(0)',\n      opacity: '0'\n    },\n    to: {\n      transform: '',\n      opacity: ''\n    }\n  },\n  fade: {\n    from: {\n      opacity: '0'\n    },\n    to: {\n      opacity: ''\n    }\n  },\n  accordionVertical: {\n    from: {\n      transform: 'scaleY(0)',\n      transformOrigin: 'center top'\n    },\n    to: {\n      transform: '',\n      transformOrigin: 'center top'\n    }\n  },\n  accordionHorizontal: {\n    from: {\n      transform: 'scaleX(0)',\n      transformOrigin: 'left center'\n    },\n    to: {\n      transform: '',\n      transformOrigin: 'left center'\n    }\n  },\n  none: null\n};\n/**\n * React Flip Move | enterLeavePresets\n * (c) 2016-present Joshua Comeau\n *\n * This contains the master list of presets available for enter/leave animations,\n * along with the mapping between preset and styles.\n */\n\nvar leavePresets = {\n  elevator: {\n    from: {\n      transform: 'scale(1)',\n      opacity: '1'\n    },\n    to: {\n      transform: 'scale(0)',\n      opacity: '0'\n    }\n  },\n  fade: {\n    from: {\n      opacity: '1'\n    },\n    to: {\n      opacity: '0'\n    }\n  },\n  accordionVertical: {\n    from: {\n      transform: 'scaleY(1)',\n      transformOrigin: 'center top'\n    },\n    to: {\n      transform: 'scaleY(0)',\n      transformOrigin: 'center top'\n    }\n  },\n  accordionHorizontal: {\n    from: {\n      transform: 'scaleX(1)',\n      transformOrigin: 'left center'\n    },\n    to: {\n      transform: 'scaleX(0)',\n      transformOrigin: 'left center'\n    }\n  },\n  none: null\n};\n\n// For now, appearPresets will be identical to enterPresets.\n// Assigning a custom export in case we ever want to add appear-specific ones.\nvar appearPresets = enterPresets;\nvar defaultPreset = 'elevator';\nvar disablePreset = 'none';\nvar find = function find(predicate, arr) {\n  for (var i = 0; i < arr.length; i++) {\n    if (predicate(arr[i], i, arr)) {\n      return arr[i];\n    }\n  }\n  return undefined;\n};\nvar every = function every(predicate, arr) {\n  for (var i = 0; i < arr.length; i++) {\n    if (!predicate(arr[i], i, arr)) {\n      return false;\n    }\n  }\n  return true;\n};\n\n// eslint-disable-next-line import/no-mutable-exports\nvar _isArray = function isArray(arr) {\n  _isArray = Array.isArray || function (arg) {\n    return Object.prototype.toString.call(arg) === '[object Array]';\n  };\n  return _isArray(arr);\n};\nvar isElementAnSFC = function isElementAnSFC(element) {\n  var isNativeDOMElement = typeof element.type === 'string';\n  if (isNativeDOMElement) {\n    return false;\n  }\n  return typeof element.type === 'function' && !element.type.prototype.isReactComponent;\n};\nfunction omit(obj) {\n  var attrs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n  var result = {};\n  Object.keys(obj).forEach(function (key) {\n    if (attrs.indexOf(key) === -1) {\n      result[key] = obj[key];\n    }\n  });\n  return result;\n}\nfunction arraysEqual(a, b) {\n  var sameObject = a === b;\n  if (sameObject) {\n    return true;\n  }\n  var notBothArrays = !_isArray(a) || !_isArray(b);\n  var differentLengths = a.length !== b.length;\n  if (notBothArrays || differentLengths) {\n    return false;\n  }\n  return every(function (element, index) {\n    return element === b[index];\n  }, a);\n}\nfunction memoizeString(fn) {\n  var cache = {};\n  return function (str) {\n    if (!cache[str]) {\n      cache[str] = fn(str);\n    }\n    return cache[str];\n  };\n}\nvar hyphenate = memoizeString(function (str) {\n  return str.replace(/([A-Z])/g, '-$1').toLowerCase();\n});\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n  return target;\n};\nvar inherits = function (subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass);\n  }\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n};\nvar possibleConstructorReturn = function (self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n  return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self;\n};\n\n/**\n * React Flip Move | propConverter\n * (c) 2016-present Joshua Comeau\n *\n * Abstracted away a bunch of the messy business with props.\n *   - props flow types and defaultProps\n *   - Type conversion (We accept 'string' and 'number' values for duration,\n *     delay, and other fields, but we actually need them to be ints.)\n *   - Children conversion (we need the children to be an array. May not always\n *     be, if a single child is passed in.)\n *   - Resolving animation presets into their base CSS styles\n */\n/* eslint-disable block-scoped-var */\n\n// eslint-disable-next-line no-duplicate-imports\n\nfunction propConverter(ComposedComponent) {\n  var _class, _temp;\n  return _temp = _class = function (_Component) {\n    inherits(FlipMovePropConverter, _Component);\n    function FlipMovePropConverter() {\n      classCallCheck(this, FlipMovePropConverter);\n      return possibleConstructorReturn(this, _Component.apply(this, arguments));\n    }\n\n    // eslint-disable-next-line class-methods-use-this\n    FlipMovePropConverter.prototype.checkChildren = function checkChildren(children) {\n      // Skip all console warnings in production.\n      // Bail early, to avoid unnecessary work.\n      if (process.env.NODE_ENV === 'production') {\n        return;\n      }\n\n      // same as React.Node, but without fragments, see https://github.com/facebook/flow/issues/4781\n\n      // FlipMove does not support stateless functional components.\n      // Check to see if any supplied components won't work.\n      // If the child doesn't have a key, it means we aren't animating it.\n      // It's allowed to be an SFC, since we ignore it.\n      Children.forEach(children, function (child) {\n        // null, undefined, and booleans will be filtered out by Children.toArray\n        if (child == null || typeof child === 'boolean') {\n          return;\n        }\n        if ((typeof child === 'undefined' ? 'undefined' : _typeof(child)) !== 'object') {\n          primitiveNodeSupplied();\n          return;\n        }\n        if (isElementAnSFC(child) && child.key != null) {\n          statelessFunctionalComponentSupplied();\n        }\n      });\n    };\n    FlipMovePropConverter.prototype.convertProps = function convertProps(props) {\n      var workingProps = {\n        // explicitly bypass the props that don't need conversion\n        children: props.children,\n        easing: props.easing,\n        onStart: props.onStart,\n        onFinish: props.onFinish,\n        onStartAll: props.onStartAll,\n        onFinishAll: props.onFinishAll,\n        typeName: props.typeName,\n        disableAllAnimations: props.disableAllAnimations,\n        getPosition: props.getPosition,\n        maintainContainerHeight: props.maintainContainerHeight,\n        verticalAlignment: props.verticalAlignment,\n        // Do string-to-int conversion for all timing-related props\n        duration: this.convertTimingProp('duration'),\n        delay: this.convertTimingProp('delay'),\n        staggerDurationBy: this.convertTimingProp('staggerDurationBy'),\n        staggerDelayBy: this.convertTimingProp('staggerDelayBy'),\n        // Our enter/leave animations can be specified as boolean (default or\n        // disabled), string (preset name), or object (actual animation values).\n        // Let's standardize this so that they're always objects\n        appearAnimation: this.convertAnimationProp(props.appearAnimation, appearPresets),\n        enterAnimation: this.convertAnimationProp(props.enterAnimation, enterPresets),\n        leaveAnimation: this.convertAnimationProp(props.leaveAnimation, leavePresets),\n        delegated: {}\n      };\n      this.checkChildren(workingProps.children);\n\n      // Gather any additional props;\n      // they will be delegated to the ReactElement created.\n      var primaryPropKeys = Object.keys(workingProps);\n      var delegatedProps = omit(this.props, primaryPropKeys);\n\n      // The FlipMove container element needs to have a non-static position.\n      // We use `relative` by default, but it can be overridden by the user.\n      // Now that we're delegating props, we need to merge this in.\n      delegatedProps.style = _extends({\n        position: 'relative'\n      }, delegatedProps.style);\n      workingProps.delegated = delegatedProps;\n      return workingProps;\n    };\n    FlipMovePropConverter.prototype.convertTimingProp = function convertTimingProp(prop) {\n      var rawValue = this.props[prop];\n      var value = typeof rawValue === 'number' ? rawValue : parseInt(rawValue, 10);\n      if (isNaN(value)) {\n        var defaultValue = FlipMovePropConverter.defaultProps[prop];\n        if (process.env.NODE_ENV !== 'production') {\n          invalidTypeForTimingProp({\n            prop: prop,\n            value: rawValue,\n            defaultValue: defaultValue\n          });\n        }\n        return defaultValue;\n      }\n      return value;\n    };\n\n    // eslint-disable-next-line class-methods-use-this\n\n    FlipMovePropConverter.prototype.convertAnimationProp = function convertAnimationProp(animation, presets) {\n      switch (typeof animation === 'undefined' ? 'undefined' : _typeof(animation)) {\n        case 'boolean':\n          {\n            // If it's true, we want to use the default preset.\n            // If it's false, we want to use the 'none' preset.\n            return presets[animation ? defaultPreset : disablePreset];\n          }\n        case 'string':\n          {\n            var presetKeys = Object.keys(presets);\n            if (presetKeys.indexOf(animation) === -1) {\n              if (process.env.NODE_ENV !== 'production') {\n                invalidEnterLeavePreset({\n                  value: animation,\n                  acceptableValues: presetKeys.join(', '),\n                  defaultValue: defaultPreset\n                });\n              }\n              return presets[defaultPreset];\n            }\n            return presets[animation];\n          }\n        default:\n          {\n            return animation;\n          }\n      }\n    };\n    FlipMovePropConverter.prototype.render = function render() {\n      return /*#__PURE__*/React.createElement(ComposedComponent, this.convertProps(this.props));\n    };\n    return FlipMovePropConverter;\n  }(Component), _class.defaultProps = {\n    easing: 'ease-in-out',\n    duration: 350,\n    delay: 0,\n    staggerDurationBy: 0,\n    staggerDelayBy: 0,\n    typeName: 'div',\n    enterAnimation: defaultPreset,\n    leaveAnimation: defaultPreset,\n    disableAllAnimations: false,\n    getPosition: function getPosition(node) {\n      return node.getBoundingClientRect();\n    },\n    maintainContainerHeight: false,\n    verticalAlignment: 'top'\n  }, _temp;\n}\n\n/**\n * React Flip Move\n * (c) 2016-present Joshua Comeau\n *\n * These methods read from and write to the DOM.\n * They almost always have side effects, and will hopefully become the\n * only spot in the codebase with impure functions.\n */\nfunction applyStylesToDOMNode(_ref) {\n  var domNode = _ref.domNode,\n    styles = _ref.styles;\n\n  // Can't just do an object merge because domNode.styles is no regular object.\n  // Need to do it this way for the engine to fire its `set` listeners.\n  Object.keys(styles).forEach(function (key) {\n    domNode.style.setProperty(hyphenate(key), styles[key]);\n  });\n}\n\n// Modified from Modernizr\nfunction whichTransitionEvent() {\n  var transitions = {\n    transition: 'transitionend',\n    '-o-transition': 'oTransitionEnd',\n    '-moz-transition': 'transitionend',\n    '-webkit-transition': 'webkitTransitionEnd'\n  };\n\n  // If we're running in a browserless environment (eg. SSR), it doesn't apply.\n  // Return a placeholder string, for consistent type return.\n  if (typeof document === 'undefined') return '';\n  var el = document.createElement('fakeelement');\n  var match = find(function (t) {\n    return el.style.getPropertyValue(t) !== undefined;\n  }, Object.keys(transitions));\n\n  // If no `transition` is found, we must be running in a browser so ancient,\n  // React itself won't run. Return an empty string, for consistent type return\n  return match ? transitions[match] : '';\n}\nvar getRelativeBoundingBox = function getRelativeBoundingBox(_ref2) {\n  var childDomNode = _ref2.childDomNode,\n    parentDomNode = _ref2.parentDomNode,\n    getPosition = _ref2.getPosition;\n  var parentBox = getPosition(parentDomNode);\n  var _getPosition = getPosition(childDomNode),\n    top = _getPosition.top,\n    left = _getPosition.left,\n    right = _getPosition.right,\n    bottom = _getPosition.bottom,\n    width = _getPosition.width,\n    height = _getPosition.height;\n  return {\n    top: top - parentBox.top,\n    left: left - parentBox.left,\n    right: parentBox.right - right,\n    bottom: parentBox.bottom - bottom,\n    width: width,\n    height: height\n  };\n};\n\n/** getPositionDelta\n * This method returns the delta between two bounding boxes, to figure out\n * how many pixels on each axis the element has moved.\n *\n */\nvar getPositionDelta = function getPositionDelta(_ref3) {\n  var childDomNode = _ref3.childDomNode,\n    childBoundingBox = _ref3.childBoundingBox,\n    parentBoundingBox = _ref3.parentBoundingBox,\n    getPosition = _ref3.getPosition;\n\n  // TEMP: A mystery bug is sometimes causing unnecessary boundingBoxes to\n  var defaultBox = {\n    top: 0,\n    left: 0,\n    right: 0,\n    bottom: 0,\n    height: 0,\n    width: 0\n  };\n\n  // Our old box is its last calculated position, derived on mount or at the\n  // start of the previous animation.\n  var oldRelativeBox = childBoundingBox || defaultBox;\n  var parentBox = parentBoundingBox || defaultBox;\n\n  // Our new box is the new final resting place: Where we expect it to wind up\n  // after the animation. First we get the box in absolute terms (AKA relative\n  // to the viewport), and then we calculate its relative box (relative to the\n  // parent container)\n  var newAbsoluteBox = getPosition(childDomNode);\n  var newRelativeBox = {\n    top: newAbsoluteBox.top - parentBox.top,\n    left: newAbsoluteBox.left - parentBox.left\n  };\n  return [oldRelativeBox.left - newRelativeBox.left, oldRelativeBox.top - newRelativeBox.top];\n};\n\n/** removeNodeFromDOMFlow\n * This method does something very sneaky: it removes a DOM node from the\n * document flow, but without actually changing its on-screen position.\n *\n * It works by calculating where the node is, and then applying styles\n * so that it winds up being positioned absolutely, but in exactly the\n * same place.\n *\n * This is a vital part of the FLIP technique.\n */\nvar removeNodeFromDOMFlow = function removeNodeFromDOMFlow(childData, verticalAlignment) {\n  var domNode = childData.domNode,\n    boundingBox = childData.boundingBox;\n  if (!domNode || !boundingBox) {\n    return;\n  }\n\n  // For this to work, we have to offset any given `margin`.\n  var computed = window.getComputedStyle(domNode);\n\n  // We need to clean up margins, by converting and removing suffix:\n  // eg. '21px' -> 21\n  var marginAttrs = ['margin-top', 'margin-left', 'margin-right'];\n  var margins = marginAttrs.reduce(function (acc, margin) {\n    var _babelHelpers$extends;\n    var propertyVal = computed.getPropertyValue(margin);\n    return _extends({}, acc, (_babelHelpers$extends = {}, _babelHelpers$extends[margin] = Number(propertyVal.replace('px', '')), _babelHelpers$extends));\n  }, {});\n\n  // If we're bottom-aligned, we need to add the height of the child to its\n  // top offset. This is because, when the container is bottom-aligned, its\n  // height shrinks from the top, not the bottom. We're removing this node\n  // from the flow, so the top is going to drop by its height.\n  var topOffset = verticalAlignment === 'bottom' ? boundingBox.top - boundingBox.height : boundingBox.top;\n  var styles = {\n    position: 'absolute',\n    top: topOffset - margins['margin-top'] + 'px',\n    left: boundingBox.left - margins['margin-left'] + 'px',\n    right: boundingBox.right - margins['margin-right'] + 'px'\n  };\n  applyStylesToDOMNode({\n    domNode: domNode,\n    styles: styles\n  });\n};\n\n/** updateHeightPlaceholder\n * An optional property to FlipMove is a `maintainContainerHeight` boolean.\n * This property creates a node that fills space, so that the parent\n * container doesn't collapse when its children are removed from the\n * document flow.\n */\nvar updateHeightPlaceholder = function updateHeightPlaceholder(_ref4) {\n  var domNode = _ref4.domNode,\n    parentData = _ref4.parentData,\n    getPosition = _ref4.getPosition;\n  var parentDomNode = parentData.domNode;\n  var parentBoundingBox = parentData.boundingBox;\n  if (!parentDomNode || !parentBoundingBox) {\n    return;\n  }\n\n  // We need to find the height of the container *without* the placeholder.\n  // Since it's possible that the placeholder might already be present,\n  // we first set its height to 0.\n  // This allows the container to collapse down to the size of just its\n  // content (plus container padding or borders if any).\n  applyStylesToDOMNode({\n    domNode: domNode,\n    styles: {\n      height: '0'\n    }\n  });\n\n  // Find the distance by which the container would be collapsed by elements\n  // leaving. We compare the freshly-available parent height with the original,\n  // cached container height.\n  var originalParentHeight = parentBoundingBox.height;\n  var collapsedParentHeight = getPosition(parentDomNode).height;\n  var reductionInHeight = originalParentHeight - collapsedParentHeight;\n\n  // If the container has become shorter, update the padding element's\n  // height to take up the difference. Otherwise set its height to zero,\n  // so that it has no effect.\n  var styles = {\n    height: reductionInHeight > 0 ? reductionInHeight + 'px' : '0'\n  };\n  applyStylesToDOMNode({\n    domNode: domNode,\n    styles: styles\n  });\n};\nvar getNativeNode = function getNativeNode(element) {\n  // When running in a windowless environment, abort!\n  if (typeof HTMLElement === 'undefined') {\n    return null;\n  }\n\n  // `element` may already be a native node.\n  if (element instanceof HTMLElement) {\n    return element;\n  }\n\n  // While ReactDOM's `findDOMNode` is discouraged, it's the only\n  // publicly-exposed way to find the underlying DOM node for\n  // composite components.\n  var foundNode = findDOMNode(element);\n  if (foundNode && foundNode.nodeType === Node.TEXT_NODE) {\n    // Text nodes are not supported\n    return null;\n  }\n  // eslint-disable-next-line flowtype/no-weak-types\n  return foundNode;\n};\nvar createTransitionString = function createTransitionString(index, props) {\n  var delay = props.delay,\n    duration = props.duration;\n  var staggerDurationBy = props.staggerDurationBy,\n    staggerDelayBy = props.staggerDelayBy,\n    easing = props.easing;\n  delay += index * staggerDelayBy;\n  duration += index * staggerDurationBy;\n  var cssProperties = ['transform', 'opacity'];\n  return cssProperties.map(function (prop) {\n    return prop + ' ' + duration + 'ms ' + easing + ' ' + delay + 'ms';\n  }).join(', ');\n};\n\n/**\n * React Flip Move\n * (c) 2016-present Joshua Comeau\n *\n * For information on how this code is laid out, check out CODE_TOUR.md\n */\n\n/* eslint-disable react/prop-types */\n\n// eslint-disable-next-line no-duplicate-imports\n\nvar transitionEnd = whichTransitionEvent();\nvar noBrowserSupport = !transitionEnd;\nfunction getKey(childData) {\n  return childData.key || '';\n}\nfunction getElementChildren(children) {\n  // Fix incomplete typing of Children.toArray\n  // eslint-disable-next-line flowtype/no-weak-types\n  return Children.toArray(children);\n}\nvar FlipMove$1 = function (_Component) {\n  inherits(FlipMove, _Component);\n  function FlipMove() {\n    var _temp, _this, _ret;\n    classCallCheck(this, FlipMove);\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.state = {\n      children: getElementChildren(\n      // `this.props` ought to always be defined at this point, but a report\n      // was made about it not being defined in IE10.\n      // TODO: Test in IE10, to see if there's an underlying cause that can\n      // be addressed.\n      _this.props ? _this.props.children : []).map(function (element) {\n        return _extends({}, element, {\n          element: element,\n          appearing: true\n        });\n      })\n    }, _this.childrenData = {}, _this.parentData = {\n      domNode: null,\n      boundingBox: null\n    }, _this.heightPlaceholderData = {\n      domNode: null\n    }, _this.remainingAnimations = 0, _this.childrenToAnimate = [], _this.findDOMContainer = function () {\n      // eslint-disable-next-line react/no-find-dom-node\n      var domNode = ReactDOM.findDOMNode(_this);\n      var parentNode = domNode && domNode.parentNode;\n\n      // This ought to be impossible, but handling it for Flow's sake.\n      if (!parentNode || !(parentNode instanceof HTMLElement)) {\n        return;\n      }\n\n      // If the parent node has static positioning, leave animations might look\n      // really funky. Let's automatically apply `position: relative` in this\n      // case, to prevent any quirkiness.\n      if (window.getComputedStyle(parentNode).position === 'static') {\n        parentNode.style.position = 'relative';\n        parentNodePositionStatic();\n      }\n      _this.parentData.domNode = parentNode;\n    }, _this.runAnimation = function () {\n      var dynamicChildren = _this.state.children.filter(_this.doesChildNeedToBeAnimated);\n\n      // Splitting DOM reads and writes to be peformed in batches\n      var childrenInitialStyles = dynamicChildren.map(function (child) {\n        return _this.computeInitialStyles(child);\n      });\n      dynamicChildren.forEach(function (child, index) {\n        _this.remainingAnimations += 1;\n        _this.childrenToAnimate.push(getKey(child));\n        _this.animateChild(child, index, childrenInitialStyles[index]);\n      });\n      if (typeof _this.props.onStartAll === 'function') {\n        _this.callChildrenHook(_this.props.onStartAll);\n      }\n    }, _this.doesChildNeedToBeAnimated = function (child) {\n      // If the child doesn't have a key, it's an immovable child (one that we\n      // do not want to do FLIP stuff to.)\n      if (!getKey(child)) {\n        return false;\n      }\n      var childData = _this.getChildData(getKey(child));\n      var childDomNode = childData.domNode;\n      var childBoundingBox = childData.boundingBox;\n      var parentBoundingBox = _this.parentData.boundingBox;\n      if (!childDomNode) {\n        return false;\n      }\n      var _this$props = _this.props,\n        appearAnimation = _this$props.appearAnimation,\n        enterAnimation = _this$props.enterAnimation,\n        leaveAnimation = _this$props.leaveAnimation,\n        getPosition = _this$props.getPosition;\n      var isAppearingWithAnimation = child.appearing && appearAnimation;\n      var isEnteringWithAnimation = child.entering && enterAnimation;\n      var isLeavingWithAnimation = child.leaving && leaveAnimation;\n      if (isAppearingWithAnimation || isEnteringWithAnimation || isLeavingWithAnimation) {\n        return true;\n      }\n\n      // If it isn't entering/leaving, we want to animate it if it's\n      // on-screen position has changed.\n\n      var _getPositionDelta = getPositionDelta({\n          childDomNode: childDomNode,\n          childBoundingBox: childBoundingBox,\n          parentBoundingBox: parentBoundingBox,\n          getPosition: getPosition\n        }),\n        dX = _getPositionDelta[0],\n        dY = _getPositionDelta[1];\n      return dX !== 0 || dY !== 0;\n    }, _temp), possibleConstructorReturn(_this, _ret);\n  }\n  // Copy props.children into state.\n  // To understand why this is important (and not an anti-pattern), consider\n  // how \"leave\" animations work. An item has \"left\" when the component\n  // receives a new set of props that do NOT contain the item.\n  // If we just render the props as-is, the item would instantly disappear.\n  // We want to keep the item rendered for a little while, until its animation\n  // can complete. Because we cannot mutate props, we make `state` the source\n  // of truth.\n\n  // FlipMove needs to know quite a bit about its children in order to do\n  // its job. We store these as a property on the instance. We're not using\n  // state, because we don't want changes to trigger re-renders, we just\n  // need a place to keep the data for reference, when changes happen.\n  // This field should not be accessed directly. Instead, use getChildData,\n  // putChildData, etc...\n\n  // Similarly, track the dom node and box of our parent element.\n\n  // If `maintainContainerHeight` prop is set to true, we'll create a\n  // placeholder element which occupies space so that the parent height\n  // doesn't change when items are removed from the document flow (which\n  // happens during leave animations)\n\n  // Keep track of remaining animations so we know when to fire the\n  // all-finished callback, and clean up after ourselves.\n  // NOTE: we can't simply use childrenToAnimate.length to track remaining\n  // animations, because we need to maintain the list of animating children,\n  // to pass to the `onFinishAll` handler.\n\n  FlipMove.prototype.componentDidMount = function componentDidMount() {\n    // Because React 16 no longer requires wrapping elements, Flip Move can opt\n    // to not wrap the children in an element. In that case, find the parent\n    // element using `findDOMNode`.\n    if (this.props.typeName === null) {\n      this.findDOMContainer();\n    }\n\n    // Run our `appearAnimation` if it was requested, right after the\n    // component mounts.\n    var shouldTriggerFLIP = this.props.appearAnimation && !this.isAnimationDisabled(this.props);\n    if (shouldTriggerFLIP) {\n      this.prepForAnimation();\n      this.runAnimation();\n    }\n  };\n  FlipMove.prototype.componentDidUpdate = function componentDidUpdate(previousProps) {\n    if (this.props.typeName === null) {\n      this.findDOMContainer();\n    }\n    // If the children have been re-arranged, moved, or added/removed,\n    // trigger the main FLIP animation.\n    //\n    // IMPORTANT: We need to make sure that the children have actually changed.\n    // At the end of the transition, we clean up nodes that need to be removed.\n    // We DON'T want this cleanup to trigger another update.\n\n    var oldChildrenKeys = getElementChildren(this.props.children).map(function (d) {\n      return d.key;\n    });\n    var nextChildrenKeys = getElementChildren(previousProps.children).map(function (d) {\n      return d.key;\n    });\n    var shouldTriggerFLIP = !arraysEqual(oldChildrenKeys, nextChildrenKeys) && !this.isAnimationDisabled(this.props);\n    if (shouldTriggerFLIP) {\n      this.prepForAnimation();\n      this.runAnimation();\n    }\n  };\n  FlipMove.prototype.calculateNextSetOfChildren = function calculateNextSetOfChildren(nextChildren) {\n    var _this2 = this;\n\n    // We want to:\n    //   - Mark all new children as `entering`\n    //   - Pull in previous children that aren't in nextChildren, and mark them\n    //     as `leaving`\n    //   - Preserve the nextChildren list order, with leaving children in their\n    //     appropriate places.\n    //\n\n    var updatedChildren = nextChildren.map(function (nextChild) {\n      var child = _this2.findChildByKey(nextChild.key);\n\n      // If the current child did exist, but it was in the midst of leaving,\n      // we want to treat it as though it's entering\n      var isEntering = !child || child.leaving;\n      return _extends({}, nextChild, {\n        element: nextChild,\n        entering: isEntering\n      });\n    });\n\n    // This is tricky. We want to keep the nextChildren's ordering, but with\n    // any just-removed items maintaining their original position.\n    // eg.\n    //   this.state.children  = [ 1, 2, 3, 4 ]\n    //   nextChildren         = [ 3, 1 ]\n    //\n    // In this example, we've removed the '2' & '4'\n    // We want to end up with:  [ 2, 3, 1, 4 ]\n    //\n    // To accomplish that, we'll iterate through this.state.children. whenever\n    // we find a match, we'll append our `leaving` flag to it, and insert it\n    // into the nextChildren in its ORIGINAL position. Note that, as we keep\n    // inserting old items into the new list, the \"original\" position will\n    // keep incrementing.\n    var numOfChildrenLeaving = 0;\n    this.state.children.forEach(function (child, index) {\n      var isLeaving = !find(function (_ref) {\n        var key = _ref.key;\n        return key === getKey(child);\n      }, nextChildren);\n\n      // If the child isn't leaving (or, if there is no leave animation),\n      // we don't need to add it into the state children.\n      if (!isLeaving || !_this2.props.leaveAnimation) return;\n      var nextChild = _extends({}, child, {\n        leaving: true\n      });\n      var nextChildIndex = index + numOfChildrenLeaving;\n      updatedChildren.splice(nextChildIndex, 0, nextChild);\n      numOfChildrenLeaving += 1;\n    });\n    return updatedChildren;\n  };\n  FlipMove.prototype.prepForAnimation = function prepForAnimation() {\n    var _this3 = this;\n\n    // Our animation prep consists of:\n    // - remove children that are leaving from the DOM flow, so that the new\n    //   layout can be accurately calculated,\n    // - update the placeholder container height, if needed, to ensure that\n    //   the parent's height doesn't collapse.\n\n    var _props = this.props,\n      leaveAnimation = _props.leaveAnimation,\n      maintainContainerHeight = _props.maintainContainerHeight,\n      getPosition = _props.getPosition;\n\n    // we need to make all leaving nodes \"invisible\" to the layout calculations\n    // that will take place in the next step (this.runAnimation).\n\n    if (leaveAnimation) {\n      var leavingChildren = this.state.children.filter(function (child) {\n        return child.leaving;\n      });\n      leavingChildren.forEach(function (leavingChild) {\n        var childData = _this3.getChildData(getKey(leavingChild));\n\n        // Warn if child is disabled\n        if (!_this3.isAnimationDisabled(_this3.props) && childData.domNode && childData.domNode.disabled) {\n          childIsDisabled();\n        }\n\n        // We need to take the items out of the \"flow\" of the document, so that\n        // its siblings can move to take its place.\n        if (childData.boundingBox) {\n          removeNodeFromDOMFlow(childData, _this3.props.verticalAlignment);\n        }\n      });\n      if (maintainContainerHeight && this.heightPlaceholderData.domNode) {\n        updateHeightPlaceholder({\n          domNode: this.heightPlaceholderData.domNode,\n          parentData: this.parentData,\n          getPosition: getPosition\n        });\n      }\n    }\n\n    // For all children not in the middle of entering or leaving,\n    // we need to reset the transition, so that the NEW shuffle starts from\n    // the right place.\n    this.state.children.forEach(function (child) {\n      var _getChildData = _this3.getChildData(getKey(child)),\n        domNode = _getChildData.domNode;\n\n      // Ignore children that don't render DOM nodes (eg. by returning null)\n\n      if (!domNode) {\n        return;\n      }\n      if (!child.entering && !child.leaving) {\n        applyStylesToDOMNode({\n          domNode: domNode,\n          styles: {\n            transition: ''\n          }\n        });\n      }\n    });\n  };\n\n  // eslint-disable-next-line camelcase\n\n  FlipMove.prototype.UNSAFE_componentWillReceiveProps = function UNSAFE_componentWillReceiveProps(nextProps) {\n    // When the component is handed new props, we need to figure out the\n    // \"resting\" position of all currently-rendered DOM nodes.\n    // We store that data in this.parent and this.children,\n    // so it can be used later to work out the animation.\n    this.updateBoundingBoxCaches();\n\n    // Convert opaque children object to array.\n    var nextChildren = getElementChildren(nextProps.children);\n\n    // Next, we need to update our state, so that it contains our new set of\n    // children. If animation is disabled or unsupported, this is easy;\n    // we just copy our props into state.\n    // Assuming that we can animate, though, we have to do some work.\n    // Essentially, we want to keep just-deleted nodes in the DOM for a bit\n    // longer, so that we can animate them away.\n    this.setState({\n      children: this.isAnimationDisabled(nextProps) ? nextChildren.map(function (element) {\n        return _extends({}, element, {\n          element: element\n        });\n      }) : this.calculateNextSetOfChildren(nextChildren)\n    });\n  };\n  FlipMove.prototype.animateChild = function animateChild(child, index, childInitialStyles) {\n    var _this4 = this;\n    var _getChildData2 = this.getChildData(getKey(child)),\n      domNode = _getChildData2.domNode;\n    if (!domNode) {\n      return;\n    }\n\n    // Apply the relevant style for this DOM node\n    // This is the offset from its actual DOM position.\n    // eg. if an item has been re-rendered 20px lower, we want to apply a\n    // style of 'transform: translate(-20px)', so that it appears to be where\n    // it started.\n    // In FLIP terminology, this is the 'Invert' stage.\n    applyStylesToDOMNode({\n      domNode: domNode,\n      styles: childInitialStyles\n    });\n\n    // Start by invoking the onStart callback for this child.\n    if (this.props.onStart) this.props.onStart(child, domNode);\n\n    // Next, animate the item from it's artificially-offset position to its\n    // new, natural position.\n    requestAnimationFrame(function () {\n      requestAnimationFrame(function () {\n        // NOTE, RE: the double-requestAnimationFrame:\n        // Sadly, this is the most browser-compatible way to do this I've found.\n        // Essentially we need to set the initial styles outside of any request\n        // callbacks to avoid batching them. Then, a frame needs to pass with\n        // the styles above rendered. Then, on the second frame, we can apply\n        // our final styles to perform the animation.\n\n        // Our first order of business is to \"undo\" the styles applied in the\n        // previous frames, while also adding a `transition` property.\n        // This way, the item will smoothly transition from its old position\n        // to its new position.\n\n        // eslint-disable-next-line flowtype/require-variable-type\n        var styles = {\n          transition: createTransitionString(index, _this4.props),\n          transform: '',\n          opacity: ''\n        };\n        if (child.appearing && _this4.props.appearAnimation) {\n          styles = _extends({}, styles, _this4.props.appearAnimation.to);\n        } else if (child.entering && _this4.props.enterAnimation) {\n          styles = _extends({}, styles, _this4.props.enterAnimation.to);\n        } else if (child.leaving && _this4.props.leaveAnimation) {\n          styles = _extends({}, styles, _this4.props.leaveAnimation.to);\n        }\n\n        // In FLIP terminology, this is the 'Play' stage.\n        applyStylesToDOMNode({\n          domNode: domNode,\n          styles: styles\n        });\n      });\n    });\n    this.bindTransitionEndHandler(child);\n  };\n  FlipMove.prototype.bindTransitionEndHandler = function bindTransitionEndHandler(child) {\n    var _this5 = this;\n    var _getChildData3 = this.getChildData(getKey(child)),\n      domNode = _getChildData3.domNode;\n    if (!domNode) {\n      return;\n    }\n\n    // The onFinish callback needs to be bound to the transitionEnd event.\n    // We also need to unbind it when the transition completes, so this ugly\n    // inline function is required (we need it here so it closes over\n    // dependent variables `child` and `domNode`)\n    var transitionEndHandler = function transitionEndHandler(ev) {\n      // It's possible that this handler is fired not on our primary transition,\n      // but on a nested transition (eg. a hover effect). Ignore these cases.\n      if (ev.target !== domNode) return;\n\n      // Remove the 'transition' inline style we added. This is cleanup.\n      domNode.style.transition = '';\n\n      // Trigger any applicable onFinish/onFinishAll hooks\n      _this5.triggerFinishHooks(child, domNode);\n      domNode.removeEventListener(transitionEnd, transitionEndHandler);\n      if (child.leaving) {\n        _this5.removeChildData(getKey(child));\n      }\n    };\n    domNode.addEventListener(transitionEnd, transitionEndHandler);\n  };\n  FlipMove.prototype.triggerFinishHooks = function triggerFinishHooks(child, domNode) {\n    var _this6 = this;\n    if (this.props.onFinish) this.props.onFinish(child, domNode);\n\n    // Reduce the number of children we need to animate by 1,\n    // so that we can tell when all children have finished.\n    this.remainingAnimations -= 1;\n    if (this.remainingAnimations === 0) {\n      // Remove any items from the DOM that have left, and reset `entering`.\n      var nextChildren = this.state.children.filter(function (_ref2) {\n        var leaving = _ref2.leaving;\n        return !leaving;\n      }).map(function (item) {\n        return _extends({}, item, {\n          // fix for Flow\n          element: item.element,\n          appearing: false,\n          entering: false\n        });\n      });\n      this.setState({\n        children: nextChildren\n      }, function () {\n        if (typeof _this6.props.onFinishAll === 'function') {\n          _this6.callChildrenHook(_this6.props.onFinishAll);\n        }\n\n        // Reset our variables for the next iteration\n        _this6.childrenToAnimate = [];\n      });\n\n      // If the placeholder was holding the container open while elements were\n      // leaving, we we can now set its height to zero.\n      if (this.heightPlaceholderData.domNode) {\n        this.heightPlaceholderData.domNode.style.height = '0';\n      }\n    }\n  };\n  FlipMove.prototype.callChildrenHook = function callChildrenHook(hook) {\n    var _this7 = this;\n    var elements = [];\n    var domNodes = [];\n    this.childrenToAnimate.forEach(function (childKey) {\n      // If this was an exit animation, the child may no longer exist.\n      // If so, skip it.\n      var child = _this7.findChildByKey(childKey);\n      if (!child) {\n        return;\n      }\n      elements.push(child);\n      if (_this7.hasChildData(childKey)) {\n        domNodes.push(_this7.getChildData(childKey).domNode);\n      }\n    });\n    hook(elements, domNodes);\n  };\n  FlipMove.prototype.updateBoundingBoxCaches = function updateBoundingBoxCaches() {\n    var _this8 = this;\n\n    // This is the ONLY place that parentData and childrenData's\n    // bounding boxes are updated. They will be calculated at other times\n    // to be compared to this value, but it's important that the cache is\n    // updated once per update.\n    var parentDomNode = this.parentData.domNode;\n    if (!parentDomNode) {\n      return;\n    }\n    this.parentData.boundingBox = this.props.getPosition(parentDomNode);\n\n    // Splitting DOM reads and writes to be peformed in batches\n    var childrenBoundingBoxes = [];\n    this.state.children.forEach(function (child) {\n      var childKey = getKey(child);\n\n      // It is possible that a child does not have a `key` property;\n      // Ignore these children, they don't need to be moved.\n      if (!childKey) {\n        childrenBoundingBoxes.push(null);\n        return;\n      }\n\n      // In very rare circumstances, for reasons unknown, the ref is never\n      // populated for certain children. In this case, avoid doing this update.\n      // see: https://github.com/joshwcomeau/react-flip-move/pull/91\n      if (!_this8.hasChildData(childKey)) {\n        childrenBoundingBoxes.push(null);\n        return;\n      }\n      var childData = _this8.getChildData(childKey);\n\n      // If the child element returns null, we need to avoid trying to\n      // account for it\n      if (!childData.domNode || !child) {\n        childrenBoundingBoxes.push(null);\n        return;\n      }\n      childrenBoundingBoxes.push(getRelativeBoundingBox({\n        childDomNode: childData.domNode,\n        parentDomNode: parentDomNode,\n        getPosition: _this8.props.getPosition\n      }));\n    });\n    this.state.children.forEach(function (child, index) {\n      var childKey = getKey(child);\n      var childBoundingBox = childrenBoundingBoxes[index];\n      if (!childKey) {\n        return;\n      }\n      _this8.setChildData(childKey, {\n        boundingBox: childBoundingBox\n      });\n    });\n  };\n  FlipMove.prototype.computeInitialStyles = function computeInitialStyles(child) {\n    if (child.appearing) {\n      return this.props.appearAnimation ? this.props.appearAnimation.from : {};\n    } else if (child.entering) {\n      if (!this.props.enterAnimation) {\n        return {};\n      }\n      // If this child was in the middle of leaving, it still has its\n      // absolute positioning styles applied. We need to undo those.\n      return _extends({\n        position: '',\n        top: '',\n        left: '',\n        right: '',\n        bottom: ''\n      }, this.props.enterAnimation.from);\n    } else if (child.leaving) {\n      return this.props.leaveAnimation ? this.props.leaveAnimation.from : {};\n    }\n    var childData = this.getChildData(getKey(child));\n    var childDomNode = childData.domNode;\n    var childBoundingBox = childData.boundingBox;\n    var parentBoundingBox = this.parentData.boundingBox;\n    if (!childDomNode) {\n      return {};\n    }\n    var _getPositionDelta2 = getPositionDelta({\n        childDomNode: childDomNode,\n        childBoundingBox: childBoundingBox,\n        parentBoundingBox: parentBoundingBox,\n        getPosition: this.props.getPosition\n      }),\n      dX = _getPositionDelta2[0],\n      dY = _getPositionDelta2[1];\n    return {\n      transform: 'translate(' + dX + 'px, ' + dY + 'px)'\n    };\n  };\n\n  // eslint-disable-next-line class-methods-use-this\n\n  FlipMove.prototype.isAnimationDisabled = function isAnimationDisabled(props) {\n    // If the component is explicitly passed a `disableAllAnimations` flag,\n    // we can skip this whole process. Similarly, if all of the numbers have\n    // been set to 0, there is no point in trying to animate; doing so would\n    // only cause a flicker (and the intent is probably to disable animations)\n    // We can also skip this rigamarole if there's no browser support for it.\n    return noBrowserSupport || props.disableAllAnimations || props.duration === 0 && props.delay === 0 && props.staggerDurationBy === 0 && props.staggerDelayBy === 0;\n  };\n  FlipMove.prototype.findChildByKey = function findChildByKey(key) {\n    return find(function (child) {\n      return getKey(child) === key;\n    }, this.state.children);\n  };\n  FlipMove.prototype.hasChildData = function hasChildData(key) {\n    // Object has some built-in properties on its prototype, such as toString.  hasOwnProperty makes\n    // sure that key is present on childrenData itself, not on its prototype.\n    return Object.prototype.hasOwnProperty.call(this.childrenData, key);\n  };\n  FlipMove.prototype.getChildData = function getChildData(key) {\n    return this.hasChildData(key) ? this.childrenData[key] : {};\n  };\n  FlipMove.prototype.setChildData = function setChildData(key, data) {\n    this.childrenData[key] = _extends({}, this.getChildData(key), data);\n  };\n  FlipMove.prototype.removeChildData = function removeChildData(key) {\n    delete this.childrenData[key];\n    this.setState(function (prevState) {\n      return _extends({}, prevState, {\n        children: prevState.children.filter(function (child) {\n          return child.element.key !== key;\n        })\n      });\n    });\n  };\n  FlipMove.prototype.createHeightPlaceholder = function createHeightPlaceholder() {\n    var _this9 = this;\n    var typeName = this.props.typeName;\n\n    // If requested, create an invisible element at the end of the list.\n    // Its height will be modified to prevent the container from collapsing\n    // prematurely.\n\n    var isContainerAList = typeName === 'ul' || typeName === 'ol';\n    var placeholderType = isContainerAList ? 'li' : 'div';\n    return /*#__PURE__*/createElement(placeholderType, {\n      key: 'height-placeholder',\n      ref: function ref(domNode) {\n        _this9.heightPlaceholderData.domNode = domNode;\n      },\n      style: {\n        visibility: 'hidden',\n        height: 0\n      }\n    });\n  };\n  FlipMove.prototype.childrenWithRefs = function childrenWithRefs() {\n    var _this10 = this;\n\n    // We need to clone the provided children, capturing a reference to the\n    // underlying DOM node. Flip Move needs to use the React escape hatches to\n    // be able to do its calculations.\n    return this.state.children.map(function (child) {\n      return /*#__PURE__*/cloneElement(child.element, {\n        ref: function ref(element) {\n          // Functional Components without a forwarded ref are not supported by FlipMove,\n          // because they don't have instances.\n          if (!element) {\n            return;\n          }\n          var domNode = getNativeNode(element);\n          _this10.setChildData(getKey(child), {\n            domNode: domNode\n          });\n        }\n      });\n    });\n  };\n  FlipMove.prototype.render = function render() {\n    var _this11 = this;\n    var _props2 = this.props,\n      typeName = _props2.typeName,\n      delegated = _props2.delegated,\n      leaveAnimation = _props2.leaveAnimation,\n      maintainContainerHeight = _props2.maintainContainerHeight;\n    var children = this.childrenWithRefs();\n    if (leaveAnimation && maintainContainerHeight) {\n      children.push(this.createHeightPlaceholder());\n    }\n    if (!typeName) return children;\n    var props = _extends({}, delegated, {\n      children: children,\n      ref: function ref(node) {\n        _this11.parentData.domNode = node;\n      }\n    });\n    return /*#__PURE__*/createElement(typeName, props);\n  };\n  return FlipMove;\n}(Component);\nvar enhancedFlipMove = /* #__PURE__ */propConverter(FlipMove$1);\n\n/**\n * React Flip Move\n * (c) 2016-present Joshua Comeau\n */\n\nexport default enhancedFlipMove;","module.exports = __webpack_public_path__ + \"media/react-images-upload/UploadIcon-1cedb6e9.svg\";","function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : i + \"\"; }\nfunction _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\nfunction _iterableToArrayLimit(r, l) { var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\nimport { useMemo, useLayoutEffect, useEffect, useRef, useCallback } from 'react';\nfunction useCombinedRefs() {\n  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {\n    refs[_key] = arguments[_key];\n  }\n  return useMemo(() => node => {\n    refs.forEach(ref => ref(node));\n  },\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  refs);\n}\n\n// https://github.com/facebook/react/blob/master/packages/shared/ExecutionEnvironment.js\nconst canUseDOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';\nfunction isWindow(element) {\n  const elementString = Object.prototype.toString.call(element);\n  return elementString === '[object Window]' ||\n  // In Electron context the Window object serializes to [object global]\n  elementString === '[object global]';\n}\nfunction isNode(node) {\n  return 'nodeType' in node;\n}\nfunction getWindow(target) {\n  var _target$ownerDocument, _target$ownerDocument2;\n  if (!target) {\n    return window;\n  }\n  if (isWindow(target)) {\n    return target;\n  }\n  if (!isNode(target)) {\n    return window;\n  }\n  return (_target$ownerDocument = (_target$ownerDocument2 = target.ownerDocument) == null ? void 0 : _target$ownerDocument2.defaultView) != null ? _target$ownerDocument : window;\n}\nfunction isDocument(node) {\n  const _getWindow = getWindow(node),\n    Document = _getWindow.Document;\n  return node instanceof Document;\n}\nfunction isHTMLElement(node) {\n  if (isWindow(node)) {\n    return false;\n  }\n  return node instanceof getWindow(node).HTMLElement;\n}\nfunction isSVGElement(node) {\n  return node instanceof getWindow(node).SVGElement;\n}\nfunction getOwnerDocument(target) {\n  if (!target) {\n    return document;\n  }\n  if (isWindow(target)) {\n    return target.document;\n  }\n  if (!isNode(target)) {\n    return document;\n  }\n  if (isDocument(target)) {\n    return target;\n  }\n  if (isHTMLElement(target) || isSVGElement(target)) {\n    return target.ownerDocument;\n  }\n  return document;\n}\n\n/**\r\n * A hook that resolves to useEffect on the server and useLayoutEffect on the client\r\n * @param callback {function} Callback function that is invoked when the dependencies of the hook change\r\n */\n\nconst useIsomorphicLayoutEffect = canUseDOM ? useLayoutEffect : useEffect;\nfunction useEvent(handler) {\n  const handlerRef = useRef(handler);\n  useIsomorphicLayoutEffect(() => {\n    handlerRef.current = handler;\n  });\n  return useCallback(function () {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    return handlerRef.current == null ? void 0 : handlerRef.current(...args);\n  }, []);\n}\nfunction useInterval() {\n  const intervalRef = useRef(null);\n  const set = useCallback((listener, duration) => {\n    intervalRef.current = setInterval(listener, duration);\n  }, []);\n  const clear = useCallback(() => {\n    if (intervalRef.current !== null) {\n      clearInterval(intervalRef.current);\n      intervalRef.current = null;\n    }\n  }, []);\n  return [set, clear];\n}\nfunction useLatestValue(value, dependencies) {\n  if (dependencies === void 0) {\n    dependencies = [value];\n  }\n  const valueRef = useRef(value);\n  useIsomorphicLayoutEffect(() => {\n    if (valueRef.current !== value) {\n      valueRef.current = value;\n    }\n  }, dependencies);\n  return valueRef;\n}\nfunction useLazyMemo(callback, dependencies) {\n  const valueRef = useRef();\n  return useMemo(() => {\n    const newValue = callback(valueRef.current);\n    valueRef.current = newValue;\n    return newValue;\n  },\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [...dependencies]);\n}\nfunction useNodeRef(onChange) {\n  const onChangeHandler = useEvent(onChange);\n  const node = useRef(null);\n  const setNodeRef = useCallback(element => {\n    if (element !== node.current) {\n      onChangeHandler == null ? void 0 : onChangeHandler(element, node.current);\n    }\n    node.current = element;\n  },\n  //eslint-disable-next-line\n  []);\n  return [node, setNodeRef];\n}\nfunction usePrevious(value) {\n  const ref = useRef();\n  useEffect(() => {\n    ref.current = value;\n  }, [value]);\n  return ref.current;\n}\nlet ids = {};\nfunction useUniqueId(prefix, value) {\n  return useMemo(() => {\n    if (value) {\n      return value;\n    }\n    const id = ids[prefix] == null ? 0 : ids[prefix] + 1;\n    ids[prefix] = id;\n    return prefix + \"-\" + id;\n  }, [prefix, value]);\n}\nfunction createAdjustmentFn(modifier) {\n  return function (object) {\n    for (var _len = arguments.length, adjustments = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      adjustments[_key - 1] = arguments[_key];\n    }\n    return adjustments.reduce((accumulator, adjustment) => {\n      const entries = Object.entries(adjustment);\n      for (const _ref2 of entries) {\n        var _ref3 = _slicedToArray(_ref2, 2);\n        const key = _ref3[0];\n        const valueAdjustment = _ref3[1];\n        const value = accumulator[key];\n        if (value != null) {\n          accumulator[key] = value + modifier * valueAdjustment;\n        }\n      }\n      return accumulator;\n    }, _objectSpread({}, object));\n  };\n}\nconst add = /*#__PURE__*/createAdjustmentFn(1);\nconst subtract = /*#__PURE__*/createAdjustmentFn(-1);\nfunction hasViewportRelativeCoordinates(event) {\n  return 'clientX' in event && 'clientY' in event;\n}\nfunction isKeyboardEvent(event) {\n  if (!event) {\n    return false;\n  }\n  const _getWindow2 = getWindow(event.target),\n    KeyboardEvent = _getWindow2.KeyboardEvent;\n  return KeyboardEvent && event instanceof KeyboardEvent;\n}\nfunction isTouchEvent(event) {\n  if (!event) {\n    return false;\n  }\n  const _getWindow3 = getWindow(event.target),\n    TouchEvent = _getWindow3.TouchEvent;\n  return TouchEvent && event instanceof TouchEvent;\n}\n\n/**\r\n * Returns the normalized x and y coordinates for mouse and touch events.\r\n */\n\nfunction getEventCoordinates(event) {\n  if (isTouchEvent(event)) {\n    if (event.touches && event.touches.length) {\n      const _event$touches$ = event.touches[0],\n        x = _event$touches$.clientX,\n        y = _event$touches$.clientY;\n      return {\n        x,\n        y\n      };\n    } else if (event.changedTouches && event.changedTouches.length) {\n      const _event$changedTouches = event.changedTouches[0],\n        x = _event$changedTouches.clientX,\n        y = _event$changedTouches.clientY;\n      return {\n        x,\n        y\n      };\n    }\n  }\n  if (hasViewportRelativeCoordinates(event)) {\n    return {\n      x: event.clientX,\n      y: event.clientY\n    };\n  }\n  return null;\n}\nconst CSS = /*#__PURE__*/Object.freeze({\n  Translate: {\n    toString(transform) {\n      if (!transform) {\n        return;\n      }\n      const x = transform.x,\n        y = transform.y;\n      return \"translate3d(\" + (x ? Math.round(x) : 0) + \"px, \" + (y ? Math.round(y) : 0) + \"px, 0)\";\n    }\n  },\n  Scale: {\n    toString(transform) {\n      if (!transform) {\n        return;\n      }\n      const scaleX = transform.scaleX,\n        scaleY = transform.scaleY;\n      return \"scaleX(\" + scaleX + \") scaleY(\" + scaleY + \")\";\n    }\n  },\n  Transform: {\n    toString(transform) {\n      if (!transform) {\n        return;\n      }\n      return [CSS.Translate.toString(transform), CSS.Scale.toString(transform)].join(' ');\n    }\n  },\n  Transition: {\n    toString(_ref) {\n      let property = _ref.property,\n        duration = _ref.duration,\n        easing = _ref.easing;\n      return property + \" \" + duration + \"ms \" + easing;\n    }\n  }\n});\nconst SELECTOR = 'a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not(:disabled),*[tabindex]';\nfunction findFirstFocusableNode(element) {\n  if (element.matches(SELECTOR)) {\n    return element;\n  }\n  return element.querySelector(SELECTOR);\n}\nexport { CSS, add, canUseDOM, findFirstFocusableNode, getEventCoordinates, getOwnerDocument, getWindow, hasViewportRelativeCoordinates, isDocument, isHTMLElement, isKeyboardEvent, isNode, isSVGElement, isTouchEvent, isWindow, subtract, useCombinedRefs, useEvent, useInterval, useIsomorphicLayoutEffect, useLatestValue, useLazyMemo, useNodeRef, usePrevious, useUniqueId };","/**\n * Assigns (shallow copies) the properties of `src` onto `dest`, if the\n * corresponding property on `dest` === `undefined`.\n *\n * @param {Object} dest The destination object.\n * @param {Object} src The source object.\n * @return {Object} The destination object (`dest`)\n */\nexport function defaults(dest, src) {\n  for (var prop in src) {\n    if (src.hasOwnProperty(prop) && dest[prop] === undefined) {\n      dest[prop] = src[prop];\n    }\n  }\n  return dest;\n}\n/**\n * Truncates the `str` at `len - ellipsisChars.length`, and adds the `ellipsisChars` to the\n * end of the string (by default, two periods: '..'). If the `str` length does not exceed\n * `len`, the string will be returned unchanged.\n *\n * @param {String} str The string to truncate and add an ellipsis to.\n * @param {Number} truncateLen The length to truncate the string at.\n * @param {String} [ellipsisChars=...] The ellipsis character(s) to add to the end of `str`\n *   when truncated. Defaults to '...'\n */\nexport function ellipsis(str, truncateLen, ellipsisChars) {\n  var ellipsisLength;\n  if (str.length > truncateLen) {\n    if (ellipsisChars == null) {\n      ellipsisChars = '&hellip;';\n      ellipsisLength = 3;\n    } else {\n      ellipsisLength = ellipsisChars.length;\n    }\n    str = str.substring(0, truncateLen - ellipsisLength) + ellipsisChars;\n  }\n  return str;\n}\n/**\n * Supports `Array.prototype.indexOf()` functionality for old IE (IE8 and below).\n *\n * @param {Array} arr The array to find an element of.\n * @param {*} element The element to find in the array, and return the index of.\n * @return {Number} The index of the `element`, or -1 if it was not found.\n */\nexport function indexOf(arr, element) {\n  // @ts-ignore - As far as TypeScript is concerned, this method will always\n  // exist (lowest \"lib\" in TS is \"ES5\"). Hence we need to ignore this error\n  // to support IE8 which only implements ES3 and doesn't have this method\n  if (Array.prototype.indexOf) {\n    return arr.indexOf(element);\n  } else {\n    for (var i = 0, len = arr.length; i < len; i++) {\n      if (arr[i] === element) return i;\n    }\n    return -1;\n  }\n}\n/**\n * Removes array elements based on a filtering function. Mutates the input\n * array.\n *\n * Using this instead of the ES5 Array.prototype.filter() function, to allow\n * Autolinker compatibility with IE8, and also to prevent creating many new\n * arrays in memory for filtering.\n *\n * @param {Array} arr The array to remove elements from. This array is\n *   mutated.\n * @param {Function} fn A function which should return `true` to\n *   remove an element.\n * @return {Array} The mutated input `arr`.\n */\nexport function remove(arr, fn) {\n  for (var i = arr.length - 1; i >= 0; i--) {\n    if (fn(arr[i]) === true) {\n      arr.splice(i, 1);\n    }\n  }\n}\n/**\n * Performs the functionality of what modern browsers do when `String.prototype.split()` is called\n * with a regular expression that contains capturing parenthesis.\n *\n * For example:\n *\n *     // Modern browsers:\n *     \"a,b,c\".split( /(,)/ );  // --> [ 'a', ',', 'b', ',', 'c' ]\n *\n *     // Old IE (including IE8):\n *     \"a,b,c\".split( /(,)/ );  // --> [ 'a', 'b', 'c' ]\n *\n * This method emulates the functionality of modern browsers for the old IE case.\n *\n * @param {String} str The string to split.\n * @param {RegExp} splitRegex The regular expression to split the input `str` on. The splitting\n *   character(s) will be spliced into the array, as in the \"modern browsers\" example in the\n *   description of this method.\n *   Note #1: the supplied regular expression **must** have the 'g' flag specified.\n *   Note #2: for simplicity's sake, the regular expression does not need\n *   to contain capturing parenthesis - it will be assumed that any match has them.\n * @return {String[]} The split array of strings, with the splitting character(s) included.\n */\nexport function splitAndCapture(str, splitRegex) {\n  if (!splitRegex.global) throw new Error(\"`splitRegex` must have the 'g' flag set\");\n  var result = [],\n    lastIdx = 0,\n    match;\n  while (match = splitRegex.exec(str)) {\n    result.push(str.substring(lastIdx, match.index));\n    result.push(match[0]); // push the splitting char(s)\n    lastIdx = match.index + match[0].length;\n  }\n  result.push(str.substring(lastIdx));\n  return result;\n}\n/**\n * Function that should never be called but is used to check that every\n * enum value is handled using TypeScript's 'never' type.\n */\nexport function throwUnhandledCaseError(theValue) {\n  throw new Error(\"Unhandled case for value: '\".concat(theValue, \"'\"));\n}","import { indexOf } from './utils';\n/**\n * @class Autolinker.HtmlTag\n * @extends Object\n *\n * Represents an HTML tag, which can be used to easily build/modify HTML tags programmatically.\n *\n * Autolinker uses this abstraction to create HTML tags, and then write them out as strings. You may also use\n * this class in your code, especially within a {@link Autolinker#replaceFn replaceFn}.\n *\n * ## Examples\n *\n * Example instantiation:\n *\n *     var tag = new Autolinker.HtmlTag( {\n *         tagName : 'a',\n *         attrs   : { 'href': 'http://google.com', 'class': 'external-link' },\n *         innerHtml : 'Google'\n *     } );\n *\n *     tag.toAnchorString();  // <a href=\"http://google.com\" class=\"external-link\">Google</a>\n *\n *     // Individual accessor methods\n *     tag.getTagName();                 // 'a'\n *     tag.getAttr( 'href' );            // 'http://google.com'\n *     tag.hasClass( 'external-link' );  // true\n *\n *\n * Using mutator methods (which may be used in combination with instantiation config properties):\n *\n *     var tag = new Autolinker.HtmlTag();\n *     tag.setTagName( 'a' );\n *     tag.setAttr( 'href', 'http://google.com' );\n *     tag.addClass( 'external-link' );\n *     tag.setInnerHtml( 'Google' );\n *\n *     tag.getTagName();                 // 'a'\n *     tag.getAttr( 'href' );            // 'http://google.com'\n *     tag.hasClass( 'external-link' );  // true\n *\n *     tag.toAnchorString();  // <a href=\"http://google.com\" class=\"external-link\">Google</a>\n *\n *\n * ## Example use within a {@link Autolinker#replaceFn replaceFn}\n *\n *     var html = Autolinker.link( \"Test google.com\", {\n *         replaceFn : function( match ) {\n *             var tag = match.buildTag();  // returns an {@link Autolinker.HtmlTag} instance, configured with the Match's href and anchor text\n *             tag.setAttr( 'rel', 'nofollow' );\n *\n *             return tag;\n *         }\n *     } );\n *\n *     // generated html:\n *     //   Test <a href=\"http://google.com\" target=\"_blank\" rel=\"nofollow\">google.com</a>\n *\n *\n * ## Example use with a new tag for the replacement\n *\n *     var html = Autolinker.link( \"Test google.com\", {\n *         replaceFn : function( match ) {\n *             var tag = new Autolinker.HtmlTag( {\n *                 tagName : 'button',\n *                 attrs   : { 'title': 'Load URL: ' + match.getAnchorHref() },\n *                 innerHtml : 'Load URL: ' + match.getAnchorText()\n *             } );\n *\n *             return tag;\n *         }\n *     } );\n *\n *     // generated html:\n *     //   Test <button title=\"Load URL: http://google.com\">Load URL: google.com</button>\n */\nvar HtmlTag = /** @class */function () {\n  /**\n   * @method constructor\n   * @param {Object} [cfg] The configuration properties for this class, in an Object (map)\n   */\n  function HtmlTag(cfg) {\n    if (cfg === void 0) {\n      cfg = {};\n    }\n    /**\n     * @cfg {String} tagName\n     *\n     * The tag name. Ex: 'a', 'button', etc.\n     *\n     * Not required at instantiation time, but should be set using {@link #setTagName} before {@link #toAnchorString}\n     * is executed.\n     */\n    this.tagName = ''; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Object.<String, String>} attrs\n     *\n     * An key/value Object (map) of attributes to create the tag with. The keys are the attribute names, and the\n     * values are the attribute values.\n     */\n    this.attrs = {}; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {String} innerHTML\n     *\n     * The inner HTML for the tag.\n     */\n    this.innerHTML = ''; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @protected\n     * @property {RegExp} whitespaceRegex\n     *\n     * Regular expression used to match whitespace in a string of CSS classes.\n     */\n    this.whitespaceRegex = /\\s+/; // default value just to get the above doc comment in the ES5 output and documentation generator\n    this.tagName = cfg.tagName || '';\n    this.attrs = cfg.attrs || {};\n    this.innerHTML = cfg.innerHtml || cfg.innerHTML || ''; // accept either the camelCased form or the fully capitalized acronym as in the DOM\n  }\n  /**\n   * Sets the tag name that will be used to generate the tag with.\n   *\n   * @param {String} tagName\n   * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained.\n   */\n  HtmlTag.prototype.setTagName = function (tagName) {\n    this.tagName = tagName;\n    return this;\n  };\n  /**\n   * Retrieves the tag name.\n   *\n   * @return {String}\n   */\n  HtmlTag.prototype.getTagName = function () {\n    return this.tagName || '';\n  };\n  /**\n   * Sets an attribute on the HtmlTag.\n   *\n   * @param {String} attrName The attribute name to set.\n   * @param {String} attrValue The attribute value to set.\n   * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained.\n   */\n  HtmlTag.prototype.setAttr = function (attrName, attrValue) {\n    var tagAttrs = this.getAttrs();\n    tagAttrs[attrName] = attrValue;\n    return this;\n  };\n  /**\n   * Retrieves an attribute from the HtmlTag. If the attribute does not exist, returns `undefined`.\n   *\n   * @param {String} attrName The attribute name to retrieve.\n   * @return {String} The attribute's value, or `undefined` if it does not exist on the HtmlTag.\n   */\n  HtmlTag.prototype.getAttr = function (attrName) {\n    return this.getAttrs()[attrName];\n  };\n  /**\n   * Sets one or more attributes on the HtmlTag.\n   *\n   * @param {Object.<String, String>} attrs A key/value Object (map) of the attributes to set.\n   * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained.\n   */\n  HtmlTag.prototype.setAttrs = function (attrs) {\n    Object.assign(this.getAttrs(), attrs);\n    return this;\n  };\n  /**\n   * Retrieves the attributes Object (map) for the HtmlTag.\n   *\n   * @return {Object.<String, String>} A key/value object of the attributes for the HtmlTag.\n   */\n  HtmlTag.prototype.getAttrs = function () {\n    return this.attrs || (this.attrs = {});\n  };\n  /**\n   * Sets the provided `cssClass`, overwriting any current CSS classes on the HtmlTag.\n   *\n   * @param {String} cssClass One or more space-separated CSS classes to set (overwrite).\n   * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained.\n   */\n  HtmlTag.prototype.setClass = function (cssClass) {\n    return this.setAttr('class', cssClass);\n  };\n  /**\n   * Convenience method to add one or more CSS classes to the HtmlTag. Will not add duplicate CSS classes.\n   *\n   * @param {String} cssClass One or more space-separated CSS classes to add.\n   * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained.\n   */\n  HtmlTag.prototype.addClass = function (cssClass) {\n    var classAttr = this.getClass(),\n      whitespaceRegex = this.whitespaceRegex,\n      classes = !classAttr ? [] : classAttr.split(whitespaceRegex),\n      newClasses = cssClass.split(whitespaceRegex),\n      newClass;\n    while (newClass = newClasses.shift()) {\n      if (indexOf(classes, newClass) === -1) {\n        classes.push(newClass);\n      }\n    }\n    this.getAttrs()['class'] = classes.join(' ');\n    return this;\n  };\n  /**\n   * Convenience method to remove one or more CSS classes from the HtmlTag.\n   *\n   * @param {String} cssClass One or more space-separated CSS classes to remove.\n   * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained.\n   */\n  HtmlTag.prototype.removeClass = function (cssClass) {\n    var classAttr = this.getClass(),\n      whitespaceRegex = this.whitespaceRegex,\n      classes = !classAttr ? [] : classAttr.split(whitespaceRegex),\n      removeClasses = cssClass.split(whitespaceRegex),\n      removeClass;\n    while (classes.length && (removeClass = removeClasses.shift())) {\n      var idx = indexOf(classes, removeClass);\n      if (idx !== -1) {\n        classes.splice(idx, 1);\n      }\n    }\n    this.getAttrs()['class'] = classes.join(' ');\n    return this;\n  };\n  /**\n   * Convenience method to retrieve the CSS class(es) for the HtmlTag, which will each be separated by spaces when\n   * there are multiple.\n   *\n   * @return {String}\n   */\n  HtmlTag.prototype.getClass = function () {\n    return this.getAttrs()['class'] || '';\n  };\n  /**\n   * Convenience method to check if the tag has a CSS class or not.\n   *\n   * @param {String} cssClass The CSS class to check for.\n   * @return {Boolean} `true` if the HtmlTag has the CSS class, `false` otherwise.\n   */\n  HtmlTag.prototype.hasClass = function (cssClass) {\n    return (' ' + this.getClass() + ' ').indexOf(' ' + cssClass + ' ') !== -1;\n  };\n  /**\n   * Sets the inner HTML for the tag.\n   *\n   * @param {String} html The inner HTML to set.\n   * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained.\n   */\n  HtmlTag.prototype.setInnerHTML = function (html) {\n    this.innerHTML = html;\n    return this;\n  };\n  /**\n   * Backwards compatibility method name.\n   *\n   * @param {String} html The inner HTML to set.\n   * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained.\n   */\n  HtmlTag.prototype.setInnerHtml = function (html) {\n    return this.setInnerHTML(html);\n  };\n  /**\n   * Retrieves the inner HTML for the tag.\n   *\n   * @return {String}\n   */\n  HtmlTag.prototype.getInnerHTML = function () {\n    return this.innerHTML || '';\n  };\n  /**\n   * Backward compatibility method name.\n   *\n   * @return {String}\n   */\n  HtmlTag.prototype.getInnerHtml = function () {\n    return this.getInnerHTML();\n  };\n  /**\n   * Override of superclass method used to generate the HTML string for the tag.\n   *\n   * @return {String}\n   */\n  HtmlTag.prototype.toAnchorString = function () {\n    var tagName = this.getTagName(),\n      attrsStr = this.buildAttrsStr();\n    attrsStr = attrsStr ? ' ' + attrsStr : ''; // prepend a space if there are actually attributes\n    return ['<', tagName, attrsStr, '>', this.getInnerHtml(), '</', tagName, '>'].join('');\n  };\n  /**\n   * Support method for {@link #toAnchorString}, returns the string space-separated key=\"value\" pairs, used to populate\n   * the stringified HtmlTag.\n   *\n   * @protected\n   * @return {String} Example return: `attr1=\"value1\" attr2=\"value2\"`\n   */\n  HtmlTag.prototype.buildAttrsStr = function () {\n    if (!this.attrs) return ''; // no `attrs` Object (map) has been set, return empty string\n    var attrs = this.getAttrs(),\n      attrsArr = [];\n    for (var prop in attrs) {\n      if (attrs.hasOwnProperty(prop)) {\n        attrsArr.push(prop + '=\"' + attrs[prop] + '\"');\n      }\n    }\n    return attrsArr.join(' ');\n  };\n  return HtmlTag;\n}();\nexport { HtmlTag };","import { HtmlTag } from './html-tag';\nimport { truncateSmart } from './truncate/truncate-smart';\nimport { truncateMiddle } from './truncate/truncate-middle';\nimport { truncateEnd } from './truncate/truncate-end';\n/**\n * @protected\n * @class Autolinker.AnchorTagBuilder\n * @extends Object\n *\n * Builds anchor (&lt;a&gt;) tags for the Autolinker utility when a match is\n * found.\n *\n * Normally this class is instantiated, configured, and used internally by an\n * {@link Autolinker} instance, but may actually be used indirectly in a\n * {@link Autolinker#replaceFn replaceFn} to create {@link Autolinker.HtmlTag HtmlTag}\n * instances which may be modified before returning from the\n * {@link Autolinker#replaceFn replaceFn}. For example:\n *\n *     var html = Autolinker.link( \"Test google.com\", {\n *         replaceFn : function( match ) {\n *             var tag = match.buildTag();  // returns an {@link Autolinker.HtmlTag} instance\n *             tag.setAttr( 'rel', 'nofollow' );\n *\n *             return tag;\n *         }\n *     } );\n *\n *     // generated html:\n *     //   Test <a href=\"http://google.com\" target=\"_blank\" rel=\"nofollow\">google.com</a>\n */\nvar AnchorTagBuilder = /** @class */function () {\n  /**\n   * @method constructor\n   * @param {Object} [cfg] The configuration options for the AnchorTagBuilder instance, specified in an Object (map).\n   */\n  function AnchorTagBuilder(cfg) {\n    if (cfg === void 0) {\n      cfg = {};\n    }\n    /**\n     * @cfg {Boolean} newWindow\n     * @inheritdoc Autolinker#newWindow\n     */\n    this.newWindow = false; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Object} truncate\n     * @inheritdoc Autolinker#truncate\n     */\n    this.truncate = {}; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {String} className\n     * @inheritdoc Autolinker#className\n     */\n    this.className = ''; // default value just to get the above doc comment in the ES5 output and documentation generator\n    this.newWindow = cfg.newWindow || false;\n    this.truncate = cfg.truncate || {};\n    this.className = cfg.className || '';\n  }\n  /**\n   * Generates the actual anchor (&lt;a&gt;) tag to use in place of the\n   * matched text, via its `match` object.\n   *\n   * @param {Autolinker.match.Match} match The Match instance to generate an\n   *   anchor tag from.\n   * @return {Autolinker.HtmlTag} The HtmlTag instance for the anchor tag.\n   */\n  AnchorTagBuilder.prototype.build = function (match) {\n    return new HtmlTag({\n      tagName: 'a',\n      attrs: this.createAttrs(match),\n      innerHtml: this.processAnchorText(match.getAnchorText())\n    });\n  };\n  /**\n   * Creates the Object (map) of the HTML attributes for the anchor (&lt;a&gt;)\n   *   tag being generated.\n   *\n   * @protected\n   * @param {Autolinker.match.Match} match The Match instance to generate an\n   *   anchor tag from.\n   * @return {Object} A key/value Object (map) of the anchor tag's attributes.\n   */\n  AnchorTagBuilder.prototype.createAttrs = function (match) {\n    var attrs = {\n      href: match.getAnchorHref() // we'll always have the `href` attribute\n    };\n    var cssClass = this.createCssClass(match);\n    if (cssClass) {\n      attrs['class'] = cssClass;\n    }\n    if (this.newWindow) {\n      attrs['target'] = '_blank';\n      attrs['rel'] = 'noopener noreferrer'; // Issue #149. See https://mathiasbynens.github.io/rel-noopener/\n    }\n    if (this.truncate) {\n      if (this.truncate.length && this.truncate.length < match.getAnchorText().length) {\n        attrs['title'] = match.getAnchorHref();\n      }\n    }\n    return attrs;\n  };\n  /**\n   * Creates the CSS class that will be used for a given anchor tag, based on\n   * the `matchType` and the {@link #className} config.\n   *\n   * Example returns:\n   *\n   * - \"\"                                      // no {@link #className}\n   * - \"myLink myLink-url\"                     // url match\n   * - \"myLink myLink-email\"                   // email match\n   * - \"myLink myLink-phone\"                   // phone match\n   * - \"myLink myLink-hashtag\"                 // hashtag match\n   * - \"myLink myLink-mention myLink-twitter\"  // mention match with Twitter service\n   *\n   * @protected\n   * @param {Autolinker.match.Match} match The Match instance to generate an\n   *   anchor tag from.\n   * @return {String} The CSS class string for the link. Example return:\n   *   \"myLink myLink-url\". If no {@link #className} was configured, returns\n   *   an empty string.\n   */\n  AnchorTagBuilder.prototype.createCssClass = function (match) {\n    var className = this.className;\n    if (!className) {\n      return '';\n    } else {\n      var returnClasses = [className],\n        cssClassSuffixes = match.getCssClassSuffixes();\n      for (var i = 0, len = cssClassSuffixes.length; i < len; i++) {\n        returnClasses.push(className + '-' + cssClassSuffixes[i]);\n      }\n      return returnClasses.join(' ');\n    }\n  };\n  /**\n   * Processes the `anchorText` by truncating the text according to the\n   * {@link #truncate} config.\n   *\n   * @private\n   * @param {String} anchorText The anchor tag's text (i.e. what will be\n   *   displayed).\n   * @return {String} The processed `anchorText`.\n   */\n  AnchorTagBuilder.prototype.processAnchorText = function (anchorText) {\n    anchorText = this.doTruncate(anchorText);\n    return anchorText;\n  };\n  /**\n   * Performs the truncation of the `anchorText` based on the {@link #truncate}\n   * option. If the `anchorText` is longer than the length specified by the\n   * {@link #truncate} option, the truncation is performed based on the\n   * `location` property. See {@link #truncate} for details.\n   *\n   * @private\n   * @param {String} anchorText The anchor tag's text (i.e. what will be\n   *   displayed).\n   * @return {String} The truncated anchor text.\n   */\n  AnchorTagBuilder.prototype.doTruncate = function (anchorText) {\n    var truncate = this.truncate;\n    if (!truncate || !truncate.length) return anchorText;\n    var truncateLength = truncate.length,\n      truncateLocation = truncate.location;\n    if (truncateLocation === 'smart') {\n      return truncateSmart(anchorText, truncateLength);\n    } else if (truncateLocation === 'middle') {\n      return truncateMiddle(anchorText, truncateLength);\n    } else {\n      return truncateEnd(anchorText, truncateLength);\n    }\n  };\n  return AnchorTagBuilder;\n}();\nexport { AnchorTagBuilder };","import { __extends } from \"tslib\";\nimport { Matcher } from './matcher';\nimport { alphaNumericCharsStr, alphaNumericAndMarksCharsStr, getDomainNameStr } from '../regex-lib';\nimport { tldRegex } from './tld-regex';\nimport { UrlMatch } from '../match/url-match';\nimport { UrlMatchValidator } from './url-match-validator';\n// RegExp objects which are shared by all instances of UrlMatcher. These are\n// here to avoid re-instantiating the RegExp objects if `Autolinker.link()` is\n// called multiple times, thus instantiating UrlMatcher and its RegExp\n// objects each time (which is very expensive - see https://github.com/gregjacobs/Autolinker.js/issues/314).\n// See descriptions of the properties where they are used for details about them\n// prettier-ignore\nvar matcherRegex = function () {\n  var schemeRegex = /(?:[A-Za-z][-.+A-Za-z0-9]{0,63}:(?![A-Za-z][-.+A-Za-z0-9]{0,63}:\\/\\/)(?!\\d+\\/?)(?:\\/\\/)?)/,\n    // match protocol, allow in format \"http://\" or \"mailto:\". However, do not match the first part of something like 'link:http://www.google.com' (i.e. don't match \"link:\"). Also, make sure we don't interpret 'google.com:8000' as if 'google.com' was a protocol here (i.e. ignore a trailing port number in this regex)\n    wwwRegex = /(?:www\\.)/,\n    // starting with 'www.'\n    // Allow optional path, query string, and hash anchor, not ending in the following characters: \"?!:,.;\"\n    // http://blog.codinghorror.com/the-problem-with-urls/\n    urlSuffixRegex = new RegExp('[/?#](?:[' + alphaNumericAndMarksCharsStr + '\\\\-+&@#/%=~_()|\\'$*\\\\[\\\\]{}?!:,.;^\\u2713]*[' + alphaNumericAndMarksCharsStr + '\\\\-+&@#/%=~_()|\\'$*\\\\[\\\\]{}\\u2713])?');\n  return new RegExp(['(?:', '(', schemeRegex.source, getDomainNameStr(2), ')', '|', '(', '(//)?', wwwRegex.source, getDomainNameStr(6), ')', '|', '(', '(//)?', getDomainNameStr(10) + '\\\\.', tldRegex.source, '(?![-' + alphaNumericCharsStr + '])', ')', ')', '(?::[0-9]+)?', '(?:' + urlSuffixRegex.source + ')?' // match for path, query string, and/or hash anchor - optional\n  ].join(\"\"), 'gi');\n}();\nvar wordCharRegExp = new RegExp('[' + alphaNumericAndMarksCharsStr + ']');\n/**\n * @class Autolinker.matcher.Url\n * @extends Autolinker.matcher.Matcher\n *\n * Matcher to find URL matches in an input string.\n *\n * See this class's superclass ({@link Autolinker.matcher.Matcher}) for more details.\n */\nvar UrlMatcher = /** @class */function (_super) {\n  __extends(UrlMatcher, _super);\n  /**\n   * @method constructor\n   * @param {Object} cfg The configuration properties for the Match instance,\n   *   specified in an Object (map).\n   */\n  function UrlMatcher(cfg) {\n    var _this = _super.call(this, cfg) || this;\n    /**\n     * @cfg {Object} stripPrefix (required)\n     *\n     * The Object form of {@link Autolinker#cfg-stripPrefix}.\n     */\n    _this.stripPrefix = {\n      scheme: true,\n      www: true\n    }; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Boolean} stripTrailingSlash (required)\n     * @inheritdoc Autolinker#stripTrailingSlash\n     */\n    _this.stripTrailingSlash = true; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Boolean} decodePercentEncoding (required)\n     * @inheritdoc Autolinker#decodePercentEncoding\n     */\n    _this.decodePercentEncoding = true; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @protected\n     * @property {RegExp} matcherRegex\n     *\n     * The regular expression to match URLs with an optional scheme, port\n     * number, path, query string, and hash anchor.\n     *\n     * Example matches:\n     *\n     *     http://google.com\n     *     www.google.com\n     *     google.com/path/to/file?q1=1&q2=2#myAnchor\n     *\n     *\n     * This regular expression will have the following capturing groups:\n     *\n     * 1.  Group that matches a scheme-prefixed URL (i.e. 'http://google.com').\n     *     This is used to match scheme URLs with just a single word, such as\n     *     'http://localhost', where we won't double check that the domain name\n     *     has at least one dot ('.') in it.\n     * 2.  Group that matches a 'www.' prefixed URL. This is only matched if the\n     *     'www.' text was not prefixed by a scheme (i.e.: not prefixed by\n     *     'http://', 'ftp:', etc.)\n     * 3.  A protocol-relative ('//') match for the case of a 'www.' prefixed\n     *     URL. Will be an empty string if it is not a protocol-relative match.\n     *     We need to know the character before the '//' in order to determine\n     *     if it is a valid match or the // was in a string we don't want to\n     *     auto-link.\n     * 4.  Group that matches a known TLD (top level domain), when a scheme\n     *     or 'www.'-prefixed domain is not matched.\n     * 5.  A protocol-relative ('//') match for the case of a known TLD prefixed\n     *     URL. Will be an empty string if it is not a protocol-relative match.\n     *     See #3 for more info.\n     */\n    _this.matcherRegex = matcherRegex;\n    /**\n     * A regular expression to use to check the character before a protocol-relative\n     * URL match. We don't want to match a protocol-relative URL if it is part\n     * of another word.\n     *\n     * For example, we want to match something like \"Go to: //google.com\",\n     * but we don't want to match something like \"abc//google.com\"\n     *\n     * This regular expression is used to test the character before the '//'.\n     *\n     * @protected\n     * @type {RegExp} wordCharRegExp\n     */\n    _this.wordCharRegExp = wordCharRegExp;\n    _this.stripPrefix = cfg.stripPrefix;\n    _this.stripTrailingSlash = cfg.stripTrailingSlash;\n    _this.decodePercentEncoding = cfg.decodePercentEncoding;\n    return _this;\n  }\n  /**\n   * @inheritdoc\n   */\n  UrlMatcher.prototype.parseMatches = function (text) {\n    var matcherRegex = this.matcherRegex,\n      stripPrefix = this.stripPrefix,\n      stripTrailingSlash = this.stripTrailingSlash,\n      decodePercentEncoding = this.decodePercentEncoding,\n      tagBuilder = this.tagBuilder,\n      matches = [],\n      match;\n    var _loop_1 = function () {\n      var matchStr = match[0],\n        schemeUrlMatch = match[1],\n        wwwUrlMatch = match[4],\n        wwwProtocolRelativeMatch = match[5],\n        //tldUrlMatch = match[ 8 ],  -- not needed at the moment\n        tldProtocolRelativeMatch = match[9],\n        offset = match.index,\n        protocolRelativeMatch = wwwProtocolRelativeMatch || tldProtocolRelativeMatch,\n        prevChar = text.charAt(offset - 1);\n      if (!UrlMatchValidator.isValid(matchStr, schemeUrlMatch)) {\n        return \"continue\";\n      }\n      // If the match is preceded by an '@' character, then it is either\n      // an email address or a username. Skip these types of matches.\n      if (offset > 0 && prevChar === '@') {\n        return \"continue\";\n      }\n      // If it's a protocol-relative '//' match, but the character before the '//'\n      // was a word character (i.e. a letter/number), then we found the '//' in the\n      // middle of another word (such as \"asdf//asdf.com\"). In this case, skip the\n      // match.\n      if (offset > 0 && protocolRelativeMatch && this_1.wordCharRegExp.test(prevChar)) {\n        return \"continue\";\n      }\n      // If the URL ends with a question mark, don't include the question\n      // mark as part of the URL. We'll assume the question mark was the\n      // end of a sentence, such as: \"Going to google.com?\"\n      if (/\\?$/.test(matchStr)) {\n        matchStr = matchStr.substr(0, matchStr.length - 1);\n      }\n      // Handle a closing parenthesis or square bracket at the end of the\n      // match, and exclude it if there is not a matching open parenthesis\n      // or square bracket in the match itself.\n      if (this_1.matchHasUnbalancedClosingParen(matchStr)) {\n        matchStr = matchStr.substr(0, matchStr.length - 1); // remove the trailing \")\"\n      } else {\n        // Handle an invalid character after the TLD\n        var pos = this_1.matchHasInvalidCharAfterTld(matchStr, schemeUrlMatch);\n        if (pos > -1) {\n          matchStr = matchStr.substr(0, pos); // remove the trailing invalid chars\n        }\n      }\n      // The autolinker accepts many characters in a url's scheme (like `fake://test.com`).\n      // However, in cases where a URL is missing whitespace before an obvious link,\n      // (for example: `nowhitespacehttp://www.test.com`), we only want the match to start\n      // at the http:// part. We will check if the match contains a common scheme and then\n      // shift the match to start from there.\n      var foundCommonScheme = ['http://', 'https://'].find(function (commonScheme) {\n        return !!schemeUrlMatch && schemeUrlMatch.indexOf(commonScheme) !== -1;\n      });\n      if (foundCommonScheme) {\n        // If we found an overmatched URL, we want to find the index\n        // of where the match should start and shift the match to\n        // start from the beginning of the common scheme\n        var indexOfSchemeStart = matchStr.indexOf(foundCommonScheme);\n        matchStr = matchStr.substr(indexOfSchemeStart);\n        schemeUrlMatch = schemeUrlMatch.substr(indexOfSchemeStart);\n        offset = offset + indexOfSchemeStart;\n      }\n      var urlMatchType = schemeUrlMatch ? 'scheme' : wwwUrlMatch ? 'www' : 'tld',\n        protocolUrlMatch = !!schemeUrlMatch;\n      matches.push(new UrlMatch({\n        tagBuilder: tagBuilder,\n        matchedText: matchStr,\n        offset: offset,\n        urlMatchType: urlMatchType,\n        url: matchStr,\n        protocolUrlMatch: protocolUrlMatch,\n        protocolRelativeMatch: !!protocolRelativeMatch,\n        stripPrefix: stripPrefix,\n        stripTrailingSlash: stripTrailingSlash,\n        decodePercentEncoding: decodePercentEncoding\n      }));\n    };\n    var this_1 = this;\n    while ((match = matcherRegex.exec(text)) !== null) {\n      _loop_1();\n    }\n    return matches;\n  };\n  /**\n   * Determines if a match found has an unmatched closing parenthesis,\n   * square bracket or curly bracket. If so, the symbol will be removed\n   * from the match itself, and appended after the generated anchor tag.\n   *\n   * A match may have an extra closing parenthesis at the end of the match\n   * because the regular expression must include parenthesis for URLs such as\n   * \"wikipedia.com/something_(disambiguation)\", which should be auto-linked.\n   *\n   * However, an extra parenthesis *will* be included when the URL itself is\n   * wrapped in parenthesis, such as in the case of:\n   *     \"(wikipedia.com/something_(disambiguation))\"\n   * In this case, the last closing parenthesis should *not* be part of the\n   * URL itself, and this method will return `true`.\n   *\n   * For square brackets in URLs such as in PHP arrays, the same behavior as\n   * parenthesis discussed above should happen:\n   *     \"[http://www.example.com/foo.php?bar[]=1&bar[]=2&bar[]=3]\"\n   * The closing square bracket should not be part of the URL itself, and this\n   * method will return `true`.\n   *\n   * @protected\n   * @param {String} matchStr The full match string from the {@link #matcherRegex}.\n   * @return {Boolean} `true` if there is an unbalanced closing parenthesis or\n   *   square bracket at the end of the `matchStr`, `false` otherwise.\n   */\n  UrlMatcher.prototype.matchHasUnbalancedClosingParen = function (matchStr) {\n    var endChar = matchStr.charAt(matchStr.length - 1);\n    var startChar;\n    if (endChar === ')') {\n      startChar = '(';\n    } else if (endChar === ']') {\n      startChar = '[';\n    } else if (endChar === '}') {\n      startChar = '{';\n    } else {\n      return false; // not a close parenthesis or square bracket\n    }\n    // Find if there are the same number of open braces as close braces in\n    // the URL string, minus the last character (which we have already\n    // determined to be either ')', ']' or '}'\n    var numOpenBraces = 0;\n    for (var i = 0, len = matchStr.length - 1; i < len; i++) {\n      var char = matchStr.charAt(i);\n      if (char === startChar) {\n        numOpenBraces++;\n      } else if (char === endChar) {\n        numOpenBraces = Math.max(numOpenBraces - 1, 0);\n      }\n    }\n    // If the number of open braces matches the number of close braces in\n    // the URL minus the last character, then the match has *unbalanced*\n    // braces because of the last character. Example of unbalanced braces\n    // from the regex match:\n    //     \"http://example.com?a[]=1]\"\n    if (numOpenBraces === 0) {\n      return true;\n    }\n    return false;\n  };\n  /**\n   * Determine if there's an invalid character after the TLD in a URL. Valid\n   * characters after TLD are ':/?#'. Exclude scheme matched URLs from this\n   * check.\n   *\n   * @protected\n   * @param {String} urlMatch The matched URL, if there was one. Will be an\n   *   empty string if the match is not a URL match.\n   * @param {String} schemeUrlMatch The match URL string for a scheme\n   *   match. Ex: 'http://yahoo.com'. This is used to match something like\n   *   'http://localhost', where we won't double check that the domain name\n   *   has at least one '.' in it.\n   * @return {Number} the position where the invalid character was found. If\n   *   no such character was found, returns -1\n   */\n  UrlMatcher.prototype.matchHasInvalidCharAfterTld = function (urlMatch, schemeUrlMatch) {\n    if (!urlMatch) {\n      return -1;\n    }\n    var offset = 0;\n    if (schemeUrlMatch) {\n      offset = urlMatch.indexOf(':');\n      urlMatch = urlMatch.slice(offset);\n    }\n    // prettier-ignore\n    var re = new RegExp(\"^((.?\\/\\/)?[-.\" + alphaNumericAndMarksCharsStr + \"]*[-\" + alphaNumericAndMarksCharsStr + \"]\\\\.[-\" + alphaNumericAndMarksCharsStr + \"]+)\");\n    var res = re.exec(urlMatch);\n    if (res === null) {\n      return -1;\n    }\n    offset += res[1].length;\n    urlMatch = urlMatch.slice(res[1].length);\n    if (/^[^-.A-Za-z0-9:\\/?#]/.test(urlMatch)) {\n      return offset;\n    }\n    return -1;\n  };\n  return UrlMatcher;\n}(Matcher);\nexport { UrlMatcher };","/**\n * Date: 2015-10-05\n * Author: Kasper Søfren <soefritz@gmail.com> (https://github.com/kafoso)\n *\n * A truncation feature, where the ellipsis will be placed at a section within\n * the URL making it still somewhat human readable.\n *\n * @param {String} url\t\t\t\t\t\t A URL.\n * @param {Number} truncateLen\t\t The maximum length of the truncated output URL string.\n * @param {String} ellipsisChars\t The characters to place within the url, e.g. \"...\".\n * @return {String} The truncated URL.\n */\nexport function truncateSmart(url, truncateLen, ellipsisChars) {\n  var ellipsisLengthBeforeParsing;\n  var ellipsisLength;\n  if (ellipsisChars == null) {\n    ellipsisChars = '&hellip;';\n    ellipsisLength = 3;\n    ellipsisLengthBeforeParsing = 8;\n  } else {\n    ellipsisLength = ellipsisChars.length;\n    ellipsisLengthBeforeParsing = ellipsisChars.length;\n  }\n  var parse_url = function (url) {\n    // Functionality inspired by PHP function of same name\n    var urlObj = {};\n    var urlSub = url;\n    var match = urlSub.match(/^([a-z]+):\\/\\//i);\n    if (match) {\n      urlObj.scheme = match[1];\n      urlSub = urlSub.substr(match[0].length);\n    }\n    match = urlSub.match(/^(.*?)(?=(\\?|#|\\/|$))/i);\n    if (match) {\n      urlObj.host = match[1];\n      urlSub = urlSub.substr(match[0].length);\n    }\n    match = urlSub.match(/^\\/(.*?)(?=(\\?|#|$))/i);\n    if (match) {\n      urlObj.path = match[1];\n      urlSub = urlSub.substr(match[0].length);\n    }\n    match = urlSub.match(/^\\?(.*?)(?=(#|$))/i);\n    if (match) {\n      urlObj.query = match[1];\n      urlSub = urlSub.substr(match[0].length);\n    }\n    match = urlSub.match(/^#(.*?)$/i);\n    if (match) {\n      urlObj.fragment = match[1];\n      //urlSub = urlSub.substr(match[0].length);  -- not used. Uncomment if adding another block.\n    }\n    return urlObj;\n  };\n  var buildUrl = function (urlObj) {\n    var url = '';\n    if (urlObj.scheme && urlObj.host) {\n      url += urlObj.scheme + '://';\n    }\n    if (urlObj.host) {\n      url += urlObj.host;\n    }\n    if (urlObj.path) {\n      url += '/' + urlObj.path;\n    }\n    if (urlObj.query) {\n      url += '?' + urlObj.query;\n    }\n    if (urlObj.fragment) {\n      url += '#' + urlObj.fragment;\n    }\n    return url;\n  };\n  var buildSegment = function (segment, remainingAvailableLength) {\n    var remainingAvailableLengthHalf = remainingAvailableLength / 2,\n      startOffset = Math.ceil(remainingAvailableLengthHalf),\n      endOffset = -1 * Math.floor(remainingAvailableLengthHalf),\n      end = '';\n    if (endOffset < 0) {\n      end = segment.substr(endOffset);\n    }\n    return segment.substr(0, startOffset) + ellipsisChars + end;\n  };\n  if (url.length <= truncateLen) {\n    return url;\n  }\n  var availableLength = truncateLen - ellipsisLength;\n  var urlObj = parse_url(url);\n  // Clean up the URL\n  if (urlObj.query) {\n    var matchQuery = urlObj.query.match(/^(.*?)(?=(\\?|\\#))(.*?)$/i);\n    if (matchQuery) {\n      // Malformed URL; two or more \"?\". Removed any content behind the 2nd.\n      urlObj.query = urlObj.query.substr(0, matchQuery[1].length);\n      url = buildUrl(urlObj);\n    }\n  }\n  if (url.length <= truncateLen) {\n    return url;\n  }\n  if (urlObj.host) {\n    urlObj.host = urlObj.host.replace(/^www\\./, '');\n    url = buildUrl(urlObj);\n  }\n  if (url.length <= truncateLen) {\n    return url;\n  }\n  // Process and build the URL\n  var str = '';\n  if (urlObj.host) {\n    str += urlObj.host;\n  }\n  if (str.length >= availableLength) {\n    if (urlObj.host.length == truncateLen) {\n      return (urlObj.host.substr(0, truncateLen - ellipsisLength) + ellipsisChars).substr(0, availableLength + ellipsisLengthBeforeParsing);\n    }\n    return buildSegment(str, availableLength).substr(0, availableLength + ellipsisLengthBeforeParsing);\n  }\n  var pathAndQuery = '';\n  if (urlObj.path) {\n    pathAndQuery += '/' + urlObj.path;\n  }\n  if (urlObj.query) {\n    pathAndQuery += '?' + urlObj.query;\n  }\n  if (pathAndQuery) {\n    if ((str + pathAndQuery).length >= availableLength) {\n      if ((str + pathAndQuery).length == truncateLen) {\n        return (str + pathAndQuery).substr(0, truncateLen);\n      }\n      var remainingAvailableLength = availableLength - str.length;\n      return (str + buildSegment(pathAndQuery, remainingAvailableLength)).substr(0, availableLength + ellipsisLengthBeforeParsing);\n    } else {\n      str += pathAndQuery;\n    }\n  }\n  if (urlObj.fragment) {\n    var fragment = '#' + urlObj.fragment;\n    if ((str + fragment).length >= availableLength) {\n      if ((str + fragment).length == truncateLen) {\n        return (str + fragment).substr(0, truncateLen);\n      }\n      var remainingAvailableLength2 = availableLength - str.length;\n      return (str + buildSegment(fragment, remainingAvailableLength2)).substr(0, availableLength + ellipsisLengthBeforeParsing);\n    } else {\n      str += fragment;\n    }\n  }\n  if (urlObj.scheme && urlObj.host) {\n    var scheme = urlObj.scheme + '://';\n    if ((str + scheme).length < availableLength) {\n      return (scheme + str).substr(0, truncateLen);\n    }\n  }\n  if (str.length <= truncateLen) {\n    return str;\n  }\n  var end = '';\n  if (availableLength > 0) {\n    end = str.substr(-1 * Math.floor(availableLength / 2));\n  }\n  return (str.substr(0, Math.ceil(availableLength / 2)) + ellipsisChars + end).substr(0, availableLength + ellipsisLengthBeforeParsing);\n}","/**\n * Date: 2015-10-05\n * Author: Kasper Søfren <soefritz@gmail.com> (https://github.com/kafoso)\n *\n * A truncation feature, where the ellipsis will be placed in the dead-center of the URL.\n *\n * @param {String} url             A URL.\n * @param {Number} truncateLen     The maximum length of the truncated output URL string.\n * @param {String} ellipsisChars   The characters to place within the url, e.g. \"..\".\n * @return {String} The truncated URL.\n */\nexport function truncateMiddle(url, truncateLen, ellipsisChars) {\n  if (url.length <= truncateLen) {\n    return url;\n  }\n  var ellipsisLengthBeforeParsing;\n  var ellipsisLength;\n  if (ellipsisChars == null) {\n    ellipsisChars = '&hellip;';\n    ellipsisLengthBeforeParsing = 8;\n    ellipsisLength = 3;\n  } else {\n    ellipsisLengthBeforeParsing = ellipsisChars.length;\n    ellipsisLength = ellipsisChars.length;\n  }\n  var availableLength = truncateLen - ellipsisLength;\n  var end = '';\n  if (availableLength > 0) {\n    end = url.substr(-1 * Math.floor(availableLength / 2));\n  }\n  return (url.substr(0, Math.ceil(availableLength / 2)) + ellipsisChars + end).substr(0, availableLength + ellipsisLengthBeforeParsing);\n}","import { ellipsis } from '../utils';\n/**\n * A truncation feature where the ellipsis will be placed at the end of the URL.\n *\n * @param {String} anchorText\n * @param {Number} truncateLen The maximum length of the truncated output URL string.\n * @param {String} ellipsisChars The characters to place within the url, e.g. \"..\".\n * @return {String} The truncated URL.\n */\nexport function truncateEnd(anchorText, truncateLen, ellipsisChars) {\n  return ellipsis(anchorText, truncateLen, ellipsisChars);\n}","/**\n * @abstract\n * @class Autolinker.match.Match\n *\n * Represents a match found in an input string which should be Autolinked. A Match object is what is provided in a\n * {@link Autolinker#replaceFn replaceFn}, and may be used to query for details about the match.\n *\n * For example:\n *\n *     var input = \"...\";  // string with URLs, Email Addresses, and Mentions (Twitter, Instagram, Soundcloud)\n *\n *     var linkedText = Autolinker.link( input, {\n *         replaceFn : function( match ) {\n *             console.log( \"href = \", match.getAnchorHref() );\n *             console.log( \"text = \", match.getAnchorText() );\n *\n *             switch( match.getType() ) {\n *                 case 'url' :\n *                     console.log( \"url: \", match.getUrl() );\n *\n *                 case 'email' :\n *                     console.log( \"email: \", match.getEmail() );\n *\n *                 case 'mention' :\n *                     console.log( \"mention: \", match.getMention() );\n *             }\n *         }\n *     } );\n *\n * See the {@link Autolinker} class for more details on using the {@link Autolinker#replaceFn replaceFn}.\n */\nvar Match = /** @class */function () {\n  /**\n   * @member Autolinker.match.Match\n   * @method constructor\n   * @param {Object} cfg The configuration properties for the Match\n   *   instance, specified in an Object (map).\n   */\n  function Match(cfg) {\n    /**\n     * @cfg {Autolinker.AnchorTagBuilder} tagBuilder (required)\n     *\n     * Reference to the AnchorTagBuilder instance to use to generate an anchor\n     * tag for the Match.\n     */\n    // @ts-ignore\n    this.__jsduckDummyDocProp = null; // property used just to get the above doc comment into the ES5 output and documentation generator\n    /**\n     * @cfg {String} matchedText (required)\n     *\n     * The original text that was matched by the {@link Autolinker.matcher.Matcher}.\n     */\n    this.matchedText = ''; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Number} offset (required)\n     *\n     * The offset of where the match was made in the input string.\n     */\n    this.offset = 0; // default value just to get the above doc comment in the ES5 output and documentation generator\n    this.tagBuilder = cfg.tagBuilder;\n    this.matchedText = cfg.matchedText;\n    this.offset = cfg.offset;\n  }\n  /**\n   * Returns the original text that was matched.\n   *\n   * @return {String}\n   */\n  Match.prototype.getMatchedText = function () {\n    return this.matchedText;\n  };\n  /**\n   * Sets the {@link #offset} of where the match was made in the input string.\n   *\n   * A {@link Autolinker.matcher.Matcher} will be fed only HTML text nodes,\n   * and will therefore set an original offset that is relative to the HTML\n   * text node itself. However, we want this offset to be relative to the full\n   * HTML input string, and thus if using {@link Autolinker#parse} (rather\n   * than calling a {@link Autolinker.matcher.Matcher} directly), then this\n   * offset is corrected after the Matcher itself has done its job.\n   *\n   * @param {Number} offset\n   */\n  Match.prototype.setOffset = function (offset) {\n    this.offset = offset;\n  };\n  /**\n   * Returns the offset of where the match was made in the input string. This\n   * is the 0-based index of the match.\n   *\n   * @return {Number}\n   */\n  Match.prototype.getOffset = function () {\n    return this.offset;\n  };\n  /**\n   * Returns the CSS class suffix(es) for this match.\n   *\n   * A CSS class suffix is appended to the {@link Autolinker#className} in\n   * the {@link Autolinker.AnchorTagBuilder} when a match is translated into\n   * an anchor tag.\n   *\n   * For example, if {@link Autolinker#className} was configured as 'myLink',\n   * and this method returns `[ 'url' ]`, the final class name of the element\n   * will become: 'myLink myLink-url'.\n   *\n   * The match may provide multiple CSS class suffixes to be appended to the\n   * {@link Autolinker#className} in order to facilitate better styling\n   * options for different match criteria. See {@link Autolinker.match.Mention}\n   * for an example.\n   *\n   * By default, this method returns a single array with the match's\n   * {@link #getType type} name, but may be overridden by subclasses.\n   *\n   * @return {String[]}\n   */\n  Match.prototype.getCssClassSuffixes = function () {\n    return [this.getType()];\n  };\n  /**\n   * Builds and returns an {@link Autolinker.HtmlTag} instance based on the\n   * Match.\n   *\n   * This can be used to easily generate anchor tags from matches, and either\n   * return their HTML string, or modify them before doing so.\n   *\n   * Example Usage:\n   *\n   *     var tag = match.buildTag();\n   *     tag.addClass( 'cordova-link' );\n   *     tag.setAttr( 'target', '_system' );\n   *\n   *     tag.toAnchorString();  // <a href=\"http://google.com\" class=\"cordova-link\" target=\"_system\">Google</a>\n   *\n   * Example Usage in {@link Autolinker#replaceFn}:\n   *\n   *     var html = Autolinker.link( \"Test google.com\", {\n   *         replaceFn : function( match ) {\n   *             var tag = match.buildTag();  // returns an {@link Autolinker.HtmlTag} instance\n   *             tag.setAttr( 'rel', 'nofollow' );\n   *\n   *             return tag;\n   *         }\n   *     } );\n   *\n   *     // generated html:\n   *     //   Test <a href=\"http://google.com\" target=\"_blank\" rel=\"nofollow\">google.com</a>\n   */\n  Match.prototype.buildTag = function () {\n    return this.tagBuilder.build(this);\n  };\n  return Match;\n}();\nexport { Match };","import { __extends } from \"tslib\";\nimport { Match } from './match';\n/**\n * @class Autolinker.match.Email\n * @extends Autolinker.match.Match\n *\n * Represents a Email match found in an input string which should be Autolinked.\n *\n * See this class's superclass ({@link Autolinker.match.Match}) for more details.\n */\nvar EmailMatch = /** @class */function (_super) {\n  __extends(EmailMatch, _super);\n  /**\n   * @method constructor\n   * @param {Object} cfg The configuration properties for the Match\n   *   instance, specified in an Object (map).\n   */\n  function EmailMatch(cfg) {\n    var _this = _super.call(this, cfg) || this;\n    /**\n     * @cfg {String} email (required)\n     *\n     * The email address that was matched.\n     */\n    _this.email = ''; // default value just to get the above doc comment in the ES5 output and documentation generator\n    _this.email = cfg.email;\n    return _this;\n  }\n  /**\n   * Returns a string name for the type of match that this class represents.\n   * For the case of EmailMatch, returns 'email'.\n   *\n   * @return {String}\n   */\n  EmailMatch.prototype.getType = function () {\n    return 'email';\n  };\n  /**\n   * Returns the email address that was matched.\n   *\n   * @return {String}\n   */\n  EmailMatch.prototype.getEmail = function () {\n    return this.email;\n  };\n  /**\n   * Returns the anchor href that should be generated for the match.\n   *\n   * @return {String}\n   */\n  EmailMatch.prototype.getAnchorHref = function () {\n    return 'mailto:' + this.email;\n  };\n  /**\n   * Returns the anchor text that should be generated for the match.\n   *\n   * @return {String}\n   */\n  EmailMatch.prototype.getAnchorText = function () {\n    return this.email;\n  };\n  return EmailMatch;\n}(Match);\nexport { EmailMatch };","import { __extends } from \"tslib\";\nimport { Match } from './match';\n/**\n * @class Autolinker.match.Hashtag\n * @extends Autolinker.match.Match\n *\n * Represents a Hashtag match found in an input string which should be\n * Autolinked.\n *\n * See this class's superclass ({@link Autolinker.match.Match}) for more\n * details.\n */\nvar HashtagMatch = /** @class */function (_super) {\n  __extends(HashtagMatch, _super);\n  /**\n   * @method constructor\n   * @param {Object} cfg The configuration properties for the Match\n   *   instance, specified in an Object (map).\n   */\n  function HashtagMatch(cfg) {\n    var _this = _super.call(this, cfg) || this;\n    /**\n     * @cfg {String} serviceName\n     *\n     * The service to point hashtag matches to. See {@link Autolinker#hashtag}\n     * for available values.\n     */\n    _this.serviceName = ''; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {String} hashtag (required)\n     *\n     * The HashtagMatch that was matched, without the '#'.\n     */\n    _this.hashtag = ''; // default value just to get the above doc comment in the ES5 output and documentation generator\n    _this.serviceName = cfg.serviceName;\n    _this.hashtag = cfg.hashtag;\n    return _this;\n  }\n  /**\n   * Returns a string name for the type of match that this class represents.\n   * For the case of HashtagMatch, returns 'hashtag'.\n   *\n   * @return {String}\n   */\n  HashtagMatch.prototype.getType = function () {\n    return 'hashtag';\n  };\n  /**\n   * Returns the configured {@link #serviceName} to point the HashtagMatch to.\n   * Ex: 'facebook', 'twitter'.\n   *\n   * @return {String}\n   */\n  HashtagMatch.prototype.getServiceName = function () {\n    return this.serviceName;\n  };\n  /**\n   * Returns the matched hashtag, without the '#' character.\n   *\n   * @return {String}\n   */\n  HashtagMatch.prototype.getHashtag = function () {\n    return this.hashtag;\n  };\n  /**\n   * Returns the anchor href that should be generated for the match.\n   *\n   * @return {String}\n   */\n  HashtagMatch.prototype.getAnchorHref = function () {\n    var serviceName = this.serviceName,\n      hashtag = this.hashtag;\n    switch (serviceName) {\n      case 'twitter':\n        return 'https://twitter.com/hashtag/' + hashtag;\n      case 'facebook':\n        return 'https://www.facebook.com/hashtag/' + hashtag;\n      case 'instagram':\n        return 'https://instagram.com/explore/tags/' + hashtag;\n      case 'tiktok':\n        return 'https://www.tiktok.com/tag/' + hashtag;\n      default:\n        // Shouldn't happen because Autolinker's constructor should block any invalid values, but just in case.\n        throw new Error('Unknown service name to point hashtag to: ' + serviceName);\n    }\n  };\n  /**\n   * Returns the anchor text that should be generated for the match.\n   *\n   * @return {String}\n   */\n  HashtagMatch.prototype.getAnchorText = function () {\n    return '#' + this.hashtag;\n  };\n  return HashtagMatch;\n}(Match);\nexport { HashtagMatch };","import { __extends } from \"tslib\";\nimport { Match } from './match';\n/**\n * @class Autolinker.match.Mention\n * @extends Autolinker.match.Match\n *\n * Represents a Mention match found in an input string which should be Autolinked.\n *\n * See this class's superclass ({@link Autolinker.match.Match}) for more details.\n */\nvar MentionMatch = /** @class */function (_super) {\n  __extends(MentionMatch, _super);\n  /**\n   * @method constructor\n   * @param {Object} cfg The configuration properties for the Match\n   *   instance, specified in an Object (map).\n   */\n  function MentionMatch(cfg) {\n    var _this = _super.call(this, cfg) || this;\n    /**\n     * @cfg {String} serviceName\n     *\n     * The service to point mention matches to. See {@link Autolinker#mention}\n     * for available values.\n     */\n    _this.serviceName = 'twitter'; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {String} mention (required)\n     *\n     * The Mention that was matched, without the '@' character.\n     */\n    _this.mention = ''; // default value just to get the above doc comment in the ES5 output and documentation generator\n    _this.mention = cfg.mention;\n    _this.serviceName = cfg.serviceName;\n    return _this;\n  }\n  /**\n   * Returns a string name for the type of match that this class represents.\n   * For the case of MentionMatch, returns 'mention'.\n   *\n   * @return {String}\n   */\n  MentionMatch.prototype.getType = function () {\n    return 'mention';\n  };\n  /**\n   * Returns the mention, without the '@' character.\n   *\n   * @return {String}\n   */\n  MentionMatch.prototype.getMention = function () {\n    return this.mention;\n  };\n  /**\n   * Returns the configured {@link #serviceName} to point the mention to.\n   * Ex: 'instagram', 'twitter', 'soundcloud'.\n   *\n   * @return {String}\n   */\n  MentionMatch.prototype.getServiceName = function () {\n    return this.serviceName;\n  };\n  /**\n   * Returns the anchor href that should be generated for the match.\n   *\n   * @return {String}\n   */\n  MentionMatch.prototype.getAnchorHref = function () {\n    switch (this.serviceName) {\n      case 'twitter':\n        return 'https://twitter.com/' + this.mention;\n      case 'instagram':\n        return 'https://instagram.com/' + this.mention;\n      case 'soundcloud':\n        return 'https://soundcloud.com/' + this.mention;\n      case 'tiktok':\n        return 'https://www.tiktok.com/@' + this.mention;\n      default:\n        // Shouldn't happen because Autolinker's constructor should block any invalid values, but just in case.\n        throw new Error('Unknown service name to point mention to: ' + this.serviceName);\n    }\n  };\n  /**\n   * Returns the anchor text that should be generated for the match.\n   *\n   * @return {String}\n   */\n  MentionMatch.prototype.getAnchorText = function () {\n    return '@' + this.mention;\n  };\n  /**\n   * Returns the CSS class suffixes that should be used on a tag built with\n   * the match. See {@link Autolinker.match.Match#getCssClassSuffixes} for\n   * details.\n   *\n   * @return {String[]}\n   */\n  MentionMatch.prototype.getCssClassSuffixes = function () {\n    var cssClassSuffixes = _super.prototype.getCssClassSuffixes.call(this),\n      serviceName = this.getServiceName();\n    if (serviceName) {\n      cssClassSuffixes.push(serviceName);\n    }\n    return cssClassSuffixes;\n  };\n  return MentionMatch;\n}(Match);\nexport { MentionMatch };","import { __extends } from \"tslib\";\nimport { Match } from './match';\n/**\n * @class Autolinker.match.Phone\n * @extends Autolinker.match.Match\n *\n * Represents a Phone number match found in an input string which should be\n * Autolinked.\n *\n * See this class's superclass ({@link Autolinker.match.Match}) for more\n * details.\n */\nvar PhoneMatch = /** @class */function (_super) {\n  __extends(PhoneMatch, _super);\n  /**\n   * @method constructor\n   * @param {Object} cfg The configuration properties for the Match\n   *   instance, specified in an Object (map).\n   */\n  function PhoneMatch(cfg) {\n    var _this = _super.call(this, cfg) || this;\n    /**\n     * @protected\n     * @property {String} number (required)\n     *\n     * The phone number that was matched, without any delimiter characters.\n     *\n     * Note: This is a string to allow for prefixed 0's.\n     */\n    _this.number = ''; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @protected\n     * @property  {Boolean} plusSign (required)\n     *\n     * `true` if the matched phone number started with a '+' sign. We'll include\n     * it in the `tel:` URL if so, as this is needed for international numbers.\n     *\n     * Ex: '+1 (123) 456 7879'\n     */\n    _this.plusSign = false; // default value just to get the above doc comment in the ES5 output and documentation generator\n    _this.number = cfg.number;\n    _this.plusSign = cfg.plusSign;\n    return _this;\n  }\n  /**\n   * Returns a string name for the type of match that this class represents.\n   * For the case of PhoneMatch, returns 'phone'.\n   *\n   * @return {String}\n   */\n  PhoneMatch.prototype.getType = function () {\n    return 'phone';\n  };\n  /**\n   * Returns the phone number that was matched as a string, without any\n   * delimiter characters.\n   *\n   * Note: This is a string to allow for prefixed 0's.\n   *\n   * @return {String}\n   */\n  PhoneMatch.prototype.getPhoneNumber = function () {\n    return this.number;\n  };\n  /**\n   * Alias of {@link #getPhoneNumber}, returns the phone number that was\n   * matched as a string, without any delimiter characters.\n   *\n   * Note: This is a string to allow for prefixed 0's.\n   *\n   * @return {String}\n   */\n  PhoneMatch.prototype.getNumber = function () {\n    return this.getPhoneNumber();\n  };\n  /**\n   * Returns the anchor href that should be generated for the match.\n   *\n   * @return {String}\n   */\n  PhoneMatch.prototype.getAnchorHref = function () {\n    return 'tel:' + (this.plusSign ? '+' : '') + this.number;\n  };\n  /**\n   * Returns the anchor text that should be generated for the match.\n   *\n   * @return {String}\n   */\n  PhoneMatch.prototype.getAnchorText = function () {\n    return this.matchedText;\n  };\n  return PhoneMatch;\n}(Match);\nexport { PhoneMatch };","import { __extends } from \"tslib\";\nimport { Match } from './match';\n/**\n * @class Autolinker.match.Url\n * @extends Autolinker.match.Match\n *\n * Represents a Url match found in an input string which should be Autolinked.\n *\n * See this class's superclass ({@link Autolinker.match.Match}) for more details.\n */\nvar UrlMatch = /** @class */function (_super) {\n  __extends(UrlMatch, _super);\n  /**\n   * @method constructor\n   * @param {Object} cfg The configuration properties for the Match\n   *   instance, specified in an Object (map).\n   */\n  function UrlMatch(cfg) {\n    var _this = _super.call(this, cfg) || this;\n    /**\n     * @cfg {String} url (required)\n     *\n     * The url that was matched.\n     */\n    _this.url = ''; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {\"scheme\"/\"www\"/\"tld\"} urlMatchType (required)\n     *\n     * The type of URL match that this class represents. This helps to determine\n     * if the match was made in the original text with a prefixed scheme (ex:\n     * 'http://www.google.com'), a prefixed 'www' (ex: 'www.google.com'), or\n     * was matched by a known top-level domain (ex: 'google.com').\n     */\n    _this.urlMatchType = 'scheme'; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Boolean} protocolUrlMatch (required)\n     *\n     * `true` if the URL is a match which already has a protocol (i.e.\n     * 'http://'), `false` if the match was from a 'www' or known TLD match.\n     */\n    _this.protocolUrlMatch = false; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Boolean} protocolRelativeMatch (required)\n     *\n     * `true` if the URL is a protocol-relative match. A protocol-relative match\n     * is a URL that starts with '//', and will be either http:// or https://\n     * based on the protocol that the site is loaded under.\n     */\n    _this.protocolRelativeMatch = false; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Object} stripPrefix (required)\n     *\n     * The Object form of {@link Autolinker#cfg-stripPrefix}.\n     */\n    _this.stripPrefix = {\n      scheme: true,\n      www: true\n    }; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Boolean} stripTrailingSlash (required)\n     * @inheritdoc Autolinker#cfg-stripTrailingSlash\n     */\n    _this.stripTrailingSlash = true; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Boolean} decodePercentEncoding (required)\n     * @inheritdoc Autolinker#cfg-decodePercentEncoding\n     */\n    _this.decodePercentEncoding = true; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @private\n     * @property {RegExp} schemePrefixRegex\n     *\n     * A regular expression used to remove the 'http://' or 'https://' from\n     * URLs.\n     */\n    _this.schemePrefixRegex = /^(https?:\\/\\/)?/i;\n    /**\n     * @private\n     * @property {RegExp} wwwPrefixRegex\n     *\n     * A regular expression used to remove the 'www.' from URLs.\n     */\n    _this.wwwPrefixRegex = /^(https?:\\/\\/)?(www\\.)?/i;\n    /**\n     * @private\n     * @property {RegExp} protocolRelativeRegex\n     *\n     * The regular expression used to remove the protocol-relative '//' from the {@link #url} string, for purposes\n     * of {@link #getAnchorText}. A protocol-relative URL is, for example, \"//yahoo.com\"\n     */\n    _this.protocolRelativeRegex = /^\\/\\//;\n    /**\n     * @private\n     * @property {Boolean} protocolPrepended\n     *\n     * Will be set to `true` if the 'http://' protocol has been prepended to the {@link #url} (because the\n     * {@link #url} did not have a protocol)\n     */\n    _this.protocolPrepended = false;\n    _this.urlMatchType = cfg.urlMatchType;\n    _this.url = cfg.url;\n    _this.protocolUrlMatch = cfg.protocolUrlMatch;\n    _this.protocolRelativeMatch = cfg.protocolRelativeMatch;\n    _this.stripPrefix = cfg.stripPrefix;\n    _this.stripTrailingSlash = cfg.stripTrailingSlash;\n    _this.decodePercentEncoding = cfg.decodePercentEncoding;\n    return _this;\n  }\n  /**\n   * Returns a string name for the type of match that this class represents.\n   * For the case of UrlMatch, returns 'url'.\n   *\n   * @return {String}\n   */\n  UrlMatch.prototype.getType = function () {\n    return 'url';\n  };\n  /**\n   * Returns a string name for the type of URL match that this class\n   * represents.\n   *\n   * This helps to determine if the match was made in the original text with a\n   * prefixed scheme (ex: 'http://www.google.com'), a prefixed 'www' (ex:\n   * 'www.google.com'), or was matched by a known top-level domain (ex:\n   * 'google.com').\n   *\n   * @return {\"scheme\"/\"www\"/\"tld\"}\n   */\n  UrlMatch.prototype.getUrlMatchType = function () {\n    return this.urlMatchType;\n  };\n  /**\n   * Returns the url that was matched, assuming the protocol to be 'http://' if the original\n   * match was missing a protocol.\n   *\n   * @return {String}\n   */\n  UrlMatch.prototype.getUrl = function () {\n    var url = this.url;\n    // if the url string doesn't begin with a protocol, assume 'http://'\n    if (!this.protocolRelativeMatch && !this.protocolUrlMatch && !this.protocolPrepended) {\n      url = this.url = 'http://' + url;\n      this.protocolPrepended = true;\n    }\n    return url;\n  };\n  /**\n   * Returns the anchor href that should be generated for the match.\n   *\n   * @return {String}\n   */\n  UrlMatch.prototype.getAnchorHref = function () {\n    var url = this.getUrl();\n    return url.replace(/&amp;/g, '&'); // any &amp;'s in the URL should be converted back to '&' if they were displayed as &amp; in the source html\n  };\n  /**\n   * Returns the anchor text that should be generated for the match.\n   *\n   * @return {String}\n   */\n  UrlMatch.prototype.getAnchorText = function () {\n    var anchorText = this.getMatchedText();\n    if (this.protocolRelativeMatch) {\n      // Strip off any protocol-relative '//' from the anchor text\n      anchorText = this.stripProtocolRelativePrefix(anchorText);\n    }\n    if (this.stripPrefix.scheme) {\n      anchorText = this.stripSchemePrefix(anchorText);\n    }\n    if (this.stripPrefix.www) {\n      anchorText = this.stripWwwPrefix(anchorText);\n    }\n    if (this.stripTrailingSlash) {\n      anchorText = this.removeTrailingSlash(anchorText); // remove trailing slash, if there is one\n    }\n    if (this.decodePercentEncoding) {\n      anchorText = this.removePercentEncoding(anchorText);\n    }\n    return anchorText;\n  };\n  // ---------------------------------------\n  // Utility Functionality\n  /**\n   * Strips the scheme prefix (such as \"http://\" or \"https://\") from the given\n   * `url`.\n   *\n   * @private\n   * @param {String} url The text of the anchor that is being generated, for\n   *   which to strip off the url scheme.\n   * @return {String} The `url`, with the scheme stripped.\n   */\n  UrlMatch.prototype.stripSchemePrefix = function (url) {\n    return url.replace(this.schemePrefixRegex, '');\n  };\n  /**\n   * Strips the 'www' prefix from the given `url`.\n   *\n   * @private\n   * @param {String} url The text of the anchor that is being generated, for\n   *   which to strip off the 'www' if it exists.\n   * @return {String} The `url`, with the 'www' stripped.\n   */\n  UrlMatch.prototype.stripWwwPrefix = function (url) {\n    return url.replace(this.wwwPrefixRegex, '$1'); // leave any scheme ($1), it one exists\n  };\n  /**\n   * Strips any protocol-relative '//' from the anchor text.\n   *\n   * @private\n   * @param {String} text The text of the anchor that is being generated, for which to strip off the\n   *   protocol-relative prefix (such as stripping off \"//\")\n   * @return {String} The `anchorText`, with the protocol-relative prefix stripped.\n   */\n  UrlMatch.prototype.stripProtocolRelativePrefix = function (text) {\n    return text.replace(this.protocolRelativeRegex, '');\n  };\n  /**\n   * Removes any trailing slash from the given `anchorText`, in preparation for the text to be displayed.\n   *\n   * @private\n   * @param {String} anchorText The text of the anchor that is being generated, for which to remove any trailing\n   *   slash ('/') that may exist.\n   * @return {String} The `anchorText`, with the trailing slash removed.\n   */\n  UrlMatch.prototype.removeTrailingSlash = function (anchorText) {\n    if (anchorText.charAt(anchorText.length - 1) === '/') {\n      anchorText = anchorText.slice(0, -1);\n    }\n    return anchorText;\n  };\n  /**\n   * Decodes percent-encoded characters from the given `anchorText`, in\n   * preparation for the text to be displayed.\n   *\n   * @private\n   * @param {String} anchorText The text of the anchor that is being\n   *   generated, for which to decode any percent-encoded characters.\n   * @return {String} The `anchorText`, with the percent-encoded characters\n   *   decoded.\n   */\n  UrlMatch.prototype.removePercentEncoding = function (anchorText) {\n    // First, convert a few of the known % encodings to the corresponding\n    // HTML entities that could accidentally be interpretted as special\n    // HTML characters\n    var preProcessedEntityAnchorText = anchorText.replace(/%22/gi, '&quot;') // \" char\n    .replace(/%26/gi, '&amp;') // & char\n    .replace(/%27/gi, '&#39;') // ' char\n    .replace(/%3C/gi, '&lt;') // < char\n    .replace(/%3E/gi, '&gt;'); // > char\n    try {\n      // Now attempt to decode the rest of the anchor text\n      return decodeURIComponent(preProcessedEntityAnchorText);\n    } catch (e) {\n      // Invalid % escape sequence in the anchor text\n      return preProcessedEntityAnchorText;\n    }\n  };\n  return UrlMatch;\n}(Match);\nexport { UrlMatch };","/**\n * @abstract\n * @class Autolinker.matcher.Matcher\n *\n * An abstract class and interface for individual matchers to find matches in\n * an input string with linkified versions of them.\n *\n * Note that Matchers do not take HTML into account - they must be fed the text\n * nodes of any HTML string, which is handled by {@link Autolinker#parse}.\n */\nvar Matcher = /** @class */function () {\n  /**\n   * @method constructor\n   * @param {Object} cfg The configuration properties for the Matcher\n   *   instance, specified in an Object (map).\n   */\n  function Matcher(cfg) {\n    /**\n     * @cfg {Autolinker.AnchorTagBuilder} tagBuilder (required)\n     *\n     * Reference to the AnchorTagBuilder instance to use to generate HTML tags\n     * for {@link Autolinker.match.Match Matches}.\n     */\n    // @ts-ignore\n    this.__jsduckDummyDocProp = null; // property used just to get the above doc comment into the ES5 output and documentation generator\n    this.tagBuilder = cfg.tagBuilder;\n  }\n  return Matcher;\n}();\nexport { Matcher };","/*\n * This file builds and stores a library of the common regular expressions used\n * by the Autolinker utility.\n *\n * Other regular expressions may exist ad-hoc, but these are generally the\n * regular expressions that are shared between source files.\n */\n/**\n * Regular expression to match upper and lowercase ASCII letters\n */\nexport var letterRe = /[A-Za-z]/;\n/**\n * Regular expression to match ASCII digits\n */\nexport var digitRe = /[\\d]/;\n/**\n * Regular expression to match everything *except* ASCII digits\n */\nexport var nonDigitRe = /[\\D]/;\n/**\n * Regular expression to match whitespace\n */\nexport var whitespaceRe = /\\s/;\n/**\n * Regular expression to match quote characters\n */\nexport var quoteRe = /['\"]/;\n/**\n * Regular expression to match the range of ASCII control characters (0-31), and\n * the backspace char (127)\n */\nexport var controlCharsRe = /[\\x00-\\x1F\\x7F]/;\n/**\n * The string form of a regular expression that would match all of the\n * alphabetic (\"letter\") chars in the unicode character set when placed in a\n * RegExp character class (`[]`). This includes all international alphabetic\n * characters.\n *\n * These would be the characters matched by unicode regex engines `\\p{L}`\n * escape (\"all letters\").\n *\n * Taken from the XRegExp library: http://xregexp.com/ (thanks @https://github.com/slevithan)\n * Specifically: http://xregexp.com/v/3.2.0/xregexp-all.js, the 'Letter'\n *   regex's bmp\n *\n * VERY IMPORTANT: This set of characters is defined inside of a Regular\n *   Expression literal rather than a string literal to prevent UglifyJS from\n *   compressing the unicode escape sequences into their actual unicode\n *   characters. If Uglify compresses these into the unicode characters\n *   themselves, this results in the error \"Range out of order in character\n *   class\" when these characters are used inside of a Regular Expression\n *   character class (`[]`). See usages of this const. Alternatively, we can set\n *   the UglifyJS option `ascii_only` to true for the build, but that doesn't\n *   help others who are pulling in Autolinker into their own build and running\n *   UglifyJS themselves.\n */\n// prettier-ignore\nexport var alphaCharsStr = /A-Za-z\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0-\\u08B4\\u08B6-\\u08BD\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C60\\u0C61\\u0C80\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D54-\\u0D56\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\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\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\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\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16F1-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u1884\\u1887-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1C80-\\u1C88\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\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\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6E5\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AE\\uA7B0-\\uA7B7\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC/.source; // see note in above variable description\n/**\n * The string form of a regular expression that would match all emoji characters\n * Based on the emoji regex defined in this article: https://thekevinscott.com/emojis-in-javascript/\n */\nexport var emojiStr = /\\u2700-\\u27bf\\udde6-\\uddff\\ud800-\\udbff\\udc00-\\udfff\\ufe0e\\ufe0f\\u0300-\\u036f\\ufe20-\\ufe23\\u20d0-\\u20f0\\ud83c\\udffb-\\udfff\\u200d\\u3299\\u3297\\u303d\\u3030\\u24c2\\ud83c\\udd70-\\udd71\\udd7e-\\udd7f\\udd8e\\udd91-\\udd9a\\udde6-\\uddff\\ude01-\\ude02\\ude1a\\ude2f\\ude32-\\ude3a\\ude50-\\ude51\\u203c\\u2049\\u25aa-\\u25ab\\u25b6\\u25c0\\u25fb-\\u25fe\\u00a9\\u00ae\\u2122\\u2139\\udc04\\u2600-\\u26FF\\u2b05\\u2b06\\u2b07\\u2b1b\\u2b1c\\u2b50\\u2b55\\u231a\\u231b\\u2328\\u23cf\\u23e9-\\u23f3\\u23f8-\\u23fa\\udccf\\u2935\\u2934\\u2190-\\u21ff/.source;\n/**\n * The string form of a regular expression that would match all of the\n * combining mark characters in the unicode character set when placed in a\n * RegExp character class (`[]`).\n *\n * These would be the characters matched by unicode regex engines `\\p{M}`\n * escape (\"all marks\").\n *\n * Taken from the XRegExp library: http://xregexp.com/ (thanks @https://github.com/slevithan)\n * Specifically: http://xregexp.com/v/3.2.0/xregexp-all.js, the 'Mark'\n *   regex's bmp\n *\n * VERY IMPORTANT: This set of characters is defined inside of a Regular\n *   Expression literal rather than a string literal to prevent UglifyJS from\n *   compressing the unicode escape sequences into their actual unicode\n *   characters. If Uglify compresses these into the unicode characters\n *   themselves, this results in the error \"Range out of order in character\n *   class\" when these characters are used inside of a Regular Expression\n *   character class (`[]`). See usages of this const. Alternatively, we can set\n *   the UglifyJS option `ascii_only` to true for the build, but that doesn't\n *   help others who are pulling in Autolinker into their own build and running\n *   UglifyJS themselves.\n */\n// prettier-ignore\nexport var marksStr = /\\u0300-\\u036F\\u0483-\\u0489\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065F\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0859-\\u085B\\u08D4-\\u08E1\\u08E3-\\u0903\\u093A-\\u093C\\u093E-\\u094F\\u0951-\\u0957\\u0962\\u0963\\u0981-\\u0983\\u09BC\\u09BE-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CD\\u09D7\\u09E2\\u09E3\\u0A01-\\u0A03\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81-\\u0A83\\u0ABC\\u0ABE-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0AE2\\u0AE3\\u0B01-\\u0B03\\u0B3C\\u0B3E-\\u0B44\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B62\\u0B63\\u0B82\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD7\\u0C00-\\u0C03\\u0C3E-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0C81-\\u0C83\\u0CBC\\u0CBE-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0CE2\\u0CE3\\u0D01-\\u0D03\\u0D3E-\\u0D44\\u0D46-\\u0D48\\u0D4A-\\u0D4D\\u0D57\\u0D62\\u0D63\\u0D82\\u0D83\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F3E\\u0F3F\\u0F71-\\u0F84\\u0F86\\u0F87\\u0F8D-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102B-\\u103E\\u1056-\\u1059\\u105E-\\u1060\\u1062-\\u1064\\u1067-\\u106D\\u1071-\\u1074\\u1082-\\u108D\\u108F\\u109A-\\u109D\\u135D-\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B4-\\u17D3\\u17DD\\u180B-\\u180D\\u1885\\u1886\\u18A9\\u1920-\\u192B\\u1930-\\u193B\\u1A17-\\u1A1B\\u1A55-\\u1A5E\\u1A60-\\u1A7C\\u1A7F\\u1AB0-\\u1ABE\\u1B00-\\u1B04\\u1B34-\\u1B44\\u1B6B-\\u1B73\\u1B80-\\u1B82\\u1BA1-\\u1BAD\\u1BE6-\\u1BF3\\u1C24-\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE8\\u1CED\\u1CF2-\\u1CF4\\u1CF8\\u1CF9\\u1DC0-\\u1DF5\\u1DFB-\\u1DFF\\u20D0-\\u20F0\\u2CEF-\\u2CF1\\u2D7F\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F-\\uA672\\uA674-\\uA67D\\uA69E\\uA69F\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA823-\\uA827\\uA880\\uA881\\uA8B4-\\uA8C5\\uA8E0-\\uA8F1\\uA926-\\uA92D\\uA947-\\uA953\\uA980-\\uA983\\uA9B3-\\uA9C0\\uA9E5\\uAA29-\\uAA36\\uAA43\\uAA4C\\uAA4D\\uAA7B-\\uAA7D\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uAAEB-\\uAAEF\\uAAF5\\uAAF6\\uABE3-\\uABEA\\uABEC\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE2F/.source; // see note in above variable description\n/**\n * The string form of a regular expression that would match all of the\n * alphabetic (\"letter\") chars, emoji, and combining marks in the unicode character set\n * when placed in a RegExp character class (`[]`). This includes all\n * international alphabetic characters.\n *\n * These would be the characters matched by unicode regex engines `\\p{L}\\p{M}`\n * escapes and emoji characters.\n */\nexport var alphaCharsAndMarksStr = alphaCharsStr + emojiStr + marksStr;\n/**\n * The string form of a regular expression that would match all of the\n * decimal number chars in the unicode character set when placed in a RegExp\n * character class (`[]`).\n *\n * These would be the characters matched by unicode regex engines `\\p{Nd}`\n * escape (\"all decimal numbers\")\n *\n * Taken from the XRegExp library: http://xregexp.com/ (thanks @https://github.com/slevithan)\n * Specifically: http://xregexp.com/v/3.2.0/xregexp-all.js, the 'Decimal_Number'\n *   regex's bmp\n *\n * VERY IMPORTANT: This set of characters is defined inside of a Regular\n *   Expression literal rather than a string literal to prevent UglifyJS from\n *   compressing the unicode escape sequences into their actual unicode\n *   characters. If Uglify compresses these into the unicode characters\n *   themselves, this results in the error \"Range out of order in character\n *   class\" when these characters are used inside of a Regular Expression\n *   character class (`[]`). See usages of this const. Alternatively, we can set\n *   the UglifyJS option `ascii_only` to true for the build, but that doesn't\n *   help others who are pulling in Autolinker into their own build and running\n *   UglifyJS themselves.\n */\n// prettier-ignore\nexport var decimalNumbersStr = /0-9\\u0660-\\u0669\\u06F0-\\u06F9\\u07C0-\\u07C9\\u0966-\\u096F\\u09E6-\\u09EF\\u0A66-\\u0A6F\\u0AE6-\\u0AEF\\u0B66-\\u0B6F\\u0BE6-\\u0BEF\\u0C66-\\u0C6F\\u0CE6-\\u0CEF\\u0D66-\\u0D6F\\u0DE6-\\u0DEF\\u0E50-\\u0E59\\u0ED0-\\u0ED9\\u0F20-\\u0F29\\u1040-\\u1049\\u1090-\\u1099\\u17E0-\\u17E9\\u1810-\\u1819\\u1946-\\u194F\\u19D0-\\u19D9\\u1A80-\\u1A89\\u1A90-\\u1A99\\u1B50-\\u1B59\\u1BB0-\\u1BB9\\u1C40-\\u1C49\\u1C50-\\u1C59\\uA620-\\uA629\\uA8D0-\\uA8D9\\uA900-\\uA909\\uA9D0-\\uA9D9\\uA9F0-\\uA9F9\\uAA50-\\uAA59\\uABF0-\\uABF9\\uFF10-\\uFF19/.source; // see note in above variable description\n/**\n * The string form of a regular expression that would match all of the\n * letters and decimal number chars in the unicode character set when placed in\n * a RegExp character class (`[]`).\n *\n * These would be the characters matched by unicode regex engines\n * `[\\p{L}\\p{Nd}]` escape (\"all letters and decimal numbers\")\n */\nexport var alphaNumericCharsStr = alphaCharsAndMarksStr + decimalNumbersStr;\n/**\n * The string form of a regular expression that would match all of the\n * letters, combining marks, and decimal number chars in the unicode character\n * set when placed in a RegExp character class (`[]`).\n *\n * These would be the characters matched by unicode regex engines\n * `[\\p{L}\\p{M}\\p{Nd}]` escape (\"all letters, combining marks, and decimal\n * numbers\")\n */\nexport var alphaNumericAndMarksCharsStr = alphaCharsAndMarksStr + decimalNumbersStr;\n/**\n * The regular expression that will match a single letter of the\n * {@link #alphaNumericAndMarksCharsStr}.\n */\nexport var alphaNumericAndMarksCharRe = new RegExp(\"[\".concat(alphaNumericAndMarksCharsStr, \"]\"));\n// Simplified IP regular expression\nvar ipStr = '(?:[' + decimalNumbersStr + ']{1,3}\\\\.){3}[' + decimalNumbersStr + ']{1,3}';\n// Protected domain label which do not allow \"-\" or \"_\" character on the beginning and the end of a single label\n// prettier-ignore\nvar domainLabelStr = '[' + alphaNumericAndMarksCharsStr + '](?:[' + alphaNumericAndMarksCharsStr + '\\\\-_]{0,61}[' + alphaNumericAndMarksCharsStr + '])?';\nvar getDomainLabelStr = function (group) {\n  return '(?=(' + domainLabelStr + '))\\\\' + group;\n};\n/**\n * A function to match domain names of a URL or email address.\n * Ex: 'google', 'yahoo', 'some-other-company', etc.\n */\n// prettier-ignore\nexport var getDomainNameStr = function (group) {\n  return '(?:' + getDomainLabelStr(group) + '(?:\\\\.' + getDomainLabelStr(group + 1) + '){0,126}|' + ipStr + ')';\n};\n/**\n * A regular expression to match domain names of a URL or email address.\n * Ex: 'google', 'yahoo', 'some-other-company', etc.\n */\nexport var domainNameRegex = new RegExp('[' + alphaNumericAndMarksCharsStr + '.\\\\-]*[' + alphaNumericAndMarksCharsStr + '\\\\-]');\n/**\n * A regular expression that is simply the character class of the characters\n * that may be used in a domain name, minus the '-' or '.'\n */\nexport var domainNameCharRegex = alphaNumericAndMarksCharRe;","// NOTE: THIS IS A GENERATED FILE\n// To update with the latest TLD list, run `npm run update-tld-regex`\nexport var tldRegex = /(?:xn--vermgensberatung-pwb|xn--vermgensberater-ctb|xn--clchc0ea0b2g2a9gcd|xn--w4r85el8fhu5dnra|northwesternmutual|travelersinsurance|vermögensberatung|xn--5su34j936bgsg|xn--bck1b9a5dre4c|xn--mgbah1a3hjkrd|xn--mgbai9azgqp6j|xn--mgberp4a5d4ar|xn--xkc2dl3a5ee0h|vermögensberater|xn--fzys8d69uvgm|xn--mgba7c0bbn0a|xn--mgbcpq6gpa1a|xn--xkc2al3hye2a|americanexpress|kerryproperties|sandvikcoromant|xn--i1b6b1a6a2e|xn--kcrx77d1x4a|xn--lgbbat1ad8j|xn--mgba3a4f16a|xn--mgbaakc7dvf|xn--mgbc0a9azcg|xn--nqv7fs00ema|americanfamily|bananarepublic|cancerresearch|cookingchannel|kerrylogistics|weatherchannel|xn--54b7fta0cc|xn--6qq986b3xl|xn--80aqecdr1a|xn--b4w605ferd|xn--fiq228c5hs|xn--h2breg3eve|xn--jlq480n2rg|xn--jlq61u9w7b|xn--mgba3a3ejt|xn--mgbaam7a8h|xn--mgbayh7gpa|xn--mgbbh1a71e|xn--mgbca7dzdo|xn--mgbi4ecexp|xn--mgbx4cd0ab|xn--rvc1e0am3e|international|lifeinsurance|travelchannel|wolterskluwer|xn--cckwcxetd|xn--eckvdtc9d|xn--fpcrj9c3d|xn--fzc2c9e2c|xn--h2brj9c8c|xn--tiq49xqyj|xn--yfro4i67o|xn--ygbi2ammx|construction|lplfinancial|scholarships|versicherung|xn--3e0b707e|xn--45br5cyl|xn--4dbrk0ce|xn--80adxhks|xn--80asehdb|xn--8y0a063a|xn--gckr3f0f|xn--mgb9awbf|xn--mgbab2bd|xn--mgbgu82a|xn--mgbpl2fh|xn--mgbt3dhd|xn--mk1bu44c|xn--ngbc5azd|xn--ngbe9e0a|xn--ogbpf8fl|xn--qcka1pmc|accountants|barclaycard|blackfriday|blockbuster|bridgestone|calvinklein|contractors|creditunion|engineering|enterprises|foodnetwork|investments|kerryhotels|lamborghini|motorcycles|olayangroup|photography|playstation|productions|progressive|redumbrella|williamhill|xn--11b4c3d|xn--1ck2e1b|xn--1qqw23a|xn--2scrj9c|xn--3bst00m|xn--3ds443g|xn--3hcrj9c|xn--42c2d9a|xn--45brj9c|xn--55qw42g|xn--6frz82g|xn--80ao21a|xn--9krt00a|xn--cck2b3b|xn--czr694b|xn--d1acj3b|xn--efvy88h|xn--fct429k|xn--fjq720a|xn--flw351e|xn--g2xx48c|xn--gecrj9c|xn--gk3at1e|xn--h2brj9c|xn--hxt814e|xn--imr513n|xn--j6w193g|xn--jvr189m|xn--kprw13d|xn--kpry57d|xn--mgbbh1a|xn--mgbtx2b|xn--mix891f|xn--nyqy26a|xn--otu796d|xn--pgbs0dh|xn--q9jyb4c|xn--rhqv96g|xn--rovu88b|xn--s9brj9c|xn--ses554g|xn--t60b56a|xn--vuq861b|xn--w4rs40l|xn--xhq521b|xn--zfr164b|சிங்கப்பூர்|accountant|apartments|associates|basketball|bnpparibas|boehringer|capitalone|consulting|creditcard|cuisinella|eurovision|extraspace|foundation|healthcare|immobilien|industries|management|mitsubishi|nextdirect|properties|protection|prudential|realestate|republican|restaurant|schaeffler|tatamotors|technology|university|vlaanderen|volkswagen|xn--30rr7y|xn--3pxu8k|xn--45q11c|xn--4gbrim|xn--55qx5d|xn--5tzm5g|xn--80aswg|xn--90a3ac|xn--9dbq2a|xn--9et52u|xn--c2br7g|xn--cg4bki|xn--czrs0t|xn--czru2d|xn--fiq64b|xn--fiqs8s|xn--fiqz9s|xn--io0a7i|xn--kput3i|xn--mxtq1m|xn--o3cw4h|xn--pssy2u|xn--q7ce6a|xn--unup4y|xn--wgbh1c|xn--wgbl6a|xn--y9a3aq|accenture|alfaromeo|allfinanz|amsterdam|analytics|aquarelle|barcelona|bloomberg|christmas|community|directory|education|equipment|fairwinds|financial|firestone|fresenius|frontdoor|furniture|goldpoint|hisamitsu|homedepot|homegoods|homesense|institute|insurance|kuokgroup|lancaster|landrover|lifestyle|marketing|marshalls|melbourne|microsoft|panasonic|passagens|pramerica|richardli|shangrila|solutions|statebank|statefarm|stockholm|travelers|vacations|xn--90ais|xn--c1avg|xn--d1alf|xn--e1a4c|xn--fhbei|xn--j1aef|xn--j1amh|xn--l1acc|xn--ngbrx|xn--nqv7f|xn--p1acf|xn--qxa6a|xn--tckwe|xn--vhquv|yodobashi|موريتانيا|abudhabi|airforce|allstate|attorney|barclays|barefoot|bargains|baseball|boutique|bradesco|broadway|brussels|builders|business|capetown|catering|catholic|cipriani|cityeats|cleaning|clinique|clothing|commbank|computer|delivery|deloitte|democrat|diamonds|discount|discover|download|engineer|ericsson|etisalat|exchange|feedback|fidelity|firmdale|football|frontier|goodyear|grainger|graphics|guardian|hdfcbank|helsinki|holdings|hospital|infiniti|ipiranga|istanbul|jpmorgan|lighting|lundbeck|marriott|maserati|mckinsey|memorial|merckmsd|mortgage|observer|partners|pharmacy|pictures|plumbing|property|redstone|reliance|saarland|samsclub|security|services|shopping|showtime|softbank|software|stcgroup|supplies|training|vanguard|ventures|verisign|woodside|xn--90ae|xn--node|xn--p1ai|xn--qxam|yokohama|السعودية|abogado|academy|agakhan|alibaba|android|athleta|auction|audible|auspost|avianca|banamex|bauhaus|bentley|bestbuy|booking|brother|bugatti|capital|caravan|careers|channel|charity|chintai|citadel|clubmed|college|cologne|comcast|company|compare|contact|cooking|corsica|country|coupons|courses|cricket|cruises|dentist|digital|domains|exposed|express|farmers|fashion|ferrari|ferrero|finance|fishing|fitness|flights|florist|flowers|forsale|frogans|fujitsu|gallery|genting|godaddy|grocery|guitars|hamburg|hangout|hitachi|holiday|hosting|hoteles|hotmail|hyundai|ismaili|jewelry|juniper|kitchen|komatsu|lacaixa|lanxess|lasalle|latrobe|leclerc|limited|lincoln|markets|monster|netbank|netflix|network|neustar|okinawa|oldnavy|organic|origins|philips|pioneer|politie|realtor|recipes|rentals|reviews|rexroth|samsung|sandvik|schmidt|schwarz|science|shiksha|singles|staples|storage|support|surgery|systems|temasek|theater|theatre|tickets|tiffany|toshiba|trading|walmart|wanggou|watches|weather|website|wedding|whoswho|windows|winners|xfinity|yamaxun|youtube|zuerich|католик|اتصالات|البحرين|الجزائر|العليان|پاکستان|كاثوليك|இந்தியா|abarth|abbott|abbvie|africa|agency|airbus|airtel|alipay|alsace|alstom|amazon|anquan|aramco|author|bayern|beauty|berlin|bharti|bostik|boston|broker|camera|career|casino|center|chanel|chrome|church|circle|claims|clinic|coffee|comsec|condos|coupon|credit|cruise|dating|datsun|dealer|degree|dental|design|direct|doctor|dunlop|dupont|durban|emerck|energy|estate|events|expert|family|flickr|futbol|gallup|garden|george|giving|global|google|gratis|health|hermes|hiphop|hockey|hotels|hughes|imamat|insure|intuit|jaguar|joburg|juegos|kaufen|kinder|kindle|kosher|lancia|latino|lawyer|lefrak|living|locker|london|luxury|madrid|maison|makeup|market|mattel|mobile|monash|mormon|moscow|museum|mutual|nagoya|natura|nissan|nissay|norton|nowruz|office|olayan|online|oracle|orange|otsuka|pfizer|photos|physio|pictet|quebec|racing|realty|reisen|repair|report|review|rocher|rogers|ryukyu|safety|sakura|sanofi|school|schule|search|secure|select|shouji|soccer|social|stream|studio|supply|suzuki|swatch|sydney|taipei|taobao|target|tattoo|tennis|tienda|tjmaxx|tkmaxx|toyota|travel|unicom|viajes|viking|villas|virgin|vision|voting|voyage|vuelos|walter|webcam|xihuan|yachts|yandex|zappos|москва|онлайн|ابوظبي|ارامكو|الاردن|المغرب|امارات|فلسطين|مليسيا|भारतम्|இலங்கை|ファッション|actor|adult|aetna|amfam|amica|apple|archi|audio|autos|azure|baidu|beats|bible|bingo|black|boats|bosch|build|canon|cards|chase|cheap|cisco|citic|click|cloud|coach|codes|crown|cymru|dabur|dance|deals|delta|drive|dubai|earth|edeka|email|epson|faith|fedex|final|forex|forum|gallo|games|gifts|gives|glass|globo|gmail|green|gripe|group|gucci|guide|homes|honda|horse|house|hyatt|ikano|irish|jetzt|koeln|kyoto|lamer|lease|legal|lexus|lilly|linde|lipsy|loans|locus|lotte|lotto|macys|mango|media|miami|money|movie|music|nexus|nikon|ninja|nokia|nowtv|omega|osaka|paris|parts|party|phone|photo|pizza|place|poker|praxi|press|prime|promo|quest|radio|rehab|reise|ricoh|rocks|rodeo|rugby|salon|sener|seven|sharp|shell|shoes|skype|sling|smart|smile|solar|space|sport|stada|store|study|style|sucks|swiss|tatar|tires|tirol|tmall|today|tokyo|tools|toray|total|tours|trade|trust|tunes|tushu|ubank|vegas|video|vodka|volvo|wales|watch|weber|weibo|works|world|xerox|yahoo|ישראל|ایران|بازار|بھارت|سودان|سورية|همراه|भारोत|संगठन|বাংলা|భారత్|ഭാരതം|嘉里大酒店|aarp|able|adac|aero|akdn|ally|amex|arab|army|arpa|arte|asda|asia|audi|auto|baby|band|bank|bbva|beer|best|bike|bing|blog|blue|bofa|bond|book|buzz|cafe|call|camp|care|cars|casa|case|cash|cbre|cern|chat|citi|city|club|cool|coop|cyou|data|date|dclk|deal|dell|desi|diet|dish|docs|dvag|erni|fage|fail|fans|farm|fast|fiat|fido|film|fire|fish|flir|food|ford|free|fund|game|gbiz|gent|ggee|gift|gmbh|gold|golf|goog|guge|guru|hair|haus|hdfc|help|here|hgtv|host|hsbc|icbc|ieee|imdb|immo|info|itau|java|jeep|jobs|jprs|kddi|kids|kiwi|kpmg|kred|land|lego|lgbt|lidl|life|like|limo|link|live|loan|loft|love|ltda|luxe|maif|meet|meme|menu|mini|mint|mobi|moda|moto|name|navy|news|next|nico|nike|ollo|open|page|pars|pccw|pics|ping|pink|play|plus|pohl|porn|post|prod|prof|qpon|read|reit|rent|rest|rich|room|rsvp|ruhr|safe|sale|sarl|save|saxo|scot|seat|seek|sexy|shaw|shia|shop|show|silk|sina|site|skin|sncf|sohu|song|sony|spot|star|surf|talk|taxi|team|tech|teva|tiaa|tips|town|toys|tube|vana|visa|viva|vivo|vote|voto|wang|weir|wien|wiki|wine|work|xbox|yoga|zara|zero|zone|дети|сайт|بارت|بيتك|ڀارت|تونس|شبكة|عراق|عمان|موقع|भारत|ভারত|ভাৰত|ਭਾਰਤ|ભારત|ଭାରତ|ಭಾರತ|ලංකා|アマゾン|グーグル|クラウド|ポイント|组织机构|電訊盈科|香格里拉|aaa|abb|abc|aco|ads|aeg|afl|aig|anz|aol|app|art|aws|axa|bar|bbc|bbt|bcg|bcn|bet|bid|bio|biz|bms|bmw|bom|boo|bot|box|buy|bzh|cab|cal|cam|car|cat|cba|cbn|cbs|ceo|cfa|cfd|com|cpa|crs|dad|day|dds|dev|dhl|diy|dnp|dog|dot|dtv|dvr|eat|eco|edu|esq|eus|fan|fit|fly|foo|fox|frl|ftr|fun|fyi|gal|gap|gay|gdn|gea|gle|gmo|gmx|goo|gop|got|gov|hbo|hiv|hkt|hot|how|ibm|ice|icu|ifm|inc|ing|ink|int|ist|itv|jcb|jio|jll|jmp|jnj|jot|joy|kfh|kia|kim|kpn|krd|lat|law|lds|llc|llp|lol|lpl|ltd|man|map|mba|med|men|mil|mit|mlb|mls|mma|moe|moi|mom|mov|msd|mtn|mtr|nab|nba|nec|net|new|nfl|ngo|nhk|now|nra|nrw|ntt|nyc|obi|one|ong|onl|ooo|org|ott|ovh|pay|pet|phd|pid|pin|pnc|pro|pru|pub|pwc|red|ren|ril|rio|rip|run|rwe|sap|sas|sbi|sbs|sca|scb|ses|sew|sex|sfr|ski|sky|soy|spa|srl|stc|tab|tax|tci|tdk|tel|thd|tjx|top|trv|tui|tvs|ubs|uno|uol|ups|vet|vig|vin|vip|wed|win|wme|wow|wtc|wtf|xin|xxx|xyz|you|yun|zip|бел|ком|қаз|мкд|мон|орг|рус|срб|укр|հայ|קום|عرب|قطر|كوم|مصر|कॉम|नेट|คอม|ไทย|ລາວ|ストア|セール|みんな|中文网|亚马逊|天主教|我爱你|新加坡|淡马锡|诺基亚|飞利浦|ac|ad|ae|af|ag|ai|al|am|ao|aq|ar|as|at|au|aw|ax|az|ba|bb|bd|be|bf|bg|bh|bi|bj|bm|bn|bo|br|bs|bt|bv|bw|by|bz|ca|cc|cd|cf|cg|ch|ci|ck|cl|cm|cn|co|cr|cu|cv|cw|cx|cy|cz|de|dj|dk|dm|do|dz|ec|ee|eg|er|es|et|eu|fi|fj|fk|fm|fo|fr|ga|gb|gd|ge|gf|gg|gh|gi|gl|gm|gn|gp|gq|gr|gs|gt|gu|gw|gy|hk|hm|hn|hr|ht|hu|id|ie|il|im|in|io|iq|ir|is|it|je|jm|jo|jp|ke|kg|kh|ki|km|kn|kp|kr|kw|ky|kz|la|lb|lc|li|lk|lr|ls|lt|lu|lv|ly|ma|mc|md|me|mg|mh|mk|ml|mm|mn|mo|mp|mq|mr|ms|mt|mu|mv|mw|mx|my|mz|na|nc|ne|nf|ng|ni|nl|no|np|nr|nu|nz|om|pa|pe|pf|pg|ph|pk|pl|pm|pn|pr|ps|pt|pw|py|qa|re|ro|rs|ru|rw|sa|sb|sc|sd|se|sg|sh|si|sj|sk|sl|sm|sn|so|sr|ss|st|su|sv|sx|sy|sz|tc|td|tf|tg|th|tj|tk|tl|tm|tn|to|tr|tt|tv|tw|tz|ua|ug|uk|us|uy|uz|va|vc|ve|vg|vi|vn|vu|wf|ws|ye|yt|za|zm|zw|ελ|ευ|бг|ею|рф|გე|닷넷|닷컴|삼성|한국|コム|世界|中信|中国|中國|企业|佛山|信息|健康|八卦|公司|公益|台湾|台灣|商城|商店|商标|嘉里|在线|大拿|娱乐|家電|广东|微博|慈善|手机|招聘|政务|政府|新闻|时尚|書籍|机构|游戏|澳門|点看|移动|网址|网店|网站|网络|联通|谷歌|购物|通販|集团|食品|餐厅|香港)/;","import { __assign, __extends } from \"tslib\";\nimport { Matcher } from './matcher';\nimport { alphaNumericAndMarksCharsStr, domainNameCharRegex } from '../regex-lib';\nimport { EmailMatch } from '../match/email-match';\nimport { throwUnhandledCaseError } from '../utils';\nimport { tldRegex } from './tld-regex';\n// For debugging: search for other \"For debugging\" lines\n// import CliTable from 'cli-table';\n// RegExp objects which are shared by all instances of EmailMatcher. These are\n// here to avoid re-instantiating the RegExp objects if `Autolinker.link()` is\n// called multiple times, thus instantiating EmailMatcher and its RegExp\n// objects each time (which is very expensive - see https://github.com/gregjacobs/Autolinker.js/issues/314).\n// See descriptions of the properties where they are used for details about them\nvar localPartCharRegex = new RegExp(\"[\".concat(alphaNumericAndMarksCharsStr, \"!#$%&'*+/=?^_`{|}~-]\"));\nvar strictTldRegex = new RegExp(\"^\".concat(tldRegex.source, \"$\"));\n/**\n * @class Autolinker.matcher.Email\n * @extends Autolinker.matcher.Matcher\n *\n * Matcher to find email matches in an input string.\n *\n * See this class's superclass ({@link Autolinker.matcher.Matcher}) for more details.\n */\nvar EmailMatcher = /** @class */function (_super) {\n  __extends(EmailMatcher, _super);\n  function EmailMatcher() {\n    var _this = _super !== null && _super.apply(this, arguments) || this;\n    /**\n     * Valid characters that can be used in the \"local\" part of an email address,\n     * i.e. the \"name\" part of \"name@site.com\"\n     */\n    _this.localPartCharRegex = localPartCharRegex;\n    /**\n     * Stricter TLD regex which adds a beginning and end check to ensure\n     * the string is a valid TLD\n     */\n    _this.strictTldRegex = strictTldRegex;\n    return _this;\n  }\n  /**\n   * @inheritdoc\n   */\n  EmailMatcher.prototype.parseMatches = function (text) {\n    var tagBuilder = this.tagBuilder,\n      localPartCharRegex = this.localPartCharRegex,\n      strictTldRegex = this.strictTldRegex,\n      matches = [],\n      len = text.length,\n      noCurrentEmailMatch = new CurrentEmailMatch();\n    // for matching a 'mailto:' prefix\n    var mailtoTransitions = {\n      m: 'a',\n      a: 'i',\n      i: 'l',\n      l: 't',\n      t: 'o',\n      o: ':'\n    };\n    var charIdx = 0,\n      state = 0 /* NonEmailMatch */,\n      currentEmailMatch = noCurrentEmailMatch;\n    // For debugging: search for other \"For debugging\" lines\n    // const table = new CliTable( {\n    // \thead: [ 'charIdx', 'char', 'state', 'charIdx', 'currentEmailAddress.idx', 'hasDomainDot' ]\n    // } );\n    while (charIdx < len) {\n      var char = text.charAt(charIdx);\n      // For debugging: search for other \"For debugging\" lines\n      // table.push(\n      // \t[ charIdx, char, State[ state ], charIdx, currentEmailAddress.idx, currentEmailAddress.hasDomainDot ]\n      // );\n      switch (state) {\n        case 0 /* NonEmailMatch */:\n          stateNonEmailAddress(char);\n          break;\n        case 1 /* Mailto */:\n          stateMailTo(text.charAt(charIdx - 1), char);\n          break;\n        case 2 /* LocalPart */:\n          stateLocalPart(char);\n          break;\n        case 3 /* LocalPartDot */:\n          stateLocalPartDot(char);\n          break;\n        case 4 /* AtSign */:\n          stateAtSign(char);\n          break;\n        case 5 /* DomainChar */:\n          stateDomainChar(char);\n          break;\n        case 6 /* DomainHyphen */:\n          stateDomainHyphen(char);\n          break;\n        case 7 /* DomainDot */:\n          stateDomainDot(char);\n          break;\n        default:\n          throwUnhandledCaseError(state);\n      }\n      // For debugging: search for other \"For debugging\" lines\n      // table.push(\n      // \t[ charIdx, char, State[ state ], charIdx, currentEmailAddress.idx, currentEmailAddress.hasDomainDot ]\n      // );\n      charIdx++;\n    }\n    // Capture any valid match at the end of the string\n    captureMatchIfValidAndReset();\n    // For debugging: search for other \"For debugging\" lines\n    //console.log( '\\n' + table.toString() );\n    return matches;\n    // Handles the state when we're not in an email address\n    function stateNonEmailAddress(char) {\n      if (char === 'm') {\n        beginEmailMatch(1 /* Mailto */);\n      } else if (localPartCharRegex.test(char)) {\n        beginEmailMatch();\n      } else {\n        // not an email address character, continue\n      }\n    }\n    // Handles if we're reading a 'mailto:' prefix on the string\n    function stateMailTo(prevChar, char) {\n      if (prevChar === ':') {\n        // We've reached the end of the 'mailto:' prefix\n        if (localPartCharRegex.test(char)) {\n          state = 2 /* LocalPart */;\n          currentEmailMatch = new CurrentEmailMatch(__assign(__assign({}, currentEmailMatch), {\n            hasMailtoPrefix: true\n          }));\n        } else {\n          // we've matched 'mailto:' but didn't get anything meaningful\n          // immediately afterwards (for example, we encountered a\n          // space character, or an '@' character which formed 'mailto:@'\n          resetToNonEmailMatchState();\n        }\n      } else if (mailtoTransitions[prevChar] === char) {\n        // We're currently reading the 'mailto:' prefix, stay in\n        // Mailto state\n      } else if (localPartCharRegex.test(char)) {\n        // We we're reading a prefix of 'mailto:', but encountered a\n        // different character that didn't continue the prefix\n        state = 2 /* LocalPart */;\n      } else if (char === '.') {\n        // We we're reading a prefix of 'mailto:', but encountered a\n        // dot character\n        state = 3 /* LocalPartDot */;\n      } else if (char === '@') {\n        // We we're reading a prefix of 'mailto:', but encountered a\n        // an @ character\n        state = 4 /* AtSign */;\n      } else {\n        // not an email address character, return to \"NonEmailAddress\" state\n        resetToNonEmailMatchState();\n      }\n    }\n    // Handles the state when we're currently in the \"local part\" of an\n    // email address (as opposed to the \"domain part\")\n    function stateLocalPart(char) {\n      if (char === '.') {\n        state = 3 /* LocalPartDot */;\n      } else if (char === '@') {\n        state = 4 /* AtSign */;\n      } else if (localPartCharRegex.test(char)) {\n        // stay in the \"local part\" of the email address\n      } else {\n        // not an email address character, return to \"NonEmailAddress\" state\n        resetToNonEmailMatchState();\n      }\n    }\n    // Handles the state where we've read\n    function stateLocalPartDot(char) {\n      if (char === '.') {\n        // We read a second '.' in a row, not a valid email address\n        // local part\n        resetToNonEmailMatchState();\n      } else if (char === '@') {\n        // We read the '@' character immediately after a dot ('.'), not\n        // an email address\n        resetToNonEmailMatchState();\n      } else if (localPartCharRegex.test(char)) {\n        state = 2 /* LocalPart */;\n      } else {\n        // Anything else, not an email address\n        resetToNonEmailMatchState();\n      }\n    }\n    function stateAtSign(char) {\n      if (domainNameCharRegex.test(char)) {\n        state = 5 /* DomainChar */;\n      } else {\n        // Anything else, not an email address\n        resetToNonEmailMatchState();\n      }\n    }\n    function stateDomainChar(char) {\n      if (char === '.') {\n        state = 7 /* DomainDot */;\n      } else if (char === '-') {\n        state = 6 /* DomainHyphen */;\n      } else if (domainNameCharRegex.test(char)) {\n        // Stay in the DomainChar state\n      } else {\n        // Anything else, we potentially matched if the criteria has\n        // been met\n        captureMatchIfValidAndReset();\n      }\n    }\n    function stateDomainHyphen(char) {\n      if (char === '-' || char === '.') {\n        // Not valid to have two hyphens (\"--\") or hypen+dot (\"-.\")\n        captureMatchIfValidAndReset();\n      } else if (domainNameCharRegex.test(char)) {\n        state = 5 /* DomainChar */;\n      } else {\n        // Anything else\n        captureMatchIfValidAndReset();\n      }\n    }\n    function stateDomainDot(char) {\n      if (char === '.' || char === '-') {\n        // not valid to have two dots (\"..\") or dot+hypen (\".-\")\n        captureMatchIfValidAndReset();\n      } else if (domainNameCharRegex.test(char)) {\n        state = 5 /* DomainChar */;\n        // After having read a '.' and then a valid domain character,\n        // we now know that the domain part of the email is valid, and\n        // we have found at least a partial EmailMatch (however, the\n        // email address may have additional characters from this point)\n        currentEmailMatch = new CurrentEmailMatch(__assign(__assign({}, currentEmailMatch), {\n          hasDomainDot: true\n        }));\n      } else {\n        // Anything else\n        captureMatchIfValidAndReset();\n      }\n    }\n    function beginEmailMatch(newState) {\n      if (newState === void 0) {\n        newState = 2 /* LocalPart */;\n      }\n      state = newState;\n      currentEmailMatch = new CurrentEmailMatch({\n        idx: charIdx\n      });\n    }\n    function resetToNonEmailMatchState() {\n      state = 0 /* NonEmailMatch */;\n      currentEmailMatch = noCurrentEmailMatch;\n    }\n    /*\n     * Captures the current email address as an EmailMatch if it's valid,\n     * and resets the state to read another email address.\n     */\n    function captureMatchIfValidAndReset() {\n      if (currentEmailMatch.hasDomainDot) {\n        // we need at least one dot in the domain to be considered a valid email address\n        var matchedText = text.slice(currentEmailMatch.idx, charIdx);\n        // If we read a '.' or '-' char that ended the email address\n        // (valid domain name characters, but only valid email address\n        // characters if they are followed by something else), strip\n        // it off now\n        if (/[-.]$/.test(matchedText)) {\n          matchedText = matchedText.slice(0, -1);\n        }\n        var emailAddress = currentEmailMatch.hasMailtoPrefix ? matchedText.slice('mailto:'.length) : matchedText;\n        // if the email address has a valid TLD, add it to the list of matches\n        if (doesEmailHaveValidTld(emailAddress)) {\n          matches.push(new EmailMatch({\n            tagBuilder: tagBuilder,\n            matchedText: matchedText,\n            offset: currentEmailMatch.idx,\n            email: emailAddress\n          }));\n        }\n      }\n      resetToNonEmailMatchState();\n      /**\n       * Determines if the given email address has a valid TLD or not\n       * @param {string} emailAddress - email address\n       * @return {Boolean} - true is email have valid TLD, false otherwise\n       */\n      function doesEmailHaveValidTld(emailAddress) {\n        var emailAddressTld = emailAddress.split('.').pop() || '';\n        var emailAddressNormalized = emailAddressTld.toLowerCase();\n        var isValidTld = strictTldRegex.test(emailAddressNormalized);\n        return isValidTld;\n      }\n    }\n  };\n  return EmailMatcher;\n}(Matcher);\nexport { EmailMatcher };\nvar CurrentEmailMatch = /** @class */function () {\n  function CurrentEmailMatch(cfg) {\n    if (cfg === void 0) {\n      cfg = {};\n    }\n    this.idx = cfg.idx !== undefined ? cfg.idx : -1;\n    this.hasMailtoPrefix = !!cfg.hasMailtoPrefix;\n    this.hasDomainDot = !!cfg.hasDomainDot;\n  }\n  return CurrentEmailMatch;\n}();","import { alphaCharsStr } from '../regex-lib';\n/**\n * @private\n * @class Autolinker.matcher.UrlMatchValidator\n * @singleton\n *\n * Used by Autolinker to filter out false URL positives from the\n * {@link Autolinker.matcher.Url UrlMatcher}.\n *\n * Due to the limitations of regular expressions (including the missing feature\n * of look-behinds in JS regular expressions), we cannot always determine the\n * validity of a given match. This class applies a bit of additional logic to\n * filter out any false positives that have been matched by the\n * {@link Autolinker.matcher.Url UrlMatcher}.\n */\nvar UrlMatchValidator = /** @class */function () {\n  function UrlMatchValidator() {}\n  /**\n   * Determines if a given URL match found by the {@link Autolinker.matcher.Url UrlMatcher}\n   * is valid. Will return `false` for:\n   *\n   * 1) URL matches which do not have at least have one period ('.') in the\n   *    domain name (effectively skipping over matches like \"abc:def\").\n   *    However, URL matches with a protocol will be allowed (ex: 'http://localhost')\n   * 2) URL matches which do not have at least one word character in the\n   *    domain name (effectively skipping over matches like \"git:1.0\").\n   *    However, URL matches with a protocol will be allowed (ex: 'intra-net://271219.76')\n   * 3) A protocol-relative url match (a URL beginning with '//') whose\n   *    previous character is a word character (effectively skipping over\n   *    strings like \"abc//google.com\")\n   *\n   * Otherwise, returns `true`.\n   *\n   * @param {String} urlMatch The matched URL, if there was one. Will be an\n   *   empty string if the match is not a URL match.\n   * @param {String} protocolUrlMatch The match URL string for a protocol\n   *   match. Ex: 'http://yahoo.com'. This is used to match something like\n   *   'http://localhost', where we won't double check that the domain name\n   *   has at least one '.' in it.\n   * @return {Boolean} `true` if the match given is valid and should be\n   *   processed, or `false` if the match is invalid and/or should just not be\n   *   processed.\n   */\n  UrlMatchValidator.isValid = function (urlMatch, protocolUrlMatch) {\n    if (protocolUrlMatch && !this.isValidUriScheme(protocolUrlMatch) || this.urlMatchDoesNotHaveProtocolOrDot(urlMatch, protocolUrlMatch) ||\n    // At least one period ('.') must exist in the URL match for us to consider it an actual URL, *unless* it was a full protocol match (like 'http://localhost')\n    this.urlMatchDoesNotHaveAtLeastOneWordChar(urlMatch, protocolUrlMatch) &&\n    // At least one letter character must exist in the domain name after a protocol match. Ex: skip over something like \"git:1.0\"\n    !this.isValidIpAddress(urlMatch) ||\n    // Except if it's an IP address\n    this.containsMultipleDots(urlMatch)) {\n      return false;\n    }\n    return true;\n  };\n  UrlMatchValidator.isValidIpAddress = function (uriSchemeMatch) {\n    var newRegex = new RegExp(this.hasFullProtocolRegex.source + this.ipRegex.source);\n    var uriScheme = uriSchemeMatch.match(newRegex);\n    return uriScheme !== null;\n  };\n  UrlMatchValidator.containsMultipleDots = function (urlMatch) {\n    var stringBeforeSlash = urlMatch;\n    if (this.hasFullProtocolRegex.test(urlMatch)) {\n      stringBeforeSlash = urlMatch.split('://')[1];\n    }\n    return stringBeforeSlash.split('/')[0].indexOf('..') > -1;\n  };\n  /**\n   * Determines if the URI scheme is a valid scheme to be autolinked. Returns\n   * `false` if the scheme is 'javascript:' or 'vbscript:'\n   *\n   * @private\n   * @param {String} uriSchemeMatch The match URL string for a full URI scheme\n   *   match. Ex: 'http://yahoo.com' or 'mailto:a@a.com'.\n   * @return {Boolean} `true` if the scheme is a valid one, `false` otherwise.\n   */\n  UrlMatchValidator.isValidUriScheme = function (uriSchemeMatch) {\n    var uriSchemeMatchArr = uriSchemeMatch.match(this.uriSchemeRegex),\n      uriScheme = uriSchemeMatchArr && uriSchemeMatchArr[0].toLowerCase();\n    return uriScheme !== 'javascript:' && uriScheme !== 'vbscript:';\n  };\n  /**\n   * Determines if a URL match does not have either:\n   *\n   * a) a full protocol (i.e. 'http://'), or\n   * b) at least one dot ('.') in the domain name (for a non-full-protocol\n   *    match).\n   *\n   * Either situation is considered an invalid URL (ex: 'git:d' does not have\n   * either the '://' part, or at least one dot in the domain name. If the\n   * match was 'git:abc.com', we would consider this valid.)\n   *\n   * @private\n   * @param {String} urlMatch The matched URL, if there was one. Will be an\n   *   empty string if the match is not a URL match.\n   * @param {String} protocolUrlMatch The match URL string for a protocol\n   *   match. Ex: 'http://yahoo.com'. This is used to match something like\n   *   'http://localhost', where we won't double check that the domain name\n   *   has at least one '.' in it.\n   * @return {Boolean} `true` if the URL match does not have a full protocol,\n   *   or at least one dot ('.') in a non-full-protocol match.\n   */\n  UrlMatchValidator.urlMatchDoesNotHaveProtocolOrDot = function (urlMatch, protocolUrlMatch) {\n    return !!urlMatch && (!protocolUrlMatch || !this.hasFullProtocolRegex.test(protocolUrlMatch)) && urlMatch.indexOf('.') === -1;\n  };\n  /**\n   * Determines if a URL match does not have either:\n   *\n   * a) a full protocol (i.e. 'http://'), or\n   * b) at least one word character after the protocol (i.e. in the domain name)\n   *\n   * At least one letter character must exist in the domain name after a\n   * protocol match. Ex: skip over something like \"git:1.0\"\n   *\n   * @private\n   * @param {String} urlMatch The matched URL, if there was one. Will be an\n   *   empty string if the match is not a URL match.\n   * @param {String} protocolUrlMatch The match URL string for a protocol\n   *   match. Ex: 'http://yahoo.com'. This is used to know whether or not we\n   *   have a protocol in the URL string, in order to check for a word\n   *   character after the protocol separator (':').\n   * @return {Boolean} `true` if the URL match does not have a full protocol, or\n   * at least one word character in it, `false` otherwise.\n   */\n  UrlMatchValidator.urlMatchDoesNotHaveAtLeastOneWordChar = function (urlMatch, protocolUrlMatch) {\n    if (urlMatch && protocolUrlMatch) {\n      return !this.hasFullProtocolRegex.test(protocolUrlMatch) && !this.hasWordCharAfterProtocolRegex.test(urlMatch);\n    } else {\n      return false;\n    }\n  };\n  /**\n   * Regex to test for a full protocol, with the two trailing slashes. Ex: 'http://'\n   *\n   * @private\n   * @property {RegExp} hasFullProtocolRegex\n   */\n  UrlMatchValidator.hasFullProtocolRegex = /^[A-Za-z][-.+A-Za-z0-9]*:\\/\\//;\n  /**\n   * Regex to find the URI scheme, such as 'mailto:'.\n   *\n   * This is used to filter out 'javascript:' and 'vbscript:' schemes.\n   *\n   * @private\n   * @property {RegExp} uriSchemeRegex\n   */\n  UrlMatchValidator.uriSchemeRegex = /^[A-Za-z][-.+A-Za-z0-9]*:/;\n  /**\n   * Regex to determine if at least one word char exists after the protocol (i.e. after the ':')\n   *\n   * @private\n   * @property {RegExp} hasWordCharAfterProtocolRegex\n   */\n  UrlMatchValidator.hasWordCharAfterProtocolRegex = new RegExp(':[^\\\\s]*?[' + alphaCharsStr + ']');\n  /**\n   * Regex to determine if the string is a valid IP address\n   *\n   * @private\n   * @property {RegExp} ipRegex\n   */\n  UrlMatchValidator.ipRegex = /[0-9][0-9]?[0-9]?\\.[0-9][0-9]?[0-9]?\\.[0-9][0-9]?[0-9]?\\.[0-9][0-9]?[0-9]?(:[0-9]*)?\\/?$/;\n  return UrlMatchValidator;\n}();\nexport { UrlMatchValidator };","import { __extends } from \"tslib\";\nimport { Matcher } from './matcher';\nimport { alphaNumericAndMarksCharRe, alphaNumericAndMarksCharsStr } from '../regex-lib';\nimport { HashtagMatch } from '../match/hashtag-match';\nimport { throwUnhandledCaseError } from '../utils';\n// For debugging: search for other \"For debugging\" lines\n// import CliTable from 'cli-table';\nvar hashtagTextCharRe = new RegExp(\"[_\".concat(alphaNumericAndMarksCharsStr, \"]\"));\n/**\n * @class Autolinker.matcher.Hashtag\n * @extends Autolinker.matcher.Matcher\n *\n * Matcher to find HashtagMatch matches in an input string.\n */\nvar HashtagMatcher = /** @class */function (_super) {\n  __extends(HashtagMatcher, _super);\n  /**\n   * @method constructor\n   * @param {Object} cfg The configuration properties for the Match instance,\n   *   specified in an Object (map).\n   */\n  function HashtagMatcher(cfg) {\n    var _this = _super.call(this, cfg) || this;\n    /**\n     * @cfg {String} service\n     *\n     * A string for the service name to have hashtags (ex: \"#myHashtag\")\n     * auto-linked to. The currently-supported values are:\n     *\n     * - 'twitter'\n     * - 'facebook'\n     * - 'instagram'\n     * - 'tiktok'\n     */\n    _this.serviceName = 'twitter'; // default value just to get the above doc comment in the ES5 output and documentation generator\n    _this.serviceName = cfg.serviceName;\n    return _this;\n  }\n  /**\n   * @inheritdoc\n   */\n  HashtagMatcher.prototype.parseMatches = function (text) {\n    var tagBuilder = this.tagBuilder;\n    var serviceName = this.serviceName;\n    var matches = [];\n    var len = text.length;\n    var charIdx = 0,\n      hashCharIdx = -1,\n      state = 0 /* None */;\n    // For debugging: search for other \"For debugging\" lines\n    // const table = new CliTable( {\n    // \thead: [ 'charIdx', 'char', 'state', 'charIdx', 'currentEmailAddress.idx', 'hasDomainDot' ]\n    // } );\n    while (charIdx < len) {\n      var char = text.charAt(charIdx);\n      // For debugging: search for other \"For debugging\" lines\n      // table.push(\n      // \t[ charIdx, char, State[ state ], charIdx, currentEmailAddress.idx, currentEmailAddress.hasDomainDot ]\n      // );\n      switch (state) {\n        case 0 /* None */:\n          stateNone(char);\n          break;\n        case 1 /* NonHashtagWordChar */:\n          stateNonHashtagWordChar(char);\n          break;\n        case 2 /* HashtagHashChar */:\n          stateHashtagHashChar(char);\n          break;\n        case 3 /* HashtagTextChar */:\n          stateHashtagTextChar(char);\n          break;\n        default:\n          throwUnhandledCaseError(state);\n      }\n      // For debugging: search for other \"For debugging\" lines\n      // table.push(\n      // \t[ charIdx, char, State[ state ], charIdx, currentEmailAddress.idx, currentEmailAddress.hasDomainDot ]\n      // );\n      charIdx++;\n    }\n    // Capture any valid match at the end of the string\n    captureMatchIfValid();\n    // For debugging: search for other \"For debugging\" lines\n    //console.log( '\\n' + table.toString() );\n    return matches;\n    // Handles the state when we're not in a hashtag or any word\n    function stateNone(char) {\n      if (char === '#') {\n        state = 2 /* HashtagHashChar */;\n        hashCharIdx = charIdx;\n      } else if (alphaNumericAndMarksCharRe.test(char)) {\n        state = 1 /* NonHashtagWordChar */;\n      } else {\n        // not a hashtag character ('#') or word char, stay in State.None\n      }\n    }\n    // Handles the state when we've encountered a word character but are not\n    // in a hashtag. This is used to distinguish between a standalone\n    // hashtag such as '#Stuff' vs a hash char that is part of a word like\n    // 'asdf#stuff' (the latter of which would not be a match)\n    function stateNonHashtagWordChar(char) {\n      if (alphaNumericAndMarksCharRe.test(char)) {\n        // continue in NonHashtagWordChar state\n      } else {\n        state = 0 /* None */;\n      }\n    }\n    // Handles the state when we've just encountered a '#' character\n    function stateHashtagHashChar(char) {\n      if (hashtagTextCharRe.test(char)) {\n        // '#' char with valid hash text char following\n        state = 3 /* HashtagTextChar */;\n      } else if (alphaNumericAndMarksCharRe.test(char)) {\n        state = 1 /* NonHashtagWordChar */;\n      } else {\n        state = 0 /* None */;\n      }\n    }\n    // Handles the state when we're currently in the hash tag's text chars\n    function stateHashtagTextChar(char) {\n      if (hashtagTextCharRe.test(char)) {\n        // Continue reading characters in the HashtagText state\n      } else {\n        captureMatchIfValid();\n        hashCharIdx = -1;\n        if (alphaNumericAndMarksCharRe.test(char)) {\n          state = 1 /* NonHashtagWordChar */;\n        } else {\n          state = 0 /* None */;\n        }\n      }\n    }\n    /*\n     * Captures the current hashtag as a HashtagMatch if it's valid.\n     */\n    function captureMatchIfValid() {\n      if (hashCharIdx > -1 && charIdx - hashCharIdx <= 140) {\n        // Max length of 140 for a hashtag ('#' char + 139 word chars)\n        var matchedText = text.slice(hashCharIdx, charIdx);\n        var match = new HashtagMatch({\n          tagBuilder: tagBuilder,\n          matchedText: matchedText,\n          offset: hashCharIdx,\n          serviceName: serviceName,\n          hashtag: matchedText.slice(1)\n        });\n        matches.push(match);\n      }\n    }\n  };\n  return HashtagMatcher;\n}(Matcher);\nexport { HashtagMatcher };\nexport var hashtagServices = ['twitter', 'facebook', 'instagram', 'tiktok'];","import { __extends } from \"tslib\";\nimport { Matcher } from './matcher';\nimport { PhoneMatch } from '../match/phone-match';\nimport { nonDigitRe } from '../regex-lib';\n// RegExp objects which are shared by all instances of PhoneMatcher. These are\n// here to avoid re-instantiating the RegExp objects if `Autolinker.link()` is\n// called multiple times, thus instantiating PhoneMatcher and its RegExp\n// objects each time (which is very expensive - see https://github.com/gregjacobs/Autolinker.js/issues/314).\n// See descriptions of the properties where they are used for details about them\n// Over the years, many people have added to this regex, but it should have been\n// split up by country. Maybe one day we can break this down.\nvar mostPhoneNumbers = /(?:(?:(?:(\\+)?\\d{1,3}[-\\040.]?)?\\(?\\d{3}\\)?[-\\040.]?\\d{3}[-\\040.]?\\d{4})|(?:(\\+)(?:9[976]\\d|8[987530]\\d|6[987]\\d|5[90]\\d|42\\d|3[875]\\d|2[98654321]\\d|9[8543210]|8[6421]|6[6543210]|5[87654321]|4[987654310]|3[9643210]|2[70]|7|1)[-\\040.]?(?:\\d[-\\040.]?){6,12}\\d+))([,;]+[0-9]+#?)*/;\n// Regex for Japanese phone numbers\nvar japanesePhoneRe = /(0([1-9]{1}-?[1-9]\\d{3}|[1-9]{2}-?\\d{3}|[1-9]{2}\\d{1}-?\\d{2}|[1-9]{2}\\d{2}-?\\d{1})-?\\d{4}|0[789]0-?\\d{4}-?\\d{4}|050-?\\d{4}-?\\d{4})/;\n// Combined regex\nvar phoneMatcherRegex = new RegExp(\"\".concat(mostPhoneNumbers.source, \"|\").concat(japanesePhoneRe.source), 'g');\n/**\n * @class Autolinker.matcher.Phone\n * @extends Autolinker.matcher.Matcher\n *\n * Matcher to find Phone number matches in an input string.\n *\n * See this class's superclass ({@link Autolinker.matcher.Matcher}) for more\n * details.\n */\nvar PhoneMatcher = /** @class */function (_super) {\n  __extends(PhoneMatcher, _super);\n  function PhoneMatcher() {\n    var _this = _super !== null && _super.apply(this, arguments) || this;\n    /**\n     * The regular expression to match Phone numbers. Example matches:\n     *\n     *     (123) 456-7890\n     *     123 456 7890\n     *     123-456-7890\n     *     +18004441234,,;,10226420346#\n     *     +1 (800) 444 1234\n     *     10226420346#\n     *     1-800-444-1234,1022,64,20346#\n     *\n     * This regular expression has the following capturing groups:\n     *\n     * 1 or 2. The prefixed '+' sign, if there is one.\n     *\n     * @protected\n     * @property {RegExp} matcherRegex\n     */\n    _this.matcherRegex = phoneMatcherRegex;\n    return _this;\n  }\n  /**\n   * @inheritdoc\n   */\n  PhoneMatcher.prototype.parseMatches = function (text) {\n    var matcherRegex = this.matcherRegex,\n      tagBuilder = this.tagBuilder,\n      matches = [],\n      match;\n    while ((match = matcherRegex.exec(text)) !== null) {\n      // Remove non-numeric values from phone number string\n      var matchedText = match[0],\n        cleanNumber = matchedText.replace(/[^0-9,;#]/g, ''),\n        // strip out non-digit characters exclude comma semicolon and #\n        plusSign = !!(match[1] || match[2]),\n        // match[ 1 ] or match[ 2 ] is the prefixed plus sign, if there is one\n        before = match.index == 0 ? '' : text.substr(match.index - 1, 1),\n        after = text.substr(match.index + matchedText.length, 1),\n        contextClear = !before.match(/\\d/) && !after.match(/\\d/);\n      if (this.testMatch(match[3]) && this.testMatch(matchedText) && contextClear) {\n        matches.push(new PhoneMatch({\n          tagBuilder: tagBuilder,\n          matchedText: matchedText,\n          offset: match.index,\n          number: cleanNumber,\n          plusSign: plusSign\n        }));\n      }\n    }\n    return matches;\n  };\n  PhoneMatcher.prototype.testMatch = function (text) {\n    return nonDigitRe.test(text);\n  };\n  return PhoneMatcher;\n}(Matcher);\nexport { PhoneMatcher };","import { __extends } from \"tslib\";\nimport { Matcher } from './matcher';\nimport { alphaNumericAndMarksCharsStr } from '../regex-lib';\nimport { MentionMatch } from '../match/mention-match';\n// RegExp objects which are shared by all instances of MentionMatcher. These are\n// here to avoid re-instantiating the RegExp objects if `Autolinker.link()` is\n// called multiple times, thus instantiating MentionMatcher and its RegExp\n// objects each time (which is very expensive - see https://github.com/gregjacobs/Autolinker.js/issues/314).\n// See descriptions of the properties where they are used for details about them\nvar twitterRegex = new RegExp(\"@[_\".concat(alphaNumericAndMarksCharsStr, \"]{1,50}(?![_\").concat(alphaNumericAndMarksCharsStr, \"])\"), 'g'); // lookahead used to make sure we don't match something above 50 characters\nvar instagramRegex = new RegExp(\"@[_.\".concat(alphaNumericAndMarksCharsStr, \"]{1,30}(?![_\").concat(alphaNumericAndMarksCharsStr, \"])\"), 'g'); // lookahead used to make sure we don't match something above 30 characters\nvar soundcloudRegex = new RegExp(\"@[-_.\".concat(alphaNumericAndMarksCharsStr, \"]{1,50}(?![-_\").concat(alphaNumericAndMarksCharsStr, \"])\"), 'g'); // lookahead used to make sure we don't match something above 50 characters\n// TikTok usernames are 1-24 characters containing letters, numbers, underscores\n// and periods, but cannot end in a period: https://support.tiktok.com/en/getting-started/setting-up-your-profile/changing-your-username\nvar tiktokRegex = new RegExp(\"@[_.\".concat(alphaNumericAndMarksCharsStr, \"]{1,23}[_\").concat(alphaNumericAndMarksCharsStr, \"](?![_\").concat(alphaNumericAndMarksCharsStr, \"])\"), 'g'); // lookahead used to make sure we don't match something above 24 characters\nvar nonWordCharRegex = new RegExp('[^' + alphaNumericAndMarksCharsStr + ']');\n/**\n * @class Autolinker.matcher.Mention\n * @extends Autolinker.matcher.Matcher\n *\n * Matcher to find/replace username matches in an input string.\n */\nvar MentionMatcher = /** @class */function (_super) {\n  __extends(MentionMatcher, _super);\n  /**\n   * @method constructor\n   * @param {Object} cfg The configuration properties for the Match instance,\n   *   specified in an Object (map).\n   */\n  function MentionMatcher(cfg) {\n    var _this = _super.call(this, cfg) || this;\n    /**\n     * @cfg {'twitter'/'instagram'/'soundcloud'} protected\n     *\n     * The name of service to link @mentions to.\n     *\n     * Valid values are: 'twitter', 'instagram', 'soundcloud', or 'tiktok'\n     */\n    _this.serviceName = 'twitter'; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * Hash of regular expression to match username handles. Example match:\n     *\n     *     @asdf\n     *\n     * @private\n     * @property {Object} matcherRegexes\n     */\n    _this.matcherRegexes = {\n      twitter: twitterRegex,\n      instagram: instagramRegex,\n      soundcloud: soundcloudRegex,\n      tiktok: tiktokRegex\n    };\n    /**\n     * The regular expression to use to check the character before a username match to\n     * make sure we didn't accidentally match an email address.\n     *\n     * For example, the string \"asdf@asdf.com\" should not match \"@asdf\" as a username.\n     *\n     * @private\n     * @property {RegExp} nonWordCharRegex\n     */\n    _this.nonWordCharRegex = nonWordCharRegex;\n    _this.serviceName = cfg.serviceName;\n    return _this;\n  }\n  /**\n   * @inheritdoc\n   */\n  MentionMatcher.prototype.parseMatches = function (text) {\n    var serviceName = this.serviceName,\n      matcherRegex = this.matcherRegexes[this.serviceName],\n      nonWordCharRegex = this.nonWordCharRegex,\n      tagBuilder = this.tagBuilder,\n      matches = [],\n      match;\n    if (!matcherRegex) {\n      return matches;\n    }\n    while ((match = matcherRegex.exec(text)) !== null) {\n      var offset = match.index,\n        prevChar = text.charAt(offset - 1);\n      // If we found the match at the beginning of the string, or we found the match\n      // and there is a whitespace char in front of it (meaning it is not an email\n      // address), then it is a username match.\n      if (offset === 0 || nonWordCharRegex.test(prevChar)) {\n        var matchedText = match[0].replace(/\\.+$/g, ''),\n          // strip off trailing .\n          mention = matchedText.slice(1); // strip off the '@' character at the beginning\n        matches.push(new MentionMatch({\n          tagBuilder: tagBuilder,\n          matchedText: matchedText,\n          offset: offset,\n          serviceName: serviceName,\n          mention: mention\n        }));\n      }\n    }\n    return matches;\n  };\n  return MentionMatcher;\n}(Matcher);\nexport { MentionMatcher };","import { __assign } from \"tslib\";\nimport { letterRe, digitRe, whitespaceRe, quoteRe, controlCharsRe } from '../regex-lib';\nimport { throwUnhandledCaseError } from '../utils';\n// For debugging: search for other \"For debugging\" lines\n// import CliTable from 'cli-table';\n/**\n * Parses an HTML string, calling the callbacks to notify of tags and text.\n *\n * ## History\n *\n * This file previously used a regular expression to find html tags in the input\n * text. Unfortunately, we ran into a bunch of catastrophic backtracking issues\n * with certain input text, causing Autolinker to either hang or just take a\n * really long time to parse the string.\n *\n * The current code is intended to be a O(n) algorithm that walks through\n * the string in one pass, and tries to be as cheap as possible. We don't need\n * to implement the full HTML spec, but rather simply determine where the string\n * looks like an HTML tag, and where it looks like text (so that we can autolink\n * that).\n *\n * This state machine parser is intended just to be a simple but performant\n * parser of HTML for the subset of requirements we have. We simply need to:\n *\n * 1. Determine where HTML tags are\n * 2. Determine the tag name (Autolinker specifically only cares about <a>,\n *    <script>, and <style> tags, so as not to link any text within them)\n *\n * We don't need to:\n *\n * 1. Create a parse tree\n * 2. Auto-close tags with invalid markup\n * 3. etc.\n *\n * The other intention behind this is that we didn't want to add external\n * dependencies on the Autolinker utility which would increase its size. For\n * instance, adding htmlparser2 adds 125kb to the minified output file,\n * increasing its final size from 47kb to 172kb (at the time of writing). It\n * also doesn't work exactly correctly, treating the string \"<3 blah blah blah\"\n * as an HTML tag.\n *\n * Reference for HTML spec:\n *\n *     https://www.w3.org/TR/html51/syntax.html#sec-tokenization\n *\n * @param {String} html The HTML to parse\n * @param {Object} callbacks\n * @param {Function} callbacks.onOpenTag Callback function to call when an open\n *   tag is parsed. Called with the tagName as its argument.\n * @param {Function} callbacks.onCloseTag Callback function to call when a close\n *   tag is parsed. Called with the tagName as its argument. If a self-closing\n *   tag is found, `onCloseTag` is called immediately after `onOpenTag`.\n * @param {Function} callbacks.onText Callback function to call when text (i.e\n *   not an HTML tag) is parsed. Called with the text (string) as its first\n *   argument, and offset (number) into the string as its second.\n */\nexport function parseHtml(html, _a) {\n  var onOpenTag = _a.onOpenTag,\n    onCloseTag = _a.onCloseTag,\n    onText = _a.onText,\n    onComment = _a.onComment,\n    onDoctype = _a.onDoctype;\n  var noCurrentTag = new CurrentTag();\n  var charIdx = 0,\n    len = html.length,\n    state = 0 /* Data */,\n    currentDataIdx = 0,\n    // where the current data start index is\n    currentTag = noCurrentTag; // describes the current tag that is being read\n  // For debugging: search for other \"For debugging\" lines\n  // const table = new CliTable( {\n  // \thead: [ 'charIdx', 'char', 'state', 'currentDataIdx', 'currentOpenTagIdx', 'tag.type' ]\n  // } );\n  while (charIdx < len) {\n    var char = html.charAt(charIdx);\n    // For debugging: search for other \"For debugging\" lines\n    // ALSO: Temporarily remove the 'const' keyword on the State enum\n    // table.push(\n    // \t[ charIdx, char, State[ state ], currentDataIdx, currentTag.idx, currentTag.idx === -1 ? '' : currentTag.type ]\n    // );\n    switch (state) {\n      case 0 /* Data */:\n        stateData(char);\n        break;\n      case 1 /* TagOpen */:\n        stateTagOpen(char);\n        break;\n      case 2 /* EndTagOpen */:\n        stateEndTagOpen(char);\n        break;\n      case 3 /* TagName */:\n        stateTagName(char);\n        break;\n      case 4 /* BeforeAttributeName */:\n        stateBeforeAttributeName(char);\n        break;\n      case 5 /* AttributeName */:\n        stateAttributeName(char);\n        break;\n      case 6 /* AfterAttributeName */:\n        stateAfterAttributeName(char);\n        break;\n      case 7 /* BeforeAttributeValue */:\n        stateBeforeAttributeValue(char);\n        break;\n      case 8 /* AttributeValueDoubleQuoted */:\n        stateAttributeValueDoubleQuoted(char);\n        break;\n      case 9 /* AttributeValueSingleQuoted */:\n        stateAttributeValueSingleQuoted(char);\n        break;\n      case 10 /* AttributeValueUnquoted */:\n        stateAttributeValueUnquoted(char);\n        break;\n      case 11 /* AfterAttributeValueQuoted */:\n        stateAfterAttributeValueQuoted(char);\n        break;\n      case 12 /* SelfClosingStartTag */:\n        stateSelfClosingStartTag(char);\n        break;\n      case 13 /* MarkupDeclarationOpenState */:\n        stateMarkupDeclarationOpen(char);\n        break;\n      case 14 /* CommentStart */:\n        stateCommentStart(char);\n        break;\n      case 15 /* CommentStartDash */:\n        stateCommentStartDash(char);\n        break;\n      case 16 /* Comment */:\n        stateComment(char);\n        break;\n      case 17 /* CommentEndDash */:\n        stateCommentEndDash(char);\n        break;\n      case 18 /* CommentEnd */:\n        stateCommentEnd(char);\n        break;\n      case 19 /* CommentEndBang */:\n        stateCommentEndBang(char);\n        break;\n      case 20 /* Doctype */:\n        stateDoctype(char);\n        break;\n      default:\n        throwUnhandledCaseError(state);\n    }\n    // For debugging: search for other \"For debugging\" lines\n    // ALSO: Temporarily remove the 'const' keyword on the State enum\n    // table.push(\n    // \t[ charIdx, char, State[ state ], currentDataIdx, currentTag.idx, currentTag.idx === -1 ? '' : currentTag.type ]\n    // );\n    charIdx++;\n  }\n  if (currentDataIdx < charIdx) {\n    emitText();\n  }\n  // For debugging: search for other \"For debugging\" lines\n  // console.log( '\\n' + table.toString() );\n  // Called when non-tags are being read (i.e. the text around HTML †ags)\n  // https://www.w3.org/TR/html51/syntax.html#data-state\n  function stateData(char) {\n    if (char === '<') {\n      startNewTag();\n    }\n  }\n  // Called after a '<' is read from the Data state\n  // https://www.w3.org/TR/html51/syntax.html#tag-open-state\n  function stateTagOpen(char) {\n    if (char === '!') {\n      state = 13 /* MarkupDeclarationOpenState */;\n    } else if (char === '/') {\n      state = 2 /* EndTagOpen */;\n      currentTag = new CurrentTag(__assign(__assign({}, currentTag), {\n        isClosing: true\n      }));\n    } else if (char === '<') {\n      // start of another tag (ignore the previous, incomplete one)\n      startNewTag();\n    } else if (letterRe.test(char)) {\n      // tag name start (and no '/' read)\n      state = 3 /* TagName */;\n      currentTag = new CurrentTag(__assign(__assign({}, currentTag), {\n        isOpening: true\n      }));\n    } else {\n      // Any other\n      state = 0 /* Data */;\n      currentTag = noCurrentTag;\n    }\n  }\n  // After a '<x', '</x' sequence is read (where 'x' is a letter character),\n  // this is to continue reading the tag name\n  // https://www.w3.org/TR/html51/syntax.html#tag-name-state\n  function stateTagName(char) {\n    if (whitespaceRe.test(char)) {\n      currentTag = new CurrentTag(__assign(__assign({}, currentTag), {\n        name: captureTagName()\n      }));\n      state = 4 /* BeforeAttributeName */;\n    } else if (char === '<') {\n      // start of another tag (ignore the previous, incomplete one)\n      startNewTag();\n    } else if (char === '/') {\n      currentTag = new CurrentTag(__assign(__assign({}, currentTag), {\n        name: captureTagName()\n      }));\n      state = 12 /* SelfClosingStartTag */;\n    } else if (char === '>') {\n      currentTag = new CurrentTag(__assign(__assign({}, currentTag), {\n        name: captureTagName()\n      }));\n      emitTagAndPreviousTextNode(); // resets to Data state as well\n    } else if (!letterRe.test(char) && !digitRe.test(char) && char !== ':') {\n      // Anything else that does not form an html tag. Note: the colon\n      // character is accepted for XML namespaced tags\n      resetToDataState();\n    } else {\n      // continue reading tag name\n    }\n  }\n  // Called after the '/' is read from a '</' sequence\n  // https://www.w3.org/TR/html51/syntax.html#end-tag-open-state\n  function stateEndTagOpen(char) {\n    if (char === '>') {\n      // parse error. Encountered \"</>\". Skip it without treating as a tag\n      resetToDataState();\n    } else if (letterRe.test(char)) {\n      state = 3 /* TagName */;\n    } else {\n      // some other non-tag-like character, don't treat this as a tag\n      resetToDataState();\n    }\n  }\n  // https://www.w3.org/TR/html51/syntax.html#before-attribute-name-state\n  function stateBeforeAttributeName(char) {\n    if (whitespaceRe.test(char)) {\n      // stay in BeforeAttributeName state - continue reading chars\n    } else if (char === '/') {\n      state = 12 /* SelfClosingStartTag */;\n    } else if (char === '>') {\n      emitTagAndPreviousTextNode(); // resets to Data state as well\n    } else if (char === '<') {\n      // start of another tag (ignore the previous, incomplete one)\n      startNewTag();\n    } else if (char === \"=\" || quoteRe.test(char) || controlCharsRe.test(char)) {\n      // \"Parse error\" characters that, according to the spec, should be\n      // appended to the attribute name, but we'll treat these characters\n      // as not forming a real HTML tag\n      resetToDataState();\n    } else {\n      // Any other char, start of a new attribute name\n      state = 5 /* AttributeName */;\n    }\n  }\n  // https://www.w3.org/TR/html51/syntax.html#attribute-name-state\n  function stateAttributeName(char) {\n    if (whitespaceRe.test(char)) {\n      state = 6 /* AfterAttributeName */;\n    } else if (char === '/') {\n      state = 12 /* SelfClosingStartTag */;\n    } else if (char === '=') {\n      state = 7 /* BeforeAttributeValue */;\n    } else if (char === '>') {\n      emitTagAndPreviousTextNode(); // resets to Data state as well\n    } else if (char === '<') {\n      // start of another tag (ignore the previous, incomplete one)\n      startNewTag();\n    } else if (quoteRe.test(char)) {\n      // \"Parse error\" characters that, according to the spec, should be\n      // appended to the attribute name, but we'll treat these characters\n      // as not forming a real HTML tag\n      resetToDataState();\n    } else {\n      // anything else: continue reading attribute name\n    }\n  }\n  // https://www.w3.org/TR/html51/syntax.html#after-attribute-name-state\n  function stateAfterAttributeName(char) {\n    if (whitespaceRe.test(char)) {\n      // ignore the character - continue reading\n    } else if (char === '/') {\n      state = 12 /* SelfClosingStartTag */;\n    } else if (char === '=') {\n      state = 7 /* BeforeAttributeValue */;\n    } else if (char === '>') {\n      emitTagAndPreviousTextNode();\n    } else if (char === '<') {\n      // start of another tag (ignore the previous, incomplete one)\n      startNewTag();\n    } else if (quoteRe.test(char)) {\n      // \"Parse error\" characters that, according to the spec, should be\n      // appended to the attribute name, but we'll treat these characters\n      // as not forming a real HTML tag\n      resetToDataState();\n    } else {\n      // Any other character, start a new attribute in the current tag\n      state = 5 /* AttributeName */;\n    }\n  }\n  // https://www.w3.org/TR/html51/syntax.html#before-attribute-value-state\n  function stateBeforeAttributeValue(char) {\n    if (whitespaceRe.test(char)) {\n      // ignore the character - continue reading\n    } else if (char === \"\\\"\") {\n      state = 8 /* AttributeValueDoubleQuoted */;\n    } else if (char === \"'\") {\n      state = 9 /* AttributeValueSingleQuoted */;\n    } else if (/[>=`]/.test(char)) {\n      // Invalid chars after an '=' for an attribute value, don't count\n      // the current tag as an HTML tag\n      resetToDataState();\n    } else if (char === '<') {\n      // start of another tag (ignore the previous, incomplete one)\n      startNewTag();\n    } else {\n      // Any other character, consider it an unquoted attribute value\n      state = 10 /* AttributeValueUnquoted */;\n    }\n  }\n  // https://www.w3.org/TR/html51/syntax.html#attribute-value-double-quoted-state\n  function stateAttributeValueDoubleQuoted(char) {\n    if (char === \"\\\"\") {\n      // end the current double-quoted attribute\n      state = 11 /* AfterAttributeValueQuoted */;\n    } else {\n      // consume the character as part of the double-quoted attribute value\n    }\n  }\n  // https://www.w3.org/TR/html51/syntax.html#attribute-value-single-quoted-state\n  function stateAttributeValueSingleQuoted(char) {\n    if (char === \"'\") {\n      // end the current single-quoted attribute\n      state = 11 /* AfterAttributeValueQuoted */;\n    } else {\n      // consume the character as part of the double-quoted attribute value\n    }\n  }\n  // https://www.w3.org/TR/html51/syntax.html#attribute-value-unquoted-state\n  function stateAttributeValueUnquoted(char) {\n    if (whitespaceRe.test(char)) {\n      state = 4 /* BeforeAttributeName */;\n    } else if (char === '>') {\n      emitTagAndPreviousTextNode();\n    } else if (char === '<') {\n      // start of another tag (ignore the previous, incomplete one)\n      startNewTag();\n    } else {\n      // Any other character, treat it as part of the attribute value\n    }\n  }\n  // https://www.w3.org/TR/html51/syntax.html#after-attribute-value-quoted-state\n  function stateAfterAttributeValueQuoted(char) {\n    if (whitespaceRe.test(char)) {\n      state = 4 /* BeforeAttributeName */;\n    } else if (char === '/') {\n      state = 12 /* SelfClosingStartTag */;\n    } else if (char === '>') {\n      emitTagAndPreviousTextNode();\n    } else if (char === '<') {\n      // start of another tag (ignore the previous, incomplete one)\n      startNewTag();\n    } else {\n      // Any other character, \"parse error\". Spec says to switch to the\n      // BeforeAttributeState and re-consume the character, as it may be\n      // the start of a new attribute name\n      state = 4 /* BeforeAttributeName */;\n      reconsumeCurrentCharacter();\n    }\n  }\n  // A '/' has just been read in the current tag (presumably for '/>'), and\n  // this handles the next character\n  // https://www.w3.org/TR/html51/syntax.html#self-closing-start-tag-state\n  function stateSelfClosingStartTag(char) {\n    if (char === '>') {\n      currentTag = new CurrentTag(__assign(__assign({}, currentTag), {\n        isClosing: true\n      }));\n      emitTagAndPreviousTextNode(); // resets to Data state as well\n    } else {\n      state = 4 /* BeforeAttributeName */;\n    }\n  }\n  // https://www.w3.org/TR/html51/syntax.html#markup-declaration-open-state\n  // (HTML Comments or !DOCTYPE)\n  function stateMarkupDeclarationOpen(char) {\n    if (html.substr(charIdx, 2) === '--') {\n      // html comment\n      charIdx += 2; // \"consume\" characters\n      currentTag = new CurrentTag(__assign(__assign({}, currentTag), {\n        type: 'comment'\n      }));\n      state = 14 /* CommentStart */;\n    } else if (html.substr(charIdx, 7).toUpperCase() === 'DOCTYPE') {\n      charIdx += 7; // \"consume\" characters\n      currentTag = new CurrentTag(__assign(__assign({}, currentTag), {\n        type: 'doctype'\n      }));\n      state = 20 /* Doctype */;\n    } else {\n      // At this point, the spec specifies that the state machine should\n      // enter the \"bogus comment\" state, in which case any character(s)\n      // after the '<!' that were read should become an HTML comment up\n      // until the first '>' that is read (or EOF). Instead, we'll assume\n      // that a user just typed '<!' as part of text data\n      resetToDataState();\n    }\n  }\n  // Handles after the sequence '<!--' has been read\n  // https://www.w3.org/TR/html51/syntax.html#comment-start-state\n  function stateCommentStart(char) {\n    if (char === '-') {\n      // We've read the sequence '<!---' at this point (3 dashes)\n      state = 15 /* CommentStartDash */;\n    } else if (char === '>') {\n      // At this point, we'll assume the comment wasn't a real comment\n      // so we'll just emit it as data. We basically read the sequence\n      // '<!-->'\n      resetToDataState();\n    } else {\n      // Any other char, take it as part of the comment\n      state = 16 /* Comment */;\n    }\n  }\n  // We've read the sequence '<!---' at this point (3 dashes)\n  // https://www.w3.org/TR/html51/syntax.html#comment-start-dash-state\n  function stateCommentStartDash(char) {\n    if (char === '-') {\n      // We've read '<!----' (4 dashes) at this point\n      state = 18 /* CommentEnd */;\n    } else if (char === '>') {\n      // At this point, we'll assume the comment wasn't a real comment\n      // so we'll just emit it as data. We basically read the sequence\n      // '<!--->'\n      resetToDataState();\n    } else {\n      // Anything else, take it as a valid comment\n      state = 16 /* Comment */;\n    }\n  }\n  // Currently reading the comment's text (data)\n  // https://www.w3.org/TR/html51/syntax.html#comment-state\n  function stateComment(char) {\n    if (char === '-') {\n      state = 17 /* CommentEndDash */;\n    } else {\n      // Any other character, stay in the Comment state\n    }\n  }\n  // When we we've read the first dash inside a comment, it may signal the\n  // end of the comment if we read another dash\n  // https://www.w3.org/TR/html51/syntax.html#comment-end-dash-state\n  function stateCommentEndDash(char) {\n    if (char === '-') {\n      state = 18 /* CommentEnd */;\n    } else {\n      // Wasn't a dash, must still be part of the comment\n      state = 16 /* Comment */;\n    }\n  }\n  // After we've read two dashes inside a comment, it may signal the end of\n  // the comment if we then read a '>' char\n  // https://www.w3.org/TR/html51/syntax.html#comment-end-state\n  function stateCommentEnd(char) {\n    if (char === '>') {\n      emitTagAndPreviousTextNode();\n    } else if (char === '!') {\n      state = 19 /* CommentEndBang */;\n    } else if (char === '-') {\n      // A 3rd '-' has been read: stay in the CommentEnd state\n    } else {\n      // Anything else, switch back to the comment state since we didn't\n      // read the full \"end comment\" sequence (i.e. '-->')\n      state = 16 /* Comment */;\n    }\n  }\n  // We've read the sequence '--!' inside of a comment\n  // https://www.w3.org/TR/html51/syntax.html#comment-end-bang-state\n  function stateCommentEndBang(char) {\n    if (char === '-') {\n      // We read the sequence '--!-' inside of a comment. The last dash\n      // could signify that the comment is going to close\n      state = 17 /* CommentEndDash */;\n    } else if (char === '>') {\n      // End of comment with the sequence '--!>'\n      emitTagAndPreviousTextNode();\n    } else {\n      // The '--!' was not followed by a '>', continue reading the\n      // comment's text\n      state = 16 /* Comment */;\n    }\n  }\n  /**\n   * For DOCTYPES in particular, we don't care about the attributes. Just\n   * advance to the '>' character and emit the tag, unless we find a '<'\n   * character in which case we'll start a new tag.\n   *\n   * Example doctype tag:\n   *    <!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3.org/TR/html4/strict.dtd\">\n   *\n   * Actual spec: https://www.w3.org/TR/html51/syntax.html#doctype-state\n   */\n  function stateDoctype(char) {\n    if (char === '>') {\n      emitTagAndPreviousTextNode();\n    } else if (char === '<') {\n      startNewTag();\n    } else {\n      // stay in the Doctype state\n    }\n  }\n  /**\n   * Resets the state back to the Data state, and removes the current tag.\n   *\n   * We'll generally run this function whenever a \"parse error\" is\n   * encountered, where the current tag that is being read no longer looks\n   * like a real HTML tag.\n   */\n  function resetToDataState() {\n    state = 0 /* Data */;\n    currentTag = noCurrentTag;\n  }\n  /**\n   * Starts a new HTML tag at the current index, ignoring any previous HTML\n   * tag that was being read.\n   *\n   * We'll generally run this function whenever we read a new '<' character,\n   * including when we read a '<' character inside of an HTML tag that we were\n   * previously reading.\n   */\n  function startNewTag() {\n    state = 1 /* TagOpen */;\n    currentTag = new CurrentTag({\n      idx: charIdx\n    });\n  }\n  /**\n   * Once we've decided to emit an open tag, that means we can also emit the\n   * text node before it.\n   */\n  function emitTagAndPreviousTextNode() {\n    var textBeforeTag = html.slice(currentDataIdx, currentTag.idx);\n    if (textBeforeTag) {\n      // the html tag was the first element in the html string, or two\n      // tags next to each other, in which case we should not emit a text\n      // node\n      onText(textBeforeTag, currentDataIdx);\n    }\n    if (currentTag.type === 'comment') {\n      onComment(currentTag.idx);\n    } else if (currentTag.type === 'doctype') {\n      onDoctype(currentTag.idx);\n    } else {\n      if (currentTag.isOpening) {\n        onOpenTag(currentTag.name, currentTag.idx);\n      }\n      if (currentTag.isClosing) {\n        // note: self-closing tags will emit both opening and closing\n        onCloseTag(currentTag.name, currentTag.idx);\n      }\n    }\n    // Since we just emitted a tag, reset to the data state for the next char\n    resetToDataState();\n    currentDataIdx = charIdx + 1;\n  }\n  function emitText() {\n    var text = html.slice(currentDataIdx, charIdx);\n    onText(text, currentDataIdx);\n    currentDataIdx = charIdx + 1;\n  }\n  /**\n   * Captures the tag name from the start of the tag to the current character\n   * index, and converts it to lower case\n   */\n  function captureTagName() {\n    var startIdx = currentTag.idx + (currentTag.isClosing ? 2 : 1);\n    return html.slice(startIdx, charIdx).toLowerCase();\n  }\n  /**\n   * Causes the main loop to re-consume the current character, such as after\n   * encountering a \"parse error\" that changed state and needs to reconsume\n   * the same character in that new state.\n   */\n  function reconsumeCurrentCharacter() {\n    charIdx--;\n  }\n}\nvar CurrentTag = /** @class */function () {\n  function CurrentTag(cfg) {\n    if (cfg === void 0) {\n      cfg = {};\n    }\n    this.idx = cfg.idx !== undefined ? cfg.idx : -1;\n    this.type = cfg.type || 'tag';\n    this.name = cfg.name || '';\n    this.isOpening = !!cfg.isOpening;\n    this.isClosing = !!cfg.isClosing;\n  }\n  return CurrentTag;\n}();","import { version } from './version';\nimport { defaults, remove, splitAndCapture } from './utils';\nimport { AnchorTagBuilder } from './anchor-tag-builder';\nimport { Match } from './match/match';\nimport { EmailMatch } from './match/email-match';\nimport { HashtagMatch } from './match/hashtag-match';\nimport { MentionMatch } from './match/mention-match';\nimport { PhoneMatch } from './match/phone-match';\nimport { UrlMatch } from './match/url-match';\nimport { Matcher } from './matcher/matcher';\nimport { HtmlTag } from './html-tag';\nimport { EmailMatcher } from './matcher/email-matcher';\nimport { UrlMatcher } from './matcher/url-matcher';\nimport { HashtagMatcher, hashtagServices } from './matcher/hashtag-matcher';\nimport { PhoneMatcher } from './matcher/phone-matcher';\nimport { MentionMatcher } from './matcher/mention-matcher';\nimport { parseHtml } from './htmlParser/parse-html';\n/**\n * @class Autolinker\n * @extends Object\n *\n * Utility class used to process a given string of text, and wrap the matches in\n * the appropriate anchor (&lt;a&gt;) tags to turn them into links.\n *\n * Any of the configuration options may be provided in an Object provided\n * to the Autolinker constructor, which will configure how the {@link #link link()}\n * method will process the links.\n *\n * For example:\n *\n *     var autolinker = new Autolinker( {\n *         newWindow : false,\n *         truncate  : 30\n *     } );\n *\n *     var html = autolinker.link( \"Joe went to www.yahoo.com\" );\n *     // produces: 'Joe went to <a href=\"http://www.yahoo.com\">yahoo.com</a>'\n *\n *\n * The {@link #static-link static link()} method may also be used to inline\n * options into a single call, which may be more convenient for one-off uses.\n * For example:\n *\n *     var html = Autolinker.link( \"Joe went to www.yahoo.com\", {\n *         newWindow : false,\n *         truncate  : 30\n *     } );\n *     // produces: 'Joe went to <a href=\"http://www.yahoo.com\">yahoo.com</a>'\n *\n *\n * ## Custom Replacements of Links\n *\n * If the configuration options do not provide enough flexibility, a {@link #replaceFn}\n * may be provided to fully customize the output of Autolinker. This function is\n * called once for each URL/Email/Phone#/Hashtag/Mention (Twitter, Instagram, Soundcloud)\n * match that is encountered.\n *\n * For example:\n *\n *     var input = \"...\";  // string with URLs, Email Addresses, Phone #s, Hashtags, and Mentions (Twitter, Instagram, Soundcloud)\n *\n *     var linkedText = Autolinker.link( input, {\n *         replaceFn : function( match ) {\n *             console.log( \"href = \", match.getAnchorHref() );\n *             console.log( \"text = \", match.getAnchorText() );\n *\n *             switch( match.getType() ) {\n *                 case 'url' :\n *                     console.log( \"url: \", match.getUrl() );\n *\n *                     if( match.getUrl().indexOf( 'mysite.com' ) === -1 ) {\n *                         var tag = match.buildTag();  // returns an `Autolinker.HtmlTag` instance, which provides mutator methods for easy changes\n *                         tag.setAttr( 'rel', 'nofollow' );\n *                         tag.addClass( 'external-link' );\n *\n *                         return tag;\n *\n *                     } else {\n *                         return true;  // let Autolinker perform its normal anchor tag replacement\n *                     }\n *\n *                 case 'email' :\n *                     var email = match.getEmail();\n *                     console.log( \"email: \", email );\n *\n *                     if( email === \"my@own.address\" ) {\n *                         return false;  // don't auto-link this particular email address; leave as-is\n *                     } else {\n *                         return;  // no return value will have Autolinker perform its normal anchor tag replacement (same as returning `true`)\n *                     }\n *\n *                 case 'phone' :\n *                     var phoneNumber = match.getPhoneNumber();\n *                     console.log( phoneNumber );\n *\n *                     return '<a href=\"http://newplace.to.link.phone.numbers.to/\">' + phoneNumber + '</a>';\n *\n *                 case 'hashtag' :\n *                     var hashtag = match.getHashtag();\n *                     console.log( hashtag );\n *\n *                     return '<a href=\"http://newplace.to.link.hashtag.handles.to/\">' + hashtag + '</a>';\n *\n *                 case 'mention' :\n *                     var mention = match.getMention();\n *                     console.log( mention );\n *\n *                     return '<a href=\"http://newplace.to.link.mention.to/\">' + mention + '</a>';\n *             }\n *         }\n *     } );\n *\n *\n * The function may return the following values:\n *\n * - `true` (Boolean): Allow Autolinker to replace the match as it normally\n *   would.\n * - `false` (Boolean): Do not replace the current match at all - leave as-is.\n * - Any String: If a string is returned from the function, the string will be\n *   used directly as the replacement HTML for the match.\n * - An {@link Autolinker.HtmlTag} instance, which can be used to build/modify\n *   an HTML tag before writing out its HTML text.\n */\nvar Autolinker = /** @class */function () {\n  /**\n   * @method constructor\n   * @param {Object} [cfg] The configuration options for the Autolinker instance,\n   *   specified in an Object (map).\n   */\n  function Autolinker(cfg) {\n    if (cfg === void 0) {\n      cfg = {};\n    }\n    /**\n     * The Autolinker version number exposed on the instance itself.\n     *\n     * Ex: 0.25.1\n     */\n    this.version = Autolinker.version;\n    /**\n     * @cfg {Boolean/Object} [urls]\n     *\n     * `true` if URLs should be automatically linked, `false` if they should not\n     * be. Defaults to `true`.\n     *\n     * Examples:\n     *\n     *     urls: true\n     *\n     *     // or\n     *\n     *     urls: {\n     *         schemeMatches : true,\n     *         wwwMatches    : true,\n     *         tldMatches    : true\n     *     }\n     *\n     * As shown above, this option also accepts an Object form with 3 properties\n     * to allow for more customization of what exactly gets linked. All default\n     * to `true`:\n     *\n     * @cfg {Boolean} [urls.schemeMatches] `true` to match URLs found prefixed\n     *   with a scheme, i.e. `http://google.com`, or `other+scheme://google.com`,\n     *   `false` to prevent these types of matches.\n     * @cfg {Boolean} [urls.wwwMatches] `true` to match urls found prefixed with\n     *   `'www.'`, i.e. `www.google.com`. `false` to prevent these types of\n     *   matches. Note that if the URL had a prefixed scheme, and\n     *   `schemeMatches` is true, it will still be linked.\n     * @cfg {Boolean} [urls.tldMatches] `true` to match URLs with known top\n     *   level domains (.com, .net, etc.) that are not prefixed with a scheme or\n     *   `'www.'`. This option attempts to match anything that looks like a URL\n     *   in the given text. Ex: `google.com`, `asdf.org/?page=1`, etc. `false`\n     *   to prevent these types of matches.\n     */\n    this.urls = {}; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Boolean} [email=true]\n     *\n     * `true` if email addresses should be automatically linked, `false` if they\n     * should not be.\n     */\n    this.email = true; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Boolean} [phone=true]\n     *\n     * `true` if Phone numbers (\"(555)555-5555\") should be automatically linked,\n     * `false` if they should not be.\n     */\n    this.phone = true; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Boolean/String} [hashtag=false]\n     *\n     * A string for the service name to have hashtags (ex: \"#myHashtag\")\n     * auto-linked to. The currently-supported values are:\n     *\n     * - 'twitter'\n     * - 'facebook'\n     * - 'instagram'\n     *\n     * Pass `false` to skip auto-linking of hashtags.\n     */\n    this.hashtag = false; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {String/Boolean} [mention=false]\n     *\n     * A string for the service name to have mentions (ex: \"@myuser\")\n     * auto-linked to. The currently supported values are:\n     *\n     * - 'twitter'\n     * - 'instagram'\n     * - 'soundcloud'\n     *\n     * Defaults to `false` to skip auto-linking of mentions.\n     */\n    this.mention = false; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Boolean} [newWindow=true]\n     *\n     * `true` if the links should open in a new window, `false` otherwise.\n     */\n    this.newWindow = true; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Boolean/Object} [stripPrefix=true]\n     *\n     * `true` if 'http://' (or 'https://') and/or the 'www.' should be stripped\n     * from the beginning of URL links' text, `false` otherwise. Defaults to\n     * `true`.\n     *\n     * Examples:\n     *\n     *     stripPrefix: true\n     *\n     *     // or\n     *\n     *     stripPrefix: {\n     *         scheme : true,\n     *         www    : true\n     *     }\n     *\n     * As shown above, this option also accepts an Object form with 2 properties\n     * to allow for more customization of what exactly is prevented from being\n     * displayed. Both default to `true`:\n     *\n     * @cfg {Boolean} [stripPrefix.scheme] `true` to prevent the scheme part of\n     *   a URL match from being displayed to the user. Example:\n     *   `'http://google.com'` will be displayed as `'google.com'`. `false` to\n     *   not strip the scheme. NOTE: Only an `'http://'` or `'https://'` scheme\n     *   will be removed, so as not to remove a potentially dangerous scheme\n     *   (such as `'file://'` or `'javascript:'`)\n     * @cfg {Boolean} [stripPrefix.www] www (Boolean): `true` to prevent the\n     *   `'www.'` part of a URL match from being displayed to the user. Ex:\n     *   `'www.google.com'` will be displayed as `'google.com'`. `false` to not\n     *   strip the `'www'`.\n     */\n    this.stripPrefix = {\n      scheme: true,\n      www: true\n    }; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Boolean} [stripTrailingSlash=true]\n     *\n     * `true` to remove the trailing slash from URL matches, `false` to keep\n     *  the trailing slash.\n     *\n     *  Example when `true`: `http://google.com/` will be displayed as\n     *  `http://google.com`.\n     */\n    this.stripTrailingSlash = true; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Boolean} [decodePercentEncoding=true]\n     *\n     * `true` to decode percent-encoded characters in URL matches, `false` to keep\n     *  the percent-encoded characters.\n     *\n     *  Example when `true`: `https://en.wikipedia.org/wiki/San_Jos%C3%A9` will\n     *  be displayed as `https://en.wikipedia.org/wiki/San_José`.\n     */\n    this.decodePercentEncoding = true; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Number/Object} [truncate=0]\n     *\n     * ## Number Form\n     *\n     * A number for how many characters matched text should be truncated to\n     * inside the text of a link. If the matched text is over this number of\n     * characters, it will be truncated to this length by adding a two period\n     * ellipsis ('..') to the end of the string.\n     *\n     * For example: A url like 'http://www.yahoo.com/some/long/path/to/a/file'\n     * truncated to 25 characters might look something like this:\n     * 'yahoo.com/some/long/pat..'\n     *\n     * Example Usage:\n     *\n     *     truncate: 25\n     *\n     *\n     *  Defaults to `0` for \"no truncation.\"\n     *\n     *\n     * ## Object Form\n     *\n     * An Object may also be provided with two properties: `length` (Number) and\n     * `location` (String). `location` may be one of the following: 'end'\n     * (default), 'middle', or 'smart'.\n     *\n     * Example Usage:\n     *\n     *     truncate: { length: 25, location: 'middle' }\n     *\n     * @cfg {Number} [truncate.length=0] How many characters to allow before\n     *   truncation will occur. Defaults to `0` for \"no truncation.\"\n     * @cfg {\"end\"/\"middle\"/\"smart\"} [truncate.location=\"end\"]\n     *\n     * - 'end' (default): will truncate up to the number of characters, and then\n     *   add an ellipsis at the end. Ex: 'yahoo.com/some/long/pat..'\n     * - 'middle': will truncate and add the ellipsis in the middle. Ex:\n     *   'yahoo.com/s..th/to/a/file'\n     * - 'smart': for URLs where the algorithm attempts to strip out unnecessary\n     *   parts first (such as the 'www.', then URL scheme, hash, etc.),\n     *   attempting to make the URL human-readable before looking for a good\n     *   point to insert the ellipsis if it is still too long. Ex:\n     *   'yahoo.com/some..to/a/file'. For more details, see\n     *   {@link Autolinker.truncate.TruncateSmart}.\n     */\n    this.truncate = {\n      length: 0,\n      location: 'end'\n    }; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {String} className\n     *\n     * A CSS class name to add to the generated links. This class will be added\n     * to all links, as well as this class plus match suffixes for styling\n     * url/email/phone/hashtag/mention links differently.\n     *\n     * For example, if this config is provided as \"myLink\", then:\n     *\n     * - URL links will have the CSS classes: \"myLink myLink-url\"\n     * - Email links will have the CSS classes: \"myLink myLink-email\", and\n     * - Phone links will have the CSS classes: \"myLink myLink-phone\"\n     * - Hashtag links will have the CSS classes: \"myLink myLink-hashtag\"\n     * - Mention links will have the CSS classes: \"myLink myLink-mention myLink-[type]\"\n     *   where [type] is either \"instagram\", \"twitter\" or \"soundcloud\"\n     */\n    this.className = ''; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Function} replaceFn\n     *\n     * A function to individually process each match found in the input string.\n     *\n     * See the class's description for usage.\n     *\n     * The `replaceFn` can be called with a different context object (`this`\n     * reference) using the {@link #context} cfg.\n     *\n     * This function is called with the following parameter:\n     *\n     * @cfg {Autolinker.match.Match} replaceFn.match The Match instance which\n     *   can be used to retrieve information about the match that the `replaceFn`\n     *   is currently processing. See {@link Autolinker.match.Match} subclasses\n     *   for details.\n     */\n    this.replaceFn = null; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Object} context\n     *\n     * The context object (`this` reference) to call the `replaceFn` with.\n     *\n     * Defaults to this Autolinker instance.\n     */\n    this.context = undefined; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @cfg {Boolean} [sanitizeHtml=false]\n     *\n     * `true` to HTML-encode the start and end brackets of existing HTML tags found\n     * in the input string. This will escape `<` and `>` characters to `&lt;` and\n     * `&gt;`, respectively.\n     *\n     * Setting this to `true` will prevent XSS (Cross-site Scripting) attacks,\n     * but will remove the significance of existing HTML tags in the input string. If\n     * you would like to maintain the significance of existing HTML tags while also\n     * making the output HTML string safe, leave this option as `false` and use a\n     * tool like https://github.com/cure53/DOMPurify (or others) on the input string\n     * before running Autolinker.\n     */\n    this.sanitizeHtml = false; // default value just to get the above doc comment in the ES5 output and documentation generator\n    /**\n     * @private\n     * @property {Autolinker.matcher.Matcher[]} matchers\n     *\n     * The {@link Autolinker.matcher.Matcher} instances for this Autolinker\n     * instance.\n     *\n     * This is lazily created in {@link #getMatchers}.\n     */\n    this.matchers = null;\n    /**\n     * @private\n     * @property {Autolinker.AnchorTagBuilder} tagBuilder\n     *\n     * The AnchorTagBuilder instance used to build match replacement anchor tags.\n     * Note: this is lazily instantiated in the {@link #getTagBuilder} method.\n     */\n    this.tagBuilder = null;\n    // Note: when `this.something` is used in the rhs of these assignments,\n    //       it refers to the default values set above the constructor\n    this.urls = this.normalizeUrlsCfg(cfg.urls);\n    this.email = typeof cfg.email === 'boolean' ? cfg.email : this.email;\n    this.phone = typeof cfg.phone === 'boolean' ? cfg.phone : this.phone;\n    this.hashtag = cfg.hashtag || this.hashtag;\n    this.mention = cfg.mention || this.mention;\n    this.newWindow = typeof cfg.newWindow === 'boolean' ? cfg.newWindow : this.newWindow;\n    this.stripPrefix = this.normalizeStripPrefixCfg(cfg.stripPrefix);\n    this.stripTrailingSlash = typeof cfg.stripTrailingSlash === 'boolean' ? cfg.stripTrailingSlash : this.stripTrailingSlash;\n    this.decodePercentEncoding = typeof cfg.decodePercentEncoding === 'boolean' ? cfg.decodePercentEncoding : this.decodePercentEncoding;\n    this.sanitizeHtml = cfg.sanitizeHtml || false;\n    // Validate the value of the `mention` cfg\n    var mention = this.mention;\n    if (mention !== false && ['twitter', 'instagram', 'soundcloud', 'tiktok'].indexOf(mention) === -1) {\n      throw new Error(\"invalid `mention` cfg '\".concat(mention, \"' - see docs\"));\n    }\n    // Validate the value of the `hashtag` cfg\n    var hashtag = this.hashtag;\n    if (hashtag !== false && hashtagServices.indexOf(hashtag) === -1) {\n      throw new Error(\"invalid `hashtag` cfg '\".concat(hashtag, \"' - see docs\"));\n    }\n    this.truncate = this.normalizeTruncateCfg(cfg.truncate);\n    this.className = cfg.className || this.className;\n    this.replaceFn = cfg.replaceFn || this.replaceFn;\n    this.context = cfg.context || this;\n  }\n  /**\n   * Automatically links URLs, Email addresses, Phone Numbers, Twitter handles,\n   * Hashtags, and Mentions found in the given chunk of HTML. Does not link URLs\n   * found within HTML tags.\n   *\n   * For instance, if given the text: `You should go to http://www.yahoo.com`,\n   * then the result will be `You should go to &lt;a href=\"http://www.yahoo.com\"&gt;http://www.yahoo.com&lt;/a&gt;`\n   *\n   * Example:\n   *\n   *     var linkedText = Autolinker.link( \"Go to google.com\", { newWindow: false } );\n   *     // Produces: \"Go to <a href=\"http://google.com\">google.com</a>\"\n   *\n   * @static\n   * @param {String} textOrHtml The HTML or text to find matches within (depending\n   *   on if the {@link #urls}, {@link #email}, {@link #phone}, {@link #mention},\n   *   {@link #hashtag}, and {@link #mention} options are enabled).\n   * @param {Object} [options] Any of the configuration options for the Autolinker\n   *   class, specified in an Object (map). See the class description for an\n   *   example call.\n   * @return {String} The HTML text, with matches automatically linked.\n   */\n  Autolinker.link = function (textOrHtml, options) {\n    var autolinker = new Autolinker(options);\n    return autolinker.link(textOrHtml);\n  };\n  /**\n   * Parses the input `textOrHtml` looking for URLs, email addresses, phone\n   * numbers, username handles, and hashtags (depending on the configuration\n   * of the Autolinker instance), and returns an array of {@link Autolinker.match.Match}\n   * objects describing those matches (without making any replacements).\n   *\n   * Note that if parsing multiple pieces of text, it is slightly more efficient\n   * to create an Autolinker instance, and use the instance-level {@link #parse}\n   * method.\n   *\n   * Example:\n   *\n   *     var matches = Autolinker.parse( \"Hello google.com, I am asdf@asdf.com\", {\n   *         urls: true,\n   *         email: true\n   *     } );\n   *\n   *     console.log( matches.length );           // 2\n   *     console.log( matches[ 0 ].getType() );   // 'url'\n   *     console.log( matches[ 0 ].getUrl() );    // 'google.com'\n   *     console.log( matches[ 1 ].getType() );   // 'email'\n   *     console.log( matches[ 1 ].getEmail() );  // 'asdf@asdf.com'\n   *\n   * @static\n   * @param {String} textOrHtml The HTML or text to find matches within\n   *   (depending on if the {@link #urls}, {@link #email}, {@link #phone},\n   *   {@link #hashtag}, and {@link #mention} options are enabled).\n   * @param {Object} [options] Any of the configuration options for the Autolinker\n   *   class, specified in an Object (map). See the class description for an\n   *   example call.\n   * @return {Autolinker.match.Match[]} The array of Matches found in the\n   *   given input `textOrHtml`.\n   */\n  Autolinker.parse = function (textOrHtml, options) {\n    var autolinker = new Autolinker(options);\n    return autolinker.parse(textOrHtml);\n  };\n  /**\n   * Normalizes the {@link #urls} config into an Object with 3 properties:\n   * `schemeMatches`, `wwwMatches`, and `tldMatches`, all Booleans.\n   *\n   * See {@link #urls} config for details.\n   *\n   * @private\n   * @param {Boolean/Object} urls\n   * @return {Object}\n   */\n  Autolinker.prototype.normalizeUrlsCfg = function (urls) {\n    if (urls == null) urls = true; // default to `true`\n    if (typeof urls === 'boolean') {\n      return {\n        schemeMatches: urls,\n        wwwMatches: urls,\n        tldMatches: urls\n      };\n    } else {\n      // object form\n      return {\n        schemeMatches: typeof urls.schemeMatches === 'boolean' ? urls.schemeMatches : true,\n        wwwMatches: typeof urls.wwwMatches === 'boolean' ? urls.wwwMatches : true,\n        tldMatches: typeof urls.tldMatches === 'boolean' ? urls.tldMatches : true\n      };\n    }\n  };\n  /**\n   * Normalizes the {@link #stripPrefix} config into an Object with 2\n   * properties: `scheme`, and `www` - both Booleans.\n   *\n   * See {@link #stripPrefix} config for details.\n   *\n   * @private\n   * @param {Boolean/Object} stripPrefix\n   * @return {Object}\n   */\n  Autolinker.prototype.normalizeStripPrefixCfg = function (stripPrefix) {\n    if (stripPrefix == null) stripPrefix = true; // default to `true`\n    if (typeof stripPrefix === 'boolean') {\n      return {\n        scheme: stripPrefix,\n        www: stripPrefix\n      };\n    } else {\n      // object form\n      return {\n        scheme: typeof stripPrefix.scheme === 'boolean' ? stripPrefix.scheme : true,\n        www: typeof stripPrefix.www === 'boolean' ? stripPrefix.www : true\n      };\n    }\n  };\n  /**\n   * Normalizes the {@link #truncate} config into an Object with 2 properties:\n   * `length` (Number), and `location` (String).\n   *\n   * See {@link #truncate} config for details.\n   *\n   * @private\n   * @param {Number/Object} truncate\n   * @return {Object}\n   */\n  Autolinker.prototype.normalizeTruncateCfg = function (truncate) {\n    if (typeof truncate === 'number') {\n      return {\n        length: truncate,\n        location: 'end'\n      };\n    } else {\n      // object, or undefined/null\n      return defaults(truncate || {}, {\n        length: Number.POSITIVE_INFINITY,\n        location: 'end'\n      });\n    }\n  };\n  /**\n   * Parses the input `textOrHtml` looking for URLs, email addresses, phone\n   * numbers, username handles, and hashtags (depending on the configuration\n   * of the Autolinker instance), and returns an array of {@link Autolinker.match.Match}\n   * objects describing those matches (without making any replacements).\n   *\n   * This method is used by the {@link #link} method, but can also be used to\n   * simply do parsing of the input in order to discover what kinds of links\n   * there are and how many.\n   *\n   * Example usage:\n   *\n   *     var autolinker = new Autolinker( {\n   *         urls: true,\n   *         email: true\n   *     } );\n   *\n   *     var matches = autolinker.parse( \"Hello google.com, I am asdf@asdf.com\" );\n   *\n   *     console.log( matches.length );           // 2\n   *     console.log( matches[ 0 ].getType() );   // 'url'\n   *     console.log( matches[ 0 ].getUrl() );    // 'google.com'\n   *     console.log( matches[ 1 ].getType() );   // 'email'\n   *     console.log( matches[ 1 ].getEmail() );  // 'asdf@asdf.com'\n   *\n   * @param {String} textOrHtml The HTML or text to find matches within\n   *   (depending on if the {@link #urls}, {@link #email}, {@link #phone},\n   *   {@link #hashtag}, and {@link #mention} options are enabled).\n   * @return {Autolinker.match.Match[]} The array of Matches found in the\n   *   given input `textOrHtml`.\n   */\n  Autolinker.prototype.parse = function (textOrHtml) {\n    var _this = this;\n    var skipTagNames = ['a', 'style', 'script'],\n      skipTagsStackCount = 0,\n      // used to only Autolink text outside of anchor/script/style tags. We don't want to autolink something that is already linked inside of an <a> tag, for instance\n      matches = [];\n    // Find all matches within the `textOrHtml` (but not matches that are\n    // already nested within <a>, <style> and <script> tags)\n    parseHtml(textOrHtml, {\n      onOpenTag: function (tagName) {\n        if (skipTagNames.indexOf(tagName) >= 0) {\n          skipTagsStackCount++;\n        }\n      },\n      onText: function (text, offset) {\n        // Only process text nodes that are not within an <a>, <style> or <script> tag\n        if (skipTagsStackCount === 0) {\n          // \"Walk around\" common HTML entities. An '&nbsp;' (for example)\n          // could be at the end of a URL, but we don't want to\n          // include the trailing '&' in the URL. See issue #76\n          // TODO: Handle HTML entities separately in parseHtml() and\n          // don't emit them as \"text\" except for &amp; entities\n          var htmlCharacterEntitiesRegex = /(&nbsp;|&#160;|&lt;|&#60;|&gt;|&#62;|&quot;|&#34;|&#39;)/gi;\n          var textSplit = splitAndCapture(text, htmlCharacterEntitiesRegex);\n          var currentOffset_1 = offset;\n          textSplit.forEach(function (splitText, i) {\n            // even number matches are text, odd numbers are html entities\n            if (i % 2 === 0) {\n              var textNodeMatches = _this.parseText(splitText, currentOffset_1);\n              matches.push.apply(matches, textNodeMatches);\n            }\n            currentOffset_1 += splitText.length;\n          });\n        }\n      },\n      onCloseTag: function (tagName) {\n        if (skipTagNames.indexOf(tagName) >= 0) {\n          skipTagsStackCount = Math.max(skipTagsStackCount - 1, 0); // attempt to handle extraneous </a> tags by making sure the stack count never goes below 0\n        }\n      },\n      onComment: function (offset) {},\n      onDoctype: function (offset) {} // no need to process doctype nodes\n    });\n    // After we have found all matches, remove subsequent matches that\n    // overlap with a previous match. This can happen for instance with URLs,\n    // where the url 'google.com/#link' would match '#link' as a hashtag.\n    matches = this.compactMatches(matches);\n    // And finally, remove matches for match types that have been turned\n    // off. We needed to have all match types turned on initially so that\n    // things like hashtags could be filtered out if they were really just\n    // part of a URL match (for instance, as a named anchor).\n    matches = this.removeUnwantedMatches(matches);\n    return matches;\n  };\n  /**\n   * After we have found all matches, we need to remove matches that overlap\n   * with a previous match. This can happen for instance with URLs, where the\n   * url 'google.com/#link' would match '#link' as a hashtag. Because the\n   * '#link' part is contained in a larger match that comes before the HashTag\n   * match, we'll remove the HashTag match.\n   *\n   * @private\n   * @param {Autolinker.match.Match[]} matches\n   * @return {Autolinker.match.Match[]}\n   */\n  Autolinker.prototype.compactMatches = function (matches) {\n    // First, the matches need to be sorted in order of offset\n    matches.sort(function (a, b) {\n      return a.getOffset() - b.getOffset();\n    });\n    var i = 0;\n    while (i < matches.length - 1) {\n      var match = matches[i],\n        offset = match.getOffset(),\n        matchedTextLength = match.getMatchedText().length,\n        endIdx = offset + matchedTextLength;\n      if (i + 1 < matches.length) {\n        // Remove subsequent matches that equal offset with current match\n        if (matches[i + 1].getOffset() === offset) {\n          var removeIdx = matches[i + 1].getMatchedText().length > matchedTextLength ? i : i + 1;\n          matches.splice(removeIdx, 1);\n          continue;\n        }\n        // Remove subsequent matches that overlap with the current match\n        if (matches[i + 1].getOffset() < endIdx) {\n          matches.splice(i + 1, 1);\n          continue;\n        }\n      }\n      i++;\n    }\n    return matches;\n  };\n  /**\n   * Removes matches for matchers that were turned off in the options. For\n   * example, if {@link #hashtag hashtags} were not to be matched, we'll\n   * remove them from the `matches` array here.\n   *\n   * Note: we *must* use all Matchers on the input string, and then filter\n   * them out later. For example, if the options were `{ url: false, hashtag: true }`,\n   * we wouldn't want to match the text '#link' as a HashTag inside of the text\n   * 'google.com/#link'. The way the algorithm works is that we match the full\n   * URL first (which prevents the accidental HashTag match), and then we'll\n   * simply throw away the URL match.\n   *\n   * @private\n   * @param {Autolinker.match.Match[]} matches The array of matches to remove\n   *   the unwanted matches from. Note: this array is mutated for the\n   *   removals.\n   * @return {Autolinker.match.Match[]} The mutated input `matches` array.\n   */\n  Autolinker.prototype.removeUnwantedMatches = function (matches) {\n    if (!this.hashtag) remove(matches, function (match) {\n      return match.getType() === 'hashtag';\n    });\n    if (!this.email) remove(matches, function (match) {\n      return match.getType() === 'email';\n    });\n    if (!this.phone) remove(matches, function (match) {\n      return match.getType() === 'phone';\n    });\n    if (!this.mention) remove(matches, function (match) {\n      return match.getType() === 'mention';\n    });\n    if (!this.urls.schemeMatches) {\n      remove(matches, function (m) {\n        return m.getType() === 'url' && m.getUrlMatchType() === 'scheme';\n      });\n    }\n    if (!this.urls.wwwMatches) {\n      remove(matches, function (m) {\n        return m.getType() === 'url' && m.getUrlMatchType() === 'www';\n      });\n    }\n    if (!this.urls.tldMatches) {\n      remove(matches, function (m) {\n        return m.getType() === 'url' && m.getUrlMatchType() === 'tld';\n      });\n    }\n    return matches;\n  };\n  /**\n   * Parses the input `text` looking for URLs, email addresses, phone\n   * numbers, username handles, and hashtags (depending on the configuration\n   * of the Autolinker instance), and returns an array of {@link Autolinker.match.Match}\n   * objects describing those matches.\n   *\n   * This method processes a **non-HTML string**, and is used to parse and\n   * match within the text nodes of an HTML string. This method is used\n   * internally by {@link #parse}.\n   *\n   * @private\n   * @param {String} text The text to find matches within (depending on if the\n   *   {@link #urls}, {@link #email}, {@link #phone},\n   *   {@link #hashtag}, and {@link #mention} options are enabled). This must be a non-HTML string.\n   * @param {Number} [offset=0] The offset of the text node within the\n   *   original string. This is used when parsing with the {@link #parse}\n   *   method to generate correct offsets within the {@link Autolinker.match.Match}\n   *   instances, but may be omitted if calling this method publicly.\n   * @return {Autolinker.match.Match[]} The array of Matches found in the\n   *   given input `text`.\n   */\n  Autolinker.prototype.parseText = function (text, offset) {\n    if (offset === void 0) {\n      offset = 0;\n    }\n    offset = offset || 0;\n    var matchers = this.getMatchers(),\n      matches = [];\n    for (var i = 0, numMatchers = matchers.length; i < numMatchers; i++) {\n      var textMatches = matchers[i].parseMatches(text);\n      // Correct the offset of each of the matches. They are originally\n      // the offset of the match within the provided text node, but we\n      // need to correct them to be relative to the original HTML input\n      // string (i.e. the one provided to #parse).\n      for (var j = 0, numTextMatches = textMatches.length; j < numTextMatches; j++) {\n        textMatches[j].setOffset(offset + textMatches[j].getOffset());\n      }\n      matches.push.apply(matches, textMatches);\n    }\n    return matches;\n  };\n  /**\n   * Automatically links URLs, Email addresses, Phone numbers, Hashtags,\n   * and Mentions (Twitter, Instagram, Soundcloud) found in the given chunk of HTML. Does not link\n   * URLs found within HTML tags.\n   *\n   * For instance, if given the text: `You should go to http://www.yahoo.com`,\n   * then the result will be `You should go to\n   * &lt;a href=\"http://www.yahoo.com\"&gt;http://www.yahoo.com&lt;/a&gt;`\n   *\n   * This method finds the text around any HTML elements in the input\n   * `textOrHtml`, which will be the text that is processed. Any original HTML\n   * elements will be left as-is, as well as the text that is already wrapped\n   * in anchor (&lt;a&gt;) tags.\n   *\n   * @param {String} textOrHtml The HTML or text to autolink matches within\n   *   (depending on if the {@link #urls}, {@link #email}, {@link #phone}, {@link #hashtag}, and {@link #mention} options are enabled).\n   * @return {String} The HTML, with matches automatically linked.\n   */\n  Autolinker.prototype.link = function (textOrHtml) {\n    if (!textOrHtml) {\n      return '';\n    } // handle `null` and `undefined` (for JavaScript users that don't have TypeScript support)\n    /* We would want to sanitize the start and end characters of a tag\n     * before processing the string in order to avoid an XSS scenario.\n     * This behaviour can be changed by toggling the sanitizeHtml option.\n     */\n    if (this.sanitizeHtml) {\n      textOrHtml = textOrHtml.replace(/</g, '&lt;').replace(/>/g, '&gt;');\n    }\n    var matches = this.parse(textOrHtml),\n      newHtml = [],\n      lastIndex = 0;\n    for (var i = 0, len = matches.length; i < len; i++) {\n      var match = matches[i];\n      newHtml.push(textOrHtml.substring(lastIndex, match.getOffset()));\n      newHtml.push(this.createMatchReturnVal(match));\n      lastIndex = match.getOffset() + match.getMatchedText().length;\n    }\n    newHtml.push(textOrHtml.substring(lastIndex)); // handle the text after the last match\n    return newHtml.join('');\n  };\n  /**\n   * Creates the return string value for a given match in the input string.\n   *\n   * This method handles the {@link #replaceFn}, if one was provided.\n   *\n   * @private\n   * @param {Autolinker.match.Match} match The Match object that represents\n   *   the match.\n   * @return {String} The string that the `match` should be replaced with.\n   *   This is usually the anchor tag string, but may be the `matchStr` itself\n   *   if the match is not to be replaced.\n   */\n  Autolinker.prototype.createMatchReturnVal = function (match) {\n    // Handle a custom `replaceFn` being provided\n    var replaceFnResult;\n    if (this.replaceFn) {\n      replaceFnResult = this.replaceFn.call(this.context, match); // Autolinker instance is the context\n    }\n    if (typeof replaceFnResult === 'string') {\n      return replaceFnResult; // `replaceFn` returned a string, use that\n    } else if (replaceFnResult === false) {\n      return match.getMatchedText(); // no replacement for the match\n    } else if (replaceFnResult instanceof HtmlTag) {\n      return replaceFnResult.toAnchorString();\n    } else {\n      // replaceFnResult === true, or no/unknown return value from function\n      // Perform Autolinker's default anchor tag generation\n      var anchorTag = match.buildTag(); // returns an Autolinker.HtmlTag instance\n      return anchorTag.toAnchorString();\n    }\n  };\n  /**\n   * Lazily instantiates and returns the {@link Autolinker.matcher.Matcher}\n   * instances for this Autolinker instance.\n   *\n   * @private\n   * @return {Autolinker.matcher.Matcher[]}\n   */\n  Autolinker.prototype.getMatchers = function () {\n    if (!this.matchers) {\n      var tagBuilder = this.getTagBuilder();\n      var matchers = [new HashtagMatcher({\n        tagBuilder: tagBuilder,\n        serviceName: this.hashtag\n      }), new EmailMatcher({\n        tagBuilder: tagBuilder\n      }), new PhoneMatcher({\n        tagBuilder: tagBuilder\n      }), new MentionMatcher({\n        tagBuilder: tagBuilder,\n        serviceName: this.mention\n      }), new UrlMatcher({\n        tagBuilder: tagBuilder,\n        stripPrefix: this.stripPrefix,\n        stripTrailingSlash: this.stripTrailingSlash,\n        decodePercentEncoding: this.decodePercentEncoding\n      })];\n      return this.matchers = matchers;\n    } else {\n      return this.matchers;\n    }\n  };\n  /**\n   * Returns the {@link #tagBuilder} instance for this Autolinker instance,\n   * lazily instantiating it if it does not yet exist.\n   *\n   * @private\n   * @return {Autolinker.AnchorTagBuilder}\n   */\n  Autolinker.prototype.getTagBuilder = function () {\n    var tagBuilder = this.tagBuilder;\n    if (!tagBuilder) {\n      tagBuilder = this.tagBuilder = new AnchorTagBuilder({\n        newWindow: this.newWindow,\n        truncate: this.truncate,\n        className: this.className\n      });\n    }\n    return tagBuilder;\n  };\n  // NOTE: must be 'export default' here for UMD module\n  /**\n   * @static\n   * @property {String} version\n   *\n   * The Autolinker version number in the form major.minor.patch\n   *\n   * Ex: 3.15.0\n   */\n  Autolinker.version = version;\n  /**\n   * For backwards compatibility with Autolinker 1.x, the AnchorTagBuilder\n   * class is provided as a static on the Autolinker class.\n   */\n  Autolinker.AnchorTagBuilder = AnchorTagBuilder;\n  /**\n   * For backwards compatibility with Autolinker 1.x, the HtmlTag class is\n   * provided as a static on the Autolinker class.\n   */\n  Autolinker.HtmlTag = HtmlTag;\n  /**\n   * For backwards compatibility with Autolinker 1.x, the Matcher classes are\n   * provided as statics on the Autolinker class.\n   */\n  Autolinker.matcher = {\n    Email: EmailMatcher,\n    Hashtag: HashtagMatcher,\n    Matcher: Matcher,\n    Mention: MentionMatcher,\n    Phone: PhoneMatcher,\n    Url: UrlMatcher\n  };\n  /**\n   * For backwards compatibility with Autolinker 1.x, the Match classes are\n   * provided as statics on the Autolinker class.\n   */\n  Autolinker.match = {\n    Email: EmailMatch,\n    Hashtag: HashtagMatch,\n    Match: Match,\n    Mention: MentionMatch,\n    Phone: PhoneMatch,\n    Url: UrlMatch\n  };\n  return Autolinker;\n}();\nexport default Autolinker;","// Important: this file is generated from the 'build' script and should not be\n// edited directly\nexport var version = '3.16.2';","// WARNING: This file is modified a bit when it is compiled into index.js in\n// order to support nodejs interoperability with require('autolinker') directly.\n// This is done by the buildSrcFixCommonJsIndexTask() function in the gulpfile.\n// See that function for more details.\nimport Autolinker from './autolinker';\nexport default Autolinker;\nexport { Autolinker };\nexport * from './autolinker';\nexport * from './anchor-tag-builder';\nexport * from './html-tag';\nexport * from './match/index';\nexport * from './matcher/index';","function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\nfunction _iterableToArrayLimit(r, l) { var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\nimport React, { useState, useCallback } from 'react';\nconst hiddenStyles = {\n  display: 'none'\n};\nfunction HiddenText(_ref) {\n  let id = _ref.id,\n    value = _ref.value;\n  return /*#__PURE__*/React.createElement(\"div\", {\n    id: id,\n    style: hiddenStyles\n  }, value);\n}\nfunction LiveRegion(_ref) {\n  let id = _ref.id,\n    announcement = _ref.announcement,\n    _ref$ariaLiveType = _ref.ariaLiveType,\n    ariaLiveType = _ref$ariaLiveType === void 0 ? \"assertive\" : _ref$ariaLiveType;\n  // Hide element visually but keep it readable by screen readers\n  const visuallyHidden = {\n    position: 'fixed',\n    width: 1,\n    height: 1,\n    margin: -1,\n    border: 0,\n    padding: 0,\n    overflow: 'hidden',\n    clip: 'rect(0 0 0 0)',\n    clipPath: 'inset(100%)',\n    whiteSpace: 'nowrap'\n  };\n  return /*#__PURE__*/React.createElement(\"div\", {\n    id: id,\n    style: visuallyHidden,\n    role: \"status\",\n    \"aria-live\": ariaLiveType,\n    \"aria-atomic\": true\n  }, announcement);\n}\nfunction useAnnouncement() {\n  const _useState = useState(''),\n    _useState2 = _slicedToArray(_useState, 2),\n    announcement = _useState2[0],\n    setAnnouncement = _useState2[1];\n  const announce = useCallback(value => {\n    if (value != null) {\n      setAnnouncement(value);\n    }\n  }, []);\n  return {\n    announce,\n    announcement\n  };\n}\nexport { HiddenText, LiveRegion, useAnnouncement };","const _excluded = [\"transform\"],\n  _excluded2 = [\"id\", \"accessibility\", \"autoScroll\", \"children\", \"sensors\", \"collisionDetection\", \"measuring\", \"modifiers\"],\n  _excluded3 = [\"active\", \"dragOverlay\", \"transform\"];\nfunction _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : i + \"\"; }\nfunction _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\nfunction _iterableToArrayLimit(r, l) { var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\nimport React, { createContext, useContext, useEffect, useState, useCallback, useMemo, useRef, useReducer, memo, cloneElement, forwardRef } from 'react';\nimport { createPortal, unstable_batchedUpdates } from 'react-dom';\nimport { useUniqueId, getEventCoordinates, getWindow, isDocument, isHTMLElement, isSVGElement, canUseDOM, isWindow, isNode, getOwnerDocument, add, isKeyboardEvent, subtract, useLazyMemo, useInterval, usePrevious, useLatestValue, useEvent, useIsomorphicLayoutEffect, useNodeRef, findFirstFocusableNode, CSS } from '@dnd-kit/utilities';\nimport { useAnnouncement, HiddenText, LiveRegion } from '@dnd-kit/accessibility';\nconst DndMonitorContext = /*#__PURE__*/createContext(null);\nfunction useDndMonitor(listener) {\n  const registerListener = useContext(DndMonitorContext);\n  useEffect(() => {\n    if (!registerListener) {\n      throw new Error('useDndMonitor must be used within a children of <DndContext>');\n    }\n    const unsubscribe = registerListener(listener);\n    return unsubscribe;\n  }, [listener, registerListener]);\n}\nfunction useDndMonitorProvider() {\n  const _useState = useState(() => new Set()),\n    _useState2 = _slicedToArray(_useState, 1),\n    listeners = _useState2[0];\n  const registerListener = useCallback(listener => {\n    listeners.add(listener);\n    return () => listeners.delete(listener);\n  }, [listeners]);\n  const dispatch = useCallback(_ref => {\n    let type = _ref.type,\n      event = _ref.event;\n    listeners.forEach(listener => {\n      var _listener$type;\n      return (_listener$type = listener[type]) == null ? void 0 : _listener$type.call(listener, event);\n    });\n  }, [listeners]);\n  return [dispatch, registerListener];\n}\nconst defaultScreenReaderInstructions = {\n  draggable: \"\\n    To pick up a draggable item, press the space bar.\\n    While dragging, use the arrow keys to move the item.\\n    Press space again to drop the item in its new position, or press escape to cancel.\\n  \"\n};\nconst defaultAnnouncements = {\n  onDragStart(_ref) {\n    let active = _ref.active;\n    return \"Picked up draggable item \" + active.id + \".\";\n  },\n  onDragOver(_ref2) {\n    let active = _ref2.active,\n      over = _ref2.over;\n    if (over) {\n      return \"Draggable item \" + active.id + \" was moved over droppable area \" + over.id + \".\";\n    }\n    return \"Draggable item \" + active.id + \" is no longer over a droppable area.\";\n  },\n  onDragEnd(_ref3) {\n    let active = _ref3.active,\n      over = _ref3.over;\n    if (over) {\n      return \"Draggable item \" + active.id + \" was dropped over droppable area \" + over.id;\n    }\n    return \"Draggable item \" + active.id + \" was dropped.\";\n  },\n  onDragCancel(_ref4) {\n    let active = _ref4.active;\n    return \"Dragging was cancelled. Draggable item \" + active.id + \" was dropped.\";\n  }\n};\nfunction Accessibility(_ref) {\n  let _ref$announcements = _ref.announcements,\n    announcements = _ref$announcements === void 0 ? defaultAnnouncements : _ref$announcements,\n    container = _ref.container,\n    hiddenTextDescribedById = _ref.hiddenTextDescribedById,\n    _ref$screenReaderInst = _ref.screenReaderInstructions,\n    screenReaderInstructions = _ref$screenReaderInst === void 0 ? defaultScreenReaderInstructions : _ref$screenReaderInst;\n  const _useAnnouncement = useAnnouncement(),\n    announce = _useAnnouncement.announce,\n    announcement = _useAnnouncement.announcement;\n  const liveRegionId = useUniqueId(\"DndLiveRegion\");\n  const _useState3 = useState(false),\n    _useState4 = _slicedToArray(_useState3, 2),\n    mounted = _useState4[0],\n    setMounted = _useState4[1];\n  useEffect(() => {\n    setMounted(true);\n  }, []);\n  useDndMonitor(useMemo(() => ({\n    onDragStart(_ref2) {\n      let active = _ref2.active;\n      announce(announcements.onDragStart({\n        active\n      }));\n    },\n    onDragMove(_ref3) {\n      let active = _ref3.active,\n        over = _ref3.over;\n      if (announcements.onDragMove) {\n        announce(announcements.onDragMove({\n          active,\n          over\n        }));\n      }\n    },\n    onDragOver(_ref4) {\n      let active = _ref4.active,\n        over = _ref4.over;\n      announce(announcements.onDragOver({\n        active,\n        over\n      }));\n    },\n    onDragEnd(_ref5) {\n      let active = _ref5.active,\n        over = _ref5.over;\n      announce(announcements.onDragEnd({\n        active,\n        over\n      }));\n    },\n    onDragCancel(_ref6) {\n      let active = _ref6.active,\n        over = _ref6.over;\n      announce(announcements.onDragCancel({\n        active,\n        over\n      }));\n    }\n  }), [announce, announcements]));\n  if (!mounted) {\n    return null;\n  }\n  const markup = /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(HiddenText, {\n    id: hiddenTextDescribedById,\n    value: screenReaderInstructions.draggable\n  }), /*#__PURE__*/React.createElement(LiveRegion, {\n    id: liveRegionId,\n    announcement: announcement\n  }));\n  return container ? /*#__PURE__*/createPortal(markup, container) : markup;\n}\nvar Action;\n(function (Action) {\n  Action[\"DragStart\"] = \"dragStart\";\n  Action[\"DragMove\"] = \"dragMove\";\n  Action[\"DragEnd\"] = \"dragEnd\";\n  Action[\"DragCancel\"] = \"dragCancel\";\n  Action[\"DragOver\"] = \"dragOver\";\n  Action[\"RegisterDroppable\"] = \"registerDroppable\";\n  Action[\"SetDroppableDisabled\"] = \"setDroppableDisabled\";\n  Action[\"UnregisterDroppable\"] = \"unregisterDroppable\";\n})(Action || (Action = {}));\nfunction noop() {}\nfunction useSensor(sensor, options) {\n  return useMemo(() => ({\n    sensor,\n    options: options != null ? options : {}\n  }),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [sensor, options]);\n}\nfunction useSensors() {\n  for (var _len = arguments.length, sensors = new Array(_len), _key = 0; _key < _len; _key++) {\n    sensors[_key] = arguments[_key];\n  }\n  return useMemo(() => [...sensors].filter(sensor => sensor != null),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [...sensors]);\n}\nconst defaultCoordinates = /*#__PURE__*/Object.freeze({\n  x: 0,\n  y: 0\n});\n\n/**\r\n * Returns the distance between two points\r\n */\nfunction distanceBetween(p1, p2) {\n  return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));\n}\nfunction getRelativeTransformOrigin(event, rect) {\n  const eventCoordinates = getEventCoordinates(event);\n  if (!eventCoordinates) {\n    return '0 0';\n  }\n  const transformOrigin = {\n    x: (eventCoordinates.x - rect.left) / rect.width * 100,\n    y: (eventCoordinates.y - rect.top) / rect.height * 100\n  };\n  return transformOrigin.x + \"% \" + transformOrigin.y + \"%\";\n}\n\n/**\r\n * Sort collisions from smallest to greatest value\r\n */\nfunction sortCollisionsAsc(_ref, _ref2) {\n  let a = _ref.data.value;\n  let b = _ref2.data.value;\n  return a - b;\n}\n/**\r\n * Sort collisions from greatest to smallest value\r\n */\n\nfunction sortCollisionsDesc(_ref3, _ref4) {\n  let a = _ref3.data.value;\n  let b = _ref4.data.value;\n  return b - a;\n}\n/**\r\n * Returns the coordinates of the corners of a given rectangle:\r\n * [TopLeft {x, y}, TopRight {x, y}, BottomLeft {x, y}, BottomRight {x, y}]\r\n */\n\nfunction cornersOfRectangle(_ref5) {\n  let left = _ref5.left,\n    top = _ref5.top,\n    height = _ref5.height,\n    width = _ref5.width;\n  return [{\n    x: left,\n    y: top\n  }, {\n    x: left + width,\n    y: top\n  }, {\n    x: left,\n    y: top + height\n  }, {\n    x: left + width,\n    y: top + height\n  }];\n}\nfunction getFirstCollision(collisions, property) {\n  if (!collisions || collisions.length === 0) {\n    return null;\n  }\n  const _collisions = _slicedToArray(collisions, 1),\n    firstCollision = _collisions[0];\n  return property ? firstCollision[property] : firstCollision;\n}\n\n/**\r\n * Returns the coordinates of the center of a given ClientRect\r\n */\n\nfunction centerOfRectangle(rect, left, top) {\n  if (left === void 0) {\n    left = rect.left;\n  }\n  if (top === void 0) {\n    top = rect.top;\n  }\n  return {\n    x: left + rect.width * 0.5,\n    y: top + rect.height * 0.5\n  };\n}\n/**\r\n * Returns the closest rectangles from an array of rectangles to the center of a given\r\n * rectangle.\r\n */\n\nconst closestCenter = _ref => {\n  let collisionRect = _ref.collisionRect,\n    droppableRects = _ref.droppableRects,\n    droppableContainers = _ref.droppableContainers;\n  const centerRect = centerOfRectangle(collisionRect, collisionRect.left, collisionRect.top);\n  const collisions = [];\n  for (const droppableContainer of droppableContainers) {\n    const id = droppableContainer.id;\n    const rect = droppableRects.get(id);\n    if (rect) {\n      const distBetween = distanceBetween(centerOfRectangle(rect), centerRect);\n      collisions.push({\n        id,\n        data: {\n          droppableContainer,\n          value: distBetween\n        }\n      });\n    }\n  }\n  return collisions.sort(sortCollisionsAsc);\n};\n\n/**\r\n * Returns the closest rectangles from an array of rectangles to the corners of\r\n * another rectangle.\r\n */\n\nconst closestCorners = _ref => {\n  let collisionRect = _ref.collisionRect,\n    droppableRects = _ref.droppableRects,\n    droppableContainers = _ref.droppableContainers;\n  const corners = cornersOfRectangle(collisionRect);\n  const collisions = [];\n  for (const droppableContainer of droppableContainers) {\n    const id = droppableContainer.id;\n    const rect = droppableRects.get(id);\n    if (rect) {\n      const rectCorners = cornersOfRectangle(rect);\n      const distances = corners.reduce((accumulator, corner, index) => {\n        return accumulator + distanceBetween(rectCorners[index], corner);\n      }, 0);\n      const effectiveDistance = Number((distances / 4).toFixed(4));\n      collisions.push({\n        id,\n        data: {\n          droppableContainer,\n          value: effectiveDistance\n        }\n      });\n    }\n  }\n  return collisions.sort(sortCollisionsAsc);\n};\n\n/**\r\n * Returns the intersecting rectangle area between two rectangles\r\n */\n\nfunction getIntersectionRatio(entry, target) {\n  const top = Math.max(target.top, entry.top);\n  const left = Math.max(target.left, entry.left);\n  const right = Math.min(target.left + target.width, entry.left + entry.width);\n  const bottom = Math.min(target.top + target.height, entry.top + entry.height);\n  const width = right - left;\n  const height = bottom - top;\n  if (left < right && top < bottom) {\n    const targetArea = target.width * target.height;\n    const entryArea = entry.width * entry.height;\n    const intersectionArea = width * height;\n    const intersectionRatio = intersectionArea / (targetArea + entryArea - intersectionArea);\n    return Number(intersectionRatio.toFixed(4));\n  } // Rectangles do not overlap, or overlap has an area of zero (edge/corner overlap)\n\n  return 0;\n}\n/**\r\n * Returns the rectangles that has the greatest intersection area with a given\r\n * rectangle in an array of rectangles.\r\n */\n\nconst rectIntersection = _ref => {\n  let collisionRect = _ref.collisionRect,\n    droppableRects = _ref.droppableRects,\n    droppableContainers = _ref.droppableContainers;\n  const collisions = [];\n  for (const droppableContainer of droppableContainers) {\n    const id = droppableContainer.id;\n    const rect = droppableRects.get(id);\n    if (rect) {\n      const intersectionRatio = getIntersectionRatio(rect, collisionRect);\n      if (intersectionRatio > 0) {\n        collisions.push({\n          id,\n          data: {\n            droppableContainer,\n            value: intersectionRatio\n          }\n        });\n      }\n    }\n  }\n  return collisions.sort(sortCollisionsDesc);\n};\n\n/**\r\n * Check if a given point is contained within a bounding rectangle\r\n */\n\nfunction isPointWithinRect(point, rect) {\n  const top = rect.top,\n    left = rect.left,\n    bottom = rect.bottom,\n    right = rect.right;\n  return top <= point.y && point.y <= bottom && left <= point.x && point.x <= right;\n}\n/**\r\n * Returns the rectangles that the pointer is hovering over\r\n */\n\nconst pointerWithin = _ref => {\n  let droppableContainers = _ref.droppableContainers,\n    droppableRects = _ref.droppableRects,\n    pointerCoordinates = _ref.pointerCoordinates;\n  if (!pointerCoordinates) {\n    return [];\n  }\n  const collisions = [];\n  for (const droppableContainer of droppableContainers) {\n    const id = droppableContainer.id;\n    const rect = droppableRects.get(id);\n    if (rect && isPointWithinRect(pointerCoordinates, rect)) {\n      /* There may be more than a single rectangle intersecting\r\n       * with the pointer coordinates. In order to sort the\r\n       * colliding rectangles, we measure the distance between\r\n       * the pointer and the corners of the intersecting rectangle\r\n       */\n      const corners = cornersOfRectangle(rect);\n      const distances = corners.reduce((accumulator, corner) => {\n        return accumulator + distanceBetween(pointerCoordinates, corner);\n      }, 0);\n      const effectiveDistance = Number((distances / 4).toFixed(4));\n      collisions.push({\n        id,\n        data: {\n          droppableContainer,\n          value: effectiveDistance\n        }\n      });\n    }\n  }\n  return collisions.sort(sortCollisionsAsc);\n};\nfunction adjustScale(transform, rect1, rect2) {\n  return _objectSpread(_objectSpread({}, transform), {}, {\n    scaleX: rect1 && rect2 ? rect1.width / rect2.width : 1,\n    scaleY: rect1 && rect2 ? rect1.height / rect2.height : 1\n  });\n}\nfunction getRectDelta(rect1, rect2) {\n  return rect1 && rect2 ? {\n    x: rect1.left - rect2.left,\n    y: rect1.top - rect2.top\n  } : defaultCoordinates;\n}\nfunction createRectAdjustmentFn(modifier) {\n  return function adjustClientRect(rect) {\n    for (var _len = arguments.length, adjustments = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      adjustments[_key - 1] = arguments[_key];\n    }\n    return adjustments.reduce((acc, adjustment) => _objectSpread(_objectSpread({}, acc), {}, {\n      top: acc.top + modifier * adjustment.y,\n      bottom: acc.bottom + modifier * adjustment.y,\n      left: acc.left + modifier * adjustment.x,\n      right: acc.right + modifier * adjustment.x\n    }), _objectSpread({}, rect));\n  };\n}\nconst getAdjustedRect = /*#__PURE__*/createRectAdjustmentFn(1);\nfunction parseTransform(transform) {\n  if (transform.startsWith('matrix3d(')) {\n    const transformArray = transform.slice(9, -1).split(/, /);\n    return {\n      x: +transformArray[12],\n      y: +transformArray[13],\n      scaleX: +transformArray[0],\n      scaleY: +transformArray[5]\n    };\n  } else if (transform.startsWith('matrix(')) {\n    const transformArray = transform.slice(7, -1).split(/, /);\n    return {\n      x: +transformArray[4],\n      y: +transformArray[5],\n      scaleX: +transformArray[0],\n      scaleY: +transformArray[3]\n    };\n  }\n  return null;\n}\nfunction inverseTransform(rect, transform, transformOrigin) {\n  const parsedTransform = parseTransform(transform);\n  if (!parsedTransform) {\n    return rect;\n  }\n  const scaleX = parsedTransform.scaleX,\n    scaleY = parsedTransform.scaleY,\n    translateX = parsedTransform.x,\n    translateY = parsedTransform.y;\n  const x = rect.left - translateX - (1 - scaleX) * parseFloat(transformOrigin);\n  const y = rect.top - translateY - (1 - scaleY) * parseFloat(transformOrigin.slice(transformOrigin.indexOf(' ') + 1));\n  const w = scaleX ? rect.width / scaleX : rect.width;\n  const h = scaleY ? rect.height / scaleY : rect.height;\n  return {\n    width: w,\n    height: h,\n    top: y,\n    right: x + w,\n    bottom: y + h,\n    left: x\n  };\n}\nconst defaultOptions = {\n  ignoreTransform: false\n};\n/**\r\n * Returns the bounding client rect of an element relative to the viewport.\r\n */\n\nfunction getClientRect(element, options) {\n  if (options === void 0) {\n    options = defaultOptions;\n  }\n  let rect = element.getBoundingClientRect();\n  if (options.ignoreTransform) {\n    const _getWindow$getCompute = getWindow(element).getComputedStyle(element),\n      transform = _getWindow$getCompute.transform,\n      transformOrigin = _getWindow$getCompute.transformOrigin;\n    if (transform) {\n      rect = inverseTransform(rect, transform, transformOrigin);\n    }\n  }\n  const _rect = rect,\n    top = _rect.top,\n    left = _rect.left,\n    width = _rect.width,\n    height = _rect.height,\n    bottom = _rect.bottom,\n    right = _rect.right;\n  return {\n    top,\n    left,\n    width,\n    height,\n    bottom,\n    right\n  };\n}\n/**\r\n * Returns the bounding client rect of an element relative to the viewport.\r\n *\r\n * @remarks\r\n * The ClientRect returned by this method does not take into account transforms\r\n * applied to the element it measures.\r\n *\r\n */\n\nfunction getTransformAgnosticClientRect(element) {\n  return getClientRect(element, {\n    ignoreTransform: true\n  });\n}\nfunction getWindowClientRect(element) {\n  const width = element.innerWidth;\n  const height = element.innerHeight;\n  return {\n    top: 0,\n    left: 0,\n    right: width,\n    bottom: height,\n    width,\n    height\n  };\n}\nfunction isFixed(node, computedStyle) {\n  if (computedStyle === void 0) {\n    computedStyle = getWindow(node).getComputedStyle(node);\n  }\n  return computedStyle.position === 'fixed';\n}\nfunction isScrollable(element, computedStyle) {\n  if (computedStyle === void 0) {\n    computedStyle = getWindow(element).getComputedStyle(element);\n  }\n  const overflowRegex = /(auto|scroll|overlay)/;\n  const properties = ['overflow', 'overflowX', 'overflowY'];\n  return properties.some(property => {\n    const value = computedStyle[property];\n    return typeof value === 'string' ? overflowRegex.test(value) : false;\n  });\n}\nfunction getScrollableAncestors(element, limit) {\n  const scrollParents = [];\n  function findScrollableAncestors(node) {\n    if (limit != null && scrollParents.length >= limit) {\n      return scrollParents;\n    }\n    if (!node) {\n      return scrollParents;\n    }\n    if (isDocument(node) && node.scrollingElement != null && !scrollParents.includes(node.scrollingElement)) {\n      scrollParents.push(node.scrollingElement);\n      return scrollParents;\n    }\n    if (!isHTMLElement(node) || isSVGElement(node)) {\n      return scrollParents;\n    }\n    if (scrollParents.includes(node)) {\n      return scrollParents;\n    }\n    const computedStyle = getWindow(element).getComputedStyle(node);\n    if (node !== element) {\n      if (isScrollable(node, computedStyle)) {\n        scrollParents.push(node);\n      }\n    }\n    if (isFixed(node, computedStyle)) {\n      return scrollParents;\n    }\n    return findScrollableAncestors(node.parentNode);\n  }\n  if (!element) {\n    return scrollParents;\n  }\n  return findScrollableAncestors(element);\n}\nfunction getFirstScrollableAncestor(node) {\n  const _getScrollableAncesto = getScrollableAncestors(node, 1),\n    _getScrollableAncesto2 = _slicedToArray(_getScrollableAncesto, 1),\n    firstScrollableAncestor = _getScrollableAncesto2[0];\n  return firstScrollableAncestor != null ? firstScrollableAncestor : null;\n}\nfunction getScrollableElement(element) {\n  if (!canUseDOM || !element) {\n    return null;\n  }\n  if (isWindow(element)) {\n    return element;\n  }\n  if (!isNode(element)) {\n    return null;\n  }\n  if (isDocument(element) || element === getOwnerDocument(element).scrollingElement) {\n    return window;\n  }\n  if (isHTMLElement(element)) {\n    return element;\n  }\n  return null;\n}\nfunction getScrollXCoordinate(element) {\n  if (isWindow(element)) {\n    return element.scrollX;\n  }\n  return element.scrollLeft;\n}\nfunction getScrollYCoordinate(element) {\n  if (isWindow(element)) {\n    return element.scrollY;\n  }\n  return element.scrollTop;\n}\nfunction getScrollCoordinates(element) {\n  return {\n    x: getScrollXCoordinate(element),\n    y: getScrollYCoordinate(element)\n  };\n}\nvar Direction;\n(function (Direction) {\n  Direction[Direction[\"Forward\"] = 1] = \"Forward\";\n  Direction[Direction[\"Backward\"] = -1] = \"Backward\";\n})(Direction || (Direction = {}));\nfunction isDocumentScrollingElement(element) {\n  if (!canUseDOM || !element) {\n    return false;\n  }\n  return element === document.scrollingElement;\n}\nfunction getScrollPosition(scrollingContainer) {\n  const minScroll = {\n    x: 0,\n    y: 0\n  };\n  const dimensions = isDocumentScrollingElement(scrollingContainer) ? {\n    height: window.innerHeight,\n    width: window.innerWidth\n  } : {\n    height: scrollingContainer.clientHeight,\n    width: scrollingContainer.clientWidth\n  };\n  const maxScroll = {\n    x: scrollingContainer.scrollWidth - dimensions.width,\n    y: scrollingContainer.scrollHeight - dimensions.height\n  };\n  const isTop = scrollingContainer.scrollTop <= minScroll.y;\n  const isLeft = scrollingContainer.scrollLeft <= minScroll.x;\n  const isBottom = scrollingContainer.scrollTop >= maxScroll.y;\n  const isRight = scrollingContainer.scrollLeft >= maxScroll.x;\n  return {\n    isTop,\n    isLeft,\n    isBottom,\n    isRight,\n    maxScroll,\n    minScroll\n  };\n}\nconst defaultThreshold = {\n  x: 0.2,\n  y: 0.2\n};\nfunction getScrollDirectionAndSpeed(scrollContainer, scrollContainerRect, _ref, acceleration, thresholdPercentage) {\n  let top = _ref.top,\n    left = _ref.left,\n    right = _ref.right,\n    bottom = _ref.bottom;\n  if (acceleration === void 0) {\n    acceleration = 10;\n  }\n  if (thresholdPercentage === void 0) {\n    thresholdPercentage = defaultThreshold;\n  }\n  const _getScrollPosition = getScrollPosition(scrollContainer),\n    isTop = _getScrollPosition.isTop,\n    isBottom = _getScrollPosition.isBottom,\n    isLeft = _getScrollPosition.isLeft,\n    isRight = _getScrollPosition.isRight;\n  const direction = {\n    x: 0,\n    y: 0\n  };\n  const speed = {\n    x: 0,\n    y: 0\n  };\n  const threshold = {\n    height: scrollContainerRect.height * thresholdPercentage.y,\n    width: scrollContainerRect.width * thresholdPercentage.x\n  };\n  if (!isTop && top <= scrollContainerRect.top + threshold.height) {\n    // Scroll Up\n    direction.y = Direction.Backward;\n    speed.y = acceleration * Math.abs((scrollContainerRect.top + threshold.height - top) / threshold.height);\n  } else if (!isBottom && bottom >= scrollContainerRect.bottom - threshold.height) {\n    // Scroll Down\n    direction.y = Direction.Forward;\n    speed.y = acceleration * Math.abs((scrollContainerRect.bottom - threshold.height - bottom) / threshold.height);\n  }\n  if (!isRight && right >= scrollContainerRect.right - threshold.width) {\n    // Scroll Right\n    direction.x = Direction.Forward;\n    speed.x = acceleration * Math.abs((scrollContainerRect.right - threshold.width - right) / threshold.width);\n  } else if (!isLeft && left <= scrollContainerRect.left + threshold.width) {\n    // Scroll Left\n    direction.x = Direction.Backward;\n    speed.x = acceleration * Math.abs((scrollContainerRect.left + threshold.width - left) / threshold.width);\n  }\n  return {\n    direction,\n    speed\n  };\n}\nfunction getScrollElementRect(element) {\n  if (element === document.scrollingElement) {\n    const _window = window,\n      innerWidth = _window.innerWidth,\n      innerHeight = _window.innerHeight;\n    return {\n      top: 0,\n      left: 0,\n      right: innerWidth,\n      bottom: innerHeight,\n      width: innerWidth,\n      height: innerHeight\n    };\n  }\n  const _element$getBoundingC = element.getBoundingClientRect(),\n    top = _element$getBoundingC.top,\n    left = _element$getBoundingC.left,\n    right = _element$getBoundingC.right,\n    bottom = _element$getBoundingC.bottom;\n  return {\n    top,\n    left,\n    right,\n    bottom,\n    width: element.clientWidth,\n    height: element.clientHeight\n  };\n}\nfunction getScrollOffsets(scrollableAncestors) {\n  return scrollableAncestors.reduce((acc, node) => {\n    return add(acc, getScrollCoordinates(node));\n  }, defaultCoordinates);\n}\nfunction getScrollXOffset(scrollableAncestors) {\n  return scrollableAncestors.reduce((acc, node) => {\n    return acc + getScrollXCoordinate(node);\n  }, 0);\n}\nfunction getScrollYOffset(scrollableAncestors) {\n  return scrollableAncestors.reduce((acc, node) => {\n    return acc + getScrollYCoordinate(node);\n  }, 0);\n}\nfunction scrollIntoViewIfNeeded(element, measure) {\n  if (measure === void 0) {\n    measure = getClientRect;\n  }\n  if (!element) {\n    return;\n  }\n  const _measure = measure(element),\n    top = _measure.top,\n    left = _measure.left,\n    bottom = _measure.bottom,\n    right = _measure.right;\n  const firstScrollableAncestor = getFirstScrollableAncestor(element);\n  if (!firstScrollableAncestor) {\n    return;\n  }\n  if (bottom <= 0 || right <= 0 || top >= window.innerHeight || left >= window.innerWidth) {\n    element.scrollIntoView({\n      block: 'center',\n      inline: 'center'\n    });\n  }\n}\nconst properties = [['x', ['left', 'right'], getScrollXOffset], ['y', ['top', 'bottom'], getScrollYOffset]];\nclass Rect {\n  constructor(rect, element) {\n    this.rect = void 0;\n    this.width = void 0;\n    this.height = void 0;\n    this.top = void 0;\n    this.bottom = void 0;\n    this.right = void 0;\n    this.left = void 0;\n    const scrollableAncestors = getScrollableAncestors(element);\n    const scrollOffsets = getScrollOffsets(scrollableAncestors);\n    this.rect = _objectSpread({}, rect);\n    this.width = rect.width;\n    this.height = rect.height;\n    for (const _ref7 of properties) {\n      var _ref8 = _slicedToArray(_ref7, 3);\n      const axis = _ref8[0];\n      const keys = _ref8[1];\n      const getScrollOffset = _ref8[2];\n      for (const key of keys) {\n        Object.defineProperty(this, key, {\n          get: () => {\n            const currentOffsets = getScrollOffset(scrollableAncestors);\n            const scrollOffsetsDeltla = scrollOffsets[axis] - currentOffsets;\n            return this.rect[key] + scrollOffsetsDeltla;\n          },\n          enumerable: true\n        });\n      }\n    }\n    Object.defineProperty(this, 'rect', {\n      enumerable: false\n    });\n  }\n}\nclass Listeners {\n  constructor(target) {\n    this.target = void 0;\n    this.listeners = [];\n    this.removeAll = () => {\n      this.listeners.forEach(listener => {\n        var _this$target;\n        return (_this$target = this.target) == null ? void 0 : _this$target.removeEventListener(...listener);\n      });\n    };\n    this.target = target;\n  }\n  add(eventName, handler, options) {\n    var _this$target2;\n    (_this$target2 = this.target) == null ? void 0 : _this$target2.addEventListener(eventName, handler, options);\n    this.listeners.push([eventName, handler, options]);\n  }\n}\nfunction getEventListenerTarget(target) {\n  // If the `event.target` element is removed from the document events will still be targeted\n  // at it, and hence won't always bubble up to the window or document anymore.\n  // If there is any risk of an element being removed while it is being dragged,\n  // the best practice is to attach the event listeners directly to the target.\n  // https://developer.mozilla.org/en-US/docs/Web/API/EventTarget\n  const _getWindow = getWindow(target),\n    EventTarget = _getWindow.EventTarget;\n  return target instanceof EventTarget ? target : getOwnerDocument(target);\n}\nfunction hasExceededDistance(delta, measurement) {\n  const dx = Math.abs(delta.x);\n  const dy = Math.abs(delta.y);\n  if (typeof measurement === 'number') {\n    return Math.sqrt(dx ** 2 + dy ** 2) > measurement;\n  }\n  if ('x' in measurement && 'y' in measurement) {\n    return dx > measurement.x && dy > measurement.y;\n  }\n  if ('x' in measurement) {\n    return dx > measurement.x;\n  }\n  if ('y' in measurement) {\n    return dy > measurement.y;\n  }\n  return false;\n}\nvar EventName;\n(function (EventName) {\n  EventName[\"Click\"] = \"click\";\n  EventName[\"DragStart\"] = \"dragstart\";\n  EventName[\"Keydown\"] = \"keydown\";\n  EventName[\"ContextMenu\"] = \"contextmenu\";\n  EventName[\"Resize\"] = \"resize\";\n  EventName[\"SelectionChange\"] = \"selectionchange\";\n  EventName[\"VisibilityChange\"] = \"visibilitychange\";\n})(EventName || (EventName = {}));\nfunction preventDefault(event) {\n  event.preventDefault();\n}\nfunction stopPropagation(event) {\n  event.stopPropagation();\n}\nvar KeyboardCode;\n(function (KeyboardCode) {\n  KeyboardCode[\"Space\"] = \"Space\";\n  KeyboardCode[\"Down\"] = \"ArrowDown\";\n  KeyboardCode[\"Right\"] = \"ArrowRight\";\n  KeyboardCode[\"Left\"] = \"ArrowLeft\";\n  KeyboardCode[\"Up\"] = \"ArrowUp\";\n  KeyboardCode[\"Esc\"] = \"Escape\";\n  KeyboardCode[\"Enter\"] = \"Enter\";\n})(KeyboardCode || (KeyboardCode = {}));\nconst defaultKeyboardCodes = {\n  start: [KeyboardCode.Space, KeyboardCode.Enter],\n  cancel: [KeyboardCode.Esc],\n  end: [KeyboardCode.Space, KeyboardCode.Enter]\n};\nconst defaultKeyboardCoordinateGetter = (event, _ref) => {\n  let currentCoordinates = _ref.currentCoordinates;\n  switch (event.code) {\n    case KeyboardCode.Right:\n      return _objectSpread(_objectSpread({}, currentCoordinates), {}, {\n        x: currentCoordinates.x + 25\n      });\n    case KeyboardCode.Left:\n      return _objectSpread(_objectSpread({}, currentCoordinates), {}, {\n        x: currentCoordinates.x - 25\n      });\n    case KeyboardCode.Down:\n      return _objectSpread(_objectSpread({}, currentCoordinates), {}, {\n        y: currentCoordinates.y + 25\n      });\n    case KeyboardCode.Up:\n      return _objectSpread(_objectSpread({}, currentCoordinates), {}, {\n        y: currentCoordinates.y - 25\n      });\n  }\n  return undefined;\n};\nclass KeyboardSensor {\n  constructor(props) {\n    this.props = void 0;\n    this.autoScrollEnabled = false;\n    this.referenceCoordinates = void 0;\n    this.listeners = void 0;\n    this.windowListeners = void 0;\n    this.props = props;\n    const target = props.event.target;\n    this.props = props;\n    this.listeners = new Listeners(getOwnerDocument(target));\n    this.windowListeners = new Listeners(getWindow(target));\n    this.handleKeyDown = this.handleKeyDown.bind(this);\n    this.handleCancel = this.handleCancel.bind(this);\n    this.attach();\n  }\n  attach() {\n    this.handleStart();\n    this.windowListeners.add(EventName.Resize, this.handleCancel);\n    this.windowListeners.add(EventName.VisibilityChange, this.handleCancel);\n    setTimeout(() => this.listeners.add(EventName.Keydown, this.handleKeyDown));\n  }\n  handleStart() {\n    const _this$props = this.props,\n      activeNode = _this$props.activeNode,\n      onStart = _this$props.onStart;\n    const node = activeNode.node.current;\n    if (node) {\n      scrollIntoViewIfNeeded(node);\n    }\n    onStart(defaultCoordinates);\n  }\n  handleKeyDown(event) {\n    if (isKeyboardEvent(event)) {\n      const _this$props2 = this.props,\n        active = _this$props2.active,\n        context = _this$props2.context,\n        options = _this$props2.options;\n      const _options$keyboardCode = options.keyboardCodes,\n        keyboardCodes = _options$keyboardCode === void 0 ? defaultKeyboardCodes : _options$keyboardCode,\n        _options$coordinateGe = options.coordinateGetter,\n        coordinateGetter = _options$coordinateGe === void 0 ? defaultKeyboardCoordinateGetter : _options$coordinateGe,\n        _options$scrollBehavi = options.scrollBehavior,\n        scrollBehavior = _options$scrollBehavi === void 0 ? 'smooth' : _options$scrollBehavi;\n      const code = event.code;\n      if (keyboardCodes.end.includes(code)) {\n        this.handleEnd(event);\n        return;\n      }\n      if (keyboardCodes.cancel.includes(code)) {\n        this.handleCancel(event);\n        return;\n      }\n      const collisionRect = context.current.collisionRect;\n      const currentCoordinates = collisionRect ? {\n        x: collisionRect.left,\n        y: collisionRect.top\n      } : defaultCoordinates;\n      if (!this.referenceCoordinates) {\n        this.referenceCoordinates = currentCoordinates;\n      }\n      const newCoordinates = coordinateGetter(event, {\n        active,\n        context: context.current,\n        currentCoordinates\n      });\n      if (newCoordinates) {\n        const coordinatesDelta = subtract(newCoordinates, currentCoordinates);\n        const scrollDelta = {\n          x: 0,\n          y: 0\n        };\n        const scrollableAncestors = context.current.scrollableAncestors;\n        for (const scrollContainer of scrollableAncestors) {\n          const direction = event.code;\n          const _getScrollPosition2 = getScrollPosition(scrollContainer),\n            isTop = _getScrollPosition2.isTop,\n            isRight = _getScrollPosition2.isRight,\n            isLeft = _getScrollPosition2.isLeft,\n            isBottom = _getScrollPosition2.isBottom,\n            maxScroll = _getScrollPosition2.maxScroll,\n            minScroll = _getScrollPosition2.minScroll;\n          const scrollElementRect = getScrollElementRect(scrollContainer);\n          const clampedCoordinates = {\n            x: Math.min(direction === KeyboardCode.Right ? scrollElementRect.right - scrollElementRect.width / 2 : scrollElementRect.right, Math.max(direction === KeyboardCode.Right ? scrollElementRect.left : scrollElementRect.left + scrollElementRect.width / 2, newCoordinates.x)),\n            y: Math.min(direction === KeyboardCode.Down ? scrollElementRect.bottom - scrollElementRect.height / 2 : scrollElementRect.bottom, Math.max(direction === KeyboardCode.Down ? scrollElementRect.top : scrollElementRect.top + scrollElementRect.height / 2, newCoordinates.y))\n          };\n          const canScrollX = direction === KeyboardCode.Right && !isRight || direction === KeyboardCode.Left && !isLeft;\n          const canScrollY = direction === KeyboardCode.Down && !isBottom || direction === KeyboardCode.Up && !isTop;\n          if (canScrollX && clampedCoordinates.x !== newCoordinates.x) {\n            const newScrollCoordinates = scrollContainer.scrollLeft + coordinatesDelta.x;\n            const canScrollToNewCoordinates = direction === KeyboardCode.Right && newScrollCoordinates <= maxScroll.x || direction === KeyboardCode.Left && newScrollCoordinates >= minScroll.x;\n            if (canScrollToNewCoordinates && !coordinatesDelta.y) {\n              // We don't need to update coordinates, the scroll adjustment alone will trigger\n              // logic to auto-detect the new container we are over\n              scrollContainer.scrollTo({\n                left: newScrollCoordinates,\n                behavior: scrollBehavior\n              });\n              return;\n            }\n            if (canScrollToNewCoordinates) {\n              scrollDelta.x = scrollContainer.scrollLeft - newScrollCoordinates;\n            } else {\n              scrollDelta.x = direction === KeyboardCode.Right ? scrollContainer.scrollLeft - maxScroll.x : scrollContainer.scrollLeft - minScroll.x;\n            }\n            if (scrollDelta.x) {\n              scrollContainer.scrollBy({\n                left: -scrollDelta.x,\n                behavior: scrollBehavior\n              });\n            }\n            break;\n          } else if (canScrollY && clampedCoordinates.y !== newCoordinates.y) {\n            const newScrollCoordinates = scrollContainer.scrollTop + coordinatesDelta.y;\n            const canScrollToNewCoordinates = direction === KeyboardCode.Down && newScrollCoordinates <= maxScroll.y || direction === KeyboardCode.Up && newScrollCoordinates >= minScroll.y;\n            if (canScrollToNewCoordinates && !coordinatesDelta.x) {\n              // We don't need to update coordinates, the scroll adjustment alone will trigger\n              // logic to auto-detect the new container we are over\n              scrollContainer.scrollTo({\n                top: newScrollCoordinates,\n                behavior: scrollBehavior\n              });\n              return;\n            }\n            if (canScrollToNewCoordinates) {\n              scrollDelta.y = scrollContainer.scrollTop - newScrollCoordinates;\n            } else {\n              scrollDelta.y = direction === KeyboardCode.Down ? scrollContainer.scrollTop - maxScroll.y : scrollContainer.scrollTop - minScroll.y;\n            }\n            if (scrollDelta.y) {\n              scrollContainer.scrollBy({\n                top: -scrollDelta.y,\n                behavior: scrollBehavior\n              });\n            }\n            break;\n          }\n        }\n        this.handleMove(event, add(subtract(newCoordinates, this.referenceCoordinates), scrollDelta));\n      }\n    }\n  }\n  handleMove(event, coordinates) {\n    const onMove = this.props.onMove;\n    event.preventDefault();\n    onMove(coordinates);\n  }\n  handleEnd(event) {\n    const onEnd = this.props.onEnd;\n    event.preventDefault();\n    this.detach();\n    onEnd();\n  }\n  handleCancel(event) {\n    const onCancel = this.props.onCancel;\n    event.preventDefault();\n    this.detach();\n    onCancel();\n  }\n  detach() {\n    this.listeners.removeAll();\n    this.windowListeners.removeAll();\n  }\n}\nKeyboardSensor.activators = [{\n  eventName: 'onKeyDown',\n  handler: (event, _ref, _ref2) => {\n    let _ref$keyboardCodes = _ref.keyboardCodes,\n      keyboardCodes = _ref$keyboardCodes === void 0 ? defaultKeyboardCodes : _ref$keyboardCodes,\n      onActivation = _ref.onActivation;\n    let active = _ref2.active;\n    const code = event.nativeEvent.code;\n    if (keyboardCodes.start.includes(code)) {\n      const activator = active.activatorNode.current;\n      if (activator && event.target !== activator) {\n        return false;\n      }\n      event.preventDefault();\n      onActivation == null ? void 0 : onActivation({\n        event: event.nativeEvent\n      });\n      return true;\n    }\n    return false;\n  }\n}];\nfunction isDistanceConstraint(constraint) {\n  return Boolean(constraint && 'distance' in constraint);\n}\nfunction isDelayConstraint(constraint) {\n  return Boolean(constraint && 'delay' in constraint);\n}\nclass AbstractPointerSensor {\n  constructor(props, events, listenerTarget) {\n    var _getEventCoordinates;\n    if (listenerTarget === void 0) {\n      listenerTarget = getEventListenerTarget(props.event.target);\n    }\n    this.props = void 0;\n    this.events = void 0;\n    this.autoScrollEnabled = true;\n    this.document = void 0;\n    this.activated = false;\n    this.initialCoordinates = void 0;\n    this.timeoutId = null;\n    this.listeners = void 0;\n    this.documentListeners = void 0;\n    this.windowListeners = void 0;\n    this.props = props;\n    this.events = events;\n    const event = props.event;\n    const target = event.target;\n    this.props = props;\n    this.events = events;\n    this.document = getOwnerDocument(target);\n    this.documentListeners = new Listeners(this.document);\n    this.listeners = new Listeners(listenerTarget);\n    this.windowListeners = new Listeners(getWindow(target));\n    this.initialCoordinates = (_getEventCoordinates = getEventCoordinates(event)) != null ? _getEventCoordinates : defaultCoordinates;\n    this.handleStart = this.handleStart.bind(this);\n    this.handleMove = this.handleMove.bind(this);\n    this.handleEnd = this.handleEnd.bind(this);\n    this.handleCancel = this.handleCancel.bind(this);\n    this.handleKeydown = this.handleKeydown.bind(this);\n    this.removeTextSelection = this.removeTextSelection.bind(this);\n    this.attach();\n  }\n  attach() {\n    const events = this.events,\n      _this$props$options = this.props.options,\n      activationConstraint = _this$props$options.activationConstraint,\n      bypassActivationConstraint = _this$props$options.bypassActivationConstraint;\n    this.listeners.add(events.move.name, this.handleMove, {\n      passive: false\n    });\n    this.listeners.add(events.end.name, this.handleEnd);\n    this.windowListeners.add(EventName.Resize, this.handleCancel);\n    this.windowListeners.add(EventName.DragStart, preventDefault);\n    this.windowListeners.add(EventName.VisibilityChange, this.handleCancel);\n    this.windowListeners.add(EventName.ContextMenu, preventDefault);\n    this.documentListeners.add(EventName.Keydown, this.handleKeydown);\n    if (activationConstraint) {\n      if (bypassActivationConstraint != null && bypassActivationConstraint({\n        event: this.props.event,\n        activeNode: this.props.activeNode,\n        options: this.props.options\n      })) {\n        return this.handleStart();\n      }\n      if (isDelayConstraint(activationConstraint)) {\n        this.timeoutId = setTimeout(this.handleStart, activationConstraint.delay);\n        return;\n      }\n      if (isDistanceConstraint(activationConstraint)) {\n        return;\n      }\n    }\n    this.handleStart();\n  }\n  detach() {\n    this.listeners.removeAll();\n    this.windowListeners.removeAll(); // Wait until the next event loop before removing document listeners\n    // This is necessary because we listen for `click` and `selection` events on the document\n\n    setTimeout(this.documentListeners.removeAll, 50);\n    if (this.timeoutId !== null) {\n      clearTimeout(this.timeoutId);\n      this.timeoutId = null;\n    }\n  }\n  handleStart() {\n    const initialCoordinates = this.initialCoordinates;\n    const onStart = this.props.onStart;\n    if (initialCoordinates) {\n      this.activated = true; // Stop propagation of click events once activation constraints are met\n\n      this.documentListeners.add(EventName.Click, stopPropagation, {\n        capture: true\n      }); // Remove any text selection from the document\n\n      this.removeTextSelection(); // Prevent further text selection while dragging\n\n      this.documentListeners.add(EventName.SelectionChange, this.removeTextSelection);\n      onStart(initialCoordinates);\n    }\n  }\n  handleMove(event) {\n    var _getEventCoordinates2;\n    const activated = this.activated,\n      initialCoordinates = this.initialCoordinates,\n      props = this.props;\n    const onMove = props.onMove,\n      activationConstraint = props.options.activationConstraint;\n    if (!initialCoordinates) {\n      return;\n    }\n    const coordinates = (_getEventCoordinates2 = getEventCoordinates(event)) != null ? _getEventCoordinates2 : defaultCoordinates;\n    const delta = subtract(initialCoordinates, coordinates); // Constraint validation\n\n    if (!activated && activationConstraint) {\n      if (isDistanceConstraint(activationConstraint)) {\n        if (activationConstraint.tolerance != null && hasExceededDistance(delta, activationConstraint.tolerance)) {\n          return this.handleCancel();\n        }\n        if (hasExceededDistance(delta, activationConstraint.distance)) {\n          return this.handleStart();\n        }\n      }\n      if (isDelayConstraint(activationConstraint)) {\n        if (hasExceededDistance(delta, activationConstraint.tolerance)) {\n          return this.handleCancel();\n        }\n      }\n      return;\n    }\n    if (event.cancelable) {\n      event.preventDefault();\n    }\n    onMove(coordinates);\n  }\n  handleEnd() {\n    const onEnd = this.props.onEnd;\n    this.detach();\n    onEnd();\n  }\n  handleCancel() {\n    const onCancel = this.props.onCancel;\n    this.detach();\n    onCancel();\n  }\n  handleKeydown(event) {\n    if (event.code === KeyboardCode.Esc) {\n      this.handleCancel();\n    }\n  }\n  removeTextSelection() {\n    var _this$document$getSel;\n    (_this$document$getSel = this.document.getSelection()) == null ? void 0 : _this$document$getSel.removeAllRanges();\n  }\n}\nconst events = {\n  move: {\n    name: 'pointermove'\n  },\n  end: {\n    name: 'pointerup'\n  }\n};\nclass PointerSensor extends AbstractPointerSensor {\n  constructor(props) {\n    const event = props.event; // Pointer events stop firing if the target is unmounted while dragging\n    // Therefore we attach listeners to the owner document instead\n\n    const listenerTarget = getOwnerDocument(event.target);\n    super(props, events, listenerTarget);\n  }\n}\nPointerSensor.activators = [{\n  eventName: 'onPointerDown',\n  handler: (_ref, _ref2) => {\n    let event = _ref.nativeEvent;\n    let onActivation = _ref2.onActivation;\n    if (!event.isPrimary || event.button !== 0) {\n      return false;\n    }\n    onActivation == null ? void 0 : onActivation({\n      event\n    });\n    return true;\n  }\n}];\nconst events$1 = {\n  move: {\n    name: 'mousemove'\n  },\n  end: {\n    name: 'mouseup'\n  }\n};\nvar MouseButton;\n(function (MouseButton) {\n  MouseButton[MouseButton[\"RightClick\"] = 2] = \"RightClick\";\n})(MouseButton || (MouseButton = {}));\nclass MouseSensor extends AbstractPointerSensor {\n  constructor(props) {\n    super(props, events$1, getOwnerDocument(props.event.target));\n  }\n}\nMouseSensor.activators = [{\n  eventName: 'onMouseDown',\n  handler: (_ref, _ref2) => {\n    let event = _ref.nativeEvent;\n    let onActivation = _ref2.onActivation;\n    if (event.button === MouseButton.RightClick) {\n      return false;\n    }\n    onActivation == null ? void 0 : onActivation({\n      event\n    });\n    return true;\n  }\n}];\nconst events$2 = {\n  move: {\n    name: 'touchmove'\n  },\n  end: {\n    name: 'touchend'\n  }\n};\nclass TouchSensor extends AbstractPointerSensor {\n  constructor(props) {\n    super(props, events$2);\n  }\n  static setup() {\n    // Adding a non-capture and non-passive `touchmove` listener in order\n    // to force `event.preventDefault()` calls to work in dynamically added\n    // touchmove event handlers. This is required for iOS Safari.\n    window.addEventListener(events$2.move.name, noop, {\n      capture: false,\n      passive: false\n    });\n    return function teardown() {\n      window.removeEventListener(events$2.move.name, noop);\n    }; // We create a new handler because the teardown function of another sensor\n    // could remove our event listener if we use a referentially equal listener.\n\n    function noop() {}\n  }\n}\nTouchSensor.activators = [{\n  eventName: 'onTouchStart',\n  handler: (_ref, _ref2) => {\n    let event = _ref.nativeEvent;\n    let onActivation = _ref2.onActivation;\n    const touches = event.touches;\n    if (touches.length > 1) {\n      return false;\n    }\n    onActivation == null ? void 0 : onActivation({\n      event\n    });\n    return true;\n  }\n}];\nvar AutoScrollActivator;\n(function (AutoScrollActivator) {\n  AutoScrollActivator[AutoScrollActivator[\"Pointer\"] = 0] = \"Pointer\";\n  AutoScrollActivator[AutoScrollActivator[\"DraggableRect\"] = 1] = \"DraggableRect\";\n})(AutoScrollActivator || (AutoScrollActivator = {}));\nvar TraversalOrder;\n(function (TraversalOrder) {\n  TraversalOrder[TraversalOrder[\"TreeOrder\"] = 0] = \"TreeOrder\";\n  TraversalOrder[TraversalOrder[\"ReversedTreeOrder\"] = 1] = \"ReversedTreeOrder\";\n})(TraversalOrder || (TraversalOrder = {}));\nfunction useAutoScroller(_ref) {\n  let acceleration = _ref.acceleration,\n    _ref$activator = _ref.activator,\n    activator = _ref$activator === void 0 ? AutoScrollActivator.Pointer : _ref$activator,\n    canScroll = _ref.canScroll,\n    draggingRect = _ref.draggingRect,\n    enabled = _ref.enabled,\n    _ref$interval = _ref.interval,\n    interval = _ref$interval === void 0 ? 5 : _ref$interval,\n    _ref$order = _ref.order,\n    order = _ref$order === void 0 ? TraversalOrder.TreeOrder : _ref$order,\n    pointerCoordinates = _ref.pointerCoordinates,\n    scrollableAncestors = _ref.scrollableAncestors,\n    scrollableAncestorRects = _ref.scrollableAncestorRects,\n    delta = _ref.delta,\n    threshold = _ref.threshold;\n  const scrollIntent = useScrollIntent({\n    delta,\n    disabled: !enabled\n  });\n  const _useInterval = useInterval(),\n    _useInterval2 = _slicedToArray(_useInterval, 2),\n    setAutoScrollInterval = _useInterval2[0],\n    clearAutoScrollInterval = _useInterval2[1];\n  const scrollSpeed = useRef({\n    x: 0,\n    y: 0\n  });\n  const scrollDirection = useRef({\n    x: 0,\n    y: 0\n  });\n  const rect = useMemo(() => {\n    switch (activator) {\n      case AutoScrollActivator.Pointer:\n        return pointerCoordinates ? {\n          top: pointerCoordinates.y,\n          bottom: pointerCoordinates.y,\n          left: pointerCoordinates.x,\n          right: pointerCoordinates.x\n        } : null;\n      case AutoScrollActivator.DraggableRect:\n        return draggingRect;\n    }\n  }, [activator, draggingRect, pointerCoordinates]);\n  const scrollContainerRef = useRef(null);\n  const autoScroll = useCallback(() => {\n    const scrollContainer = scrollContainerRef.current;\n    if (!scrollContainer) {\n      return;\n    }\n    const scrollLeft = scrollSpeed.current.x * scrollDirection.current.x;\n    const scrollTop = scrollSpeed.current.y * scrollDirection.current.y;\n    scrollContainer.scrollBy(scrollLeft, scrollTop);\n  }, []);\n  const sortedScrollableAncestors = useMemo(() => order === TraversalOrder.TreeOrder ? [...scrollableAncestors].reverse() : scrollableAncestors, [order, scrollableAncestors]);\n  useEffect(() => {\n    if (!enabled || !scrollableAncestors.length || !rect) {\n      clearAutoScrollInterval();\n      return;\n    }\n    for (const scrollContainer of sortedScrollableAncestors) {\n      if ((canScroll == null ? void 0 : canScroll(scrollContainer)) === false) {\n        continue;\n      }\n      const index = scrollableAncestors.indexOf(scrollContainer);\n      const scrollContainerRect = scrollableAncestorRects[index];\n      if (!scrollContainerRect) {\n        continue;\n      }\n      const _getScrollDirectionAn = getScrollDirectionAndSpeed(scrollContainer, scrollContainerRect, rect, acceleration, threshold),\n        direction = _getScrollDirectionAn.direction,\n        speed = _getScrollDirectionAn.speed;\n      for (const axis of ['x', 'y']) {\n        if (!scrollIntent[axis][direction[axis]]) {\n          speed[axis] = 0;\n          direction[axis] = 0;\n        }\n      }\n      if (speed.x > 0 || speed.y > 0) {\n        clearAutoScrollInterval();\n        scrollContainerRef.current = scrollContainer;\n        setAutoScrollInterval(autoScroll, interval);\n        scrollSpeed.current = speed;\n        scrollDirection.current = direction;\n        return;\n      }\n    }\n    scrollSpeed.current = {\n      x: 0,\n      y: 0\n    };\n    scrollDirection.current = {\n      x: 0,\n      y: 0\n    };\n    clearAutoScrollInterval();\n  },\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [acceleration, autoScroll, canScroll, clearAutoScrollInterval, enabled, interval,\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  JSON.stringify(rect),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  JSON.stringify(scrollIntent), setAutoScrollInterval, scrollableAncestors, sortedScrollableAncestors, scrollableAncestorRects,\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  JSON.stringify(threshold)]);\n}\nconst defaultScrollIntent = {\n  x: {\n    [Direction.Backward]: false,\n    [Direction.Forward]: false\n  },\n  y: {\n    [Direction.Backward]: false,\n    [Direction.Forward]: false\n  }\n};\nfunction useScrollIntent(_ref2) {\n  let delta = _ref2.delta,\n    disabled = _ref2.disabled;\n  const previousDelta = usePrevious(delta);\n  return useLazyMemo(previousIntent => {\n    if (disabled || !previousDelta || !previousIntent) {\n      // Reset scroll intent tracking when auto-scrolling is disabled\n      return defaultScrollIntent;\n    }\n    const direction = {\n      x: Math.sign(delta.x - previousDelta.x),\n      y: Math.sign(delta.y - previousDelta.y)\n    }; // Keep track of the user intent to scroll in each direction for both axis\n\n    return {\n      x: {\n        [Direction.Backward]: previousIntent.x[Direction.Backward] || direction.x === -1,\n        [Direction.Forward]: previousIntent.x[Direction.Forward] || direction.x === 1\n      },\n      y: {\n        [Direction.Backward]: previousIntent.y[Direction.Backward] || direction.y === -1,\n        [Direction.Forward]: previousIntent.y[Direction.Forward] || direction.y === 1\n      }\n    };\n  }, [disabled, delta, previousDelta]);\n}\nfunction useCachedNode(draggableNodes, id) {\n  const draggableNode = id !== null ? draggableNodes.get(id) : undefined;\n  const node = draggableNode ? draggableNode.node.current : null;\n  return useLazyMemo(cachedNode => {\n    var _ref;\n    if (id === null) {\n      return null;\n    } // In some cases, the draggable node can unmount while dragging\n    // This is the case for virtualized lists. In those situations,\n    // we fall back to the last known value for that node.\n\n    return (_ref = node != null ? node : cachedNode) != null ? _ref : null;\n  }, [node, id]);\n}\nfunction useCombineActivators(sensors, getSyntheticHandler) {\n  return useMemo(() => sensors.reduce((accumulator, sensor) => {\n    const Sensor = sensor.sensor;\n    const sensorActivators = Sensor.activators.map(activator => ({\n      eventName: activator.eventName,\n      handler: getSyntheticHandler(activator.handler, sensor)\n    }));\n    return [...accumulator, ...sensorActivators];\n  }, []), [sensors, getSyntheticHandler]);\n}\nvar MeasuringStrategy;\n(function (MeasuringStrategy) {\n  MeasuringStrategy[MeasuringStrategy[\"Always\"] = 0] = \"Always\";\n  MeasuringStrategy[MeasuringStrategy[\"BeforeDragging\"] = 1] = \"BeforeDragging\";\n  MeasuringStrategy[MeasuringStrategy[\"WhileDragging\"] = 2] = \"WhileDragging\";\n})(MeasuringStrategy || (MeasuringStrategy = {}));\nvar MeasuringFrequency;\n(function (MeasuringFrequency) {\n  MeasuringFrequency[\"Optimized\"] = \"optimized\";\n})(MeasuringFrequency || (MeasuringFrequency = {}));\nconst defaultValue = /*#__PURE__*/new Map();\nfunction useDroppableMeasuring(containers, _ref) {\n  let dragging = _ref.dragging,\n    dependencies = _ref.dependencies,\n    config = _ref.config;\n  const _useState5 = useState(null),\n    _useState6 = _slicedToArray(_useState5, 2),\n    queue = _useState6[0],\n    setQueue = _useState6[1];\n  const frequency = config.frequency,\n    measure = config.measure,\n    strategy = config.strategy;\n  const containersRef = useRef(containers);\n  const disabled = isDisabled();\n  const disabledRef = useLatestValue(disabled);\n  const measureDroppableContainers = useCallback(function (ids) {\n    if (ids === void 0) {\n      ids = [];\n    }\n    if (disabledRef.current) {\n      return;\n    }\n    setQueue(value => {\n      if (value === null) {\n        return ids;\n      }\n      return value.concat(ids.filter(id => !value.includes(id)));\n    });\n  }, [disabledRef]);\n  const timeoutId = useRef(null);\n  const droppableRects = useLazyMemo(previousValue => {\n    if (disabled && !dragging) {\n      return defaultValue;\n    }\n    if (!previousValue || previousValue === defaultValue || containersRef.current !== containers || queue != null) {\n      const map = new Map();\n      for (let container of containers) {\n        if (!container) {\n          continue;\n        }\n        if (queue && queue.length > 0 && !queue.includes(container.id) && container.rect.current) {\n          // This container does not need to be re-measured\n          map.set(container.id, container.rect.current);\n          continue;\n        }\n        const node = container.node.current;\n        const rect = node ? new Rect(measure(node), node) : null;\n        container.rect.current = rect;\n        if (rect) {\n          map.set(container.id, rect);\n        }\n      }\n      return map;\n    }\n    return previousValue;\n  }, [containers, queue, dragging, disabled, measure]);\n  useEffect(() => {\n    containersRef.current = containers;\n  }, [containers]);\n  useEffect(() => {\n    if (disabled) {\n      return;\n    }\n    measureDroppableContainers();\n  },\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [dragging, disabled]);\n  useEffect(() => {\n    if (queue && queue.length > 0) {\n      setQueue(null);\n    }\n  },\n  //eslint-disable-next-line react-hooks/exhaustive-deps\n  [JSON.stringify(queue)]);\n  useEffect(() => {\n    if (disabled || typeof frequency !== 'number' || timeoutId.current !== null) {\n      return;\n    }\n    timeoutId.current = setTimeout(() => {\n      measureDroppableContainers();\n      timeoutId.current = null;\n    }, frequency);\n  },\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [frequency, disabled, measureDroppableContainers, ...dependencies]);\n  return {\n    droppableRects,\n    measureDroppableContainers,\n    measuringScheduled: queue != null\n  };\n  function isDisabled() {\n    switch (strategy) {\n      case MeasuringStrategy.Always:\n        return false;\n      case MeasuringStrategy.BeforeDragging:\n        return dragging;\n      default:\n        return !dragging;\n    }\n  }\n}\nfunction useInitialValue(value, computeFn) {\n  return useLazyMemo(previousValue => {\n    if (!value) {\n      return null;\n    }\n    if (previousValue) {\n      return previousValue;\n    }\n    return typeof computeFn === 'function' ? computeFn(value) : value;\n  }, [computeFn, value]);\n}\nfunction useInitialRect(node, measure) {\n  return useInitialValue(node, measure);\n}\n\n/**\r\n * Returns a new MutationObserver instance.\r\n * If `MutationObserver` is undefined in the execution environment, returns `undefined`.\r\n */\n\nfunction useMutationObserver(_ref) {\n  let callback = _ref.callback,\n    disabled = _ref.disabled;\n  const handleMutations = useEvent(callback);\n  const mutationObserver = useMemo(() => {\n    if (disabled || typeof window === 'undefined' || typeof window.MutationObserver === 'undefined') {\n      return undefined;\n    }\n    const _window2 = window,\n      MutationObserver = _window2.MutationObserver;\n    return new MutationObserver(handleMutations);\n  }, [handleMutations, disabled]);\n  useEffect(() => {\n    return () => mutationObserver == null ? void 0 : mutationObserver.disconnect();\n  }, [mutationObserver]);\n  return mutationObserver;\n}\n\n/**\r\n * Returns a new ResizeObserver instance bound to the `onResize` callback.\r\n * If `ResizeObserver` is undefined in the execution environment, returns `undefined`.\r\n */\n\nfunction useResizeObserver(_ref) {\n  let callback = _ref.callback,\n    disabled = _ref.disabled;\n  const handleResize = useEvent(callback);\n  const resizeObserver = useMemo(() => {\n    if (disabled || typeof window === 'undefined' || typeof window.ResizeObserver === 'undefined') {\n      return undefined;\n    }\n    const _window3 = window,\n      ResizeObserver = _window3.ResizeObserver;\n    return new ResizeObserver(handleResize);\n  },\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [disabled]);\n  useEffect(() => {\n    return () => resizeObserver == null ? void 0 : resizeObserver.disconnect();\n  }, [resizeObserver]);\n  return resizeObserver;\n}\nfunction defaultMeasure(element) {\n  return new Rect(getClientRect(element), element);\n}\nfunction useRect(element, measure, fallbackRect) {\n  if (measure === void 0) {\n    measure = defaultMeasure;\n  }\n  const _useReducer = useReducer(reducer, null),\n    _useReducer2 = _slicedToArray(_useReducer, 2),\n    rect = _useReducer2[0],\n    measureRect = _useReducer2[1];\n  const mutationObserver = useMutationObserver({\n    callback(records) {\n      if (!element) {\n        return;\n      }\n      for (const record of records) {\n        const type = record.type,\n          target = record.target;\n        if (type === 'childList' && target instanceof HTMLElement && target.contains(element)) {\n          measureRect();\n          break;\n        }\n      }\n    }\n  });\n  const resizeObserver = useResizeObserver({\n    callback: measureRect\n  });\n  useIsomorphicLayoutEffect(() => {\n    measureRect();\n    if (element) {\n      resizeObserver == null ? void 0 : resizeObserver.observe(element);\n      mutationObserver == null ? void 0 : mutationObserver.observe(document.body, {\n        childList: true,\n        subtree: true\n      });\n    } else {\n      resizeObserver == null ? void 0 : resizeObserver.disconnect();\n      mutationObserver == null ? void 0 : mutationObserver.disconnect();\n    }\n  }, [element]);\n  return rect;\n  function reducer(currentRect) {\n    if (!element) {\n      return null;\n    }\n    if (element.isConnected === false) {\n      var _ref;\n\n      // Fall back to last rect we measured if the element is\n      // no longer connected to the DOM.\n      return (_ref = currentRect != null ? currentRect : fallbackRect) != null ? _ref : null;\n    }\n    const newRect = measure(element);\n    if (JSON.stringify(currentRect) === JSON.stringify(newRect)) {\n      return currentRect;\n    }\n    return newRect;\n  }\n}\nfunction useRectDelta(rect) {\n  const initialRect = useInitialValue(rect);\n  return getRectDelta(rect, initialRect);\n}\nconst defaultValue$1 = [];\nfunction useScrollableAncestors(node) {\n  const previousNode = useRef(node);\n  const ancestors = useLazyMemo(previousValue => {\n    if (!node) {\n      return defaultValue$1;\n    }\n    if (previousValue && previousValue !== defaultValue$1 && node && previousNode.current && node.parentNode === previousNode.current.parentNode) {\n      return previousValue;\n    }\n    return getScrollableAncestors(node);\n  }, [node]);\n  useEffect(() => {\n    previousNode.current = node;\n  }, [node]);\n  return ancestors;\n}\nfunction useScrollOffsets(elements) {\n  const _useState7 = useState(null),\n    _useState8 = _slicedToArray(_useState7, 2),\n    scrollCoordinates = _useState8[0],\n    setScrollCoordinates = _useState8[1];\n  const prevElements = useRef(elements); // To-do: Throttle the handleScroll callback\n\n  const handleScroll = useCallback(event => {\n    const scrollingElement = getScrollableElement(event.target);\n    if (!scrollingElement) {\n      return;\n    }\n    setScrollCoordinates(scrollCoordinates => {\n      if (!scrollCoordinates) {\n        return null;\n      }\n      scrollCoordinates.set(scrollingElement, getScrollCoordinates(scrollingElement));\n      return new Map(scrollCoordinates);\n    });\n  }, []);\n  useEffect(() => {\n    const previousElements = prevElements.current;\n    if (elements !== previousElements) {\n      cleanup(previousElements);\n      const entries = elements.map(element => {\n        const scrollableElement = getScrollableElement(element);\n        if (scrollableElement) {\n          scrollableElement.addEventListener('scroll', handleScroll, {\n            passive: true\n          });\n          return [scrollableElement, getScrollCoordinates(scrollableElement)];\n        }\n        return null;\n      }).filter(entry => entry != null);\n      setScrollCoordinates(entries.length ? new Map(entries) : null);\n      prevElements.current = elements;\n    }\n    return () => {\n      cleanup(elements);\n      cleanup(previousElements);\n    };\n    function cleanup(elements) {\n      elements.forEach(element => {\n        const scrollableElement = getScrollableElement(element);\n        scrollableElement == null ? void 0 : scrollableElement.removeEventListener('scroll', handleScroll);\n      });\n    }\n  }, [handleScroll, elements]);\n  return useMemo(() => {\n    if (elements.length) {\n      return scrollCoordinates ? Array.from(scrollCoordinates.values()).reduce((acc, coordinates) => add(acc, coordinates), defaultCoordinates) : getScrollOffsets(elements);\n    }\n    return defaultCoordinates;\n  }, [elements, scrollCoordinates]);\n}\nfunction useScrollOffsetsDelta(scrollOffsets, dependencies) {\n  if (dependencies === void 0) {\n    dependencies = [];\n  }\n  const initialScrollOffsets = useRef(null);\n  useEffect(() => {\n    initialScrollOffsets.current = null;\n  },\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  dependencies);\n  useEffect(() => {\n    const hasScrollOffsets = scrollOffsets !== defaultCoordinates;\n    if (hasScrollOffsets && !initialScrollOffsets.current) {\n      initialScrollOffsets.current = scrollOffsets;\n    }\n    if (!hasScrollOffsets && initialScrollOffsets.current) {\n      initialScrollOffsets.current = null;\n    }\n  }, [scrollOffsets]);\n  return initialScrollOffsets.current ? subtract(scrollOffsets, initialScrollOffsets.current) : defaultCoordinates;\n}\nfunction useSensorSetup(sensors) {\n  useEffect(() => {\n    if (!canUseDOM) {\n      return;\n    }\n    const teardownFns = sensors.map(_ref => {\n      let sensor = _ref.sensor;\n      return sensor.setup == null ? void 0 : sensor.setup();\n    });\n    return () => {\n      for (const teardown of teardownFns) {\n        teardown == null ? void 0 : teardown();\n      }\n    };\n  },\n  // TO-DO: Sensors length could theoretically change which would not be a valid dependency\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  sensors.map(_ref2 => {\n    let sensor = _ref2.sensor;\n    return sensor;\n  }));\n}\nfunction useSyntheticListeners(listeners, id) {\n  return useMemo(() => {\n    return listeners.reduce((acc, _ref) => {\n      let eventName = _ref.eventName,\n        handler = _ref.handler;\n      acc[eventName] = event => {\n        handler(event, id);\n      };\n      return acc;\n    }, {});\n  }, [listeners, id]);\n}\nfunction useWindowRect(element) {\n  return useMemo(() => element ? getWindowClientRect(element) : null, [element]);\n}\nconst defaultValue$2 = [];\nfunction useRects(elements, measure) {\n  if (measure === void 0) {\n    measure = getClientRect;\n  }\n  const _elements = _slicedToArray(elements, 1),\n    firstElement = _elements[0];\n  const windowRect = useWindowRect(firstElement ? getWindow(firstElement) : null);\n  const _useReducer3 = useReducer(reducer, defaultValue$2),\n    _useReducer4 = _slicedToArray(_useReducer3, 2),\n    rects = _useReducer4[0],\n    measureRects = _useReducer4[1];\n  const resizeObserver = useResizeObserver({\n    callback: measureRects\n  });\n  if (elements.length > 0 && rects === defaultValue$2) {\n    measureRects();\n  }\n  useIsomorphicLayoutEffect(() => {\n    if (elements.length) {\n      elements.forEach(element => resizeObserver == null ? void 0 : resizeObserver.observe(element));\n    } else {\n      resizeObserver == null ? void 0 : resizeObserver.disconnect();\n      measureRects();\n    }\n  }, [elements]);\n  return rects;\n  function reducer() {\n    if (!elements.length) {\n      return defaultValue$2;\n    }\n    return elements.map(element => isDocumentScrollingElement(element) ? windowRect : new Rect(measure(element), element));\n  }\n}\nfunction getMeasurableNode(node) {\n  if (!node) {\n    return null;\n  }\n  if (node.children.length > 1) {\n    return node;\n  }\n  const firstChild = node.children[0];\n  return isHTMLElement(firstChild) ? firstChild : node;\n}\nfunction useDragOverlayMeasuring(_ref) {\n  let measure = _ref.measure;\n  const _useState9 = useState(null),\n    _useState10 = _slicedToArray(_useState9, 2),\n    rect = _useState10[0],\n    setRect = _useState10[1];\n  const handleResize = useCallback(entries => {\n    for (const _ref9 of entries) {\n      const target = _ref9.target;\n      if (isHTMLElement(target)) {\n        setRect(rect => {\n          const newRect = measure(target);\n          return rect ? _objectSpread(_objectSpread({}, rect), {}, {\n            width: newRect.width,\n            height: newRect.height\n          }) : newRect;\n        });\n        break;\n      }\n    }\n  }, [measure]);\n  const resizeObserver = useResizeObserver({\n    callback: handleResize\n  });\n  const handleNodeChange = useCallback(element => {\n    const node = getMeasurableNode(element);\n    resizeObserver == null ? void 0 : resizeObserver.disconnect();\n    if (node) {\n      resizeObserver == null ? void 0 : resizeObserver.observe(node);\n    }\n    setRect(node ? measure(node) : null);\n  }, [measure, resizeObserver]);\n  const _useNodeRef = useNodeRef(handleNodeChange),\n    _useNodeRef2 = _slicedToArray(_useNodeRef, 2),\n    nodeRef = _useNodeRef2[0],\n    setRef = _useNodeRef2[1];\n  return useMemo(() => ({\n    nodeRef,\n    rect,\n    setRef\n  }), [rect, nodeRef, setRef]);\n}\nconst defaultSensors = [{\n  sensor: PointerSensor,\n  options: {}\n}, {\n  sensor: KeyboardSensor,\n  options: {}\n}];\nconst defaultData = {\n  current: {}\n};\nconst defaultMeasuringConfiguration = {\n  draggable: {\n    measure: getTransformAgnosticClientRect\n  },\n  droppable: {\n    measure: getTransformAgnosticClientRect,\n    strategy: MeasuringStrategy.WhileDragging,\n    frequency: MeasuringFrequency.Optimized\n  },\n  dragOverlay: {\n    measure: getClientRect\n  }\n};\nclass DroppableContainersMap extends Map {\n  get(id) {\n    var _super$get;\n    return id != null ? (_super$get = super.get(id)) != null ? _super$get : undefined : undefined;\n  }\n  toArray() {\n    return Array.from(this.values());\n  }\n  getEnabled() {\n    return this.toArray().filter(_ref => {\n      let disabled = _ref.disabled;\n      return !disabled;\n    });\n  }\n  getNodeFor(id) {\n    var _this$get$node$curren, _this$get;\n    return (_this$get$node$curren = (_this$get = this.get(id)) == null ? void 0 : _this$get.node.current) != null ? _this$get$node$curren : undefined;\n  }\n}\nconst defaultPublicContext = {\n  activatorEvent: null,\n  active: null,\n  activeNode: null,\n  activeNodeRect: null,\n  collisions: null,\n  containerNodeRect: null,\n  draggableNodes: /*#__PURE__*/new Map(),\n  droppableRects: /*#__PURE__*/new Map(),\n  droppableContainers: /*#__PURE__*/new DroppableContainersMap(),\n  over: null,\n  dragOverlay: {\n    nodeRef: {\n      current: null\n    },\n    rect: null,\n    setRef: noop\n  },\n  scrollableAncestors: [],\n  scrollableAncestorRects: [],\n  measuringConfiguration: defaultMeasuringConfiguration,\n  measureDroppableContainers: noop,\n  windowRect: null,\n  measuringScheduled: false\n};\nconst defaultInternalContext = {\n  activatorEvent: null,\n  activators: [],\n  active: null,\n  activeNodeRect: null,\n  ariaDescribedById: {\n    draggable: ''\n  },\n  dispatch: noop,\n  draggableNodes: /*#__PURE__*/new Map(),\n  over: null,\n  measureDroppableContainers: noop\n};\nconst InternalContext = /*#__PURE__*/createContext(defaultInternalContext);\nconst PublicContext = /*#__PURE__*/createContext(defaultPublicContext);\nfunction getInitialState() {\n  return {\n    draggable: {\n      active: null,\n      initialCoordinates: {\n        x: 0,\n        y: 0\n      },\n      nodes: new Map(),\n      translate: {\n        x: 0,\n        y: 0\n      }\n    },\n    droppable: {\n      containers: new DroppableContainersMap()\n    }\n  };\n}\nfunction reducer(state, action) {\n  switch (action.type) {\n    case Action.DragStart:\n      return _objectSpread(_objectSpread({}, state), {}, {\n        draggable: _objectSpread(_objectSpread({}, state.draggable), {}, {\n          initialCoordinates: action.initialCoordinates,\n          active: action.active\n        })\n      });\n    case Action.DragMove:\n      if (!state.draggable.active) {\n        return state;\n      }\n      return _objectSpread(_objectSpread({}, state), {}, {\n        draggable: _objectSpread(_objectSpread({}, state.draggable), {}, {\n          translate: {\n            x: action.coordinates.x - state.draggable.initialCoordinates.x,\n            y: action.coordinates.y - state.draggable.initialCoordinates.y\n          }\n        })\n      });\n    case Action.DragEnd:\n    case Action.DragCancel:\n      return _objectSpread(_objectSpread({}, state), {}, {\n        draggable: _objectSpread(_objectSpread({}, state.draggable), {}, {\n          active: null,\n          initialCoordinates: {\n            x: 0,\n            y: 0\n          },\n          translate: {\n            x: 0,\n            y: 0\n          }\n        })\n      });\n    case Action.RegisterDroppable:\n      {\n        const element = action.element;\n        const id = element.id;\n        const containers = new DroppableContainersMap(state.droppable.containers);\n        containers.set(id, element);\n        return _objectSpread(_objectSpread({}, state), {}, {\n          droppable: _objectSpread(_objectSpread({}, state.droppable), {}, {\n            containers\n          })\n        });\n      }\n    case Action.SetDroppableDisabled:\n      {\n        const id = action.id,\n          key = action.key,\n          disabled = action.disabled;\n        const element = state.droppable.containers.get(id);\n        if (!element || key !== element.key) {\n          return state;\n        }\n        const containers = new DroppableContainersMap(state.droppable.containers);\n        containers.set(id, _objectSpread(_objectSpread({}, element), {}, {\n          disabled\n        }));\n        return _objectSpread(_objectSpread({}, state), {}, {\n          droppable: _objectSpread(_objectSpread({}, state.droppable), {}, {\n            containers\n          })\n        });\n      }\n    case Action.UnregisterDroppable:\n      {\n        const id = action.id,\n          key = action.key;\n        const element = state.droppable.containers.get(id);\n        if (!element || key !== element.key) {\n          return state;\n        }\n        const containers = new DroppableContainersMap(state.droppable.containers);\n        containers.delete(id);\n        return _objectSpread(_objectSpread({}, state), {}, {\n          droppable: _objectSpread(_objectSpread({}, state.droppable), {}, {\n            containers\n          })\n        });\n      }\n    default:\n      {\n        return state;\n      }\n  }\n}\nfunction RestoreFocus(_ref) {\n  let disabled = _ref.disabled;\n  const _useContext = useContext(InternalContext),\n    active = _useContext.active,\n    activatorEvent = _useContext.activatorEvent,\n    draggableNodes = _useContext.draggableNodes;\n  const previousActivatorEvent = usePrevious(activatorEvent);\n  const previousActiveId = usePrevious(active == null ? void 0 : active.id); // Restore keyboard focus on the activator node\n\n  useEffect(() => {\n    if (disabled) {\n      return;\n    }\n    if (!activatorEvent && previousActivatorEvent && previousActiveId != null) {\n      if (!isKeyboardEvent(previousActivatorEvent)) {\n        return;\n      }\n      if (document.activeElement === previousActivatorEvent.target) {\n        // No need to restore focus\n        return;\n      }\n      const draggableNode = draggableNodes.get(previousActiveId);\n      if (!draggableNode) {\n        return;\n      }\n      const activatorNode = draggableNode.activatorNode,\n        node = draggableNode.node;\n      if (!activatorNode.current && !node.current) {\n        return;\n      }\n      requestAnimationFrame(() => {\n        for (const element of [activatorNode.current, node.current]) {\n          if (!element) {\n            continue;\n          }\n          const focusableNode = findFirstFocusableNode(element);\n          if (focusableNode) {\n            focusableNode.focus();\n            break;\n          }\n        }\n      });\n    }\n  }, [activatorEvent, disabled, draggableNodes, previousActiveId, previousActivatorEvent]);\n  return null;\n}\nfunction applyModifiers(modifiers, _ref) {\n  let transform = _ref.transform,\n    args = _objectWithoutProperties(_ref, _excluded);\n  return modifiers != null && modifiers.length ? modifiers.reduce((accumulator, modifier) => {\n    return modifier(_objectSpread({\n      transform: accumulator\n    }, args));\n  }, transform) : transform;\n}\nfunction useMeasuringConfiguration(config) {\n  return useMemo(() => ({\n    draggable: _objectSpread(_objectSpread({}, defaultMeasuringConfiguration.draggable), config == null ? void 0 : config.draggable),\n    droppable: _objectSpread(_objectSpread({}, defaultMeasuringConfiguration.droppable), config == null ? void 0 : config.droppable),\n    dragOverlay: _objectSpread(_objectSpread({}, defaultMeasuringConfiguration.dragOverlay), config == null ? void 0 : config.dragOverlay)\n  }),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [config == null ? void 0 : config.draggable, config == null ? void 0 : config.droppable, config == null ? void 0 : config.dragOverlay]);\n}\nfunction useLayoutShiftScrollCompensation(_ref) {\n  let activeNode = _ref.activeNode,\n    measure = _ref.measure,\n    initialRect = _ref.initialRect,\n    _ref$config = _ref.config,\n    config = _ref$config === void 0 ? true : _ref$config;\n  const initialized = useRef(false);\n  const _ref10 = typeof config === 'boolean' ? {\n      x: config,\n      y: config\n    } : config,\n    x = _ref10.x,\n    y = _ref10.y;\n  useIsomorphicLayoutEffect(() => {\n    const disabled = !x && !y;\n    if (disabled || !activeNode) {\n      initialized.current = false;\n      return;\n    }\n    if (initialized.current || !initialRect) {\n      // Return early if layout shift scroll compensation was already attempted\n      // or if there is no initialRect to compare to.\n      return;\n    } // Get the most up to date node ref for the active draggable\n\n    const node = activeNode == null ? void 0 : activeNode.node.current;\n    if (!node || node.isConnected === false) {\n      // Return early if there is no attached node ref or if the node is\n      // disconnected from the document.\n      return;\n    }\n    const rect = measure(node);\n    const rectDelta = getRectDelta(rect, initialRect);\n    if (!x) {\n      rectDelta.x = 0;\n    }\n    if (!y) {\n      rectDelta.y = 0;\n    } // Only perform layout shift scroll compensation once\n\n    initialized.current = true;\n    if (Math.abs(rectDelta.x) > 0 || Math.abs(rectDelta.y) > 0) {\n      const firstScrollableAncestor = getFirstScrollableAncestor(node);\n      if (firstScrollableAncestor) {\n        firstScrollableAncestor.scrollBy({\n          top: rectDelta.y,\n          left: rectDelta.x\n        });\n      }\n    }\n  }, [activeNode, x, y, initialRect, measure]);\n}\nconst ActiveDraggableContext = /*#__PURE__*/createContext(_objectSpread(_objectSpread({}, defaultCoordinates), {}, {\n  scaleX: 1,\n  scaleY: 1\n}));\nvar Status;\n(function (Status) {\n  Status[Status[\"Uninitialized\"] = 0] = \"Uninitialized\";\n  Status[Status[\"Initializing\"] = 1] = \"Initializing\";\n  Status[Status[\"Initialized\"] = 2] = \"Initialized\";\n})(Status || (Status = {}));\nconst DndContext = /*#__PURE__*/memo(function DndContext(_ref) {\n  var _sensorContext$curren, _dragOverlay$nodeRef$, _dragOverlay$rect, _over$rect;\n  let id = _ref.id,\n    accessibility = _ref.accessibility,\n    _ref$autoScroll = _ref.autoScroll,\n    autoScroll = _ref$autoScroll === void 0 ? true : _ref$autoScroll,\n    children = _ref.children,\n    _ref$sensors = _ref.sensors,\n    sensors = _ref$sensors === void 0 ? defaultSensors : _ref$sensors,\n    _ref$collisionDetecti = _ref.collisionDetection,\n    collisionDetection = _ref$collisionDetecti === void 0 ? rectIntersection : _ref$collisionDetecti,\n    measuring = _ref.measuring,\n    modifiers = _ref.modifiers,\n    props = _objectWithoutProperties(_ref, _excluded2);\n  const store = useReducer(reducer, undefined, getInitialState);\n  const _store = _slicedToArray(store, 2),\n    state = _store[0],\n    dispatch = _store[1];\n  const _useDndMonitorProvide = useDndMonitorProvider(),\n    _useDndMonitorProvide2 = _slicedToArray(_useDndMonitorProvide, 2),\n    dispatchMonitorEvent = _useDndMonitorProvide2[0],\n    registerMonitorListener = _useDndMonitorProvide2[1];\n  const _useState11 = useState(Status.Uninitialized),\n    _useState12 = _slicedToArray(_useState11, 2),\n    status = _useState12[0],\n    setStatus = _useState12[1];\n  const isInitialized = status === Status.Initialized;\n  const _state$draggable = state.draggable,\n    activeId = _state$draggable.active,\n    draggableNodes = _state$draggable.nodes,\n    translate = _state$draggable.translate,\n    droppableContainers = state.droppable.containers;\n  const node = activeId ? draggableNodes.get(activeId) : null;\n  const activeRects = useRef({\n    initial: null,\n    translated: null\n  });\n  const active = useMemo(() => {\n    var _node$data;\n    return activeId != null ? {\n      id: activeId,\n      // It's possible for the active node to unmount while dragging\n      data: (_node$data = node == null ? void 0 : node.data) != null ? _node$data : defaultData,\n      rect: activeRects\n    } : null;\n  }, [activeId, node]);\n  const activeRef = useRef(null);\n  const _useState13 = useState(null),\n    _useState14 = _slicedToArray(_useState13, 2),\n    activeSensor = _useState14[0],\n    setActiveSensor = _useState14[1];\n  const _useState15 = useState(null),\n    _useState16 = _slicedToArray(_useState15, 2),\n    activatorEvent = _useState16[0],\n    setActivatorEvent = _useState16[1];\n  const latestProps = useLatestValue(props, Object.values(props));\n  const draggableDescribedById = useUniqueId(\"DndDescribedBy\", id);\n  const enabledDroppableContainers = useMemo(() => droppableContainers.getEnabled(), [droppableContainers]);\n  const measuringConfiguration = useMeasuringConfiguration(measuring);\n  const _useDroppableMeasurin = useDroppableMeasuring(enabledDroppableContainers, {\n      dragging: isInitialized,\n      dependencies: [translate.x, translate.y],\n      config: measuringConfiguration.droppable\n    }),\n    droppableRects = _useDroppableMeasurin.droppableRects,\n    measureDroppableContainers = _useDroppableMeasurin.measureDroppableContainers,\n    measuringScheduled = _useDroppableMeasurin.measuringScheduled;\n  const activeNode = useCachedNode(draggableNodes, activeId);\n  const activationCoordinates = useMemo(() => activatorEvent ? getEventCoordinates(activatorEvent) : null, [activatorEvent]);\n  const autoScrollOptions = getAutoScrollerOptions();\n  const initialActiveNodeRect = useInitialRect(activeNode, measuringConfiguration.draggable.measure);\n  useLayoutShiftScrollCompensation({\n    activeNode: activeId ? draggableNodes.get(activeId) : null,\n    config: autoScrollOptions.layoutShiftCompensation,\n    initialRect: initialActiveNodeRect,\n    measure: measuringConfiguration.draggable.measure\n  });\n  const activeNodeRect = useRect(activeNode, measuringConfiguration.draggable.measure, initialActiveNodeRect);\n  const containerNodeRect = useRect(activeNode ? activeNode.parentElement : null);\n  const sensorContext = useRef({\n    activatorEvent: null,\n    active: null,\n    activeNode,\n    collisionRect: null,\n    collisions: null,\n    droppableRects,\n    draggableNodes,\n    draggingNode: null,\n    draggingNodeRect: null,\n    droppableContainers,\n    over: null,\n    scrollableAncestors: [],\n    scrollAdjustedTranslate: null\n  });\n  const overNode = droppableContainers.getNodeFor((_sensorContext$curren = sensorContext.current.over) == null ? void 0 : _sensorContext$curren.id);\n  const dragOverlay = useDragOverlayMeasuring({\n    measure: measuringConfiguration.dragOverlay.measure\n  }); // Use the rect of the drag overlay if it is mounted\n\n  const draggingNode = (_dragOverlay$nodeRef$ = dragOverlay.nodeRef.current) != null ? _dragOverlay$nodeRef$ : activeNode;\n  const draggingNodeRect = isInitialized ? (_dragOverlay$rect = dragOverlay.rect) != null ? _dragOverlay$rect : activeNodeRect : null;\n  const usesDragOverlay = Boolean(dragOverlay.nodeRef.current && dragOverlay.rect); // The delta between the previous and new position of the draggable node\n  // is only relevant when there is no drag overlay\n\n  const nodeRectDelta = useRectDelta(usesDragOverlay ? null : activeNodeRect); // Get the window rect of the dragging node\n\n  const windowRect = useWindowRect(draggingNode ? getWindow(draggingNode) : null); // Get scrollable ancestors of the dragging node\n\n  const scrollableAncestors = useScrollableAncestors(isInitialized ? overNode != null ? overNode : activeNode : null);\n  const scrollableAncestorRects = useRects(scrollableAncestors); // Apply modifiers\n\n  const modifiedTranslate = applyModifiers(modifiers, {\n    transform: {\n      x: translate.x - nodeRectDelta.x,\n      y: translate.y - nodeRectDelta.y,\n      scaleX: 1,\n      scaleY: 1\n    },\n    activatorEvent,\n    active,\n    activeNodeRect,\n    containerNodeRect,\n    draggingNodeRect,\n    over: sensorContext.current.over,\n    overlayNodeRect: dragOverlay.rect,\n    scrollableAncestors,\n    scrollableAncestorRects,\n    windowRect\n  });\n  const pointerCoordinates = activationCoordinates ? add(activationCoordinates, translate) : null;\n  const scrollOffsets = useScrollOffsets(scrollableAncestors); // Represents the scroll delta since dragging was initiated\n\n  const scrollAdjustment = useScrollOffsetsDelta(scrollOffsets); // Represents the scroll delta since the last time the active node rect was measured\n\n  const activeNodeScrollDelta = useScrollOffsetsDelta(scrollOffsets, [activeNodeRect]);\n  const scrollAdjustedTranslate = add(modifiedTranslate, scrollAdjustment);\n  const collisionRect = draggingNodeRect ? getAdjustedRect(draggingNodeRect, modifiedTranslate) : null;\n  const collisions = active && collisionRect ? collisionDetection({\n    active,\n    collisionRect,\n    droppableRects,\n    droppableContainers: enabledDroppableContainers,\n    pointerCoordinates\n  }) : null;\n  const overId = getFirstCollision(collisions, 'id');\n  const _useState17 = useState(null),\n    _useState18 = _slicedToArray(_useState17, 2),\n    over = _useState18[0],\n    setOver = _useState18[1]; // When there is no drag overlay used, we need to account for the\n  // window scroll delta\n\n  const appliedTranslate = usesDragOverlay ? modifiedTranslate : add(modifiedTranslate, activeNodeScrollDelta);\n  const transform = adjustScale(appliedTranslate, (_over$rect = over == null ? void 0 : over.rect) != null ? _over$rect : null, activeNodeRect);\n  const instantiateSensor = useCallback((event, _ref2) => {\n    let Sensor = _ref2.sensor,\n      options = _ref2.options;\n    if (activeRef.current == null) {\n      return;\n    }\n    const activeNode = draggableNodes.get(activeRef.current);\n    if (!activeNode) {\n      return;\n    }\n    const activatorEvent = event.nativeEvent;\n    const sensorInstance = new Sensor({\n      active: activeRef.current,\n      activeNode,\n      event: activatorEvent,\n      options,\n      // Sensors need to be instantiated with refs for arguments that change over time\n      // otherwise they are frozen in time with the stale arguments\n      context: sensorContext,\n      onStart(initialCoordinates) {\n        const id = activeRef.current;\n        if (id == null) {\n          return;\n        }\n        const draggableNode = draggableNodes.get(id);\n        if (!draggableNode) {\n          return;\n        }\n        const onDragStart = latestProps.current.onDragStart;\n        const event = {\n          active: {\n            id,\n            data: draggableNode.data,\n            rect: activeRects\n          }\n        };\n        unstable_batchedUpdates(() => {\n          onDragStart == null ? void 0 : onDragStart(event);\n          setStatus(Status.Initializing);\n          dispatch({\n            type: Action.DragStart,\n            initialCoordinates,\n            active: id\n          });\n          dispatchMonitorEvent({\n            type: 'onDragStart',\n            event\n          });\n        });\n      },\n      onMove(coordinates) {\n        dispatch({\n          type: Action.DragMove,\n          coordinates\n        });\n      },\n      onEnd: createHandler(Action.DragEnd),\n      onCancel: createHandler(Action.DragCancel)\n    });\n    unstable_batchedUpdates(() => {\n      setActiveSensor(sensorInstance);\n      setActivatorEvent(event.nativeEvent);\n    });\n    function createHandler(type) {\n      return async function handler() {\n        const _sensorContext$curren2 = sensorContext.current,\n          active = _sensorContext$curren2.active,\n          collisions = _sensorContext$curren2.collisions,\n          over = _sensorContext$curren2.over,\n          scrollAdjustedTranslate = _sensorContext$curren2.scrollAdjustedTranslate;\n        let event = null;\n        if (active && scrollAdjustedTranslate) {\n          const cancelDrop = latestProps.current.cancelDrop;\n          event = {\n            activatorEvent,\n            active: active,\n            collisions,\n            delta: scrollAdjustedTranslate,\n            over\n          };\n          if (type === Action.DragEnd && typeof cancelDrop === 'function') {\n            const shouldCancel = await Promise.resolve(cancelDrop(event));\n            if (shouldCancel) {\n              type = Action.DragCancel;\n            }\n          }\n        }\n        activeRef.current = null;\n        unstable_batchedUpdates(() => {\n          dispatch({\n            type\n          });\n          setStatus(Status.Uninitialized);\n          setOver(null);\n          setActiveSensor(null);\n          setActivatorEvent(null);\n          const eventName = type === Action.DragEnd ? 'onDragEnd' : 'onDragCancel';\n          if (event) {\n            const handler = latestProps.current[eventName];\n            handler == null ? void 0 : handler(event);\n            dispatchMonitorEvent({\n              type: eventName,\n              event\n            });\n          }\n        });\n      };\n    }\n  },\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [draggableNodes]);\n  const bindActivatorToSensorInstantiator = useCallback((handler, sensor) => {\n    return (event, active) => {\n      const nativeEvent = event.nativeEvent;\n      const activeDraggableNode = draggableNodes.get(active);\n      if (\n      // Another sensor is already instantiating\n      activeRef.current !== null ||\n      // No active draggable\n      !activeDraggableNode ||\n      // Event has already been captured\n      nativeEvent.dndKit || nativeEvent.defaultPrevented) {\n        return;\n      }\n      const activationContext = {\n        active: activeDraggableNode\n      };\n      const shouldActivate = handler(event, sensor.options, activationContext);\n      if (shouldActivate === true) {\n        nativeEvent.dndKit = {\n          capturedBy: sensor.sensor\n        };\n        activeRef.current = active;\n        instantiateSensor(event, sensor);\n      }\n    };\n  }, [draggableNodes, instantiateSensor]);\n  const activators = useCombineActivators(sensors, bindActivatorToSensorInstantiator);\n  useSensorSetup(sensors);\n  useIsomorphicLayoutEffect(() => {\n    if (activeNodeRect && status === Status.Initializing) {\n      setStatus(Status.Initialized);\n    }\n  }, [activeNodeRect, status]);\n  useEffect(() => {\n    const onDragMove = latestProps.current.onDragMove;\n    const _sensorContext$curren3 = sensorContext.current,\n      active = _sensorContext$curren3.active,\n      activatorEvent = _sensorContext$curren3.activatorEvent,\n      collisions = _sensorContext$curren3.collisions,\n      over = _sensorContext$curren3.over;\n    if (!active || !activatorEvent) {\n      return;\n    }\n    const event = {\n      active,\n      activatorEvent,\n      collisions,\n      delta: {\n        x: scrollAdjustedTranslate.x,\n        y: scrollAdjustedTranslate.y\n      },\n      over\n    };\n    unstable_batchedUpdates(() => {\n      onDragMove == null ? void 0 : onDragMove(event);\n      dispatchMonitorEvent({\n        type: 'onDragMove',\n        event\n      });\n    });\n  },\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [scrollAdjustedTranslate.x, scrollAdjustedTranslate.y]);\n  useEffect(() => {\n    const _sensorContext$curren4 = sensorContext.current,\n      active = _sensorContext$curren4.active,\n      activatorEvent = _sensorContext$curren4.activatorEvent,\n      collisions = _sensorContext$curren4.collisions,\n      droppableContainers = _sensorContext$curren4.droppableContainers,\n      scrollAdjustedTranslate = _sensorContext$curren4.scrollAdjustedTranslate;\n    if (!active || activeRef.current == null || !activatorEvent || !scrollAdjustedTranslate) {\n      return;\n    }\n    const onDragOver = latestProps.current.onDragOver;\n    const overContainer = droppableContainers.get(overId);\n    const over = overContainer && overContainer.rect.current ? {\n      id: overContainer.id,\n      rect: overContainer.rect.current,\n      data: overContainer.data,\n      disabled: overContainer.disabled\n    } : null;\n    const event = {\n      active,\n      activatorEvent,\n      collisions,\n      delta: {\n        x: scrollAdjustedTranslate.x,\n        y: scrollAdjustedTranslate.y\n      },\n      over\n    };\n    unstable_batchedUpdates(() => {\n      setOver(over);\n      onDragOver == null ? void 0 : onDragOver(event);\n      dispatchMonitorEvent({\n        type: 'onDragOver',\n        event\n      });\n    });\n  },\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [overId]);\n  useIsomorphicLayoutEffect(() => {\n    sensorContext.current = {\n      activatorEvent,\n      active,\n      activeNode,\n      collisionRect,\n      collisions,\n      droppableRects,\n      draggableNodes,\n      draggingNode,\n      draggingNodeRect,\n      droppableContainers,\n      over,\n      scrollableAncestors,\n      scrollAdjustedTranslate\n    };\n    activeRects.current = {\n      initial: draggingNodeRect,\n      translated: collisionRect\n    };\n  }, [active, activeNode, collisions, collisionRect, draggableNodes, draggingNode, draggingNodeRect, droppableRects, droppableContainers, over, scrollableAncestors, scrollAdjustedTranslate]);\n  useAutoScroller(_objectSpread(_objectSpread({}, autoScrollOptions), {}, {\n    delta: translate,\n    draggingRect: collisionRect,\n    pointerCoordinates,\n    scrollableAncestors,\n    scrollableAncestorRects\n  }));\n  const publicContext = useMemo(() => {\n    const context = {\n      active,\n      activeNode,\n      activeNodeRect,\n      activatorEvent,\n      collisions,\n      containerNodeRect,\n      dragOverlay,\n      draggableNodes,\n      droppableContainers,\n      droppableRects,\n      over,\n      measureDroppableContainers,\n      scrollableAncestors,\n      scrollableAncestorRects,\n      measuringConfiguration,\n      measuringScheduled,\n      windowRect\n    };\n    return context;\n  }, [active, activeNode, activeNodeRect, activatorEvent, collisions, containerNodeRect, dragOverlay, draggableNodes, droppableContainers, droppableRects, over, measureDroppableContainers, scrollableAncestors, scrollableAncestorRects, measuringConfiguration, measuringScheduled, windowRect]);\n  const internalContext = useMemo(() => {\n    const context = {\n      activatorEvent,\n      activators,\n      active,\n      activeNodeRect,\n      ariaDescribedById: {\n        draggable: draggableDescribedById\n      },\n      dispatch,\n      draggableNodes,\n      over,\n      measureDroppableContainers\n    };\n    return context;\n  }, [activatorEvent, activators, active, activeNodeRect, dispatch, draggableDescribedById, draggableNodes, over, measureDroppableContainers]);\n  return /*#__PURE__*/React.createElement(DndMonitorContext.Provider, {\n    value: registerMonitorListener\n  }, /*#__PURE__*/React.createElement(InternalContext.Provider, {\n    value: internalContext\n  }, /*#__PURE__*/React.createElement(PublicContext.Provider, {\n    value: publicContext\n  }, /*#__PURE__*/React.createElement(ActiveDraggableContext.Provider, {\n    value: transform\n  }, children)), /*#__PURE__*/React.createElement(RestoreFocus, {\n    disabled: (accessibility == null ? void 0 : accessibility.restoreFocus) === false\n  })), /*#__PURE__*/React.createElement(Accessibility, _objectSpread(_objectSpread({}, accessibility), {}, {\n    hiddenTextDescribedById: draggableDescribedById\n  })));\n  function getAutoScrollerOptions() {\n    const activeSensorDisablesAutoscroll = (activeSensor == null ? void 0 : activeSensor.autoScrollEnabled) === false;\n    const autoScrollGloballyDisabled = typeof autoScroll === 'object' ? autoScroll.enabled === false : autoScroll === false;\n    const enabled = isInitialized && !activeSensorDisablesAutoscroll && !autoScrollGloballyDisabled;\n    if (typeof autoScroll === 'object') {\n      return _objectSpread(_objectSpread({}, autoScroll), {}, {\n        enabled\n      });\n    }\n    return {\n      enabled\n    };\n  }\n});\nconst NullContext = /*#__PURE__*/createContext(null);\nconst defaultRole = 'button';\nconst ID_PREFIX = 'Droppable';\nfunction useDraggable(_ref) {\n  let id = _ref.id,\n    data = _ref.data,\n    _ref$disabled = _ref.disabled,\n    disabled = _ref$disabled === void 0 ? false : _ref$disabled,\n    attributes = _ref.attributes;\n  const key = useUniqueId(ID_PREFIX);\n  const _useContext2 = useContext(InternalContext),\n    activators = _useContext2.activators,\n    activatorEvent = _useContext2.activatorEvent,\n    active = _useContext2.active,\n    activeNodeRect = _useContext2.activeNodeRect,\n    ariaDescribedById = _useContext2.ariaDescribedById,\n    draggableNodes = _useContext2.draggableNodes,\n    over = _useContext2.over;\n  const _ref11 = attributes != null ? attributes : {},\n    _ref11$role = _ref11.role,\n    role = _ref11$role === void 0 ? defaultRole : _ref11$role,\n    _ref11$roleDescriptio = _ref11.roleDescription,\n    roleDescription = _ref11$roleDescriptio === void 0 ? 'draggable' : _ref11$roleDescriptio,\n    _ref11$tabIndex = _ref11.tabIndex,\n    tabIndex = _ref11$tabIndex === void 0 ? 0 : _ref11$tabIndex;\n  const isDragging = (active == null ? void 0 : active.id) === id;\n  const transform = useContext(isDragging ? ActiveDraggableContext : NullContext);\n  const _useNodeRef3 = useNodeRef(),\n    _useNodeRef4 = _slicedToArray(_useNodeRef3, 2),\n    node = _useNodeRef4[0],\n    setNodeRef = _useNodeRef4[1];\n  const _useNodeRef5 = useNodeRef(),\n    _useNodeRef6 = _slicedToArray(_useNodeRef5, 2),\n    activatorNode = _useNodeRef6[0],\n    setActivatorNodeRef = _useNodeRef6[1];\n  const listeners = useSyntheticListeners(activators, id);\n  const dataRef = useLatestValue(data);\n  useIsomorphicLayoutEffect(() => {\n    draggableNodes.set(id, {\n      id,\n      key,\n      node,\n      activatorNode,\n      data: dataRef\n    });\n    return () => {\n      const node = draggableNodes.get(id);\n      if (node && node.key === key) {\n        draggableNodes.delete(id);\n      }\n    };\n  },\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [draggableNodes, id]);\n  const memoizedAttributes = useMemo(() => ({\n    role,\n    tabIndex,\n    'aria-disabled': disabled,\n    'aria-pressed': isDragging && role === defaultRole ? true : undefined,\n    'aria-roledescription': roleDescription,\n    'aria-describedby': ariaDescribedById.draggable\n  }), [disabled, role, tabIndex, isDragging, roleDescription, ariaDescribedById.draggable]);\n  return {\n    active,\n    activatorEvent,\n    activeNodeRect,\n    attributes: memoizedAttributes,\n    isDragging,\n    listeners: disabled ? undefined : listeners,\n    node,\n    over,\n    setNodeRef,\n    setActivatorNodeRef,\n    transform\n  };\n}\nfunction useDndContext() {\n  return useContext(PublicContext);\n}\nconst ID_PREFIX$1 = 'Droppable';\nconst defaultResizeObserverConfig = {\n  timeout: 25\n};\nfunction useDroppable(_ref) {\n  let data = _ref.data,\n    _ref$disabled2 = _ref.disabled,\n    disabled = _ref$disabled2 === void 0 ? false : _ref$disabled2,\n    id = _ref.id,\n    resizeObserverConfig = _ref.resizeObserverConfig;\n  const key = useUniqueId(ID_PREFIX$1);\n  const _useContext3 = useContext(InternalContext),\n    active = _useContext3.active,\n    dispatch = _useContext3.dispatch,\n    over = _useContext3.over,\n    measureDroppableContainers = _useContext3.measureDroppableContainers;\n  const previous = useRef({\n    disabled\n  });\n  const resizeObserverConnected = useRef(false);\n  const rect = useRef(null);\n  const callbackId = useRef(null);\n  const _defaultResizeObserve = _objectSpread(_objectSpread({}, defaultResizeObserverConfig), resizeObserverConfig),\n    resizeObserverDisabled = _defaultResizeObserve.disabled,\n    updateMeasurementsFor = _defaultResizeObserve.updateMeasurementsFor,\n    resizeObserverTimeout = _defaultResizeObserve.timeout;\n  const ids = useLatestValue(updateMeasurementsFor != null ? updateMeasurementsFor : id);\n  const handleResize = useCallback(() => {\n    if (!resizeObserverConnected.current) {\n      // ResizeObserver invokes the `handleResize` callback as soon as `observe` is called,\n      // assuming the element is rendered and displayed.\n      resizeObserverConnected.current = true;\n      return;\n    }\n    if (callbackId.current != null) {\n      clearTimeout(callbackId.current);\n    }\n    callbackId.current = setTimeout(() => {\n      measureDroppableContainers(Array.isArray(ids.current) ? ids.current : [ids.current]);\n      callbackId.current = null;\n    }, resizeObserverTimeout);\n  },\n  //eslint-disable-next-line react-hooks/exhaustive-deps\n  [resizeObserverTimeout]);\n  const resizeObserver = useResizeObserver({\n    callback: handleResize,\n    disabled: resizeObserverDisabled || !active\n  });\n  const handleNodeChange = useCallback((newElement, previousElement) => {\n    if (!resizeObserver) {\n      return;\n    }\n    if (previousElement) {\n      resizeObserver.unobserve(previousElement);\n      resizeObserverConnected.current = false;\n    }\n    if (newElement) {\n      resizeObserver.observe(newElement);\n    }\n  }, [resizeObserver]);\n  const _useNodeRef7 = useNodeRef(handleNodeChange),\n    _useNodeRef8 = _slicedToArray(_useNodeRef7, 2),\n    nodeRef = _useNodeRef8[0],\n    setNodeRef = _useNodeRef8[1];\n  const dataRef = useLatestValue(data);\n  useEffect(() => {\n    if (!resizeObserver || !nodeRef.current) {\n      return;\n    }\n    resizeObserver.disconnect();\n    resizeObserverConnected.current = false;\n    resizeObserver.observe(nodeRef.current);\n  }, [nodeRef, resizeObserver]);\n  useIsomorphicLayoutEffect(() => {\n    dispatch({\n      type: Action.RegisterDroppable,\n      element: {\n        id,\n        key,\n        disabled,\n        node: nodeRef,\n        rect,\n        data: dataRef\n      }\n    });\n    return () => dispatch({\n      type: Action.UnregisterDroppable,\n      key,\n      id\n    });\n  },\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [id]);\n  useEffect(() => {\n    if (disabled !== previous.current.disabled) {\n      dispatch({\n        type: Action.SetDroppableDisabled,\n        id,\n        key,\n        disabled\n      });\n      previous.current.disabled = disabled;\n    }\n  }, [id, key, disabled, dispatch]);\n  return {\n    active,\n    rect,\n    isOver: (over == null ? void 0 : over.id) === id,\n    node: nodeRef,\n    over,\n    setNodeRef\n  };\n}\nfunction AnimationManager(_ref) {\n  let animation = _ref.animation,\n    children = _ref.children;\n  const _useState19 = useState(null),\n    _useState20 = _slicedToArray(_useState19, 2),\n    clonedChildren = _useState20[0],\n    setClonedChildren = _useState20[1];\n  const _useState21 = useState(null),\n    _useState22 = _slicedToArray(_useState21, 2),\n    element = _useState22[0],\n    setElement = _useState22[1];\n  const previousChildren = usePrevious(children);\n  if (!children && !clonedChildren && previousChildren) {\n    setClonedChildren(previousChildren);\n  }\n  useIsomorphicLayoutEffect(() => {\n    if (!element) {\n      return;\n    }\n    const key = clonedChildren == null ? void 0 : clonedChildren.key;\n    const id = clonedChildren == null ? void 0 : clonedChildren.props.id;\n    if (key == null || id == null) {\n      setClonedChildren(null);\n      return;\n    }\n    Promise.resolve(animation(id, element)).then(() => {\n      setClonedChildren(null);\n    });\n  }, [animation, clonedChildren, element]);\n  return /*#__PURE__*/React.createElement(React.Fragment, null, children, clonedChildren ? /*#__PURE__*/cloneElement(clonedChildren, {\n    ref: setElement\n  }) : null);\n}\nconst defaultTransform = {\n  x: 0,\n  y: 0,\n  scaleX: 1,\n  scaleY: 1\n};\nfunction NullifiedContextProvider(_ref) {\n  let children = _ref.children;\n  return /*#__PURE__*/React.createElement(InternalContext.Provider, {\n    value: defaultInternalContext\n  }, /*#__PURE__*/React.createElement(ActiveDraggableContext.Provider, {\n    value: defaultTransform\n  }, children));\n}\nconst baseStyles = {\n  position: 'fixed',\n  touchAction: 'none'\n};\nconst defaultTransition = activatorEvent => {\n  const isKeyboardActivator = isKeyboardEvent(activatorEvent);\n  return isKeyboardActivator ? 'transform 250ms ease' : undefined;\n};\nconst PositionedOverlay = /*#__PURE__*/forwardRef((_ref, ref) => {\n  let as = _ref.as,\n    activatorEvent = _ref.activatorEvent,\n    adjustScale = _ref.adjustScale,\n    children = _ref.children,\n    className = _ref.className,\n    rect = _ref.rect,\n    style = _ref.style,\n    transform = _ref.transform,\n    _ref$transition = _ref.transition,\n    transition = _ref$transition === void 0 ? defaultTransition : _ref$transition;\n  if (!rect) {\n    return null;\n  }\n  const scaleAdjustedTransform = adjustScale ? transform : _objectSpread(_objectSpread({}, transform), {}, {\n    scaleX: 1,\n    scaleY: 1\n  });\n  const styles = _objectSpread(_objectSpread({}, baseStyles), {}, {\n    width: rect.width,\n    height: rect.height,\n    top: rect.top,\n    left: rect.left,\n    transform: CSS.Transform.toString(scaleAdjustedTransform),\n    transformOrigin: adjustScale && activatorEvent ? getRelativeTransformOrigin(activatorEvent, rect) : undefined,\n    transition: typeof transition === 'function' ? transition(activatorEvent) : transition\n  }, style);\n  return /*#__PURE__*/React.createElement(as, {\n    className,\n    style: styles,\n    ref\n  }, children);\n});\nconst defaultDropAnimationSideEffects = options => _ref => {\n  let active = _ref.active,\n    dragOverlay = _ref.dragOverlay;\n  const originalStyles = {};\n  const styles = options.styles,\n    className = options.className;\n  if (styles != null && styles.active) {\n    for (const _ref12 of Object.entries(styles.active)) {\n      var _ref13 = _slicedToArray(_ref12, 2);\n      const key = _ref13[0];\n      const value = _ref13[1];\n      if (value === undefined) {\n        continue;\n      }\n      originalStyles[key] = active.node.style.getPropertyValue(key);\n      active.node.style.setProperty(key, value);\n    }\n  }\n  if (styles != null && styles.dragOverlay) {\n    for (const _ref14 of Object.entries(styles.dragOverlay)) {\n      var _ref15 = _slicedToArray(_ref14, 2);\n      const key = _ref15[0];\n      const value = _ref15[1];\n      if (value === undefined) {\n        continue;\n      }\n      dragOverlay.node.style.setProperty(key, value);\n    }\n  }\n  if (className != null && className.active) {\n    active.node.classList.add(className.active);\n  }\n  if (className != null && className.dragOverlay) {\n    dragOverlay.node.classList.add(className.dragOverlay);\n  }\n  return function cleanup() {\n    for (const _ref16 of Object.entries(originalStyles)) {\n      var _ref17 = _slicedToArray(_ref16, 2);\n      const key = _ref17[0];\n      const value = _ref17[1];\n      active.node.style.setProperty(key, value);\n    }\n    if (className != null && className.active) {\n      active.node.classList.remove(className.active);\n    }\n  };\n};\nconst defaultKeyframeResolver = _ref2 => {\n  let _ref2$transform = _ref2.transform,\n    initial = _ref2$transform.initial,\n    final = _ref2$transform.final;\n  return [{\n    transform: CSS.Transform.toString(initial)\n  }, {\n    transform: CSS.Transform.toString(final)\n  }];\n};\nconst defaultDropAnimationConfiguration = {\n  duration: 250,\n  easing: 'ease',\n  keyframes: defaultKeyframeResolver,\n  sideEffects: /*#__PURE__*/defaultDropAnimationSideEffects({\n    styles: {\n      active: {\n        opacity: '0'\n      }\n    }\n  })\n};\nfunction useDropAnimation(_ref3) {\n  let config = _ref3.config,\n    draggableNodes = _ref3.draggableNodes,\n    droppableContainers = _ref3.droppableContainers,\n    measuringConfiguration = _ref3.measuringConfiguration;\n  return useEvent((id, node) => {\n    if (config === null) {\n      return;\n    }\n    const activeDraggable = draggableNodes.get(id);\n    if (!activeDraggable) {\n      return;\n    }\n    const activeNode = activeDraggable.node.current;\n    if (!activeNode) {\n      return;\n    }\n    const measurableNode = getMeasurableNode(node);\n    if (!measurableNode) {\n      return;\n    }\n    const _getWindow$getCompute2 = getWindow(node).getComputedStyle(node),\n      transform = _getWindow$getCompute2.transform;\n    const parsedTransform = parseTransform(transform);\n    if (!parsedTransform) {\n      return;\n    }\n    const animation = typeof config === 'function' ? config : createDefaultDropAnimation(config);\n    scrollIntoViewIfNeeded(activeNode, measuringConfiguration.draggable.measure);\n    return animation({\n      active: {\n        id,\n        data: activeDraggable.data,\n        node: activeNode,\n        rect: measuringConfiguration.draggable.measure(activeNode)\n      },\n      draggableNodes,\n      dragOverlay: {\n        node,\n        rect: measuringConfiguration.dragOverlay.measure(measurableNode)\n      },\n      droppableContainers,\n      measuringConfiguration,\n      transform: parsedTransform\n    });\n  });\n}\nfunction createDefaultDropAnimation(options) {\n  const _defaultDropAnimation = _objectSpread(_objectSpread({}, defaultDropAnimationConfiguration), options),\n    duration = _defaultDropAnimation.duration,\n    easing = _defaultDropAnimation.easing,\n    sideEffects = _defaultDropAnimation.sideEffects,\n    keyframes = _defaultDropAnimation.keyframes;\n  return _ref4 => {\n    let active = _ref4.active,\n      dragOverlay = _ref4.dragOverlay,\n      transform = _ref4.transform,\n      rest = _objectWithoutProperties(_ref4, _excluded3);\n    if (!duration) {\n      // Do not animate if animation duration is zero.\n      return;\n    }\n    const delta = {\n      x: dragOverlay.rect.left - active.rect.left,\n      y: dragOverlay.rect.top - active.rect.top\n    };\n    const scale = {\n      scaleX: transform.scaleX !== 1 ? active.rect.width * transform.scaleX / dragOverlay.rect.width : 1,\n      scaleY: transform.scaleY !== 1 ? active.rect.height * transform.scaleY / dragOverlay.rect.height : 1\n    };\n    const finalTransform = _objectSpread({\n      x: transform.x - delta.x,\n      y: transform.y - delta.y\n    }, scale);\n    const animationKeyframes = keyframes(_objectSpread(_objectSpread({}, rest), {}, {\n      active,\n      dragOverlay,\n      transform: {\n        initial: transform,\n        final: finalTransform\n      }\n    }));\n    const _animationKeyframes = _slicedToArray(animationKeyframes, 1),\n      firstKeyframe = _animationKeyframes[0];\n    const lastKeyframe = animationKeyframes[animationKeyframes.length - 1];\n    if (JSON.stringify(firstKeyframe) === JSON.stringify(lastKeyframe)) {\n      // The start and end keyframes are the same, infer that there is no animation needed.\n      return;\n    }\n    const cleanup = sideEffects == null ? void 0 : sideEffects(_objectSpread({\n      active,\n      dragOverlay\n    }, rest));\n    const animation = dragOverlay.node.animate(animationKeyframes, {\n      duration,\n      easing,\n      fill: 'forwards'\n    });\n    return new Promise(resolve => {\n      animation.onfinish = () => {\n        cleanup == null ? void 0 : cleanup();\n        resolve();\n      };\n    });\n  };\n}\nlet key = 0;\nfunction useKey(id) {\n  return useMemo(() => {\n    if (id == null) {\n      return;\n    }\n    key++;\n    return key;\n  }, [id]);\n}\nconst DragOverlay = /*#__PURE__*/React.memo(_ref => {\n  let _ref$adjustScale = _ref.adjustScale,\n    adjustScale = _ref$adjustScale === void 0 ? false : _ref$adjustScale,\n    children = _ref.children,\n    dropAnimationConfig = _ref.dropAnimation,\n    style = _ref.style,\n    transition = _ref.transition,\n    modifiers = _ref.modifiers,\n    _ref$wrapperElement = _ref.wrapperElement,\n    wrapperElement = _ref$wrapperElement === void 0 ? 'div' : _ref$wrapperElement,\n    className = _ref.className,\n    _ref$zIndex = _ref.zIndex,\n    zIndex = _ref$zIndex === void 0 ? 999 : _ref$zIndex;\n  const _useDndContext = useDndContext(),\n    activatorEvent = _useDndContext.activatorEvent,\n    active = _useDndContext.active,\n    activeNodeRect = _useDndContext.activeNodeRect,\n    containerNodeRect = _useDndContext.containerNodeRect,\n    draggableNodes = _useDndContext.draggableNodes,\n    droppableContainers = _useDndContext.droppableContainers,\n    dragOverlay = _useDndContext.dragOverlay,\n    over = _useDndContext.over,\n    measuringConfiguration = _useDndContext.measuringConfiguration,\n    scrollableAncestors = _useDndContext.scrollableAncestors,\n    scrollableAncestorRects = _useDndContext.scrollableAncestorRects,\n    windowRect = _useDndContext.windowRect;\n  const transform = useContext(ActiveDraggableContext);\n  const key = useKey(active == null ? void 0 : active.id);\n  const modifiedTransform = applyModifiers(modifiers, {\n    activatorEvent,\n    active,\n    activeNodeRect,\n    containerNodeRect,\n    draggingNodeRect: dragOverlay.rect,\n    over,\n    overlayNodeRect: dragOverlay.rect,\n    scrollableAncestors,\n    scrollableAncestorRects,\n    transform,\n    windowRect\n  });\n  const initialRect = useInitialValue(activeNodeRect);\n  const dropAnimation = useDropAnimation({\n    config: dropAnimationConfig,\n    draggableNodes,\n    droppableContainers,\n    measuringConfiguration\n  }); // We need to wait for the active node to be measured before connecting the drag overlay ref\n  // otherwise collisions can be computed against a mispositioned drag overlay\n\n  const ref = initialRect ? dragOverlay.setRef : undefined;\n  return /*#__PURE__*/React.createElement(NullifiedContextProvider, null, /*#__PURE__*/React.createElement(AnimationManager, {\n    animation: dropAnimation\n  }, active && key ? /*#__PURE__*/React.createElement(PositionedOverlay, {\n    key: key,\n    id: active.id,\n    ref: ref,\n    as: wrapperElement,\n    activatorEvent: activatorEvent,\n    adjustScale: adjustScale,\n    className: className,\n    transition: transition,\n    rect: initialRect,\n    style: _objectSpread({\n      zIndex\n    }, style),\n    transform: modifiedTransform\n  }, children) : null));\n});\nexport { AutoScrollActivator, DndContext, DragOverlay, KeyboardCode, KeyboardSensor, MeasuringFrequency, MeasuringStrategy, MouseSensor, PointerSensor, TouchSensor, TraversalOrder, applyModifiers, closestCenter, closestCorners, defaultAnnouncements, defaultCoordinates, defaultDropAnimationConfiguration as defaultDropAnimation, defaultDropAnimationSideEffects, defaultScreenReaderInstructions, getClientRect, getFirstCollision, getScrollableAncestors, pointerWithin, rectIntersection, useDndContext, useDndMonitor, useDraggable, useDroppable, useSensor, useSensors };","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\n/* global Reflect, Promise, SuppressedError, Symbol */\n\nvar extendStatics = function (d, b) {\n  extendStatics = Object.setPrototypeOf || {\n    __proto__: []\n  } instanceof Array && function (d, b) {\n    d.__proto__ = b;\n  } || function (d, b) {\n    for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];\n  };\n  return extendStatics(d, b);\n};\nexport function __extends(d, b) {\n  if (typeof b !== \"function\" && b !== null) throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n  extendStatics(d, b);\n  function __() {\n    this.constructor = d;\n  }\n  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\nexport var __assign = function () {\n  __assign = Object.assign || function __assign(t) {\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\n      s = arguments[i];\n      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n    }\n    return t;\n  };\n  return __assign.apply(this, arguments);\n};\nexport function __rest(s, e) {\n  var t = {};\n  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];\n  if (s != null && typeof Object.getOwnPropertySymbols === \"function\") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];\n  }\n  return t;\n}\nexport function __decorate(decorators, target, key, desc) {\n  var c = arguments.length,\n    r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,\n    d;\n  if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\nexport function __param(paramIndex, decorator) {\n  return function (target, key) {\n    decorator(target, key, paramIndex);\n  };\n}\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\n  function accept(f) {\n    if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\");\n    return f;\n  }\n  var kind = contextIn.kind,\n    key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\n  var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\n  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\n  var _,\n    done = false;\n  for (var i = decorators.length - 1; i >= 0; i--) {\n    var context = {};\n    for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\n    for (var p in contextIn.access) context.access[p] = contextIn.access[p];\n    context.addInitializer = function (f) {\n      if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\");\n      extraInitializers.push(accept(f || null));\n    };\n    var result = (0, decorators[i])(kind === \"accessor\" ? {\n      get: descriptor.get,\n      set: descriptor.set\n    } : descriptor[key], context);\n    if (kind === \"accessor\") {\n      if (result === void 0) continue;\n      if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\n      if (_ = accept(result.get)) descriptor.get = _;\n      if (_ = accept(result.set)) descriptor.set = _;\n      if (_ = accept(result.init)) initializers.unshift(_);\n    } else if (_ = accept(result)) {\n      if (kind === \"field\") initializers.unshift(_);else descriptor[key] = _;\n    }\n  }\n  if (target) Object.defineProperty(target, contextIn.name, descriptor);\n  done = true;\n}\n;\nexport function __runInitializers(thisArg, initializers, value) {\n  var useValue = arguments.length > 2;\n  for (var i = 0; i < initializers.length; i++) {\n    value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\n  }\n  return useValue ? value : void 0;\n}\n;\nexport function __propKey(x) {\n  return typeof x === \"symbol\" ? x : \"\".concat(x);\n}\n;\nexport function __setFunctionName(f, name, prefix) {\n  if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\n  return Object.defineProperty(f, \"name\", {\n    configurable: true,\n    value: prefix ? \"\".concat(prefix, \" \", name) : name\n  });\n}\n;\nexport function __metadata(metadataKey, metadataValue) {\n  if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\nexport function __awaiter(thisArg, _arguments, P, generator) {\n  function adopt(value) {\n    return value instanceof P ? value : new P(function (resolve) {\n      resolve(value);\n    });\n  }\n  return new (P || (P = Promise))(function (resolve, reject) {\n    function fulfilled(value) {\n      try {\n        step(generator.next(value));\n      } catch (e) {\n        reject(e);\n      }\n    }\n    function rejected(value) {\n      try {\n        step(generator[\"throw\"](value));\n      } catch (e) {\n        reject(e);\n      }\n    }\n    function step(result) {\n      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);\n    }\n    step((generator = generator.apply(thisArg, _arguments || [])).next());\n  });\n}\nexport function __generator(thisArg, body) {\n  var _ = {\n      label: 0,\n      sent: function () {\n        if (t[0] & 1) throw t[1];\n        return t[1];\n      },\n      trys: [],\n      ops: []\n    },\n    f,\n    y,\n    t,\n    g;\n  return g = {\n    next: verb(0),\n    \"throw\": verb(1),\n    \"return\": verb(2)\n  }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function () {\n    return this;\n  }), g;\n  function verb(n) {\n    return function (v) {\n      return step([n, v]);\n    };\n  }\n  function step(op) {\n    if (f) throw new TypeError(\"Generator is already executing.\");\n    while (g && (g = 0, op[0] && (_ = 0)), _) try {\n      if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n      if (y = 0, t) op = [op[0] & 2, t.value];\n      switch (op[0]) {\n        case 0:\n        case 1:\n          t = op;\n          break;\n        case 4:\n          _.label++;\n          return {\n            value: op[1],\n            done: false\n          };\n        case 5:\n          _.label++;\n          y = op[1];\n          op = [0];\n          continue;\n        case 7:\n          op = _.ops.pop();\n          _.trys.pop();\n          continue;\n        default:\n          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {\n            _ = 0;\n            continue;\n          }\n          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {\n            _.label = op[1];\n            break;\n          }\n          if (op[0] === 6 && _.label < t[1]) {\n            _.label = t[1];\n            t = op;\n            break;\n          }\n          if (t && _.label < t[2]) {\n            _.label = t[2];\n            _.ops.push(op);\n            break;\n          }\n          if (t[2]) _.ops.pop();\n          _.trys.pop();\n          continue;\n      }\n      op = body.call(thisArg, _);\n    } catch (e) {\n      op = [6, e];\n      y = 0;\n    } finally {\n      f = t = 0;\n    }\n    if (op[0] & 5) throw op[1];\n    return {\n      value: op[0] ? op[1] : void 0,\n      done: true\n    };\n  }\n}\nexport var __createBinding = Object.create ? function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n    desc = {\n      enumerable: true,\n      get: function () {\n        return m[k];\n      }\n    };\n  }\n  Object.defineProperty(o, k2, desc);\n} : function (o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n};\nexport function __exportStar(m, o) {\n  for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\n}\nexport function __values(o) {\n  var s = typeof Symbol === \"function\" && Symbol.iterator,\n    m = s && o[s],\n    i = 0;\n  if (m) return m.call(o);\n  if (o && typeof o.length === \"number\") return {\n    next: function () {\n      if (o && i >= o.length) o = void 0;\n      return {\n        value: o && o[i++],\n        done: !o\n      };\n    }\n  };\n  throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n}\nexport function __read(o, n) {\n  var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n  if (!m) return o;\n  var i = m.call(o),\n    r,\n    ar = [],\n    e;\n  try {\n    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n  } catch (error) {\n    e = {\n      error: error\n    };\n  } finally {\n    try {\n      if (r && !r.done && (m = i[\"return\"])) m.call(i);\n    } finally {\n      if (e) throw e.error;\n    }\n  }\n  return ar;\n}\n\n/** @deprecated */\nexport function __spread() {\n  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));\n  return ar;\n}\n\n/** @deprecated */\nexport function __spreadArrays() {\n  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n  for (var r = Array(s), k = 0, i = 0; i < il; i++) for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) r[k] = a[j];\n  return r;\n}\nexport function __spreadArray(to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n    if (ar || !(i in from)) {\n      if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n      ar[i] = from[i];\n    }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n}\nexport function __await(v) {\n  return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\nexport function __asyncGenerator(thisArg, _arguments, generator) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var g = generator.apply(thisArg, _arguments || []),\n    i,\n    q = [];\n  return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () {\n    return this;\n  }, i;\n  function verb(n) {\n    if (g[n]) i[n] = function (v) {\n      return new Promise(function (a, b) {\n        q.push([n, v, a, b]) > 1 || resume(n, v);\n      });\n    };\n  }\n  function resume(n, v) {\n    try {\n      step(g[n](v));\n    } catch (e) {\n      settle(q[0][3], e);\n    }\n  }\n  function step(r) {\n    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);\n  }\n  function fulfill(value) {\n    resume(\"next\", value);\n  }\n  function reject(value) {\n    resume(\"throw\", value);\n  }\n  function settle(f, v) {\n    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);\n  }\n}\nexport function __asyncDelegator(o) {\n  var i, p;\n  return i = {}, verb(\"next\"), verb(\"throw\", function (e) {\n    throw e;\n  }), verb(\"return\"), i[Symbol.iterator] = function () {\n    return this;\n  }, i;\n  function verb(n, f) {\n    i[n] = o[n] ? function (v) {\n      return (p = !p) ? {\n        value: __await(o[n](v)),\n        done: false\n      } : f ? f(v) : v;\n    } : f;\n  }\n}\nexport function __asyncValues(o) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var m = o[Symbol.asyncIterator],\n    i;\n  return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () {\n    return this;\n  }, i);\n  function verb(n) {\n    i[n] = o[n] && function (v) {\n      return new Promise(function (resolve, reject) {\n        v = o[n](v), settle(resolve, reject, v.done, v.value);\n      });\n    };\n  }\n  function settle(resolve, reject, d, v) {\n    Promise.resolve(v).then(function (v) {\n      resolve({\n        value: v,\n        done: d\n      });\n    }, reject);\n  }\n}\nexport function __makeTemplateObject(cooked, raw) {\n  if (Object.defineProperty) {\n    Object.defineProperty(cooked, \"raw\", {\n      value: raw\n    });\n  } else {\n    cooked.raw = raw;\n  }\n  return cooked;\n}\n;\nvar __setModuleDefault = Object.create ? function (o, v) {\n  Object.defineProperty(o, \"default\", {\n    enumerable: true,\n    value: v\n  });\n} : function (o, v) {\n  o[\"default\"] = v;\n};\nexport function __importStar(mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n  __setModuleDefault(result, mod);\n  return result;\n}\nexport function __importDefault(mod) {\n  return mod && mod.__esModule ? mod : {\n    default: mod\n  };\n}\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n  return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n}\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\n  if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n  return kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;\n}\nexport function __classPrivateFieldIn(state, receiver) {\n  if (receiver === null || typeof receiver !== \"object\" && typeof receiver !== \"function\") throw new TypeError(\"Cannot use 'in' operator on non-object\");\n  return typeof state === \"function\" ? receiver === state : state.has(receiver);\n}\nexport function __addDisposableResource(env, value, async) {\n  if (value !== null && value !== void 0) {\n    if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\n    var dispose;\n    if (async) {\n      if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\n      dispose = value[Symbol.asyncDispose];\n    }\n    if (dispose === void 0) {\n      if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\n      dispose = value[Symbol.dispose];\n    }\n    if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\n    env.stack.push({\n      value: value,\n      dispose: dispose,\n      async: async\n    });\n  } else if (async) {\n    env.stack.push({\n      async: true\n    });\n  }\n  return value;\n}\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\n  var e = new Error(message);\n  return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\n};\nexport function __disposeResources(env) {\n  function fail(e) {\n    env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\n    env.hasError = true;\n  }\n  function next() {\n    while (env.stack.length) {\n      var rec = env.stack.pop();\n      try {\n        var result = rec.dispose && rec.dispose.call(rec.value);\n        if (rec.async) return Promise.resolve(result).then(next, function (e) {\n          fail(e);\n          return next();\n        });\n      } catch (e) {\n        fail(e);\n      }\n    }\n    if (env.hasError) throw env.error;\n  }\n  return next();\n}\nexport default {\n  __extends: __extends,\n  __assign: __assign,\n  __rest: __rest,\n  __decorate: __decorate,\n  __param: __param,\n  __metadata: __metadata,\n  __awaiter: __awaiter,\n  __generator: __generator,\n  __createBinding: __createBinding,\n  __exportStar: __exportStar,\n  __values: __values,\n  __read: __read,\n  __spread: __spread,\n  __spreadArrays: __spreadArrays,\n  __spreadArray: __spreadArray,\n  __await: __await,\n  __asyncGenerator: __asyncGenerator,\n  __asyncDelegator: __asyncDelegator,\n  __asyncValues: __asyncValues,\n  __makeTemplateObject: __makeTemplateObject,\n  __importStar: __importStar,\n  __importDefault: __importDefault,\n  __classPrivateFieldGet: __classPrivateFieldGet,\n  __classPrivateFieldSet: __classPrivateFieldSet,\n  __classPrivateFieldIn: __classPrivateFieldIn,\n  __addDisposableResource: __addDisposableResource,\n  __disposeResources: __disposeResources\n};","function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\nfunction _iterableToArrayLimit(r, l) { var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\nfunction ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }\nfunction _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(t) { var i = _toPrimitive(t, \"string\"); return \"symbol\" == typeof i ? i : i + \"\"; }\nfunction _toPrimitive(t, r) { if (\"object\" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || \"default\"); if (\"object\" != typeof i) return i; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (\"string\" === r ? String : Number)(t); }\nimport React, { useMemo, useRef, useEffect, useState, useContext } from 'react';\nimport { useDndContext, getClientRect, useDroppable, useDraggable, closestCorners, getFirstCollision, getScrollableAncestors, KeyboardCode } from '@dnd-kit/core';\nimport { useUniqueId, useIsomorphicLayoutEffect, CSS, useCombinedRefs, isKeyboardEvent, subtract } from '@dnd-kit/utilities';\n\n/**\r\n * Move an array item to a different position. Returns a new array with the item moved to the new position.\r\n */\nfunction arrayMove(array, from, to) {\n  const newArray = array.slice();\n  newArray.splice(to < 0 ? newArray.length + to : to, 0, newArray.splice(from, 1)[0]);\n  return newArray;\n}\n\n/**\r\n * Swap an array item to a different position. Returns a new array with the item swapped to the new position.\r\n */\nfunction arraySwap(array, from, to) {\n  const newArray = array.slice();\n  newArray[from] = array[to];\n  newArray[to] = array[from];\n  return newArray;\n}\nfunction getSortedRects(items, rects) {\n  return items.reduce((accumulator, id, index) => {\n    const rect = rects.get(id);\n    if (rect) {\n      accumulator[index] = rect;\n    }\n    return accumulator;\n  }, Array(items.length));\n}\nfunction isValidIndex(index) {\n  return index !== null && index >= 0;\n}\nfunction itemsEqual(a, b) {\n  if (a === b) {\n    return true;\n  }\n  if (a.length !== b.length) {\n    return false;\n  }\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) {\n      return false;\n    }\n  }\n  return true;\n}\nfunction normalizeDisabled(disabled) {\n  if (typeof disabled === 'boolean') {\n    return {\n      draggable: disabled,\n      droppable: disabled\n    };\n  }\n  return disabled;\n}\n\n// To-do: We should be calculating scale transformation\nconst defaultScale = {\n  scaleX: 1,\n  scaleY: 1\n};\nconst horizontalListSortingStrategy = _ref => {\n  var _rects$activeIndex;\n  let rects = _ref.rects,\n    fallbackActiveRect = _ref.activeNodeRect,\n    activeIndex = _ref.activeIndex,\n    overIndex = _ref.overIndex,\n    index = _ref.index;\n  const activeNodeRect = (_rects$activeIndex = rects[activeIndex]) != null ? _rects$activeIndex : fallbackActiveRect;\n  if (!activeNodeRect) {\n    return null;\n  }\n  const itemGap = getItemGap(rects, index, activeIndex);\n  if (index === activeIndex) {\n    const newIndexRect = rects[overIndex];\n    if (!newIndexRect) {\n      return null;\n    }\n    return _objectSpread({\n      x: activeIndex < overIndex ? newIndexRect.left + newIndexRect.width - (activeNodeRect.left + activeNodeRect.width) : newIndexRect.left - activeNodeRect.left,\n      y: 0\n    }, defaultScale);\n  }\n  if (index > activeIndex && index <= overIndex) {\n    return _objectSpread({\n      x: -activeNodeRect.width - itemGap,\n      y: 0\n    }, defaultScale);\n  }\n  if (index < activeIndex && index >= overIndex) {\n    return _objectSpread({\n      x: activeNodeRect.width + itemGap,\n      y: 0\n    }, defaultScale);\n  }\n  return _objectSpread({\n    x: 0,\n    y: 0\n  }, defaultScale);\n};\nfunction getItemGap(rects, index, activeIndex) {\n  const currentRect = rects[index];\n  const previousRect = rects[index - 1];\n  const nextRect = rects[index + 1];\n  if (!currentRect || !previousRect && !nextRect) {\n    return 0;\n  }\n  if (activeIndex < index) {\n    return previousRect ? currentRect.left - (previousRect.left + previousRect.width) : nextRect.left - (currentRect.left + currentRect.width);\n  }\n  return nextRect ? nextRect.left - (currentRect.left + currentRect.width) : currentRect.left - (previousRect.left + previousRect.width);\n}\nconst rectSortingStrategy = _ref => {\n  let rects = _ref.rects,\n    activeIndex = _ref.activeIndex,\n    overIndex = _ref.overIndex,\n    index = _ref.index;\n  const newRects = arrayMove(rects, overIndex, activeIndex);\n  const oldRect = rects[index];\n  const newRect = newRects[index];\n  if (!newRect || !oldRect) {\n    return null;\n  }\n  return {\n    x: newRect.left - oldRect.left,\n    y: newRect.top - oldRect.top,\n    scaleX: newRect.width / oldRect.width,\n    scaleY: newRect.height / oldRect.height\n  };\n};\nconst rectSwappingStrategy = _ref => {\n  let activeIndex = _ref.activeIndex,\n    index = _ref.index,\n    rects = _ref.rects,\n    overIndex = _ref.overIndex;\n  let oldRect;\n  let newRect;\n  if (index === activeIndex) {\n    oldRect = rects[index];\n    newRect = rects[overIndex];\n  }\n  if (index === overIndex) {\n    oldRect = rects[index];\n    newRect = rects[activeIndex];\n  }\n  if (!newRect || !oldRect) {\n    return null;\n  }\n  return {\n    x: newRect.left - oldRect.left,\n    y: newRect.top - oldRect.top,\n    scaleX: newRect.width / oldRect.width,\n    scaleY: newRect.height / oldRect.height\n  };\n};\n\n// To-do: We should be calculating scale transformation\nconst defaultScale$1 = {\n  scaleX: 1,\n  scaleY: 1\n};\nconst verticalListSortingStrategy = _ref => {\n  var _rects$activeIndex;\n  let activeIndex = _ref.activeIndex,\n    fallbackActiveRect = _ref.activeNodeRect,\n    index = _ref.index,\n    rects = _ref.rects,\n    overIndex = _ref.overIndex;\n  const activeNodeRect = (_rects$activeIndex = rects[activeIndex]) != null ? _rects$activeIndex : fallbackActiveRect;\n  if (!activeNodeRect) {\n    return null;\n  }\n  if (index === activeIndex) {\n    const overIndexRect = rects[overIndex];\n    if (!overIndexRect) {\n      return null;\n    }\n    return _objectSpread({\n      x: 0,\n      y: activeIndex < overIndex ? overIndexRect.top + overIndexRect.height - (activeNodeRect.top + activeNodeRect.height) : overIndexRect.top - activeNodeRect.top\n    }, defaultScale$1);\n  }\n  const itemGap = getItemGap$1(rects, index, activeIndex);\n  if (index > activeIndex && index <= overIndex) {\n    return _objectSpread({\n      x: 0,\n      y: -activeNodeRect.height - itemGap\n    }, defaultScale$1);\n  }\n  if (index < activeIndex && index >= overIndex) {\n    return _objectSpread({\n      x: 0,\n      y: activeNodeRect.height + itemGap\n    }, defaultScale$1);\n  }\n  return _objectSpread({\n    x: 0,\n    y: 0\n  }, defaultScale$1);\n};\nfunction getItemGap$1(clientRects, index, activeIndex) {\n  const currentRect = clientRects[index];\n  const previousRect = clientRects[index - 1];\n  const nextRect = clientRects[index + 1];\n  if (!currentRect) {\n    return 0;\n  }\n  if (activeIndex < index) {\n    return previousRect ? currentRect.top - (previousRect.top + previousRect.height) : nextRect ? nextRect.top - (currentRect.top + currentRect.height) : 0;\n  }\n  return nextRect ? nextRect.top - (currentRect.top + currentRect.height) : previousRect ? currentRect.top - (previousRect.top + previousRect.height) : 0;\n}\nconst ID_PREFIX = 'Sortable';\nconst Context = /*#__PURE__*/React.createContext({\n  activeIndex: -1,\n  containerId: ID_PREFIX,\n  disableTransforms: false,\n  items: [],\n  overIndex: -1,\n  useDragOverlay: false,\n  sortedRects: [],\n  strategy: rectSortingStrategy,\n  disabled: {\n    draggable: false,\n    droppable: false\n  }\n});\nfunction SortableContext(_ref) {\n  let children = _ref.children,\n    id = _ref.id,\n    userDefinedItems = _ref.items,\n    _ref$strategy = _ref.strategy,\n    strategy = _ref$strategy === void 0 ? rectSortingStrategy : _ref$strategy,\n    _ref$disabled = _ref.disabled,\n    disabledProp = _ref$disabled === void 0 ? false : _ref$disabled;\n  const _useDndContext = useDndContext(),\n    active = _useDndContext.active,\n    dragOverlay = _useDndContext.dragOverlay,\n    droppableRects = _useDndContext.droppableRects,\n    over = _useDndContext.over,\n    measureDroppableContainers = _useDndContext.measureDroppableContainers;\n  const containerId = useUniqueId(ID_PREFIX, id);\n  const useDragOverlay = Boolean(dragOverlay.rect !== null);\n  const items = useMemo(() => userDefinedItems.map(item => typeof item === 'object' && 'id' in item ? item.id : item), [userDefinedItems]);\n  const isDragging = active != null;\n  const activeIndex = active ? items.indexOf(active.id) : -1;\n  const overIndex = over ? items.indexOf(over.id) : -1;\n  const previousItemsRef = useRef(items);\n  const itemsHaveChanged = !itemsEqual(items, previousItemsRef.current);\n  const disableTransforms = overIndex !== -1 && activeIndex === -1 || itemsHaveChanged;\n  const disabled = normalizeDisabled(disabledProp);\n  useIsomorphicLayoutEffect(() => {\n    if (itemsHaveChanged && isDragging) {\n      measureDroppableContainers(items);\n    }\n  }, [itemsHaveChanged, items, isDragging, measureDroppableContainers]);\n  useEffect(() => {\n    previousItemsRef.current = items;\n  }, [items]);\n  const contextValue = useMemo(() => ({\n    activeIndex,\n    containerId,\n    disabled,\n    disableTransforms,\n    items,\n    overIndex,\n    useDragOverlay,\n    sortedRects: getSortedRects(items, droppableRects),\n    strategy\n  }),\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [activeIndex, containerId, disabled.draggable, disabled.droppable, disableTransforms, items, overIndex, droppableRects, useDragOverlay, strategy]);\n  return /*#__PURE__*/React.createElement(Context.Provider, {\n    value: contextValue\n  }, children);\n}\nconst defaultNewIndexGetter = _ref => {\n  let id = _ref.id,\n    items = _ref.items,\n    activeIndex = _ref.activeIndex,\n    overIndex = _ref.overIndex;\n  return arrayMove(items, activeIndex, overIndex).indexOf(id);\n};\nconst defaultAnimateLayoutChanges = _ref2 => {\n  let containerId = _ref2.containerId,\n    isSorting = _ref2.isSorting,\n    wasDragging = _ref2.wasDragging,\n    index = _ref2.index,\n    items = _ref2.items,\n    newIndex = _ref2.newIndex,\n    previousItems = _ref2.previousItems,\n    previousContainerId = _ref2.previousContainerId,\n    transition = _ref2.transition;\n  if (!transition || !wasDragging) {\n    return false;\n  }\n  if (previousItems !== items && index === newIndex) {\n    return false;\n  }\n  if (isSorting) {\n    return true;\n  }\n  return newIndex !== index && containerId === previousContainerId;\n};\nconst defaultTransition = {\n  duration: 200,\n  easing: 'ease'\n};\nconst transitionProperty = 'transform';\nconst disabledTransition = /*#__PURE__*/CSS.Transition.toString({\n  property: transitionProperty,\n  duration: 0,\n  easing: 'linear'\n});\nconst defaultAttributes = {\n  roleDescription: 'sortable'\n};\n\n/*\r\n * When the index of an item changes while sorting,\r\n * we need to temporarily disable the transforms\r\n */\n\nfunction useDerivedTransform(_ref) {\n  let disabled = _ref.disabled,\n    index = _ref.index,\n    node = _ref.node,\n    rect = _ref.rect;\n  const _useState = useState(null),\n    _useState2 = _slicedToArray(_useState, 2),\n    derivedTransform = _useState2[0],\n    setDerivedtransform = _useState2[1];\n  const previousIndex = useRef(index);\n  useIsomorphicLayoutEffect(() => {\n    if (!disabled && index !== previousIndex.current && node.current) {\n      const initial = rect.current;\n      if (initial) {\n        const current = getClientRect(node.current, {\n          ignoreTransform: true\n        });\n        const delta = {\n          x: initial.left - current.left,\n          y: initial.top - current.top,\n          scaleX: initial.width / current.width,\n          scaleY: initial.height / current.height\n        };\n        if (delta.x || delta.y) {\n          setDerivedtransform(delta);\n        }\n      }\n    }\n    if (index !== previousIndex.current) {\n      previousIndex.current = index;\n    }\n  }, [disabled, index, node, rect]);\n  useEffect(() => {\n    if (derivedTransform) {\n      setDerivedtransform(null);\n    }\n  }, [derivedTransform]);\n  return derivedTransform;\n}\nfunction useSortable(_ref) {\n  let _ref$animateLayoutCha = _ref.animateLayoutChanges,\n    animateLayoutChanges = _ref$animateLayoutCha === void 0 ? defaultAnimateLayoutChanges : _ref$animateLayoutCha,\n    userDefinedAttributes = _ref.attributes,\n    localDisabled = _ref.disabled,\n    customData = _ref.data,\n    _ref$getNewIndex = _ref.getNewIndex,\n    getNewIndex = _ref$getNewIndex === void 0 ? defaultNewIndexGetter : _ref$getNewIndex,\n    id = _ref.id,\n    localStrategy = _ref.strategy,\n    resizeObserverConfig = _ref.resizeObserverConfig,\n    _ref$transition = _ref.transition,\n    transition = _ref$transition === void 0 ? defaultTransition : _ref$transition;\n  const _useContext = useContext(Context),\n    items = _useContext.items,\n    containerId = _useContext.containerId,\n    activeIndex = _useContext.activeIndex,\n    globalDisabled = _useContext.disabled,\n    disableTransforms = _useContext.disableTransforms,\n    sortedRects = _useContext.sortedRects,\n    overIndex = _useContext.overIndex,\n    useDragOverlay = _useContext.useDragOverlay,\n    globalStrategy = _useContext.strategy;\n  const disabled = normalizeLocalDisabled(localDisabled, globalDisabled);\n  const index = items.indexOf(id);\n  const data = useMemo(() => _objectSpread({\n    sortable: {\n      containerId,\n      index,\n      items\n    }\n  }, customData), [containerId, customData, index, items]);\n  const itemsAfterCurrentSortable = useMemo(() => items.slice(items.indexOf(id)), [items, id]);\n  const _useDroppable = useDroppable({\n      id,\n      data,\n      disabled: disabled.droppable,\n      resizeObserverConfig: _objectSpread({\n        updateMeasurementsFor: itemsAfterCurrentSortable\n      }, resizeObserverConfig)\n    }),\n    rect = _useDroppable.rect,\n    node = _useDroppable.node,\n    isOver = _useDroppable.isOver,\n    setDroppableNodeRef = _useDroppable.setNodeRef;\n  const _useDraggable = useDraggable({\n      id,\n      data,\n      attributes: _objectSpread(_objectSpread({}, defaultAttributes), userDefinedAttributes),\n      disabled: disabled.draggable\n    }),\n    active = _useDraggable.active,\n    activatorEvent = _useDraggable.activatorEvent,\n    activeNodeRect = _useDraggable.activeNodeRect,\n    attributes = _useDraggable.attributes,\n    setDraggableNodeRef = _useDraggable.setNodeRef,\n    listeners = _useDraggable.listeners,\n    isDragging = _useDraggable.isDragging,\n    over = _useDraggable.over,\n    setActivatorNodeRef = _useDraggable.setActivatorNodeRef,\n    transform = _useDraggable.transform;\n  const setNodeRef = useCombinedRefs(setDroppableNodeRef, setDraggableNodeRef);\n  const isSorting = Boolean(active);\n  const displaceItem = isSorting && !disableTransforms && isValidIndex(activeIndex) && isValidIndex(overIndex);\n  const shouldDisplaceDragSource = !useDragOverlay && isDragging;\n  const dragSourceDisplacement = shouldDisplaceDragSource && displaceItem ? transform : null;\n  const strategy = localStrategy != null ? localStrategy : globalStrategy;\n  const finalTransform = displaceItem ? dragSourceDisplacement != null ? dragSourceDisplacement : strategy({\n    rects: sortedRects,\n    activeNodeRect,\n    activeIndex,\n    overIndex,\n    index\n  }) : null;\n  const newIndex = isValidIndex(activeIndex) && isValidIndex(overIndex) ? getNewIndex({\n    id,\n    items,\n    activeIndex,\n    overIndex\n  }) : index;\n  const activeId = active == null ? void 0 : active.id;\n  const previous = useRef({\n    activeId,\n    items,\n    newIndex,\n    containerId\n  });\n  const itemsHaveChanged = items !== previous.current.items;\n  const shouldAnimateLayoutChanges = animateLayoutChanges({\n    active,\n    containerId,\n    isDragging,\n    isSorting,\n    id,\n    index,\n    items,\n    newIndex: previous.current.newIndex,\n    previousItems: previous.current.items,\n    previousContainerId: previous.current.containerId,\n    transition,\n    wasDragging: previous.current.activeId != null\n  });\n  const derivedTransform = useDerivedTransform({\n    disabled: !shouldAnimateLayoutChanges,\n    index,\n    node,\n    rect\n  });\n  useEffect(() => {\n    if (isSorting && previous.current.newIndex !== newIndex) {\n      previous.current.newIndex = newIndex;\n    }\n    if (containerId !== previous.current.containerId) {\n      previous.current.containerId = containerId;\n    }\n    if (items !== previous.current.items) {\n      previous.current.items = items;\n    }\n  }, [isSorting, newIndex, containerId, items]);\n  useEffect(() => {\n    if (activeId === previous.current.activeId) {\n      return;\n    }\n    if (activeId && !previous.current.activeId) {\n      previous.current.activeId = activeId;\n      return;\n    }\n    const timeoutId = setTimeout(() => {\n      previous.current.activeId = activeId;\n    }, 50);\n    return () => clearTimeout(timeoutId);\n  }, [activeId]);\n  return {\n    active,\n    activeIndex,\n    attributes,\n    data,\n    rect,\n    index,\n    newIndex,\n    items,\n    isOver,\n    isSorting,\n    isDragging,\n    listeners,\n    node,\n    overIndex,\n    over,\n    setNodeRef,\n    setActivatorNodeRef,\n    setDroppableNodeRef,\n    setDraggableNodeRef,\n    transform: derivedTransform != null ? derivedTransform : finalTransform,\n    transition: getTransition()\n  };\n  function getTransition() {\n    if (\n    // Temporarily disable transitions for a single frame to set up derived transforms\n    derivedTransform ||\n    // Or to prevent items jumping to back to their \"new\" position when items change\n    itemsHaveChanged && previous.current.newIndex === index) {\n      return disabledTransition;\n    }\n    if (shouldDisplaceDragSource && !isKeyboardEvent(activatorEvent) || !transition) {\n      return undefined;\n    }\n    if (isSorting || shouldAnimateLayoutChanges) {\n      return CSS.Transition.toString(_objectSpread(_objectSpread({}, transition), {}, {\n        property: transitionProperty\n      }));\n    }\n    return undefined;\n  }\n}\nfunction normalizeLocalDisabled(localDisabled, globalDisabled) {\n  var _localDisabled$dragga, _localDisabled$droppa;\n  if (typeof localDisabled === 'boolean') {\n    return {\n      draggable: localDisabled,\n      // Backwards compatibility\n      droppable: false\n    };\n  }\n  return {\n    draggable: (_localDisabled$dragga = localDisabled == null ? void 0 : localDisabled.draggable) != null ? _localDisabled$dragga : globalDisabled.draggable,\n    droppable: (_localDisabled$droppa = localDisabled == null ? void 0 : localDisabled.droppable) != null ? _localDisabled$droppa : globalDisabled.droppable\n  };\n}\nfunction hasSortableData(entry) {\n  if (!entry) {\n    return false;\n  }\n  const data = entry.data.current;\n  if (data && 'sortable' in data && typeof data.sortable === 'object' && 'containerId' in data.sortable && 'items' in data.sortable && 'index' in data.sortable) {\n    return true;\n  }\n  return false;\n}\nconst directions = [KeyboardCode.Down, KeyboardCode.Right, KeyboardCode.Up, KeyboardCode.Left];\nconst sortableKeyboardCoordinates = (event, _ref) => {\n  let _ref$context = _ref.context,\n    active = _ref$context.active,\n    collisionRect = _ref$context.collisionRect,\n    droppableRects = _ref$context.droppableRects,\n    droppableContainers = _ref$context.droppableContainers,\n    over = _ref$context.over,\n    scrollableAncestors = _ref$context.scrollableAncestors;\n  if (directions.includes(event.code)) {\n    event.preventDefault();\n    if (!active || !collisionRect) {\n      return;\n    }\n    const filteredContainers = [];\n    droppableContainers.getEnabled().forEach(entry => {\n      if (!entry || entry != null && entry.disabled) {\n        return;\n      }\n      const rect = droppableRects.get(entry.id);\n      if (!rect) {\n        return;\n      }\n      switch (event.code) {\n        case KeyboardCode.Down:\n          if (collisionRect.top < rect.top) {\n            filteredContainers.push(entry);\n          }\n          break;\n        case KeyboardCode.Up:\n          if (collisionRect.top > rect.top) {\n            filteredContainers.push(entry);\n          }\n          break;\n        case KeyboardCode.Left:\n          if (collisionRect.left > rect.left) {\n            filteredContainers.push(entry);\n          }\n          break;\n        case KeyboardCode.Right:\n          if (collisionRect.left < rect.left) {\n            filteredContainers.push(entry);\n          }\n          break;\n      }\n    });\n    const collisions = closestCorners({\n      active,\n      collisionRect: collisionRect,\n      droppableRects,\n      droppableContainers: filteredContainers,\n      pointerCoordinates: null\n    });\n    let closestId = getFirstCollision(collisions, 'id');\n    if (closestId === (over == null ? void 0 : over.id) && collisions.length > 1) {\n      closestId = collisions[1].id;\n    }\n    if (closestId != null) {\n      const activeDroppable = droppableContainers.get(active.id);\n      const newDroppable = droppableContainers.get(closestId);\n      const newRect = newDroppable ? droppableRects.get(newDroppable.id) : null;\n      const newNode = newDroppable == null ? void 0 : newDroppable.node.current;\n      if (newNode && newRect && activeDroppable && newDroppable) {\n        const newScrollAncestors = getScrollableAncestors(newNode);\n        const hasDifferentScrollAncestors = newScrollAncestors.some((element, index) => scrollableAncestors[index] !== element);\n        const hasSameContainer = isSameContainer(activeDroppable, newDroppable);\n        const isAfterActive = isAfter(activeDroppable, newDroppable);\n        const offset = hasDifferentScrollAncestors || !hasSameContainer ? {\n          x: 0,\n          y: 0\n        } : {\n          x: isAfterActive ? collisionRect.width - newRect.width : 0,\n          y: isAfterActive ? collisionRect.height - newRect.height : 0\n        };\n        const rectCoordinates = {\n          x: newRect.left,\n          y: newRect.top\n        };\n        const newCoordinates = offset.x && offset.y ? rectCoordinates : subtract(rectCoordinates, offset);\n        return newCoordinates;\n      }\n    }\n  }\n  return undefined;\n};\nfunction isSameContainer(a, b) {\n  if (!hasSortableData(a) || !hasSortableData(b)) {\n    return false;\n  }\n  return a.data.current.sortable.containerId === b.data.current.sortable.containerId;\n}\nfunction isAfter(a, b) {\n  if (!hasSortableData(a) || !hasSortableData(b)) {\n    return false;\n  }\n  if (!isSameContainer(a, b)) {\n    return false;\n  }\n  return a.data.current.sortable.index < b.data.current.sortable.index;\n}\nexport { SortableContext, arrayMove, arraySwap, defaultAnimateLayoutChanges, defaultNewIndexGetter, hasSortableData, horizontalListSortingStrategy, rectSortingStrategy, rectSwappingStrategy, sortableKeyboardCoordinates, useSortable, verticalListSortingStrategy };","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nvar _createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\nvar _react = require('react');\nvar _react2 = _interopRequireDefault(_react);\nvar _propTypes = require('prop-types');\nvar _propTypes2 = _interopRequireDefault(_propTypes);\nrequire('./index.css');\nvar _reactFlipMove = require('react-flip-move');\nvar _reactFlipMove2 = _interopRequireDefault(_reactFlipMove);\nvar _UploadIcon = require('./UploadIcon.svg');\nvar _UploadIcon2 = _interopRequireDefault(_UploadIcon);\nfunction _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    default: obj\n  };\n}\nfunction _toConsumableArray(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {\n      arr2[i] = arr[i];\n    }\n    return arr2;\n  } else {\n    return Array.from(arr);\n  }\n}\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\nfunction _possibleConstructorReturn(self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n  return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self;\n}\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass);\n  }\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n}\nvar styles = {\n  display: \"flex\",\n  alignItems: \"center\",\n  justifyContent: \"center\",\n  flexWrap: \"wrap\",\n  width: \"100%\"\n};\nvar ERROR = {\n  NOT_SUPPORTED_EXTENSION: 'NOT_SUPPORTED_EXTENSION',\n  FILESIZE_TOO_LARGE: 'FILESIZE_TOO_LARGE'\n};\nvar ReactImageUploadComponent = function (_React$Component) {\n  _inherits(ReactImageUploadComponent, _React$Component);\n  function ReactImageUploadComponent(props) {\n    _classCallCheck(this, ReactImageUploadComponent);\n    var _this = _possibleConstructorReturn(this, (ReactImageUploadComponent.__proto__ || Object.getPrototypeOf(ReactImageUploadComponent)).call(this, props));\n    _this.state = {\n      pictures: [].concat(_toConsumableArray(props.defaultImages)),\n      files: [],\n      fileErrors: []\n    };\n    _this.inputElement = '';\n    _this.onDropFile = _this.onDropFile.bind(_this);\n    _this.onUploadClick = _this.onUploadClick.bind(_this);\n    _this.triggerFileUpload = _this.triggerFileUpload.bind(_this);\n    return _this;\n  }\n  _createClass(ReactImageUploadComponent, [{\n    key: 'componentDidUpdate',\n    value: function componentDidUpdate(prevProps, prevState, snapshot) {\n      if (prevState.files !== this.state.files) {\n        this.props.onChange(this.state.files, this.state.pictures);\n      }\n    }\n\n    /*\n     Load image at the beggining if defaultImage prop exists\n     */\n  }, {\n    key: 'componentWillReceiveProps',\n    value: function componentWillReceiveProps(nextProps) {\n      if (nextProps.defaultImages !== this.props.defaultImages) {\n        this.setState({\n          pictures: nextProps.defaultImages\n        });\n      }\n    }\n\n    /*\n    Check file extension (onDropFile)\n    */\n  }, {\n    key: 'hasExtension',\n    value: function hasExtension(fileName) {\n      var pattern = '(' + this.props.imgExtension.join('|').replace(/\\./g, '\\\\.') + ')$';\n      return new RegExp(pattern, 'i').test(fileName);\n    }\n\n    /*\n     Handle file validation\n     */\n  }, {\n    key: 'onDropFile',\n    value: function onDropFile(e) {\n      var _this2 = this;\n      var files = e.target.files;\n      var allFilePromises = [];\n      var fileErrors = [];\n\n      // Iterate over all uploaded files\n      for (var i = 0; i < files.length; i++) {\n        var file = files[i];\n        var fileError = {\n          name: file.name\n        };\n        // Check for file extension\n        if (!this.hasExtension(file.name)) {\n          fileError = Object.assign(fileError, {\n            type: ERROR.NOT_SUPPORTED_EXTENSION\n          });\n          fileErrors.push(fileError);\n          continue;\n        }\n        // Check for file size\n        if (file.size > this.props.maxFileSize) {\n          fileError = Object.assign(fileError, {\n            type: ERROR.FILESIZE_TOO_LARGE\n          });\n          fileErrors.push(fileError);\n          continue;\n        }\n        allFilePromises.push(this.readFile(file));\n      }\n      this.setState({\n        fileErrors: fileErrors\n      });\n      var singleImage = this.props.singleImage;\n      Promise.all(allFilePromises).then(function (newFilesData) {\n        var dataURLs = singleImage ? [] : _this2.state.pictures.slice();\n        var files = singleImage ? [] : _this2.state.files.slice();\n        newFilesData.forEach(function (newFileData) {\n          dataURLs.push(newFileData.dataURL);\n          files.push(newFileData.file);\n        });\n        _this2.setState({\n          pictures: dataURLs,\n          files: files\n        });\n      });\n    }\n  }, {\n    key: 'onUploadClick',\n    value: function onUploadClick(e) {\n      // Fixes https://github.com/JakeHartnell/react-images-upload/issues/55\n      e.target.value = null;\n    }\n\n    /*\n       Read a file and return a promise that when resolved gives the file itself and the data URL\n     */\n  }, {\n    key: 'readFile',\n    value: function readFile(file) {\n      return new Promise(function (resolve, reject) {\n        var reader = new FileReader();\n\n        // Read the image via FileReader API and save image result in state.\n        reader.onload = function (e) {\n          // Add the file name to the data URL\n          var dataURL = e.target.result;\n          dataURL = dataURL.replace(\";base64\", ';name=' + file.name + ';base64');\n          resolve({\n            file: file,\n            dataURL: dataURL\n          });\n        };\n        reader.readAsDataURL(file);\n      });\n    }\n\n    /*\n     Remove the image from state\n     */\n  }, {\n    key: 'removeImage',\n    value: function removeImage(picture) {\n      var _this3 = this;\n      var removeIndex = this.state.pictures.findIndex(function (e) {\n        return e === picture;\n      });\n      var filteredPictures = this.state.pictures.filter(function (e, index) {\n        return index !== removeIndex;\n      });\n      var filteredFiles = this.state.files.filter(function (e, index) {\n        return index !== removeIndex;\n      });\n      this.setState({\n        pictures: filteredPictures,\n        files: filteredFiles\n      }, function () {\n        _this3.props.onChange(_this3.state.files, _this3.state.pictures);\n      });\n    }\n\n    /*\n     Check if any errors && render\n     */\n  }, {\n    key: 'renderErrors',\n    value: function renderErrors() {\n      var _this4 = this;\n      var fileErrors = this.state.fileErrors;\n      return fileErrors.map(function (fileError, index) {\n        return _react2.default.createElement('div', {\n          className: 'errorMessage ' + _this4.props.errorClass,\n          key: index,\n          style: _this4.props.errorStyle\n        }, '* ', fileError.name, ' ', fileError.type === ERROR.FILESIZE_TOO_LARGE ? _this4.props.fileSizeError : _this4.props.fileTypeError);\n      });\n    }\n\n    /*\n     Render the upload icon\n     */\n  }, {\n    key: 'renderIcon',\n    value: function renderIcon() {\n      if (this.props.withIcon) {\n        return _react2.default.createElement('img', {\n          src: _UploadIcon2.default,\n          className: 'uploadIcon',\n          alt: 'Upload Icon'\n        });\n      }\n    }\n\n    /*\n     Render label\n     */\n  }, {\n    key: 'renderLabel',\n    value: function renderLabel() {\n      if (this.props.withLabel) {\n        return _react2.default.createElement('p', {\n          className: this.props.labelClass,\n          style: this.props.labelStyles\n        }, this.props.label);\n      }\n    }\n\n    /*\n     Render preview images\n     */\n  }, {\n    key: 'renderPreview',\n    value: function renderPreview() {\n      return _react2.default.createElement('div', {\n        className: 'uploadPicturesWrapper'\n      }, _react2.default.createElement(_reactFlipMove2.default, {\n        enterAnimation: 'fade',\n        leaveAnimation: 'fade',\n        style: styles\n      }, this.renderPreviewPictures()));\n    }\n  }, {\n    key: 'renderPreviewPictures',\n    value: function renderPreviewPictures() {\n      var _this5 = this;\n      return this.state.pictures.map(function (picture, index) {\n        return _react2.default.createElement('div', {\n          key: index,\n          className: 'uploadPictureContainer'\n        }, _react2.default.createElement('div', {\n          className: 'deleteImage',\n          onClick: function onClick() {\n            return _this5.removeImage(picture);\n          }\n        }, 'X'), _react2.default.createElement('img', {\n          src: picture,\n          className: 'uploadPicture',\n          alt: 'preview'\n        }));\n      });\n    }\n\n    /*\n     On button click, trigger input file to open\n     */\n  }, {\n    key: 'triggerFileUpload',\n    value: function triggerFileUpload() {\n      this.inputElement.click();\n    }\n  }, {\n    key: 'clearPictures',\n    value: function clearPictures() {\n      this.setState({\n        pictures: []\n      });\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var _this6 = this;\n      return _react2.default.createElement('div', {\n        className: \"fileUploader \" + this.props.className,\n        style: this.props.style\n      }, _react2.default.createElement('div', {\n        className: 'fileContainer',\n        style: this.props.fileContainerStyle\n      }, this.renderIcon(), this.renderLabel(), _react2.default.createElement('div', {\n        className: 'errorsContainer'\n      }, this.renderErrors()), _react2.default.createElement('button', {\n        type: this.props.buttonType,\n        className: \"chooseFileButton \" + this.props.buttonClassName,\n        style: this.props.buttonStyles,\n        onClick: this.triggerFileUpload\n      }, this.props.buttonText), _react2.default.createElement('input', {\n        type: 'file',\n        ref: function ref(input) {\n          return _this6.inputElement = input;\n        },\n        name: this.props.name,\n        multiple: !this.props.singleImage,\n        onChange: this.onDropFile,\n        onClick: this.onUploadClick,\n        accept: this.props.accept\n      }), this.props.withPreview ? this.renderPreview() : null));\n    }\n  }]);\n  return ReactImageUploadComponent;\n}(_react2.default.Component);\nReactImageUploadComponent.defaultProps = {\n  className: '',\n  fileContainerStyle: {},\n  buttonClassName: \"\",\n  buttonStyles: {},\n  withPreview: false,\n  accept: \"image/*\",\n  name: \"\",\n  withIcon: true,\n  buttonText: \"Choose images\",\n  buttonType: \"button\",\n  withLabel: true,\n  label: \"Max file size: 5mb, accepted: jpg|gif|png\",\n  labelStyles: {},\n  labelClass: \"\",\n  imgExtension: ['.jpg', '.jpeg', '.gif', '.png'],\n  maxFileSize: 5242880,\n  fileSizeError: \" file size is too big\",\n  fileTypeError: \" is not a supported file extension\",\n  errorClass: \"\",\n  style: {},\n  errorStyle: {},\n  singleImage: false,\n  onChange: function onChange() {},\n  defaultImages: []\n};\nReactImageUploadComponent.propTypes = {\n  style: _propTypes2.default.object,\n  fileContainerStyle: _propTypes2.default.object,\n  className: _propTypes2.default.string,\n  onChange: _propTypes2.default.func,\n  onDelete: _propTypes2.default.func,\n  buttonClassName: _propTypes2.default.string,\n  buttonStyles: _propTypes2.default.object,\n  buttonType: _propTypes2.default.string,\n  withPreview: _propTypes2.default.bool,\n  accept: _propTypes2.default.string,\n  name: _propTypes2.default.string,\n  withIcon: _propTypes2.default.bool,\n  buttonText: _propTypes2.default.string,\n  withLabel: _propTypes2.default.bool,\n  label: _propTypes2.default.string,\n  labelStyles: _propTypes2.default.object,\n  labelClass: _propTypes2.default.string,\n  imgExtension: _propTypes2.default.array,\n  maxFileSize: _propTypes2.default.number,\n  fileSizeError: _propTypes2.default.string,\n  fileTypeError: _propTypes2.default.string,\n  errorClass: _propTypes2.default.string,\n  errorStyle: _propTypes2.default.object,\n  singleImage: _propTypes2.default.bool,\n  defaultImages: _propTypes2.default.array\n};\nexports.default = ReactImageUploadComponent;"],"sourceRoot":""}