{"version":3,"sources":["webpack:///webpack/universalModuleDefinition?5ca6*","webpack:///webpack/bootstrap e53f3a44e16ca2bd7531?fa2f*","webpack:///./src/main/modules/All.js","webpack:///./src/main/Form.js","webpack:///./src/main/Tooltip.js","webpack:///./src/main/util/Util.js","webpack:///./src/main/DestroyableWidget.js","webpack:///./src/main/util/Settings.js","webpack:///./~/isomorphic-fetch/fetch-npm-browserify.js","webpack:///./~/whatwg-fetch/fetch.js","webpack:///./src/main/util/Event.js","webpack:///./src/main/Modal.js","webpack:///./src/main/Widget.js","webpack:///./src/main/lib/FixedWindow.js","webpack:///./src/main/lib/debounce.js","webpack:///./src/main/Toggleable.js","webpack:///./src/main/OffCanvas.js","webpack:///./src/main/Dropdown.js","webpack:///./src/main/LightBox.js"],"names":["Form","Tooltip","Modal","Widget","Settings","Util","Toggleable","OffCanvas","Dropdown","LightBox","LOADING_CLASS","DATA_ELEMENT_INVALID","REMOTE","REMOTE_ACTION","ATTR_DISABLE_INLINE","ATTR_DISABLE_REALTIME","ATTR_VALIDATOR","ATTR_DATA_CUSTOM_MESSAGE","ATTR_DATA_CUSTOM_LABEL","ATTR_VALIDATE_VISIBILITY","ATTR_ERROR_TARGET_ID","ATTR_DEPENDS","CONST_USE_JSON","CONST_REALTIME_EVENT","FOCUS_TOOLTIP_DELAY","CLICK_TOOLTIP_DELAY","EVENT_FORM_READY","EVENT_FORM_SUBMIT","EVENT_FORM_AFTER_AJAX_SUBMIT","EVENT_FORM_AJAX_COMPLETED","form","options","HTMLFormElement","Error","tooltips","currentValidationFuture","Promise","createTooltips","appendError","ajaxSubmitType","ajaxJsonContentType","inlineValidation","realtime","realtimeTimeout","formatErrorTooltip","error","inputErrorClass","containerErrorClass","fetchOptions","credentials","tooltipContainer","tooltipOptions","containerClass","shouldScrollToElement","scrollToElementDiff","Object","assign","applyOptionsFromElement","hfWidgetInstance","_validators","globalValidators","_remoteValidationFunction","initFormValidation","destroy","thisForm","e","self","shouldUseAjax","getAttribute","ajaxPostUrl","window","location","href","useJson","ev","dispatch","withOriginal","fire","defaultPrevented","_formStopLoading","submit","preventDefault","defaultHeaders","defaultOptions","headers","method","serverCall","fetch","body","JSON","stringify","serialize","FormData","then","r","globalRemoteValidationFunction","apply","withDetail","response","selectors","inputs","querySelectorAll","join","result","Array","prototype","forEach","call","input","exists","name","value","push","field","focus","fields","NodeList","_handleValidation","foundAnyError","removeTooltip","toValidateFields","scoped","arr","_createArrayFromInvalidFieldList","isLocalInvalid","length","_focusElement","validation","_customValidationsForElements","validateCustomFields","thisToValidateFields","from","concat","checkedFields","foundInvalidFields","prepareErrors","firstInvalidField","document","activeElement","_handleTooltipHideClickAfterChange","showAndOrCreateTooltip","validity","globalErrorMessageHandler","keys","id","labels","getForm","invalid","labelsIndex","labelEl","_markElementInvalid","_markElementValid","el","setAttribute","classList","add","removeAttribute","remove","filter","HTMLFieldSetElement","thisParent","errors","inputsWithErrorClasses","elementErrorIndex","parentNode","removeChild","inputErrorIndex","validator","validationRef","cl","future","futures","fieldsLength","iVal","_shouldNotValidateField","customError","valid","_runValidation","all","allFutures","l","fI","_removeElementErrors","removeAllErrors","removeErrors","labelGroups","invalidFields","handleAdditionalLabels","isInvalid","thisLabelGroup","additionalLabels","group","i","errorTarget","_findErrorTarget","parent","flexFormsSavedValidity","parse","_setupErrorMessages","msg","validationMessage","insertAdjacentHTML","flexFormsSavedValidationMessage","setCustomValidity","linkedFields","thisField","_isElementInvalidElement","_handleLabels","func","target","createTooltip","_formatErrorTooltip","hasAttribute","fieldSelector","base","slice","invalidEvent","_checkIsValidRealtimeElement","addEventListener","addEventOnce","handleInvalid","_formLoading","_checkIsInvalid","resolve","setTimeout","_handleSubmit","TIMEOUT_KEYDOWN","KEYDOWN_RUNNING","clearKeyDownTimeout","clearTimeout","_formIsLoading","isStillTarget","_handleTooltipInline","dependentFields","_getDependentFields","_checkIsValidBlurFocusElement","attr","_checkIsValidInlineCheckElement","flexcssKeepTooltips","listener","_submitListener","dispatchAndFire","contains","getTabEvent","global","t","scrollToElement","submitListener","submitEvent","removeEventListener","checkValidity","_getInvalidElements","firstError","_submitFunction","undefined","isVisible","list","n","foundTarget","HTMLElement","getElementById","errorFunc","selector","forms","instances","customMsg","CLASS_NAMES_TOOLTIP","CLASS_NAMES_OPEN","ATTR_DATA_CLASSNAME","ATTR_DATA_NO_TOUCH","doc","DelegateContainer","container","selectorAttribute","collisionContainer","text","removeTitle","positionRelative","trim","isTouchDevice","createElement","appendChild","_restoreClassNames","style","left","top","innerHTML","flexTooltipCurrentTarget","oldTitle","setupPositionNearby","classNames","maybeTargetClass","className","selfTarget","PFX","COL_LEFT_CLASS","COL_RIGHT_CLASS","COL_BOTTOM_CLASS","element","type","callback","thisFunction","p","thisType","toLowerCase","transitions","transition","OTransition","MozTransition","WebkitTransition","entries","key","now","s4","Math","floor","random","toString","substring","inner","width","height","outer","position","visibility","overflow","w1","offsetWidth","w2","clientWidth","capture","event","offsetHeight","str","replace","g","toUpperCase","attrs","attributes","s","dashToCamelCase","nodeName","val","nodeValue","hasOwnProperty","parseInt","elementToPosition","centerHorizontal","positionTop","amountTop","amountLeft","parentsUntil","getComputedStyle","isPartOfNode","offsetTop","offsetLeft","targetPosition","getBoundingClientRect","elementRect","colRect","targetTop","targetRight","right","isCollisionTop","isCollisionBottom","innerHeight","isCollisionLeft","targetLeft","isCollisionRight","calcTop","calcLeft","rightPosition","leftCentered","collisionCentered","cssText","optionalOffset","scrollIntoView","thisOffset","scrolledY","pageYOffset","scroll","DestroyableWidget","listeners","args","FLEXCSS_GLOBAL_SETTINGS","smallBreakpoint","touchMoveBreakpointOffCanvas","scrollbarUpdateNodes","darkenerFadeDelay","canvasToggledClass","FLEXCSS_CONST_IS_IOS","FLEXCSS_CONST_IS_TOUCH","FLEXCSS_CONST_IS_SAFARI","FLEXCSS_CONST_IS_IE","FLEXCSS_CONST_TAB_EVENT","FLEXCSS_IS_SMALL_SCREEN","init","FLEXCSS_CONST_SCROLLBAR_WIDTH","getScrollBarWidth","FLEXCSS_CONST_TRANSITION_EVENT","whichTransitionEndEvent","readyState","settings","navigator","userAgent","match","test","innerWidth","get","msMaxTouchPoints","poly","CustomEvent","params","thisParams","bubbles","cancelable","detail","evt","createEvent","initCustomEvent","superPreventDefault","defineProperty","Event","EventHandler","originalEvent","o","dispatchEvent","withOptions","KEY_ESC","ATTR_CREATE_NEW","ATTR_CLOSE","ATTR_NAME","CLS_CONTAINER_CURRENT","CLS_OPEN","CLS_CURRENT","CLS_PART_OF_STACK","CLS_MODAL_CONTAINER","CLS_ANIM_END","CLS_LOADER_CONTAINER","CLS_LOADER","CLS_BACKDROP","EVENT_MODAL_CLOSED","EVENT_MODAL_BEFORE_CLOSED","EVENT_MODAL_OPENED","EVENT_MODAL_INIT","EVENT_MODAL_ASYNC_TARGET_LOADED","currentOpen","loading","closeOnEscape","closeOnBackgroundClick","destroyOnFinish","fixedContainer","containerClassNames","eventContainer","eventFunction","dataMainPageContainer","currentScrollTop","modalContainer","_modalInstances","indexOf","splice","getInstance","close","copy","KeyboardEvent","_finishState","prevModal","switchModals","_removeModalFromStack","lastContainer","childNodes","node","co","last","open","prefixedAnimateEvent","_finishAnim","m","isCurrent","foundInstance","flexModalInstance","targetContent","widget","hasTarget","isHtmlElement","isWidget","findWidget","newInstance","setDestroyOnFinish","fromEvent","registerEvents","getModalContainer","stopImmediatePropagation","modalContainerClasses","closeModalFunction","ce","loader","toggleLoader","show","loaderLoader","requestAnimationFrame","async","getAsync","DocumentFragment","guid","finalContent","thisEl","modal","internal","maybeEvent","delegate","delegateContainer","addScreenConstraint","createWidget","v","isEmptyContainer","MutationObserver","observer","mutations","disconnect","observe","childList","keyCode","lastModal","asyncContent","_isWidget","setAsync","CLS_FIXED_WINDOW","EVENT_BEFORE_FIXED_ADD","EVENT_AFTER_FIXED_REMOVE","ALLOW_ELEMENT_OVERFLOW_TOUCH","fixedWindowInstance","FixedWindow","widgets","fixedScreenConstraints","windowWidth","isFixedWindowActive","touchListener","fixedBreakpointFn","thisWidget","fixed","Set","widgetsThatRequireFixedWindow","some","isFixed","getCurrentWidget","index","_removeFixedContainer","_addFixedContainer","map","foundProperty","direction","whatNode","property","d","__fixedWindowMod__","getScrollbarWidth","shouldNotMoveUp","shouldNotMoveDown","neverScroll","lastClientY","touchStartListener","getLastFixedWidget","closestOverflow","closestCallback","HTMLTextAreaElement","scrollHeight","touches","clientY","scrollTop","touchMoveListener","isScrollingDown","touchEndListener","documentElement","paddingRight","_checkFixedNeeded","pop","instance","constructor","fixedWidget","eventHandler","resizeListener","bind","fn","ms","timeout","EVENT_TAB_CLOSED","EVENT_TAB_OPENED","ACTIVE_CLASS","ATTR_TOGGLE_LIST","ContainerId","refId","ref","toggleTarget","_listener","querySelector","elClassList","failure","maybeToggleNode","parentClassList","toggle","children","targetRef","_handleLoaded","catch","ATTR_CLOSE_SIDEBAR","ATTR_TARGET","INIT_CLASS","OPEN_CLASS","HIDE_FACTOR","EVENT_TOGGLE","NavigationId","Darkener","factor","disableTouch","touchedX","navigationContainer","darkener","DARKENER_CLASS_TOGGLE","DARKENER_CLASS_INSTANT_TOGGLE","shouldNotTouch","darkenerClassToggle","darkenerClassToggleInstant","globalToggleClass","navigationContainerId","clientX","mustHide","calcX","bounds","compare","webkitTransition","transform","webkitTransform","_remove","resetTransform","_removeInstant","getTransitionEvent","scheduler","docCls","darkenerClass","navigationControllerClassList","docElementCls","promise","thisDelegate","validTarget","ATTR_CC","ATTR_DARKENER","ATTR_ENABLE_EVENT_BUBBLE","DARKENER_INIT","ATTR_DATA_TARGET","ATTR_CLOSE_DROPDOWN","STATE_LOADING","CLS_DARKENER_DROPDOWN","CLS_DROPDOWN","EVENT_DROPDOWN_CLOSED","currentTarget","destroyOnClose","targetIsCurrent","_delegateFunction","isLoading","createDropdown","cls","darkenerInstance","flexDarkenerInstance","thisCurrentOpen","toggleDarkenerToggler","data","dropdownContainerElement","dropdownContent","isAbsolute","flexCollisionContainer","collisionC","ATTR_MAX_WIDTH","ATTR_MAX_HEIGHT","ATTR_SRC","CLS_HAS_PREV","CLS_HAS_NEXT","CLS_LOADING","ATTR_NO_THUMBNAIL","ATTR_DATA_HREF","ATTR_HREF","KEY_NEXT","KEY_PREV","AttributeSelector","ModalAppend","thisDelegateContainer","_modalAppend","_resizeEvent","_keyboardNextEvent","_future","_nextFuture","_imageContainer","_modalContainerDiv","_contentContainer","_closerContainerDiv","_delegateContainer","_attributeSelector","_widget","_isOpen","img","_isLoading","registerPrevNextEvents","closeOnLast","onNext","onClose","getNext","getPrev","onSwitchImage","findImmediateNextTarget","nextElementSibling","previousElementSibling","onOpen","parentIsValid","next","switchImage","_","reject","hasPrev","hasNext","hasPrevClass","hasNextClass","isIE","nextThumb","nextHighRes","nextSource","src","nextImgObject","Image","backgroundImage","_setupMaxWidthHeight","_calculateContainer","highRes","_setupPrevNextStates","thisThumbnail","thisImgHighResolution","highImageObj","_getSrc","thumbnail","imgHighResolution","imgSrc","imageObj","pageX","TouchEvent","changedTouches","rect","imgX","wrapperWidth","posX","switchImageByDirection","_runOptionalClose","fromWidget","loadedImage","nextMaxWidth","nextMaxHeight","maxWidth","maxHeight"],"mappings":"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H;AACD,oBAAO8K,OAAOqJ,mBAAd;AACH;;AAED;;;;;;8CAG4B;AACxB,oBAAOrJ,OAAO2J,8BAAd;AACH;;AAED;;;;;;6CAG2B;AACvB,oBAAO3J,OAAOyJ,6BAAd;AACH;;AAED;;;;;;uCAGqB;AACjB,oBAAOzJ,OAAOsJ,uBAAd;AACH;;;;;;mBAGUtY,Q;;;;;;;ACtKf;AACA;AACA;AACA;AACA;AACA;;;;;;;ACLA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA,MAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,iBAAgB;AAChB;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,QAAO;;AAEP,MAAK;AACL;AACA;AACA,QAAO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,QAAO;AACP,MAAK;AACL;;AAEA;AACA;AACA,yCAAwC,mBAAmB;AAC3D;AACA;;AAEA;AACA;AACA,mCAAkC,oBAAoB;AACtD;AACA;;AAEA;AACA;AACA,yCAAwC,4BAA4B;AACpE;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,oBAAmB,iBAAiB;AACpC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA,QAAO;AACP;AACA,QAAO;AACP;AACA,QAAO;AACP;AACA,QAAO;AACP;AACA;AACA;AACA,QAAO;AACP;AACA,QAAO;AACP;AACA;;AAEA;AACA;AACA,wDAAuD;AACvD,UAAS;AACT;AACA,UAAS;AACT,+EAA8E;AAC9E;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,UAAS;AACT;AACA,UAAS;AACT;AACA,UAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,QAAO;AACP;AACA,QAAO;AACP;AACA,QAAO;AACP;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,+BAA8B,uBAAuB;AACrD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;AACA,wCAAuC,0BAA0B;AACjE;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA,gCAA+B,0BAA0B,eAAe;AACxE;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,QAAO;;AAEP;AACA,MAAK;AACL;AACA;AACA,EAAC;;;;;;;;;;;;;;;;;ACjdD;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;AAwBA;AACA;AACC,WAASsZ,IAAT,GAAgB;AACb,SAAItK,OAAO3G,QAAP,KAAoB,CAAC2G,OAAOuK,WAAR,IAAuB,OAAOvK,OAAOuK,WAAd,KAA8B,UAAzE,CAAJ,EAA0F;AACtF,aAAMA,eAAc,SAASA,WAAT,CAAqBhF,KAArB,EAA4BiF,MAA5B,EAAoC;AACpD,iBAAMC,aAAaD,UAAU;AACzBE,0BAAS,KADgB;AAEzBC,6BAAY,KAFa;AAGzBC,yBAAQlK;AAHiB,cAA7B;AAKA,iBAAMmK,MAAMxR,SAASyR,WAAT,CAAqB,aAArB,CAAZ;AACAD,iBAAIE,eAAJ,CAAoBxF,KAApB,EAA2BkF,WAAWC,OAAtC,EACID,WAAWE,UADf,EAC2BF,WAAWG,MADtC;AAEAC,iBAAIG,mBAAJ,GAA0BH,IAAIhV,cAA9B;AACAgV,iBAAIhV,cAAJ,GAAqB,YAAM;AACvB;AACA1B,wBAAO8W,cAAP,CAAsBJ,GAAtB,EAA2B,kBAA3B,EAA+C;AAC3CT,0BAAK,eAAM;AACP,gCAAO,IAAP;AACH;AAH0C,kBAA/C;AAKAS,qBAAIG,mBAAJ;AACH,cARD;AASA,oBAAOH,GAAP;AACH,UApBD;AAqBAN,sBAAYlT,SAAZ,GAAwB2I,OAAOkL,KAAP,CAAa7T,SAArC;AACA2I,gBAAOuK,WAAP,GAAqBA,YAArB;AACH;AACJ,EA1BA,GAAD;AA2BA;;;;KAGMY,Y;;AAEF;;;;AAIA,2BAAYtN,MAAZ,EAAoBnG,IAApB,EAA0B;AAAA;;AACtB,cAAKmG,MAAL,GAAcA,MAAd;AACA,cAAK9H,cAAL,GAAsB;AAClB2U,sBAAS,IADS;AAElBC,yBAAY;AAFM,UAAtB;;AAKA,cAAKjT,IAAL,GAAYA,IAAZ;AACH;;AAED;;;;;;;;;qCAKY/E,O,EAAS;AACjBwB,oBAAOC,MAAP,CAAc,KAAK2B,cAAnB,EAAoCpD,WAAW,EAA/C;AACA,oBAAO,IAAP;AACH;;AAED;;;;;;;;sCAKakC,C,EAAG;AACZ,oBAAO,KAAKgC,UAAL,CAAgB;AACnBuU,gCAAevW;AADI,cAAhB,CAAP;AAGH;;AAED;;;;;;;;oCAKWwW,C,EAAG;AACV,iBAAI,CAAC,KAAKtV,cAAL,CAAoB6U,MAAzB,EAAiC;AAC7B,sBAAK7U,cAAL,CAAoB6U,MAApB,GAA6B,EAA7B;AACH;AACDzW,oBAAOC,MAAP,CAAc,KAAK2B,cAAL,CAAoB6U,MAAlC,EAA0CS,CAA1C;AACA,oBAAO,IAAP;AACH;;AAED;;;;;;gCAGO;AACH,iBAAMxW,IAAI,IAAI0V,WAAJ,CAAgB,KAAK7S,IAArB,EAA2B,KAAK3B,cAAhC,CAAV;AACA,iBAAI,KAAK8H,MAAT,EAAiB;AACb,sBAAKA,MAAL,CAAYyN,aAAZ,CAA0BzW,CAA1B;AACH;AACD,oBAAOA,CAAP;AACH;;;;;;KAGCqW,K;;;;;;;;AACF;;;;;;kCAMgBrN,M,EAAQnG,I,EAAM;AAC1B,oBAAO,IAAIyT,YAAJ,CAAiBtN,MAAjB,EAAyBnG,IAAzB,CAAP;AACH;;AAED;;;;;;;;;;yCAOuBmG,M,EAAQnG,I,EAAM/E,O,EAAS;AAC1C,oBAAO,IAAIwY,YAAJ,CAAiBtN,MAAjB,EAAyBnG,IAAzB,EAA+B6T,WAA/B,CAA2C5Y,OAA3C,EAAoD8C,IAApD,EAAP;AACH;;;;;;mBAGUyV,K;;;;;;;;;;;;;;sjBC/If;;;;;;;;;;;;;;;;;;;;;;;;AAwBA;;;;;;AAMA;;AAEA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;;;AACA,KAAMM,UAAU,EAAhB;AACA;AACA,KAAMC,kBAAkB,mBAAxB;AACA,KAAMC,aAAa,kBAAnB;AACA,KAAMC,YAAY,YAAlB;;AAEA;AACA,KAAMC,wBAAwB,OAA9B;AACA,KAAMC,WAAW,MAAjB;AACA,KAAMC,cAAc,SAApB;AACA,KAAMC,oBAAoB,eAA1B;AACA,KAAMC,sBAAsB,iBAA5B;AACA,KAAMC,eAAe,gBAArB;AACA,KAAMC,uBAAuB,kBAA7B;AACA,KAAMC,aAAa,QAAnB;AACA,KAAMC,eAAe,UAArB;;AAEA;;AAEA;;;;AAIO,KAAMC,kDAAqB,sBAA3B;AACP;;;;AAIO,KAAMC,gEAA4B,2BAAlC;AACP;;;;AAIO,KAAMC,kDAAqB,sBAA3B;;AAEP;;;;AAIO,KAAMC,8CAAmB,oBAAzB;;AAEP;;;;AAIO,KAAMC,4EAAkC,iCAAxC;;AAEP;;;;KAGM3b,K;AACF,oBAAY6Q,iBAAZ,EAA+BhP,OAA/B,EAAwC;AAAA;;AACpC,aAAM+O,MAAM1B,OAAO3G,QAAnB;AACA,aAAMuI,YAAYD,6BAA6BZ,WAA7B,GACdY,iBADc,GACMD,IAAIV,cAAJ,CAAmBW,iBAAnB,CADxB;;AAGA;AACA,aAAI,CAACC,SAAL,EAAgB;AACZ,mBAAM,IAAI/O,KAAJ,6DAAoE8O,iBAApE,CAAN;AACH;;AAED,cAAK+K,WAAL,GAAmB,IAAnB;;AAEA,cAAKC,OAAL,GAAe,KAAf;;AAEA,cAAK/K,SAAL,GAAiBA,SAAjB;;AAEA;;;AAGA,cAAKjP,OAAL,GAAe;AACXmQ,yBAAY,OADD;AAEX8J,4BAAe,IAFJ;AAGXC,qCAAwB,IAHb;AAIXC,8BAAiB,KAJN;AAKXC,6BAAgB,IALL;AAMXC,kCAAqB;AANV,UAAf;;AASA7Y,gBAAOC,MAAP,CAAc,KAAKzB,OAAnB,EAA4BA,OAA5B;;AAEA;AACA,cAAKsa,cAAL,GAAsB,IAAtB;AACA,cAAKC,aAAL,GAAqB,IAArB;;AAEA,cAAKC,qBAAL,GAA6BnN,OAAO3G,QAAP,CAAgBjD,IAA7C;;AAEA,cAAKgX,gBAAL,GAAwB,CAAxB;;AAEA,cAAKC,cAAL,GAAsB,IAAtB;;AAEA;AACA;AACA,cAAKP,eAAL,GAAuB,KAAKna,OAAL,CAAama,eAApC;AACH;;AAED;;;;;;;;;;+CAMsBjM,C,EAAG;AACrB,iBAAMZ,IAAInP,MAAMwc,eAAN,CAAsBC,OAAtB,CAA8B1M,CAA9B,CAAV;AACA,iBAAIZ,IAAI,CAAC,CAAT,EAAY;AACRnP,uBAAMwc,eAAN,CAAsBE,MAAtB,CAA6BvN,CAA7B,EAAgC,CAAhC;AACA,uCAAYwN,WAAZ,GAA0BC,KAA1B;AACH;AACJ;;AAGD;;;;;;;6CAIoB;AAChB,oBAAO,KAAKL,cAAZ;AACH;;AAED;;;;;;;;+BAKMxY,C,EAAG;AACL,iBAAMC,OAAO,IAAb;;AAEA,iBAAMnC,UAAUmC,KAAK4X,WAAL,GAAmB,eAAKrY,uBAAL,CAC/BS,KAAK4X,WAD0B,EACb,eAAKiB,IAAL,CAAU7Y,KAAKnC,OAAf,CADa,CAAnB,GACiCmC,KAAKnC,OADtD;;AAGA;AACA,iBAAI,CAACA,QAAQia,aAAT,IAA0B/X,aAAa+Y,aAA3C,EAA0D;AACtD,wBAAO,KAAP;AACH;;AAED;AACA,iBAAI,CAACjb,QAAQka,sBAAT,IAAmChY,CAAnC,IACAA,EAAE0O,IAAF,KAAW,mBAASxD,WAAT,EADX,IACqC,CAAClL,EAAEgJ,MAAF,CAASG,YAAT,CAAsB0N,UAAtB,CAD1C,EAC6E;AACzE,wBAAO,KAAP;AACH;;AAED;AACA,iBAAI5W,KAAK6X,OAAT,EAAkB;AACd,wBAAO,KAAP;AACH;;AAED,iBAAI9X,CAAJ,EAAO;AACHA,mBAAEgB,cAAF;AACH;;AAED,iBAAIf,KAAK4X,WAAT,EAAsB;AAClB;AACA,qBAAMpX,KAAK,gBAAMuK,eAAN,CAAsB/K,KAAK4X,WAA3B,EAAwCJ,yBAAxC,CAAX;AACA,qBAAIhX,GAAGI,gBAAP,EAAyB;AACrB,4BAAO,KAAP;AACH;;AAED,sBAAKmY,YAAL,CAAkB/Y,KAAK4X,WAAvB;AACA;AACA,qBAAI5X,KAAK4X,WAAL,CAAiBoB,SAArB,EAAgC;AAC5B;AACA,4BAAOhZ,KAAKiZ,YAAL,CAAkBjZ,KAAK4X,WAAL,CAAiBoB,SAAnC,EACHhZ,KAAK4X,WAAL,CAAiBoB,SAAjB,CAA2BA,SAA3B,IAAwC,IADrC,CAAP;AAEH;;AAED;AACA,iCAAMvY,QAAN,CAAeT,KAAK4X,WAApB,EAAiCL,kBAAjC,EAAqD7W,YAArD,CAAkEX,CAAlE,EAAqEY,IAArE;AACH;AACDX,kBAAKkZ,qBAAL,CAA2BlZ,KAAK4X,WAAhC;;AAEA;AACA5X,kBAAK4X,WAAL,GAAmB,IAAnB;AACA,iBAAI5X,KAAKuY,cAAT,EAAyB;AACrB;AACA,qBAAMY,gBAAgBnd,MAAMwc,eAAN,CAAsBxc,MAAMwc,eAAN,CAAsB7U,MAAtB,GAA+B,CAArD,CAAtB;AACA,qBAAM6B,YAAYxF,KAAKuY,cAAL,CAAoB/S,SAAtC;AACAA,2BAAUG,MAAV,CAAiBmR,qBAAjB;AACAtR,2BAAUG,MAAV,CAAiB2R,YAAjB;AACA9R,2BAAUG,MAAV,CAAiBoR,QAAjB;AACA;AACA,sBAAK,IAAIjP,IAAI,CAAb,EAAgBA,IAAI9H,KAAKuY,cAAL,CAAoBa,UAApB,CAA+BzV,MAAnD,EAA2DmE,GAA3D,EAAgE;AAC5D,yBAAMuR,OAAOrZ,KAAKuY,cAAL,CAAoBa,UAApB,CAA+BtR,CAA/B,CAAb;AACA,yBAAMvB,KAAK8S,KAAK7T,SAAhB;AACA;AACAxF,0BAAK+Y,YAAL,CAAkBM,IAAlB;AACA9S,wBAAGZ,MAAH,CAAUqR,WAAV;AACAzQ,wBAAGZ,MAAH,CAAUsR,iBAAV;AACH;AACD,qBAAIkC,aAAJ,EAAmB;AACfA,mCAAcjT,UAAd,CAAyBV,SAAzB,CAAmCC,GAAnC,CAAuCqR,qBAAvC;AACH;AACJ;;AAED,iBAAI9W,KAAKgY,eAAT,EAA0B;AACtBhY,sBAAKH,OAAL;AACH;AACD,oBAAOG,IAAP;AACH;;AAED;;;;;;;;sCAKa+I,M,EAAQ;AACjBA,oBAAOvD,SAAP,CAAiBG,MAAjB,CAAwBwR,YAAxB;AACH;;AAED;;;;;;;;;qCAMYpX,C,EAAGC,I,EAAM;AACjBD,eAAEgJ,MAAF,CAASvD,SAAT,CAAmBC,GAAnB,CAAuB0R,YAAvB;AACApX,eAAEgJ,MAAF,CAASwC,mBAAT,CAA6BxL,EAAE0O,IAA/B,EAAqCzO,IAArC,EAA2C,IAA3C;AACH;;AAED;;;;;;;;sCAKasZ,E,EAAIC,I,EAAM;AACnBD,gBAAGN,SAAH,GAAeO,IAAf;AACAvd,mBAAMwc,eAAN,CAAsB1V,IAAtB,CAA2BwW,EAA3B;AACA,mCAAYX,WAAZ,GAA0Ba,IAA1B,CAA+B,IAA/B,EAAqC,KAAKjB,cAA1C;AACA,iBAAIgB,IAAJ,EAAU;AACN,sBAAKR,YAAL,CAAkBQ,IAAlB;AACA,gCAAKE,oBAAL,CAA0BF,IAA1B,EAAgC,cAAhC,EAAgD,KAAKG,WAArD;AACAH,sBAAK/T,SAAL,CAAeC,GAAf,CAAmBwR,iBAAnB;AACH;AACD;AACA,kBAAKW,WAAL,GAAmB0B,EAAnB;;AAEA;AACA,iBAAMhN,YAAYtQ,MAAMwc,eAAxB;;AAEA,kBAAK,IAAImB,IAAI,CAAb,EAAgBA,IAAIrN,UAAU3I,MAA9B,EAAsCgW,GAAtC,EAA2C;AACvCrN,2BAAUqN,CAAV,EAAazT,UAAb,CAAwBV,SAAxB,CAAkCG,MAAlC,CAAyCmR,qBAAzC;AACH;AACD,kBAAKyB,cAAL,CAAoB/S,SAApB,CAA8BC,GAA9B,CAAkCqR,qBAAlC;AACA;AACA;AACA,4BAAK2C,oBAAL,CAA0BH,EAA1B,EAA8B,cAA9B,EAA8C,KAAKI,WAAnD;;AAEA,kBAAK,IAAI5R,IAAI,CAAb,EAAgBA,IAAI,KAAKyQ,cAAL,CAAoBa,UAApB,CAA+BzV,MAAnD,EAA2DmE,GAA3D,EAAgE;AAC5D,qBAAMiE,IAAI,KAAKwM,cAAL,CAAoBa,UAApB,CAA+BtR,CAA/B,CAAV;AACA,qBAAM8R,YAAY7N,EAAEvG,SAAF,CAAYwF,QAAZ,CAAqBgM,WAArB,CAAlB;AACA,qBAAIjL,MAAMuN,EAAV,EAAc;AACVA,wBAAG9T,SAAH,CAAaC,GAAb,CAAiBuR,WAAjB;AACAsC,wBAAG9T,SAAH,CAAaG,MAAb,CAAoBsR,iBAApB;AACA,0BAAK8B,YAAL,CAAkBO,EAAlB;AACH,kBAJD,MAIO;AACHvN,uBAAEvG,SAAF,CAAYG,MAAZ,CAAmBqR,WAAnB;AACA,yBAAI4C,SAAJ,EAAe;AACX,8BAAKV,qBAAL,CAA2BnN,CAA3B;AACA,yCAAMhB,eAAN,CAAsBgB,CAAtB,EAAyBwL,kBAAzB;AACH;AACJ;AACJ;AACJ;;AAED;;;;;;;;sCAKaxX,C,EAAG;AAAA;;AACZ,iBAAMC,OAAO,IAAb;AACA,iBAAI,KAAK6X,OAAT,EAAkB;AACd,wBAAO,KAAP;AACH;;AAED;AACA,iBAAI9X,KAAKA,EAAEgJ,MAAX,EAAmB;AACf,qBAAM8Q,gBAAgB,eAAKhI,YAAL,CAAkB9R,EAAEgJ,MAApB,EAA4B,UAACsQ,IAAD,EAAU;AACxD,4BAAOA,QAAQA,KAAKS,iBAApB;AACH,kBAFqB,CAAtB;;AAIA;AACA,qBAAID,kBAAkB,KAAK/M,SAA3B,EAAsC;AAClC,4BAAO,KAAP;AACH;AACJ;AACD,iBAAIiN,sBAAJ;AACA,iBAAIvT,eAAJ;AACA,iBAAIwT,eAAJ;AACA,iBAAIjR,eAAJ;AACA,iBAAIkR,YAAY,IAAhB;AACA,iBAAMC,gBAAgBna,aAAakM,WAAnC;AACA,iBAAMkO,WAAW,iBAAOA,QAAP,CAAgBpa,CAAhB,CAAjB;AACA,iBAAIma,iBAAiBC,QAArB,EAA+B;AAC3B,qBAAID,aAAJ,EAAmB;AACfH,qCAAgBha,CAAhB;AACH,kBAFD,MAEO;AACHia,8BAASja,CAAT;AACAga,qCAAgBC,OAAOxL,OAAvB;AACH;AACJ,cAPD,MAOO;AACHzF,0BAAShJ,EAAEgJ,MAAX;AACA,qBAAI,CAACA,MAAL,EAAa;AACT,2BAAM,IAAIhL,KAAJ,CAAU,2EAAV,CAAN;AACH;AACDkc,6BAAYlR,OAAOG,YAAP,CAAoB2N,SAApB,CAAZ;AACAkD,iCAAgBhR,OAAO7I,YAAP,CAAoB2W,SAApB,CAAhB;AACAmD,0BAAS,iBAAOI,UAAP,CAAkBrR,MAAlB,CAAT;AACA,qBAAIA,OAAOG,YAAP,CAAoByN,eAApB,KAAwC,CAAC5W,EAAEsa,WAA/C,EAA4D;AACxD,yBAAMA,cAAc,IAAIre,KAAJ,CAAU,KAAK8Q,SAAf,EACfwN,kBADe,CACI,IADJ,CAApB;AAEAva,uBAAEsa,WAAF,GAAgB,IAAhB;AACAA,iCAAYE,SAAZ,CAAsBxa,CAAtB,EAAyB4B,IAAzB,CAA8B,YAAM;AAChC0Y,qCAAYG,cAAZ,CAA2BH,YAAYI,iBAAZ,EAA3B;AACH,sBAFD;AAGA,4BAAO,KAAP;AACH;AACD,qBAAIR,SAAJ,EAAe;AACXla,uBAAE2a,wBAAF;AACA3a,uBAAEgB,cAAF;AACH;AACJ;;AAED,iBAAI,CAACkZ,SAAL,EAAgB;AACZ,wBAAO,KAAP;AACH;;AAED,iBAAIU,wBAAwB,KAAKpC,cAAL,GAAsB,KAAKA,cAAL,CAAoB/S,SAA1C,GAAsD,EAAlF;;AAEA;AACA,iBAAI,CAAC,KAAK+S,cAAV,EAA0B;AACtB,sBAAKA,cAAL,GAAsBrN,OAAO3G,QAAP,CAAgB+I,aAAhB,CAA8B,KAA9B,CAAtB;AACA,sBAAKiL,cAAL,CAAoBrK,SAApB,GAAmCgJ,mBAAnC,SAA0D,KAAKrZ,OAAL,CAAaqa,mBAAvE,SAA8FnB,QAA9F;AACA,qBAAM6D,qBAAqB,SAArBA,kBAAqB,CAACC,EAAD,EAAQ;AAC/B,yBAAI,MAAKhD,OAAT,EAAkB;AACd,gCAAO,KAAP;AACH;AACD,yBAAI,eAAK9F,YAAL,CAAkB8I,GAAG9R,MAArB,EAA6B,MAAK6O,WAAlC,CAAJ,EAAoD;AAChD,6BAAI,CAACiD,GAAG9R,MAAH,CAAUG,YAAV,CAAuB0N,UAAvB,CAAL,EAAyC;AACrC,oCAAO,KAAP;AACH;AACJ;AACD,2BAAKgC,KAAL,CAAWiC,EAAX;AACH,kBAVD;;AAYA,sBAAKtC,cAAL,CAAoB/O,gBAApB,CAAqC,mBAASyB,WAAT,EAArC,EAA6D2P,kBAA7D,EAAiF,KAAjF;;AAEAD,yCAAwB,KAAKpC,cAAL,CAAoB/S,SAA5C;AACA,sBAAKsH,SAAL,CAAeS,WAAf,CAA2B,KAAKgL,cAAhC;AACH,cAnBD,MAmBO;AACHoC,uCAAsBlV,GAAtB,CAA0BsR,QAA1B;AACH;;AAED,iBAAI+D,eAAJ;AACA,iBAAMlO,MAAM1B,OAAO3G,QAAnB;AACA,iBAAMwW,eAAe,SAAfA,YAAe,CAACC,IAAD,EAAU;AAC3B,qBAAIA,IAAJ,EAAU;AACNF,8BAASlO,IAAIU,aAAJ,CAAkB,KAAlB,CAAT;AACAwN,4BAAO5M,SAAP,GAAmBkJ,oBAAnB;AACA,yBAAM6D,eAAerO,IAAIU,aAAJ,CAAkB,KAAlB,CAArB;AACA2N,kCAAa/M,SAAb,GAAyBmJ,UAAzB;AACAyD,4BAAOvN,WAAP,CAAmB0N,YAAnB;AACA,2BAAK1C,cAAL,CAAoBhL,WAApB,CAAgCuN,MAAhC;AACH,kBAPD,MAOO;AACHA,4BAAO5U,UAAP,CAAkBC,WAAlB,CAA8B2U,MAA9B;AACH;AACJ,cAXD;AAYAH,mCAAsBlV,GAAtB,CAA0B,SAA1B;AACAkV,mCAAsBlV,GAAtB,CAA0BqR,qBAA1B;;AAEAoE,mCAAsB,YAAM;AACxBA,uCAAsB,YAAM;AACxBP,2CAAsBlV,GAAtB,CAA0B6R,YAA1B;AACH,kBAFD;AAGH,cAJD;;AAMA,kBAAKO,OAAL,GAAe,IAAf;AACAkD,0BAAa,IAAb;AACA,iBAAMI,QAAQnB,SAASA,OAAOoB,QAAP,EAAT,GAA6B,IAA3C;AACA,iBAAI,iBAAOjB,QAAP,CAAgBH,MAAhB,KAA2BmB,KAA/B,EAAsC;AAClC3U,0BAAS2U,MAAMxZ,IAAN,CAAW,UAACC,CAAD,EAAO;AACvB,yBAAIS,eAAJ;AACA,yBAAIT,aAAaqK,WAAb,IAA4BrK,aAAayZ,gBAA7C,EAA+D;AAC3DhZ,kCAAST,CAAT;AACH,sBAFD,MAEO;AACH;AACA,6BAAM4M,UAAU5B,IAAIU,aAAJ,CAAkB,KAAlB,CAAhB;AACAkB,iCAAQN,SAAR,GAAoBlO,KAAKnC,OAAL,CAAamQ,UAAjC;AACAQ,iCAAQZ,SAAR,GAAoBhM,CAApB;AACA4M,iCAAQ1J,EAAR,GAAa,eAAKwW,IAAL,EAAb;AACAjZ,kCAASmM,OAAT;AACH;AACDwL,4BAAOuB,YAAP,GAAsBlZ,MAAtB;AACA,qCAAM0I,eAAN,CAAsBhC,MAAtB,EAA8B4O,+BAA9B;AACA,4BAAOtV,MAAP;AACH,kBAfQ,CAAT;AAgBH,cAjBD,MAiBO;AACH,qBAAMiD,KAAKyU,yBAAyB9N,WAAzB,IACX8N,yBAAyBsB,gBADd,GACiCtB,aADjC,GACiDnN,IAAIV,cAAJ,CAAmB6N,aAAnB,CAD5D;AAEA,qBAAIzU,EAAJ,EAAQ;AACJkB,8BAAS,IAAItI,OAAJ,CAAY,UAAC2L,OAAD,EAAa;AAC9BA,iCAAQvE,EAAR;AACH,sBAFQ,CAAT;AAGH,kBAJD,MAIO;AACH,2BAAM,IAAIvH,KAAJ,6DAAoEgc,aAApE,CAAN;AACH;AACJ;;AAED,6BAAMhP,eAAN,CAAsBhC,MAAtB,EAA8B2O,gBAA9B;;AAEA,oBAAOlR,OAAO7E,IAAP,CAAY,UAAC6Z,MAAD,EAAY;AAC3BA,wBAAOhc,gBAAP;AACA,uBAAK+Y,cAAL,CAAoBhL,WAApB,CAAgCiO,MAAhC;AACAb,uCAAsBhV,MAAtB,CAA6B,SAA7B;AACA,uBAAKkS,OAAL,GAAe,KAAf;AACAkD,8BAAa,KAAb;AACA,uBAAKvB,IAAL,CAAUgC,MAAV,EAAkB,IAAlB,EAAwBzb,CAAxB;AACA,wBAAOyb,MAAP;AACH,cARM,CAAP;AASH;;AAED;;;;;;;;;8BAMKC,K,EAAOC,Q,EAAUC,U,EAAY;AAC9B,iBAAI,CAACD,QAAL,EAAe;AACX,sBAAKnD,cAAL,CAAoB/S,SAApB,CAA8BC,GAA9B,CAAkC,MAAlC;AACH;AACD,kBAAKwT,YAAL,CAAkBwC,KAAlB,EAAyB,KAAK7D,WAA9B;;AAEA,6BAAMnX,QAAN,CAAegb,KAAf,EAAsBhE,kBAAtB,EAA0C/W,YAA1C,CAAuDib,UAAvD,EAAmEhb,IAAnE;AACH;;;wCAGcib,Q,EAAU;AAAA;;AACrB,iBAAMC,oBAAoBD,YAAY,KAAK9O,SAA3C;AACA;AACA,mCAAY6L,WAAZ,GAA0BmD,mBAA1B,CAA8C9f,KAA9C,EAAqD;AAAA,wBAAM,IAAN;AAAA,cAArD;AACA;AACA6f,+BAAkB/B,iBAAlB,GAAsC,IAAtC;AACA,kBAAK1B,aAAL,GAAqB,YAAa;AAAA,mDAATvE,IAAS;AAATA,yBAAS;AAAA;;AAC9B,wBAAKkI,YAAL,CAAkBja,KAAlB,SAA8B+R,IAA9B;AACH,cAFD;AAGAgI,+BAAkBrS,gBAAlB,CAAmC,mBAASyB,WAAT,EAAnC,EAA2D,KAAKmN,aAAhE,EAA+E,KAA/E;;AAEA,kBAAKD,cAAL,GAAsB0D,iBAAtB;AACA,oBAAO,IAAP;AACH;;AAGD;;;;;;;;oCAKW7B,M,EAAQ;AACf,oBAAO,KAAK+B,YAAL,CAAkB/B,MAAlB,CAAP;AACH;;AAED;;;;;;;;mCAKUja,C,EAAG;AACT,oBAAO,KAAKgc,YAAL,CAAkBhc,CAAlB,CAAP;AACH;;;4CAEkBic,C,EAAG;AAClB,kBAAKhE,eAAL,GAAuBgE,CAAvB;AACA,oBAAO,IAAP;AACH;;AAED;;;;;;;mCAIU;AACN,iBAAMzD,iBAAiB,KAAKA,cAA5B;AACA,iBAAM0D,mBAAmB1D,eAAea,UAAf,CAA0BzV,MAA1B,KAAqC,CAA9D;AACA;AACA,iBAAI,KAAKwU,cAAT,EAAyB;AACrB,sBAAKA,cAAL,CAAoB5M,mBAApB,CAAwC,mBAASN,WAAT,EAAxC,EAAgE,KAAKmN,aAArE,EAAoF,IAApF;AACH;;AAED,iBAAI6D,gBAAJ,EAAsB;AAClB,qBAAI1D,eAAerS,UAAnB,EAA+B;AAC3BqS,oCAAerS,UAAf,CAA0BC,WAA1B,CAAsCoS,cAAtC;AACH;AACJ;AACD,iBAAIrN,OAAOgR,gBAAX,EAA6B;AACzB,qBAAMC,WAAW,IAAID,gBAAJ,CAAqB,UAACE,SAAD,EAAe;AACjDA,+BAAU5Z,OAAV,CAAkB,YAAM;AACpB,6BAAI+V,eAAea,UAAf,CAA0BzV,MAA1B,KAAqC,CAAzC,EAA4C;AACxC4U,4CAAerS,UAAf,CAA0BC,WAA1B,CAAsCoS,cAAtC;AACA4D,sCAASE,UAAT;AACH;AACJ,sBALD;AAMH,kBAPgB,CAAjB;AAQAF,0BAASG,OAAT,CAAiB/D,cAAjB,EACI;AACIgE,gCAAW;AADf,kBADJ;AAKH,cAdD,MAcO;AACHhE,gCAAe/O,gBAAf,CAAgC,gBAAhC,EAAkD,UAACzJ,CAAD,EAAO;AACrD,yBAAIA,EAAEgJ,MAAF,KAAawP,cAAb,IAAgCA,eAAea,UAAf,CAA0BzV,MAA1B,GAAmC,CAApC,KAA2C,CAA9E,EAAiF;AAC7E4U,wCAAerS,UAAf,CAA0BC,WAA1B,CAAsCoS,cAAtC;AACH;AACJ,kBAJD;AAKH;AACJ;;;;;;AAIL;;;AACAvc,OAAMwc,eAAN,GAAwB,EAAxB;;AAEA,KAAItN,OAAO1B,gBAAX,EAA6B;AAC7B;AACI0B,YAAO1B,gBAAP,CAAwB,SAAxB,EAAmC,UAACzJ,CAAD,EAAO;AACtC,aAAIA,EAAEyc,OAAF,KAAc9F,OAAlB,EAA2B;AACvB,iBAAM+F,YAAYzgB,MAAMwc,eAAN,CAAsBxc,MAAMwc,eAAN,CAAsB7U,MAAtB,GAA+B,CAArD,CAAlB;AACA,iBAAI8Y,SAAJ,EAAe;AACX,kCAAOrC,UAAP,CAAkBqC,SAAlB,EAA6B7D,KAA7B,CAAmC7Y,CAAnC;AACH;AACJ;AACJ,MAPD;AAQH;;mBAEc/D,K;;;;;;;;;;;;;;;;;;;AC1jBf;;;;;;;;;;;;;;;;;;;;;;;;AAwBA;;;;;;AAMA;;;KAGMC,M;;AAEF;;;;AAIA,mBAAYuS,OAAZ,EAAqB;AAAA;;AAAA;;AACjB;;;;AAIA,UAAKkO,YAAL,GAAoB,IAApB;;AAEA;;;AAGA,UAAKC,SAAL,GAAiB,IAAjB;;AAEA,SAAInO,OAAJ,EAAa;AACT;;;AAGA,YAAKA,OAAL,GAAeA,mBAAmBvC,WAAnB,GAAiCuC,OAAjC,GAA2CtD,OAAO3G,QAAP,CAAgB2H,cAAhB,CAA+BsC,OAA/B,CAA1D;AACA,WAAI,KAAKA,OAAT,EAAkB;AACd,cAAKA,OAAL,CAAahP,gBAAb,GAAgC,IAAhC;AACA,cAAKod,QAAL,CAAc,YAAM;AAChB,kBAAO,IAAI1e,OAAJ,CAAY,UAAC+S,CAAD,EAAO;AACtBA,eAAE,MAAKzC,OAAP;AACH,YAFM,CAAP;AAGH,UAJD;AAKH,QAPD,MAOO;AACH,eAAM,IAAIzQ,KAAJ,uCAA8CyQ,OAA9C,CAAN;AACH;AACJ;AACD;;;;AAIA,UAAK+M,YAAL,GAAoB,IAApB;AACH;;AAED;;;;;;;;gCAIW;AACP,cAAO,KAAKmB,YAAL,EAAP;AACH;;AAED;;;;;;;8BAISvB,K,EAAO;AACZ,YAAKuB,YAAL,GAAoBvB,KAApB;AACA,cAAO,IAAP;AACH;;AAED;;;;;;uCAGkB;AACd,cAAO,KAAKI,YAAZ;AACH;;AAED;;;;;;;gCAIW/M,O,EAAS;AAChB,YAAKA,OAAL,GAAeA,OAAf;AACA,cAAO,IAAP;AACH;;AAED;;;;;;;+BAIU;AACN,WAAI,KAAK+M,YAAL,IAAqB,KAAKA,YAAL,CAAkBrV,UAA3C,EAAuD;AACnD,cAAKqV,YAAL,CAAkBrV,UAAlB,CAA6BC,WAA7B,CAAyC,KAAKoV,YAA9C;AACA,gBAAO,IAAP;AACH;;AAED,cAAO,KAAK/M,OAAZ;AACA,cAAO,KAAKkO,YAAZ;AACA,cAAO,KAAKnB,YAAZ;;AAEA,cAAO,KAAP;AACH;;AAED;;;;;;;;gCAKkB/M,O,EAAS;AACvB,cAAOA,UAAUA,QAAQhP,gBAAlB,GAAqCoM,SAA5C;AACH;;AAED;;;;;;;;8BAKgB5L,I,EAAM;AAClB,cAAOA,gBAAgB/D,MAAhB,IAA0B,QAAO+D,IAAP,yCAAOA,IAAP,OAAgB,QAAhB,IAA4BA,KAAKsR,cAAL,CAAoB,WAApB,CAA7D;AACH;;;;;;mBAGUrV,M;;;;;;;;;;;;;;;;;;;;AC/If;;;;AACA;;;;AACA;;;;AACA;;;;;;;;AAEA,KAAM4gB,mBAAmB,mBAAzB;;AAEO,KAAMC,0DAAyB,+BAA/B;AACA,KAAMC,8DAA2B,iCAAjC;;AAEP;;;AAGO,KAAMC,sEAA+B,eAArC;;AAEP;;;AAGA,KAAIC,4BAAJ;;KAEqBC,W;AAEjB,4BAAc;AAAA;;AACV,cAAKC,OAAL,GAAe,EAAf;AACA,cAAK7E,gBAAL,GAAwB,CAAxB;AACA,cAAK8E,sBAAL,GAA8B,EAA9B;AACA,cAAKC,WAAL,GAAmB,CAAnB;AACA,cAAKC,mBAAL,GAA2B,KAA3B;AACA,cAAKC,aAAL,GAAqB,IAArB;AACH;;AAED;;;;;;;;;;6CAMoBvD,M,EAAQwD,iB,EAAmB;AAC3C,kBAAKJ,sBAAL,CAA4BpD,MAA5B,IAAsCwD,iBAAtC;AACH;;AAED;;;;;;4CAGmB;AACf,oBAAO,KAAKL,OAAL,CAAaxZ,MAAb,GAAsB,CAAtB,GAA0B,KAAKwZ,OAAL,CAAa,KAAKA,OAAL,CAAaxZ,MAAb,GAAsB,CAAnC,CAA1B,GAAkE,IAAzE;AACH;;;8CAEoB;AACjB,iBAAIA,SAAS,KAAKwZ,OAAL,CAAaxZ,MAA1B;AACA,iBAAIqW,SAAS,IAAb;AACA,oBAAOrW,SAAS,CAAhB,EAAmB;AACf,qBAAM8Z,aAAa,KAAKN,OAAL,CAAaxZ,SAAS,CAAtB,CAAnB;AACA,qBAAI8Z,WAAWC,KAAf,EAAsB;AAClB1D,8BAASyD,UAAT;AACA;AACH;AACD9Z;AACH;AACD,oBAAOqW,MAAP;AACH;;AAED;;;;;;6CAGoB;AAAA;;AAChB,iBAAI,KAAKmD,OAAL,CAAaxZ,MAAb,KAAwB,CAA5B,EAA+B;AAC3B;AACH;AACD,iBAAMwZ,UAAU,IAAIQ,GAAJ,CAAQ,KAAKR,OAAb,CAAhB;AACA,iBAAMS,gCAAgCtb,MAAM2B,IAAN,CAAWkZ,OAAX,EAAoBU,IAApB,CAAyB,cAAM;AAAA,qBACzD7D,MADyD,GAC9C1U,EAD8C,CACzD0U,MADyD;;AAEjE,qBAAM8D,UAAU,MAAKV,sBAAL,CAA4BpD,MAA5B,KACd,MAAKoD,sBAAL,CAA4BpD,MAA5B,EAAoC,MAAKqD,WAAzC,EAAsD,MAAKU,gBAAL,EAAtD,CADF;AAEA,qBAAMC,QAAQ,MAAKb,OAAL,CAAa1E,OAAb,CAAqBnT,EAArB,CAAd;AACA,uBAAK6X,OAAL,CAAaa,KAAb,IAAsB3e,OAAOC,MAAP,CAAcgG,EAAd,EAAkB,EAAEoY,OAAOI,OAAT,EAAlB,CAAtB;AACA,wBAAOA,OAAP;AACH,cAPqC,CAAtC;AAQA,iBAAI,CAACF,6BAAL,EAAoC;AAChC,sBAAKK,qBAAL;AACH,cAFD,MAEO;AACH,sBAAKC,kBAAL;AACH;AACJ;;AAED;;;;;;8CAGqB;AAAA;;AACjB,iBAAI,KAAKZ,mBAAT,EAA8B;AAC1B;AACH;AACD,6BAAMvS,eAAN,CAAsBG,OAAO3G,QAA7B,EAAuCuY,sBAAvC,EAA+D;AAC3DhH,yBAAQ,KAAKiI,gBAAL;AADmD,cAA/D;AAGA;AACA;AACA,gCAASzI,GAAT,GAAerB,oBAAf,CAAoCkK,GAApC,CAAwC,UAACpS,CAAD,EAAO;AAC3C,qBAAIqS,gBAAgB,cAApB;AACA,qBAAIC,YAAY,CAAhB;AACA,qBAAIhF,OAAOtN,CAAX;AACA,qBAAIA,aAAazJ,KAAjB,EAAwB;AAAA,6CACYyJ,CADZ;AAAA,yBACbuS,QADa;AAAA,yBACHC,QADG;AAAA,yBACOC,CADP;;AAEpBJ,qCAAgBG,QAAhB;AACAlF,4BAAOiF,QAAP;AACAD,iCAAYG,KAAK,CAAjB;AACH;AACD,wBAAO;AACHnF,+BADG;AAEHkF,+BAAUH,aAFP;AAGHvb,4BAAU0O,SAASrG,OAAO4G,gBAAP,CAAwBuH,IAAxB,EAA8B+E,aAA9B,CAAT,EAAuD,EAAvD,KACT,CAAC/E,KAAKoF,kBAAN,GAA4B,mBAASC,iBAAT,KAA+BL,SAA3D,GAAwE,CAD/D,CAAV;AAHG,kBAAP;AAMH,cAhBD,EAgBG7b,OAhBH,CAgBW,UAACgc,CAAD,EAAO;AACdA,mBAAEnF,IAAF,CAAOoF,kBAAP,GAA4B,IAA5B;AACAD,mBAAEnF,IAAF,CAAO5L,KAAP,CAAa+Q,EAAED,QAAf,IAA2BC,EAAE3b,KAA7B;AACH,cAnBD;;AAqBA,kBAAK0a,aAAL,GAAqB,UAACxd,CAAD,EAAO;AACxBA,mBAAEgB,cAAF;AACH,cAFD;;AAIA,iBAAI4d,kBAAkB,KAAtB;AACA,iBAAIC,oBAAoB,KAAxB;AACA,iBAAIC,cAAc,KAAlB;AACA,iBAAIC,cAAc,CAAlB;AACA,kBAAKC,kBAAL,GAA0B,UAAChf,CAAD,EAAO;AAAA,2CACX,OAAKif,kBAAL,EADW;AAAA,qBACvBxQ,OADuB,uBACvBA,OADuB;;AAE7B,qBAAMyQ,kBAAkB,eAAKC,eAAL,CAAqBnf,EAAEgJ,MAAvB,EACtB,UAACzD,EAAD;AAAA,4BAAQA,cAAc6Z,mBAAd,IACP7Z,GAAG4D,YAAH,IAAmB5D,GAAG4D,YAAH,CAAgB8T,4BAAhB,CADpB;AAAA,kBADsB,CAAxB;AAGA,qBAAIiC,mBAAmBA,gBAAgBG,YAAhB,KAAiCH,gBAAgBvO,YAAxE,EAAsF;AAClFlC,+BAAUyQ,eAAV;AACH;AACD,qBAAI,eAAKlN,YAAL,CAAkBhS,EAAEgJ,MAApB,EAA4ByF,OAA5B,CAAJ,EAA0C;AACtCqQ,mCAAcrQ,QAAQ4Q,YAAR,KAAyB5Q,QAAQkC,YAA/C;AACAoO,mCAAc/e,EAAEsf,OAAF,CAAU,CAAV,EAAaC,OAA3B;AACA;AACA,yBAAIT,WAAJ,EAAiB;AACb,gCAAO,KAAP;AACH;AACD,yBAAIrQ,QAAQ+Q,SAAR,KAAsB,CAA1B,EAA6B;AACzBZ,2CAAkB,IAAlB;AACH,sBAFD,MAEO,IAAInQ,QAAQ4Q,YAAR,KAAyB5Q,QAAQ+Q,SAAR,GAAoB/Q,QAAQkC,YAAzD,EAAuE;AAC1EkO,6CAAoB,IAApB;AACH;AACJ;AACJ,cArBD;;AAuBA1T,oBAAO1B,gBAAP,CAAwB,WAAxB,EAAqC,KAAK+T,aAA1C;AACArS,oBAAO3G,QAAP,CAAgBjD,IAAhB,CAAqBkI,gBAArB,CAAsC,YAAtC,EAAoD,KAAKuV,kBAAzD;;AAEA,kBAAKS,iBAAL,GAAyB,UAACzf,CAAD,EAAO;AAAA,4CACR,OAAKif,kBAAL,EADQ;AAAA,qBACpBxQ,OADoB,wBACpBA,OADoB;;AAE5B,qBAAI,eAAKuD,YAAL,CAAkBhS,EAAEgJ,MAApB,EAA4ByF,OAA5B,CAAJ,EAA0C;AAAA,yBAC9B8Q,OAD8B,GAClBvf,EAAEsf,OAAF,CAAU,CAAV,CADkB,CAC9BC,OAD8B;;AAEtC,yBAAMG,kBAAmBX,cAAcQ,OAAf,GAA0B,CAAlD;AACAR,mCAAcQ,OAAd;AACA,yBAAIT,WAAJ,EAAiB;AACb,gCAAO,KAAP;AACH;AACD,yBAAK,CAACD,iBAAD,IAAsBa,eAAvB,IACCb,qBAAqB,CAACa,eADvB,IAEC,CAACb,iBAAD,IAAsB,CAACD,eAAvB,IAA0C,CAACc,eAF5C,IAGCb,qBAAqBD,eAArB,IAAwCc,eAH7C,EAIE;AACE1f,2BAAE2a,wBAAF;AACH;AACJ;AACJ,cAjBD;;AAmBA,kBAAKgF,gBAAL,GAAwB,YAAM;AAC1Bb,+BAAc,KAAd;AACAF,mCAAkB,KAAlB;AACAC,qCAAoB,KAApB;AACAE,+BAAc,CAAd;AACH,cALD;;AAOA5T,oBAAO3G,QAAP,CAAgBjD,IAAhB,CAAqBkI,gBAArB,CAAsC,WAAtC,EAAmD,KAAKgW,iBAAxD;AACAtU,oBAAO3G,QAAP,CAAgBjD,IAAhB,CAAqBkI,gBAArB,CAAsC,UAAtC,EAAkD,KAAKkW,gBAAvD;AACAxU,oBAAO3G,QAAP,CAAgBob,eAAhB,CAAgCna,SAAhC,CAA0CC,GAA1C,CAA8CoX,gBAA9C;AACA,kBAAKS,mBAAL,GAA2B,IAA3B;AACH;;AAED;;;;;;iDAGwB;AACpB,iBAAI,KAAKA,mBAAT,EAA8B;AAC1B;AACApS,wBAAOK,mBAAP,CAA2B,WAA3B,EAAwC,KAAKgS,aAA7C;AACArS,wBAAO3G,QAAP,CAAgBjD,IAAhB,CAAqBiK,mBAArB,CAAyC,YAAzC,EAAuD,KAAKwT,kBAA5D;AACA7T,wBAAO3G,QAAP,CAAgBjD,IAAhB,CAAqBiK,mBAArB,CAAyC,WAAzC,EAAsD,KAAKiU,iBAA3D;AACAtU,wBAAO3G,QAAP,CAAgBjD,IAAhB,CAAqBiK,mBAArB,CAAyC,UAAzC,EAAqD,KAAKmU,gBAA1D;;AAEA;AACA,oCAASpK,GAAT,GAAerB,oBAAf,CAAoCzR,OAApC,CAA4C,UAAC6W,IAAD,EAAU;AAClD,yBAAIA,gBAAgB/W,KAApB,EAA2B;AAAA,oDACM+W,IADN;AAAA,6BAChBiF,QADgB;AAAA,6BACNC,QADM;;AAEvB,gCAAOD,SAASG,kBAAhB;AACAH,kCAAS7Q,KAAT,CAAe8Q,QAAf,IAA2B,EAA3B;AACH,sBAJD,MAIO;AACH,gCAAOlF,KAAKoF,kBAAZ;AACApF,8BAAK5L,KAAL,CAAWmS,YAAX,GAA0B,EAA1B;AACH;AACJ,kBATD;AAUA1U,wBAAO3G,QAAP,CAAgBob,eAAhB,CAAgCna,SAAhC,CAA0CG,MAA1C,CAAiDkX,gBAAjD;AACA,iCAAM9R,eAAN,CAAsBG,OAAO3G,QAA7B,EAAuCwY,wBAAvC;AACA,sBAAKO,mBAAL,GAA2B,KAA3B;AACH;AACJ;;AAED;;;;;;0CAGiB;AACb,kBAAKD,WAAL,GAAmBnS,OAAOmK,UAA1B;AACA,kBAAKwK,iBAAL;AACH;;AAED;;;;;;;;AAiBA;;;iCAGQ;AACJ,kBAAK1C,OAAL,CAAa2C,GAAb;AACA,kBAAKD,iBAAL;AACA,iBAAI,KAAK1C,OAAL,CAAaxZ,MAAb,KAAwB,CAA5B,EAA+B;AAC3B,sBAAKsa,qBAAL;AACH;AACJ;;AAED;;;;;;;;8BAKK8B,Q,EAAUvR,O,EAAS;AACpB,iBAAIkP,QAAQ,KAAZ;AACA,iBAAI,QAAOqC,QAAP,yCAAOA,QAAP,OAAoB,QAAxB,EAAkC;AAC9B,qBAAM/F,SAAS+F,SAASC,WAAxB;AACA,qBAAMC,cAAc,KAAK7C,sBAAL,CAA4B2C,SAASC,WAArC,CAApB;AACA,qBAAIhG,UAAUiG,WAAd,EAA2B;AACvBvC,6BAAQuC,YAAY,KAAK5C,WAAjB,EAA8B0C,QAA9B,CAAR;AACH;AACD,sBAAK5C,OAAL,CAAara,IAAb,CACI;AACIkX,mCADJ;AAEIxL,qCAFJ;AAGIkP;AAHJ,kBADJ;AAOA;AACA,qBAAI,CAAC,KAAKJ,mBAAN,IAA6BI,KAAjC,EAAwC;AACpC,0BAAKQ,kBAAL;AACH;AACJ;AACJ;;;uCAlDoB;AACjB,iBAAI,CAACjB,mBAAL,EAA0B;AACtBA,uCAAsB,IAAIC,WAAJ,EAAtB;AACAD,qCAAoBI,WAApB,GAAkCnS,OAAOmK,UAAzC;AACA,qBAAM6K,eAAejD,oBAAoBkD,cAApB,CAAmCC,IAAnC,CAAwCnD,mBAAxC,CAArB;AACA/R,wBAAO1B,gBAAP,CACI,QADJ,EAEI,wBAAS0W,YAAT,EAAuB,GAAvB,CAFJ;AAIAhV,wBAAO1B,gBAAP,CAAwB,mBAAxB,EAA6C0W,YAA7C;AACH;AACD,oBAAOjD,mBAAP;AACH;;;;;;mBAvNgBC,W;;;;;;;;;;;;;mBCpBN,UAACmD,EAAD,EAAKC,EAAL;AAAA,YAAY,YAAa;AAAA,2CAATzM,IAAS;AAATA,iBAAS;AAAA;;AACpC1J,sBAAakW,GAAGE,OAAhB;AACAF,YAAGE,OAAH,GAAazW,WAAWuW,GAAGD,IAAH,8BAAiBvM,IAAjB,EAAX,EAAmCyM,EAAnC,CAAb;AACA,gBAAOD,GAAGE,OAAV;AACH,MAJc;AAAA,E;;;;;;;;;;;;;sjBCAf;;;;;;;;;;;;;;;;;;;;;;;;AAwBA;;;;;;AAMA;;;;AACA;;;;AACA;;;;AACA;;;;;;;;AAEA;;;;;AAKO,KAAMC,8CAAmB,oBAAzB;;AAEP;;;;AAIO,KAAMC,8CAAmB,oBAAzB;AACP;;;AAGA,KAAM5J,YAAY,aAAlB;AACA;;;AAGA,KAAM6J,eAAe,QAArB;AACA;;;AAGA,KAAMlkB,gBAAgB,SAAtB;;AAEA;;;AAGA,KAAMmkB,mBAAmB,kBAAzB;;AAEA;;;;KAGMvkB,U;AACF,yBAAYwkB,WAAZ,EAAyB;AAAA;;AACrB,aAAMhU,MAAM1B,OAAO3G,QAAnB;;AAEA,cAAKuI,SAAL,GAAiB8T,uBAAuB3U,WAAvB,GAAqC2U,WAArC,GACbhU,IAAIV,cAAJ,CAAmB0U,WAAnB,CADJ;;AAGA,cAAK/I,OAAL,GAAe,KAAf;;AAEA,aAAI,CAAC,KAAK/K,SAAV,EAAqB;AACjB,mBAAM,IAAI/O,KAAJ,mCAA0C6iB,WAA1C,gBAAN;AACH;AACJ;;AAED;;;;;;;;;mCAKU7gB,C,EAAG;AACT,iBAAIgJ,SAAShJ,EAAEgJ,MAAf;AACA,iBAAMd,SAASc,OAAO7C,UAAtB;AACA,iBAAM0G,MAAM1B,OAAO3G,QAAnB;;AAEA;AACA,iBAAI,CAACwE,OAAOG,YAAP,CAAoB2N,SAApB,CAAL,EAAqC;AACjC,qBAAI5O,UAAUA,OAAOiB,YAAP,CAAoB2N,SAApB,CAAd,EAA8C;AAC1C9N,8BAASd,MAAT;AACH,kBAFD,MAEO;AACH;AACH;AACJ;;AAED,iBAAI,CAACc,OAAOG,YAAP,CAAoB2N,SAApB,CAAL,EAAqC;AACjC;AACH;;AAED,iBAAMgK,QAAQ9X,OAAO7I,YAAP,CAAoB2W,SAApB,CAAd;AACA,iBAAMiK,MAAMlU,IAAIV,cAAJ,CAAmB2U,KAAnB,CAAZ;;AAEA9gB,eAAEgB,cAAF;;AAEA,iBAAI,KAAK8W,OAAT,EAAkB;AACd;AACH;;AAED,kBAAKkJ,YAAL,CAAkBD,GAAlB,EAAuB/X,MAAvB;AACH;;AAED;;;;;;;0CAIiB;AACb,kBAAK+D,SAAL,CAAetD,gBAAf,CAAgC,mBAASyB,WAAT,EAAhC,EAAwD,KAAK+V,SAAL,CAAeZ,IAAf,CAAoB,IAApB,CAAxD;AACA,oBAAO,IAAP;AACH;;AAED;;;;;;;;sCAKaU,G,EAAK3S,U,EAAY;AAAA;;AAC1B,iBAAIpF,SAASoF,UAAb;AACA,iBAAI,CAACpF,MAAD,IAAW,CAAC+X,GAAhB,EAAqB;AACjB;AACH;AACD,iBAAI,CAAC/X,MAAL,EAAa;AACTA,0BAASxE,SAAS0c,aAAT,OAA2BpK,SAA3B,UAAyCiK,IAAIhc,EAA7C,QAAT;AACH;;AAED,iBAAI0B,eAAJ;AACA,iBAAM0a,cAAcnY,OAAOvD,SAA3B;AACA,iBAAMyC,SAASc,OAAO7C,UAAtB;AACA,iBAAM0G,MAAM1B,OAAO3G,QAAnB;;AAEAiC,sBAAS,IAAItI,OAAJ,CAAY,UAAC2L,OAAD,EAAUsX,OAAV,EAAsB;AACvC,qBAAIL,GAAJ,EAAS;AACLjX,6BAAQiX,GAAR;AACH,kBAFD,MAEO;AACH,yBAAM9G,SAAS,iBAAOI,UAAP,CAAkBrR,MAAlB,CAAf;AACA,yBAAMoS,QAAQnB,SAASA,OAAOoB,QAAP,EAAT,GAA6B,IAA3C;AACA,yBAAI,iBAAOjB,QAAP,CAAgBH,MAAhB,KAA2BmB,KAA/B,EAAsC;AAClC3U,kCAAS2U,MAAMxZ,IAAN,CAAW,UAACC,CAAD,EAAO;AACvB,iCAAIA,aAAaqK,WAAjB,EAA8B;AAC1B,qCAAMnH,KAAK,eAAKwW,IAAL,EAAX;AACA1Z,mCAAEkD,EAAF,GAAOA,EAAP;AACAiE,wCAAOxD,YAAP,CAAoBsR,SAApB,EAA+B/R,EAA/B;AACA+E,yCAAQjI,CAAR;AACH,8BALD,MAKO;AACH,uCAAM,IAAI7D,KAAJ,+HAAN;AAEH;AACJ,0BAVQ,CAAT;AAWH,sBAZD,MAYO;AACHojB,iCAAQ,kBAAR;AACH;AACJ;AACJ,cAtBQ,CAAT;;AAwBA,iBAAIlZ,MAAJ,EAAY;AACR,qBAAMmZ,kBAAkB,eAAKvP,YAAL,CAAkB9I,MAAlB,EAA0B,UAACsQ,IAAD,EAAU;AACxD,4BAAOA,QAAQA,KAAKnQ,YAAb,IAA6BmQ,KAAKnQ,YAAL,CAAkByX,gBAAlB,CAApC;AACH,kBAFuB,CAAxB;;AAIA,qBAAMU,kBAAkBpZ,OAAOzC,SAA/B;AACA;AACA,qBAAI4b,eAAJ,EAAqB;AACjB,yBAAI,CAACC,gBAAgBrW,QAAhB,CAAyB0V,YAAzB,CAAL,EAA6C;AACzCW,yCAAgBC,MAAhB,CAAuBZ,YAAvB;AACAW,yCAAgB5b,GAAhB,CAAoBjJ,aAApB;AACH,sBAHD,MAGO;AACH;AACH;AACJ;;AAED,qBAAI4kB,eAAJ,EAAqB;AACjB,0BAAK,IAAItZ,IAAI,CAAb,EAAgBA,IAAIsZ,gBAAgBG,QAAhB,CAAyB5d,MAA7C,EAAqDmE,GAArD,EAA0D;AACtD,6BAAMiE,IAAIqV,gBAAgBG,QAAhB,CAAyBzZ,CAAzB,CAAV;AACA,6BAAM0Z,YAAYzV,EAAEwV,QAAF,CAAW,CAAX,CAAlB;AACA,6BAAIxV,MAAM9D,MAAV,EAAkB;AACd8D,+BAAEvG,SAAF,CAAYG,MAAZ,CAAmB+a,YAAnB;AACA,iCAAIc,SAAJ,EAAe;AACX,qCAAM9W,OAAO8W,UAAUthB,YAAV,CAAuB2W,SAAvB,CAAb;AACA,qCAAMvR,KAAKoF,OAAOkC,IAAIV,cAAJ,CAAmBxB,IAAnB,CAAP,GAAkC,IAA7C;AACA,qCAAIpF,EAAJ,EAAQ;AACJ,qDAAMyF,eAAN,CAAsBzF,EAAtB,EAA0Bkb,gBAA1B;AACAlb,wCAAGE,SAAH,CAAaG,MAAb,CAAoB+a,YAApB;AACAc,+CAAUhc,SAAV,CAAoBG,MAApB,CAA2B+a,YAA3B;AACH;AACJ;AACJ;AACJ;AACJ;AACJ;AACD,iBAAIQ,WAAJ,EAAiB;AACbA,6BAAYI,MAAZ,CAAmBZ,YAAnB;AACAQ,6BAAYzb,GAAZ,CAAgBjJ,aAAhB;AACH;AACD,kBAAKqb,OAAL,GAAe,IAAf;AACArR,oBAAO7E,IAAP,CAAY,UAACC,CAAD,EAAO;AACf,iCAAMmJ,eAAN,CAAsBnJ,CAAtB,EAAyB6e,gBAAzB;AACArkB,4BAAWqlB,aAAX,CAAyB1Y,MAAzB;AACAnH,mBAAE4D,SAAF,CAAY8b,MAAZ,CAAmBZ,YAAnB;AACA,uBAAK7I,OAAL,GAAe,KAAf;AACH,cALD,EAKG6J,KALH,CAKS,YAAM;AACX,uBAAK7J,OAAL,GAAe,KAAf;AACAzb,4BAAWqlB,aAAX,CAAyB1Y,MAAzB;AACH,cARD;AASH;;AAED;;;;;;;uCAIqBzD,E,EAAI;AACrB,iBAAM+b,kBAAkB/b,GAAGY,UAAH,CAAcV,SAAtC;AACAF,gBAAGE,SAAH,CAAaG,MAAb,CAAoBnJ,aAApB;AACA,iBAAI6kB,eAAJ,EAAqB;AACjBA,iCAAgB1b,MAAhB,CAAuBnJ,aAAvB;AACH;AACJ;;;;;;mBAGUJ,U;;;;;;;;;;;;;;sjBCzOf;;;;;;;;;;;;;;;;;;;;;;;;AAwBA;;;;;;AAMA;;;;AACA;;;;AACA;;;;AACA;;;;;;;;AAEA;;;AAGA,KAAMulB,qBAAqB,sBAA3B;;AAEA;;;AAGA,KAAMC,cAAc,gBAApB;AACA;;;AAGA,KAAMC,aAAa,MAAnB;AACA;;;AAGA,KAAMC,aAAa,MAAnB;AACA;;;AAGA,KAAMC,cAAc,CAApB;;AAEA;;;AAGO,KAAMC,sCAAe,0BAArB;;AAEP;;;;KAGM3lB,S;;AAEF;;;;;;;;AAQA,wBAAY4lB,YAAZ,EAA0BC,QAA1B,EAAoCC,MAApC,EAA4CC,YAA5C,EAA0D;AAAA;;AAAA;;AACtD,aAAMxV,MAAM1B,OAAO3G,QAAnB;AACA,aAAI8d,WAAW,CAAf;AACA,aAAMC,sBAAsBL,wBAAwBhW,WAAxB,GACxBgW,YADwB,GACTrV,IAAIV,cAAJ,CAAmB+V,YAAnB,CADnB;AAEA,aAAMM,WAAWL,oBAAoBjW,WAApB,GAAkCiW,QAAlC,GAA6CtV,IAAIV,cAAJ,CAAmBgW,QAAnB,CAA9D;AACA,aAAMM,wBAAwB,YAAUD,SAASzd,EAAnB,IAA2B,UAAzD;AACA,aAAM2d,gCAAmCD,qBAAnC,UAAN;;AAEA,aAAME,iBAAiB,SAAjBA,cAAiB,GAAM;AACzB,oBAAOtiB,OAAOiV,UAAP,IAAqB,mBAASC,GAAT,GAAetB,4BAA3C;AACH,UAFD;;AAIA,aAAI,CAACuO,QAAD,IAAa,CAACD,mBAAlB,EAAuC;AACnC,mBAAM,IAAIvkB,KAAJ,CAAU,+DAAV,CAAN;AACH;;AAED,cAAKwkB,QAAL,GAAgBA,QAAhB;AACA,cAAKI,mBAAL,GAA2BH,qBAA3B;AACA,cAAKI,0BAAL,GAAkCH,6BAAlC;AACA,cAAKI,iBAAL,GAAyB,mBAASvN,GAAT,GAAenB,kBAAxC;;AAEA,cAAKmO,mBAAL,GAA2BA,mBAA3B;AACA,cAAKQ,qBAAL,GAA6BR,oBAAoBxd,EAAjD;;AAEA;AACA,aAAI,CAAC,KAAKge,qBAAV,EAAiC;AAC7B,kBAAKA,qBAAL,GAA6B,eAAKxH,IAAL,EAA7B;AACAgH,iCAAoBxd,EAApB,GAAyB,KAAKge,qBAA9B;AACH;;AAED,aAAI,CAACV,YAAL,EAAmB;AACfE,iCAAoB9Y,gBAApB,CAAqC,YAArC,EAAmD,UAACzJ,CAAD,EAAO;AACtD,qBAAI2iB,gBAAJ,EAAsB;AAClB;AACH;AACDL,4BAAWtiB,EAAEsf,OAAF,CAAU,CAAV,EAAa0D,OAAxB;AACAT,qCAAoBU,QAApB,GAA+B,KAA/B;AACH,cAND;AAOAV,iCAAoB9Y,gBAApB,CAAqC,WAArC,EAAkD,UAACzJ,CAAD,EAAO;AACrD,qBAAI2iB,gBAAJ,EAAsB;AAClB;AACH;AAHoD,qBAI7CK,OAJ6C,GAIjChjB,EAAEsf,OAAF,CAAU,CAAV,CAJiC,CAI7C0D,OAJ6C;;AAKrD,qBAAMha,SAASuZ,mBAAf;AACA,qBAAM7U,QAAQ1E,OAAO0E,KAArB;AACA,qBAAMwV,QAAQZ,WAAWU,OAAzB;AACA,qBAAMG,SAASna,OAAOoJ,qBAAP,EAAf;AACA,qBAAMgR,UAAUhB,SAAS,CAAT,GAAac,SAAS,CAAtB,GAA0BA,SAAS,CAAnD;AACA,qBAAIE,OAAJ,EAAa;AACT1V,2BAAMuB,UAAN,GAAmB,mBAAnB;AACAvB,2BAAM2V,gBAAN,GAAyB,2BAAzB;AACAra,4BAAOia,QAAP,GAAkBb,SAAS,CAAT,GAAac,QAAQ,CAAC,CAAT,GAC/BC,OAAOpT,KAAP,GAAeiS,WADG,GACWkB,QAAQC,OAAOpT,KAAP,GAAeiS,WADpD;AAEA,yBAAMsB,6BAA2BJ,QAAQ,CAAC,CAApC,YAAN;AACAxV,2BAAM4V,SAAN,GAAkBA,SAAlB;AACA5V,2BAAM6V,eAAN,GAAwBD,SAAxB;AACH;AACJ,cAnBD;AAoBAf,iCAAoB9Y,gBAApB,CAAqC,UAArC,EAAiD,YAAM;AACnD,qBAAIkZ,gBAAJ,EAAsB;AAClB;AACH;AACD,qBAAM3Z,SAASuZ,mBAAf;AACA,qBAAM7U,QAAQ1E,OAAO0E,KAArB;AACA,qBAAI1E,OAAOia,QAAX,EAAqB;AACjB,yBAAMlT,QAAQ/G,OAAOoJ,qBAAP,GAA+BrC,KAA/B,GAAuCqS,MAArD;AACA1U,2BAAMuB,UAAN,GAAmB,oBAAnB;AACAvB,2BAAM2V,gBAAN,GAAyB,4BAAzB;AACA,yBAAMC,6BAA2BvT,KAA3B,YAAN;AACArC,2BAAM4V,SAAN,GAAkBA,SAAlB;AACA5V,2BAAM6V,eAAN,GAAwBD,SAAxB;AACA,2BAAKE,OAAL,GAAe5hB,IAAf,CAAoB,YAAM;AACtB,+BAAK6hB,cAAL,CAAoB/V,KAApB;AACH,sBAFD;AAGA,2BAAKgW,cAAL;AACH,kBAXD,MAWO;AACH,2BAAKD,cAAL,CAAoB/V,KAApB;AACH;AACJ,cApBD;AAqBH;AACJ;;AAED;;;;;;;wCAGewD,C,EAAG;AACdA,eAAEoS,SAAF,GAAc,EAAd;AACApS,eAAEjC,UAAF,GAAe,EAAf;AACAiC,eAAEqS,eAAF,GAAoB,EAApB;AACArS,eAAEmS,gBAAF,GAAqB,EAArB;AACH;;AAED;;;;;;;iCAIQ3S,K,EAAO;AAAA;;AACX,oBAAO,IAAIvS,OAAJ,CAAY,UAAC2L,OAAD,EAAa;AAC5B,gCAAKJ,YAAL,CAAkB,mBAASia,kBAAT,EAAlB,EAAiD,OAAKpB,mBAAtD,EAA2E,SAASqB,SAAT,CAAmB5jB,CAAnB,EAAsB;AAAA;;AAC7F,yBAAIA,EAAEgJ,MAAF,KAAa,KAAKuZ,mBAAtB,EAA2C;AACvC,gCAAO,eAAK7Y,YAAL,CAAkB,mBAASia,kBAAT,EAAlB,EACH,KAAKpB,mBADF,EACuBqB,UAAUvD,IAAV,CAAe,IAAf,CADvB,CAAP;AAEH;AACDlF,2CAAsB,YAAM;AACxB7e,mCAAUub,WAAV,GAAwB,IAAxB;AACA,6BAAMgM,SAAS1Y,OAAO3G,QAAP,CAAgBob,eAAhB,CAAgCna,SAA/C;AACAoe,gCAAOje,MAAP,CAAc,OAAKgd,mBAAnB;AACAiB,gCAAOje,MAAP,CAAc,OAAKkd,iBAAnB;AACA,6BAAI,CAAC,CAACpS,KAAN,EAAa;AACT,6CAAM1F,eAAN,CAAsB,OAAKuX,mBAA3B,EAAgDN,YAAhD;AACH;AACDnY;AACH,sBATD;AAUH,kBAf0E,CAezEuW,IAfyE,QAA3E;AAgBH,cAjBM,CAAP;AAkBH;;AAED;;;;;;0CAGiB;AACb,kBAAKkC,mBAAL,CAAyB9c,SAAzB,CAAmCG,MAAnC,CAA0Cmc,UAA1C;AACA5W,oBAAO3G,QAAP,CAAgBob,eAAhB,CAAgCna,SAAhC,CAA0CG,MAA1C,CAAiD,KAAKid,0BAAtD;AACA,kBAAKL,QAAL,CAAc/c,SAAd,CAAwBG,MAAxB,CAA+Bkc,UAA/B;AACA,mCAAYlJ,WAAZ,GAA0BC,KAA1B;AACH;;AAED;;;;;;;;gCAKO7Y,C,EAAG;AAAA;;AACN,iBAAIA,CAAJ,EAAO;AACHA,mBAAEgB,cAAF;AACH;AACD,kBAAKyiB,cAAL,CAAoB,KAAKlB,mBAAL,CAAyB7U,KAA7C;AACA,iBAAMoW,gBAAgB,KAAKtB,QAAL,CAAc/c,SAApC;AACA,iBAAMgd,wBAAwB,KAAKG,mBAAnC;AACA,iBAAMF,gCAAgC,KAAKG,0BAA3C;AACA,iBAAMkB,gCAAgC,KAAKxB,mBAAL,CAAyB9c,SAA/D;AACA,iBAAI,CAACnJ,UAAUub,WAAf,EAA4B;AACxB,gCAAKnO,YAAL,CAAkB,mBAASia,kBAAT,EAAlB,EAAiD,KAAKpB,mBAAtD,EAA2E,YAAM;AAC7E,yBAAI,CAAC,CAACviB,CAAN,EAAS;AACL,yCAAMgL,eAAN,CAAsB,OAAKuX,mBAA3B,EAAgDN,YAAhD;AACH;AACJ,kBAJD;AAKA3lB,2BAAUub,WAAV,GAAwB,IAAxB;AACA,uCAAYe,WAAZ,GAA0Ba,IAA1B,CAA+B,IAA/B,EAAqC,KAAK8I,mBAA1C;AACA,qBAAMyB,gBAAgB7Y,OAAO3G,QAAP,CAAgBob,eAAhB,CAAgCna,SAAtD;AACAue,+BAActe,GAAd,CAAkB,KAAKod,iBAAvB;AACAkB,+BAActe,GAAd,CAAkBgd,6BAAlB;AACAsB,+BAActe,GAAd,CAAkB+c,qBAAlB;AACAqB,+BAAcpe,GAAd,CAAkBoc,UAAlB;AACAiC,+CAA8Bre,GAA9B,CAAkCqc,UAAlC;AACH,cAdD,MAcO;AACH,wBAAO,KAAKlJ,KAAL,CAAW7Y,CAAX,CAAP;AACH;AACJ;;;+BAEK0Q,K,EAAO;AACT,iBAAI,KAAK6R,mBAAL,CAAyB9c,SAAzB,CAAmCwF,QAAnC,CAA4C8W,UAA5C,CAAJ,EAA6D;AACzD,qBAAMkC,UAAU,KAAKT,OAAL,CAAa9S,KAAb,CAAhB;AACA,sBAAKgT,cAAL;AACA,wBAAOO,OAAP;AACH;AACD,oBAAO,IAAI9lB,OAAJ,CAAY;AAAA,wBAAK0D,GAAL;AAAA,cAAZ,CAAP;AACH;;AAED;;;;;;;wCAIega,Q,EAAU;AAAA;;AACrB,iBAAMqI,eAAerI,YAAY1Q,OAAO3G,QAAxC;AACA,mCAAYoU,WAAZ,GAA0BmD,mBAA1B,CAA8Czf,SAA9C,EAAyD,UAACyT,KAAD;AAAA,wBAAWA,QAAQ,mBAASwF,GAAT,GAAevB,eAAlC;AAAA,cAAzD;AACAkQ,0BAAaza,gBAAb,CAA8B,mBAASyB,WAAT,EAA9B,EAAsD,UAAClL,CAAD,EAAO;AACzD,qBAAI1D,UAAUub,WAAV,IAAyBvb,UAAUub,WAAV,WAA7B,EAA6D;AACzD;AACH;AACD,qBAAM9S,KAAK,OAAKge,qBAAhB;AACA,qBAAMoB,cAAcnkB,EAAEgJ,MAAF,CAAS7I,YAAT,CAAsB0hB,WAAtB,MAAuC9c,EAA3D;AACA,qBAAI,CAAC,eAAKiN,YAAL,CAAkBhS,EAAEgJ,MAApB,EAA4B,OAAKuZ,mBAAjC,CAAL,EAA4D;AACxD,yBAAI4B,eAAgB7nB,UAAUub,WAAV,eAAkC7X,EAAEgJ,MAAF,KAAa,OAAKwZ,QAAxE,EAAmF;AAC/E,gCAAKjB,MAAL,CAAYvhB,CAAZ;AACH;AACJ,kBAJD,MAIO;AACH,yBAAIA,EAAEgJ,MAAF,CAASG,YAAT,CAAsByY,kBAAtB,CAAJ,EAA+C;AAC3C,gCAAKL,MAAL,CAAYvhB,CAAZ;AACH;AACJ;AACJ,cAfD;AAgBH;;;;;;AAGL1D,WAAUub,WAAV,GAAwB,IAAxB;;mBAEevb,S;;;;;;;;;;;;;;sjBCjRf;;;;;;;;;;;;;;;;;;;;;;;;AAwBA;;;;;;AAMA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;;;AAEA;;;AAGA,KAAM8nB,UAAU,0BAAhB;AACA;;;AAGA,KAAMC,gBAAgB,yBAAtB;AACA;;;AAGA,KAAMC,2BAA2B,0BAAjC;AACA;;;AAGA,KAAMC,gBAAgB,MAAtB;AACA;;;AAGA,KAAMC,mBAAmB,aAAzB;AACA;;;AAGA,KAAMC,sBAAsB,qBAA5B;AACA;;;AAGA,KAAM3N,YAAY,eAAlB;AACA;;;AAGA,KAAM4N,gBAAgB,SAAtB;;AAEA,KAAMC,wBAAwB,mBAA9B;AACA;;;AAGA,KAAM3N,WAAW,MAAjB;;AAEA;;;AAGA,KAAM4N,eAAe,UAArB;;AAEA;;;AAGO,KAAMC,wDAAwB,yBAA9B;;AAEP;;;;KAGMtoB,Q;AACF,uBAAYuQ,iBAAZ,EAA+BqV,QAA/B,EAAyC;AAAA;;AACrC,aAAMtV,MAAM1B,OAAO3G,QAAnB;;AAEA;;;;AAIA,cAAKuI,SAAL,GAAiBD,6BAA6BZ,WAA7B,GACbY,iBADa,GACOD,IAAIV,cAAJ,CAAmBW,iBAAnB,CADxB;;AAGA,cAAK+K,WAAL,GAAmB,IAAnB;AACA,cAAKiN,aAAL,GAAqB,IAArB;AACA;;;AAGA,cAAKtC,QAAL,GAAgBL,oBAAoBjW,WAApB,GAAkCiW,QAAlC,GAA6C3d,SAAS2H,cAAT,CAAwBgW,QAAxB,CAA7D;;AAEA,cAAK4C,cAAL,GAAsB,KAAtB;;AAEA,aAAI,CAAC,KAAKvC,QAAN,IAAkB,CAAC,KAAKzV,SAA5B,EAAuC;AACnC,mBAAM,IAAI/O,KAAJ,CAAU,8DAAV,CAAN;AACH;AACJ;;AAED;;;;;;;;;;2CAMkBgC,C,EAAG;AACjB,iBAAM6X,cAAc,KAAKA,WAAzB;AACA,iBAAM7O,SAAS,eAAKmW,eAAL,CAAqBnf,EAAEgJ,MAAvB,EAA+B;AAAA,wBAAKgD,aAAaE,WAAb,IAA4BF,EAAE7C,YAAF,CAAe2N,SAAf,CAAjC;AAAA,cAA/B,CAAf;AACA,iBAAMkO,kBAAkBhc,WAAW,KAAK8b,aAAxC;;AAEA,iBAAIjN,eAAe,CAAC,eAAK7F,YAAL,CAAkBhS,EAAEgJ,MAApB,EAA4B6O,WAA5B,CAAhB,IAA4DmN,eAAhE,EAAiF;AAC7E,sBAAKnM,KAAL;AACA,qBAAImM,eAAJ,EAAqB;AACjBhlB,uBAAEgB,cAAF;AACH;AACD,wBAAOgkB,kBAAkB,KAAlB,GAA0B,KAAKC,iBAAL,CAAuBjlB,CAAvB,CAAjC;AACH;;AAED,iBAAIgJ,UAAU,CAAC6O,WAAf,EAA4B;AACxB,qBAAI,CAAC7O,OAAO7I,YAAP,CAAoBmkB,wBAApB,CAAL,EAAoD;AAChDtkB,uBAAEgB,cAAF;AACAhB,uBAAE2a,wBAAF;AACH;;AAED,qBAAI3R,OAAOkc,SAAX,EAAsB;AAClB,4BAAO,KAAP;AACH;AACD,sBAAKC,cAAL,CAAoBnc,MAApB;AACH,cAVD,MAUO;AACH,qBAAI6O,WAAJ,EAAiB;AACb,yBAAI7X,EAAEgJ,MAAF,CAASG,YAAT,CAAsBsb,mBAAtB,CAAJ,EAAgD;AAC5C,6BAAI,CAACzkB,EAAEgJ,MAAF,CAAS7I,YAAT,CAAsBmkB,wBAAtB,CAAL,EAAsD;AAClDtkB,+BAAEgB,cAAF;AACH;AACD,8BAAK6X,KAAL;AACH;AACD,yBAAI,CAAC,eAAK7G,YAAL,CAAkBhS,EAAEgJ,MAApB,EAA4B6O,WAA5B,CAAL,EAA+C;AAC3C,8BAAKgB,KAAL;AACH;AACJ;AACJ;AACJ;;AAED;;;;;;;0CAIiB;AACb,mCAAYD,WAAZ,GAA0BmD,mBAA1B,CAA8Cxf,QAA9C,EAAwD,UAACwT,KAAD;AAAA,wBAAWA,QAAQ,mBAASwF,GAAT,GAAevB,eAAlC;AAAA,cAAxD;AACA,kBAAKjH,SAAL,CAAetD,gBAAf,CAAgC,mBAASyB,WAAT,EAAhC,EAAwD,KAAK+Z,iBAAL,CAAuB5E,IAAvB,CAA4B,IAA5B,CAAxD,EAA2F,IAA3F;AACA,oBAAO,IAAP;AACH;;AAED;;;;;;;mCAIU;AACN,kBAAKtT,SAAL,CAAevB,mBAAf,CAAmC,mBAASN,WAAT,EAAnC,EAA2D,KAAK+Z,iBAAL,CAAuB5E,IAAvB,CAA4B,IAA5B,CAA3D,EAA8F,IAA9F;AACA,oBAAO,IAAP;AACH;;AAGD;;;;;;;;2CAKkBpE,C,EAAG;AACjB,kBAAK8I,cAAL,GAAsB9I,CAAtB;AACA,oBAAO,IAAP;AACH;;AAGD;;;;;;;;+CAKsB+D,Q,EAAU/E,I,EAAM;AAClC,iBAAMmK,mBAAiBpF,SAASjb,EAAT,IAAe4f,qBAAhC,CAAN;AACA,iBAAMlf,YAAY,KAAKsH,SAAL,CAAetH,SAAjC;AACA,iBAAIwV,IAAJ,EAAU;AACNxV,2BAAUC,GAAV,CAAc0f,GAAd;AACH,cAFD,MAEO;AACH3f,2BAAUG,MAAV,CAAiBwf,GAAjB;AACH;AACJ;;AAED;;;;;;;iCAIQ;AAAA;;AACJ,iBAAMvN,cAAc,KAAKA,WAAzB;AACA,iBAAI,CAACA,WAAL,EAAkB;AACd,wBAAO,KAAP;AACH;AACD,iBAAMwN,mBAAmBxN,YAAYyN,oBAAZ,IAAoC,KAAK9C,QAAlE;AACA,iBAAM+C,kBAAkB1N,WAAxB;;AAEA,iBAAMpR,SAAS,IAAItI,OAAJ,CAAY,UAAC2L,OAAD,EAAa;AACpC,qBAAIzJ,OAAO0R,gBAAP,CAAwB8F,WAAxB,EAAqC3H,QAArC,KAAkD,OAAtD,EAA+D;AAC3D,oCAAKxG,YAAL,CAAkB,mBAASia,kBAAT,EAAlB,EAAiD9L,WAAjD,EAA8D,SAAS+L,SAAT,CAAmB5jB,CAAnB,EAAsB;AAAA;;AAChF,6BAAIA,EAAEgJ,MAAF,KAAa6O,WAAjB,EAA8B;AAC1B,oCAAO,eAAKnO,YAAL,CAAkB,mBAASia,kBAAT,EAAlB,EAAiD9L,WAAjD,EAA8D+L,UAAUvD,IAAV,CAAe,IAAf,CAA9D,CAAP;AACH;AACDlF,+CAAsB,YAAM;AACxB,6CAAMnQ,eAAN,CAAsBua,eAAtB,EAAuCV,qBAAvC;AACA;AACA,iCAAI,MAAKhN,WAAL,KAAqB,IAAzB,EAA+B;AAC3B,wCAAO,KAAP;AACH;AACD,mCAAK2N,qBAAL,CAA2BH,gBAA3B,EAA6C,KAA7C;AACAvb,qCAAQ,IAAR;AACH,0BARD;AASH,sBAb6D,CAa5DuW,IAb4D,QAA9D;AAcH,kBAfD,MAeO;AACHvW,6BAAQ,IAAR;AACA,qCAAMkB,eAAN,CAAsBua,eAAtB,EAAuCV,qBAAvC;AACH;AACJ,cApBc,CAAf;;AAsBA,mCAAYjM,WAAZ,GAA0BC,KAA1B;AACAhB,yBAAYpS,SAAZ,CAAsBG,MAAtB,CAA6BoR,QAA7B;;AAEA,iBAAIa,YAAYyN,oBAAhB,EAAsC;AAClCzN,6BAAYyN,oBAAZ,CAAiC7f,SAAjC,CAA2CG,MAA3C,CAAkD2e,aAAlD;AACH,cAFD,MAEO;AACH,sBAAK/B,QAAL,CAAc/c,SAAd,CAAwBG,MAAxB,CAA+B2e,aAA/B;AACH;;AAED,kBAAK1M,WAAL,GAAmB,IAAnB;AACA,kBAAKiN,aAAL,GAAqB,IAArB;;AAEA,iBAAI,KAAKC,cAAT,EAAyB;AACrB,sBAAKjlB,OAAL;AACH;;AAED,oBAAO2G,MAAP;AACH;;AAED;;;;;;;;;wCAMeuC,M,EAAQ0U,U,EAAY;AAAA;;AAC/B,iBAAM7Q,MAAM1B,OAAO3G,QAAnB;;AAEA,iBAAI,CAACwE,MAAL,EAAa;AACT,uBAAM,IAAIhL,KAAJ,CAAU,2BAAV,CAAN;AACH;;AAED,iBAAMic,SAASyD,cAAc,iBAAOrD,UAAP,CAAkBrR,MAAlB,CAA7B;AACA,iBAAIvC,eAAJ;AACA,iBAAMgf,OAAOzc,OAAO7I,YAAP,CAAoB2W,SAApB,CAAb;AACA,iBAAM4O,2BAA2B7Y,IAAIV,cAAJ,CAAmBsZ,IAAnB,CAAjC;AACA,iBAAMrK,QAAQ,CAACsK,wBAAD,IAA6B,iBAAOtL,QAAP,CAAgBH,MAAhB,CAA7B,GAAuDA,OAAOoB,QAAP,EAAvD,GAA2E,KAAzF;;AAEA,iBAAID,KAAJ,EAAW;AACPpS,wBAAOvD,SAAP,CAAiBC,GAAjB,CAAqBgf,aAArB;AACA1b,wBAAOkc,SAAP,GAAmB,IAAnB;AACAze,0BAAS2U,MAAMxZ,IAAN,CAAW,UAACC,CAAD,EAAO;AACvB,yBAAIA,aAAaqK,WAAjB,EAA8B;AAC1B,6BAAIrK,EAAEkD,EAAN,EAAU;AACNiE,oCAAOxD,YAAP,CAAoBsR,SAApB,EAA+BjV,EAAEkD,EAAjC;AACH;AACD,gCAAOlD,CAAP;AACH;AACD;AACA,yBAAM4M,UAAU5B,IAAIU,aAAJ,CAAkB,KAAlB,CAAhB;AACAkB,6BAAQN,SAAR,GAAoByW,YAApB;AACAnW,6BAAQZ,SAAR,GAAoBhM,CAApB;AACA4M,6BAAQ1J,EAAR,GAAa,eAAKwW,IAAL,EAAb;AACA;AACAvS,4BAAOxD,YAAP,CAAoBsR,SAApB,EAA+BrI,QAAQ1J,EAAvC;AACA,4BAAKgI,SAAL,CAAeS,WAAf,CAA2BiB,OAA3B;AACA,4BAAOA,OAAP;AACH,kBAhBQ,EAgBN7M,IAhBM,CAgBD,UAACC,CAAD,EAAO;AACXmH,4BAAOkc,SAAP,GAAmB,KAAnB;AACAlc,4BAAOvD,SAAP,CAAiBG,MAAjB,CAAwB8e,aAAxB;AACA,4BAAO7iB,CAAP;AACH,kBApBQ,CAAT;AAqBH,cAxBD,MAwBO;AACH,qBAAI,CAAC6jB,wBAAL,EAA+B;AAC3B,2BAAM,IAAI1nB,KAAJ,kDAAyDynB,IAAzD,OAAN;AACH;AACDhf,0BAAS,IAAItI,OAAJ,CAAY,UAAC0D,CAAD,EAAO;AACxBA,uBAAE6jB,wBAAF;AACH,kBAFQ,CAAT;AAGH;;AAEDjf,oBAAO7E,IAAP,CAAY,UAAC+jB,eAAD,EAAqB;AAC7B,qBAAI,OAAK9N,WAAT,EAAsB;AAClB,4BAAKgB,KAAL;AACH;AACD;AACA7P,wBAAO2c,eAAP,GAAyBA,eAAzB;AACA,qBAAMC,aAAaza,OAAO4G,gBAAP,CAAwB4T,eAAxB,EAAyCzV,QAAzC,KAAsD,UAAzE;AACAyV,iCAAgBlmB,gBAAhB;;AAEA,qBAAI,CAACuJ,OAAO6c,sBAAZ,EAAoC;AAChC,yBAAMC,aAAa9c,OAAO7I,YAAP,CAAoBikB,OAApB,CAAnB;AACApb,4BAAO6c,sBAAP,GAAgCC,aAChCjZ,IAAIV,cAAJ,CAAmB2Z,UAAnB,KAAkCthB,SAASob,eADX,GAC6Bpb,SAASob,eADtE;AAEH;;AAED+F,iCAAgBlgB,SAAhB,CAA0B8b,MAA1B,CAAiCvK,QAAjC;AACA,qBAAI2O,gBAAgBlgB,SAAhB,CAA0BwF,QAA1B,CAAmC+L,QAAnC,CAAJ,EAAkD;AAC9C,4BAAKa,WAAL,GAAmB8N,eAAnB;AACA,4BAAKb,aAAL,GAAqB9b,MAArB;AACH;AACD,uCAAY4P,WAAZ,GAA0Ba,IAA1B,SAAqCkM,eAArC;AACA,qBAAIC,UAAJ,EAAgB;AACZ;AACA,yBAAIxX,aAAapF,OAAO7I,YAAP,CAAoBqkB,gBAApB,CAAjB;AACApW,kCAAaA,aAAavB,IAAIV,cAAJ,CAAmBiC,UAAnB,CAAb,GAA8CpF,MAA3D;AACA,oCAAKgF,mBAAL,CAAyBI,UAAzB,EAAqCuX,eAArC,EAAsD3c,OAAO6c,sBAA7D;AACH,kBALD,MAKO;AACH;AACA,yBAAMpH,IAAIzV,OAAO7I,YAAP,CAAoBkkB,aAApB,CAAV;AACA,yBAAI5F,CAAJ,EAAO;AACHkH,yCAAgBL,oBAAhB,GAAuCzY,IAAIV,cAAJ,CAAmBsS,CAAnB,CAAvC;AACA,0BAACkH,gBAAgBL,oBAAhB,IAAwC,OAAK9C,QAA9C,EAAwD/c,SAAxD,CAAkE8b,MAAlE,CAAyEgD,aAAzE;AACH,sBAHD,MAGO;AACH,gCAAK/B,QAAL,CAAc/c,SAAd,CAAwB8b,MAAxB,CAA+BgD,aAA/B;AACH;AACD,4BAAKiB,qBAAL,CAA2BG,gBAAgBL,oBAAhB,IAAwC,OAAK9C,QAAxE,EAAkF,IAAlF;;AAEAmD,qCAAgBjY,KAAhB,CAAsBC,IAAtB,GAA6B,GAA7B;AACAgY,qCAAgBjY,KAAhB,CAAsBE,GAAtB,GAA4B,MAA5B;AACH;AACJ,cAxCD;AAyCH;;;;;;mBAIUrR,Q;;;;;;;;;;;;;sjBCjWf;;;;;;;;;;;;;;;;;;;;;;;;AAwBA;;;;;;AAMA;;AAEA;;;;AACA;;;;AACA;;;;;;;;AAEA,KAAMwpB,iBAAiB,qBAAvB;AACA,KAAMC,kBAAkB,sBAAxB;AACA,KAAMC,WAAW,UAAjB;;AAEA,KAAMC,eAAe,UAArB;AACA,KAAMC,eAAe,UAArB;AACA,KAAMC,cAAc,SAApB;;AAEA,KAAMC,oBAAoB,mBAA1B;AACA,KAAMC,iBAAiB,WAAvB;AACA,KAAMC,YAAY,MAAlB;;AAEA,KAAMC,WAAW,EAAjB;AACA,KAAMC,WAAW,EAAjB;AACA,KAAM5P,aAAa,kBAAnB;AACA;;;;KAGMra,Q;;AAEF;;;;;;;AAOA,uBAAYsQ,iBAAZ,EAA+B4Z,iBAA/B,EAAkDC,WAAlD,EAA+D7oB,OAA/D,EAAwE;AAAA;;AACpE,aAAM8oB,wBAAwB9Z,6BAA6BZ,WAA7B,GAA2CY,iBAA3C,GAC1BtI,SAAS2H,cAAT,CAAwBW,iBAAxB,CADJ;;AAGA,cAAK+Z,YAAL,GAAoBF,eAAe7Z,iBAAnC;AACA;;;AAGA,cAAKga,YAAL,GAAoB,IAApB;AACA;;;AAGA,cAAKC,kBAAL,GAA0B,IAA1B;AACA;;;AAGA,cAAKC,OAAL,GAAe,IAAf;AACA;;;AAGA,cAAKC,WAAL,GAAmB,KAAKD,OAAxB;AACA;;;AAGA,cAAKE,eAAL,GAAuB,IAAvB;AACA;;;AAGA,cAAKC,kBAAL,GAA0B,IAA1B;AACA;;;AAGA,cAAKC,iBAAL,GAAyB,IAAzB;AACA;;;AAGA,cAAKC,mBAAL,GAA2B,IAA3B;AACA;;;AAGA,cAAKC,kBAAL,GAA0BV,qBAA1B;AACA;;;AAGA,cAAKW,kBAAL,GAA0Bb,iBAA1B;AACA;;;AAGA,cAAKc,OAAL,GAAe,IAAf;AACA;;;AAGA,cAAKC,OAAL,GAAe,KAAf;AACA;;;AAGA,cAAKze,MAAL,GAAc,IAAd;AACA;;;AAGA,cAAK0e,GAAL,GAAW,IAAX;AACA;;;AAGA,cAAKC,UAAL,GAAkB,KAAlB;;AAEA;;;AAGA,cAAK7pB,OAAL,GAAe;AACX;AACA8pB,qCAAwB,IAFb;AAGX;AACAC,0BAAa,IAJF;AAKX;AACAC,qBAAQ,kBAAM;AACV,wBAAO,IAAP;AACH,cARU;AASXC,sBAAS,mBAAM,CACd,CAVU;AAWXC,sBAAS,IAXE;AAYXC,sBAAS,IAZE;AAaX;AACAC,4BAAe,yBAAM,CACpB;AAfU,UAAf;;AAkBA5oB,gBAAOC,MAAP,CAAc,KAAKzB,OAAnB,EAA4BA,OAA5B;AACH;;AAED;;;;;;;;iDAIwBwb,I,EAAM;AAC1B,iBAAIA,QAAQA,KAAKkI,QAAL,CAAc,CAAd,EAAiBrY,YAAjB,CAA8B,KAAKoe,kBAAnC,CAAZ,EAAoE;AAChE,wBAAOjO,KAAKkI,QAAL,CAAc,CAAd,CAAP;AACH;AACD,oBAAO,IAAP;AACH;;AAED;;;;;;;;iCAKQxY,M,EAAQ;AACZ,iBAAI,KAAKlL,OAAL,CAAakqB,OAAjB,EAA0B;AACtB,wBAAO,KAAKlqB,OAAL,CAAakqB,OAAb,CAAqBjmB,KAArB,CAA2B,IAA3B,EAAiC,CAACiH,MAAD,CAAjC,CAAP;AACH;AACD,oBAAO,KAAKmf,uBAAL,CAA6Bnf,OAAO7C,UAAP,CAAkBiiB,kBAA/C,CAAP;AACH;;AAED;;;;;;;;iCAKQpf,M,EAAQ;AACZ,iBAAI,KAAKlL,OAAL,CAAamqB,OAAjB,EAA0B;AACtB,wBAAO,KAAKnqB,OAAL,CAAamqB,OAAb,CAAqBlmB,KAArB,CAA2B,IAA3B,EAAiC,CAACiH,MAAD,CAAjC,CAAP;AACH;AACD,oBAAO,KAAKmf,uBAAL,CAA6Bnf,OAAO7C,UAAP,CAAkBkiB,sBAA/C,CAAP;AACH;;AAED;;;;;;wCAGeC,M,EAAQ;AAAA;;AACnB,kBAAKhB,kBAAL,CAAwB7d,gBAAxB,CAAyC,mBAASyB,WAAT,EAAzC,EAAiE,UAAClL,CAAD,EAAO;AACpE,qBAAIgJ,SAAShJ,EAAEgJ,MAAf;AACA,qBAAMd,SAASc,OAAO7C,UAAtB;AACA,qBAAIge,cAAcnb,OAAOG,YAAP,CAAoB,MAAKoe,kBAAzB,CAAlB;AACA,qBAAMgB,gBAAgBrgB,UAAUA,OAAOiB,YAAP,CAAoB,MAAKoe,kBAAzB,CAAhC;;AAEA,qBAAI,CAACpD,WAAD,IAAgBoE,aAApB,EAAmC;AAC/BpE,mCAAc,IAAd;AACAnb,8BAASd,MAAT;AACH;AACD,qBAAIic,WAAJ,EAAiB;AACbnkB,uBAAEgB,cAAF;AACA,2BAAKyY,IAAL,CAAUzQ,MAAV,EAAkBpH,IAAlB,CAAuB,UAACC,CAAD,EAAO;AAC1B,6BAAIymB,MAAJ,EAAY;AACRA,oCAAOvmB,KAAP,QAAmB,CAACF,CAAD,EAAImH,MAAJ,CAAnB;AACH;AACJ,sBAJD;AAKH;AACJ,cAlBD;AAmBH;;AAED;;;;;;+CAGsB;AAClB,oBAAO,KAAKoe,iBAAZ;AACH;;AAED;;;;;;;;;;;;AAmBA;;;;gDAIuB9I,S,EAAW;AAC9B,iBAAMkK,OAAOlK,YAAY,KAAK2J,OAAL,CAAa,KAAKjf,MAAlB,CAAZ,GAAwC,KAAKgf,OAAL,CAAa,KAAKhf,MAAlB,CAArD;AACA,iBAAI,KAAKlL,OAAL,CAAagqB,MAAb,CAAoB/lB,KAApB,CAA0B,IAA1B,EAAgC,CAACymB,IAAD,CAAhC,CAAJ,EAA6C;AACzC,wBAAO,KAAKC,WAAL,CAAiBD,IAAjB,CAAP;AACH;AACD,oBAAO,IAAIrqB,OAAJ,CAAY,UAACuqB,CAAD,EAAIC,MAAJ;AAAA,wBAAeA,OAAOH,IAAP,CAAf;AAAA,cAAZ,CAAP;AACH;;AAED;;;;;;;qCAIY;AACR,oBAAO,KAAKb,UAAZ;AACH;;AAED;;;;;;;6CAIoB;AAChB,iBAAI,KAAK7pB,OAAL,CAAa+pB,WAAjB,EAA8B;AAC1B,sBAAKnM,KAAL,CAAW7C,KAAX;AACH;AACJ;;;gDAEsB;AACnB,iBAAM7P,SAAS,KAAKA,MAApB;AACA,iBAAM4f,UAAU,KAAKX,OAAL,CAAajf,MAAb,CAAhB;AACA,iBAAM6f,UAAU,KAAKb,OAAL,CAAahf,MAAb,CAAhB;AACA,iBAAM8f,eAAe5C,YAArB;AACA,iBAAM6C,eAAe5C,YAArB;AACA;AACA,iBAAIyC,OAAJ,EAAa;AACT,sBAAK1B,eAAL,CAAqBzhB,SAArB,CAA+BC,GAA/B,CAAmCojB,YAAnC;AACH,cAFD,MAEO;AACH,sBAAK5B,eAAL,CAAqBzhB,SAArB,CAA+BG,MAA/B,CAAsCkjB,YAAtC;AACH;AACD,iBAAID,OAAJ,EAAa;AACT,sBAAK3B,eAAL,CAAqBzhB,SAArB,CAA+BC,GAA/B,CAAmCqjB,YAAnC;AACH,cAFD,MAEO;AACH,sBAAK7B,eAAL,CAAqBzhB,SAArB,CAA+BG,MAA/B,CAAsCmjB,YAAtC;AACH;AACJ;;AAED;;;;;;;6CAIoBrB,G,EAAK;AAAA;;AACrB,iBAAI,mBAASsB,IAAT,EAAJ,EAAqB;AACjBjf,4BAAW,YAAM;AACb,4BAAKmd,eAAL,CAAqBxZ,KAArB,CAA2BsC,MAA3B,GAAoC0X,IAAI/W,YAAJ,GAAmB,IAAvD;AACH,kBAFD,EAEG,CAFH;AAGH;AACJ;;AAED;;;;;;;;qCAKY6X,I,EAAM;AAAA;;AACd,iBAAMvoB,OAAO,IAAb;AACA,iBAAMynB,MAAM,KAAKA,GAAjB;AACA,kBAAKC,UAAL,GAAkB,IAAlB;AACA1nB,kBAAKgnB,WAAL,GAAmB,IAAI9oB,OAAJ,CAAY,UAAC2L,OAAD,EAAU6e,MAAV,EAAqB;AAChD;AACA1oB,sBAAKnC,OAAL,CAAaoqB,aAAb,CAA2BnmB,KAA3B,CAAiC9B,IAAjC,EAAuC,CAACA,KAAKgnB,WAAN,CAAvC;AACA,qBAAIuB,IAAJ,EAAU;AACN,yBAAMS,YAAYT,KAAKrf,YAAL,CAAkBkd,iBAAlB,IAAuCmC,IAAvC,GAA+CA,KAAKhH,QAAL,CAAc,CAAd,KAAoBgH,IAArF;AACA,yBAAMU,cAAcV,KAAKroB,YAAL,CAAkBmmB,cAAlB,KACZkC,KAAKroB,YAAL,CAAkBomB,SAAlB,CADR;AAEA,yBAAM4C,aAAaF,UAAU9oB,YAAV,CAAuB8lB,QAAvB,KAAoCgD,UAAUG,GAA9C,IAAqDF,WAAxE;AACA,yBAAMG,gBAAgB,IAAIC,KAAJ,EAAtB;;AAEA,yBAAI,CAACH,UAAL,EAAiB;AACbR,gCAAOH,IAAP;AACA;AACH;AACD;AACA,4BAAKxf,MAAL,GAAcwf,IAAd;AACAa,mCAAcD,GAAd,GAAoBD,UAApB;AACAlpB,0BAAKinB,eAAL,CAAqBzhB,SAArB,CAA+BC,GAA/B,CAAmC0gB,WAAnC;AACAiD,mCAAc5f,gBAAd,CAA+B,MAA/B,EAAuC,YAAM;AACzCie,6BAAI0B,GAAJ,GAAUD,UAAV;AACAlpB,8BAAKinB,eAAL,CAAqBxZ,KAArB,CAA2B6b,eAA3B,GAA6C,SAASJ,UAAT,GAAsB,GAAnE;AACA3sB,kCAASgtB,oBAAT,CAA8BhB,IAA9B,EAAoCd,GAApC,EAAyC2B,aAAzC;AACAppB,8BAAKwpB,mBAAL,CAAyB/B,GAAzB;AACAznB,8BAAKypB,OAAL,CAAaT,SAAb,EAAwBC,WAAxB;AACAjpB,8BAAK0pB,oBAAL;AACA1pB,8BAAKinB,eAAL,CAAqBzhB,SAArB,CAA+BG,MAA/B,CAAsCwgB,WAAtC;AACA,gCAAKuB,UAAL,GAAkB,KAAlB;AACA7d,iCAAQqf,UAAR,EAAoB,OAAKngB,MAAzB;AACH,sBAVD;AAWH,kBA1BD,MA0BO;AACH2f;AACH;AACJ,cAhCkB,CAAnB;AAiCA,oBAAO1oB,KAAKgnB,WAAZ;AACH;;AAGD;;;;;;;;iCAKQ2C,a,EAAeC,qB,EAAuB;AAAA;;AAC1C,iBAAIA,yBAAyBD,cAAcR,GAAd,KAAsBS,qBAAnD,EAA0E;AACtE,qBAAMC,eAAe,IAAIR,KAAJ,EAArB;AACAQ,8BAAaV,GAAb,GAAmBS,qBAAnB;AACAC,8BAAargB,gBAAb,CAA8B,MAA9B,EAAsC,YAAM;AACxC;AACA,yBAAI,OAAKsgB,OAAL,CAAaH,aAAb,MAAgC,OAAKlC,GAAL,CAAS0B,GAA7C,EAAkD;AAC9C,gCAAK1B,GAAL,CAAS0B,GAAT,GAAeS,qBAAf;AACA,gCAAK3C,eAAL,CAAqBxZ,KAArB,CAA2B6b,eAA3B,GAA6C,SAASM,qBAAT,GAAiC,GAA9E;AACH;AACJ,kBAND;AAOH;AACJ;;AAED;;;;;;;;;iCAMQ7gB,M,EAAQ;AACZ,oBAAOA,OAAO7I,YAAP,CAAoB8lB,QAApB,KAAiCjd,OAAOogB,GAA/C;AACH;;AAED;;;;;;;;8BAKKpgB,M,EAAQ;AAAA;;AACT,iBAAM/I,OAAO,IAAb;;AAEA,iBAAI,CAAC+I,MAAL,EAAa;AACT,wBAAO,KAAP;AACH;;AAED,kBAAKA,MAAL,GAAcA,MAAd;;AAEA;AACA,iBAAI,KAAKye,OAAL,IAAgBze,MAApB,EAA4B;AACxB,wBAAO,KAAKyf,WAAL,CAAiBzf,MAAjB,EAAyBpH,IAAzB,CAA8B,YAAM;AACvC;AACH,kBAFM,CAAP;AAGH;;AAED,kBAAK6lB,OAAL,GAAe,IAAf;;AAEA;;;;AAIA,kBAAKD,OAAL,GAAe,uBAAa3K,QAAb,CAAsB,YAAM;AACvC;AACA,qBAAMmN,YAAYhhB,OAAOG,YAAP,CAAoBkd,iBAApB,IAAyCrd,MAAzC,GAAmDA,OAAOwY,QAAP,CAAgB,CAAhB,KAAsBxY,MAA3F;;AAEA,qBAAMihB,oBAAoBjhB,OAAO7I,YAAP,CAAoBmmB,cAApB,KAAuCtd,OAAO7I,YAAP,CAAoBomB,SAApB,CAAjE;AACA,qBAAM2D,SAAS,OAAKH,OAAL,CAAaC,SAAb,KAA2BC,iBAA1C;;AAEA,qBAAME,WAAW,IAAIb,KAAJ,EAAjB;AACAa,0BAASf,GAAT,GAAec,MAAf;AACA,wBAAKhD,eAAL,GAAuB1iB,SAAS+I,aAAT,CAAuB,KAAvB,CAAvB;AACA,wBAAK4Z,kBAAL,GAA0B3iB,SAAS+I,aAAT,CAAuB,KAAvB,CAA1B;AACA,wBAAK8Z,mBAAL,GAA2B7iB,SAAS+I,aAAT,CAAuB,GAAvB,CAA3B;AACA,wBAAK6Z,iBAAL,GAAyB5iB,SAAS+I,aAAT,CAAuB,KAAvB,CAAzB;;AAEA,wBAAK8Z,mBAAL,CAAyBlZ,SAAzB,GAAqC,gDAArC;AACA,wBAAKkZ,mBAAL,CAAyB7hB,YAAzB,CAAsCqR,UAAtC,EAAkDA,UAAlD;;AAEA,wBAAKsQ,kBAAL,CAAwBhZ,SAAxB,GAAoC,mBAApC;AACA,wBAAKgZ,kBAAL,CAAwB3Z,WAAxB,CAAoC,OAAK0Z,eAAzC;AACA,wBAAKC,kBAAL,CAAwB3Z,WAAxB,CAAoC,OAAK4Z,iBAAzC;AACA,wBAAKD,kBAAL,CAAwB3Z,WAAxB,CAAoC,OAAK6Z,mBAAzC;AACA,wBAAKD,iBAAL,CAAuBjZ,SAAvB,GAAmC,mBAAnC;AACA,wBAAKwZ,UAAL,GAAkB,IAAlB;AACA,wBAAKX,OAAL,GAAe,IAAI7oB,OAAJ,CAAY,UAAC2L,OAAD,EAAa;AACpCqgB,8BAAS1gB,gBAAT,CAA0B,MAA1B,EAAkC,YAAM;AACpC,gCAAKyd,eAAL,CAAqB/Y,SAArB,GAAiC,iBAAjC;AACA,6BAAMuZ,MAAMljB,SAAS+I,aAAT,CAAuB,KAAvB,CAAZ;AACA;AACA,gCAAKma,GAAL,GAAWA,GAAX;;AAEAA,6BAAI0B,GAAJ,GAAUc,MAAV;AACA1tB,kCAASgtB,oBAAT,CAA8BxgB,MAA9B,EAAsC0e,GAAtC,EAA2CyC,QAA3C;AACA,gCAAKjD,eAAL,CAAqB1Z,WAArB,CAAiCka,GAAjC;AACA,gCAAKR,eAAL,CAAqBxZ,KAArB,CAA2B6b,eAA3B,GAA6C,SAASW,MAAT,GAAkB,GAA/D;;AAEApgB,iCAAQ7J,KAAKknB,kBAAb;AACA,gCAAKQ,UAAL,GAAkB,KAAlB;;AAEA,6BAAI,mBAASqB,IAAT,EAAJ,EAAqB;AACjB/oB,kCAAK6mB,YAAL,GAAoB3b,OAAO1B,gBAAP,CAAwB,QAAxB,EAAkC,YAAM;AACxDM,4CAAW,YAAM;AACb9J,0CAAKinB,eAAL,CAAqBxZ,KAArB,CAA2BsC,MAA3B,GAAoC0X,IAAI/W,YAAJ,GAAmB,IAAvD;AACH,kCAFD,EAEG,CAFH;AAGH,8BAJmB,CAApB;AAKH;;AAED,6BAAI1Q,KAAKnC,OAAL,CAAa8pB,sBAAjB,EAAyC;AACrC3nB,kCAAK0pB,oBAAL;AACA;AACA1pB,kCAAKinB,eAAL,CAAqBzd,gBAArB,CAAsC,mBAASyB,WAAT,EAAtC,EAA8D,UAAClL,CAAD,EAAO;AACjE,qCAAIC,KAAKilB,SAAL,EAAJ,EAAsB;AAClB;AACH;AACDllB,mCAAEgB,cAAF;;AAEA,qCAAMP,KAAKT,CAAX;AACA,qCAAMoqB,QAAQjf,OAAOkf,UAAP,IAAqB5pB,cAAc4pB,UAAnC,GACV5pB,GAAG6pB,cAAH,CAAkB,CAAlB,EAAqBF,KADX,GACmB3pB,GAAG2pB,KADpC;AAEA,qCAAMG,OAAOtqB,KAAKinB,eAAL,CAAqB9U,qBAArB,EAAb;AACA,qCAAMoY,OAAOD,KAAK5c,IAAlB;AACA,qCAAM8c,eAAeF,KAAKxa,KAA1B;AACA,qCAAM2a,OAAON,QAAQI,IAArB;;AAEAvqB,sCAAK0qB,sBAAL,CAA4BF,eAAe,CAAf,GAAmBC,IAA/C,EAAqD/I,KAArD,CAA2D,YAAM;AAC7D1hB,0CAAK2qB,iBAAL;AACH,kCAFD;AAGH,8BAjBD;;AAmBA;AACA3qB,kCAAK8mB,kBAAL,GAA0B,UAAC/mB,CAAD,EAAO;AAC7B,qCAAIA,EAAEyc,OAAF,KAAc+J,QAAd,IAA0BxmB,EAAEyc,OAAF,KAAcgK,QAA5C,EAAsD;AAClD,yCAAIxmB,KAAKilB,SAAL,EAAJ,EAAsB;AAClB;AACH;AACDjlB,0CAAK0qB,sBAAL,CAA4B3qB,EAAEyc,OAAF,KAAcgK,QAA1C,EAAoD9E,KAApD,CAA0D,YAAM;AAC5D1hB,8CAAK2qB,iBAAL;AACH,sCAFD;AAGH;AACJ,8BATD;AAUAzf,oCAAO1B,gBAAP,CAAwB,SAAxB,EAAmCxJ,KAAK8mB,kBAAxC;AACH,0BAlCD,MAkCO;AACH9mB,kCAAKinB,eAAL,CAAqBzd,gBAArB,CAAsC,mBAASyB,WAAT,EAAtC,EAA8D,YAAM;AAChEjL,sCAAK2qB,iBAAL;AACH,8BAFD;AAGH;;AAED3qB,8BAAKypB,OAAL,CAAaM,SAAb,EAAwBC,iBAAxB;AACH,sBA/DD;AAgEH,kBAjEc,CAAf;;AAmEA,wBAAKjD,OAAL,CAAaplB,IAAb,CAAkB,YAAM;AACpB3B,0BAAKwpB,mBAAL,CAAyB,OAAK/B,GAA9B;AACH,kBAFD;;AAIAznB,sBAAKknB,kBAAL,CAAwB1d,gBAAxB,4BAA6D,YAAM;AAC/D;AACA,4BAAK0d,kBAAL,CAAwBhhB,UAAxB,CAAmCC,WAAnC,CAA+C,OAAK+gB,kBAApD;AACA,4BAAKrpB,OAAL,CAAaiqB,OAAb,CAAqBhmB,KAArB,CAA2B9B,IAA3B;AACA,4BAAKwnB,OAAL,GAAe,KAAf;AACA,4BAAK/L,KAAL,CAAW5b,OAAX;AACA;AACA,yBAAI,OAAKinB,kBAAT,EAA6B;AACzB5b,gCAAOK,mBAAP,CAA2B,SAA3B,EAAsCvL,KAAK8mB,kBAA3C;AACH;AACD,yBAAI,OAAKD,YAAT,EAAuB;AACnB3b,gCAAOK,mBAAP,CAA2B,QAA3B,EAAqCvL,KAAK6mB,YAA1C;AACH;AACJ,kBAbD;;AAeA,wBAAO,OAAKE,OAAZ;AACH,cA9Gc,CAAf;;AAgHA,kBAAKC,WAAL,GAAmB,KAAKD,OAAxB;;AAEA,iBAAI/mB,KAAKunB,OAAT,EAAkB;AACd,sBAAK9L,KAAL,GAAa,oBAAU,KAAKmL,YAAf,CAAb;AACA;AACA,wBAAO,KAAKnL,KAAL,CAAW7C,KAAX,GAAmBgS,UAAnB,CAA8B5qB,KAAKunB,OAAnC,EAA4C5lB,IAA5C,CAAiD,YAAM;AAC1D,4BAAO3B,KAAK+mB,OAAL,CAAaplB,IAAb,CAAkB,YAAM;AAC3B,gCAAO3B,IAAP;AACH,sBAFM,CAAP;AAGH,kBAJM,CAAP;AAKH;AACD,oBAAO,KAAP;AACH;;;8CA3S2B+I,M,EAAQ0e,G,EAAKoD,W,EAAa;AAClD,iBAAMC,eAAe/hB,OAAO7I,YAAP,CAAoB4lB,cAApB,CAArB;AACA,iBAAMiF,gBAAgBhiB,OAAO7I,YAAP,CAAoB6lB,eAApB,CAAtB;AACA,iBAAI+E,gBAAgBC,aAApB,EAAmC;AAC/BtD,qBAAIha,KAAJ,CAAUud,QAAV,GAAqBF,eAAe,IAApC;AACArD,qBAAIha,KAAJ,CAAUwd,SAAV,GAAsBF,gBAAgB,IAAtC;AACH,cAHD,MAGO;AACHtD,qBAAIha,KAAJ,CAAUud,QAAV,GAAqBH,YAAY/a,KAAZ,GAAoB,IAAzC;AACA2X,qBAAIha,KAAJ,CAAUwd,SAAV,GAAsBJ,YAAY9a,MAAZ,GAAqB,IAA3C;AACH;AACJ;;;;;;mBAqSUxT,Q","file":"js/flexcss.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"FlexCss\"] = factory();\n\telse\n\t\troot[\"FlexCss\"] = factory();\n})(this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"../\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap e53f3a44e16ca2bd7531","import Form from '../Form';\nimport Tooltip from '../Tooltip';\nimport Modal from '../Modal';\nimport Widget from '../Widget';\nimport Settings from '../util/Settings';\nimport Toggleable from '../Toggleable';\nimport OffCanvas from '../OffCanvas';\nimport Dropdown from '../Dropdown';\nimport LightBox from '../LightBox';\nimport Util from '../util/Util';\n\nexport { Form, Tooltip, Modal, Widget, Settings, Util, Toggleable, OffCanvas, Dropdown, LightBox };\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/modules/All.js","/* global HTMLFormElement, fetch, FormData, clearTimeout, NodeList */\n\n/*\n * The MIT License (MIT)\n *\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n/*!\n * FlexCss.Form\n * Licensed under the MIT License (MIT)\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n */\n\nimport Tooltip from './Tooltip';\nimport 'isomorphic-fetch';\nimport Event from './util/Event';\nimport Util from './util/Util';\nimport Settings from './util/Settings';\nimport DestroyableWidget from './DestroyableWidget';\n\nconst LOADING_CLASS = 'loading';\nconst DATA_ELEMENT_INVALID = 'data-flexcss-invalid';\nconst REMOTE = 'data-remote';\nconst REMOTE_ACTION = 'data-remote-action';\nconst ATTR_DISABLE_INLINE = 'data-disable-inline-validation';\nconst ATTR_DISABLE_REALTIME = 'data-disable-realtime-validation';\nconst ATTR_VALIDATOR = 'data-validate';\nconst ATTR_DATA_CUSTOM_MESSAGE = 'data-validation-message';\nconst ATTR_DATA_CUSTOM_LABEL = 'data-custom-label';\nconst ATTR_VALIDATE_VISIBILITY = 'data-validate-visibility';\nconst ATTR_ERROR_TARGET_ID = 'data-error-target';\nconst ATTR_DEPENDS = 'data-depends-selector';\nconst CONST_USE_JSON = 'json';\nconst CONST_REALTIME_EVENT = 'input';\nconst FOCUS_TOOLTIP_DELAY = 20;\nconst CLICK_TOOLTIP_DELAY = 150;\n\n/**\n * Triggered when form is fully initialized and handlers are binded\n * @type {string}\n */\nexport const EVENT_FORM_READY = 'flexcss.form.ready';\n/**\n * Fires when a form is submitted, cancelable\n * @type {string}\n */\nexport const EVENT_FORM_SUBMIT = 'flexcss.form.submit';\n/**\n * Fired directly after the form has been submitted via ajax\n * @type {string}\n */\nexport const EVENT_FORM_AFTER_AJAX_SUBMIT = 'flexcss.form.afterAjaxSubmit';\n/**\n * Fired when ajax events did complete\n * @type {string}\n */\nexport const EVENT_FORM_AJAX_COMPLETED = 'flexcss.form.ajaxCompleted';\n\n/**\n * A HTML5 Form Validation replacement\n */\n\nclass Form extends DestroyableWidget {\n    /**\n     * @param {HTMLElement} form\n     * @param [options] optional options\n     */\n    constructor(form, options) {\n        super();\n\n        if (!(form instanceof HTMLFormElement)) {\n            throw new Error('argument {0} form needs to be an form element');\n        }\n\n        /**\n         * The Form\n         * @type {HTMLElement}\n         */\n        this.form = form;\n\n        /**\n         * @type {Tooltip}\n         */\n        this.tooltips = null;\n\n        /**\n         * @type {Promise}\n         */\n        this.currentValidationFuture = new Promise(() => {\n        });\n\n        /**\n         * Default options\n         * @type {Object}\n         */\n        this.options = {\n            // if true creates tooltips above element, uses FlexCss Tooltips\n            createTooltips: true,\n            // if true appends error message after input element\n            appendError: false,\n            // type of ajax submit\n            ajaxSubmitType: 'POST',\n            // json content type if ajax method is set to json\n            ajaxJsonContentType: 'application/json; charset=utf-8',\n            // allow inline validation\n            inlineValidation: true,\n            // validate in realtime (on `input` event)\n            realtime: true,\n            // timeout when realtime event should be captured\n            realtimeTimeout: 250,\n            // formatting method for an error\n            formatErrorTooltip: (error) => {\n                return `<i class=\"icon-attention\"></i> ${error}`;\n            },\n            // the class that will be put on the element to mark it failed validation\n            inputErrorClass: 'invalid',\n            // the container class for error messages below an element\n            containerErrorClass: 'form-error',\n            // additional options for fetch\n            fetchOptions: {\n                credentials: 'include'\n            },\n            // the container for tooltips\n            tooltipContainer: form,\n            tooltipOptions: {\n                containerClass: 'error-tooltip'\n            },\n            shouldScrollToElement: true,\n            // if you have a fixed header, either set a number or function here\n            scrollToElementDiff: 0\n        };\n\n        // overwrite default options\n        Object.assign(this.options, options);\n\n        // apply settings from attributes\n        Util.applyOptionsFromElement(form, this.options);\n\n        // set form class as widget\n        // Forms are very different to classical widgets,\n        // we will not use our base widget class for this but just self\n        form.hfWidgetInstance = this;\n\n        /**\n         * A List of Validators\n         * @type {Object}\n         * @private\n         */\n        this._validators = Form.globalValidators;\n\n        /**\n         * @type {Function}\n         * @private\n         */\n        this._remoteValidationFunction = null;\n\n        this.initFormValidation();\n    }\n\n    destroy() {\n        super.destroy();\n        if (this.tooltips) {\n            this.tooltips.destroy();\n        }\n    }\n\n    /**\n     * Submits this form, either via ajax or just classical (default)\n     * @param {HTMLFormElement} thisForm\n     * @param {Event} e\n     * @private\n     * @returns {Promise|boolean} returns false if submit is cancled\n     */\n    _submitFunction(thisForm, e) {\n        const self = this;\n        const shouldUseAjax = thisForm.getAttribute(REMOTE);\n        const ajaxPostUrl = thisForm.getAttribute(REMOTE_ACTION) ||\n                thisForm.getAttribute('action') || window.location.href;\n\n        const useJson = CONST_USE_JSON === shouldUseAjax;\n\n        const ev = Event.dispatch(thisForm, EVENT_FORM_SUBMIT).withOriginal(e).fire();\n\n        // abort execution is event was prevented\n        if (ev.defaultPrevented) {\n            self._formStopLoading();\n            return false;\n        }\n\n        if (shouldUseAjax === null) {\n            // submit\n            return thisForm.submit();\n        }\n        // prevent form from submit normally\n        e.preventDefault();\n\n        // add information that this is an XMLHttpRequest request (used by some frameworks)\n        const defaultHeaders = {\n            'X-Requested-With': 'XMLHttpRequest'\n        };\n\n        // setup default headers\n        if (useJson) {\n            Object.assign(defaultHeaders, {\n                'Content-Type': this.options.ajaxJsonContentType\n            });\n        }\n        const defaultOptions = Object.assign(this.options.fetchOptions, {\n            headers: defaultHeaders,\n            method: this.options.ajaxSubmitType\n        });\n\n        // support either JSON request payload or normal payload submission\n        const serverCall = useJson ? fetch(ajaxPostUrl, Object.assign(defaultOptions, {\n            body: JSON.stringify(this.serialize())\n        })) : fetch(ajaxPostUrl, Object.assign(defaultOptions, {\n            body: new FormData(thisForm)\n        }));\n\n        Event.dispatch(thisForm, EVENT_FORM_AFTER_AJAX_SUBMIT).withOriginal(e).fire();\n\n        return serverCall.then((r) => {\n            (self._remoteValidationFunction || Form.globalRemoteValidationFunction).apply(self, [r]);\n\n            Event.dispatch(thisForm, EVENT_FORM_AJAX_COMPLETED).withOriginal(e).withDetail({ response: r }).fire();\n            // always remove error class\n            self._formStopLoading();\n        });\n    }\n\n    /**\n     * Serializes a form to a json object\n     * @returns {Object}\n     */\n    serialize() {\n        const selectors = [\n            'input[name]:not([type=\"radio\"]):enabled',\n            'input[type=\"radio\"][name]:checked',\n            'select[name]:enabled',\n            'textarea[name]:enabled'\n        ];\n        const inputs = this.form.querySelectorAll(selectors.join(','));\n        const result = {};\n\n        Array.prototype.forEach.call(inputs, (input) => {\n            const exists = result[input.name];\n            const value = input.value;\n            if (exists instanceof Array) {\n                exists.push(value);\n            } else if (exists) {\n                result[input.name] = [result[input.name], value];\n            } else {\n                result[input.name] = value;\n            }\n        });\n\n        return result;\n    }\n\n    /**\n     * Handles the chain of validation on given fields\n     *\n     * @param {HTMLElement|Array|NodeList} field\n     * @param [focus] optional focus first error\n     * @returns {Promise}\n     */\n    handleValidation(field, focus) {\n        const fields = (field instanceof Array || field instanceof NodeList) ? field : [field];\n        return this._handleValidation(fields, focus, true).then((r) => {\n            if (!r.foundAnyError) {\n                // remove tooltips\n                if (this.tooltips) {\n                    this.tooltips.removeTooltip();\n                }\n            }\n            return r;\n        });\n    }\n\n    /**\n     * Handles errors on given node list\n     * @param {NodeList} toValidateFields\n     * @param {boolean} focus\n     * @param {boolean} scoped if true, will only validate the fields `invalidFields`\n     * @returns {Promise}\n     * @private\n     */\n    _handleValidation(toValidateFields, focus, scoped) {\n        const self = this;\n        const arr = Form._createArrayFromInvalidFieldList(toValidateFields);\n        const isLocalInvalid = arr.length > 0;\n\n        // focus must appear in the same frame for iOS devices\n        if (isLocalInvalid && focus) {\n            self._focusElement(arr[0]);\n        }\n\n        const validation = scoped\n            ? this._customValidationsForElements(toValidateFields)\n            : self.validateCustomFields();\n        return validation.then((r) => {\n            if (isLocalInvalid) {\n                // combine browser and custom validators\n                r.foundAnyError = true;\n            }\n            // get a unique field list of all fields that need to be checked and rendered\n            // it's possible that we have duplicates in non scoped mode\n            const thisToValidateFields = scoped\n                ? toValidateFields\n                : Array.from(arr).concat(r.checkedFields);\n            r.checkedFields = thisToValidateFields;\n            const foundInvalidFields = self.prepareErrors(thisToValidateFields, false);\n            const firstInvalidField = foundInvalidFields[0];\n            if (firstInvalidField) {\n                if (focus) {\n                    self._focusElement(firstInvalidField);\n                    // if element could not be focused:\n                    if (document.activeElement !== firstInvalidField) {\n                        self._handleTooltipHideClickAfterChange();\n                    }\n                } else {\n                    self._handleTooltipHideClickAfterChange();\n                }\n                self.showAndOrCreateTooltip(firstInvalidField);\n            }\n            return r;\n        });\n    }\n\n    /**\n     * @param {HTMLElement} field\n     * @param {ValidityState} validity\n     * @returns {*}\n     * @private\n     */\n\n    _setupErrorMessages(field, validity) {\n        return Form.globalErrorMessageHandler ?\n            Form.globalErrorMessageHandler.apply(this, [field, validity]) : false;\n    }\n\n    /**\n     * Handles class labels for elements\n     * @param {Object} fields\n     * @private\n     */\n    _handleLabels(fields) {\n        Object.keys(fields).forEach((id) => {\n            const labels = this.getForm().querySelectorAll(`[for=\"${id}\"]`);\n            const invalid = fields[id];\n            if (labels.length) {\n                for (let labelsIndex = 0; labelsIndex < labels.length; labelsIndex++) {\n                    const labelEl = labels[labelsIndex];\n                    // we can't use toggle attribute, not supported in IE\n                    if (invalid) {\n                        this._markElementInvalid(labelEl);\n                    } else {\n                        this._markElementValid(labelEl);\n                    }\n                }\n            }\n        });\n    }\n\n    /**\n     * @param el\n     * @private\n     */\n    _markElementInvalid(el) {\n        el.setAttribute(DATA_ELEMENT_INVALID, \"true\");\n        el.classList.add(this.options.inputErrorClass);\n    }\n\n    /**\n     * @param el\n     * @private\n     */\n    _markElementValid(el) {\n        el.removeAttribute(DATA_ELEMENT_INVALID);\n        el.classList.remove(this.options.inputErrorClass);\n    }\n\n    /**\n     * A List of invalid elements (:invalid)\n     * @returns {Array}\n     * @private\n     */\n    _getInvalidElements() {\n        return Array.prototype.filter.call(this.getForm().querySelectorAll(\":invalid\"), (r) => {\n            return !(r instanceof HTMLFieldSetElement);\n        });\n    }\n\n    /**\n     * @param {HTMLElement} thisParent\n     * @private\n     */\n    _removeElementErrors(thisParent) {\n        const errors = thisParent.querySelectorAll(`.${this.options.containerErrorClass}`);\n        const inputsWithErrorClasses = thisParent.querySelectorAll(`[${DATA_ELEMENT_INVALID}]`);\n        for (let elementErrorIndex = 0; elementErrorIndex < errors.length; elementErrorIndex++) {\n            errors[elementErrorIndex].parentNode.removeChild(errors[elementErrorIndex]);\n        }\n        for (let inputErrorIndex = 0; inputErrorIndex < inputsWithErrorClasses.length; inputErrorIndex++) {\n            const el = inputsWithErrorClasses[inputErrorIndex];\n            this._markElementValid(el);\n        }\n    }\n\n\n    /**\n     * Registers a custom validator\n     * @param {String} name\n     * @param {Function} validator a validation function should always return either a Future(true) or Future(false)\n     * even when the field has been invalidated with `setCustomValidity`, because of different browser `bugs`\n     * we can't rely on that\n     * @returns {Form}\n     */\n    registerValidator(name, validator) {\n        this._validators[name] = validator;\n        return this;\n    }\n\n    /**\n     * Runs async validation\n     * @param {String} validationRef\n     * @param {HTMLElement} field\n     * @returns {Promise}\n     * @private\n     */\n    _runValidation(validationRef, field) {\n        if (!this._validators[validationRef]) {\n            throw new Error(`Could not found validator: ${validationRef}`);\n        }\n        const cl = field.classList;\n        const future = this._validators[validationRef].apply(this, [field, this.form]);\n        cl.add(LOADING_CLASS);\n        future.then(() => {\n            cl.remove(LOADING_CLASS);\n        });\n        return future;\n    }\n\n\n    /**\n     * Run custom validations for elements, validations are done async do support XHR Requests or other stuff\n     *\n     * @param {Array|NodeList} fields\n     * @returns {Promise} contains either true if validations passed or false if something went wrong\n     * @private\n     */\n    _customValidationsForElements(fields) {\n        const futures = [];\n        const fieldsLength = fields.length;\n        const checkedFields = [];\n        for (let iVal = 0; iVal < fieldsLength; iVal++) {\n            const field = fields[iVal];\n            const validationRef = field.getAttribute(ATTR_VALIDATOR);\n            const validity = field.validity;\n            if (this._validators[validationRef]) {\n                // use local validation first and then continue with custom validations\n                if (Form._shouldNotValidateField(field) || (validity && !validity.customError && !validity.valid)) {\n                    continue;\n                }\n                checkedFields.push(field);\n                futures.push(this._runValidation(validationRef, field));\n            } else {\n                if (validationRef) {\n                    // console.warn('data-validate was set but no validator was found');\n                }\n            }\n        }\n        return Promise.all(futures).then((allFutures) => {\n            const l = allFutures.length;\n            const result = {\n                checkedFields,\n                foundAnyError: false\n            };\n            for (let fI = 0; fI < l; fI++) {\n                if (!allFutures[fI]) {\n                    result.foundAnyError = true;\n                    break;\n                }\n            }\n            return result;\n        });\n    }\n\n    /**\n     * Remove all errors for this form\n     * @returns {Form}\n     */\n    removeErrors() {\n        this._removeElementErrors(this.form);\n        if (this.tooltips) {\n            this.tooltips.removeTooltip();\n        }\n        return this;\n    }\n\n    /**\n     * Will handle errors for given fields\n     * @param {Array|NodeList} fields\n     * @param {Boolean} removeAllErrors\n     */\n    prepareErrors(fields, removeAllErrors) {\n        if (removeAllErrors) {\n            this.removeErrors();\n        }\n        const labelGroups = {};\n        const invalidFields = [];\n\n        function handleAdditionalLabels(isInvalid, thisLabelGroup, field) {\n            const additionalLabels = field.getAttribute(ATTR_DATA_CUSTOM_LABEL) || field.id;\n            let group = thisLabelGroup[additionalLabels];\n            if (additionalLabels) {\n                // check additionally if field is currently marked as invalid\n                // so the label is not marked as error if no field is marked as one\n                group = group || isInvalid;\n                thisLabelGroup[additionalLabels] = group;\n            }\n        }\n\n        // We save all validations in an extra property because we need to reset the validity due some\n        // implementation errors in other browsers then chrome\n        for (let i = 0; i < fields.length; i++) {\n            const field = fields[i];\n            const errorTarget = Form._findErrorTarget(field);\n            const parent = errorTarget.parentNode;\n            const validity = field.validity;\n            const isInvalid = validity && !validity.valid;\n            if (Form._shouldNotValidateField(field)) {\n                continue;\n            }\n            field.flexFormsSavedValidity = JSON.parse(JSON.stringify(validity));\n            handleAdditionalLabels(isInvalid, labelGroups, field);\n            if (isInvalid) {\n                if (!removeAllErrors) {\n                    // Remove current errors:\n                    this._removeElementErrors(parent);\n                }\n                // setup custom error messages:\n                this._setupErrorMessages(field, validity);\n                const msg = field.validationMessage;\n\n                // mark fields as invalid\n                this._markElementInvalid(errorTarget);\n                this._markElementInvalid(field);\n\n                if (this.options.appendError) {\n                    parent.insertAdjacentHTML(\"beforeend\",\n                        `<div class=\"${this.options.containerErrorClass}\">${msg}</div>`);\n                }\n                invalidFields.push(field);\n                field.flexFormsSavedValidationMessage = msg;\n            } else {\n                // restore invalid fields\n                this._markElementValid(errorTarget);\n                this._markElementValid(field);\n\n                // cleanup\n                delete field.flexFormsSavedValidationMessage;\n\n                // remove error markup\n                this._removeElementErrors(parent);\n            }\n            // We have to reset the custom validity here to allow native validations work again\n            field.setCustomValidity('');\n        }\n        // if validates a single field we need to check the linked fields to a label:\n        if (fields.length === 1) {\n            const field = fields[0];\n            const id = field.getAttribute(ATTR_DATA_CUSTOM_LABEL) || field.id;\n            if (id) {\n                const linkedFields = Array.from(\n                    this.getForm().querySelectorAll(`[${ATTR_DATA_CUSTOM_LABEL}=\"${id}\"], #${id}`));\n                linkedFields.forEach((thisField) => {\n                    const validity = thisField.validity;\n                    const isInvalid = validity && !validity.valid && this._isElementInvalidElement(thisField);\n                    handleAdditionalLabels(isInvalid, labelGroups, thisField);\n                });\n            }\n        }\n        this._handleLabels(labelGroups);\n        return invalidFields;\n    }\n\n    /**\n     * Validates all custom fields\n     * @returns {Promise}\n     */\n    validateCustomFields() {\n        return this._customValidationsForElements(\n            this.form.querySelectorAll(\"[data-validate]\"));\n    }\n\n    /**\n     * Tests if a field should be validated\n     * @param {HTMLElement} field\n     * @returns {boolean}\n     * @private\n     */\n    static _shouldNotValidateField(field) {\n        const target = Form._findErrorTarget(field);\n        return target instanceof HTMLFieldSetElement || field.validity === undefined ||\n            (target.hasAttribute(ATTR_VALIDATE_VISIBILITY) && !Util.isVisible(target));\n    }\n\n    /**\n     * Creates an array from a node list with invalid items\n     * This Method expicitly checks if field should not be validated so it can be used to foucs a field\n     * @param list\n     * @returns {Array}\n     * @private\n     */\n    static _createArrayFromInvalidFieldList(list) {\n        const arr = [];\n        for (let i = 0; i < list.length; ++i) {\n            const n = list[i];\n            if (n.validity && !n.validity.valid) {\n                if (!Form._shouldNotValidateField(n)) {\n                    arr.push(n);\n                }\n            }\n        }\n        return arr;\n    }\n\n\n    /**\n     * This form\n     * @returns {HTMLElement}\n     */\n    getForm() {\n        return this.form;\n    }\n\n    /**\n     * Registers a function that handles remote validation\n     * @param {Function} func\n     * @returns {Form}\n     */\n    registerRemoteValidation(func) {\n        this._remoteValidationFunction = func;\n        return this;\n    }\n\n\n    /**\n     * Formats the error content for the tooltip\n     * @param {String} error\n     * @returns {String}\n     * @private\n     */\n    _formatErrorTooltip(error) {\n        return this.options.formatErrorTooltip.apply(this, [error]);\n    }\n\n    /**\n     * Tries to find a custom error target on given target\n     * @param target\n     * @returns {HTMLElement}\n     * @private\n     */\n    static _findErrorTarget(target) {\n        const el = target.getAttribute(ATTR_ERROR_TARGET_ID) || target;\n        const foundTarget = el instanceof HTMLElement ? el : global.document.getElementById(el);\n        if (!foundTarget) {\n            throw new Error(`Given error target did not exists: ${target}`);\n        }\n        return foundTarget;\n    }\n\n    /**\n     * Creates a tooltip at given element, will only create a new instance if not created\n     * @param {HTMLElement} target\n     * @param {Boolean} [remove]\n     */\n    showAndOrCreateTooltip(target, remove) {\n        const self = this;\n        if (!this.tooltips && this.options.createTooltips) {\n            this.tooltips = new Tooltip(this.options.tooltipContainer, this.options.tooltipOptions);\n        }\n        if (!this.options.createTooltips) {\n            return false;\n        }\n\n        if (!target.flexFormsSavedValidity) {\n            return false;\n        }\n        const errorTarget = Form._findErrorTarget(target);\n        let result = false;\n        if (!target.flexFormsSavedValidity.valid && self._isElementInvalidElement(errorTarget)) {\n            self.tooltips.createTooltip(\n                errorTarget,\n                self._formatErrorTooltip(target.flexFormsSavedValidationMessage), false\n            );\n            result = true;\n        } else {\n            if (remove) {\n                self.tooltips.removeTooltip();\n            }\n        }\n        return result;\n    }\n\n    /**\n     * Checks if element is marked as invalid\n     * @param {HTMLElement} el\n     * @returns {boolean}\n     * @private\n     */\n    _isElementInvalidElement(el) {\n        return el.hasAttribute(DATA_ELEMENT_INVALID);\n    }\n\n    /**\n     * Handles invalid event of a form\n     * @param {Event} e\n     * @returns {Promise|boolean}\n     * @private\n     */\n    _checkIsInvalid(e) {\n        e.preventDefault();\n        const invalidFields = this.getForm().querySelectorAll(\":invalid\");\n        return this._handleValidation(invalidFields, true, false);\n    }\n\n    /**\n     * Will query dependent fields (by selector) that should be validated with given field\n     * @param field\n     * @returns {NodeList|[]}\n     * @private\n     */\n    _getDependentFields(field) {\n        const fieldSelector = field.getAttribute(ATTR_DEPENDS);\n        const base = [field];\n        if (fieldSelector) {\n            base.push.apply(base, Array.prototype.slice.apply(\n                this.getForm().querySelectorAll(fieldSelector)));\n        }\n        return base;\n    }\n\n    /**\n     * @private\n     * @param {HTMLElement} [target]\n     */\n    _handleTooltipInline(target) {\n        if (this.tooltips) {\n            this.tooltips.removeTooltip(target);\n        }\n    }\n\n    /**\n     * Initializes validation for a given form, registers event handlers\n     */\n    initFormValidation() {\n        // Suppress the default bubbles\n        const self = this;\n        const form = this.getForm();\n        const invalidEvent = 'invalid';\n\n        /**\n         * Validates if is valid realtime element\n         * @param {HTMLElement} target\n         * @returns {boolean}\n         * @private\n         */\n        function _checkIsValidRealtimeElement(target) {\n            return !target.hasAttribute(ATTR_DISABLE_REALTIME) && !target.hasAttribute(ATTR_DISABLE_INLINE);\n        }\n\n        form.addEventListener(invalidEvent, (e) => {\n            e.preventDefault();\n        }, true);\n\n        Util.addEventOnce(invalidEvent, form, function handleInvalid(e) {\n            self._formLoading();\n            const result = self._checkIsInvalid(e);\n            if (result) {\n                self.currentValidationFuture = new Promise((resolve) => {\n                    result.then((r) => {\n                        setTimeout(() => {\n                            Util.addEventOnce(invalidEvent, form, handleInvalid, true);\n                        }, 0);\n                        resolve(r);\n                        self._formStopLoading();\n                        if (!r.foundAnyError) {\n                            self._formLoading();\n                            self._handleSubmit(e);\n                        }\n                    });\n                });\n            }\n        }, true);\n\n        this.addEventListener(form, 'reset', () => {\n            this.removeErrors();\n        });\n\n        // Timeout for keys:\n        let TIMEOUT_KEYDOWN;\n        let KEYDOWN_RUNNING = false;\n\n        // resets keydown events\n        function clearKeyDownTimeout() {\n            KEYDOWN_RUNNING = false;\n            clearTimeout(TIMEOUT_KEYDOWN);\n        }\n\n        // setup custom realtime event if given\n        if (self.options.realtime) {\n            this.addEventListener(form, CONST_REALTIME_EVENT, (e) => {\n                if (self._formIsLoading()) {\n                    return;\n                }\n                const target = e.target;\n                clearTimeout(TIMEOUT_KEYDOWN);\n                if (KEYDOWN_RUNNING) {\n                    return;\n                }\n                TIMEOUT_KEYDOWN = setTimeout(() => {\n                    const isStillTarget = document.activeElement === e.target;\n                    if (!_checkIsValidRealtimeElement(target)) {\n                        return;\n                    }\n                    if (isStillTarget) {\n                        self._handleTooltipInline();\n                    }\n                    KEYDOWN_RUNNING = true;\n                    const dependentFields = self._getDependentFields(target);\n                    self._customValidationsForElements(dependentFields).then(() => {\n                        self.prepareErrors(dependentFields, false);\n                        if (isStillTarget) {\n                            self.showAndOrCreateTooltip(e.target);\n                        }\n                        // future must be resolved before another event can be started\n                        KEYDOWN_RUNNING = false;\n                    });\n                }, self.options.realtimeTimeout);\n            }, true);\n        }\n\n        /**\n         * Validates if target is a valid input field to check blur and focus events\n         *\n         * @param {HTMLElement} target\n         * @returns {boolean}\n         * @private\n         */\n        function _checkIsValidBlurFocusElement(target) {\n            const attr = target.getAttribute(\"type\");\n            return (attr !== \"radio\" && attr !== \"checkbox\" && attr !== \"submit\");\n        }\n\n        /**\n         * Validates if is valid inline-check element\n         * @param {HTMLElement} target\n         * @returns {boolean}\n         * @private\n         */\n        function _checkIsValidInlineCheckElement(target) {\n            return !target.hasAttribute(ATTR_DISABLE_INLINE);\n        }\n\n        this.addEventListener(form, 'blur', (e) => {\n            // do not hide tooltip after change event\n            if (!e.target.flexcssKeepTooltips) {\n                self._handleTooltipInline(e.target);\n            }\n            delete e.target.flexcssKeepTooltips;\n        }, true);\n\n        // handle focus on input elements\n        // will show an error if field is invalid\n        this.addEventListener(form, \"focus\", (e) => {\n            if (self._formIsLoading()) {\n                return;\n            }\n            // do not track errors for checkbox and radios on focus:\n            if (!_checkIsValidBlurFocusElement(e.target)) {\n                return;\n            }\n            // we need to delay this a little, because Firefox and Safari do not show a tooltip after it\n            // just have been hidden (on blur). Maybe fix this with a queue later\n            setTimeout(() => {\n                self.showAndOrCreateTooltip(e.target);\n            }, FOCUS_TOOLTIP_DELAY);\n        }, true);\n\n        if (self.options.inlineValidation) {\n            // Handle change for checkbox, radios and selects\n            this.addEventListener(form, \"change\", (e) => {\n                const target = e.target;\n                if (self._formIsLoading() || !_checkIsValidInlineCheckElement(target)) {\n                    return;\n                }\n                clearKeyDownTimeout();\n                const name = target.getAttribute('name');\n                let inputs = name ? form.querySelectorAll(`[name=\"${name}\"]`) : [target];\n                // we only support dependent fields for a single widgets right now\n                if (inputs.length === 1) {\n                    inputs = self._getDependentFields(target);\n                }\n                self._customValidationsForElements(inputs).then(() => {\n                    self.prepareErrors(inputs, false);\n                    target.flexcssKeepTooltips = self.showAndOrCreateTooltip(target, true);\n                    if (target.flexcssKeepTooltips) {\n                        self._handleTooltipHideClickAfterChange();\n                    }\n                });\n            });\n        }\n\n        // prevent default if form is invalid\n        this.addEventListener(form, \"submit\", function listener(e) {\n            self._submitListener(e, listener);\n        });\n\n        Event.dispatchAndFire(form, EVENT_FORM_READY);\n    }\n\n    /* Loading states, unfortunately we can't check if a promise is pending :/*/\n    /* TODO: Maybe wrap promise to extend this functionality */\n\n    _formLoading() {\n        this.getForm().classList.add(LOADING_CLASS);\n    }\n\n    _formStopLoading() {\n        this.getForm().classList.remove(LOADING_CLASS);\n    }\n\n    _formIsLoading() {\n        return this.getForm().classList.contains(LOADING_CLASS);\n    }\n\n    // this defines the logic after a change event when a tooltip is shown\n    // because we call this method inside the change event, the click would be immeditally executed with the change\n    // event when not using setTimeout(). There might be another solution for this...\n    _handleTooltipHideClickAfterChange() {\n        const self = this;\n        if (this.options.createTooltips) {\n            setTimeout(() => {\n                Util.addEventOnce(Settings.getTabEvent(), global.document.body, (t) => {\n                    if (!self._isElementInvalidElement(t.target)) {\n                        self._handleTooltipInline();\n                    }\n                });\n            }, CLICK_TOOLTIP_DELAY);\n        }\n    }\n\n    _focusElement(el) {\n        el.focus();\n        if (this.options.shouldScrollToElement) {\n            Util.scrollToElement(el, this.options.scrollToElementDiff);\n        }\n    }\n\n    /**\n     * Listener that is executed on form submit\n     * @param e\n     * @param submitListener\n     * @returns {boolean}\n     * @private\n     */\n    _submitListener(e, submitListener) {\n        const form = this.getForm();\n        const self = this;\n        const submitEvent = 'submit';\n\n        if (this._formIsLoading()) {\n            e.preventDefault();\n            return false;\n        }\n        this._formLoading();\n        form.removeEventListener(submitEvent, submitListener);\n        this.removeErrors();\n        e.preventDefault();\n        // reset:\n        if (form.checkValidity()) {\n            form.addEventListener(submitEvent, submitListener);\n            // It's possible that the form is valid but the custom validations need to be checked again:\n            self.currentValidationFuture = new Promise((resolve) => {\n                const validation = self.validateCustomFields();\n                validation.then((r) => {\n                    // because custom validators may mark multiple fields as invalid, we get all of them in the form\n                    const fields = self._getInvalidElements();\n                    const errors = self.prepareErrors(fields, false);\n                    const firstError = errors[0];\n                    if (firstError) {\n                        self._focusElement(firstError);\n                        self.showAndOrCreateTooltip(firstError, true);\n                    }\n                    resolve(r);\n                });\n            });\n            self.currentValidationFuture.then((r) => {\n                if (!r.foundAnyError) {\n                    // Handle submitting the form to server:\n                    self._handleSubmit(e);\n                } else {\n                    self._formStopLoading();\n                }\n            });\n        } else {\n            self._formStopLoading();\n            form.addEventListener(submitEvent, submitListener);\n        }\n    }\n\n\n    /**\n     * Handles submitting, optionally allows to stop submitting\n     * @param e\n     * @private\n     */\n    _handleSubmit(e) {\n        this._submitFunction(this.form, e);\n    }\n\n\n    /**\n     * Registers a global event Handler\n     * @param errorFunc\n     */\n    static registerErrorMessageHandler(errorFunc) {\n        Form.globalErrorMessageHandler = errorFunc;\n    }\n\n    /**\n     * Initialize forms for a specific selector\n     * @param {String} selector\n     * @param {Object} [options]\n     * @return {array.<Form>}\n     */\n    static init(selector, options) {\n        const forms = selector instanceof HTMLElement ? selector.querySelectorAll('form') :\n            document.querySelectorAll(selector);\n        const instances = [];\n        for (let i = 0; i < forms.length; i++) {\n            instances.push(new Form(forms[i], options));\n        }\n        return instances;\n    }\n\n\n    /**\n     * Registers a global validator that is usable on all form instances\n     * @param {String} name\n     * @param {Function} validator\n     * @returns {Function}\n     */\n    static registerValidator(name, validator) {\n        Form.globalValidators[name] = validator;\n        return Form;\n    }\n\n    /**\n     * Registers a global function that is called when a form should validate the response of a server\n     * @param {Function} func\n     * @returns {Form}\n     */\n    static registerGlobalRemoteValidationFunction(func) {\n        Form.globalRemoteValidationFunction = func;\n        return Form;\n    }\n}\n\n\n/**\n * Global validators\n * @type {Array}\n */\nForm.globalValidators = [];\n\n/**\n * Global Remote validation function\n */\nForm.globalRemoteValidationFunction = () => {\n};\n\n/**\n * Handles custom error messages extracts custom message by default\n */\nForm.globalErrorMessageHandler = (field, validity) => {\n    if (!validity.customError) {\n        const customMsg = field.getAttribute(ATTR_DATA_CUSTOM_MESSAGE);\n        if (customMsg) {\n            field.setCustomValidity(customMsg);\n        }\n    }\n};\n\nexport default Form;\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/Form.js","/*\n * The MIT License (MIT)\n *\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n/*!\n * FlexCss.Tooltip\n * Licensed under the MIT License (MIT)\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n */\n\nimport Util from './util/Util';\nimport DestroyableWidget from './DestroyableWidget';\nimport Settings from './util/Settings';\n\n/**\n * @type {string}\n */\nconst CLASS_NAMES_TOOLTIP = 'tooltip-container';\n/**\n * @type {string}\n */\nconst CLASS_NAMES_OPEN = 'open';\n\n/**\n * @type {string}\n */\nconst ATTR_DATA_CLASSNAME = 'data-class';\n\n/**\n * @type {string}\n */\nconst ATTR_DATA_NO_TOUCH = 'data-no-touch';\n\n/**\n * @type {HTMLDocument}\n */\nconst doc = global.document;\n\n/**\n * Simple Tooltip\n */\nclass Tooltip extends DestroyableWidget {\n\n    /**\n     * Creates a Tooltip\n     * @param {HTMLElement|String} DelegateContainer\n     * @param {Object} [options]\n     */\n    constructor(DelegateContainer, options) {\n        super();\n        /**\n         * The Container where possible events are captured\n         */\n        this.container = DelegateContainer instanceof HTMLElement ?\n            DelegateContainer : doc.getElementById(DelegateContainer);\n\n        if (!this.container) {\n            throw new Error('Could not create Tooltip, DelegateContainer not found');\n        }\n\n        /**\n         * The Container where tooltips are stored for this instance\n         * @type {HTMLElement}\n         */\n        this.tooltipContainer = null;\n\n        /**\n         * Default Options\n         */\n        this.options = {\n            containerClass: '',\n            selectorAttribute: 'data-tooltip',\n            collisionContainer: this.container\n        };\n\n        Object.assign(this.options, options || {});\n    }\n\n    /**\n     * Creates and shows a tooltip\n     * @param {HTMLElement} target where is this tooltip positioned\n     * @param {String} text text content in tooltip, will be NOT escaped\n     * @param {Boolean} [removeTitle] removes title element if given\n     * @param {Node} [positionRelative]\n     */\n    createTooltip(target, text, removeTitle, positionRelative) {\n        // abort if text is empty\n        if (!text || text && text.trim() === '') {\n            return;\n        }\n\n        if (Settings.isTouchDevice() && target && target.hasAttribute(ATTR_DATA_NO_TOUCH)) {\n            return;\n        }\n\n        let tooltipContainer = this.tooltipContainer;\n\n        if (!tooltipContainer) {\n            tooltipContainer = doc.createElement('div');\n            this.container.appendChild(tooltipContainer);\n            this.tooltipContainer = tooltipContainer;\n        }\n        this._restoreClassNames(tooltipContainer, target);\n\n        tooltipContainer.style.left = 'auto';\n        tooltipContainer.style.top = 'auto';\n        tooltipContainer.innerHTML = text;\n        tooltipContainer.flexTooltipCurrentTarget = target;\n        if (removeTitle) {\n            target.oldTitle = text;\n            target.removeAttribute('title');\n        }\n\n        Util.setupPositionNearby(positionRelative || target, tooltipContainer,\n            this.options.collisionContainer, true, true);\n\n        tooltipContainer.classList.add(CLASS_NAMES_OPEN);\n    }\n\n    _restoreClassNames(container, target) {\n        // allow additional classname per tooltip on target element\n        const classNames = [CLASS_NAMES_TOOLTIP, this.options.containerClass];\n        const maybeTargetClass = target.getAttribute(ATTR_DATA_CLASSNAME);\n        if (maybeTargetClass) {\n            classNames.push(maybeTargetClass);\n        }\n        container.className = classNames.join(\" \");\n        return this;\n    }\n\n    /**\n     * @returns {HTMLElement|null}\n     */\n    getCurrentTarget() {\n        return this.tooltipContainer ? this.tooltipContainer.flexTooltipCurrentTarget : null;\n    }\n\n    /**\n     * Destroys this Widget\n     * @returns {boolean}\n     */\n    destroy() {\n        super.destroy();\n\n        if (this.tooltipContainer) {\n            this.tooltipContainer.parentNode.removeChild(this.tooltipContainer);\n            return true;\n        }\n        return false;\n    }\n\n    /**\n     * Removes a Tooltip on given target\n     * @param {HTMLElement} [target], if not given will remove current open tooltip on this instance\n     */\n    removeTooltip(target) {\n        let selfTarget = target;\n        if (!selfTarget && this.tooltipContainer) {\n            selfTarget = this.tooltipContainer.flexTooltipCurrentTarget;\n        }\n        if (this.tooltipContainer) {\n            if (this.tooltipContainer.flexTooltipCurrentTarget !== selfTarget) {\n                return;\n            }\n            this.tooltipContainer.classList.remove(CLASS_NAMES_OPEN);\n            delete this.tooltipContainer.flexTooltipCurrentTarget;\n        }\n        if (selfTarget && selfTarget.oldTitle) {\n            selfTarget.setAttribute('title', selfTarget.oldTitle);\n        }\n    }\n\n    /**\n     * Initilizes mouse events on container element\n     */\n    registerEvents() {\n        const self = this;\n        this.addEventListener(this.container, 'mouseover', (e) => {\n            if (e.target.hasAttribute(self.options.selectorAttribute)) {\n                self.createTooltip(e.target, e.target.getAttribute('title'), true);\n            }\n        });\n\n        this.addEventListener(this.container, 'mouseout', (e) => {\n            if (e.target.hasAttribute(self.options.selectorAttribute)) {\n                self.removeTooltip(e.target);\n            }\n        });\n        return this;\n    }\n}\n\nexport default Tooltip;\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/Tooltip.js","/*\n * The MIT License (MIT)\n *\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\nconst PFX = [\"webkit\", \"moz\", \"MS\", \"o\", \"\"];\n\nconst COL_LEFT_CLASS = 'is-collision-left';\n\nconst COL_RIGHT_CLASS = 'is-collision-right';\n\nconst COL_BOTTOM_CLASS = 'is-collision-bottom';\n\n/**\n * Provides shared DOM-Utility functions\n */\nclass Util {\n\n    /**\n     * Will register the right animation event based on browser\n     * @param element\n     * @param type\n     * @param callback\n     */\n    static prefixedAnimateEvent(element, type, callback) {\n        const thisFunction = function thisFunction(e) {\n            callback.apply(element, [e, thisFunction]);\n        };\n\n        for (let p = 0; p < PFX.length; p++) {\n            let thisType = type;\n            if (!PFX[p]) {\n                thisType = type.toLowerCase();\n            }\n            const name = PFX[p] + thisType;\n            element.addEventListener(name, thisFunction, true);\n        }\n    }\n\n    /**\n     * Get correct transitionend event\n     * @returns {String}\n     * @private\n     */\n    static whichTransitionEndEvent() {\n        const el = document.createElement('fake');\n\n        const transitions = {\n            transition: 'transitionend',\n            OTransition: 'oTransitionEnd',\n            MozTransition: 'transitionend',\n            WebkitTransition: 'webkitTransitionEnd'\n        };\n\n        for (const [key, value] of Object.entries(transitions)) {\n            if (el.style[key] !== undefined) {\n                return value;\n            }\n        }\n    }\n\n    /**\n     * Check if target is part of parent node\n     * @param target\n     * @param parent\n     * @returns {boolean}\n     */\n    static isPartOfNode(target, parent) {\n        if (!target || !parent) {\n            return false;\n        }\n        let now = target;\n        while (now !== parent && now !== null) {\n            if (now === parent) {\n                break;\n            }\n            now = now.parentNode;\n        }\n        return now !== null;\n    }\n\n    /**\n     * Finds the closest element including itself matching a callback\n     * @param {Node} el\n     * @param {Function} callback\n     * @returns {Node|boolean}\n     */\n    static closestCallback(el, callback) {\n        let element = el;\n        while (element !== null) {\n            if (callback(element)) {\n                return element;\n            }\n            element = element.parentNode;\n        }\n        return false;\n    }\n\n    /**\n     * Walks the tree until func returns true for given argument\n     * @param target\n     * @param func\n     * @returns {boolean|HTMLElement}\n     */\n    static parentsUntil(target, func) {\n        if (!target) {\n            return false;\n        }\n        let now = target;\n        while (!func(now) && now !== null) {\n            now = now.parentNode;\n        }\n\n        return now;\n    }\n\n    /**\n     * Generates a unique id\n     * @return {String}\n     */\n    static guid() {\n        function s4() {\n            return Math.floor((1 + Math.random()) * 0x10000)\n                .toString(16)\n                .substring(1);\n        }\n\n        return `${s4() + s4()}-${s4()}-${s4()}-${s4()}-${s4() + s4() + s4()}`;\n    }\n\n    /**\n     * Detects scrollbar width\n     * @see http://stackoverflow.com/questions/986937/how-can-i-get-the-browsers-scrollbar-sizes\n     * @returns {number}\n     */\n    static getScrollBarWidth() {\n        const doc = global.document;\n        const inner = doc.createElement('p');\n\n        inner.style.width = \"100%\";\n        inner.style.height = \"200px\";\n\n        const outer = doc.createElement('div');\n        outer.style.position = \"absolute\";\n        outer.style.top = \"0px\";\n        outer.style.left = \"0px\";\n        outer.style.visibility = \"hidden\";\n        outer.style.width = \"200px\";\n        outer.style.height = \"150px\";\n        outer.style.overflow = \"hidden\";\n        outer.appendChild(inner);\n\n        doc.body.appendChild(outer);\n        const w1 = inner.offsetWidth;\n        outer.style.overflow = 'scroll';\n        let w2 = inner.offsetWidth;\n        if (w1 === w2) {\n            w2 = outer.clientWidth;\n        }\n        doc.body.removeChild(outer);\n\n        return (w1 - w2);\n    }\n\n\n    /**\n     * Run an event once\n     * @param {String} ev\n     * @param {HTMLElement|HTMLDocument} target\n     * @param {Function} func\n     * @param {boolean} [capture]\n     * @return Function created listener\n     */\n    static addEventOnce(ev, target, func, capture) {\n        const thisFunction = function thisFunction(event) {\n            func(event, func);\n            target.removeEventListener(ev, thisFunction, capture);\n        };\n        target.addEventListener(ev, thisFunction, capture);\n        return thisFunction;\n    }\n\n    /**\n     * Checks if an element is visible\n     * @param {HTMLElement} element\n     * @returns bool\n     */\n    static isVisible(element) {\n        return element.offsetWidth > 0 && element.offsetHeight > 0;\n    }\n\n    /**\n     * Creates a camelCaseRepresentation of a dashed string\n     * @param {String} str\n     * @returns String\n     */\n    static dashToCamelCase(str) {\n        return str.replace(/-([a-z])/g, (g) => {\n            return g[1].toUpperCase();\n        });\n    }\n\n    /**\n     * Creates a copy of `input`\n     * @param {*} input\n     * @return *\n     */\n    static copy(input) {\n        return JSON.parse(JSON.stringify(input));\n    }\n\n    /**\n     * Reads options from element (data attributes) and applies to base\n     * @param {HTMLElement} element\n     * @param {Object} base\n     * @return {Object}\n     */\n    static applyOptionsFromElement(element, base) {\n        if (!element) {\n            return base;\n        }\n        const attrs = element.attributes;\n        for (let i = 0; i < attrs.length; i++) {\n            const attr = attrs[i];\n            if (attr) {\n                const s = Util.dashToCamelCase(attr.nodeName.replace('data-', ''));\n                const val = attr.nodeValue;\n                if (base.hasOwnProperty(s)) {\n                    // skip functions\n                    if (typeof base[s] === 'function') {\n                        continue;\n                    }\n                    if (typeof base[s] === 'boolean') {\n                        base[s] = parseInt(val || 1, 10) === 1;\n                    } else {\n                        base[s] = val;\n                    }\n                }\n            }\n        }\n        return base;\n    }\n\n    /**\n     * Will position an element directly at given target\n     * Is aware of a given collision container to detect edges\n     * Will put elementToPosition either to left, center or right edge (prefer right)\n     *  and either to bottom or top (prefers bottom)\n     *\n     * You may overwrite preferred positioned with `centerHorizontal` and `positionTop`\n     *\n     * @param {HTMLElement|ClientRect} target the target container to align to\n     * @param {HTMLElement} elementToPosition the element to position\n     * @param {HTMLElement} collisionContainer the outer container to prevent collisions\n     * @param {boolean} [centerHorizontal] set true to center element, otherwise it's put on the right border by default\n     * @param {boolean} [positionTop] flip top, by default element is positioned to the bottom.\n     * @returns {HTMLElement}\n     */\n    static setupPositionNearby(target, elementToPosition, collisionContainer, centerHorizontal, positionTop) {\n        // determine relative offsets\n        let amountTop = 0;\n        let amountLeft = 0;\n        Util.parentsUntil(target.parentNode, (el) => {\n            if (!(el instanceof HTMLElement)) {\n                return false;\n            }\n            const style = window.getComputedStyle(el);\n            if (Util.isPartOfNode(elementToPosition, el)) {\n                if (style && style.position === 'relative') {\n                    amountTop += el.offsetTop || 0;\n                    amountLeft += el.offsetLeft || 0;\n                }\n                return false;\n            }\n            return true;\n        });\n\n        const targetPosition = target instanceof HTMLElement ? target.getBoundingClientRect() : target;\n        const elementRect = elementToPosition.getBoundingClientRect();\n        const colRect = collisionContainer.getBoundingClientRect();\n        const targetTop = targetPosition.top - amountTop;\n        const targetRight = targetPosition.right;\n        const isCollisionTop = (targetTop - elementRect.height) <= 0;\n        const isCollisionBottom =\n            window.innerHeight < (targetTop + amountTop + targetPosition.height + elementRect.height);\n        const isCollisionLeft = targetRight < elementRect.width;\n        const targetLeft = targetPosition.left;\n        const isCollisionRight = (targetLeft + elementRect.width) > colRect.width;\n        const classList = elementToPosition.classList;\n\n        classList.remove(COL_RIGHT_CLASS);\n        classList.remove(COL_LEFT_CLASS);\n        classList.remove(COL_BOTTOM_CLASS);\n\n        let calcTop;\n        let calcLeft;\n        if (isCollisionLeft && !isCollisionRight) {\n            // put element to left if collision with left\n            calcLeft = `${(targetPosition.left - colRect.left - amountLeft)}px`;\n            classList.add(COL_LEFT_CLASS);\n        } else {\n            // maybe center if no collision with either side\n            const rightPosition = `${(targetRight - elementRect.width - colRect.left - amountLeft)}px`;\n            const leftCentered = ((targetLeft + targetPosition.width / 2) -\n                    (elementRect.width / 2) || 0) - colRect.left;\n            const collisionCentered = (leftCentered + elementRect.width) > colRect.width;\n            if (centerHorizontal && !collisionCentered) {\n                calcLeft = `${leftCentered}px`;\n            } else {\n                classList.add(COL_RIGHT_CLASS);\n                calcLeft = rightPosition;\n            }\n        }\n\n        if (isCollisionBottom || (positionTop && !isCollisionTop)) {\n            // Put Element on top if collision\n            calcTop = `${(targetTop - elementRect.height) - colRect.top}px`;\n            classList.add(COL_BOTTOM_CLASS);\n        } else {\n            calcTop = `${(targetTop + targetPosition.height) - colRect.top}px`;\n        }\n\n        elementToPosition.style.cssText = `top:${calcTop};left:${calcLeft};`;\n\n        return elementToPosition;\n    }\n\n    /**\n     * Brings a given element into viewport\n     * @param {HTMLElement} el\n     * @param {int|function}[optionalOffset]\n     */\n    static scrollToElement(el, optionalOffset) {\n        el.scrollIntoView();\n        let thisOffset = optionalOffset;\n        // optionally use a additional scrollDif\n        if (thisOffset) {\n            if (typeof thisOffset === 'function') {\n                thisOffset = optionalOffset();\n            }\n            const scrolledY = window.pageYOffset;\n            window.scroll(0, scrolledY - thisOffset);\n        }\n    }\n}\n\nexport default Util;\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/util/Util.js","/*\n * The MIT License (MIT)\n *\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n/**\n * Provides a Basic Widget\n */\nclass DestroyableWidget {\n\n    constructor() {\n        this.listeners = [];\n    }\n\n    /**\n     * Destroys a Widget\n     */\n    destroy() {\n        this.listeners.forEach((listener) => {\n            listener.element.removeEventListener.apply(listener.element, listener.args);\n        });\n        this.listeners = [];\n    }\n\n    /**\n     * Adds an event and registers it later to remove bindings\n     * @param {HTMLElement} element\n     * @param {String} name\n     * @param {Function} listener\n     * @param {boolean} [capture]\n     * @returns {Function}\n     */\n    addEventListener(element, name, listener, capture) {\n        this.listeners.push({\n            element,\n            args: [name, listener, capture]\n        });\n\n        element.addEventListener(name, listener, capture);\n        return listener;\n    }\n\n}\n\nexport default DestroyableWidget;\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/DestroyableWidget.js","/*\n * The MIT License (MIT)\n *\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nimport Util from './Util';\n\n// we attach global settings to global once because settings might be shared a lot of times trough the application\n// Maybe find a better way to handle that scenario\nif (global.document && !global.FLEXCSS_GLOBAL_SETTINGS) {\n    global.FLEXCSS_GLOBAL_SETTINGS = {\n        // defined breakpoint for small devices < n\n        smallBreakpoint: 768,\n        // breakpoint when touchmove should be available\n        touchMoveBreakpointOffCanvas: 768,\n        // nodes that should be updated when no scrollbar is expected\n        scrollbarUpdateNodes: global.document.body !== null ? [global.document.body] : [],\n        // additional Delay until darkener is fully hidden\n        darkenerFadeDelay: 100,\n        // class that is added if canvas has been toggled\n        canvasToggledClass: 'toggled-canvas'\n    };\n\n    global.FLEXCSS_CONST_IS_IOS = null;\n\n    global.FLEXCSS_CONST_IS_TOUCH = null;\n\n    global.FLEXCSS_CONST_IS_SAFARI = null;\n\n    global.FLEXCSS_CONST_IS_IE = null;\n\n    global.FLEXCSS_CONST_TAB_EVENT = 'click';\n\n    global.FLEXCSS_IS_SMALL_SCREEN = false;\n\n    const init = () => {\n        // Measure scrollbar width\n        global.FLEXCSS_CONST_SCROLLBAR_WIDTH = Util.getScrollBarWidth();\n        // detect right transition end event\n        global.FLEXCSS_CONST_TRANSITION_EVENT = Util.whichTransitionEndEvent();\n    };\n\n    if (global.document.readyState !== 'loading') {\n        init();\n    } else {\n        // it's possible that global.document.body is not available if the document is not\n        // loaded completely\n        document.addEventListener('DOMContentLoaded', () => {\n            init();\n        });\n    }\n}\n\n/**\n * Utility class that setups global settings\n */\nclass Settings {\n\n    /**\n     * Setup global settings, overwrite default values\n     * @param {Object} settings\n     */\n    static setup(settings) {\n        Object.assign(global.FLEXCSS_GLOBAL_SETTINGS, settings);\n    }\n\n    /**\n     * Access to global settings\n     * @returns {Object}\n     */\n    static get() {\n        return global.FLEXCSS_GLOBAL_SETTINGS;\n    }\n\n    /**\n     * Detects a IOS Device, caches subsequent calls\n     * @returns {boolean}\n     */\n    static isIosDevice() {\n        if (!global.FLEXCSS_CONST_IS_IOS) {\n            global.FLEXCSS_CONST_IS_IOS = global.navigator.userAgent.match(/(iPad|iPhone|iPod)/i);\n        }\n\n        return global.FLEXCSS_CONST_IS_IOS;\n    }\n\n    /**\n     * Detects a safari browser\n     * @returns {boolean}\n     */\n    static isSafari() {\n        if (!global.FLEXCSS_CONST_IS_SAFARI) {\n            global.FLEXCSS_CONST_IS_SAFARI = !!/^((?!chrome|android).)*safari/i.test(global.navigator.userAgent);\n        }\n        return global.FLEXCSS_CONST_IS_SAFARI;\n    }\n\n    /**\n     * @returns {boolean}\n     */\n    static isSmallScreen() {\n        return window.innerWidth < Settings.get().smallBreakpoint;\n    }\n\n    /**\n     * Detects a touch device, caches subsequent calls\n     * @returns {boolean}\n     */\n    static isTouchDevice() {\n        if (!global.FLEXCSS_CONST_IS_TOUCH) {\n            global.FLEXCSS_CONST_IS_TOUCH = 'ontouchstart' in window || !!(global.navigator.msMaxTouchPoints);\n        }\n        return global.FLEXCSS_CONST_IS_TOUCH;\n    }\n\n    /**\n     * Checks if current browser is Internet Explorer\n     * @returns {boolean|*}\n     */\n    static isIE() {\n        if (!global.FLEXCSS_CONST_IS_IE) {\n            global.FLEXCSS_CONST_IS_IE = \"ActiveXObject\" in window;\n        }\n        return global.FLEXCSS_CONST_IS_IE;\n    }\n\n    /**\n     * @returns {String}\n     */\n    static getTransitionEvent() {\n        return global.FLEXCSS_CONST_TRANSITION_EVENT;\n    }\n\n    /**\n     * @returns {int}\n     */\n    static getScrollbarWidth() {\n        return global.FLEXCSS_CONST_SCROLLBAR_WIDTH;\n    }\n\n    /**\n     * @returns {String}\n     */\n    static getTabEvent() {\n        return global.FLEXCSS_CONST_TAB_EVENT;\n    }\n}\n\nexport default Settings;\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/util/Settings.js","// the whatwg-fetch polyfill installs the fetch() function\n// on the global object (window or self)\n//\n// Return that as the export for use in Webpack, Browserify etc.\nrequire('whatwg-fetch');\nmodule.exports = self.fetch.bind(self);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/isomorphic-fetch/fetch-npm-browserify.js\n// module id = 12\n// module chunks = 2 3","(function(self) {\n  'use strict';\n\n  if (self.fetch) {\n    return\n  }\n\n  var support = {\n    searchParams: 'URLSearchParams' in self,\n    iterable: 'Symbol' in self && 'iterator' in Symbol,\n    blob: 'FileReader' in self && 'Blob' in self && (function() {\n      try {\n        new Blob()\n        return true\n      } catch(e) {\n        return false\n      }\n    })(),\n    formData: 'FormData' in self,\n    arrayBuffer: 'ArrayBuffer' in self\n  }\n\n  if (support.arrayBuffer) {\n    var viewClasses = [\n      '[object Int8Array]',\n      '[object Uint8Array]',\n      '[object Uint8ClampedArray]',\n      '[object Int16Array]',\n      '[object Uint16Array]',\n      '[object Int32Array]',\n      '[object Uint32Array]',\n      '[object Float32Array]',\n      '[object Float64Array]'\n    ]\n\n    var isDataView = function(obj) {\n      return obj && DataView.prototype.isPrototypeOf(obj)\n    }\n\n    var isArrayBufferView = ArrayBuffer.isView || function(obj) {\n      return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1\n    }\n  }\n\n  function normalizeName(name) {\n    if (typeof name !== 'string') {\n      name = String(name)\n    }\n    if (/[^a-z0-9\\-#$%&'*+.\\^_`|~]/i.test(name)) {\n      throw new TypeError('Invalid character in header field name')\n    }\n    return name.toLowerCase()\n  }\n\n  function normalizeValue(value) {\n    if (typeof value !== 'string') {\n      value = String(value)\n    }\n    return value\n  }\n\n  // Build a destructive iterator for the value list\n  function iteratorFor(items) {\n    var iterator = {\n      next: function() {\n        var value = items.shift()\n        return {done: value === undefined, value: value}\n      }\n    }\n\n    if (support.iterable) {\n      iterator[Symbol.iterator] = function() {\n        return iterator\n      }\n    }\n\n    return iterator\n  }\n\n  function Headers(headers) {\n    this.map = {}\n\n    if (headers instanceof Headers) {\n      headers.forEach(function(value, name) {\n        this.append(name, value)\n      }, this)\n\n    } else if (headers) {\n      Object.getOwnPropertyNames(headers).forEach(function(name) {\n        this.append(name, headers[name])\n      }, this)\n    }\n  }\n\n  Headers.prototype.append = function(name, value) {\n    name = normalizeName(name)\n    value = normalizeValue(value)\n    var list = this.map[name]\n    if (!list) {\n      list = []\n      this.map[name] = list\n    }\n    list.push(value)\n  }\n\n  Headers.prototype['delete'] = function(name) {\n    delete this.map[normalizeName(name)]\n  }\n\n  Headers.prototype.get = function(name) {\n    var values = this.map[normalizeName(name)]\n    return values ? values[0] : null\n  }\n\n  Headers.prototype.getAll = function(name) {\n    return this.map[normalizeName(name)] || []\n  }\n\n  Headers.prototype.has = function(name) {\n    return this.map.hasOwnProperty(normalizeName(name))\n  }\n\n  Headers.prototype.set = function(name, value) {\n    this.map[normalizeName(name)] = [normalizeValue(value)]\n  }\n\n  Headers.prototype.forEach = function(callback, thisArg) {\n    Object.getOwnPropertyNames(this.map).forEach(function(name) {\n      this.map[name].forEach(function(value) {\n        callback.call(thisArg, value, name, this)\n      }, this)\n    }, this)\n  }\n\n  Headers.prototype.keys = function() {\n    var items = []\n    this.forEach(function(value, name) { items.push(name) })\n    return iteratorFor(items)\n  }\n\n  Headers.prototype.values = function() {\n    var items = []\n    this.forEach(function(value) { items.push(value) })\n    return iteratorFor(items)\n  }\n\n  Headers.prototype.entries = function() {\n    var items = []\n    this.forEach(function(value, name) { items.push([name, value]) })\n    return iteratorFor(items)\n  }\n\n  if (support.iterable) {\n    Headers.prototype[Symbol.iterator] = Headers.prototype.entries\n  }\n\n  function consumed(body) {\n    if (body.bodyUsed) {\n      return Promise.reject(new TypeError('Already read'))\n    }\n    body.bodyUsed = true\n  }\n\n  function fileReaderReady(reader) {\n    return new Promise(function(resolve, reject) {\n      reader.onload = function() {\n        resolve(reader.result)\n      }\n      reader.onerror = function() {\n        reject(reader.error)\n      }\n    })\n  }\n\n  function readBlobAsArrayBuffer(blob) {\n    var reader = new FileReader()\n    var promise = fileReaderReady(reader)\n    reader.readAsArrayBuffer(blob)\n    return promise\n  }\n\n  function readBlobAsText(blob) {\n    var reader = new FileReader()\n    var promise = fileReaderReady(reader)\n    reader.readAsText(blob)\n    return promise\n  }\n\n  function readArrayBufferAsText(buf) {\n    var view = new Uint8Array(buf)\n    var chars = new Array(view.length)\n\n    for (var i = 0; i < view.length; i++) {\n      chars[i] = String.fromCharCode(view[i])\n    }\n    return chars.join('')\n  }\n\n  function bufferClone(buf) {\n    if (buf.slice) {\n      return buf.slice(0)\n    } else {\n      var view = new Uint8Array(buf.byteLength)\n      view.set(new Uint8Array(buf))\n      return view.buffer\n    }\n  }\n\n  function Body() {\n    this.bodyUsed = false\n\n    this._initBody = function(body) {\n      this._bodyInit = body\n      if (!body) {\n        this._bodyText = ''\n      } else if (typeof body === 'string') {\n        this._bodyText = body\n      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {\n        this._bodyBlob = body\n      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {\n        this._bodyFormData = body\n      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n        this._bodyText = body.toString()\n      } else if (support.arrayBuffer && support.blob && isDataView(body)) {\n        this._bodyArrayBuffer = bufferClone(body.buffer)\n        // IE 10-11 can't handle a DataView body.\n        this._bodyInit = new Blob([this._bodyArrayBuffer])\n      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {\n        this._bodyArrayBuffer = bufferClone(body)\n      } else {\n        throw new Error('unsupported BodyInit type')\n      }\n\n      if (!this.headers.get('content-type')) {\n        if (typeof body === 'string') {\n          this.headers.set('content-type', 'text/plain;charset=UTF-8')\n        } else if (this._bodyBlob && this._bodyBlob.type) {\n          this.headers.set('content-type', this._bodyBlob.type)\n        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')\n        }\n      }\n    }\n\n    if (support.blob) {\n      this.blob = function() {\n        var rejected = consumed(this)\n        if (rejected) {\n          return rejected\n        }\n\n        if (this._bodyBlob) {\n          return Promise.resolve(this._bodyBlob)\n        } else if (this._bodyArrayBuffer) {\n          return Promise.resolve(new Blob([this._bodyArrayBuffer]))\n        } else if (this._bodyFormData) {\n          throw new Error('could not read FormData body as blob')\n        } else {\n          return Promise.resolve(new Blob([this._bodyText]))\n        }\n      }\n\n      this.arrayBuffer = function() {\n        if (this._bodyArrayBuffer) {\n          return consumed(this) || Promise.resolve(this._bodyArrayBuffer)\n        } else {\n          return this.blob().then(readBlobAsArrayBuffer)\n        }\n      }\n    }\n\n    this.text = function() {\n      var rejected = consumed(this)\n      if (rejected) {\n        return rejected\n      }\n\n      if (this._bodyBlob) {\n        return readBlobAsText(this._bodyBlob)\n      } else if (this._bodyArrayBuffer) {\n        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))\n      } else if (this._bodyFormData) {\n        throw new Error('could not read FormData body as text')\n      } else {\n        return Promise.resolve(this._bodyText)\n      }\n    }\n\n    if (support.formData) {\n      this.formData = function() {\n        return this.text().then(decode)\n      }\n    }\n\n    this.json = function() {\n      return this.text().then(JSON.parse)\n    }\n\n    return this\n  }\n\n  // HTTP methods whose capitalization should be normalized\n  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']\n\n  function normalizeMethod(method) {\n    var upcased = method.toUpperCase()\n    return (methods.indexOf(upcased) > -1) ? upcased : method\n  }\n\n  function Request(input, options) {\n    options = options || {}\n    var body = options.body\n\n    if (typeof input === 'string') {\n      this.url = input\n    } else {\n      if (input.bodyUsed) {\n        throw new TypeError('Already read')\n      }\n      this.url = input.url\n      this.credentials = input.credentials\n      if (!options.headers) {\n        this.headers = new Headers(input.headers)\n      }\n      this.method = input.method\n      this.mode = input.mode\n      if (!body && input._bodyInit != null) {\n        body = input._bodyInit\n        input.bodyUsed = true\n      }\n    }\n\n    this.credentials = options.credentials || this.credentials || 'omit'\n    if (options.headers || !this.headers) {\n      this.headers = new Headers(options.headers)\n    }\n    this.method = normalizeMethod(options.method || this.method || 'GET')\n    this.mode = options.mode || this.mode || null\n    this.referrer = null\n\n    if ((this.method === 'GET' || this.method === 'HEAD') && body) {\n      throw new TypeError('Body not allowed for GET or HEAD requests')\n    }\n    this._initBody(body)\n  }\n\n  Request.prototype.clone = function() {\n    return new Request(this, { body: this._bodyInit })\n  }\n\n  function decode(body) {\n    var form = new FormData()\n    body.trim().split('&').forEach(function(bytes) {\n      if (bytes) {\n        var split = bytes.split('=')\n        var name = split.shift().replace(/\\+/g, ' ')\n        var value = split.join('=').replace(/\\+/g, ' ')\n        form.append(decodeURIComponent(name), decodeURIComponent(value))\n      }\n    })\n    return form\n  }\n\n  function parseHeaders(rawHeaders) {\n    var headers = new Headers()\n    rawHeaders.split('\\r\\n').forEach(function(line) {\n      var parts = line.split(':')\n      var key = parts.shift().trim()\n      if (key) {\n        var value = parts.join(':').trim()\n        headers.append(key, value)\n      }\n    })\n    return headers\n  }\n\n  Body.call(Request.prototype)\n\n  function Response(bodyInit, options) {\n    if (!options) {\n      options = {}\n    }\n\n    this.type = 'default'\n    this.status = 'status' in options ? options.status : 200\n    this.ok = this.status >= 200 && this.status < 300\n    this.statusText = 'statusText' in options ? options.statusText : 'OK'\n    this.headers = new Headers(options.headers)\n    this.url = options.url || ''\n    this._initBody(bodyInit)\n  }\n\n  Body.call(Response.prototype)\n\n  Response.prototype.clone = function() {\n    return new Response(this._bodyInit, {\n      status: this.status,\n      statusText: this.statusText,\n      headers: new Headers(this.headers),\n      url: this.url\n    })\n  }\n\n  Response.error = function() {\n    var response = new Response(null, {status: 0, statusText: ''})\n    response.type = 'error'\n    return response\n  }\n\n  var redirectStatuses = [301, 302, 303, 307, 308]\n\n  Response.redirect = function(url, status) {\n    if (redirectStatuses.indexOf(status) === -1) {\n      throw new RangeError('Invalid status code')\n    }\n\n    return new Response(null, {status: status, headers: {location: url}})\n  }\n\n  self.Headers = Headers\n  self.Request = Request\n  self.Response = Response\n\n  self.fetch = function(input, init) {\n    return new Promise(function(resolve, reject) {\n      var request = new Request(input, init)\n      var xhr = new XMLHttpRequest()\n\n      xhr.onload = function() {\n        var options = {\n          status: xhr.status,\n          statusText: xhr.statusText,\n          headers: parseHeaders(xhr.getAllResponseHeaders() || '')\n        }\n        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL')\n        var body = 'response' in xhr ? xhr.response : xhr.responseText\n        resolve(new Response(body, options))\n      }\n\n      xhr.onerror = function() {\n        reject(new TypeError('Network request failed'))\n      }\n\n      xhr.ontimeout = function() {\n        reject(new TypeError('Network request failed'))\n      }\n\n      xhr.open(request.method, request.url, true)\n\n      if (request.credentials === 'include') {\n        xhr.withCredentials = true\n      }\n\n      if ('responseType' in xhr && support.blob) {\n        xhr.responseType = 'blob'\n      }\n\n      request.headers.forEach(function(value, name) {\n        xhr.setRequestHeader(name, value)\n      })\n\n      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)\n    })\n  }\n  self.fetch.polyfill = true\n})(typeof self !== 'undefined' ? self : this);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/whatwg-fetch/fetch.js\n// module id = 13\n// module chunks = 2 3","/* global CustomEvent */\n\n/*\n * The MIT License (MIT)\n *\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n// polyfill for custom events to make thinks work in IE\n// The needed polyfill is so small that I embedded it here\n(function poly() {\n    if (global.document && (!global.CustomEvent || typeof global.CustomEvent !== 'function')) {\n        const CustomEvent = function CustomEvent(event, params) {\n            const thisParams = params || {\n                bubbles: false,\n                cancelable: false,\n                detail: undefined\n            };\n            const evt = document.createEvent(\"CustomEvent\");\n            evt.initCustomEvent(event, thisParams.bubbles,\n                thisParams.cancelable, thisParams.detail);\n            evt.superPreventDefault = evt.preventDefault;\n            evt.preventDefault = () => {\n                // Due a bug in IE11, we need to set defaultPrevented manually\n                Object.defineProperty(evt, \"defaultPrevented\", {\n                    get: () => {\n                        return true;\n                    }\n                });\n                evt.superPreventDefault();\n            };\n            return evt;\n        };\n        CustomEvent.prototype = global.Event.prototype;\n        global.CustomEvent = CustomEvent;\n    }\n}());\n/**\n * Simpler Event dispatching\n */\nclass EventHandler {\n\n    /**\n     * @param {HTMLElement} target\n     * @param {String} name\n     */\n    constructor(target, name) {\n        this.target = target;\n        this.defaultOptions = {\n            bubbles: true,\n            cancelable: true\n        };\n\n        this.name = name;\n    }\n\n    /**\n     * Set more options\n     * @param {Object} options\n     * @returns {EventHandler}\n     */\n    withOptions(options) {\n        Object.assign(this.defaultOptions, (options || {}));\n        return this;\n    }\n\n    /**\n     * Call with the originalEvent\n     * @param {Event} e\n     * @returns {EventHandler}\n     */\n    withOriginal(e) {\n        return this.withDetail({\n            originalEvent: e\n        });\n    }\n\n    /**\n     * Extends the detail part of the event\n     * @param {Object} o\n     * @returns {EventHandler}\n     */\n    withDetail(o) {\n        if (!this.defaultOptions.detail) {\n            this.defaultOptions.detail = {};\n        }\n        Object.assign(this.defaultOptions.detail, o);\n        return this;\n    }\n\n    /**\n     * @returns {CustomEvent}\n     */\n    fire() {\n        const e = new CustomEvent(this.name, this.defaultOptions);\n        if (this.target) {\n            this.target.dispatchEvent(e);\n        }\n        return e;\n    }\n}\n\nclass Event {\n    /**\n     * Prepares to dispatch a custom event (without firing)\n     * @param {HTMLElement} target\n     * @param {String} name\n     * @returns {EventHandler}\n     */\n    static dispatch(target, name) {\n        return new EventHandler(target, name);\n    }\n\n    /**\n     * Dispatches a custom event and fires it directly\n     * @param {HTMLElement} target\n     * @param {String} name\n     * @param {Object} [options]\n     * @returns {CustomEvent}\n     */\n    static dispatchAndFire(target, name, options) {\n        return new EventHandler(target, name).withOptions(options).fire();\n    }\n}\n\nexport default Event;\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/util/Event.js","/*\n * The MIT License (MIT)\n *\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n/*!\n * FlexCss.Modal\n * Licensed under the MIT License (MIT)\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n */\n\n/* global KeyboardEvent */\n\nimport Settings from './util/Settings';\nimport Event from './util/Event';\nimport Util from './util/Util';\nimport Widget from './Widget';\nimport FixedWindow from './lib/FixedWindow';\nconst KEY_ESC = 27;\n/* Attribute Names */\nconst ATTR_CREATE_NEW = 'data-new-instance';\nconst ATTR_CLOSE = 'data-close-modal';\nconst ATTR_NAME = 'data-modal';\n\n/* Class names */\nconst CLS_CONTAINER_CURRENT = 'front';\nconst CLS_OPEN = 'open';\nconst CLS_CURRENT = 'current';\nconst CLS_PART_OF_STACK = 'part-of-stack';\nconst CLS_MODAL_CONTAINER = 'modal-container';\nconst CLS_ANIM_END = 'modal-anim-end';\nconst CLS_LOADER_CONTAINER = 'loader-container';\nconst CLS_LOADER = 'loader';\nconst CLS_BACKDROP = 'backdrop';\n\n/* Events */\n\n/**\n * Event triggered when modal is closed\n * @type {string}\n */\nexport const EVENT_MODAL_CLOSED = 'flexcss.modal.closed';\n/**\n * Event triggered before a modal is closed, cancelable\n * @type {string}\n */\nexport const EVENT_MODAL_BEFORE_CLOSED = 'flexcss.modal.beforeClose';\n/**\n * Event triggered when a modal is opened\n * @type {string}\n */\nexport const EVENT_MODAL_OPENED = 'flexcss.modal.opened';\n\n/**\n * Event triggered when modal is initilized, called on target\n * @type {string}\n */\nexport const EVENT_MODAL_INIT = 'flexcss.modal.init';\n\n/**\n * Triggered when the content of an async modal on a target is loaded, called on target\n * @type {string}\n */\nexport const EVENT_MODAL_ASYNC_TARGET_LOADED = 'flexcss.modal.asyncTargetLoaded';\n\n/**\n * A Modal Implementation\n */\nclass Modal {\n    constructor(DelegateContainer, options) {\n        const doc = global.document;\n        const container = DelegateContainer instanceof HTMLElement ?\n            DelegateContainer : doc.getElementById(DelegateContainer);\n\n        // Instance vars:\n        if (!container) {\n            throw new Error(`Could not found container element by given ID/Element: ${DelegateContainer}`);\n        }\n\n        this.currentOpen = null;\n\n        this.loading = false;\n\n        this.container = container;\n\n        /**\n         * Default Options\n         */\n        this.options = {\n            classNames: 'modal',\n            closeOnEscape: true,\n            closeOnBackgroundClick: true,\n            destroyOnFinish: false,\n            fixedContainer: true,\n            containerClassNames: ''\n        };\n\n        Object.assign(this.options, options);\n\n        // Container where events are delegated\n        this.eventContainer = null;\n        this.eventFunction = null;\n\n        this.dataMainPageContainer = global.document.body;\n\n        this.currentScrollTop = 0;\n\n        this.modalContainer = null;\n\n        // Destroy full modal instance when no dialogs are bind to?\n        // Otherwise container is recycled\n        this.destroyOnFinish = this.options.destroyOnFinish;\n    }\n\n    /**\n     * Removes this modal from global stack\n     * Will handle fixing main html element too\n     * @private\n     * @param n\n     */\n    _removeModalFromStack(n) {\n        const t = Modal._modalInstances.indexOf(n);\n        if (t > -1) {\n            Modal._modalInstances.splice(t, 1);\n            FixedWindow.getInstance().close();\n        }\n    }\n\n\n    /**\n     * Modal container that contains all `stacked` modals for this instance\n     * @returns {HTMLElement}\n     */\n    getModalContainer() {\n        return this.modalContainer;\n    }\n\n    /**\n     * Closes the current open modal of this stack\n     * @params [e], optional event\n     * @returns {*}\n     */\n    close(e) {\n        const self = this;\n\n        const options = self.currentOpen ? Util.applyOptionsFromElement(\n            self.currentOpen, Util.copy(self.options)) : self.options;\n\n        // close only on keyboard if instance should\n        if (!options.closeOnEscape && e instanceof KeyboardEvent) {\n            return false;\n        }\n\n        // close only on background if instance should\n        if (!options.closeOnBackgroundClick && e &&\n            e.type === Settings.getTabEvent() && !e.target.hasAttribute(ATTR_CLOSE)) {\n            return false;\n        }\n\n        // if an instance is currently loading, prevent from closing\n        if (self.loading) {\n            return false;\n        }\n\n        if (e) {\n            e.preventDefault();\n        }\n\n        if (self.currentOpen) {\n            // dispatch beforeClose event, if prevented prevent modal from closing\n            const ev = Event.dispatchAndFire(self.currentOpen, EVENT_MODAL_BEFORE_CLOSED);\n            if (ev.defaultPrevented) {\n                return false;\n            }\n\n            this._finishState(self.currentOpen);\n            // if there is an previous modal\n            if (self.currentOpen.prevModal) {\n                // switch to the next modal\n                return self.switchModals(self.currentOpen.prevModal,\n                    self.currentOpen.prevModal.prevModal || null);\n            }\n\n            // finally trigger closed event\n            Event.dispatch(self.currentOpen, EVENT_MODAL_CLOSED).withOriginal(e).fire();\n        }\n        self._removeModalFromStack(self.currentOpen);\n\n        // Full stack closed:\n        self.currentOpen = null;\n        if (self.modalContainer) {\n            // setup next open\n            const lastContainer = Modal._modalInstances[Modal._modalInstances.length - 1];\n            const classList = self.modalContainer.classList;\n            classList.remove(CLS_CONTAINER_CURRENT);\n            classList.remove(CLS_BACKDROP);\n            classList.remove(CLS_OPEN);\n            // Remove all current classes from child-nodes\n            for (let i = 0; i < self.modalContainer.childNodes.length; i++) {\n                const node = self.modalContainer.childNodes[i];\n                const cl = node.classList;\n                // remove applied styles\n                self._finishState(node);\n                cl.remove(CLS_CURRENT);\n                cl.remove(CLS_PART_OF_STACK);\n            }\n            if (lastContainer) {\n                lastContainer.parentNode.classList.add(CLS_CONTAINER_CURRENT);\n            }\n        }\n\n        if (self.destroyOnFinish) {\n            self.destroy();\n        }\n        return self;\n    }\n\n    /**\n     * Resets a target when newly initilizes\n     * @param target\n     * @private\n     */\n    _finishState(target) {\n        target.classList.remove(CLS_ANIM_END);\n    }\n\n    /**\n     * Handler called when a Modal has finished an animation\n     * @param e\n     * @param self\n     * @private\n     */\n    _finishAnim(e, self) {\n        e.target.classList.add(CLS_ANIM_END);\n        e.target.removeEventListener(e.type, self, true);\n    }\n\n    /**\n     * Brings the given modal to front\n     * @param co\n     * @param last\n     */\n    switchModals(co, last) {\n        co.prevModal = last;\n        Modal._modalInstances.push(co);\n        FixedWindow.getInstance().open(this, this.modalContainer);\n        if (last) {\n            this._finishState(last);\n            Util.prefixedAnimateEvent(last, 'AnimationEnd', this._finishAnim);\n            last.classList.add(CLS_PART_OF_STACK);\n        }\n        // set new currentOpen\n        this.currentOpen = co;\n\n        // bring current container to the front\n        const instances = Modal._modalInstances;\n\n        for (let m = 0; m < instances.length; m++) {\n            instances[m].parentNode.classList.remove(CLS_CONTAINER_CURRENT);\n        }\n        this.modalContainer.classList.add(CLS_CONTAINER_CURRENT);\n        // remove animations if animations has been completed, fixes various bugs:\n        // - fixes nested scrolling element issue in iOS Browsers / Mobile-Safari\n        Util.prefixedAnimateEvent(co, 'AnimationEnd', this._finishAnim);\n\n        for (let i = 0; i < this.modalContainer.childNodes.length; i++) {\n            const n = this.modalContainer.childNodes[i];\n            const isCurrent = n.classList.contains(CLS_CURRENT);\n            if (n === co) {\n                co.classList.add(CLS_CURRENT);\n                co.classList.remove(CLS_PART_OF_STACK);\n                this._finishState(co);\n            } else {\n                n.classList.remove(CLS_CURRENT);\n                if (isCurrent) {\n                    this._removeModalFromStack(n);\n                    Event.dispatchAndFire(n, EVENT_MODAL_CLOSED);\n                }\n            }\n        }\n    }\n\n    /**\n     * Creates a Modal and opens it (later)\n     * @param e\n     * @returns {Promise|boolean}\n     */\n    createWidget(e) {\n        const self = this;\n        if (this.loading) {\n            return false;\n        }\n\n        // check if another modal has registered events on this dom path:\n        if (e && e.target) {\n            const foundInstance = Util.parentsUntil(e.target, (node) => {\n                return node && node.flexModalInstance;\n            });\n\n            // if another instance has been found, abort\n            if (foundInstance !== this.container) {\n                return false;\n            }\n        }\n        let targetContent;\n        let future;\n        let widget;\n        let target;\n        let hasTarget = true;\n        const isHtmlElement = e instanceof HTMLElement;\n        const isWidget = Widget.isWidget(e);\n        if (isHtmlElement || isWidget) {\n            if (isHtmlElement) {\n                targetContent = e;\n            } else {\n                widget = e;\n                targetContent = widget.element;\n            }\n        } else {\n            target = e.target;\n            if (!target) {\n                throw new Error('Could not find target, did you pass an event, a HTMLElement or an Widget?');\n            }\n            hasTarget = target.hasAttribute(ATTR_NAME);\n            targetContent = target.getAttribute(ATTR_NAME);\n            widget = Widget.findWidget(target);\n            if (target.hasAttribute(ATTR_CREATE_NEW) && !e.newInstance) {\n                const newInstance = new Modal(this.container)\n                    .setDestroyOnFinish(true);\n                e.newInstance = true;\n                newInstance.fromEvent(e).then(() => {\n                    newInstance.registerEvents(newInstance.getModalContainer());\n                });\n                return false;\n            }\n            if (hasTarget) {\n                e.stopImmediatePropagation();\n                e.preventDefault();\n            }\n        }\n\n        if (!hasTarget) {\n            return false;\n        }\n\n        let modalContainerClasses = this.modalContainer ? this.modalContainer.classList : [];\n\n        // lazy create modal container\n        if (!this.modalContainer) {\n            this.modalContainer = global.document.createElement('div');\n            this.modalContainer.className = `${CLS_MODAL_CONTAINER} ${this.options.containerClassNames} ${CLS_OPEN}`;\n            const closeModalFunction = (ce) => {\n                if (this.loading) {\n                    return false;\n                }\n                if (Util.isPartOfNode(ce.target, this.currentOpen)) {\n                    if (!ce.target.hasAttribute(ATTR_CLOSE)) {\n                        return false;\n                    }\n                }\n                this.close(ce);\n            };\n\n            this.modalContainer.addEventListener(Settings.getTabEvent(), closeModalFunction, false);\n\n            modalContainerClasses = this.modalContainer.classList;\n            this.container.appendChild(this.modalContainer);\n        } else {\n            modalContainerClasses.add(CLS_OPEN);\n        }\n\n        let loader;\n        const doc = global.document;\n        const toggleLoader = (show) => {\n            if (show) {\n                loader = doc.createElement('div');\n                loader.className = CLS_LOADER_CONTAINER;\n                const loaderLoader = doc.createElement('div');\n                loaderLoader.className = CLS_LOADER;\n                loader.appendChild(loaderLoader);\n                this.modalContainer.appendChild(loader);\n            } else {\n                loader.parentNode.removeChild(loader);\n            }\n        };\n        modalContainerClasses.add('loading');\n        modalContainerClasses.add(CLS_CONTAINER_CURRENT);\n\n        requestAnimationFrame(() => {\n            requestAnimationFrame(() => {\n                modalContainerClasses.add(CLS_BACKDROP);\n            });\n        });\n\n        this.loading = true;\n        toggleLoader(true);\n        const async = widget ? widget.getAsync() : null;\n        if (Widget.isWidget(widget) && async) {\n            future = async.then((r) => {\n                let result;\n                if (r instanceof HTMLElement || r instanceof DocumentFragment) {\n                    result = r;\n                } else {\n                    // Create container Element:\n                    const element = doc.createElement('div');\n                    element.className = self.options.classNames;\n                    element.innerHTML = r;\n                    element.id = Util.guid();\n                    result = element;\n                }\n                widget.finalContent = result;\n                Event.dispatchAndFire(target, EVENT_MODAL_ASYNC_TARGET_LOADED);\n                return result;\n            });\n        } else {\n            const el = targetContent instanceof HTMLElement ||\n            targetContent instanceof DocumentFragment ? targetContent : doc.getElementById(targetContent);\n            if (el) {\n                future = new Promise((resolve) => {\n                    resolve(el);\n                });\n            } else {\n                throw new Error(`Could not found given modal element (content) with ID: ${targetContent}`);\n            }\n        }\n\n        Event.dispatchAndFire(target, EVENT_MODAL_INIT);\n\n        return future.then((thisEl) => {\n            thisEl.hfWidgetInstance = this;\n            this.modalContainer.appendChild(thisEl);\n            modalContainerClasses.remove('loading');\n            this.loading = false;\n            toggleLoader(false);\n            this.open(thisEl, true, e);\n            return thisEl;\n        });\n    }\n\n    /**\n     * Open's an already rendered modal\n     * @param {HTMLElement} modal\n     * @param {Boolean} [internal], set to true to prevent container management\n     * @param {Boolean} [maybeEvent], optional event-object that triggered open\n     */\n    open(modal, internal, maybeEvent) {\n        if (!internal) {\n            this.modalContainer.classList.add('open');\n        }\n        this.switchModals(modal, this.currentOpen);\n\n        Event.dispatch(modal, EVENT_MODAL_OPENED).withOriginal(maybeEvent).fire();\n    }\n\n\n    registerEvents(delegate) {\n        const delegateContainer = delegate || this.container;\n        // Modals should always be fixed\n        FixedWindow.getInstance().addScreenConstraint(Modal, () => true);\n        // register modal instance so we can detect multiple registrars\n        delegateContainer.flexModalInstance = this;\n        this.eventFunction = (...args) => {\n            this.createWidget.apply(this, args);\n        };\n        delegateContainer.addEventListener(Settings.getTabEvent(), this.eventFunction, false);\n\n        this.eventContainer = delegateContainer;\n        return this;\n    }\n\n\n    /**\n     * Creates a new Dialog Instance either directly from HTML Element or a Widget instance\n     * @param {HTMLElement|Widget} widget instance or html element\n     * @returns {Promise}\n     */\n    fromWidget(widget) {\n        return this.createWidget(widget);\n    }\n\n    /**\n     * Creates a Widget from event\n     * @param e\n     * @returns {Promise}\n     */\n    fromEvent(e) {\n        return this.createWidget(e);\n    }\n\n    setDestroyOnFinish(v) {\n        this.destroyOnFinish = v;\n        return this;\n    }\n\n    /**\n     * Destroy this widget instance, cleans empty DOM nodes\n     * Will use fast MutationObserver if available, otherwise falls back to DOMNodeRemoved event\n     */\n    destroy() {\n        const modalContainer = this.modalContainer;\n        const isEmptyContainer = modalContainer.childNodes.length === 0;\n        // Remove event listener on destroy, do not remove DOM node\n        if (this.eventContainer) {\n            this.eventContainer.removeEventListener(Settings.getTabEvent(), this.eventFunction, true);\n        }\n\n        if (isEmptyContainer) {\n            if (modalContainer.parentNode) {\n                modalContainer.parentNode.removeChild(modalContainer);\n            }\n        }\n        if (global.MutationObserver) {\n            const observer = new MutationObserver((mutations) => {\n                mutations.forEach(() => {\n                    if (modalContainer.childNodes.length === 0) {\n                        modalContainer.parentNode.removeChild(modalContainer);\n                        observer.disconnect();\n                    }\n                });\n            });\n            observer.observe(modalContainer,\n                {\n                    childList: true\n                }\n            );\n        } else {\n            modalContainer.addEventListener('DOMNodeRemoved', (e) => {\n                if (e.target !== modalContainer && (modalContainer.childNodes.length - 1) === 0) {\n                    modalContainer.parentNode.removeChild(modalContainer);\n                }\n            });\n        }\n    }\n}\n\n\n// Static variable that keeps track of all open modals\nModal._modalInstances = [];\n\nif (global.addEventListener) {\n// Global keydown listener for modal\n    global.addEventListener('keydown', (e) => {\n        if (e.keyCode === KEY_ESC) {\n            const lastModal = Modal._modalInstances[Modal._modalInstances.length - 1];\n            if (lastModal) {\n                Widget.findWidget(lastModal).close(e);\n            }\n        }\n    });\n}\n\nexport default Modal;\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/Modal.js","/*\n * The MIT License (MIT)\n *\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n/*!\n * FlexCss.Widget\n * Licensed under the MIT License (MIT)\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n */\n\n/**\n * A Widget provides async content on a specific target (e.g. a modal link)\n */\nclass Widget {\n\n    /**\n     * Creates a new Widget\n     * @param [element], optional define the content of widget\n     */\n    constructor(element) {\n        /**\n         *\n         * @type {Promise}\n         */\n        this.asyncContent = null;\n\n        /**\n         * @type {boolean}\n         */\n        this._isWidget = true;\n\n        if (element) {\n            /**\n             * @type {HTMLElement}\n             */\n            this.element = element instanceof HTMLElement ? element : global.document.getElementById(element);\n            if (this.element) {\n                this.element.hfWidgetInstance = this;\n                this.setAsync(() => {\n                    return new Promise((s) => {\n                        s(this.element);\n                    });\n                });\n            } else {\n                throw new Error(`Could not found element with ID: ${element}`);\n            }\n        }\n        /**\n         * The final resulted content that a widget did create (e.g. a modal container)\n         * @type {HTMLElement}\n         */\n        this.finalContent = null;\n    }\n\n    /**\n     *\n     * @returns {Promise}\n     */\n    getAsync() {\n        return this.asyncContent();\n    }\n\n    /**\n     * @param {Function.<Promise>} async\n     * @returns {Widget}\n     */\n    setAsync(async) {\n        this.asyncContent = async;\n        return this;\n    }\n\n    /**\n     * @returns {HTMLElement}\n     */\n    getFinalContent() {\n        return this.finalContent;\n    }\n\n    /**\n     * @param {HTMLElement} element\n     * @returns {Widget}\n     */\n    setElement(element) {\n        this.element = element;\n        return this;\n    }\n\n    /**\n     * Destroys the generated content of this widget\n     * @returns {boolean}\n     */\n    destroy() {\n        if (this.finalContent && this.finalContent.parentNode) {\n            this.finalContent.parentNode.removeChild(this.finalContent);\n            return true;\n        }\n\n        delete this.element;\n        delete this.asyncContent;\n        delete this.finalContent;\n\n        return false;\n    }\n\n    /**\n     * Will find a widget on an Element\n     * @param {HTMLElement} element\n     * @returns {Widget|undefined}\n     */\n    static findWidget(element) {\n        return element ? element.hfWidgetInstance : undefined;\n    }\n\n    /**\n     * Checks if a given object is an instance\n     * @param {Object} self\n     * @returns {boolean}\n     */\n    static isWidget(self) {\n        return self instanceof Widget || typeof self === 'object' && self.hasOwnProperty('_isWidget');\n    }\n}\n\nexport default Widget;\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/Widget.js","import Settings from '../util/Settings';\nimport debounce from './debounce';\nimport Event from '../util/Event';\nimport Util from '../util/Util';\n\nconst CLS_FIXED_WINDOW = 'fixed-window-open';\n\nexport const EVENT_BEFORE_FIXED_ADD = 'flexcss.fixedWindow.beforeAdd';\nexport const EVENT_AFTER_FIXED_REMOVE = 'flexcss.fixedWindow.afterRemove';\n\n/**\n * @type {string}\n */\nexport const ALLOW_ELEMENT_OVERFLOW_TOUCH = 'data-overflow';\n\n/**\n * @type {FixedWindow}\n */\nlet fixedWindowInstance;\n\nexport default class FixedWindow {\n\n    constructor() {\n        this.widgets = [];\n        this.currentScrollTop = 0;\n        this.fixedScreenConstraints = [];\n        this.windowWidth = 0;\n        this.isFixedWindowActive = false;\n        this.touchListener = null;\n    }\n\n    /**\n     * Adds a constraint to detect if the window needs to be changed when the screensize changes\n     *\n     * @param {Function} widget\n     * @param {Function} fixedBreakpointFn gets a width argument, return true to open a window\n     */\n    addScreenConstraint(widget, fixedBreakpointFn) {\n        this.fixedScreenConstraints[widget] = fixedBreakpointFn;\n    }\n\n    /**\n     * @returns {null|DestroyableWidget}\n     */\n    getCurrentWidget() {\n        return this.widgets.length > 0 ? this.widgets[this.widgets.length - 1] : null;\n    }\n\n    getLastFixedWidget() {\n        let length = this.widgets.length;\n        let widget = null;\n        while (length > 0) {\n            const thisWidget = this.widgets[length - 1];\n            if (thisWidget.fixed) {\n                widget = thisWidget;\n                break;\n            }\n            length--;\n        }\n        return widget;\n    }\n\n    /**\n     * @private\n     */\n    _checkFixedNeeded() {\n        if (this.widgets.length === 0) {\n            return;\n        }\n        const widgets = new Set(this.widgets);\n        const widgetsThatRequireFixedWindow = Array.from(widgets).some(el => {\n            const { widget } = el;\n            const isFixed = this.fixedScreenConstraints[widget] &&\n              this.fixedScreenConstraints[widget](this.windowWidth, this.getCurrentWidget());\n            const index = this.widgets.indexOf(el);\n            this.widgets[index] = Object.assign(el, { fixed: isFixed });\n            return isFixed;\n        });\n        if (!widgetsThatRequireFixedWindow) {\n            this._removeFixedContainer();\n        } else {\n            this._addFixedContainer();\n        }\n    }\n\n    /**\n     * @private\n     */\n    _addFixedContainer() {\n        if (this.isFixedWindowActive) {\n            return;\n        }\n        Event.dispatchAndFire(global.document, EVENT_BEFORE_FIXED_ADD, {\n            detail: this.getCurrentWidget()\n        });\n        // this causes layout and should be optimized\n        // At lest we write in a batch later\n        Settings.get().scrollbarUpdateNodes.map((n) => {\n            let foundProperty = 'paddingRight';\n            let direction = 1;\n            let node = n;\n            if (n instanceof Array) {\n                const [whatNode, property, d] = n;\n                foundProperty = property;\n                node = whatNode;\n                direction = d || 1;\n            }\n            return {\n                node,\n                property: foundProperty,\n                value: `${parseInt(global.getComputedStyle(node)[foundProperty], 10) +\n                (!node.__fixedWindowMod__ ? (Settings.getScrollbarWidth() * direction) : 0)}px`\n            };\n        }).forEach((d) => {\n            d.node.__fixedWindowMod__ = true;\n            d.node.style[d.property] = d.value;\n        });\n\n        this.touchListener = (e) => {\n            e.preventDefault();\n        };\n\n        let shouldNotMoveUp = false;\n        let shouldNotMoveDown = false;\n        let neverScroll = false;\n        let lastClientY = 0;\n        this.touchStartListener = (e) => {\n            let { element } = this.getLastFixedWidget();\n            const closestOverflow = Util.closestCallback(e.target,\n              (el) => el instanceof HTMLTextAreaElement ||\n              (el.hasAttribute && el.hasAttribute(ALLOW_ELEMENT_OVERFLOW_TOUCH)));\n            if (closestOverflow && closestOverflow.scrollHeight !== closestOverflow.offsetHeight) {\n                element = closestOverflow;\n            }\n            if (Util.isPartOfNode(e.target, element)) {\n                neverScroll = element.scrollHeight === element.offsetHeight;\n                lastClientY = e.touches[0].clientY;\n                // never allow scrolling when there is nothing to scroll\n                if (neverScroll) {\n                    return false;\n                }\n                if (element.scrollTop === 0) {\n                    shouldNotMoveUp = true;\n                } else if (element.scrollHeight === element.scrollTop + element.offsetHeight) {\n                    shouldNotMoveDown = true;\n                }\n            }\n        };\n\n        global.addEventListener('touchmove', this.touchListener);\n        global.document.body.addEventListener('touchstart', this.touchStartListener);\n\n        this.touchMoveListener = (e) => {\n            const { element } = this.getLastFixedWidget();\n            if (Util.isPartOfNode(e.target, element)) {\n                const { clientY } = e.touches[0];\n                const isScrollingDown = (lastClientY - clientY) > 0;\n                lastClientY = clientY;\n                if (neverScroll) {\n                    return false;\n                }\n                if ((!shouldNotMoveDown && isScrollingDown) ||\n                    (shouldNotMoveDown && !isScrollingDown) ||\n                    (!shouldNotMoveDown && !shouldNotMoveUp && !isScrollingDown) ||\n                    (shouldNotMoveDown && shouldNotMoveUp && isScrollingDown)\n                ) {\n                    e.stopImmediatePropagation();\n                }\n            }\n        };\n\n        this.touchEndListener = () => {\n            neverScroll = false;\n            shouldNotMoveUp = false;\n            shouldNotMoveDown = false;\n            lastClientY = 0;\n        };\n\n        global.document.body.addEventListener('touchmove', this.touchMoveListener);\n        global.document.body.addEventListener('touchend', this.touchEndListener);\n        global.document.documentElement.classList.add(CLS_FIXED_WINDOW);\n        this.isFixedWindowActive = true;\n    }\n\n    /**\n     * @private\n     */\n    _removeFixedContainer() {\n        if (this.isFixedWindowActive) {\n            // cleanup event listeners\n            global.removeEventListener('touchmove', this.touchListener);\n            global.document.body.removeEventListener('touchstart', this.touchStartListener);\n            global.document.body.removeEventListener('touchmove', this.touchMoveListener);\n            global.document.body.removeEventListener('touchend', this.touchEndListener);\n\n            // reset scrollbar nodes\n            Settings.get().scrollbarUpdateNodes.forEach((node) => {\n                if (node instanceof Array) {\n                    const [whatNode, property] = node;\n                    delete whatNode.__fixedWindowMod__;\n                    whatNode.style[property] = '';\n                } else {\n                    delete node.__fixedWindowMod__;\n                    node.style.paddingRight = '';\n                }\n            });\n            global.document.documentElement.classList.remove(CLS_FIXED_WINDOW);\n            Event.dispatchAndFire(global.document, EVENT_AFTER_FIXED_REMOVE);\n            this.isFixedWindowActive = false;\n        }\n    }\n\n    /**\n     * Will close a window when no widgets are opened that need one\n     */\n    resizeListener() {\n        this.windowWidth = global.innerWidth;\n        this._checkFixedNeeded();\n    }\n\n    /**\n     * @returns {FixedWindow}\n     */\n    static getInstance() {\n        if (!fixedWindowInstance) {\n            fixedWindowInstance = new FixedWindow();\n            fixedWindowInstance.windowWidth = global.innerWidth;\n            const eventHandler = fixedWindowInstance.resizeListener.bind(fixedWindowInstance);\n            global.addEventListener(\n                'resize',\n                debounce(eventHandler, 500)\n            );\n            global.addEventListener('orientationchange', eventHandler);\n        }\n        return fixedWindowInstance;\n    }\n\n    /**\n     * Request a close of the fixed window\n     */\n    close() {\n        this.widgets.pop();\n        this._checkFixedNeeded();\n        if (this.widgets.length === 0) {\n            this._removeFixedContainer();\n        }\n    }\n\n    /**\n     * Request to open a fixed windows\n     * @param {Object|DestroyableWidget} instance\n     * @param {HTMLElement} element\n     */\n    open(instance, element) {\n        let fixed = false;\n        if (typeof instance === 'object') {\n            const widget = instance.constructor;\n            const fixedWidget = this.fixedScreenConstraints[instance.constructor];\n            if (widget && fixedWidget) {\n                fixed = fixedWidget(this.windowWidth, instance);\n            }\n            this.widgets.push(\n                {\n                    widget,\n                    element,\n                    fixed\n                }\n            );\n            // open a new window if there is no window active\n            if (!this.isFixedWindowActive && fixed) {\n                this._addFixedContainer();\n            }\n        }\n    }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/lib/FixedWindow.js","export default (fn, ms) => (...args) => {\n    clearTimeout(fn.timeout);\n    fn.timeout = setTimeout(fn.bind(this, ...args), ms);\n    return fn.timeout;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/lib/debounce.js","/*\n * The MIT License (MIT)\n *\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n/*!\n * FlexCss.Toggleable\n * Licensed under the MIT License (MIT)\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n */\n\nimport Settings from './util/Settings';\nimport Widget from './Widget';\nimport Util from './util/Util';\nimport Event from './util/Event';\n\n/**\n * Event that is fired when a tab is closed\n * @type {string}\n */\n\nexport const EVENT_TAB_CLOSED = 'flexcss.tab.closed';\n\n/**\n * Event that is fired when a tab has been opened\n * @type {string}\n */\nexport const EVENT_TAB_OPENED = 'flexcss.tab.opened';\n/**\n * @type {string}\n */\nconst ATTR_NAME = 'data-toggle';\n/**\n * @type {string}\n */\nconst ACTIVE_CLASS = 'active';\n/**\n * @type {string}\n */\nconst LOADING_CLASS = 'loading';\n\n/**\n * @type {string}\n */\nconst ATTR_TOGGLE_LIST = 'data-toggle-list';\n\n/**\n * Creates a toggleable element, either for tabs or a single toggle\n */\nclass Toggleable {\n    constructor(ContainerId) {\n        const doc = global.document;\n\n        this.container = ContainerId instanceof HTMLElement ? ContainerId :\n            doc.getElementById(ContainerId);\n\n        this.loading = false;\n\n        if (!this.container) {\n            throw new Error(`Toggleable container with id ${ContainerId} not found`);\n        }\n    }\n\n    /**\n     * Listener\n     * @param {Event} e\n     * @private\n     */\n    _listener(e) {\n        let target = e.target;\n        const parent = target.parentNode;\n        const doc = global.document;\n\n        // support target child element to clicked\n        if (!target.hasAttribute(ATTR_NAME)) {\n            if (parent && parent.hasAttribute(ATTR_NAME)) {\n                target = parent;\n            } else {\n                return;\n            }\n        }\n\n        if (!target.hasAttribute(ATTR_NAME)) {\n            return;\n        }\n\n        const refId = target.getAttribute(ATTR_NAME);\n        const ref = doc.getElementById(refId);\n\n        e.preventDefault();\n\n        if (this.loading) {\n            return;\n        }\n\n        this.toggleTarget(ref, target);\n    }\n\n    /**\n     * Registers Events for this instance\n     * @returns {Toggleable}\n     */\n    registerEvents() {\n        this.container.addEventListener(Settings.getTabEvent(), this._listener.bind(this));\n        return this;\n    }\n\n    /**\n     * Toggles given `ref`\n     * @param {HTMLElement|Node} ref\n     * @param {HTMLElement|Node} [selfTarget] optional target node\n     */\n    toggleTarget(ref, selfTarget) {\n        let target = selfTarget;\n        if (!target && !ref) {\n            return;\n        }\n        if (!target) {\n            target = document.querySelector(`[${ATTR_NAME}=\"${ref.id}\"]`);\n        }\n\n        let future;\n        const elClassList = target.classList;\n        const parent = target.parentNode;\n        const doc = global.document;\n\n        future = new Promise((resolve, failure) => {\n            if (ref) {\n                resolve(ref);\n            } else {\n                const widget = Widget.findWidget(target);\n                const async = widget ? widget.getAsync() : null;\n                if (Widget.isWidget(widget) && async) {\n                    future = async.then((r) => {\n                        if (r instanceof HTMLElement) {\n                            const id = Util.guid();\n                            r.id = id;\n                            target.setAttribute(ATTR_NAME, id);\n                            resolve(r);\n                        } else {\n                            throw new Error(`Dynamically creating toggle-content is not supported right now.\n                            Return an HTMLElement instance`);\n                        }\n                    });\n                } else {\n                    failure('Target not given');\n                }\n            }\n        });\n\n        if (parent) {\n            const maybeToggleNode = Util.parentsUntil(target, (node) => {\n                return node && node.hasAttribute && node.hasAttribute(ATTR_TOGGLE_LIST);\n            });\n\n            const parentClassList = parent.classList;\n            // Abort if element is already active and if is part of a toggle list\n            if (maybeToggleNode) {\n                if (!parentClassList.contains(ACTIVE_CLASS)) {\n                    parentClassList.toggle(ACTIVE_CLASS);\n                    parentClassList.add(LOADING_CLASS);\n                } else {\n                    return;\n                }\n            }\n\n            if (maybeToggleNode) {\n                for (let i = 0; i < maybeToggleNode.children.length; i++) {\n                    const n = maybeToggleNode.children[i];\n                    const targetRef = n.children[0];\n                    if (n !== parent) {\n                        n.classList.remove(ACTIVE_CLASS);\n                        if (targetRef) {\n                            const attr = targetRef.getAttribute(ATTR_NAME);\n                            const el = attr ? doc.getElementById(attr) : null;\n                            if (el) {\n                                Event.dispatchAndFire(el, EVENT_TAB_CLOSED);\n                                el.classList.remove(ACTIVE_CLASS);\n                                targetRef.classList.remove(ACTIVE_CLASS);\n                            }\n                        }\n                    }\n                }\n            }\n        }\n        if (elClassList) {\n            elClassList.toggle(ACTIVE_CLASS);\n            elClassList.add(LOADING_CLASS);\n        }\n        this.loading = true;\n        future.then((r) => {\n            Event.dispatchAndFire(r, EVENT_TAB_OPENED);\n            Toggleable._handleLoaded(target);\n            r.classList.toggle(ACTIVE_CLASS);\n            this.loading = false;\n        }).catch(() => {\n            this.loading = false;\n            Toggleable._handleLoaded(target);\n        });\n    }\n\n    /**\n     * @param el\n     * @private\n     */\n    static _handleLoaded(el) {\n        const parentClassList = el.parentNode.classList;\n        el.classList.remove(LOADING_CLASS);\n        if (parentClassList) {\n            parentClassList.remove(LOADING_CLASS);\n        }\n    }\n}\n\nexport default Toggleable;\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/Toggleable.js","/*\n * The MIT License (MIT)\n *\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n/*!\n * FlexCss.OffCanvas\n * Licensed under the MIT License (MIT)\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n */\n\nimport Settings from './util/Settings';\nimport Util from './util/Util';\nimport Event from './util/Event';\nimport FixedWindow from './lib/FixedWindow';\n\n/**\n * @type {string}\n */\nconst ATTR_CLOSE_SIDEBAR = 'data-close-offcanvas';\n\n/**\n * @type {string}\n */\nconst ATTR_TARGET = 'data-offcanvas';\n/**\n * @type {string}\n */\nconst INIT_CLASS = 'init';\n/**\n * @type {string}\n */\nconst OPEN_CLASS = 'open';\n/**\n * @type {number}\n */\nconst HIDE_FACTOR = 3;\n\n/**\n * @type {string}\n */\nexport const EVENT_TOGGLE = 'flexcss.offcanvas.toggle';\n\n/**\n * A OffCanvas Implementation\n */\nclass OffCanvas {\n\n    /**\n     * Creates an off-canvas navigation\n     * @param {HTMLElement|String} NavigationId\n     * @param {HTMLElement|String} Darkener\n     * @param {int} factor positive will expect right sidebar, positive left\n     * @param {bool} [disableTouch] if true all touch events are disabled\n     * @constructor\n     */\n    constructor(NavigationId, Darkener, factor, disableTouch) {\n        const doc = global.document;\n        let touchedX = 0;\n        const navigationContainer = NavigationId instanceof HTMLElement ?\n            NavigationId : doc.getElementById(NavigationId);\n        const darkener = Darkener instanceof HTMLElement ? Darkener : doc.getElementById(Darkener);\n        const DARKENER_CLASS_TOGGLE = `toggle-${darkener.id}` || 'darkener';\n        const DARKENER_CLASS_INSTANT_TOGGLE = `${DARKENER_CLASS_TOGGLE}-open`;\n\n        const shouldNotTouch = () => {\n            return window.innerWidth >= Settings.get().touchMoveBreakpointOffCanvas;\n        };\n\n        if (!darkener || !navigationContainer) {\n            throw new Error('Could not find needed elements (Darkener and/or NavigationId)');\n        }\n\n        this.darkener = darkener;\n        this.darkenerClassToggle = DARKENER_CLASS_TOGGLE;\n        this.darkenerClassToggleInstant = DARKENER_CLASS_INSTANT_TOGGLE;\n        this.globalToggleClass = Settings.get().canvasToggledClass;\n\n        this.navigationContainer = navigationContainer;\n        this.navigationContainerId = navigationContainer.id;\n\n        // create id if id does not exist\n        if (!this.navigationContainerId) {\n            this.navigationContainerId = Util.guid();\n            navigationContainer.id = this.navigationContainerId;\n        }\n\n        if (!disableTouch) {\n            navigationContainer.addEventListener('touchstart', (e) => {\n                if (shouldNotTouch()) {\n                    return;\n                }\n                touchedX = e.touches[0].clientX;\n                navigationContainer.mustHide = false;\n            });\n            navigationContainer.addEventListener('touchmove', (e) => {\n                if (shouldNotTouch()) {\n                    return;\n                }\n                const { clientX } = e.touches[0];\n                const target = navigationContainer;\n                const style = target.style;\n                const calcX = touchedX - clientX;\n                const bounds = target.getBoundingClientRect();\n                const compare = factor > 0 ? calcX <= 0 : calcX >= 0;\n                if (compare) {\n                    style.transition = 'transform 0s ease';\n                    style.webkitTransition = '-webkit-transform 0s ease';\n                    target.mustHide = factor > 0 ? calcX * -1 >\n                    bounds.width / HIDE_FACTOR : calcX > bounds.width / HIDE_FACTOR;\n                    const transform = `translate3d(${calcX * -1}px,0,0)`;\n                    style.transform = transform;\n                    style.webkitTransform = transform;\n                }\n            });\n            navigationContainer.addEventListener('touchend', () => {\n                if (shouldNotTouch()) {\n                    return;\n                }\n                const target = navigationContainer;\n                const style = target.style;\n                if (target.mustHide) {\n                    const width = target.getBoundingClientRect().width * factor;\n                    style.transition = 'transform .2s ease';\n                    style.webkitTransition = '-webkit-transform .2s ease';\n                    const transform = `translate3d(${width}px,0,0)`;\n                    style.transform = transform;\n                    style.webkitTransform = transform;\n                    this._remove().then(() => {\n                        this.resetTransform(style);\n                    });\n                    this._removeInstant();\n                } else {\n                    this.resetTransform(style);\n                }\n            });\n        }\n    }\n\n    /**\n     * @param {Object} s\n     */\n    resetTransform(s) {\n        s.transform = '';\n        s.transition = '';\n        s.webkitTransform = '';\n        s.webkitTransition = '';\n    }\n\n    /**\n     * @param {Object} [event]\n     * @private\n     */\n    _remove(event) {\n        return new Promise((resolve) => {\n            Util.addEventOnce(Settings.getTransitionEvent(), this.navigationContainer, function scheduler(e) {\n                if (e.target !== this.navigationContainer) {\n                    return Util.addEventOnce(Settings.getTransitionEvent(),\n                        this.navigationContainer, scheduler.bind(this));\n                }\n                requestAnimationFrame(() => {\n                    OffCanvas.currentOpen = null;\n                    const docCls = global.document.documentElement.classList;\n                    docCls.remove(this.darkenerClassToggle);\n                    docCls.remove(this.globalToggleClass);\n                    if (!!event) {\n                        Event.dispatchAndFire(this.navigationContainer, EVENT_TOGGLE);\n                    }\n                    resolve();\n                });\n            }.bind(this));\n        });\n    }\n\n    /**\n     * @private\n     */\n    _removeInstant() {\n        this.navigationContainer.classList.remove(OPEN_CLASS);\n        global.document.documentElement.classList.remove(this.darkenerClassToggleInstant);\n        this.darkener.classList.remove(INIT_CLASS);\n        FixedWindow.getInstance().close();\n    }\n\n    /**\n     * Toggles a an off-canvas element\n     * @param [e]\n     * @private\n     */\n    toggle(e) {\n        if (e) {\n            e.preventDefault();\n        }\n        this.resetTransform(this.navigationContainer.style);\n        const darkenerClass = this.darkener.classList;\n        const DARKENER_CLASS_TOGGLE = this.darkenerClassToggle;\n        const DARKENER_CLASS_INSTANT_TOGGLE = this.darkenerClassToggleInstant;\n        const navigationControllerClassList = this.navigationContainer.classList;\n        if (!OffCanvas.currentOpen) {\n            Util.addEventOnce(Settings.getTransitionEvent(), this.navigationContainer, () => {\n                if (!!e) {\n                    Event.dispatchAndFire(this.navigationContainer, EVENT_TOGGLE);\n                }\n            });\n            OffCanvas.currentOpen = this;\n            FixedWindow.getInstance().open(this, this.navigationContainer);\n            const docElementCls = global.document.documentElement.classList;\n            docElementCls.add(this.globalToggleClass);\n            docElementCls.add(DARKENER_CLASS_INSTANT_TOGGLE);\n            docElementCls.add(DARKENER_CLASS_TOGGLE);\n            darkenerClass.add(INIT_CLASS);\n            navigationControllerClassList.add(OPEN_CLASS);\n        } else {\n            return this.close(e);\n        }\n    }\n\n    close(event) {\n        if (this.navigationContainer.classList.contains(OPEN_CLASS)) {\n            const promise = this._remove(event);\n            this._removeInstant();\n            return promise;\n        }\n        return new Promise(r => r());\n    }\n\n    /**\n     * Register events\n     * @param [delegate]\n     */\n    registerEvents(delegate) {\n        const thisDelegate = delegate || global.document;\n        FixedWindow.getInstance().addScreenConstraint(OffCanvas, (width) => width < Settings.get().smallBreakpoint);\n        thisDelegate.addEventListener(Settings.getTabEvent(), (e) => {\n            if (OffCanvas.currentOpen && OffCanvas.currentOpen !== this) {\n                return;\n            }\n            const id = this.navigationContainerId;\n            const validTarget = e.target.getAttribute(ATTR_TARGET) === id;\n            if (!Util.isPartOfNode(e.target, this.navigationContainer)) {\n                if (validTarget || (OffCanvas.currentOpen === this && e.target === this.darkener)) {\n                    this.toggle(e);\n                }\n            } else {\n                if (e.target.hasAttribute(ATTR_CLOSE_SIDEBAR)) {\n                    this.toggle(e);\n                }\n            }\n        });\n    }\n}\n\nOffCanvas.currentOpen = null;\n\nexport default OffCanvas;\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/OffCanvas.js","/*\n * The MIT License (MIT)\n *\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n/*!\n * FlexCss.Dropdown\n * Licensed under the MIT License (MIT)\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n */\n\nimport Util from './util/Util';\nimport Settings from './util/Settings';\nimport Event from './util/Event';\nimport Widget from './Widget';\nimport FixedWindow from './lib/FixedWindow';\n\n/**\n * @type {string}\n */\nconst ATTR_CC = 'data-collision-container';\n/**\n * @type {string}\n */\nconst ATTR_DARKENER = 'data-darkener-container';\n/**\n * @type {string}\n */\nconst ATTR_ENABLE_EVENT_BUBBLE = 'data-enable-event-bubble';\n/**\n * @type {string}\n */\nconst DARKENER_INIT = 'init';\n/**\n * @type {string}\n */\nconst ATTR_DATA_TARGET = 'data-target';\n/**\n * @type {string}\n */\nconst ATTR_CLOSE_DROPDOWN = 'data-close-dropdown';\n/**\n * @type {string}\n */\nconst ATTR_NAME = 'data-dropdown';\n/**\n * @type {string}\n */\nconst STATE_LOADING = 'loading';\n\nconst CLS_DARKENER_DROPDOWN = 'darkener-dropdown';\n/**\n * @type {string}\n */\nconst CLS_OPEN = 'open';\n\n/**\n * @type {string}\n */\nconst CLS_DROPDOWN = 'dropdown';\n\n/**\n * @type {string}\n */\nexport const EVENT_DROPDOWN_CLOSED = 'flexcss.dropdown.closed';\n\n/**\n * A Dropdown\n */\nclass Dropdown {\n    constructor(DelegateContainer, Darkener) {\n        const doc = global.document;\n\n        /**\n         * Container Element\n         * @type {HTMLElement}\n         */\n        this.container = DelegateContainer instanceof HTMLElement ?\n            DelegateContainer : doc.getElementById(DelegateContainer);\n\n        this.currentOpen = null;\n        this.currentTarget = null;\n        /**\n         * @type {HTMLElement}\n         */\n        this.darkener = Darkener instanceof HTMLElement ? Darkener : document.getElementById(Darkener);\n\n        this.destroyOnClose = false;\n\n        if (!this.darkener || !this.container) {\n            throw new Error('required elements not found (darkener and container element)');\n        }\n    }\n\n    /**\n     * Method that handles delegation events for dropdowns\n     * @param e\n     * @returns {boolean}\n     * @private\n     */\n    _delegateFunction(e) {\n        const currentOpen = this.currentOpen;\n        const target = Util.closestCallback(e.target, n => n instanceof HTMLElement && n.hasAttribute(ATTR_NAME));\n        const targetIsCurrent = target === this.currentTarget;\n\n        if (currentOpen && !Util.isPartOfNode(e.target, currentOpen) || targetIsCurrent) {\n            this.close();\n            if (targetIsCurrent) {\n                e.preventDefault();\n            }\n            return targetIsCurrent ? false : this._delegateFunction(e);\n        }\n\n        if (target && !currentOpen) {\n            if (!target.getAttribute(ATTR_ENABLE_EVENT_BUBBLE)) {\n                e.preventDefault();\n                e.stopImmediatePropagation();\n            }\n\n            if (target.isLoading) {\n                return false;\n            }\n            this.createDropdown(target);\n        } else {\n            if (currentOpen) {\n                if (e.target.hasAttribute(ATTR_CLOSE_DROPDOWN)) {\n                    if (!e.target.getAttribute(ATTR_ENABLE_EVENT_BUBBLE)) {\n                        e.preventDefault();\n                    }\n                    this.close();\n                }\n                if (!Util.isPartOfNode(e.target, currentOpen)) {\n                    this.close();\n                }\n            }\n        }\n    }\n\n    /**\n     * Register Events for this dropdown container\n     * @returns {Dropdown}\n     */\n    registerEvents() {\n        FixedWindow.getInstance().addScreenConstraint(Dropdown, (width) => width < Settings.get().smallBreakpoint);\n        this.container.addEventListener(Settings.getTabEvent(), this._delegateFunction.bind(this), true);\n        return this;\n    }\n\n    /**\n     * Destroys this instance, unbinds events\n     * @returns {Dropdown}\n     */\n    destroy() {\n        this.container.removeEventListener(Settings.getTabEvent(), this._delegateFunction.bind(this), true);\n        return this;\n    }\n\n\n    /**\n     * Destroys instance on close of dropdown\n     * @param v\n     * @returns {Dropdown}\n     */\n    setDestroyOnClose(v) {\n        this.destroyOnClose = v;\n        return this;\n    }\n\n\n    /**\n     * Will add the right class to container for specific darkener id\n     * @param instance\n     * @param show\n     */\n    toggleDarkenerToggler(instance, show) {\n        const cls = `toggle-${(instance.id || CLS_DARKENER_DROPDOWN)}`;\n        const classList = this.container.classList;\n        if (show) {\n            classList.add(cls);\n        } else {\n            classList.remove(cls);\n        }\n    }\n\n    /**\n     * Closes Dropdown on current instance\n     * @return {Boolean|Promise}\n     */\n    close() {\n        const currentOpen = this.currentOpen;\n        if (!currentOpen) {\n            return false;\n        }\n        const darkenerInstance = currentOpen.flexDarkenerInstance || this.darkener;\n        const thisCurrentOpen = currentOpen;\n\n        const future = new Promise((resolve) => {\n            if (window.getComputedStyle(currentOpen).position === 'fixed') {\n                Util.addEventOnce(Settings.getTransitionEvent(), currentOpen, function scheduler(e) {\n                    if (e.target !== currentOpen) {\n                        return Util.addEventOnce(Settings.getTransitionEvent(), currentOpen, scheduler.bind(this));\n                    }\n                    requestAnimationFrame(() => {\n                        Event.dispatchAndFire(thisCurrentOpen, EVENT_DROPDOWN_CLOSED);\n                        // if a new dropdown has been opened in the meantime, do not remove darkener\n                        if (this.currentOpen !== null) {\n                            return false;\n                        }\n                        this.toggleDarkenerToggler(darkenerInstance, false);\n                        resolve(true);\n                    });\n                }.bind(this));\n            } else {\n                resolve(true);\n                Event.dispatchAndFire(thisCurrentOpen, EVENT_DROPDOWN_CLOSED);\n            }\n        });\n\n        FixedWindow.getInstance().close();\n        currentOpen.classList.remove(CLS_OPEN);\n\n        if (currentOpen.flexDarkenerInstance) {\n            currentOpen.flexDarkenerInstance.classList.remove(DARKENER_INIT);\n        } else {\n            this.darkener.classList.remove(DARKENER_INIT);\n        }\n\n        this.currentOpen = null;\n        this.currentTarget = null;\n\n        if (this.destroyOnClose) {\n            this.destroy();\n        }\n\n        return future;\n    }\n\n    /**\n     * Creates a dropdown on given target and opens it\n     * @param {HTMLElement} target target where this dropdown is placed\n     * @param {FlexCss.Widget} [thisWidget] if given will use widget instead of widget instance\n     * @return {FlexCss.Dropdown}\n     */\n    createDropdown(target, thisWidget) {\n        const doc = global.document;\n\n        if (!target) {\n            throw new Error('Dropdown target not found');\n        }\n\n        const widget = thisWidget || Widget.findWidget(target);\n        let future;\n        const data = target.getAttribute(ATTR_NAME);\n        const dropdownContainerElement = doc.getElementById(data);\n        const async = !dropdownContainerElement && Widget.isWidget(widget) ? widget.getAsync() : false;\n\n        if (async) {\n            target.classList.add(STATE_LOADING);\n            target.isLoading = true;\n            future = async.then((r) => {\n                if (r instanceof HTMLElement) {\n                    if (r.id) {\n                        target.setAttribute(ATTR_NAME, r.id);\n                    }\n                    return r;\n                }\n                // Create container Element:\n                const element = doc.createElement('div');\n                element.className = CLS_DROPDOWN;\n                element.innerHTML = r;\n                element.id = Util.guid();\n                // Cache target for later use:\n                target.setAttribute(ATTR_NAME, element.id);\n                this.container.appendChild(element);\n                return element;\n            }).then((r) => {\n                target.isLoading = false;\n                target.classList.remove(STATE_LOADING);\n                return r;\n            });\n        } else {\n            if (!dropdownContainerElement) {\n                throw new Error(`Could not found Dropdown container with ID \"${data}\"`);\n            }\n            future = new Promise((r) => {\n                r(dropdownContainerElement);\n            });\n        }\n\n        future.then((dropdownContent) => {\n            if (this.currentOpen) {\n                this.close();\n            }\n            // Skip one frame to show animation\n            target.dropdownContent = dropdownContent;\n            const isAbsolute = global.getComputedStyle(dropdownContent).position === 'absolute';\n            dropdownContent.hfWidgetInstance = this;\n\n            if (!target.flexCollisionContainer) {\n                const collisionC = target.getAttribute(ATTR_CC);\n                target.flexCollisionContainer = collisionC ?\n                doc.getElementById(collisionC) || document.documentElement : document.documentElement;\n            }\n\n            dropdownContent.classList.toggle(CLS_OPEN);\n            if (dropdownContent.classList.contains(CLS_OPEN)) {\n                this.currentOpen = dropdownContent;\n                this.currentTarget = target;\n            }\n            FixedWindow.getInstance().open(this, dropdownContent);\n            if (isAbsolute) {\n                // Check collision:\n                let selfTarget = target.getAttribute(ATTR_DATA_TARGET);\n                selfTarget = selfTarget ? doc.getElementById(selfTarget) : target;\n                Util.setupPositionNearby(selfTarget, dropdownContent, target.flexCollisionContainer);\n            } else {\n                // optionally get custom darkener container for target\n                const d = target.getAttribute(ATTR_DARKENER);\n                if (d) {\n                    dropdownContent.flexDarkenerInstance = doc.getElementById(d);\n                    (dropdownContent.flexDarkenerInstance || this.darkener).classList.toggle(DARKENER_INIT);\n                } else {\n                    this.darkener.classList.toggle(DARKENER_INIT);\n                }\n                this.toggleDarkenerToggler(dropdownContent.flexDarkenerInstance || this.darkener, true);\n\n                dropdownContent.style.left = '0';\n                dropdownContent.style.top = 'auto';\n            }\n        });\n    }\n\n}\n\nexport default Dropdown;\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/Dropdown.js","/*\n * The MIT License (MIT)\n *\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n/*!\n * FlexCss.LightBox\n * Licensed under the MIT License (MIT)\n * Copyright (c) 2015 David Heidrich, BowlingX <me@bowlingx.com>\n */\n\n/* global Image, TouchEvent*/\n\nimport Modal, { EVENT_MODAL_CLOSED } from './Modal';\nimport Settings from './util/Settings';\nimport Widget from './Widget';\n\nconst ATTR_MAX_WIDTH = 'data-original-width';\nconst ATTR_MAX_HEIGHT = 'data-original-height';\nconst ATTR_SRC = 'data-src';\n\nconst CLS_HAS_PREV = 'has-prev';\nconst CLS_HAS_NEXT = 'has-next';\nconst CLS_LOADING = 'loading';\n\nconst ATTR_NO_THUMBNAIL = 'data-no-thumbnail';\nconst ATTR_DATA_HREF = 'data-href';\nconst ATTR_HREF = 'href';\n\nconst KEY_NEXT = 39;\nconst KEY_PREV = 37;\nconst ATTR_CLOSE = 'data-close-modal';\n/**\n * A Simple LightBox\n */\nclass LightBox {\n\n    /**\n     * Creates a new Lightbox\n     * @param DelegateContainer\n     * @param AttributeSelector\n     * @param ModalAppend\n     * @param [options]\n     */\n    constructor(DelegateContainer, AttributeSelector, ModalAppend, options) {\n        const thisDelegateContainer = DelegateContainer instanceof HTMLElement ? DelegateContainer :\n            document.getElementById(DelegateContainer);\n\n        this._modalAppend = ModalAppend || DelegateContainer;\n        /**\n         * @type {Function}\n         */\n        this._resizeEvent = null;\n        /**\n         * @type {Function}\n         */\n        this._keyboardNextEvent = null;\n        /**\n         * @type {Promise}\n         */\n        this._future = null;\n        /**\n         * @type {Promise}\n         */\n        this._nextFuture = this._future;\n        /**\n         * @type {HTMLElement}\n         */\n        this._imageContainer = null;\n        /**\n         * @type {HTMLElement}\n         */\n        this._modalContainerDiv = null;\n        /**\n         * @type {HTMLElement}\n         */\n        this._contentContainer = null;\n        /**\n         * @type {HTMLElement}\n         */\n        this._closerContainerDiv = null;\n        /**\n         * @type {HTMLElement}\n         */\n        this._delegateContainer = thisDelegateContainer;\n        /**\n         * @type {HTMLElement}\n         */\n        this._attributeSelector = AttributeSelector;\n        /**\n         * @type {Widget}\n         */\n        this._widget = null;\n        /**\n         * @type {boolean}\n         */\n        this._isOpen = false;\n        /**\n         * @type {HTMLElement}\n         */\n        this.target = null;\n        /**\n         * @type {HTMLElement}\n         */\n        this.img = null;\n        /**\n         * @type {boolean}\n         */\n        this._isLoading = false;\n\n        /**\n         * Default options\n         */\n        this.options = {\n            // set if prev and next should be available\n            registerPrevNextEvents: true,\n            // set if modal should be closed after last image\n            closeOnLast: true,\n            // called when next image is requested (either by keyboard or click), return false to abort\n            onNext: () => {\n                return true;\n            },\n            onClose: () => {\n            },\n            getNext: null,\n            getPrev: null,\n            // called when underlying target changed\n            onSwitchImage: () => {\n            }\n        };\n\n        Object.assign(this.options, options);\n    }\n\n    /**\n     * @param {HTMLElement} node\n     * @returns {HTMLElement|null}\n     */\n    findImmediateNextTarget(node) {\n        if (node && node.children[0].hasAttribute(this._attributeSelector)) {\n            return node.children[0];\n        }\n        return null;\n    }\n\n    /**\n     * Will fetch the next element of a lightBox\n     * @param {HTMLElement} target\n     * @returns {null|HTMLElement}\n     */\n    getNext(target) {\n        if (this.options.getNext) {\n            return this.options.getNext.apply(this, [target]);\n        }\n        return this.findImmediateNextTarget(target.parentNode.nextElementSibling);\n    }\n\n    /**\n     * Will fetch the previous element of a lightBox\n     * @param {HTMLElement} target\n     * @returns {null|HTMLElement}\n     */\n    getPrev(target) {\n        if (this.options.getPrev) {\n            return this.options.getPrev.apply(this, [target]);\n        }\n        return this.findImmediateNextTarget(target.parentNode.previousElementSibling);\n    }\n\n    /**\n     * Registers events for delegate container\n     */\n    registerEvents(onOpen) {\n        this._delegateContainer.addEventListener(Settings.getTabEvent(), (e) => {\n            let target = e.target;\n            const parent = target.parentNode;\n            let validTarget = target.hasAttribute(this._attributeSelector);\n            const parentIsValid = parent && parent.hasAttribute(this._attributeSelector);\n\n            if (!validTarget && parentIsValid) {\n                validTarget = true;\n                target = parent;\n            }\n            if (validTarget) {\n                e.preventDefault();\n                this.open(target).then((r) => {\n                    if (onOpen) {\n                        onOpen.apply(this, [r, target]);\n                    }\n                });\n            }\n        });\n    }\n\n    /**\n     * @returns {HTMLElement}\n     */\n    getContentContainer() {\n        return this._contentContainer;\n    }\n\n    /**\n     * Setup max-width and max-height\n     * @param {HTMLElement} target\n     * @param {HTMLElement} img\n     * @param {HTMLElement} loadedImage\n     * @private\n     */\n    static _setupMaxWidthHeight(target, img, loadedImage) {\n        const nextMaxWidth = target.getAttribute(ATTR_MAX_WIDTH);\n        const nextMaxHeight = target.getAttribute(ATTR_MAX_HEIGHT);\n        if (nextMaxWidth && nextMaxHeight) {\n            img.style.maxWidth = nextMaxWidth + \"px\";\n            img.style.maxHeight = nextMaxHeight + \"px\";\n        } else {\n            img.style.maxWidth = loadedImage.width + \"px\";\n            img.style.maxHeight = loadedImage.height + \"px\";\n        }\n    }\n\n    /**\n     * Switches to the next image\n     * @param {boolean} direction\n     */\n    switchImageByDirection(direction) {\n        const next = direction ? this.getPrev(this.target) : this.getNext(this.target);\n        if (this.options.onNext.apply(this, [next])) {\n            return this.switchImage(next);\n        }\n        return new Promise((_, reject) => reject(next));\n    }\n\n    /**\n     * Checks if lightbox is currently loading\n     * @returns {boolean}\n     */\n    isLoading() {\n        return this._isLoading;\n    }\n\n    /**\n     * Checks if modal should be closed\n     * @private\n     */\n    _runOptionalClose() {\n        if (this.options.closeOnLast) {\n            this.modal.close();\n        }\n    }\n\n    _setupPrevNextStates() {\n        const target = this.target;\n        const hasPrev = this.getPrev(target);\n        const hasNext = this.getNext(target);\n        const hasPrevClass = CLS_HAS_PREV;\n        const hasNextClass = CLS_HAS_NEXT;\n        // because IE does not support the second toggle parameter, we need to do this manually\n        if (hasPrev) {\n            this._imageContainer.classList.add(hasPrevClass);\n        } else {\n            this._imageContainer.classList.remove(hasPrevClass);\n        }\n        if (hasNext) {\n            this._imageContainer.classList.add(hasNextClass);\n        } else {\n            this._imageContainer.classList.remove(hasNextClass);\n        }\n    }\n\n    /**\n     * @param img\n     * @private\n     */\n    _calculateContainer(img) {\n        if (Settings.isIE()) {\n            setTimeout(() => {\n                this._imageContainer.style.height = img.offsetHeight + 'px';\n            }, 0);\n        }\n    }\n\n    /**\n     * Switch to a specific image\n     * @param next\n     * @returns {*}\n     */\n    switchImage(next) {\n        const self = this;\n        const img = this.img;\n        this._isLoading = true;\n        self._nextFuture = new Promise((resolve, reject) => {\n            // notify observers about image switching\n            self.options.onSwitchImage.apply(self, [self._nextFuture]);\n            if (next) {\n                const nextThumb = next.hasAttribute(ATTR_NO_THUMBNAIL) ? next : (next.children[0] || next);\n                const nextHighRes = next.getAttribute(ATTR_DATA_HREF) ||\n                        next.getAttribute(ATTR_HREF);\n                const nextSource = nextThumb.getAttribute(ATTR_SRC) || nextThumb.src || nextHighRes;\n                const nextImgObject = new Image();\n\n                if (!nextSource) {\n                    reject(next);\n                    return;\n                }\n                // set new target to next element\n                this.target = next;\n                nextImgObject.src = nextSource;\n                self._imageContainer.classList.add(CLS_LOADING);\n                nextImgObject.addEventListener('load', () => {\n                    img.src = nextSource;\n                    self._imageContainer.style.backgroundImage = 'url(' + nextSource + ')';\n                    LightBox._setupMaxWidthHeight(next, img, nextImgObject);\n                    self._calculateContainer(img);\n                    self.highRes(nextThumb, nextHighRes);\n                    self._setupPrevNextStates();\n                    self._imageContainer.classList.remove(CLS_LOADING);\n                    this._isLoading = false;\n                    resolve(nextSource, this.target);\n                });\n            } else {\n                reject(this);\n            }\n        });\n        return self._nextFuture;\n    }\n\n\n    /**\n     * Setup High-Resolution picture\n     * @param {HTMLElement} thisThumbnail\n     * @param {String} thisImgHighResolution\n     */\n    highRes(thisThumbnail, thisImgHighResolution) {\n        if (thisImgHighResolution && thisThumbnail.src !== thisImgHighResolution) {\n            const highImageObj = new Image();\n            highImageObj.src = thisImgHighResolution;\n            highImageObj.addEventListener('load', () => {\n                // if current image is still available\n                if (this._getSrc(thisThumbnail) === this.img.src) {\n                    this.img.src = thisImgHighResolution;\n                    this._imageContainer.style.backgroundImage = 'url(' + thisImgHighResolution + ')';\n                }\n            });\n        }\n    }\n\n    /**\n     * Extracts the source of an image\n     * @param target\n     * @returns {String|null}\n     * @private\n     */\n    _getSrc(target) {\n        return target.getAttribute(ATTR_SRC) || target.src;\n    }\n\n    /**\n     * Will show a lightBox on given target\n     * @param {HTMLElement} target\n     * @returns {$.Deferred|*}\n     */\n    open(target) {\n        const self = this;\n\n        if (!target) {\n            return false;\n        }\n\n        this.target = target;\n\n        // if lightBox is open, we just switch to the new target image\n        if (this._isOpen && target) {\n            return this.switchImage(target).then(() => {\n                return this;\n            });\n        }\n\n        this._isOpen = true;\n\n        /**\n         * Setup Widget for modal\n         * @type {Widget}\n         */\n        this._widget = new Widget().setAsync(() => {\n            // thumbnail is either target itself or expected to be first childNode\n            const thumbnail = target.hasAttribute(ATTR_NO_THUMBNAIL) ? target : (target.children[0] || target);\n\n            const imgHighResolution = target.getAttribute(ATTR_DATA_HREF) || target.getAttribute(ATTR_HREF);\n            const imgSrc = this._getSrc(thumbnail) || imgHighResolution;\n\n            const imageObj = new Image();\n            imageObj.src = imgSrc;\n            this._imageContainer = document.createElement('div');\n            this._modalContainerDiv = document.createElement('div');\n            this._closerContainerDiv = document.createElement('i');\n            this._contentContainer = document.createElement('div');\n\n            this._closerContainerDiv.className = 'modal-close modal-close-lightbox icon-cancel-1';\n            this._closerContainerDiv.setAttribute(ATTR_CLOSE, ATTR_CLOSE);\n\n            this._modalContainerDiv.className = 'modal image-modal';\n            this._modalContainerDiv.appendChild(this._imageContainer);\n            this._modalContainerDiv.appendChild(this._contentContainer);\n            this._modalContainerDiv.appendChild(this._closerContainerDiv);\n            this._contentContainer.className = 'content-container';\n            this._isLoading = true;\n            this._future = new Promise((resolve) => {\n                imageObj.addEventListener('load', () => {\n                    this._imageContainer.className = 'image-container';\n                    const img = document.createElement('img');\n                    // current image\n                    this.img = img;\n\n                    img.src = imgSrc;\n                    LightBox._setupMaxWidthHeight(target, img, imageObj);\n                    this._imageContainer.appendChild(img);\n                    this._imageContainer.style.backgroundImage = 'url(' + imgSrc + ')';\n\n                    resolve(self._modalContainerDiv);\n                    this._isLoading = false;\n\n                    if (Settings.isIE()) {\n                        self._resizeEvent = global.addEventListener('resize', () => {\n                            setTimeout(() => {\n                                self._imageContainer.style.height = img.offsetHeight + 'px';\n                            }, 0);\n                        });\n                    }\n\n                    if (self.options.registerPrevNextEvents) {\n                        self._setupPrevNextStates();\n                        // prev or next on touch/click\n                        self._imageContainer.addEventListener(Settings.getTabEvent(), (e) => {\n                            if (self.isLoading()) {\n                                return;\n                            }\n                            e.preventDefault();\n\n                            const ev = e;\n                            const pageX = global.TouchEvent && ev instanceof TouchEvent ?\n                                ev.changedTouches[0].pageX : ev.pageX;\n                            const rect = self._imageContainer.getBoundingClientRect();\n                            const imgX = rect.left;\n                            const wrapperWidth = rect.width;\n                            const posX = pageX - imgX;\n\n                            self.switchImageByDirection(wrapperWidth / 2 > posX).catch(() => {\n                                self._runOptionalClose();\n                            });\n                        });\n\n                        // register keyboard events\n                        self._keyboardNextEvent = (e) => {\n                            if (e.keyCode === KEY_NEXT || e.keyCode === KEY_PREV) {\n                                if (self.isLoading()) {\n                                    return;\n                                }\n                                self.switchImageByDirection(e.keyCode === KEY_PREV).catch(() => {\n                                    self._runOptionalClose();\n                                });\n                            }\n                        };\n                        global.addEventListener('keydown', self._keyboardNextEvent);\n                    } else {\n                        self._imageContainer.addEventListener(Settings.getTabEvent(), () => {\n                            self._runOptionalClose();\n                        });\n                    }\n\n                    self.highRes(thumbnail, imgHighResolution);\n                });\n            });\n\n            this._future.then(() => {\n                self._calculateContainer(this.img);\n            });\n\n            self._modalContainerDiv.addEventListener(EVENT_MODAL_CLOSED, () => {\n                // cleanup:\n                this._modalContainerDiv.parentNode.removeChild(this._modalContainerDiv);\n                this.options.onClose.apply(self);\n                this._isOpen = false;\n                this.modal.destroy();\n                // unbind events\n                if (this._keyboardNextEvent) {\n                    global.removeEventListener('keydown', self._keyboardNextEvent);\n                }\n                if (this._resizeEvent) {\n                    global.removeEventListener('resize', self._resizeEvent);\n                }\n            });\n\n            return this._future;\n        });\n\n        this._nextFuture = this._future;\n\n        if (self._widget) {\n            this.modal = new Modal(this._modalAppend);\n            // make sure we close stack before\n            return this.modal.close().fromWidget(self._widget).then(() => {\n                return self._future.then(() => {\n                    return self;\n                });\n            });\n        }\n        return false;\n    }\n\n}\n\nexport default LightBox;\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/LightBox.js"],"sourceRoot":""}