{"version":3,"sources":["webpack:///webpack/universalModuleDefinition?5ca6**","webpack:///webpack/bootstrap e53f3a44e16ca2bd7531?fa2f**","webpack:///./src/main/Form.js?18a8","webpack:///./src/main/Tooltip.js?3890","webpack:///./src/main/util/Util.js?5bc4","webpack:///./src/main/DestroyableWidget.js?8d9b","webpack:///./src/main/util/Settings.js?b01f","webpack:///./~/isomorphic-fetch/fetch-npm-browserify.js?7723","webpack:///./~/whatwg-fetch/fetch.js?1c20","webpack:///./src/main/util/Event.js?68bf","webpack:///./src/main/modules/Form.js"],"names":["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","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","Tooltip","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","Util","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","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"],"mappings":"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;;;mBAGUQ,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,WAASS,IAAT,GAAgB;AACb,SAAIzK,OAAO3G,QAAP,KAAoB,CAAC2G,OAAO0K,WAAR,IAAuB,OAAO1K,OAAO0K,WAAd,KAA8B,UAAzE,CAAJ,EAA0F;AACtF,aAAMA,eAAc,SAASA,WAAT,CAAqBjF,KAArB,EAA4BkF,MAA5B,EAAoC;AACpD,iBAAMC,aAAaD,UAAU;AACzBE,0BAAS,KADgB;AAEzBC,6BAAY,KAFa;AAGzBC,yBAAQrK;AAHiB,cAA7B;AAKA,iBAAMsK,MAAM3R,SAAS4R,WAAT,CAAqB,aAArB,CAAZ;AACAD,iBAAIE,eAAJ,CAAoBzF,KAApB,EAA2BmF,WAAWC,OAAtC,EACID,WAAWE,UADf,EAC2BF,WAAWG,MADtC;AAEAC,iBAAIG,mBAAJ,GAA0BH,IAAInV,cAA9B;AACAmV,iBAAInV,cAAJ,GAAqB,YAAM;AACvB;AACA1B,wBAAOiX,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,sBAAYrT,SAAZ,GAAwB2I,OAAOqL,KAAP,CAAahU,SAArC;AACA2I,gBAAO0K,WAAP,GAAqBA,YAArB;AACH;AACJ,EA1BA,GAAD;AA2BA;;;;KAGMY,Y;;AAEF;;;;AAIA,2BAAYzN,MAAZ,EAAoBnG,IAApB,EAA0B;AAAA;;AACtB,cAAKmG,MAAL,GAAcA,MAAd;AACA,cAAK9H,cAAL,GAAsB;AAClB8U,sBAAS,IADS;AAElBC,yBAAY;AAFM,UAAtB;;AAKA,cAAKpT,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;AACnB0U,gCAAe1W;AADI,cAAhB,CAAP;AAGH;;AAED;;;;;;;;oCAKW2W,C,EAAG;AACV,iBAAI,CAAC,KAAKzV,cAAL,CAAoBgV,MAAzB,EAAiC;AAC7B,sBAAKhV,cAAL,CAAoBgV,MAApB,GAA6B,EAA7B;AACH;AACD5W,oBAAOC,MAAP,CAAc,KAAK2B,cAAL,CAAoBgV,MAAlC,EAA0CS,CAA1C;AACA,oBAAO,IAAP;AACH;;AAED;;;;;;gCAGO;AACH,iBAAM3W,IAAI,IAAI6V,WAAJ,CAAgB,KAAKhT,IAArB,EAA2B,KAAK3B,cAAhC,CAAV;AACA,iBAAI,KAAK8H,MAAT,EAAiB;AACb,sBAAKA,MAAL,CAAY4N,aAAZ,CAA0B5W,CAA1B;AACH;AACD,oBAAOA,CAAP;AACH;;;;;;KAGCwW,K;;;;;;;;AACF;;;;;;kCAMgBxN,M,EAAQnG,I,EAAM;AAC1B,oBAAO,IAAI4T,YAAJ,CAAiBzN,MAAjB,EAAyBnG,IAAzB,CAAP;AACH;;AAED;;;;;;;;;;yCAOuBmG,M,EAAQnG,I,EAAM/E,O,EAAS;AAC1C,oBAAO,IAAI2Y,YAAJ,CAAiBzN,MAAjB,EAAyBnG,IAAzB,EAA+BgU,WAA/B,CAA2C/Y,OAA3C,EAAoD8C,IAApD,EAAP;AACH;;;;;;mBAGU4V,K;;;;;;;;;;;;;;;;;;;;;AC/If;;;;AACA;;;;AACA;;;;;;AAEA;mBACe;AACX5Y,yBADW;AAEXuX,iCAFW;AAGXrI;AAHW,E","file":"js/form.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","/* 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","import Form from '../Form';\nimport Tooltip from '../Tooltip';\nimport Settings from '../util/Settings';\n\n// default export as component object\nexport default {\n    Form,\n    Settings,\n    Tooltip\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/modules/Form.js"],"sourceRoot":""}