{"version":3,"sources":["webpack:///./src/components/form/ControlFiles.vue?d810","webpack:///src/components/form/ControlFiles.vue","webpack:///./src/components/form/ControlFiles.vue?5e1a","webpack:///./src/components/form/ControlFiles.vue?34ae","webpack:///./node_modules/vue-filepond/dist/vue-filepond.js","webpack:///./node_modules/filepond-plugin-file-validate-type/dist/filepond-plugin-file-validate-type.js","webpack:///./node_modules/filepond-plugin-file-validate-size/dist/filepond-plugin-file-validate-size.js","webpack:///./src/components/form/ControlFiles.vue?8f33","webpack:///./node_modules/filepond/dist/filepond.js","webpack:///./node_modules/filepond-plugin-get-file/dist/filepond-plugin-get-file.js"],"names":["render","_vm","this","_h","$createElement","_c","_self","staticClass","class","formGroupClasses","attrs","control","label","id","labelSrOnly","labelHide","labelCols","labelColsSM","labelColsMD","labelColsLG","labelColsXL","labelAlign","labelAlignSM","labelAlignMD","labelAlignLG","labelAlignXL","description","controlState","ref","controlClasses","controlServer","name","form","files","disabled","readonly","allowDrop","allowBrowse","allowPaste","allowReplace","allowRevert","allowRemove","allowProcess","allowReorder","forceRevert","maxFiles","checkValidity","itemInsertLocation","itemInsertInterval","dropOnPage","dropOnElement","dropValidation","ignoredFiles","instantUpload","labelDecimalSeparator","labelThousandsSeparator","labelIdle","labelInvalidField","labelFileWaitingForSize","labelFileSizeNotAvailable","labelFileLoading","labelFileLoadError","labelFileProcessing","labelFileProcessingComplete","labelFileProcessingAborted","labelFileProcessingError","labelFileProcessingRevertError","labelFileRemoveError","labelTapToCancel","labelTapToRetry","labelTapToUndo","labelButtonRemoveItem","labelButtonAbortItemLoad","labelButtonRetryItemLoad","labelButtonAbortItemProcessing","labelButtonUndoItemProcessing","labelButtonRetryItemProcessing","labelButtonProcessItem","allowFileTypeValidation","acceptedFileTypes","labelFileTypeNotAllowed","fileValidateTypeLabelExpectedTypes","fileValidateTypeLabelExpectedTypesMap","fileValidateTypeDetectType","allowFileSizeValidation","maxFileSize","maxTotalFileSize","labelMaxFileSizeExceeded","labelMaxFileSize","labelMaxTotalFileSizeExceeded","labelMaxTotalFileSize","on","onProcessFile","onRemoveFile","nativeOn","$event","onClick","_v","_s","feedbacksValid","_e","controlInvalidFeedbacks","staticRenderFns","components","FilePond","props","formGroupClass","controlClass","value","dirty","validations","feedbacksInvalid","hardChange","serverConfig","type","Array","default","Object","data","url","$http","defaults","baseURL","process","$props","uploadUrl","patch","restore","downloadUrl","load","fetch","revert","remove","removeFileFromServer","removeUrl","deleteUrl","createInitialFiles","$T","parseInt","isResetting","computed","validator","$v","controlCanValidate","undefined","$model","keys","$params","length","$dirty","$error","state","feedbacks","error","Function","methods","updateValueByFiles","oldValue","onControlChange","setDirty","$touch","$reset","controlValue","$emit","method","source","onReset","$refs","filepond","getFiles","$nextTick","event","target","classList","contains","stopPropagation","created","mounted","watch","component","global","factory","globalThis","self","_exports","_vue","_filepond","_interopRequireDefault","obj","__esModule","defineProperty","setOptions","filteredComponentMethods","isSupported","supported","getNativeConstructorFromType","string","String","boolean","Boolean","array","function","int","Number","serverapi","object","events","instances","globalOptions","options","assign","forEach","instance","_default","registerPlugin","apply","arguments","_loop","prop","test","push","OptionTypes","_pond","h","className","required","multiple","allowMultiple","accept","capture","captureMethod","_this","_element","$el","querySelector","reduce","_len","args","_key","substr","concat","$attrs","create","$options","propsData","filter","key","includes","destroyed","_this2","detached","offsetParent","mutationHandler","mutations","observer","removedNodes","removedNode","disconnect","call","MutationObserver","observe","document","documentElement","childList","subtree","destroy","index","indexOf","splice","module","exports","plugin","_ref","addFilter","utils","Type","isString","replaceInString","guesstimateMimeType","getExtensionFromFilename","getFilenameFromURL","mimeTypeMatchesWildCard","mimeType","wildcard","mimeTypeGroup","exec","pop","wildcardGroup","slice","isValidMimeType","acceptedTypes","userInputType","some","acceptedType","getItemType","item","filename","extension","validateFile","typeDetector","Promise","resolve","reject","then","detectedType","catch","applyMimeTypeMap","map","acceptedFileType","file","_ref2","query","_ref3","validationResult","handleRejection","acceptedFileTypesMapped","status","main","sub","allTypes","join","allButLastType","lastType","BOOLEAN","ARRAY","STRING","OBJECT","FUNCTION","isBrowser","window","dispatchEvent","CustomEvent","detail","toNaturalFileSize","sizeMax","size","sizeMin","fileFilter","filesize","totalSizeMax","currentTotalSize","total","fileSize","INT","minFileSize","fileValidateSizeFilter","labelMinFileSizeExceeded","labelMinFileSize","isNode","HTMLElement","createStore","initialState","queries","actions","actionQueue","dispatchQueue","getState","processActionQueue","queue","processDispatchQueue","dispatch","isBlocking","hidden","actionHandlers","str","_queryHandles","queryHandles","api","action","property","definition","forin","cb","hasOwnProperty","createObject","attr","node","getAttribute","hasAttribute","setAttribute","ns","svgElements","isSVGElement","tag","createElement","attributes","element","createElementNS","appendChild","parent","child","children","insertBefore","appendChildView","childViews","view","removeChildView","parentNode","removeChild","IS_BROWSER","testElement","getChildCount","el","childNodes","getViewRect","elementRect","offset","scale","left","top","right","width","bottom","height","rect","inner","outer","childView","isRectIgnored","childViewRect","expandRect","calculateRectSize","marginBottom","marginRight","isNumber","thereYet","position","destination","velocity","errorMargin","Math","abs","spring","_ref$stiffness","stiffness","_ref$damping","damping","_ref$mass","mass","resting","interpolate","ts","skipToEndState","f","onupdate","oncomplete","setTarget","set","get","easeInOutQuad","t","tween","p","_ref$duration","duration","_ref$easing","easing","_ref$delay","delay","start","reverse","animator","createAnimator","category","def","addGetSet","overwrite","isArray","o","getter","setter","animations","mixinConfig","viewProps","viewInternalAPI","viewExternalAPI","initialProps","animation","write","addEvent","fn","addEventListener","removeEvent","removeEventListener","listeners","viewState","add","off","findIndex","apis","isDefined","opacity","scaleX","scaleY","translateX","translateY","rotateX","rotateY","rotateZ","originX","originY","styles","currentProps","getOffset","getScale","getRect","propsHaveChanged","applyStyles","newProps","perspective","transforms","elementCurrentStyle","style","cssText","Mixins","updateRect","layoutCalculated","paddingTop","marginTop","marginLeft","offsetLeft","offsetTop","offsetWidth","offsetHeight","scrollTop","createView","_ref$tag","_ref$name","_ref$attributes","_ref$read","read","_ref$write","_ref$create","_ref$destroy","_ref$filterFrameActio","filterFrameActionsForChild","_ref$didCreateView","didCreateView","_ref$didWriteView","didWriteView","_ref$ignoreRect","ignoreRect","_ref$ignoreRectUpdate","ignoreRectUpdate","_ref$mixins","mixins","store","getComputedStyle","frameRect","isResting","activeMixins","writers","readers","destroyers","getElement","getChildViews","getReference","createChildView","getStyle","_read","shouldUpdate","root","internalAPI","reader","_write","frameActions","shouldOptimize","writer","writerResting","timestamp","mixin","mixinResting","childResting","_destroy","destroyer","sharedAPIDefinition","internalAPIDefinition","is","needle","linkView","unlinkView","registerWriter","registerReader","registerDestroyer","invalidateLayout","externalAPIDefinition","mixinAPIDefinition","sort","a","b","mixinAPI","childCount","createPainter","fps","painter","interval","last","requestTick","cancelTick","setTimerType","setTimeout","tick","performance","now","clearTimeout","requestAnimationFrame","cancelAnimationFrame","delta","pause","createRoute","routes","_ref$actions","newNode","referenceNode","insertAfter","nextSibling","isEmpty","trim","toString","toArray","splitter","split","isBoolean","toBoolean","toNumber","replace","toInt","toFloat","parseFloat","isInt","isFinite","floor","toBytes","base","naturalFileSize","isFunction","toFunctionReference","levels","level","shift","createServerAPI","outline","timeout","headers","createAction","withCredentials","onload","ondata","onerror","parts","header","toServerAPI","isNull","isObject","isAPI","getType","replaceSingleQuotes","conversionTable","number","float","bytes","JSON","parse","e","convertTo","getValueByType","newValue","defaultValue","valueType","newValueType","convertedValue","option","createOption","currentValue","enumerable","createOptions","optionDefinition","createInitialState","items","listUpdateTimeout","itemUpdateTimeout","processingQueue","fromCamels","separator","part","toLowerCase","createOptionAPI","toUpperCase","createOptionActions","createOptionQueries","InteractionMethod","API","DROP","BROWSE","PASTE","NONE","getUniqueId","random","_AwaitValue","wrapped","_AsyncGenerator","gen","front","back","send","arg","request","next","resume","result","wrappedAwait","settle","done","err","_invoke","return","_objectWithoutPropertiesLoose","excluded","i","sourceKeys","_objectWithoutProperties","getOwnPropertySymbols","sourceSymbolKeys","prototype","propertyIsEnumerable","Symbol","asyncIterator","throw","_toConsumableArray","arr","_arrayWithoutHoles","_iterableToArray","_nonIterableSpread","arr2","iter","iterator","from","TypeError","arrayRemove","run","sync","listener","_fire","fireSync","fire","_len2","_key2","onOnce","_cb","copyObjectPropertiesToObject","src","getOwnPropertyNames","getOwnPropertyDescriptor","PRIVATE","createItemAPI","removeReleasedItems","released","ItemStatus","INIT","IDLE","PROCESSING_QUEUED","PROCESSING","PROCESSING_COMPLETE","PROCESSING_ERROR","PROCESSING_REVERT_ERROR","LOADING","LOAD_ERROR","FileOrigin","INPUT","LIMBO","LOCAL","getNonNumeric","getDecimalSeparator","toLocaleString","getThousandsSeparator","decimalSeparator","thousandsStringWithSeparator","thousandsStringWithoutSeparator","NUMBER","ACTION","SERVER_API","REGEX","filters","applyFilterChain","matchingFilters","initialFilter","current","applyFilters","extendDefaultOptions","additionalOptions","defaultOptions","getOptions","opts","allowSyncAcceptAttribute","allowDirectoriesOnly","itemInsertLocationFreedom","maxParallelUploads","chunkUploads","chunkForce","chunkSize","chunkRetryDelays","server","fileSizeBase","labelFileCountSingular","labelFileCountPlural","labelFileAdded","labelFileRemoved","iconRemove","iconProcess","iconRetry","iconUndo","iconDone","oninit","onwarning","onactivatefile","oninitfile","onaddfilestart","onaddfileprogress","onaddfile","onprocessfilestart","onprocessfileprogress","onprocessfileabort","onprocessfilerevert","onprocessfile","onprocessfiles","onremovefile","onpreparefile","onupdatefiles","onreorderfiles","beforeDropFile","beforeAddFile","beforeRemoveFile","beforePrepareFile","stylePanelLayout","stylePanelAspectRatio","styleItemPanelAspectRatio","styleButtonRemoveItemPosition","styleButtonProcessItemPosition","styleLoadIndicatorPosition","styleProgressIndicatorPosition","styleButtonRemoveItemAlign","credits","getItemByQuery","find","getNumericAspectRatioFromString","aspectRatio","getActiveItems","archived","Status","EMPTY","ERROR","BUSY","READY","ITEM_ERROR","ITEM_BUSY","ITEM_READY","isItemInErrorState","isItemInBusyState","isItemInReadyState","GET_STATUS","GET_ITEM","GET_ACTIVE_ITEM","GET_ACTIVE_ITEMS","GET_ITEMS","GET_ITEM_NAME","GET_ITEM_SIZE","GET_STYLES","GET_PANEL_ASPECT_RATIO","isShapeCircle","GET_ITEM_PANEL_ASPECT_RATIO","GET_ITEMS_BY_STATUS","GET_TOTAL_ITEMS","IS_ASYNC","hasRoomForItem","count","maxFileCount","limit","min","max","arrayInsert","insertItem","isBase64DataURI","guesstimateExtension","subtype","leftPad","padding","getDateString","date","Date","getFullYear","getMonth","getDate","getHours","getMinutes","getSeconds","getFileFromBlob","blob","lastModifiedDate","_relativePath","getBlobBuilder","BlobBuilder","WebKitBlobBuilder","MozBlobBuilder","MSBlobBuilder","createBlob","arrayBuffer","BB","bb","append","getBlob","Blob","getBlobFromByteStringWithMimeType","byteString","ab","ArrayBuffer","ia","Uint8Array","charCodeAt","getMimeTypeFromBase64DataURI","dataURI","getBase64DataFromBase64DataURI","getByteStringFromBase64DataURI","atob","getBlobFromBase64DataURI","getFileFromBase64DataURI","getFileNameFromHeader","matches","decodeURI","getFileSizeFromHeader","match","getTranfserIdFromHeader","getFileInfoFromHeaders","info","rows","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_step","_iterator","createFileLoader","fetchFn","complete","progress","getProgress","abort","File","loadURL","response","body","code","computable","fileinfo","setSource","isGet","sendRequest","onheaders","onprogress","ontimeout","onabort","aborted","xhr","headersReceived","encodeURI","encodeURIComponent","stringify","XMLHttpRequest","upload","lengthComputable","loaded","onreadystatechange","readyState","open","unescape","setRequestHeader","responseType","createResponse","createTimeoutResponse","getAllResponseHeaders","hasQS","buildURL","createFetchFunction","apiUrl","res","statusText","ChunkStatus","QUEUED","COMPLETE","WAITING","processFileChunked","metadata","transfer","chunks","chunkTransferId","chunkServer","serverId","fd","getResponseHeader","requestTransferId","formData","FormData","requestParams","requestTransferOffset","requestUrl","lastChunkIndex","retries","completeProcessingChunks","canProcessChunk","chunk","processChunk","processChunks","updateTotalProgress","retryProcessChunk","every","totalBytesTransfered","totalSize","totalProcessing","abortChunks","createFileProcessorFunction","canChunkUpload","shouldChunkUpload","willChunkUpload","createProcessorFunction","params","createRevertFunction","uniqueFileId","getRandomNumber","createPerceivedPerformanceUpdater","tickMin","tickMax","runtime","clear","createFileProcessor","processFn","perceivedProgress","perceivedPerformanceUpdater","perceivedDuration","progressFn","completeFn","transferId","reset","getDuration","getFilenameWithoutExtension","lastIndexOf","createFileStub","isFile","deepCloneObject","v","createItem","origin","serverFileReference","frozen","processingAborted","activeLoader","activeProcessor","abortProcessingRequestComplete","setStatus","getFileExtension","getFileType","getFileSize","getFile","loader","meta","success","retryLoad","abortLoad","processor","onprocess","console","requestProcessing","abortProcessing","revertFileUpload","_setMetadata","silent","getMetadata","filenameWithoutExtension","fileExtension","fileType","relativePath","setMetadata","extend","handler","itemAPI","freeze","release","archive","getItemIndexByQuery","getItemById","itemId","fetchBlob","getDomainFromURL","location","protocol","isExternalURL","href","dynamicLabel","isMockItem","listUpdated","optionalPromise","sortItems","compare","getItemByQueryFromState","itemHandler","_ref$success","_ref$failure","failure","ABORT_ALL","DID_SET_FILES","_ref2$value","activeItems","interactionMethod","DID_UPDATE_ITEM_METADATA","doUpload","shouldPrepareOutput","MOVE_ITEM","_ref4","currentIndex","SORT","_ref5","ADD_ITEMS","_ref6","_ref6$success","_ref6$failure","insertLocation","totalItems","isValidFile","validItems","promises","all","ADD_ITEM","_ref7","_ref7$index","_ref7$success","_ref7$failure","_ref7$options","_item","mainStatus","handleAdd","shouldAdd","change","loadComplete","_ref8","REQUEST_PREPARE_OUTPUT","_ref9","_ref9$failure","COMPLETE_LOAD_ITEM","_ref10","RETRY_ITEM_LOAD","REQUEST_ITEM_PREPARE","_success","output","REQUEST_ITEM_PROCESSING","itemCanBeQueuedForProcessing","processNow","PROCESS_ITEM","totalCurrentUploads","processNext","queueEntry","itemReference","allItemsProcessed","RETRY_ITEM_PROCESSING","REQUEST_REMOVE_ITEM","shouldRemove","RELEASE_ITEM","REMOVE_ITEM","removeFromView","ABORT_ITEM_LOAD","ABORT_ITEM_PROCESSING","REQUEST_REVERT_ITEM_PROCESSING","handleRevert","shouldRevert","requestRemoveResult","REVERT_ITEM_PROCESSING","SET_OPTIONS","_ref11","formatFilename","createElement$1","tagName","text","textNode","nodeValue","createTextNode","polarToCartesian","centerX","centerY","radius","angleInDegrees","angleInRadians","PI","x","cos","y","sin","describeArc","startAngle","endAngle","arcSweep","end","percentageArc","to","spin","svg","path","align","dataset","ringStrokeWidth","ringFrom","ringTo","coordinates","progressIndicator","create$1","innerHTML","icon","isDisabled","write$1","shouldDisable","removeAttribute","fileActionButton","round","KB","MB","GB","removeDecimalsWhenZero","decimalCount","toFixed","create$2","fileName","updateFile","updateFileSizeOnError","fileInfo","DID_LOAD_ITEM","DID_UPDATE_ITEM_META","DID_THROW_ITEM_LOAD_ERROR","DID_THROW_ITEM_INVALID","toPercentage","create$3","didSetItemLoadProgress","title","didSetItemProcessProgress","didRequestItemProcessing","didAbortItemProcessing","didCompleteItemProcessing","fileStatus","DID_REVERT_ITEM_PROCESSING","DID_REQUEST_ITEM_PROCESSING","DID_ABORT_ITEM_PROCESSING","DID_COMPLETE_ITEM_PROCESSING","DID_UPDATE_ITEM_PROCESS_PROGRESS","DID_UPDATE_ITEM_LOAD_PROGRESS","DID_THROW_ITEM_PROCESSING_ERROR","DID_THROW_ITEM_PROCESSING_REVERT_ERROR","DID_THROW_ITEM_REMOVE_ERROR","Buttons","AbortItemLoad","RetryItemLoad","RemoveItem","ProcessItem","AbortItemProcessing","RetryItemProcessing","RevertItemProcessing","ButtonKeys","calculateFileInfoOffset","buttonRect","buttonRemoveItem","calculateButtonWidth","buttonAbortItemLoad","calculateFileVerticalCenterOffset","calculateFileHorizontalCenterOffset","getLoadIndicatorAlignment","getProcessIndicatorAlignment","getRemoveIndicatorAligment","DefaultStyle","buttonRetryItemLoad","buttonProcessItem","buttonAbortItemProcessing","buttonRetryItemProcessing","buttonRevertItemProcessing","loadProgressIndicator","processProgressIndicator","processingCompleteIndicator","IdleStyle","ProcessingStyle","StyleMap","DID_START_ITEM_LOAD","DID_START_ITEM_REMOVE","DID_LOAD_LOCAL_ITEM","DID_START_ITEM_PROCESSING","processingCompleteIndicatorView","create$4","buttonFilter","isAsync","alignRemoveItemButton","enabledButtons","_map","buttonView","loadIndicatorView","progressIndicatorView","activeStyles","write$2","route","stylesToApply","defaultStyles","DID_SET_LABEL_BUTTON_ABORT_ITEM_PROCESSING","DID_SET_LABEL_BUTTON_ABORT_ITEM_LOAD","DID_SET_LABEL_BUTTON_ABORT_ITEM_REMOVAL","buttonAbortItemRemoval","_ref12","create$5","didLoadItem","fileWrapper","PANEL_SPRING_PROPS","create$6","section","createSection","scalable","viewConstructor","write$3","topRect","bottomRect","center","panel","heightCurrent","createDragHelper","itemIds","prevIndex","setIndex","getIndex","getItemIndex","ITEM_TRANSLATE_SPRING","ITEM_SCALE_SPRING","StateMap","create$7","handleClick","container","markedForRemoval","dragState","grab","isPrimary","removedActivateListener","pageX","pageY","dragOrigin","dragCenter","offsetX","offsetY","drag","preventDefault","dragOffset","dist","drop","route$1","DID_UPDATE_PANEL_HEIGHT","write$4","DID_GRAB_ITEM","DID_DRAG_ITEM","DID_DROP_ITEM","currentState","filepondItemState","getItemIndexByPosition","positionInView","horizontalSpace","l","itemRect","itemHorizontalMargin","itemWidth","itemsPerRow","childMid","itemVerticalMargin","itemHeight","_index","indexX","indexY","itemTop","itemRight","itemBottom","dropAreaDimensions","val","setDimensions","create$8","lastItemSpanwDate","addItemView","addIndex","spawnDate","cooldown","moveItem","vx","vy","introItemView","removeItemView","getItemHeight","getItemWidth","dragItem","numItems","oldIndex","dragPosition","dragHeight","dragWidth","cols","setHeight","setWidth","getGridIndex","getHeight","getWidth","getColIndex","visibleChildren","idx","childHeight","childBottom","childTop","route$2","DID_ADD_ITEM","DID_REMOVE_ITEM","write$5","dragCoordinates","dragIndex","dragIndexOffset","removeIndexOffset","addIndexOffset","childRect","visualHeight","prevX","prevY","visualIndex","vectorX","sign","vectorY","filterSetItemActions","list","create$9","overflowing","storeDragCoordinates","scopeLeft","scopeTop","clearDragCoordinates","route$3","DID_DRAG","DID_END_DRAG","write$6","overflow","newHeight","listScroller","attrToggle","enabledValue","resetFileInput","input","create$a","setAcceptedFileTypes","toggleAllowMultiple","toggleDirectoryFilter","toggleDisabled","toggleRequired","setCaptureMethod","handleChange","webkitRelativePath","doesAllowBrowse","disableField","updateRequiredStatus","shouldCheckValidity","setCustomValidity","updateFieldValidityStatus","browser","DID_SET_DISABLED","DID_SET_ALLOW_BROWSE","DID_SET_ALLOW_DIRECTORIES_ONLY","DID_SET_ALLOW_MULTIPLE","DID_SET_ACCEPTED_FILE_TYPES","DID_SET_CAPTURE_METHOD","DID_SET_REQUIRED","Key","ENTER","SPACE","create$b","handleKeyDown","isActivationKey","keyCode","click","isLabelClick","updateLabelValue","caption","clickable","dropLabel","DID_SET_LABEL_IDLE","addBlob","moveBlob","hideBlob","explodeBlob","write$7","route$4","DID_DROP","drip","create$c","fields","getField","syncFieldPositionsWithItems","didReorderItems","didAddItem","dataContainer","didLoadItem$1","field","didSetDisabled","didRemoveItem","didDefineValue","write$8","DID_DEFINE_VALUE","DID_REORDER_ITEMS","DID_SORT_ITEMS","getRootNode","images","text$1","zip","epub","requestDataTransferItems","dataTransfer","links","getLinks","hasFiles","promisedFiles","isFileSystemItem","getFilesFromItem","returnedFileGroups","group","isEntry","entry","getAsEntry","isDirectory","kind","isDirectoryEntry","getFilesInDirectory","getAsFile","dirCounter","fileCounter","resolveIfDone","readEntries","dirEntry","directoryReader","createReader","readBatch","entries","correctedFile","correctMissingFileType","fullPath","webkitGetAsEntry","getLinksFromTransferMetaData","getLinksFromTransferURLData","getData","dragNDropObservers","eventPosition","pageLeft","pageTop","layerX","layerY","createDragNDropClient","scopeToObserve","filterElement","getDragNDropObserver","client","ondrop","onenter","ondrag","onexit","allowdrop","addListener","newObserver","createDragNDropObserver","clients","dragenter","dragover","dragleave","handlers","createHandler","elementFromPoint","point","isEventTarget","elementAtPosition","pageXOffset","pageYOffset","initialTarget","setDropEffect","effect","dropEffect","overDropTarget","allowsTransfer","createHopper","scope","validateItems","catchesDropsOnPage","requiresDropOnElement","_options$filterItems","filterItems","lastState","filteredItems","ondragend","ondragstart","updateHopperState","hopperState","listening","listeners$1","handlePaste","activeEl","activeElement","nodeName","inScope","clipboardData","listen","unlisten","createPaster","create$d","addFilesNotificationTimeout","notificationClearTimeout","filenames","assist","message","textContent","clear$1","listModified","isUsingFilePond","itemAdded","itemRemoved","itemProcessed","itemProcessedUndo","itemError","assistant","toCamels","RegExp","charAt","debounce","func","immidiateOnly","MAX_FILES_LIMIT","prevent","create$e","measure","bounds","widthPrevious","widthUpdated","updateHistory","previousAspectRatio","canHover","matchMedia","hasPointerEvents","passive","hasCredits","frag","tabindex","rel","write$9","route$5","calculateRootBoundingBoxHeight","_root$ref","hopper","isMultiItem","maxItems","atMaxCapacity","addAction","listItemMargin","calculateListItemMargin","listHeight","calculateListHeight","labelHeight","currentLabelHeight","listMarginTop","listMarginBottom","visual","boundsHeight","history","MAX_BOUNCES","bounces","listAvailableHeight","fixedHeight","_listAvailableHeight","cappedHeight","isCappedHeight","panelHeight","_listAvailableHeight2","itemMargin","transform","scrollList","itemList","newItem","removedItem","verticalItemCount","ceil","measureHeight","maxHeight","exceedsMaxFiles","totalBrowseItems","hasMaxItems","getDragIndex","toggleDrop","isAllowed","enabled","toggleBrowse","togglePaste","paster","DID_SET_ALLOW_DROP","DID_SET_ALLOW_PASTE","createApp","initialOptions","originalElement","visibilityHandler","resizeDoneTimer","isResizing","isResizingHorizontally","initialWindowWidth","currentWindowWidth","resizeHandler","isHidden","readWriteApi","innerWidth","routeActionsToEvents","createEvent","eventRoutes","DID_DESTROY","DID_INIT","DID_THROW_MAX_FILES","DID_INIT_ITEM","DID_PREPARE_OUTPUT","DID_COMPLETE_ITEM_PROCESSING_ALL","DID_UPDATE_ITEMS","DID_ACTIVATE_ITEM","exposeEvent","pond","bubbles","cancelable","composed","filtered","prepareFile","addFile","addFiles","isFilePondFile","removeFile","sources","lastArgument","processFile","prepareFiles","processFiles","_len3","_key3","removeFiles","_len4","_key4","mappedQueries","q","moveFile","browse","appendTo","replaceElement","restoreElement","isAttachedTo","createAppObject","customOptions","app","lowerCaseFirstLetter","attributeNameToPropertyName","attributeName","mapObject","propertyMap","selector","mapping","selectorRegExp","getAttributesAsObject","attributeMapping","attribute","createAppAtElement","mergedOptions","attributeOptions","querySelectorAll","createApp$1","PRIVATE_METHODS","createAppAPI","replacements","createWorker","workerBlob","workerURL","URL","createObjectURL","worker","Worker","post","transferList","onmessage","postMessage","terminate","revokeObjectURL","loadImage","img","Image","renameFile","renamedFile","copyFile","registeredPlugins","createAppPlugin","pluginOutline","views","isOperaMini","operamini","hasPromises","hasBlobSlice","hasCreateObjectURL","hasVisibility","hasTiming","hasCSSSupports","CSS","isIE11","navigator","userAgent","apps","FileStatus","updateOptionTypes","hook","indexToRemove","context","matchedHooks","newHooks","newHook","plugins","registerDownloadComponent","labelButtonDownload","allowDownloadByUrl","downloadIcon","getDownloadIcon","prepend","downloadFile","display","download","fpAPI","viewAPI","labelButtonDownloadItem"],"mappings":"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","file":"js/chunk-5f997c09.2ac10ec0.js","sourcesContent":["var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('b-form-group',{staticClass:\"control-files\",class:_vm.formGroupClasses,attrs:{\"label\":_vm.control.label,\"label-for\":_vm.control.id,\"label-sr-only\":_vm.control.labelSrOnly || _vm.control.labelHide,\"label-cols\":_vm.control.labelCols,\"label-cols-sm\":_vm.control.labelColsSM,\"label-cols-md\":_vm.control.labelColsMD,\"label-cols-lg\":_vm.control.labelColsLG,\"label-cols-xl\":_vm.control.labelColsXL,\"label-align\":_vm.control.labelAlign,\"label-align-sm\":_vm.control.labelAlignSM,\"label-align-md\":_vm.control.labelAlignMD,\"label-align-lg\":_vm.control.labelAlignLG,\"label-align-xl\":_vm.control.labelAlignXL,\"description\":_vm.control.description,\"state\":_vm.controlState}},[_c('file-pond',{ref:\"filepond\",class:_vm.controlClasses,attrs:{\"server\":_vm.controlServer,\"credits\":'',\"id\":_vm.control.id,\"name\":_vm.control.name,\"form\":_vm.control.form,\"files\":_vm.control.files,\"disabled\":_vm.control.disabled || _vm.control.readonly,\"allowDrop\":_vm.control.allowDrop,\"allowBrowse\":_vm.control.allowBrowse,\"allowPaste\":_vm.control.allowPaste,\"allowMultiple\":\"\",\"allowReplace\":_vm.control.allowReplace,\"allowRevert\":_vm.control.allowRevert,\"allowRemove\":_vm.control.allowRemove,\"allowProcess\":_vm.control.allowProcess,\"allowReorder\":_vm.control.allowReorder,\"forceRevert\":_vm.control.forceRevert,\"maxFiles\":_vm.control.maxFiles,\"checkValidity\":_vm.control.checkValidity,\"itemInsertLocation\":_vm.control.itemInsertLocation,\"itemInsertInterval\":_vm.control.itemInsertInterval,\"dropOnPage\":_vm.control.dropOnPage,\"dropOnElement\":_vm.control.dropOnElement,\"dropValidation\":_vm.control.dropValidation,\"ignoredFiles\":_vm.control.ignoredFiles,\"instantUpload\":_vm.control.instantUpload,\"labelDecimalSeparator\":_vm.control.labelDecimalSeparator,\"labelThousandsSeparator\":_vm.control.labelThousandsSeparator,\"labelIdle\":_vm.control.labelIdle,\"labelInvalidField\":_vm.control.labelInvalidField,\"labelFileWaitingForSize\":_vm.control.labelFileWaitingForSize,\"labelFileSizeNotAvailable\":_vm.control.labelFileSizeNotAvailable,\"labelFileLoading\":_vm.control.labelFileLoading,\"labelFileLoadError\":_vm.control.labelFileLoadError,\"labelFileProcessing\":_vm.control.labelFileProcessing,\"labelFileProcessingComplete\":_vm.control.labelFileProcessingComplete,\"labelFileProcessingAborted\":_vm.control.labelFileProcessingAborted,\"labelFileProcessingError\":_vm.control.labelFileProcessingError,\"labelFileProcessingRevertError\":_vm.control.labelFileProcessingRevertError,\"labelFileRemoveError\":_vm.control.labelFileRemoveError,\"labelTapToCancel\":_vm.control.labelTapToCancel,\"labelTapToRetry\":_vm.control.labelTapToRetry,\"labelTapToUndo\":_vm.control.labelTapToUndo,\"labelButtonRemoveItem\":_vm.control.labelButtonRemoveItem,\"labelButtonAbortItemLoad\":_vm.control.labelButtonAbortItemLoad,\"labelButtonRetryItemLoad\":_vm.control.labelButtonRetryItemLoad,\"labelButtonAbortItemProcessing\":_vm.control.labelButtonAbortItemProcessing,\"labelButtonUndoItemProcessing\":_vm.control.labelButtonUndoItemProcessing,\"labelButtonRetryItemProcessing\":_vm.control.labelButtonRetryItemProcessing,\"labelButtonProcessItem\":_vm.control.labelButtonProcessItem,\"allowFileTypeValidation\":_vm.control.allowFileTypeValidation,\"acceptedFileTypes\":_vm.control.acceptedFileTypes,\"labelFileTypeNotAllowed\":_vm.control.labelFileTypeNotAllowed,\"fileValidateTypeLabelExpectedTypes\":_vm.control.fileValidateTypeLabelExpectedTypes,\"fileValidateTypeLabelExpectedTypesMap\":_vm.control.fileValidateTypeLabelExpectedTypesMap,\"fileValidateTypeDetectType\":_vm.control.fileValidateTypeDetectType,\"allowFileSizeValidation\":_vm.control.allowFileSizeValidation,\"maxFileSize\":_vm.control.maxFileSize,\"maxTotalFileSize\":_vm.control.maxTotalFileSize,\"labelMaxFileSizeExceeded\":_vm.control.labelMaxFileSizeExceeded,\"labelMaxFileSize\":_vm.control.labelMaxFileSize,\"labelMaxTotalFileSizeExceeded\":_vm.control.labelMaxTotalFileSizeExceeded,\"labelMaxTotalFileSize\":_vm.control.labelMaxTotalFileSize},on:{\"processfile\":_vm.onProcessFile,\"removefile\":_vm.onRemoveFile},nativeOn:{\"click\":function($event){return _vm.onClick($event)}}}),(_vm.control.feedbacksValid)?_c('b-form-valid-feedback',{attrs:{\"state\":_vm.controlState}},[_vm._v(_vm._s(_vm.control.feedbacksValid))]):_vm._e(),_c('b-form-invalid-feedback',{attrs:{\"state\":_vm.controlState}},[_vm._v(_vm._s(_vm.controlInvalidFeedbacks))])],1)}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","<template>\r\n  <b-form-group\r\n    class=\"control-files\"\r\n    :label=\"control.label\"\r\n    :label-for=\"control.id\"\r\n    :label-sr-only=\"control.labelSrOnly || control.labelHide\"\r\n    :label-cols=\"control.labelCols\"\r\n    :label-cols-sm=\"control.labelColsSM\"\r\n    :label-cols-md=\"control.labelColsMD\"\r\n    :label-cols-lg=\"control.labelColsLG\"\r\n    :label-cols-xl=\"control.labelColsXL\"\r\n    :label-align=\"control.labelAlign\"\r\n    :label-align-sm=\"control.labelAlignSM\"\r\n    :label-align-md=\"control.labelAlignMD\"\r\n    :label-align-lg=\"control.labelAlignLG\"\r\n    :label-align-xl=\"control.labelAlignXL\"\r\n    :class=\"formGroupClasses\"\r\n    :description=\"control.description\"\r\n    :state=\"controlState\"\r\n  >\r\n    <file-pond\r\n      ref=\"filepond\"\r\n      :server=\"controlServer\"\r\n      :class=\"controlClasses\"\r\n      :credits=\"''\"\r\n\r\n      :id=\"control.id\"\r\n      :name=\"control.name\"\r\n      :form=\"control.form\"\r\n      :files=\"control.files\"\r\n      :disabled=\"control.disabled || control.readonly\"\r\n\r\n      :allowDrop=\"control.allowDrop\"\r\n      :allowBrowse=\"control.allowBrowse\"\r\n      :allowPaste=\"control.allowPaste\"\r\n      allowMultiple\r\n      :allowReplace=\"control.allowReplace\"\r\n      :allowRevert=\"control.allowRevert\"\r\n      :allowRemove=\"control.allowRemove\"\r\n      :allowProcess=\"control.allowProcess\"\r\n      :allowReorder=\"control.allowReorder\"\r\n      :forceRevert=\"control.forceRevert\"\r\n      :maxFiles=\"control.maxFiles\"\r\n      :checkValidity=\"control.checkValidity\"\r\n      :itemInsertLocation=\"control.itemInsertLocation\"\r\n      :itemInsertInterval=\"control.itemInsertInterval\"\r\n      :dropOnPage=\"control.dropOnPage\"\r\n      :dropOnElement=\"control.dropOnElement\"\r\n      :dropValidation=\"control.dropValidation\"\r\n      :ignoredFiles=\"control.ignoredFiles\"\r\n      :instantUpload=\"control.instantUpload\"\r\n      :labelDecimalSeparator=\"control.labelDecimalSeparator\"\r\n      :labelThousandsSeparator=\"control.labelThousandsSeparator\"\r\n      :labelIdle=\"control.labelIdle\"\r\n      :labelInvalidField=\"control.labelInvalidField\"\r\n      :labelFileWaitingForSize=\"control.labelFileWaitingForSize\"\r\n      :labelFileSizeNotAvailable=\"control.labelFileSizeNotAvailable\"\r\n      :labelFileLoading=\"control.labelFileLoading\"\r\n      :labelFileLoadError=\"control.labelFileLoadError\"\r\n      :labelFileProcessing=\"control.labelFileProcessing\"\r\n      :labelFileProcessingComplete=\"control.labelFileProcessingComplete\"\r\n      :labelFileProcessingAborted=\"control.labelFileProcessingAborted\"\r\n      :labelFileProcessingError=\"control.labelFileProcessingError\"\r\n      :labelFileProcessingRevertError=\"control.labelFileProcessingRevertError\"\r\n      :labelFileRemoveError=\"control.labelFileRemoveError\"\r\n      :labelTapToCancel=\"control.labelTapToCancel\"\r\n      :labelTapToRetry=\"control.labelTapToRetry\"\r\n      :labelTapToUndo=\"control.labelTapToUndo\"\r\n      :labelButtonRemoveItem=\"control.labelButtonRemoveItem\"\r\n      :labelButtonAbortItemLoad=\"control.labelButtonAbortItemLoad\"\r\n      :labelButtonRetryItemLoad=\"control.labelButtonRetryItemLoad\"\r\n      :labelButtonAbortItemProcessing=\"control.labelButtonAbortItemProcessing\"\r\n      :labelButtonUndoItemProcessing=\"control.labelButtonUndoItemProcessing\"\r\n      :labelButtonRetryItemProcessing=\"control.labelButtonRetryItemProcessing\"\r\n      :labelButtonProcessItem=\"control.labelButtonProcessItem\"\r\n\r\n      :allowFileTypeValidation=\"control.allowFileTypeValidation\"\r\n      :acceptedFileTypes=\"control.acceptedFileTypes\"\r\n      :labelFileTypeNotAllowed=\"control.labelFileTypeNotAllowed\"\r\n      :fileValidateTypeLabelExpectedTypes=\"control.fileValidateTypeLabelExpectedTypes\"\r\n      :fileValidateTypeLabelExpectedTypesMap=\"control.fileValidateTypeLabelExpectedTypesMap\"\r\n      :fileValidateTypeDetectType=\"control.fileValidateTypeDetectType\"\r\n\r\n      :allowFileSizeValidation=\"control.allowFileSizeValidation\"\r\n      :maxFileSize=\"control.maxFileSize\"\r\n      :maxTotalFileSize=\"control.maxTotalFileSize\"\r\n      :labelMaxFileSizeExceeded=\"control.labelMaxFileSizeExceeded\"\r\n      :labelMaxFileSize=\"control.labelMaxFileSize\"\r\n      :labelMaxTotalFileSizeExceeded=\"control.labelMaxTotalFileSizeExceeded\"\r\n      :labelMaxTotalFileSize=\"control.labelMaxTotalFileSize\"\r\n\r\n      @processfile=\"onProcessFile\"\r\n      @removefile=\"onRemoveFile\"\r\n      @click.native=\"onClick\"\r\n    />\r\n\r\n    <b-form-valid-feedback v-if=\"control.feedbacksValid\" :state=\"controlState\">{{ control.feedbacksValid }}</b-form-valid-feedback>\r\n    <b-form-invalid-feedback :state=\"controlState\">{{ controlInvalidFeedbacks }}</b-form-invalid-feedback>\r\n  </b-form-group>\r\n</template>\r\n\r\n<script>\r\nimport { FILE_ENDPOINT_DEFAULT_URLS } from '@/assets/js/config/server'\r\n\r\nimport VueFilePond from 'vue-filepond'\r\nimport { FileOrigin } from 'filepond'\r\nimport { copy } from '@/assets/js/helper/object'\r\n\r\nimport FilePondPluginGetFile from 'filepond-plugin-get-file'\r\nimport FilePondPluginFileValidateType from 'filepond-plugin-file-validate-type'\r\nimport FilePondPluginFileValidateSize from 'filepond-plugin-file-validate-size'\r\n\r\nexport default {\r\n  name: 'ControlFiles',\r\n  components: {\r\n    FilePond: VueFilePond(\r\n      FilePondPluginGetFile,\r\n      FilePondPluginFileValidateType,\r\n      FilePondPluginFileValidateSize\r\n    )\r\n  },\r\n  props: {\r\n    // Base Control\r\n    id: { type: String, default: '' },\r\n    name: { type: String, default: '' },\r\n    form: { type: String, default: '' },\r\n    formGroupClass: { type: [String, Object, Array], default: '' },\r\n    controlClass: { type: [String, Object, Array], default: '' },\r\n    label: { type: String, default: '' },\r\n    labelSrOnly: { type: [Boolean], default: false },\r\n    labelHide: { type: Boolean, default: false },\r\n    labelCols: { type: [Number, String, Boolean], default: null },\r\n    labelColsSM: { type: [Number, String, Boolean], default: null },\r\n    labelColsMD: { type: [Number, String, Boolean], default: null },\r\n    labelColsLG: { type: [Number, String, Boolean], default: null },\r\n    labelColsXL: { type: [Number, String, Boolean], default: null },\r\n    labelAlign: { type: String, default: '' },\r\n    labelAlignSM: { type: String, default: '' },\r\n    labelAlignMD: { type: String, default: '' },\r\n    labelAlignLG: { type: String, default: '' },\r\n    labelAlignXL: { type: String, default: '' },\r\n    value: { type: Array, default: () => ([]) },\r\n    description: { type: String, default: '' },\r\n    readonly: { type: Boolean, default: false },\r\n    disabled: { type: Boolean, default: false },\r\n    dirty: { type: Boolean, default: false },\r\n    validations: { type: Object, default: () => ({}) },\r\n    feedbacksValid: { type: String, default: '' },\r\n    feedbacksInvalid: { type: Object, default: () => ({}) },\r\n    hardChange: { type: Function, default: null },\r\n    // FilePond\r\n    serverConfig: { type: Object, default: () => ({}) },\r\n    allowDrop: { type: Boolean, default: true },\r\n    allowBrowse: { type: Boolean, default: true },\r\n    allowPaste: { type: Boolean, default: true },\r\n    // allowMultiple: { type: Boolean, default: true },\r\n    allowReplace: { type: Boolean, default: true },\r\n    allowRevert: { type: Boolean, default: true },\r\n    allowRemove: { type: Boolean, default: true },\r\n    allowProcess: { type: Boolean, default: true },\r\n    allowReorder: { type: Boolean, default: false },\r\n    forceRevert: { type: Boolean, default: false },\r\n    maxFiles: { type: Number, default: null },\r\n    checkValidity: { type: Boolean, default: false },\r\n    itemInsertLocation: { type: String, default: 'before' },\r\n    itemInsertInterval: { type: Number, default: 75 },\r\n    dropOnPage: { type: Boolean, default: false },\r\n    dropOnElement: { type: Boolean, default: true },\r\n    dropValidation: { type: Boolean, default: false },\r\n    ignoredFiles: { type: Array, default: () => (['.ds_store', 'thumbs.db', 'desktop.ini']) },\r\n    instantUpload: { type: Boolean, default: true },\r\n    labelDecimalSeparator: { type: String, default: 'auto' },\r\n    labelThousandsSeparator: { type: String, default: 'auto' },\r\n    labelIdle: { type: String, default: null },\r\n    labelInvalidField: { type: String, default: null },\r\n    labelFileWaitingForSize: { type: String, default: null },\r\n    labelFileSizeNotAvailable: { type: String, default: null },\r\n    labelFileLoading: { type: String, default: null },\r\n    labelFileLoadError: { type: String, default: null },\r\n    labelFileProcessing: { type: String, default: null },\r\n    labelFileProcessingComplete: { type: String, default: null },\r\n    labelFileProcessingAborted: { type: String, default: null },\r\n    labelFileProcessingError: { type: String, default: null },\r\n    labelFileProcessingRevertError: { type: String, default: null },\r\n    labelFileRemoveError: { type: String, default: null },\r\n    labelTapToCancel: { type: String, default: null },\r\n    labelTapToRetry: { type: String, default: null },\r\n    labelTapToUndo: { type: String, default: null },\r\n    labelButtonRemoveItem: { type: String, default: null },\r\n    labelButtonAbortItemLoad: { type: String, default: null },\r\n    labelButtonRetryItemLoad: { type: String, default: null },\r\n    labelButtonAbortItemProcessing: { type: String, default: null },\r\n    labelButtonUndoItemProcessing: { type: String, default: null },\r\n    labelButtonRetryItemProcessing: { type: String, default: null },\r\n    labelButtonProcessItem: { type: String, default: null },\r\n    // Plugin Type Validation\r\n    allowFileTypeValidation: { type: Boolean, default: true },\r\n    acceptedFileTypes: {\r\n      type: Array,\r\n      // Sources: https://www.iana.org/assignments/media-types/media-types.xhtml | https://developer.mozilla.org/ar/docs/Web/HTTP/Basics_of_HTTP/MIME_types\r\n      // Wildcards are possible. e.g. ['image/*']\r\n      default: () => ([\r\n        'image/webp',\r\n        'image/gif',\r\n        'image/png',\r\n        'image/jpeg',\r\n        'image/svg+xml',\r\n\r\n        'video/webm',\r\n        'video/ogg',\r\n        'video/mp4',\r\n\r\n        'audio/weba',\r\n        'audio/ogg',\r\n        'audio/mp4',\r\n        'audio/mpeg',\r\n        'audio/wav',\r\n        'audio/midi',\r\n\r\n        'application/ogg',\r\n        'application/pdf',\r\n        'application/msword',\r\n        'application/vnd.openxmlformats-officedocument.wordprocessingml.document',\r\n        'application/vnd.ms-excel',\r\n        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\r\n        'application/vnd.ms-powerpoint',\r\n        'application/vnd.openxmlformats-officedocument.presentationml.presentation'\r\n      ])\r\n    },\r\n    labelFileTypeNotAllowed: { type: String, default: null },\r\n    fileValidateTypeLabelExpectedTypes: { type: String, default: null },\r\n    fileValidateTypeLabelExpectedTypesMap: {\r\n      type: Object,\r\n      default: () => ({\r\n        'image/webp': 'webp',\r\n        'image/gif': 'gif',\r\n        'image/png': 'png',\r\n        'image/jpeg': 'jpg',\r\n        'image/svg+xml': 'svg',\r\n\r\n        'video/webm': 'webm',\r\n        'video/ogg': 'ogg',\r\n        'video/mp4': 'mp4',\r\n\r\n        'audio/weba': 'weba',\r\n        'audio/ogg': null,\r\n        'audio/mp4': null,\r\n        'audio/mpeg': 'mpeg',\r\n        'audio/wav': 'wav',\r\n        'audio/midi': 'midi',\r\n\r\n        'application/ogg': null,\r\n        'application/pdf': 'pdf',\r\n        'application/msword': 'doc',\r\n        'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'docx',\r\n        'application/vnd.ms-excel': 'xls',\r\n        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',\r\n        'application/vnd.ms-powerpoint': 'ppt',\r\n        'application/vnd.openxmlformats-officedocument.presentationml.presentation': 'pptx'\r\n      })\r\n    },\r\n    fileValidateTypeDetectType: { type: Function, default: null },\r\n    // Plugin Size Validation\r\n    allowFileSizeValidation: { type: Boolean, default: true },\r\n    maxFileSize: { type: Number, default: null }, // e.g. 123456 (bytes)\r\n    maxTotalFileSize: { type: Number, default: null }, // e.g. 12345678765 (bytes)\r\n    labelMaxFileSizeExceeded: { type: String, default: null },\r\n    labelMaxFileSize: { type: String, default: null },\r\n    labelMaxTotalFileSizeExceeded: { type: String, default: null },\r\n    labelMaxTotalFileSize: { type: String, default: null }\r\n  },\r\n  data () {\r\n    return {\r\n      // https://pqina.nl/filepond/docs/patterns/api/server/\r\n      controlServer: {\r\n        url: this.$http.defaults.baseURL,\r\n        process: { // Upload Files (POST)\r\n          url: this.$props.serverConfig.uploadUrl || FILE_ENDPOINT_DEFAULT_URLS.upload\r\n        },\r\n        patch: null, // Upload chunked Files (PATCH)\r\n        restore: { // Load temporary uploaded File (GET)\r\n          url: this.$props.serverConfig.downloadUrl || FILE_ENDPOINT_DEFAULT_URLS.delete\r\n        },\r\n        load: { // Load uploaded File (GET)\r\n          url: this.$props.serverConfig.downloadUrl || FILE_ENDPOINT_DEFAULT_URLS.delete\r\n        },\r\n        fetch: null, // Load Files from remote Server (GET)\r\n        revert: { // Delete temporary uploaded File (DELETE)\r\n          url: this.$props.serverConfig.uploadUrl || FILE_ENDPOINT_DEFAULT_URLS.upload\r\n        },\r\n        // Delete uploaded File (DELETE)\r\n        // this can only be null or a callback function, e.g.\r\n        // visit https://pqina.nl/filepond/docs/patterns/api/server/#remove-1 for further informations\r\n        remove: this.removeFileFromServer,\r\n        removeUrl: this.$props.serverConfig.deleteUrl || FILE_ENDPOINT_DEFAULT_URLS.delete\r\n      },\r\n      control: {\r\n        // Swagger-Definition: http://pim.ebi-pharm.ch/swagger/#operations-tag-Produkte\r\n        id: this.$props.id,\r\n        name: this.$props.name,\r\n        form: this.$props.form,\r\n        formGroupClass: this.$props.formGroupClass,\r\n        controlClass: this.$props.controlClass,\r\n        label: this.$props.label,\r\n        files: this.createInitialFiles(),\r\n        value: this.$props.value,\r\n        labelSrOnly: this.$props.labelSrOnly,\r\n        labelHide: this.$props.labelHide,\r\n        labelCols: this.$props.labelCols,\r\n        labelColsSM: this.$props.labelColsSM,\r\n        labelColsMD: this.$props.labelColsMD,\r\n        labelColsLG: this.$props.labelColsLG,\r\n        labelColsXL: this.$props.labelColsXL,\r\n        labelAlign: this.$props.labelAlign,\r\n        labelAlignSM: this.$props.labelAlignSM,\r\n        labelAlignMD: this.$props.labelAlignMD,\r\n        labelAlignLG: this.$props.labelAlignLG,\r\n        labelAlignXL: this.$props.labelAlignXL,\r\n        description: this.$props.description,\r\n        readonly: this.$props.readonly,\r\n        disabled: this.$props.disabled,\r\n        dirty: this.$props.dirty,\r\n        validations: this.$props.validations,\r\n        feedbacksValid: this.$props.feedbacksValid,\r\n        feedbacksInvalid: this.$props.feedbacksInvalid,\r\n        // FilePond\r\n        allowDrop: this.$props.allowDrop,\r\n        allowBrowse: this.$props.allowBrowse,\r\n        allowPaste: this.$props.allowPaste,\r\n        // allowMultiple: this.$props.allowMultiple,\r\n        allowReplace: this.$props.allowReplace,\r\n        allowRevert: this.$props.allowRevert,\r\n        allowRemove: this.$props.allowRemove,\r\n        allowProcess: this.$props.allowProcess,\r\n        allowReorder: this.$props.allowReorder,\r\n        forceRevert: this.$props.forceRevert,\r\n        maxFiles: this.$props.maxFiles,\r\n        checkValidity: this.$props.checkValidity,\r\n        itemInsertLocation: this.$props.itemInsertLocation,\r\n        itemInsertInterval: this.$props.itemInsertInterval,\r\n        dropOnPage: this.$props.dropOnPage,\r\n        dropOnElement: this.$props.dropOnElement,\r\n        dropValidation: this.$props.dropValidation,\r\n        ignoredFiles: this.$props.ignoredFiles,\r\n        instantUpload: this.$props.instantUpload,\r\n        labelDecimalSeparator: this.$props.labelDecimalSeparator,\r\n        labelThousandsSeparator: this.$props.labelThousandsSeparator,\r\n        labelIdle: this.$props.labelIdle || this.$T('components.controls.file.label.idle', { br: '<br/>', browse: `<span class=\"filepond--label-action\">${this.$T('components.controls.file.label.browse')}</span>` }),\r\n        labelInvalidField: this.$props.labelInvalidField || this.$T('components.controls.file.label.InvalidField'),\r\n        labelFileWaitingForSize: this.$props.labelFileWaitingForSize || this.$T('components.controls.file.label.FileWaitingForSize'),\r\n        labelFileSizeNotAvailable: this.$props.labelFileSizeNotAvailable || this.$T('components.controls.file.label.FileSizeNotAvailable'),\r\n        labelFileLoading: this.$props.labelFileLoading || this.$T('components.controls.file.label.FileLoading'),\r\n        labelFileLoadError: this.$props.labelFileLoadError || this.$T('components.controls.file.label.FileLoadError'),\r\n        labelFileProcessing: this.$props.labelFileProcessing || this.$T('components.controls.file.label.FileProcessing'),\r\n        labelFileProcessingComplete: this.$props.labelFileProcessingComplete || this.$T('components.controls.file.label.FileProcessingComplete'),\r\n        labelFileProcessingAborted: this.$props.labelFileProcessingAborted || this.$T('components.controls.file.label.FileProcessingAborted'),\r\n        labelFileProcessingError: this.$props.labelFileProcessingError || this.$T('components.controls.file.label.FileProcessingError'),\r\n        labelFileProcessingRevertError: this.$props.labelFileProcessingRevertError || this.$T('components.controls.file.label.FileProcessingRevertError'),\r\n        labelFileRemoveError: this.$props.labelFileRemoveError || this.$T('components.controls.file.label.FileRemoveError'),\r\n        labelTapToCancel: this.$props.labelTapToCancel || this.$T('components.controls.file.label.TapToCancel'),\r\n        labelTapToRetry: this.$props.labelTapToRetry || this.$T('components.controls.file.label.TapToRetry'),\r\n        labelTapToUndo: this.$props.labelTapToUndo || this.$T('components.controls.file.label.TapToUndo'),\r\n        labelButtonRemoveItem: this.$props.labelButtonRemoveItem || this.$T('components.controls.file.label.ButtonRemoveItem'),\r\n        labelButtonAbortItemLoad: this.$props.labelButtonAbortItemLoad || this.$T('components.controls.file.label.ButtonAbortItemLoad'),\r\n        labelButtonRetryItemLoad: this.$props.labelButtonRetryItemLoad || this.$T('components.controls.file.label.ButtonRetryItemLoad'),\r\n        labelButtonAbortItemProcessing: this.$props.labelButtonAbortItemProcessing || this.$T('components.controls.file.label.ButtonAbortItemProcessing'),\r\n        labelButtonUndoItemProcessing: this.$props.labelButtonUndoItemProcessing || this.$T('components.controls.file.label.ButtonUndoItemProcessing'),\r\n        labelButtonRetryItemProcessing: this.$props.labelButtonRetryItemProcessing || this.$T('components.controls.file.label.ButtonRetryItemProcessing'),\r\n        labelButtonProcessItem: this.$props.labelButtonProcessItem || this.$T('components.controls.file.label.ButtonProcessItem'),\r\n        // Plugin Type Validation\r\n        allowFileTypeValidation: this.$props.allowFileTypeValidation,\r\n        acceptedFileTypes: this.$props.acceptedFileTypes,\r\n        labelFileTypeNotAllowed: this.$props.labelFileTypeNotAllowed || this.$T('components.controls.file.label.FileTypeNotAllowed'),\r\n        fileValidateTypeLabelExpectedTypes: this.$props.fileValidateTypeLabelExpectedTypes || this.$T('components.controls.file.label.FileExpectedTypes'),\r\n        fileValidateTypeLabelExpectedTypesMap: this.$props.fileValidateTypeLabelExpectedTypesMap,\r\n        fileValidateTypeDetectType: this.$props.fileValidateTypeDetectType,\r\n        // Plugin Size Validation\r\n        allowFileSizeValidation: this.$props.allowFileSizeValidation,\r\n        maxFileSize: parseInt(this.$props.maxFileSize),\r\n        maxTotalFileSize: parseInt(this.$props.maxTotalFileSize),\r\n        labelMaxFileSizeExceeded: this.$props.labelMaxFileSizeExceeded || this.$T('components.controls.file.label.MaxFileSizeExceeded'),\r\n        labelMaxFileSize: this.$props.labelMaxFileSize || this.$T('components.controls.file.label.MaxFileSize'),\r\n        labelMaxTotalFileSizeExceeded: this.$props.labelMaxTotalFileSizeExceeded || this.$T('components.controls.file.label.MaxTotalFileSizeExceeded'),\r\n        labelMaxTotalFileSize: this.$props.labelMaxTotalFileSize || this.$T('components.controls.file.label.MaxTotalFileSize')\r\n      },\r\n      isResetting: false\r\n    }\r\n  },\r\n  validations () {\r\n    return {\r\n      control: {\r\n        value: this.control.validations\r\n      }\r\n    }\r\n  },\r\n  computed: {\r\n    validator () {\r\n      return this.$v.control.value\r\n    },\r\n    controlCanValidate () {\r\n      if (this.validator !== undefined) return this.validator.$model !== undefined ? Object.keys(this.validator.$params).length > 0 : false\r\n      return false\r\n    },\r\n    controlState () {\r\n      if (this.controlCanValidate) return this.validator.$dirty ? !this.validator.$error : null\r\n      if (this.control.state !== null) return this.control.dirty ? this.control.state : null\r\n      return this.control.dirty ? true : null\r\n    },\r\n    controlInvalidFeedbacks () {\r\n      if (this.controlCanValidate) {\r\n        const validations = Object.keys(this.validator.$params || {})\r\n        const feedbacks = this.feedbacksInvalid || {}\r\n        const error = validations.find(key => this.validator[key] === false) || ''\r\n\r\n        return this.validator.$error ? feedbacks[error] instanceof Function ? feedbacks[error]() : feedbacks[error] || '' : ''\r\n      }\r\n\r\n      return ''\r\n    },\r\n    formGroupClasses () {\r\n      return [\r\n        {\r\n          'is-disabled': this.control.disabled,\r\n          'is-required': this.controlCanValidate,\r\n          'is-dirty': this.controlCanValidate ? this.validator.$dirty : false\r\n        }\r\n      ].concat(this.control.formGroupClass || [])\r\n    },\r\n    controlClasses () {\r\n      return [\r\n        'form-control',\r\n        {\r\n          'is-valid': this.controlState === true,\r\n          'is-invalid': this.controlState === false\r\n        }\r\n      ].concat(this.control.controlClass || [])\r\n    }\r\n  },\r\n  methods: {\r\n    createInitialFiles () {\r\n      return []\r\n        .concat(this.$props.value)\r\n        .map(f => ({ source: f, options: { type: 'local' } }))\r\n    },\r\n    updateValueByFiles () {\r\n      const oldValue = copy(this.control.value)\r\n      const value = (this.$refs.filepond ? this.$refs.filepond.getFiles() : []).map(f => f.serverId)\r\n\r\n      this.control.value = value\r\n\r\n      if (this.hardChange) this.hardChange(this.control.value)\r\n      if (this.control.value !== oldValue) this.onControlChange(this.control.value)\r\n    },\r\n    setDirty (dirty) {\r\n      if (this.controlCanValidate) {\r\n        if (dirty) {\r\n          this.validator.$touch()\r\n        } else {\r\n          this.validator.$reset()\r\n        }\r\n      }\r\n    },\r\n    onProcessFile (error, file) {\r\n      if (error) throw error\r\n\r\n      this.updateValueByFiles()\r\n    },\r\n    onRemoveFile (error, file) {\r\n      if (error) throw error\r\n\r\n      if (this.isResetting) {\r\n        this.isResetting = false\r\n        return\r\n      }\r\n\r\n      this.updateValueByFiles()\r\n    },\r\n    onControlChange (controlValue) {\r\n      if (this.controlCanValidate) {\r\n        this.validator.$model = controlValue\r\n        this.validator.$touch()\r\n      }\r\n\r\n      this.$emit('change', controlValue)\r\n    },\r\n    removeFileFromServer (source, load, error) {\r\n      this.$http({\r\n        method: 'delete',\r\n        url: this.controlServer.removeUrl,\r\n        data: source\r\n      })\r\n        .then(response => {\r\n          load()\r\n        })\r\n        .catch(error)\r\n    },\r\n    onReset () {\r\n      this.isResetting = true\r\n\r\n      this.$refs.filepond.getFiles()\r\n        .filter(f => f.origin !== FileOrigin.LOCAL)\r\n        .forEach(f => {\r\n          this.$refs.filepond.removeFile(f.id)\r\n        })\r\n\r\n      this.updateValueByFiles()\r\n\r\n      this.$nextTick(() => {\r\n        this.validator.$reset()\r\n\r\n        this.$nextTick(() => {\r\n          this.isResetting = false\r\n        })\r\n      })\r\n    },\r\n    onClick (event) {\r\n      if (event.target.classList.contains('filepond--download-icon')) event.stopPropagation()\r\n    }\r\n  },\r\n  created () {\r\n    this.setDirty(this.control.dirty)\r\n  },\r\n  mounted () {\r\n    this.$nextTick(() => {\r\n      this.updateValueByFiles()\r\n      this.$root.$emit('control:ready', Object.assign(this.control, { $touch: this.validator.$touch, $reset: this.onReset }))\r\n    })\r\n  },\r\n  watch: {\r\n    '$props.id' (id) { this.control.id = id },\r\n    '$props.name' (name) { this.control.name = name },\r\n    '$props.form' (form) { this.control.form = form },\r\n    '$props.formGroupClass' (formGroupClass) { this.control.formGroupClass = formGroupClass },\r\n    '$props.controlClass' (controlClass) { this.control.controlClass = controlClass },\r\n    '$props.label' (label) { this.control.label = label },\r\n    '$props.labelSrOnly' (labelSrOnly) { this.control.labelSrOnly = labelSrOnly },\r\n    '$props.labelHide' (labelHide) { this.control.labelHide = labelHide },\r\n    '$props.labelCols' (labelCols) { this.control.labelCols = labelCols },\r\n    '$props.labelColsSM' (labelColsSM) { this.control.labelColsSM = labelColsSM },\r\n    '$props.labelColsMD' (labelColsMD) { this.control.labelColsMD = labelColsMD },\r\n    '$props.labelColsLG' (labelColsLG) { this.control.labelColsLG = labelColsLG },\r\n    '$props.labelColsXL' (labelColsXL) { this.control.labelColsXL = labelColsXL },\r\n    '$props.labelAlign' (labelAlign) { this.control.labelAlign = labelAlign },\r\n    '$props.labelAlignSM' (labelAlignSM) { this.control.labelAlignSM = labelAlignSM },\r\n    '$props.labelAlignMD' (labelAlignMD) { this.control.labelAlignMD = labelAlignMD },\r\n    '$props.labelAlignLG' (labelAlignLG) { this.control.labelAlignLG = labelAlignLG },\r\n    '$props.labelAlignXL' (labelAlignXL) { this.control.labelAlignXL = labelAlignXL },\r\n    '$props.value' (value) { /* ignore changes as filePond handles its state on his own */ },\r\n    '$props.description' (description) { this.control.description = description },\r\n    '$props.readonly' (readonly) { this.control.readonly = readonly },\r\n    '$props.disabled' (disabled) { this.control.disabled = disabled },\r\n    '$props.dirty' (dirty) {\r\n      this.control.dirty = dirty\r\n      this.setDirty(this.control.dirty)\r\n    },\r\n    '$props.validations' (validations) { this.control.validations = validations },\r\n    // '$props.validator.$dirty' ($dirty) { if (!$dirty) this.reset() },\r\n    '$props.feedbacksValid' (feedbacksValid) { this.control.feedbacksValid = feedbacksValid },\r\n    '$props.feedbacksInvalid' (feedbacksInvalid) { this.control.feedbacksInvalid = feedbacksInvalid },\r\n    // FilePond\r\n    '$props.serverConfig' (serverConfig) {\r\n      if (serverConfig.uploadUrl) {\r\n        this.controlServer.process.url = serverConfig.uploadUrl\r\n        this.controlServer.revert.url = serverConfig.uploadUrl\r\n        this.controlServer.removeUrl = serverConfig.uploadUrl\r\n      }\r\n\r\n      if (serverConfig.downloadUrl) {\r\n        this.controlServer.restore.url = serverConfig.downloadUrl\r\n        this.controlServer.load.url = serverConfig.downloadUrl\r\n      }\r\n    },\r\n    '$props.allowDrop' (allowDrop) { this.control.allowDrop = allowDrop },\r\n    '$props.allowBrowse' (allowBrowse) { this.control.allowBrowse = allowBrowse },\r\n    '$props.allowPaste' (allowPaste) { this.control.allowPaste = allowPaste },\r\n    // '$props.allowMultiple' (allowMultiple) { this.control.allowMultiple = allowMultiple },\r\n    '$props.allowReplace' (allowReplace) { this.control.allowReplace = allowReplace },\r\n    '$props.allowRevert' (allowRevert) { this.control.allowRevert = allowRevert },\r\n    '$props.allowRemove' (allowRemove) { this.control.allowRemove = allowRemove },\r\n    '$props.allowProcess' (allowProcess) { this.control.allowProcess = allowProcess },\r\n    '$props.allowReorder' (allowReorder) { this.control.allowReorder = allowReorder },\r\n    '$props.forceRevert' (forceRevert) { this.control.forceRevert = forceRevert },\r\n    '$props.maxFiles' (maxFiles) { this.control.maxFiles = maxFiles },\r\n    '$props.checkValidity' (checkValidity) { this.control.checkValidity = checkValidity },\r\n    '$props.itemInsertLocation' (itemInsertLocation) { this.control.itemInsertLocation = itemInsertLocation },\r\n    '$props.itemInsertInterval' (itemInsertInterval) { this.control.itemInsertInterval = itemInsertInterval },\r\n    '$props.dropOnPage' (dropOnPage) { this.control.dropOnPage = dropOnPage },\r\n    '$props.dropOnElement' (dropOnElement) { this.control.dropOnElement = dropOnElement },\r\n    '$props.dropValidation' (dropValidation) { this.control.dropValidation = dropValidation },\r\n    '$props.ignoredFiles' (ignoredFiles) { this.control.ignoredFiles = ignoredFiles },\r\n    '$props.instantUpload' (instantUpload) { this.control.instantUpload = instantUpload },\r\n    '$props.labelDecimalSeparator' (labelDecimalSeparator) { this.control.labelDecimalSeparator = labelDecimalSeparator },\r\n    '$props.labelThousandsSeparator' (labelThousandsSeparator) { this.control.labelThousandsSeparator = labelThousandsSeparator },\r\n    '$props.labelIdle' (labelIdle) { this.control.labelIdle = labelIdle },\r\n    '$props.labelInvalidField' (labelInvalidField) { this.control.labelInvalidField = labelInvalidField },\r\n    '$props.labelFileWaitingForSize' (labelFileWaitingForSize) { this.control.labelFileWaitingForSize = labelFileWaitingForSize },\r\n    '$props.labelFileSizeNotAvailable' (labelFileSizeNotAvailable) { this.control.labelFileSizeNotAvailable = labelFileSizeNotAvailable },\r\n    '$props.labelFileLoading' (labelFileLoading) { this.control.labelFileLoading = labelFileLoading },\r\n    '$props.labelFileLoadError' (labelFileLoadError) { this.control.labelFileLoadError = labelFileLoadError },\r\n    '$props.labelFileProcessing' (labelFileProcessing) { this.control.labelFileProcessing = labelFileProcessing },\r\n    '$props.labelFileProcessingComplete' (labelFileProcessingComplete) { this.control.labelFileProcessingComplete = labelFileProcessingComplete },\r\n    '$props.labelFileProcessingAborted' (labelFileProcessingAborted) { this.control.labelFileProcessingAborted = labelFileProcessingAborted },\r\n    '$props.labelFileProcessingError' (labelFileProcessingError) { this.control.labelFileProcessingError = labelFileProcessingError },\r\n    '$props.labelFileProcessingRevertError' (labelFileProcessingRevertError) { this.control.labelFileProcessingRevertError = labelFileProcessingRevertError },\r\n    '$props.labelFileRemoveError' (labelFileRemoveError) { this.control.labelFileRemoveError = labelFileRemoveError },\r\n    '$props.labelTapToCancel' (labelTapToCancel) { this.control.labelTapToCancel = labelTapToCancel },\r\n    '$props.labelTapToRetry' (labelTapToRetry) { this.control.labelTapToRetry = labelTapToRetry },\r\n    '$props.labelTapToUndo' (labelTapToUndo) { this.control.labelTapToUndo = labelTapToUndo },\r\n    '$props.labelButtonRemoveItem' (labelButtonRemoveItem) { this.control.labelButtonRemoveItem = labelButtonRemoveItem },\r\n    '$props.labelButtonAbortItemLoad' (labelButtonAbortItemLoad) { this.control.labelButtonAbortItemLoad = labelButtonAbortItemLoad },\r\n    '$props.labelButtonRetryItemLoad' (labelButtonRetryItemLoad) { this.control.labelButtonRetryItemLoad = labelButtonRetryItemLoad },\r\n    '$props.labelButtonAbortItemProcessing' (labelButtonAbortItemProcessing) { this.control.labelButtonAbortItemProcessing = labelButtonAbortItemProcessing },\r\n    '$props.labelButtonUndoItemProcessing' (labelButtonUndoItemProcessing) { this.control.labelButtonUndoItemProcessing = labelButtonUndoItemProcessing },\r\n    '$props.labelButtonRetryItemProcessing' (labelButtonRetryItemProcessing) { this.control.labelButtonRetryItemProcessing = labelButtonRetryItemProcessing },\r\n    '$props.labelButtonProcessItem' (labelButtonProcessItem) { this.control.labelButtonProcessItem = labelButtonProcessItem },\r\n    // Plugin Type Validation\r\n    '$props.allowFileTypeValidation' (allowFileTypeValidation) { this.control.allowFileTypeValidation = allowFileTypeValidation },\r\n    '$props.acceptedFileTypes' (acceptedFileTypes) { this.control.acceptedFileTypes = acceptedFileTypes },\r\n    '$props.labelFileTypeNotAllowed' (labelFileTypeNotAllowed) { this.control.labelFileTypeNotAllowed = labelFileTypeNotAllowed },\r\n    '$props.fileValidateTypeLabelExpectedTypes' (fileValidateTypeLabelExpectedTypes) { this.control.fileValidateTypeLabelExpectedTypes = fileValidateTypeLabelExpectedTypes },\r\n    '$props.fileValidateTypeLabelExpectedTypesMap' (fileValidateTypeLabelExpectedTypesMap) { this.control.fileValidateTypeLabelExpectedTypesMap = fileValidateTypeLabelExpectedTypesMap },\r\n    '$props.fileValidateTypeDetectType' (fileValidateTypeDetectType) { this.control.fileValidateTypeDetectType = fileValidateTypeDetectType },\r\n    // Plugin Size Validation\r\n    '$props.allowFileSizeValidation' (allowFileSizeValidation) { this.control.allowFileSizeValidation = allowFileSizeValidation },\r\n    '$props.maxFileSize' (maxFileSize) { this.control.maxFileSize = parseInt(maxFileSize) },\r\n    '$props.maxTotalFileSize' (maxTotalFileSize) { this.control.maxTotalFileSize = parseInt(maxTotalFileSize) },\r\n    '$props.labelMaxFileSizeExceeded' (labelMaxFileSizeExceeded) { this.control.labelMaxFileSizeExceeded = labelMaxFileSizeExceeded },\r\n    '$props.labelMaxFileSize' (labelMaxFileSize) { this.control.labelMaxFileSize = labelMaxFileSize },\r\n    '$props.labelMaxTotalFileSizeExceeded' (labelMaxTotalFileSizeExceeded) { this.control.labelMaxTotalFileSizeExceeded = labelMaxTotalFileSizeExceeded },\r\n    '$props.labelMaxTotalFileSize' (labelMaxTotalFileSize) { this.control.labelMaxTotalFileSize = labelMaxTotalFileSize }\r\n  }\r\n}\r\n</script>\r\n\r\n<style lang=\"scss\">\r\n@import '~filepond/dist/filepond.min.css';\r\n@import '~filepond-plugin-get-file/dist/filepond-plugin-get-file.min.css';\r\n\r\n$control-files-drop-bg: $gray-200 !default;\r\n\r\n$control-files-drop-label-min-height: 50px !default;\r\n$control-files-drop-label-font-size: $font-size-sm !default;\r\n$control-files-drop-label-font-weight: $font-weight-base !default;\r\n$control-files-drop-label-line-height: inherit !default;\r\n\r\n.control-files {\r\n  .form-control {\r\n    padding: 0;\r\n    height: auto;\r\n    background-color: $control-files-drop-bg;\r\n  }\r\n\r\n  .filepond--root {\r\n    margin: 0;\r\n\r\n    .filepond--drop-label {\r\n      min-height: $control-files-drop-label-min-height;\r\n\r\n      label {\r\n        font-size: $control-files-drop-label-font-size;\r\n        font-weight: $control-files-drop-label-font-weight;\r\n        line-height: $control-files-drop-label-line-height;\r\n      }\r\n    }\r\n\r\n    .filepond--list-scroller {\r\n      .filepond--list {\r\n        .filepond--item {\r\n          .filepond--file-wrapper {\r\n            .filepond--file {\r\n              .filepond--file-status {\r\n                max-width: 80%;\r\n\r\n                .filepond--file-status-main {\r\n                  font-size: 11px;\r\n                }\r\n\r\n                .filepond--file-status-sub {\r\n                  display: block;\r\n                  margin-top: 0.1em;\r\n                  font-size: 10px;\r\n                  line-height: 1;\r\n                  white-space: normal;\r\n                }\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    .filepond--panel {\r\n      .filepond--panel-root {\r\n        background-color: transparent;\r\n      }\r\n    }\r\n  }\r\n\r\n  &.is-disabled {\r\n    .form-control {\r\n      background-color: transparent;\r\n      border: 0 none;\r\n\r\n      .filepond--root {\r\n        .filepond--drop-label {\r\n          display: none;\r\n        }\r\n\r\n        .filepond--list-scroller {\r\n          margin-top: 0;\r\n          margin-bottom: 0;\r\n        }\r\n      }\r\n    }\r\n  }\r\n}\r\n</style>\r\n","import mod from \"-!../../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../../node_modules/thread-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./ControlFiles.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../../node_modules/thread-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./ControlFiles.vue?vue&type=script&lang=js&\"","import { render, staticRenderFns } from \"./ControlFiles.vue?vue&type=template&id=1032dea8&\"\nimport script from \"./ControlFiles.vue?vue&type=script&lang=js&\"\nexport * from \"./ControlFiles.vue?vue&type=script&lang=js&\"\nimport style0 from \"./ControlFiles.vue?vue&type=style&index=0&lang=scss&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","/*!\n * vue-filepond v6.0.3\n * A handy FilePond adapter component for Vue\n * \n * Copyright (c) 2020 PQINA\n * https://pqina.nl/filepond\n * \n * Licensed under the MIT license.\n */\n\n(function (global, factory) {\n  if (typeof define === \"function\" && define.amd) {\n    define(\"vueFilePond\", [\"exports\", \"vue\", \"filepond\"], factory);\n  } else if (typeof exports !== \"undefined\") {\n    factory(exports, require(\"vue\"), require(\"filepond\"));\n  } else {\n    var mod = {\n      exports: {}\n    };\n    factory(mod.exports, global.Vue, global.FilePond);\n    global.vueFilePond = mod.exports;\n  }\n})(typeof globalThis !== \"undefined\" ? globalThis : typeof self !== \"undefined\" ? self : this, function (_exports, _vue, _filepond) {\n  \"use strict\";\n\n  Object.defineProperty(_exports, \"__esModule\", {\n    value: true\n  });\n  _exports.default = _exports.setOptions = void 0;\n  _vue = _interopRequireDefault(_vue);\n\n  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n  // Methods not made available to the component\n  var filteredComponentMethods = ['setOptions', 'on', 'off', 'onOnce', 'appendTo', 'insertAfter', 'insertBefore', 'isAttachedTo', 'replaceElement', 'restoreElement', 'destroy']; // Test if is supported on this client\n\n  var isSupported = (0, _filepond.supported)(); // Setup initial prop types and update when plugins are added\n\n  var getNativeConstructorFromType = function getNativeConstructorFromType(type) {\n    return {\n      string: String,\n      boolean: Boolean,\n      array: Array,\n      function: Function,\n      int: Number,\n      serverapi: Object,\n      object: Object\n    }[type];\n  }; // Activated props\n\n\n  var props = {}; // Events that need to be mapped to emitters\n\n  var events = []; // Props to watch\n\n  var watch = {}; // all active instances\n\n  var instances = []; // global options\n\n  var globalOptions = {};\n\n  var setOptions = function setOptions(options) {\n    globalOptions = Object.assign(globalOptions, options);\n    instances.forEach(function (instance) {\n      instance.setOptions(globalOptions);\n    });\n  };\n\n  _exports.setOptions = setOptions;\n\n  var _default = function _default() {\n    // register plugins in FilePond\n    _filepond.registerPlugin.apply(void 0, arguments); // build events and props array\n\n\n    events.length = 0;\n\n    var _loop = function _loop(prop) {\n      // don't add events to the props array\n      if (/^on/.test(prop)) {\n        events.push(prop);\n        return \"continue\";\n      } // get property type ( can be either a String or the type defined within FilePond )\n\n\n      props[prop] = [String, getNativeConstructorFromType(_filepond.OptionTypes[prop])]; // setup watcher\n\n      watch[prop] = function (value) {\n        this._pond[prop] = value;\n      };\n    };\n\n    for (var prop in _filepond.OptionTypes) {\n      var _ret = _loop(prop);\n\n      if (_ret === \"continue\") continue;\n    } // create \n\n\n    return _vue.default.component('FilePond', {\n      name: 'FilePond',\n      props: props,\n      watch: watch,\n      render: function render(h) {\n        return h('div', {\n          'class': {\n            'filepond--wrapper': true\n          }\n        }, [h('input', {\n          attrs: {\n            id: this.id,\n            name: this.name,\n            type: 'file',\n            'class': this.className,\n            required: this.required,\n            multiple: this.allowMultiple,\n            accept: this.acceptedFileTypes,\n            capture: this.captureMethod\n          }\n        })]);\n      },\n      // Will setup FilePond instance when mounted\n      mounted: function mounted() {\n        var _this = this;\n\n        // exit here if not supported\n        if (!isSupported) {\n          return;\n        } // get pond element\n\n\n        this._element = this.$el.querySelector('input'); // Map FilePond callback methods to Vue $emitters\n\n        var options = events.reduce(function (obj, value) {\n          obj[value] = function () {\n            _this.$emit('input', _this._pond ? _this._pond.getFiles() : []);\n\n            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n              args[_key] = arguments[_key];\n            }\n\n            _this.$emit.apply(_this, [value.substr(2)].concat(args));\n          };\n\n          return obj;\n        }, {}); // Scoop up attributes that might not have been caught by Vue ( because the props object is extended dynamically )\n\n        var attrs = Object.assign({}, this.$attrs); // Create our pond\n\n        this._pond = (0, _filepond.create)(this._element, Object.assign({}, globalOptions, options, attrs, this.$options.propsData)); // Copy instance method references to component instance\n\n        Object.keys(this._pond).filter(function (key) {\n          return !filteredComponentMethods.includes(key);\n        }).forEach(function (key) {\n          _this[key] = _this._pond[key];\n        }); // Add to instances so we can apply global options when used\n\n        instances.push(this._pond);\n      },\n      // Will clean up FilePond instance when unmounted\n      destroyed: function destroyed() {\n        var _this2 = this;\n\n        // reference to detached method\n        var detached = this.$options.detached; // no longer attached, clean up\n\n        if (!this.$el.offsetParent) {\n          detached.call(this);\n          return;\n        } // if we're still attached it's likely a transition is running, we need to \n        // determine the moment when we're no longer attached to the DOM so we can \n        // clean up properly\n\n\n        var mutationHandler = function mutationHandler(mutations, observer) {\n          var removedNodes = (mutations[0] || {}).removedNodes || [];\n          var removedNode = removedNodes[0];\n          if (!removedNode || !removedNode.contains(_this2.$el)) return;\n          observer.disconnect();\n          detached.call(_this2);\n        }; // start observing parent element for changes to the DOM\n\n\n        var observer = new MutationObserver(mutationHandler);\n        observer.observe(document.documentElement, {\n          childList: true,\n          subtree: true\n        });\n      },\n      // called when the component root node has been detached\n      detached: function detached() {\n        // exit when no pond defined\n        if (!this._pond) return; // bye bye pond\n\n        this._pond.destroy(); // remove from instances\n\n\n        var index = instances.indexOf(this._pond);\n\n        if (index >= 0) {\n          instances.splice(index, 1);\n        } // clear reference\n\n\n        this._pond = null;\n      }\n    });\n  };\n\n  _exports.default = _default;\n});\n\n\n","/*!\n * FilePondPluginFileValidateType 1.2.6\n * Licensed under MIT, https://opensource.org/licenses/MIT/\n * Please visit https://pqina.nl/filepond/ for details.\n */\n\n/* eslint-disable */\n\n(function(global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined'\n    ? (module.exports = factory())\n    : typeof define === 'function' && define.amd\n    ? define(factory)\n    : ((global = global || self),\n      (global.FilePondPluginFileValidateType = factory()));\n})(this, function() {\n  'use strict';\n\n  var plugin = function plugin(_ref) {\n    var addFilter = _ref.addFilter,\n      utils = _ref.utils;\n    // get quick reference to Type utils\n    var Type = utils.Type,\n      isString = utils.isString,\n      replaceInString = utils.replaceInString,\n      guesstimateMimeType = utils.guesstimateMimeType,\n      getExtensionFromFilename = utils.getExtensionFromFilename,\n      getFilenameFromURL = utils.getFilenameFromURL;\n\n    var mimeTypeMatchesWildCard = function mimeTypeMatchesWildCard(\n      mimeType,\n      wildcard\n    ) {\n      var mimeTypeGroup = (/^[^/]+/.exec(mimeType) || []).pop(); // image/png -> image\n      var wildcardGroup = wildcard.slice(0, -2); // image/* -> image\n      return mimeTypeGroup === wildcardGroup;\n    };\n\n    var isValidMimeType = function isValidMimeType(\n      acceptedTypes,\n      userInputType\n    ) {\n      return acceptedTypes.some(function(acceptedType) {\n        // accepted is wildcard mime type\n        if (/\\*$/.test(acceptedType)) {\n          return mimeTypeMatchesWildCard(userInputType, acceptedType);\n        }\n\n        // is normal mime type\n        return acceptedType === userInputType;\n      });\n    };\n\n    var getItemType = function getItemType(item) {\n      // if the item is a url we guess the mime type by the extension\n      var type = '';\n      if (isString(item)) {\n        var filename = getFilenameFromURL(item);\n        var extension = getExtensionFromFilename(filename);\n        if (extension) {\n          type = guesstimateMimeType(extension);\n        }\n      } else {\n        type = item.type;\n      }\n\n      return type;\n    };\n\n    var validateFile = function validateFile(\n      item,\n      acceptedFileTypes,\n      typeDetector\n    ) {\n      // no types defined, everything is allowed \\o/\n      if (acceptedFileTypes.length === 0) {\n        return true;\n      }\n\n      // gets the item type\n      var type = getItemType(item);\n\n      // no type detector, test now\n      if (!typeDetector) {\n        return isValidMimeType(acceptedFileTypes, type);\n      }\n\n      // use type detector\n      return new Promise(function(resolve, reject) {\n        typeDetector(item, type)\n          .then(function(detectedType) {\n            if (isValidMimeType(acceptedFileTypes, detectedType)) {\n              resolve();\n            } else {\n              reject();\n            }\n          })\n          .catch(reject);\n      });\n    };\n\n    var applyMimeTypeMap = function applyMimeTypeMap(map) {\n      return function(acceptedFileType) {\n        return map[acceptedFileType] === null\n          ? false\n          : map[acceptedFileType] || acceptedFileType;\n      };\n    };\n\n    // setup attribute mapping for accept\n    addFilter('SET_ATTRIBUTE_TO_OPTION_MAP', function(map) {\n      return Object.assign(map, {\n        accept: 'acceptedFileTypes'\n      });\n    });\n\n    // filtering if an item is allowed in hopper\n    addFilter('ALLOW_HOPPER_ITEM', function(file, _ref2) {\n      var query = _ref2.query;\n      // if we are not doing file type validation exit\n      if (!query('GET_ALLOW_FILE_TYPE_VALIDATION')) {\n        return true;\n      }\n\n      // we validate the file against the accepted file types\n      return validateFile(file, query('GET_ACCEPTED_FILE_TYPES'));\n    });\n\n    // called for each file that is loaded\n    // right before it is set to the item state\n    // should return a promise\n    addFilter('LOAD_FILE', function(file, _ref3) {\n      var query = _ref3.query;\n      return new Promise(function(resolve, reject) {\n        if (!query('GET_ALLOW_FILE_TYPE_VALIDATION')) {\n          resolve(file);\n          return;\n        }\n\n        var acceptedFileTypes = query('GET_ACCEPTED_FILE_TYPES');\n\n        // custom type detector method\n        var typeDetector = query('GET_FILE_VALIDATE_TYPE_DETECT_TYPE');\n\n        // if invalid, exit here\n        var validationResult = validateFile(\n          file,\n          acceptedFileTypes,\n          typeDetector\n        );\n\n        var handleRejection = function handleRejection() {\n          var acceptedFileTypesMapped = acceptedFileTypes\n            .map(\n              applyMimeTypeMap(\n                query('GET_FILE_VALIDATE_TYPE_LABEL_EXPECTED_TYPES_MAP')\n              )\n            )\n            .filter(function(label) {\n              return label !== false;\n            });\n\n          reject({\n            status: {\n              main: query('GET_LABEL_FILE_TYPE_NOT_ALLOWED'),\n              sub: replaceInString(\n                query('GET_FILE_VALIDATE_TYPE_LABEL_EXPECTED_TYPES'),\n                {\n                  allTypes: acceptedFileTypesMapped.join(', '),\n                  allButLastType: acceptedFileTypesMapped\n                    .slice(0, -1)\n                    .join(', '),\n                  lastType:\n                    acceptedFileTypesMapped[acceptedFileTypesMapped.length - 1]\n                }\n              )\n            }\n          });\n        };\n\n        // has returned new filename immidiately\n        if (typeof validationResult === 'boolean') {\n          if (!validationResult) {\n            return handleRejection();\n          }\n          return resolve(file);\n        }\n\n        // is promise\n        validationResult\n          .then(function() {\n            resolve(file);\n          })\n          .catch(handleRejection);\n      });\n    });\n\n    // expose plugin\n    return {\n      // default options\n      options: {\n        // Enable or disable file type validation\n        allowFileTypeValidation: [true, Type.BOOLEAN],\n\n        // What file types to accept\n        acceptedFileTypes: [[], Type.ARRAY],\n        // - must be comma separated\n        // - mime types: image/png, image/jpeg, image/gif\n        // - extensions: .png, .jpg, .jpeg ( not enabled yet )\n        // - wildcards: image/*\n\n        // label to show when a type is not allowed\n        labelFileTypeNotAllowed: ['File is of invalid type', Type.STRING],\n\n        // nicer label\n        fileValidateTypeLabelExpectedTypes: [\n          'Expects {allButLastType} or {lastType}',\n          Type.STRING\n        ],\n\n        // map mime types to extensions\n        fileValidateTypeLabelExpectedTypesMap: [{}, Type.OBJECT],\n\n        // Custom function to detect type of file\n        fileValidateTypeDetectType: [null, Type.FUNCTION]\n      }\n    };\n  };\n\n  // fire pluginloaded event if running in browser, this allows registering the plugin when using async script tags\n  var isBrowser =\n    typeof window !== 'undefined' && typeof window.document !== 'undefined';\n  if (isBrowser) {\n    document.dispatchEvent(\n      new CustomEvent('FilePond:pluginloaded', { detail: plugin })\n    );\n  }\n\n  return plugin;\n});\n","/*!\n * FilePondPluginFileValidateSize 2.2.5\n * Licensed under MIT, https://opensource.org/licenses/MIT/\n * Please visit https://pqina.nl/filepond/ for details.\n */\n\n/* eslint-disable */\n\n(function(global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined'\n        ? (module.exports = factory())\n        : typeof define === 'function' && define.amd\n        ? define(factory)\n        : ((global = global || self), (global.FilePondPluginFileValidateSize = factory()));\n})(this, function() {\n    'use strict';\n\n    var plugin = function plugin(_ref) {\n        var addFilter = _ref.addFilter,\n            utils = _ref.utils;\n        // get quick reference to Type utils\n        var Type = utils.Type,\n            replaceInString = utils.replaceInString,\n            toNaturalFileSize = utils.toNaturalFileSize;\n\n        // filtering if an item is allowed in hopper\n        addFilter('ALLOW_HOPPER_ITEM', function(file, _ref2) {\n            var query = _ref2.query;\n            if (!query('GET_ALLOW_FILE_SIZE_VALIDATION')) {\n                return true;\n            }\n\n            var sizeMax = query('GET_MAX_FILE_SIZE');\n            if (sizeMax !== null && file.size >= sizeMax) {\n                return false;\n            }\n\n            var sizeMin = query('GET_MIN_FILE_SIZE');\n            if (sizeMin !== null && file.size <= sizeMin) {\n                return false;\n            }\n\n            return true;\n        });\n\n        // called for each file that is loaded\n        // right before it is set to the item state\n        // should return a promise\n        addFilter('LOAD_FILE', function(file, _ref3) {\n            var query = _ref3.query;\n            return new Promise(function(resolve, reject) {\n                // if not allowed, all fine, exit\n                if (!query('GET_ALLOW_FILE_SIZE_VALIDATION')) {\n                    return resolve(file);\n                }\n\n                // check if file should be filtered\n                var fileFilter = query('GET_FILE_VALIDATE_SIZE_FILTER');\n                if (fileFilter && !fileFilter(file)) {\n                    return resolve(file);\n                }\n\n                // reject or resolve based on file size\n                var sizeMax = query('GET_MAX_FILE_SIZE');\n                if (sizeMax !== null && file.size >= sizeMax) {\n                    reject({\n                        status: {\n                            main: query('GET_LABEL_MAX_FILE_SIZE_EXCEEDED'),\n                            sub: replaceInString(query('GET_LABEL_MAX_FILE_SIZE'), {\n                                filesize: toNaturalFileSize(\n                                    sizeMax,\n                                    '.',\n                                    query('GET_FILE_SIZE_BASE'),\n                                    query('GET_FILE_SIZE_LABELS', query)\n                                ),\n                            }),\n                        },\n                    });\n\n                    return;\n                }\n\n                // reject or resolve based on file size\n                var sizeMin = query('GET_MIN_FILE_SIZE');\n                if (sizeMin !== null && file.size <= sizeMin) {\n                    reject({\n                        status: {\n                            main: query('GET_LABEL_MIN_FILE_SIZE_EXCEEDED'),\n                            sub: replaceInString(query('GET_LABEL_MIN_FILE_SIZE'), {\n                                filesize: toNaturalFileSize(\n                                    sizeMin,\n                                    '.',\n                                    query('GET_FILE_SIZE_BASE'),\n                                    query('GET_FILE_SIZE_LABELS', query)\n                                ),\n                            }),\n                        },\n                    });\n\n                    return;\n                }\n\n                // returns the current option value\n                var totalSizeMax = query('GET_MAX_TOTAL_FILE_SIZE');\n                if (totalSizeMax !== null) {\n                    // get the current total file size\n                    var currentTotalSize = query('GET_ACTIVE_ITEMS').reduce(function(total, item) {\n                        return total + item.fileSize;\n                    }, 0);\n\n                    // get the size of the new file\n                    if (currentTotalSize > totalSizeMax) {\n                        reject({\n                            status: {\n                                main: query('GET_LABEL_MAX_TOTAL_FILE_SIZE_EXCEEDED'),\n                                sub: replaceInString(query('GET_LABEL_MAX_TOTAL_FILE_SIZE'), {\n                                    filesize: toNaturalFileSize(\n                                        totalSizeMax,\n                                        '.',\n                                        query('GET_FILE_SIZE_BASE'),\n                                        query('GET_FILE_SIZE_LABELS', query)\n                                    ),\n                                }),\n                            },\n                        });\n\n                        return;\n                    }\n                }\n\n                // file is fine, let's pass it back\n                resolve(file);\n            });\n        });\n\n        return {\n            options: {\n                // Enable or disable file type validation\n                allowFileSizeValidation: [true, Type.BOOLEAN],\n\n                // Max individual file size in bytes\n                maxFileSize: [null, Type.INT],\n\n                // Min individual file size in bytes\n                minFileSize: [null, Type.INT],\n\n                // Max total file size in bytes\n                maxTotalFileSize: [null, Type.INT],\n\n                // Filter the files that need to be validated for size\n                fileValidateSizeFilter: [null, Type.FUNCTION],\n\n                // error labels\n                labelMinFileSizeExceeded: ['File is too small', Type.STRING],\n                labelMinFileSize: ['Minimum file size is {filesize}', Type.STRING],\n\n                labelMaxFileSizeExceeded: ['File is too large', Type.STRING],\n                labelMaxFileSize: ['Maximum file size is {filesize}', Type.STRING],\n\n                labelMaxTotalFileSizeExceeded: ['Maximum total size exceeded', Type.STRING],\n                labelMaxTotalFileSize: ['Maximum total file size is {filesize}', Type.STRING],\n            },\n        };\n    };\n\n    // fire pluginloaded event if running in browser, this allows registering the plugin when using async script tags\n    var isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';\n    if (isBrowser) {\n        document.dispatchEvent(new CustomEvent('FilePond:pluginloaded', { detail: plugin }));\n    }\n\n    return plugin;\n});\n","export * from \"-!../../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--8-oneOf-1-0!../../../node_modules/css-loader/dist/cjs.js??ref--8-oneOf-1-1!../../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../../node_modules/postcss-loader/src/index.js??ref--8-oneOf-1-2!../../../node_modules/sass-loader/dist/cjs.js??ref--8-oneOf-1-3!../../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./ControlFiles.vue?vue&type=style&index=0&lang=scss&\"","/*!\n * FilePond 4.25.1\n * Licensed under MIT, https://opensource.org/licenses/MIT/\n * Please visit https://pqina.nl/filepond/ for details.\n */\n\n/* eslint-disable */\n\n(function(global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined'\n    ? factory(exports)\n    : typeof define === 'function' && define.amd\n    ? define(['exports'], factory)\n    : ((global = global || self), factory((global.FilePond = {})));\n})(this, function(exports) {\n  'use strict';\n\n  var isNode = function isNode(value) {\n    return value instanceof HTMLElement;\n  };\n\n  var createStore = function createStore(initialState) {\n    var queries =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n    var actions =\n      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];\n    // internal state\n    var state = Object.assign({}, initialState);\n\n    // contains all actions for next frame, is clear when actions are requested\n    var actionQueue = [];\n    var dispatchQueue = [];\n\n    // returns a duplicate of the current state\n    var getState = function getState() {\n      return Object.assign({}, state);\n    };\n\n    // returns a duplicate of the actions array and clears the actions array\n    var processActionQueue = function processActionQueue() {\n      // create copy of actions queue\n      var queue = [].concat(actionQueue);\n\n      // clear actions queue (we don't want no double actions)\n      actionQueue.length = 0;\n\n      return queue;\n    };\n\n    // processes actions that might block the main UI thread\n    var processDispatchQueue = function processDispatchQueue() {\n      // create copy of actions queue\n      var queue = [].concat(dispatchQueue);\n\n      // clear actions queue (we don't want no double actions)\n      dispatchQueue.length = 0;\n\n      // now dispatch these actions\n      queue.forEach(function(_ref) {\n        var type = _ref.type,\n          data = _ref.data;\n        dispatch(type, data);\n      });\n    };\n\n    // adds a new action, calls its handler and\n    var dispatch = function dispatch(type, data, isBlocking) {\n      // is blocking action (should never block if document is hidden)\n      if (isBlocking && !document.hidden) {\n        dispatchQueue.push({ type: type, data: data });\n        return;\n      }\n\n      // if this action has a handler, handle the action\n      if (actionHandlers[type]) {\n        actionHandlers[type](data);\n      }\n\n      // now add action\n      actionQueue.push({\n        type: type,\n        data: data\n      });\n    };\n\n    var query = function query(str) {\n      var _queryHandles;\n      for (\n        var _len = arguments.length,\n          args = new Array(_len > 1 ? _len - 1 : 0),\n          _key = 1;\n        _key < _len;\n        _key++\n      ) {\n        args[_key - 1] = arguments[_key];\n      }\n      return queryHandles[str]\n        ? (_queryHandles = queryHandles)[str].apply(_queryHandles, args)\n        : null;\n    };\n\n    var api = {\n      getState: getState,\n      processActionQueue: processActionQueue,\n      processDispatchQueue: processDispatchQueue,\n      dispatch: dispatch,\n      query: query\n    };\n\n    var queryHandles = {};\n    queries.forEach(function(query) {\n      queryHandles = Object.assign({}, query(state), {}, queryHandles);\n    });\n\n    var actionHandlers = {};\n    actions.forEach(function(action) {\n      actionHandlers = Object.assign(\n        {},\n        action(dispatch, query, state),\n        {},\n        actionHandlers\n      );\n    });\n\n    return api;\n  };\n\n  var defineProperty = function defineProperty(obj, property, definition) {\n    if (typeof definition === 'function') {\n      obj[property] = definition;\n      return;\n    }\n    Object.defineProperty(obj, property, Object.assign({}, definition));\n  };\n\n  var forin = function forin(obj, cb) {\n    for (var key in obj) {\n      if (!obj.hasOwnProperty(key)) {\n        continue;\n      }\n\n      cb(key, obj[key]);\n    }\n  };\n\n  var createObject = function createObject(definition) {\n    var obj = {};\n    forin(definition, function(property) {\n      defineProperty(obj, property, definition[property]);\n    });\n    return obj;\n  };\n\n  var attr = function attr(node, name) {\n    var value =\n      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n    if (value === null) {\n      return node.getAttribute(name) || node.hasAttribute(name);\n    }\n    node.setAttribute(name, value);\n  };\n\n  var ns = 'http://www.w3.org/2000/svg';\n  var svgElements = ['svg', 'path']; // only svg elements used\n\n  var isSVGElement = function isSVGElement(tag) {\n    return svgElements.includes(tag);\n  };\n\n  var createElement = function createElement(tag, className) {\n    var attributes =\n      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    if (typeof className === 'object') {\n      attributes = className;\n      className = null;\n    }\n    var element = isSVGElement(tag)\n      ? document.createElementNS(ns, tag)\n      : document.createElement(tag);\n    if (className) {\n      if (isSVGElement(tag)) {\n        attr(element, 'class', className);\n      } else {\n        element.className = className;\n      }\n    }\n    forin(attributes, function(name, value) {\n      attr(element, name, value);\n    });\n    return element;\n  };\n\n  var appendChild = function appendChild(parent) {\n    return function(child, index) {\n      if (typeof index !== 'undefined' && parent.children[index]) {\n        parent.insertBefore(child, parent.children[index]);\n      } else {\n        parent.appendChild(child);\n      }\n    };\n  };\n\n  var appendChildView = function appendChildView(parent, childViews) {\n    return function(view, index) {\n      if (typeof index !== 'undefined') {\n        childViews.splice(index, 0, view);\n      } else {\n        childViews.push(view);\n      }\n\n      return view;\n    };\n  };\n\n  var removeChildView = function removeChildView(parent, childViews) {\n    return function(view) {\n      // remove from child views\n      childViews.splice(childViews.indexOf(view), 1);\n\n      // remove the element\n      if (view.element.parentNode) {\n        parent.removeChild(view.element);\n      }\n\n      return view;\n    };\n  };\n\n  var IS_BROWSER = (function() {\n    return (\n      typeof window !== 'undefined' && typeof window.document !== 'undefined'\n    );\n  })();\n  var isBrowser = function isBrowser() {\n    return IS_BROWSER;\n  };\n\n  var testElement = isBrowser() ? createElement('svg') : {};\n  var getChildCount =\n    'children' in testElement\n      ? function(el) {\n          return el.children.length;\n        }\n      : function(el) {\n          return el.childNodes.length;\n        };\n\n  var getViewRect = function getViewRect(\n    elementRect,\n    childViews,\n    offset,\n    scale\n  ) {\n    var left = offset[0] || elementRect.left;\n    var top = offset[1] || elementRect.top;\n    var right = left + elementRect.width;\n    var bottom = top + elementRect.height * (scale[1] || 1);\n\n    var rect = {\n      // the rectangle of the element itself\n      element: Object.assign({}, elementRect),\n\n      // the rectangle of the element expanded to contain its children, does not include any margins\n      inner: {\n        left: elementRect.left,\n        top: elementRect.top,\n        right: elementRect.right,\n        bottom: elementRect.bottom\n      },\n\n      // the rectangle of the element expanded to contain its children including own margin and child margins\n      // margins will be added after we've recalculated the size\n      outer: {\n        left: left,\n        top: top,\n        right: right,\n        bottom: bottom\n      }\n    };\n\n    // expand rect to fit all child rectangles\n    childViews\n      .filter(function(childView) {\n        return !childView.isRectIgnored();\n      })\n      .map(function(childView) {\n        return childView.rect;\n      })\n      .forEach(function(childViewRect) {\n        expandRect(rect.inner, Object.assign({}, childViewRect.inner));\n        expandRect(rect.outer, Object.assign({}, childViewRect.outer));\n      });\n\n    // calculate inner width and height\n    calculateRectSize(rect.inner);\n\n    // append additional margin (top and left margins are included in top and left automatically)\n    rect.outer.bottom += rect.element.marginBottom;\n    rect.outer.right += rect.element.marginRight;\n\n    // calculate outer width and height\n    calculateRectSize(rect.outer);\n\n    return rect;\n  };\n\n  var expandRect = function expandRect(parent, child) {\n    // adjust for parent offset\n    child.top += parent.top;\n    child.right += parent.left;\n    child.bottom += parent.top;\n    child.left += parent.left;\n\n    if (child.bottom > parent.bottom) {\n      parent.bottom = child.bottom;\n    }\n\n    if (child.right > parent.right) {\n      parent.right = child.right;\n    }\n  };\n\n  var calculateRectSize = function calculateRectSize(rect) {\n    rect.width = rect.right - rect.left;\n    rect.height = rect.bottom - rect.top;\n  };\n\n  var isNumber = function isNumber(value) {\n    return typeof value === 'number';\n  };\n\n  /**\n   * Determines if position is at destination\n   * @param position\n   * @param destination\n   * @param velocity\n   * @param errorMargin\n   * @returns {boolean}\n   */\n  var thereYet = function thereYet(position, destination, velocity) {\n    var errorMargin =\n      arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0.001;\n    return (\n      Math.abs(position - destination) < errorMargin &&\n      Math.abs(velocity) < errorMargin\n    );\n  };\n\n  /**\n   * Spring animation\n   */\n  var spring =\n    // default options\n    function spring() // method definition\n    {\n      var _ref =\n          arguments.length > 0 && arguments[0] !== undefined\n            ? arguments[0]\n            : {},\n        _ref$stiffness = _ref.stiffness,\n        stiffness = _ref$stiffness === void 0 ? 0.5 : _ref$stiffness,\n        _ref$damping = _ref.damping,\n        damping = _ref$damping === void 0 ? 0.75 : _ref$damping,\n        _ref$mass = _ref.mass,\n        mass = _ref$mass === void 0 ? 10 : _ref$mass;\n      var target = null;\n      var position = null;\n      var velocity = 0;\n      var resting = false;\n\n      // updates spring state\n      var interpolate = function interpolate(ts, skipToEndState) {\n        // in rest, don't animate\n        if (resting) return;\n\n        // need at least a target or position to do springy things\n        if (!(isNumber(target) && isNumber(position))) {\n          resting = true;\n          velocity = 0;\n          return;\n        }\n\n        // calculate spring force\n        var f = -(position - target) * stiffness;\n\n        // update velocity by adding force based on mass\n        velocity += f / mass;\n\n        // update position by adding velocity\n        position += velocity;\n\n        // slow down based on amount of damping\n        velocity *= damping;\n\n        // we've arrived if we're near target and our velocity is near zero\n        if (thereYet(position, target, velocity) || skipToEndState) {\n          position = target;\n          velocity = 0;\n          resting = true;\n\n          // we done\n          api.onupdate(position);\n          api.oncomplete(position);\n        } else {\n          // progress update\n          api.onupdate(position);\n        }\n      };\n\n      /**\n       * Set new target value\n       * @param value\n       */\n      var setTarget = function setTarget(value) {\n        // if currently has no position, set target and position to this value\n        if (isNumber(value) && !isNumber(position)) {\n          position = value;\n        }\n\n        // next target value will not be animated to\n        if (target === null) {\n          target = value;\n          position = value;\n        }\n\n        // let start moving to target\n        target = value;\n\n        // already at target\n        if (position === target || typeof target === 'undefined') {\n          // now resting as target is current position, stop moving\n          resting = true;\n          velocity = 0;\n\n          // done!\n          api.onupdate(position);\n          api.oncomplete(position);\n\n          return;\n        }\n\n        resting = false;\n      };\n\n      // need 'api' to call onupdate callback\n      var api = createObject({\n        interpolate: interpolate,\n        target: {\n          set: setTarget,\n          get: function get() {\n            return target;\n          }\n        },\n\n        resting: {\n          get: function get() {\n            return resting;\n          }\n        },\n\n        onupdate: function onupdate(value) {},\n        oncomplete: function oncomplete(value) {}\n      });\n\n      return api;\n    };\n\n  var easeLinear = function easeLinear(t) {\n    return t;\n  };\n  var easeInOutQuad = function easeInOutQuad(t) {\n    return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;\n  };\n\n  var tween =\n    // default values\n    function tween() // method definition\n    {\n      var _ref =\n          arguments.length > 0 && arguments[0] !== undefined\n            ? arguments[0]\n            : {},\n        _ref$duration = _ref.duration,\n        duration = _ref$duration === void 0 ? 500 : _ref$duration,\n        _ref$easing = _ref.easing,\n        easing = _ref$easing === void 0 ? easeInOutQuad : _ref$easing,\n        _ref$delay = _ref.delay,\n        delay = _ref$delay === void 0 ? 0 : _ref$delay;\n      var start = null;\n      var t;\n      var p;\n      var resting = true;\n      var reverse = false;\n      var target = null;\n\n      var interpolate = function interpolate(ts, skipToEndState) {\n        if (resting || target === null) return;\n\n        if (start === null) {\n          start = ts;\n        }\n\n        if (ts - start < delay) return;\n\n        t = ts - start - delay;\n\n        if (t >= duration || skipToEndState) {\n          t = 1;\n          p = reverse ? 0 : 1;\n          api.onupdate(p * target);\n          api.oncomplete(p * target);\n          resting = true;\n        } else {\n          p = t / duration;\n          api.onupdate((t >= 0 ? easing(reverse ? 1 - p : p) : 0) * target);\n        }\n      };\n\n      // need 'api' to call onupdate callback\n      var api = createObject({\n        interpolate: interpolate,\n        target: {\n          get: function get() {\n            return reverse ? 0 : target;\n          },\n          set: function set(value) {\n            // is initial value\n            if (target === null) {\n              target = value;\n              api.onupdate(value);\n              api.oncomplete(value);\n              return;\n            }\n\n            // want to tween to a smaller value and have a current value\n            if (value < target) {\n              target = 1;\n              reverse = true;\n            } else {\n              // not tweening to a smaller value\n              reverse = false;\n              target = value;\n            }\n\n            // let's go!\n            resting = false;\n            start = null;\n          }\n        },\n\n        resting: {\n          get: function get() {\n            return resting;\n          }\n        },\n\n        onupdate: function onupdate(value) {},\n        oncomplete: function oncomplete(value) {}\n      });\n\n      return api;\n    };\n\n  var animator = {\n    spring: spring,\n    tween: tween\n  };\n\n  /*\n                       { type: 'spring', stiffness: .5, damping: .75, mass: 10 };\n                       { translation: { type: 'spring', ... }, ... }\n                       { translation: { x: { type: 'spring', ... } } }\n                      */\n  var createAnimator = function createAnimator(definition, category, property) {\n    // default is single definition\n    // we check if transform is set, if so, we check if property is set\n    var def =\n      definition[category] && typeof definition[category][property] === 'object'\n        ? definition[category][property]\n        : definition[category] || definition;\n\n    var type = typeof def === 'string' ? def : def.type;\n    var props = typeof def === 'object' ? Object.assign({}, def) : {};\n\n    return animator[type] ? animator[type](props) : null;\n  };\n\n  var addGetSet = function addGetSet(keys, obj, props) {\n    var overwrite =\n      arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n    obj = Array.isArray(obj) ? obj : [obj];\n    obj.forEach(function(o) {\n      keys.forEach(function(key) {\n        var name = key;\n        var getter = function getter() {\n          return props[key];\n        };\n        var setter = function setter(value) {\n          return (props[key] = value);\n        };\n\n        if (typeof key === 'object') {\n          name = key.key;\n          getter = key.getter || getter;\n          setter = key.setter || setter;\n        }\n\n        if (o[name] && !overwrite) {\n          return;\n        }\n\n        o[name] = {\n          get: getter,\n          set: setter\n        };\n      });\n    });\n  };\n\n  // add to state,\n  // add getters and setters to internal and external api (if not set)\n  // setup animators\n\n  var animations = function animations(_ref) {\n    var mixinConfig = _ref.mixinConfig,\n      viewProps = _ref.viewProps,\n      viewInternalAPI = _ref.viewInternalAPI,\n      viewExternalAPI = _ref.viewExternalAPI;\n    // initial properties\n    var initialProps = Object.assign({}, viewProps);\n\n    // list of all active animations\n    var animations = [];\n\n    // setup animators\n    forin(mixinConfig, function(property, animation) {\n      var animator = createAnimator(animation);\n      if (!animator) {\n        return;\n      }\n\n      // when the animator updates, update the view state value\n      animator.onupdate = function(value) {\n        viewProps[property] = value;\n      };\n\n      // set animator target\n      animator.target = initialProps[property];\n\n      // when value is set, set the animator target value\n      var prop = {\n        key: property,\n        setter: function setter(value) {\n          // if already at target, we done!\n          if (animator.target === value) {\n            return;\n          }\n\n          animator.target = value;\n        },\n        getter: function getter() {\n          return viewProps[property];\n        }\n      };\n\n      // add getters and setters\n      addGetSet([prop], [viewInternalAPI, viewExternalAPI], viewProps, true);\n\n      // add it to the list for easy updating from the _write method\n      animations.push(animator);\n    });\n\n    // expose internal write api\n    return {\n      write: function write(ts) {\n        var skipToEndState = document.hidden;\n        var resting = true;\n        animations.forEach(function(animation) {\n          if (!animation.resting) resting = false;\n          animation.interpolate(ts, skipToEndState);\n        });\n        return resting;\n      },\n      destroy: function destroy() {}\n    };\n  };\n\n  var addEvent = function addEvent(element) {\n    return function(type, fn) {\n      element.addEventListener(type, fn);\n    };\n  };\n\n  var removeEvent = function removeEvent(element) {\n    return function(type, fn) {\n      element.removeEventListener(type, fn);\n    };\n  };\n\n  // mixin\n  var listeners = function listeners(_ref) {\n    var mixinConfig = _ref.mixinConfig,\n      viewProps = _ref.viewProps,\n      viewInternalAPI = _ref.viewInternalAPI,\n      viewExternalAPI = _ref.viewExternalAPI,\n      viewState = _ref.viewState,\n      view = _ref.view;\n    var events = [];\n\n    var add = addEvent(view.element);\n    var remove = removeEvent(view.element);\n\n    viewExternalAPI.on = function(type, fn) {\n      events.push({\n        type: type,\n        fn: fn\n      });\n\n      add(type, fn);\n    };\n\n    viewExternalAPI.off = function(type, fn) {\n      events.splice(\n        events.findIndex(function(event) {\n          return event.type === type && event.fn === fn;\n        }),\n        1\n      );\n\n      remove(type, fn);\n    };\n\n    return {\n      write: function write() {\n        // not busy\n        return true;\n      },\n      destroy: function destroy() {\n        events.forEach(function(event) {\n          remove(event.type, event.fn);\n        });\n      }\n    };\n  };\n\n  // add to external api and link to props\n\n  var apis = function apis(_ref) {\n    var mixinConfig = _ref.mixinConfig,\n      viewProps = _ref.viewProps,\n      viewExternalAPI = _ref.viewExternalAPI;\n    addGetSet(mixinConfig, viewExternalAPI, viewProps);\n  };\n\n  var isDefined = function isDefined(value) {\n    return value != null;\n  };\n\n  // add to state,\n  // add getters and setters to internal and external api (if not set)\n  // set initial state based on props in viewProps\n  // apply as transforms each frame\n\n  var defaults = {\n    opacity: 1,\n    scaleX: 1,\n    scaleY: 1,\n    translateX: 0,\n    translateY: 0,\n    rotateX: 0,\n    rotateY: 0,\n    rotateZ: 0,\n    originX: 0,\n    originY: 0\n  };\n\n  var styles = function styles(_ref) {\n    var mixinConfig = _ref.mixinConfig,\n      viewProps = _ref.viewProps,\n      viewInternalAPI = _ref.viewInternalAPI,\n      viewExternalAPI = _ref.viewExternalAPI,\n      view = _ref.view;\n    // initial props\n    var initialProps = Object.assign({}, viewProps);\n\n    // current props\n    var currentProps = {};\n\n    // we will add those properties to the external API and link them to the viewState\n    addGetSet(mixinConfig, [viewInternalAPI, viewExternalAPI], viewProps);\n\n    // override rect on internal and external rect getter so it takes in account transforms\n    var getOffset = function getOffset() {\n      return [viewProps['translateX'] || 0, viewProps['translateY'] || 0];\n    };\n\n    var getScale = function getScale() {\n      return [viewProps['scaleX'] || 0, viewProps['scaleY'] || 0];\n    };\n    var getRect = function getRect() {\n      return view.rect\n        ? getViewRect(view.rect, view.childViews, getOffset(), getScale())\n        : null;\n    };\n    viewInternalAPI.rect = { get: getRect };\n    viewExternalAPI.rect = { get: getRect };\n\n    // apply view props\n    mixinConfig.forEach(function(key) {\n      viewProps[key] =\n        typeof initialProps[key] === 'undefined'\n          ? defaults[key]\n          : initialProps[key];\n    });\n\n    // expose api\n    return {\n      write: function write() {\n        // see if props have changed\n        if (!propsHaveChanged(currentProps, viewProps)) {\n          return;\n        }\n\n        // moves element to correct position on screen\n        applyStyles(view.element, viewProps);\n\n        // store new transforms\n        Object.assign(currentProps, Object.assign({}, viewProps));\n\n        // no longer busy\n        return true;\n      },\n      destroy: function destroy() {}\n    };\n  };\n\n  var propsHaveChanged = function propsHaveChanged(currentProps, newProps) {\n    // different amount of keys\n    if (Object.keys(currentProps).length !== Object.keys(newProps).length) {\n      return true;\n    }\n\n    // lets analyze the individual props\n    for (var prop in newProps) {\n      if (newProps[prop] !== currentProps[prop]) {\n        return true;\n      }\n    }\n\n    return false;\n  };\n\n  var applyStyles = function applyStyles(element, _ref2) {\n    var opacity = _ref2.opacity,\n      perspective = _ref2.perspective,\n      translateX = _ref2.translateX,\n      translateY = _ref2.translateY,\n      scaleX = _ref2.scaleX,\n      scaleY = _ref2.scaleY,\n      rotateX = _ref2.rotateX,\n      rotateY = _ref2.rotateY,\n      rotateZ = _ref2.rotateZ,\n      originX = _ref2.originX,\n      originY = _ref2.originY,\n      width = _ref2.width,\n      height = _ref2.height;\n\n    var transforms = '';\n    var styles = '';\n\n    // handle transform origin\n    if (isDefined(originX) || isDefined(originY)) {\n      styles +=\n        'transform-origin: ' + (originX || 0) + 'px ' + (originY || 0) + 'px;';\n    }\n\n    // transform order is relevant\n    // 0. perspective\n    if (isDefined(perspective)) {\n      transforms += 'perspective(' + perspective + 'px) ';\n    }\n\n    // 1. translate\n    if (isDefined(translateX) || isDefined(translateY)) {\n      transforms +=\n        'translate3d(' +\n        (translateX || 0) +\n        'px, ' +\n        (translateY || 0) +\n        'px, 0) ';\n    }\n\n    // 2. scale\n    if (isDefined(scaleX) || isDefined(scaleY)) {\n      transforms +=\n        'scale3d(' +\n        (isDefined(scaleX) ? scaleX : 1) +\n        ', ' +\n        (isDefined(scaleY) ? scaleY : 1) +\n        ', 1) ';\n    }\n\n    // 3. rotate\n    if (isDefined(rotateZ)) {\n      transforms += 'rotateZ(' + rotateZ + 'rad) ';\n    }\n\n    if (isDefined(rotateX)) {\n      transforms += 'rotateX(' + rotateX + 'rad) ';\n    }\n\n    if (isDefined(rotateY)) {\n      transforms += 'rotateY(' + rotateY + 'rad) ';\n    }\n\n    // add transforms\n    if (transforms.length) {\n      styles += 'transform:' + transforms + ';';\n    }\n\n    // add opacity\n    if (isDefined(opacity)) {\n      styles += 'opacity:' + opacity + ';';\n\n      // if we reach zero, we make the element inaccessible\n      if (opacity === 0) {\n        styles += 'visibility:hidden;';\n      }\n\n      // if we're below 100% opacity this element can't be clicked\n      if (opacity < 1) {\n        styles += 'pointer-events:none;';\n      }\n    }\n\n    // add height\n    if (isDefined(height)) {\n      styles += 'height:' + height + 'px;';\n    }\n\n    // add width\n    if (isDefined(width)) {\n      styles += 'width:' + width + 'px;';\n    }\n\n    // apply styles\n    var elementCurrentStyle = element.elementCurrentStyle || '';\n\n    // if new styles does not match current styles, lets update!\n    if (\n      styles.length !== elementCurrentStyle.length ||\n      styles !== elementCurrentStyle\n    ) {\n      element.style.cssText = styles;\n      // store current styles so we can compare them to new styles later on\n      // _not_ getting the style value is faster\n      element.elementCurrentStyle = styles;\n    }\n  };\n\n  var Mixins = {\n    styles: styles,\n    listeners: listeners,\n    animations: animations,\n    apis: apis\n  };\n\n  var updateRect = function updateRect() {\n    var rect =\n      arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    var element =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var style =\n      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n    if (!element.layoutCalculated) {\n      rect.paddingTop = parseInt(style.paddingTop, 10) || 0;\n      rect.marginTop = parseInt(style.marginTop, 10) || 0;\n      rect.marginRight = parseInt(style.marginRight, 10) || 0;\n      rect.marginBottom = parseInt(style.marginBottom, 10) || 0;\n      rect.marginLeft = parseInt(style.marginLeft, 10) || 0;\n      element.layoutCalculated = true;\n    }\n\n    rect.left = element.offsetLeft || 0;\n    rect.top = element.offsetTop || 0;\n    rect.width = element.offsetWidth || 0;\n    rect.height = element.offsetHeight || 0;\n\n    rect.right = rect.left + rect.width;\n    rect.bottom = rect.top + rect.height;\n\n    rect.scrollTop = element.scrollTop;\n\n    rect.hidden = element.offsetParent === null;\n\n    return rect;\n  };\n\n  var createView =\n    // default view definition\n    function createView() {\n      var _ref =\n          arguments.length > 0 && arguments[0] !== undefined\n            ? arguments[0]\n            : {},\n        _ref$tag = _ref.tag,\n        tag = _ref$tag === void 0 ? 'div' : _ref$tag,\n        _ref$name = _ref.name,\n        name = _ref$name === void 0 ? null : _ref$name,\n        _ref$attributes = _ref.attributes,\n        attributes = _ref$attributes === void 0 ? {} : _ref$attributes,\n        _ref$read = _ref.read,\n        read = _ref$read === void 0 ? function() {} : _ref$read,\n        _ref$write = _ref.write,\n        write = _ref$write === void 0 ? function() {} : _ref$write,\n        _ref$create = _ref.create,\n        create = _ref$create === void 0 ? function() {} : _ref$create,\n        _ref$destroy = _ref.destroy,\n        destroy = _ref$destroy === void 0 ? function() {} : _ref$destroy,\n        _ref$filterFrameActio = _ref.filterFrameActionsForChild,\n        filterFrameActionsForChild =\n          _ref$filterFrameActio === void 0\n            ? function(child, actions) {\n                return actions;\n              }\n            : _ref$filterFrameActio,\n        _ref$didCreateView = _ref.didCreateView,\n        didCreateView =\n          _ref$didCreateView === void 0 ? function() {} : _ref$didCreateView,\n        _ref$didWriteView = _ref.didWriteView,\n        didWriteView =\n          _ref$didWriteView === void 0 ? function() {} : _ref$didWriteView,\n        _ref$ignoreRect = _ref.ignoreRect,\n        ignoreRect = _ref$ignoreRect === void 0 ? false : _ref$ignoreRect,\n        _ref$ignoreRectUpdate = _ref.ignoreRectUpdate,\n        ignoreRectUpdate =\n          _ref$ignoreRectUpdate === void 0 ? false : _ref$ignoreRectUpdate,\n        _ref$mixins = _ref.mixins,\n        mixins = _ref$mixins === void 0 ? [] : _ref$mixins;\n      return function(\n        // each view requires reference to store\n        store\n      ) {\n        var props =\n          arguments.length > 1 && arguments[1] !== undefined\n            ? arguments[1]\n            : {};\n        // root element should not be changed\n        var element = createElement(tag, 'filepond--' + name, attributes);\n\n        // style reference should also not be changed\n        var style = window.getComputedStyle(element, null);\n\n        // element rectangle\n        var rect = updateRect();\n        var frameRect = null;\n\n        // rest state\n        var isResting = false;\n\n        // pretty self explanatory\n        var childViews = [];\n\n        // loaded mixins\n        var activeMixins = [];\n\n        // references to created children\n        var ref = {};\n\n        // state used for each instance\n        var state = {};\n\n        // list of writers that will be called to update this view\n        var writers = [\n          write // default writer\n        ];\n\n        var readers = [\n          read // default reader\n        ];\n\n        var destroyers = [\n          destroy // default destroy\n        ];\n\n        // core view methods\n        var getElement = function getElement() {\n          return element;\n        };\n        var getChildViews = function getChildViews() {\n          return childViews.concat();\n        };\n        var getReference = function getReference() {\n          return ref;\n        };\n        var createChildView = function createChildView(store) {\n          return function(view, props) {\n            return view(store, props);\n          };\n        };\n        var getRect = function getRect() {\n          if (frameRect) {\n            return frameRect;\n          }\n          frameRect = getViewRect(rect, childViews, [0, 0], [1, 1]);\n          return frameRect;\n        };\n        var getStyle = function getStyle() {\n          return style;\n        };\n\n        /**\n         * Read data from DOM\n         * @private\n         */\n        var _read = function _read() {\n          frameRect = null;\n\n          // read child views\n          childViews.forEach(function(child) {\n            return child._read();\n          });\n\n          var shouldUpdate = !(ignoreRectUpdate && rect.width && rect.height);\n          if (shouldUpdate) {\n            updateRect(rect, element, style);\n          }\n\n          // readers\n          var api = { root: internalAPI, props: props, rect: rect };\n          readers.forEach(function(reader) {\n            return reader(api);\n          });\n        };\n\n        /**\n         * Write data to DOM\n         * @private\n         */\n        var _write = function _write(ts, frameActions, shouldOptimize) {\n          // if no actions, we assume that the view is resting\n          var resting = frameActions.length === 0;\n\n          // writers\n          writers.forEach(function(writer) {\n            var writerResting = writer({\n              props: props,\n              root: internalAPI,\n              actions: frameActions,\n              timestamp: ts,\n              shouldOptimize: shouldOptimize\n            });\n\n            if (writerResting === false) {\n              resting = false;\n            }\n          });\n\n          // run mixins\n          activeMixins.forEach(function(mixin) {\n            // if one of the mixins is still busy after write operation, we are not resting\n            var mixinResting = mixin.write(ts);\n            if (mixinResting === false) {\n              resting = false;\n            }\n          });\n\n          // updates child views that are currently attached to the DOM\n          childViews\n            .filter(function(child) {\n              return !!child.element.parentNode;\n            })\n            .forEach(function(child) {\n              // if a child view is not resting, we are not resting\n              var childResting = child._write(\n                ts,\n                filterFrameActionsForChild(child, frameActions),\n                shouldOptimize\n              );\n\n              if (!childResting) {\n                resting = false;\n              }\n            });\n\n          // append new elements to DOM and update those\n          childViews\n            //.filter(child => !child.element.parentNode)\n            .forEach(function(child, index) {\n              // skip\n              if (child.element.parentNode) {\n                return;\n              }\n\n              // append to DOM\n              internalAPI.appendChild(child.element, index);\n\n              // call read (need to know the size of these elements)\n              child._read();\n\n              // re-call write\n              child._write(\n                ts,\n                filterFrameActionsForChild(child, frameActions),\n                shouldOptimize\n              );\n\n              // we just added somthing to the dom, no rest\n              resting = false;\n            });\n\n          // update resting state\n          isResting = resting;\n\n          didWriteView({\n            props: props,\n            root: internalAPI,\n            actions: frameActions,\n            timestamp: ts\n          });\n\n          // let parent know if we are resting\n          return resting;\n        };\n\n        var _destroy = function _destroy() {\n          activeMixins.forEach(function(mixin) {\n            return mixin.destroy();\n          });\n          destroyers.forEach(function(destroyer) {\n            destroyer({ root: internalAPI, props: props });\n          });\n          childViews.forEach(function(child) {\n            return child._destroy();\n          });\n        };\n\n        // sharedAPI\n        var sharedAPIDefinition = {\n          element: {\n            get: getElement\n          },\n\n          style: {\n            get: getStyle\n          },\n\n          childViews: {\n            get: getChildViews\n          }\n        };\n\n        // private API definition\n        var internalAPIDefinition = Object.assign({}, sharedAPIDefinition, {\n          rect: {\n            get: getRect\n          },\n\n          // access to custom children references\n          ref: {\n            get: getReference\n          },\n\n          // dom modifiers\n          is: function is(needle) {\n            return name === needle;\n          },\n          appendChild: appendChild(element),\n          createChildView: createChildView(store),\n          linkView: function linkView(view) {\n            childViews.push(view);\n            return view;\n          },\n          unlinkView: function unlinkView(view) {\n            childViews.splice(childViews.indexOf(view), 1);\n          },\n          appendChildView: appendChildView(element, childViews),\n          removeChildView: removeChildView(element, childViews),\n          registerWriter: function registerWriter(writer) {\n            return writers.push(writer);\n          },\n          registerReader: function registerReader(reader) {\n            return readers.push(reader);\n          },\n          registerDestroyer: function registerDestroyer(destroyer) {\n            return destroyers.push(destroyer);\n          },\n          invalidateLayout: function invalidateLayout() {\n            return (element.layoutCalculated = false);\n          },\n\n          // access to data store\n          dispatch: store.dispatch,\n          query: store.query\n        });\n\n        // public view API methods\n        var externalAPIDefinition = {\n          element: {\n            get: getElement\n          },\n\n          childViews: {\n            get: getChildViews\n          },\n\n          rect: {\n            get: getRect\n          },\n\n          resting: {\n            get: function get() {\n              return isResting;\n            }\n          },\n\n          isRectIgnored: function isRectIgnored() {\n            return ignoreRect;\n          },\n          _read: _read,\n          _write: _write,\n          _destroy: _destroy\n        };\n\n        // mixin API methods\n        var mixinAPIDefinition = Object.assign({}, sharedAPIDefinition, {\n          rect: {\n            get: function get() {\n              return rect;\n            }\n          }\n        });\n\n        // add mixin functionality\n        Object.keys(mixins)\n          .sort(function(a, b) {\n            // move styles to the back of the mixin list (so adjustments of other mixins are applied to the props correctly)\n            if (a === 'styles') {\n              return 1;\n            } else if (b === 'styles') {\n              return -1;\n            }\n            return 0;\n          })\n          .forEach(function(key) {\n            var mixinAPI = Mixins[key]({\n              mixinConfig: mixins[key],\n              viewProps: props,\n              viewState: state,\n              viewInternalAPI: internalAPIDefinition,\n              viewExternalAPI: externalAPIDefinition,\n              view: createObject(mixinAPIDefinition)\n            });\n\n            if (mixinAPI) {\n              activeMixins.push(mixinAPI);\n            }\n          });\n\n        // construct private api\n        var internalAPI = createObject(internalAPIDefinition);\n\n        // create the view\n        create({\n          root: internalAPI,\n          props: props\n        });\n\n        // append created child views to root node\n        var childCount = getChildCount(element); // need to know the current child count so appending happens in correct order\n        childViews.forEach(function(child, index) {\n          internalAPI.appendChild(child.element, childCount + index);\n        });\n\n        // call did create\n        didCreateView(internalAPI);\n\n        // expose public api\n        return createObject(externalAPIDefinition);\n      };\n    };\n\n  var createPainter = function createPainter(read, write) {\n    var fps =\n      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 60;\n\n    var name = '__framePainter';\n\n    // set global painter\n    if (window[name]) {\n      window[name].readers.push(read);\n      window[name].writers.push(write);\n      return;\n    }\n\n    window[name] = {\n      readers: [read],\n      writers: [write]\n    };\n\n    var painter = window[name];\n\n    var interval = 1000 / fps;\n    var last = null;\n    var id = null;\n    var requestTick = null;\n    var cancelTick = null;\n\n    var setTimerType = function setTimerType() {\n      if (document.hidden) {\n        requestTick = function requestTick() {\n          return window.setTimeout(function() {\n            return tick(performance.now());\n          }, interval);\n        };\n        cancelTick = function cancelTick() {\n          return window.clearTimeout(id);\n        };\n      } else {\n        requestTick = function requestTick() {\n          return window.requestAnimationFrame(tick);\n        };\n        cancelTick = function cancelTick() {\n          return window.cancelAnimationFrame(id);\n        };\n      }\n    };\n\n    document.addEventListener('visibilitychange', function() {\n      if (cancelTick) cancelTick();\n      setTimerType();\n      tick(performance.now());\n    });\n\n    var tick = function tick(ts) {\n      // queue next tick\n      id = requestTick(tick);\n\n      // limit fps\n      if (!last) {\n        last = ts;\n      }\n\n      var delta = ts - last;\n\n      if (delta <= interval) {\n        // skip frame\n        return;\n      }\n\n      // align next frame\n      last = ts - (delta % interval);\n\n      // update view\n      painter.readers.forEach(function(read) {\n        return read();\n      });\n      painter.writers.forEach(function(write) {\n        return write(ts);\n      });\n    };\n\n    setTimerType();\n    tick(performance.now());\n\n    return {\n      pause: function pause() {\n        cancelTick(id);\n      }\n    };\n  };\n\n  var createRoute = function createRoute(routes, fn) {\n    return function(_ref) {\n      var root = _ref.root,\n        props = _ref.props,\n        _ref$actions = _ref.actions,\n        actions = _ref$actions === void 0 ? [] : _ref$actions,\n        timestamp = _ref.timestamp,\n        shouldOptimize = _ref.shouldOptimize;\n      actions\n        .filter(function(action) {\n          return routes[action.type];\n        })\n        .forEach(function(action) {\n          return routes[action.type]({\n            root: root,\n            props: props,\n            action: action.data,\n            timestamp: timestamp,\n            shouldOptimize: shouldOptimize\n          });\n        });\n\n      if (fn) {\n        fn({\n          root: root,\n          props: props,\n          actions: actions,\n          timestamp: timestamp,\n          shouldOptimize: shouldOptimize\n        });\n      }\n    };\n  };\n\n  var insertBefore = function insertBefore(newNode, referenceNode) {\n    return referenceNode.parentNode.insertBefore(newNode, referenceNode);\n  };\n\n  var insertAfter = function insertAfter(newNode, referenceNode) {\n    return referenceNode.parentNode.insertBefore(\n      newNode,\n      referenceNode.nextSibling\n    );\n  };\n\n  var isArray = function isArray(value) {\n    return Array.isArray(value);\n  };\n\n  var isEmpty = function isEmpty(value) {\n    return value == null;\n  };\n\n  var trim = function trim(str) {\n    return str.trim();\n  };\n\n  var toString = function toString(value) {\n    return '' + value;\n  };\n\n  var toArray = function toArray(value) {\n    var splitter =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ',';\n    if (isEmpty(value)) {\n      return [];\n    }\n    if (isArray(value)) {\n      return value;\n    }\n    return toString(value)\n      .split(splitter)\n      .map(trim)\n      .filter(function(str) {\n        return str.length;\n      });\n  };\n\n  var isBoolean = function isBoolean(value) {\n    return typeof value === 'boolean';\n  };\n\n  var toBoolean = function toBoolean(value) {\n    return isBoolean(value) ? value : value === 'true';\n  };\n\n  var isString = function isString(value) {\n    return typeof value === 'string';\n  };\n\n  var toNumber = function toNumber(value) {\n    return isNumber(value)\n      ? value\n      : isString(value)\n      ? toString(value).replace(/[a-z]+/gi, '')\n      : 0;\n  };\n\n  var toInt = function toInt(value) {\n    return parseInt(toNumber(value), 10);\n  };\n\n  var toFloat = function toFloat(value) {\n    return parseFloat(toNumber(value));\n  };\n\n  var isInt = function isInt(value) {\n    return isNumber(value) && isFinite(value) && Math.floor(value) === value;\n  };\n\n  var toBytes = function toBytes(value) {\n    var base =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;\n    // is in bytes\n    if (isInt(value)) {\n      return value;\n    }\n\n    // is natural file size\n    var naturalFileSize = toString(value).trim();\n\n    // if is value in megabytes\n    if (/MB$/i.test(naturalFileSize)) {\n      naturalFileSize = naturalFileSize.replace(/MB$i/, '').trim();\n      return toInt(naturalFileSize) * base * base;\n    }\n\n    // if is value in kilobytes\n    if (/KB/i.test(naturalFileSize)) {\n      naturalFileSize = naturalFileSize.replace(/KB$i/, '').trim();\n      return toInt(naturalFileSize) * base;\n    }\n\n    return toInt(naturalFileSize);\n  };\n\n  var isFunction = function isFunction(value) {\n    return typeof value === 'function';\n  };\n\n  var toFunctionReference = function toFunctionReference(string) {\n    var ref = self;\n    var levels = string.split('.');\n    var level = null;\n    while ((level = levels.shift())) {\n      ref = ref[level];\n      if (!ref) {\n        return null;\n      }\n    }\n    return ref;\n  };\n\n  var methods = {\n    process: 'POST',\n    patch: 'PATCH',\n    revert: 'DELETE',\n    fetch: 'GET',\n    restore: 'GET',\n    load: 'GET'\n  };\n\n  var createServerAPI = function createServerAPI(outline) {\n    var api = {};\n\n    api.url = isString(outline) ? outline : outline.url || '';\n    api.timeout = outline.timeout ? parseInt(outline.timeout, 10) : 0;\n    api.headers = outline.headers ? outline.headers : {};\n\n    forin(methods, function(key) {\n      api[key] = createAction(\n        key,\n        outline[key],\n        methods[key],\n        api.timeout,\n        api.headers\n      );\n    });\n\n    // special treatment for remove\n    api.remove = outline.remove || null;\n\n    // remove generic headers from api object\n    delete api.headers;\n\n    return api;\n  };\n\n  var createAction = function createAction(\n    name,\n    outline,\n    method,\n    timeout,\n    headers\n  ) {\n    // is explicitely set to null so disable\n    if (outline === null) {\n      return null;\n    }\n\n    // if is custom function, done! Dev handles everything.\n    if (typeof outline === 'function') {\n      return outline;\n    }\n\n    // build action object\n    var action = {\n      url: method === 'GET' || method === 'PATCH' ? '?' + name + '=' : '',\n      method: method,\n      headers: headers,\n      withCredentials: false,\n      timeout: timeout,\n      onload: null,\n      ondata: null,\n      onerror: null\n    };\n\n    // is a single url\n    if (isString(outline)) {\n      action.url = outline;\n      return action;\n    }\n\n    // overwrite\n    Object.assign(action, outline);\n\n    // see if should reformat headers;\n    if (isString(action.headers)) {\n      var parts = action.headers.split(/:(.+)/);\n      action.headers = {\n        header: parts[0],\n        value: parts[1]\n      };\n    }\n\n    // if is bool withCredentials\n    action.withCredentials = toBoolean(action.withCredentials);\n\n    return action;\n  };\n\n  var toServerAPI = function toServerAPI(value) {\n    return createServerAPI(value);\n  };\n\n  var isNull = function isNull(value) {\n    return value === null;\n  };\n\n  var isObject = function isObject(value) {\n    return typeof value === 'object' && value !== null;\n  };\n\n  var isAPI = function isAPI(value) {\n    return (\n      isObject(value) &&\n      isString(value.url) &&\n      isObject(value.process) &&\n      isObject(value.revert) &&\n      isObject(value.restore) &&\n      isObject(value.fetch)\n    );\n  };\n\n  var getType = function getType(value) {\n    if (isArray(value)) {\n      return 'array';\n    }\n\n    if (isNull(value)) {\n      return 'null';\n    }\n\n    if (isInt(value)) {\n      return 'int';\n    }\n\n    if (/^[0-9]+ ?(?:GB|MB|KB)$/gi.test(value)) {\n      return 'bytes';\n    }\n\n    if (isAPI(value)) {\n      return 'api';\n    }\n\n    return typeof value;\n  };\n\n  var replaceSingleQuotes = function replaceSingleQuotes(str) {\n    return str\n      .replace(/{\\s*'/g, '{\"')\n      .replace(/'\\s*}/g, '\"}')\n      .replace(/'\\s*:/g, '\":')\n      .replace(/:\\s*'/g, ':\"')\n      .replace(/,\\s*'/g, ',\"')\n      .replace(/'\\s*,/g, '\",');\n  };\n\n  var conversionTable = {\n    array: toArray,\n    boolean: toBoolean,\n    int: function int(value) {\n      return getType(value) === 'bytes' ? toBytes(value) : toInt(value);\n    },\n    number: toFloat,\n    float: toFloat,\n    bytes: toBytes,\n    string: function string(value) {\n      return isFunction(value) ? value : toString(value);\n    },\n    function: function _function(value) {\n      return toFunctionReference(value);\n    },\n    serverapi: toServerAPI,\n    object: function object(value) {\n      try {\n        return JSON.parse(replaceSingleQuotes(value));\n      } catch (e) {\n        return null;\n      }\n    }\n  };\n\n  var convertTo = function convertTo(value, type) {\n    return conversionTable[type](value);\n  };\n\n  var getValueByType = function getValueByType(\n    newValue,\n    defaultValue,\n    valueType\n  ) {\n    // can always assign default value\n    if (newValue === defaultValue) {\n      return newValue;\n    }\n\n    // get the type of the new value\n    var newValueType = getType(newValue);\n\n    // is valid type?\n    if (newValueType !== valueType) {\n      // is string input, let's attempt to convert\n      var convertedValue = convertTo(newValue, valueType);\n\n      // what is the type now\n      newValueType = getType(convertedValue);\n\n      // no valid conversions found\n      if (convertedValue === null) {\n        throw 'Trying to assign value with incorrect type to \"' +\n          option +\n          '\", allowed type: \"' +\n          valueType +\n          '\"';\n      } else {\n        newValue = convertedValue;\n      }\n    }\n\n    // assign new value\n    return newValue;\n  };\n\n  var createOption = function createOption(defaultValue, valueType) {\n    var currentValue = defaultValue;\n    return {\n      enumerable: true,\n      get: function get() {\n        return currentValue;\n      },\n      set: function set(newValue) {\n        currentValue = getValueByType(newValue, defaultValue, valueType);\n      }\n    };\n  };\n\n  var createOptions = function createOptions(options) {\n    var obj = {};\n    forin(options, function(prop) {\n      var optionDefinition = options[prop];\n      obj[prop] = createOption(optionDefinition[0], optionDefinition[1]);\n    });\n    return createObject(obj);\n  };\n\n  var createInitialState = function createInitialState(options) {\n    return {\n      // model\n      items: [],\n\n      // timeout used for calling update items\n      listUpdateTimeout: null,\n\n      // timeout used for stacking metadata updates\n      itemUpdateTimeout: null,\n\n      // queue of items waiting to be processed\n      processingQueue: [],\n\n      // options\n      options: createOptions(options)\n    };\n  };\n\n  var fromCamels = function fromCamels(string) {\n    var separator =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '-';\n    return string\n      .split(/(?=[A-Z])/)\n      .map(function(part) {\n        return part.toLowerCase();\n      })\n      .join(separator);\n  };\n\n  var createOptionAPI = function createOptionAPI(store, options) {\n    var obj = {};\n    forin(options, function(key) {\n      obj[key] = {\n        get: function get() {\n          return store.getState().options[key];\n        },\n        set: function set(value) {\n          store.dispatch('SET_' + fromCamels(key, '_').toUpperCase(), {\n            value: value\n          });\n        }\n      };\n    });\n    return obj;\n  };\n\n  var createOptionActions = function createOptionActions(options) {\n    return function(dispatch, query, state) {\n      var obj = {};\n      forin(options, function(key) {\n        var name = fromCamels(key, '_').toUpperCase();\n\n        obj['SET_' + name] = function(action) {\n          try {\n            state.options[key] = action.value;\n          } catch (e) {} // nope, failed\n\n          // we successfully set the value of this option\n          dispatch('DID_SET_' + name, { value: state.options[key] });\n        };\n      });\n      return obj;\n    };\n  };\n\n  var createOptionQueries = function createOptionQueries(options) {\n    return function(state) {\n      var obj = {};\n      forin(options, function(key) {\n        obj['GET_' + fromCamels(key, '_').toUpperCase()] = function(action) {\n          return state.options[key];\n        };\n      });\n      return obj;\n    };\n  };\n\n  var InteractionMethod = {\n    API: 1,\n    DROP: 2,\n    BROWSE: 3,\n    PASTE: 4,\n    NONE: 5\n  };\n\n  var getUniqueId = function getUniqueId() {\n    return Math.random()\n      .toString(36)\n      .substr(2, 9);\n  };\n\n  function _typeof(obj) {\n    if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') {\n      _typeof = function(obj) {\n        return typeof obj;\n      };\n    } else {\n      _typeof = function(obj) {\n        return obj &&\n          typeof Symbol === 'function' &&\n          obj.constructor === Symbol &&\n          obj !== Symbol.prototype\n          ? 'symbol'\n          : typeof obj;\n      };\n    }\n\n    return _typeof(obj);\n  }\n\n  var REACT_ELEMENT_TYPE;\n\n  function _jsx(type, props, key, children) {\n    if (!REACT_ELEMENT_TYPE) {\n      REACT_ELEMENT_TYPE =\n        (typeof Symbol === 'function' &&\n          Symbol['for'] &&\n          Symbol['for']('react.element')) ||\n        0xeac7;\n    }\n\n    var defaultProps = type && type.defaultProps;\n    var childrenLength = arguments.length - 3;\n\n    if (!props && childrenLength !== 0) {\n      props = {\n        children: void 0\n      };\n    }\n\n    if (props && defaultProps) {\n      for (var propName in defaultProps) {\n        if (props[propName] === void 0) {\n          props[propName] = defaultProps[propName];\n        }\n      }\n    } else if (!props) {\n      props = defaultProps || {};\n    }\n\n    if (childrenLength === 1) {\n      props.children = children;\n    } else if (childrenLength > 1) {\n      var childArray = new Array(childrenLength);\n\n      for (var i = 0; i < childrenLength; i++) {\n        childArray[i] = arguments[i + 3];\n      }\n\n      props.children = childArray;\n    }\n\n    return {\n      $$typeof: REACT_ELEMENT_TYPE,\n      type: type,\n      key: key === undefined ? null : '' + key,\n      ref: null,\n      props: props,\n      _owner: null\n    };\n  }\n\n  function _asyncIterator(iterable) {\n    var method;\n\n    if (typeof Symbol !== 'undefined') {\n      if (Symbol.asyncIterator) {\n        method = iterable[Symbol.asyncIterator];\n        if (method != null) return method.call(iterable);\n      }\n\n      if (Symbol.iterator) {\n        method = iterable[Symbol.iterator];\n        if (method != null) return method.call(iterable);\n      }\n    }\n\n    throw new TypeError('Object is not async iterable');\n  }\n\n  function _AwaitValue(value) {\n    this.wrapped = value;\n  }\n\n  function _AsyncGenerator(gen) {\n    var front, back;\n\n    function send(key, arg) {\n      return new Promise(function(resolve, reject) {\n        var request = {\n          key: key,\n          arg: arg,\n          resolve: resolve,\n          reject: reject,\n          next: null\n        };\n\n        if (back) {\n          back = back.next = request;\n        } else {\n          front = back = request;\n          resume(key, arg);\n        }\n      });\n    }\n\n    function resume(key, arg) {\n      try {\n        var result = gen[key](arg);\n        var value = result.value;\n        var wrappedAwait = value instanceof _AwaitValue;\n        Promise.resolve(wrappedAwait ? value.wrapped : value).then(\n          function(arg) {\n            if (wrappedAwait) {\n              resume('next', arg);\n              return;\n            }\n\n            settle(result.done ? 'return' : 'normal', arg);\n          },\n          function(err) {\n            resume('throw', err);\n          }\n        );\n      } catch (err) {\n        settle('throw', err);\n      }\n    }\n\n    function settle(type, value) {\n      switch (type) {\n        case 'return':\n          front.resolve({\n            value: value,\n            done: true\n          });\n          break;\n\n        case 'throw':\n          front.reject(value);\n          break;\n\n        default:\n          front.resolve({\n            value: value,\n            done: false\n          });\n          break;\n      }\n\n      front = front.next;\n\n      if (front) {\n        resume(front.key, front.arg);\n      } else {\n        back = null;\n      }\n    }\n\n    this._invoke = send;\n\n    if (typeof gen.return !== 'function') {\n      this.return = undefined;\n    }\n  }\n\n  if (typeof Symbol === 'function' && Symbol.asyncIterator) {\n    _AsyncGenerator.prototype[Symbol.asyncIterator] = function() {\n      return this;\n    };\n  }\n\n  _AsyncGenerator.prototype.next = function(arg) {\n    return this._invoke('next', arg);\n  };\n\n  _AsyncGenerator.prototype.throw = function(arg) {\n    return this._invoke('throw', arg);\n  };\n\n  _AsyncGenerator.prototype.return = function(arg) {\n    return this._invoke('return', arg);\n  };\n\n  function _wrapAsyncGenerator(fn) {\n    return function() {\n      return new _AsyncGenerator(fn.apply(this, arguments));\n    };\n  }\n\n  function _awaitAsyncGenerator(value) {\n    return new _AwaitValue(value);\n  }\n\n  function _asyncGeneratorDelegate(inner, awaitWrap) {\n    var iter = {},\n      waiting = false;\n\n    function pump(key, value) {\n      waiting = true;\n      value = new Promise(function(resolve) {\n        resolve(inner[key](value));\n      });\n      return {\n        done: false,\n        value: awaitWrap(value)\n      };\n    }\n\n    if (typeof Symbol === 'function' && Symbol.iterator) {\n      iter[Symbol.iterator] = function() {\n        return this;\n      };\n    }\n\n    iter.next = function(value) {\n      if (waiting) {\n        waiting = false;\n        return value;\n      }\n\n      return pump('next', value);\n    };\n\n    if (typeof inner.throw === 'function') {\n      iter.throw = function(value) {\n        if (waiting) {\n          waiting = false;\n          throw value;\n        }\n\n        return pump('throw', value);\n      };\n    }\n\n    if (typeof inner.return === 'function') {\n      iter.return = function(value) {\n        return pump('return', value);\n      };\n    }\n\n    return iter;\n  }\n\n  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n    try {\n      var info = gen[key](arg);\n      var value = info.value;\n    } catch (error) {\n      reject(error);\n      return;\n    }\n\n    if (info.done) {\n      resolve(value);\n    } else {\n      Promise.resolve(value).then(_next, _throw);\n    }\n  }\n\n  function _asyncToGenerator(fn) {\n    return function() {\n      var self = this,\n        args = arguments;\n      return new Promise(function(resolve, reject) {\n        var gen = fn.apply(self, args);\n\n        function _next(value) {\n          asyncGeneratorStep(\n            gen,\n            resolve,\n            reject,\n            _next,\n            _throw,\n            'next',\n            value\n          );\n        }\n\n        function _throw(err) {\n          asyncGeneratorStep(gen, resolve, reject, _next, _throw, 'throw', err);\n        }\n\n        _next(undefined);\n      });\n    };\n  }\n\n  function _classCallCheck(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n      throw new TypeError('Cannot call a class as a function');\n    }\n  }\n\n  function _defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if ('value' in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  function _createClass(Constructor, protoProps, staticProps) {\n    if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) _defineProperties(Constructor, staticProps);\n    return Constructor;\n  }\n\n  function _defineEnumerableProperties(obj, descs) {\n    for (var key in descs) {\n      var desc = descs[key];\n      desc.configurable = desc.enumerable = true;\n      if ('value' in desc) desc.writable = true;\n      Object.defineProperty(obj, key, desc);\n    }\n\n    if (Object.getOwnPropertySymbols) {\n      var objectSymbols = Object.getOwnPropertySymbols(descs);\n\n      for (var i = 0; i < objectSymbols.length; i++) {\n        var sym = objectSymbols[i];\n        var desc = descs[sym];\n        desc.configurable = desc.enumerable = true;\n        if ('value' in desc) desc.writable = true;\n        Object.defineProperty(obj, sym, desc);\n      }\n    }\n\n    return obj;\n  }\n\n  function _defaults(obj, defaults) {\n    var keys = Object.getOwnPropertyNames(defaults);\n\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i];\n      var value = Object.getOwnPropertyDescriptor(defaults, key);\n\n      if (value && value.configurable && obj[key] === undefined) {\n        Object.defineProperty(obj, key, value);\n      }\n    }\n\n    return obj;\n  }\n\n  function _defineProperty(obj, key, value) {\n    if (key in obj) {\n      Object.defineProperty(obj, key, {\n        value: value,\n        enumerable: true,\n        configurable: true,\n        writable: true\n      });\n    } else {\n      obj[key] = value;\n    }\n\n    return obj;\n  }\n\n  function _extends() {\n    _extends =\n      Object.assign ||\n      function(target) {\n        for (var i = 1; i < arguments.length; i++) {\n          var source = arguments[i];\n\n          for (var key in source) {\n            if (Object.prototype.hasOwnProperty.call(source, key)) {\n              target[key] = source[key];\n            }\n          }\n        }\n\n        return target;\n      };\n\n    return _extends.apply(this, arguments);\n  }\n\n  function _objectSpread(target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i] != null ? arguments[i] : {};\n      var ownKeys = Object.keys(source);\n\n      if (typeof Object.getOwnPropertySymbols === 'function') {\n        ownKeys = ownKeys.concat(\n          Object.getOwnPropertySymbols(source).filter(function(sym) {\n            return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n          })\n        );\n      }\n\n      ownKeys.forEach(function(key) {\n        _defineProperty(target, key, source[key]);\n      });\n    }\n\n    return target;\n  }\n\n  function ownKeys(object, enumerableOnly) {\n    var keys = Object.keys(object);\n\n    if (Object.getOwnPropertySymbols) {\n      var symbols = Object.getOwnPropertySymbols(object);\n      if (enumerableOnly)\n        symbols = symbols.filter(function(sym) {\n          return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n        });\n      keys.push.apply(keys, symbols);\n    }\n\n    return keys;\n  }\n\n  function _objectSpread2(target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i] != null ? arguments[i] : {};\n\n      if (i % 2) {\n        ownKeys(source, true).forEach(function(key) {\n          _defineProperty(target, key, source[key]);\n        });\n      } else if (Object.getOwnPropertyDescriptors) {\n        Object.defineProperties(\n          target,\n          Object.getOwnPropertyDescriptors(source)\n        );\n      } else {\n        ownKeys(source).forEach(function(key) {\n          Object.defineProperty(\n            target,\n            key,\n            Object.getOwnPropertyDescriptor(source, key)\n          );\n        });\n      }\n    }\n\n    return target;\n  }\n\n  function _inherits(subClass, superClass) {\n    if (typeof superClass !== 'function' && superClass !== null) {\n      throw new TypeError('Super expression must either be null or a function');\n    }\n\n    subClass.prototype = Object.create(superClass && superClass.prototype, {\n      constructor: {\n        value: subClass,\n        writable: true,\n        configurable: true\n      }\n    });\n    if (superClass) _setPrototypeOf(subClass, superClass);\n  }\n\n  function _inheritsLoose(subClass, superClass) {\n    subClass.prototype = Object.create(superClass.prototype);\n    subClass.prototype.constructor = subClass;\n    subClass.__proto__ = superClass;\n  }\n\n  function _getPrototypeOf(o) {\n    _getPrototypeOf = Object.setPrototypeOf\n      ? Object.getPrototypeOf\n      : function _getPrototypeOf(o) {\n          return o.__proto__ || Object.getPrototypeOf(o);\n        };\n    return _getPrototypeOf(o);\n  }\n\n  function _setPrototypeOf(o, p) {\n    _setPrototypeOf =\n      Object.setPrototypeOf ||\n      function _setPrototypeOf(o, p) {\n        o.__proto__ = p;\n        return o;\n      };\n\n    return _setPrototypeOf(o, p);\n  }\n\n  function isNativeReflectConstruct() {\n    if (typeof Reflect === 'undefined' || !Reflect.construct) return false;\n    if (Reflect.construct.sham) return false;\n    if (typeof Proxy === 'function') return true;\n\n    try {\n      Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  function _construct(Parent, args, Class) {\n    if (isNativeReflectConstruct()) {\n      _construct = Reflect.construct;\n    } else {\n      _construct = function _construct(Parent, args, Class) {\n        var a = [null];\n        a.push.apply(a, args);\n        var Constructor = Function.bind.apply(Parent, a);\n        var instance = new Constructor();\n        if (Class) _setPrototypeOf(instance, Class.prototype);\n        return instance;\n      };\n    }\n\n    return _construct.apply(null, arguments);\n  }\n\n  function _isNativeFunction(fn) {\n    return Function.toString.call(fn).indexOf('[native code]') !== -1;\n  }\n\n  function _wrapNativeSuper(Class) {\n    var _cache = typeof Map === 'function' ? new Map() : undefined;\n\n    _wrapNativeSuper = function _wrapNativeSuper(Class) {\n      if (Class === null || !_isNativeFunction(Class)) return Class;\n\n      if (typeof Class !== 'function') {\n        throw new TypeError(\n          'Super expression must either be null or a function'\n        );\n      }\n\n      if (typeof _cache !== 'undefined') {\n        if (_cache.has(Class)) return _cache.get(Class);\n\n        _cache.set(Class, Wrapper);\n      }\n\n      function Wrapper() {\n        return _construct(Class, arguments, _getPrototypeOf(this).constructor);\n      }\n\n      Wrapper.prototype = Object.create(Class.prototype, {\n        constructor: {\n          value: Wrapper,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      });\n      return _setPrototypeOf(Wrapper, Class);\n    };\n\n    return _wrapNativeSuper(Class);\n  }\n\n  function _instanceof(left, right) {\n    if (\n      right != null &&\n      typeof Symbol !== 'undefined' &&\n      right[Symbol.hasInstance]\n    ) {\n      return !!right[Symbol.hasInstance](left);\n    } else {\n      return left instanceof right;\n    }\n  }\n\n  function _interopRequireDefault(obj) {\n    return obj && obj.__esModule\n      ? obj\n      : {\n          default: obj\n        };\n  }\n\n  function _interopRequireWildcard(obj) {\n    if (obj && obj.__esModule) {\n      return obj;\n    } else {\n      var newObj = {};\n\n      if (obj != null) {\n        for (var key in obj) {\n          if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            var desc =\n              Object.defineProperty && Object.getOwnPropertyDescriptor\n                ? Object.getOwnPropertyDescriptor(obj, key)\n                : {};\n\n            if (desc.get || desc.set) {\n              Object.defineProperty(newObj, key, desc);\n            } else {\n              newObj[key] = obj[key];\n            }\n          }\n        }\n      }\n\n      newObj.default = obj;\n      return newObj;\n    }\n  }\n\n  function _newArrowCheck(innerThis, boundThis) {\n    if (innerThis !== boundThis) {\n      throw new TypeError('Cannot instantiate an arrow function');\n    }\n  }\n\n  function _objectDestructuringEmpty(obj) {\n    if (obj == null) throw new TypeError('Cannot destructure undefined');\n  }\n\n  function _objectWithoutPropertiesLoose(source, excluded) {\n    if (source == null) return {};\n    var target = {};\n    var sourceKeys = Object.keys(source);\n    var key, i;\n\n    for (i = 0; i < sourceKeys.length; i++) {\n      key = sourceKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      target[key] = source[key];\n    }\n\n    return target;\n  }\n\n  function _objectWithoutProperties(source, excluded) {\n    if (source == null) return {};\n\n    var target = _objectWithoutPropertiesLoose(source, excluded);\n\n    var key, i;\n\n    if (Object.getOwnPropertySymbols) {\n      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n      for (i = 0; i < sourceSymbolKeys.length; i++) {\n        key = sourceSymbolKeys[i];\n        if (excluded.indexOf(key) >= 0) continue;\n        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n        target[key] = source[key];\n      }\n    }\n\n    return target;\n  }\n\n  function _assertThisInitialized(self) {\n    if (self === void 0) {\n      throw new ReferenceError(\n        \"this hasn't been initialised - super() hasn't been called\"\n      );\n    }\n\n    return self;\n  }\n\n  function _possibleConstructorReturn(self, call) {\n    if (call && (typeof call === 'object' || typeof call === 'function')) {\n      return call;\n    }\n\n    return _assertThisInitialized(self);\n  }\n\n  function _superPropBase(object, property) {\n    while (!Object.prototype.hasOwnProperty.call(object, property)) {\n      object = _getPrototypeOf(object);\n      if (object === null) break;\n    }\n\n    return object;\n  }\n\n  function _get(target, property, receiver) {\n    if (typeof Reflect !== 'undefined' && Reflect.get) {\n      _get = Reflect.get;\n    } else {\n      _get = function _get(target, property, receiver) {\n        var base = _superPropBase(target, property);\n\n        if (!base) return;\n        var desc = Object.getOwnPropertyDescriptor(base, property);\n\n        if (desc.get) {\n          return desc.get.call(receiver);\n        }\n\n        return desc.value;\n      };\n    }\n\n    return _get(target, property, receiver || target);\n  }\n\n  function set(target, property, value, receiver) {\n    if (typeof Reflect !== 'undefined' && Reflect.set) {\n      set = Reflect.set;\n    } else {\n      set = function set(target, property, value, receiver) {\n        var base = _superPropBase(target, property);\n\n        var desc;\n\n        if (base) {\n          desc = Object.getOwnPropertyDescriptor(base, property);\n\n          if (desc.set) {\n            desc.set.call(receiver, value);\n            return true;\n          } else if (!desc.writable) {\n            return false;\n          }\n        }\n\n        desc = Object.getOwnPropertyDescriptor(receiver, property);\n\n        if (desc) {\n          if (!desc.writable) {\n            return false;\n          }\n\n          desc.value = value;\n          Object.defineProperty(receiver, property, desc);\n        } else {\n          _defineProperty(receiver, property, value);\n        }\n\n        return true;\n      };\n    }\n\n    return set(target, property, value, receiver);\n  }\n\n  function _set(target, property, value, receiver, isStrict) {\n    var s = set(target, property, value, receiver || target);\n\n    if (!s && isStrict) {\n      throw new Error('failed to set property');\n    }\n\n    return value;\n  }\n\n  function _taggedTemplateLiteral(strings, raw) {\n    if (!raw) {\n      raw = strings.slice(0);\n    }\n\n    return Object.freeze(\n      Object.defineProperties(strings, {\n        raw: {\n          value: Object.freeze(raw)\n        }\n      })\n    );\n  }\n\n  function _taggedTemplateLiteralLoose(strings, raw) {\n    if (!raw) {\n      raw = strings.slice(0);\n    }\n\n    strings.raw = raw;\n    return strings;\n  }\n\n  function _temporalRef(val, name) {\n    if (val === _temporalUndefined) {\n      throw new ReferenceError(name + ' is not defined - temporal dead zone');\n    } else {\n      return val;\n    }\n  }\n\n  function _readOnlyError(name) {\n    throw new Error('\"' + name + '\" is read-only');\n  }\n\n  function _classNameTDZError(name) {\n    throw new Error(\n      'Class \"' + name + '\" cannot be referenced in computed property keys.'\n    );\n  }\n\n  var _temporalUndefined = {};\n\n  function _slicedToArray(arr, i) {\n    return (\n      _arrayWithHoles(arr) ||\n      _iterableToArrayLimit(arr, i) ||\n      _nonIterableRest()\n    );\n  }\n\n  function _slicedToArrayLoose(arr, i) {\n    return (\n      _arrayWithHoles(arr) ||\n      _iterableToArrayLimitLoose(arr, i) ||\n      _nonIterableRest()\n    );\n  }\n\n  function _toArray(arr) {\n    return _arrayWithHoles(arr) || _iterableToArray(arr) || _nonIterableRest();\n  }\n\n  function _toConsumableArray(arr) {\n    return (\n      _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread()\n    );\n  }\n\n  function _arrayWithoutHoles(arr) {\n    if (Array.isArray(arr)) {\n      for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++)\n        arr2[i] = arr[i];\n\n      return arr2;\n    }\n  }\n\n  function _arrayWithHoles(arr) {\n    if (Array.isArray(arr)) return arr;\n  }\n\n  function _iterableToArray(iter) {\n    if (\n      Symbol.iterator in Object(iter) ||\n      Object.prototype.toString.call(iter) === '[object Arguments]'\n    )\n      return Array.from(iter);\n  }\n\n  function _iterableToArrayLimit(arr, i) {\n    var _arr = [];\n    var _n = true;\n    var _d = false;\n    var _e = undefined;\n\n    try {\n      for (\n        var _i = arr[Symbol.iterator](), _s;\n        !(_n = (_s = _i.next()).done);\n        _n = true\n      ) {\n        _arr.push(_s.value);\n\n        if (i && _arr.length === i) break;\n      }\n    } catch (err) {\n      _d = true;\n      _e = err;\n    } finally {\n      try {\n        if (!_n && _i['return'] != null) _i['return']();\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n\n    return _arr;\n  }\n\n  function _iterableToArrayLimitLoose(arr, i) {\n    var _arr = [];\n\n    for (\n      var _iterator = arr[Symbol.iterator](), _step;\n      !(_step = _iterator.next()).done;\n\n    ) {\n      _arr.push(_step.value);\n\n      if (i && _arr.length === i) break;\n    }\n\n    return _arr;\n  }\n\n  function _nonIterableSpread() {\n    throw new TypeError('Invalid attempt to spread non-iterable instance');\n  }\n\n  function _nonIterableRest() {\n    throw new TypeError('Invalid attempt to destructure non-iterable instance');\n  }\n\n  function _skipFirstGeneratorNext(fn) {\n    return function() {\n      var it = fn.apply(this, arguments);\n      it.next();\n      return it;\n    };\n  }\n\n  function _toPrimitive(input, hint) {\n    if (typeof input !== 'object' || input === null) return input;\n    var prim = input[Symbol.toPrimitive];\n\n    if (prim !== undefined) {\n      var res = prim.call(input, hint || 'default');\n      if (typeof res !== 'object') return res;\n      throw new TypeError('@@toPrimitive must return a primitive value.');\n    }\n\n    return (hint === 'string' ? String : Number)(input);\n  }\n\n  function _toPropertyKey(arg) {\n    var key = _toPrimitive(arg, 'string');\n\n    return typeof key === 'symbol' ? key : String(key);\n  }\n\n  function _initializerWarningHelper(descriptor, context) {\n    throw new Error(\n      'Decorating class property failed. Please ensure that ' +\n        'proposal-class-properties is enabled and set to use loose mode. ' +\n        'To use proposal-class-properties in spec mode with decorators, wait for ' +\n        'the next major version of decorators in stage 2.'\n    );\n  }\n\n  function _initializerDefineProperty(target, property, descriptor, context) {\n    if (!descriptor) return;\n    Object.defineProperty(target, property, {\n      enumerable: descriptor.enumerable,\n      configurable: descriptor.configurable,\n      writable: descriptor.writable,\n      value: descriptor.initializer\n        ? descriptor.initializer.call(context)\n        : void 0\n    });\n  }\n\n  function _applyDecoratedDescriptor(\n    target,\n    property,\n    decorators,\n    descriptor,\n    context\n  ) {\n    var desc = {};\n    Object.keys(descriptor).forEach(function(key) {\n      desc[key] = descriptor[key];\n    });\n    desc.enumerable = !!desc.enumerable;\n    desc.configurable = !!desc.configurable;\n\n    if ('value' in desc || desc.initializer) {\n      desc.writable = true;\n    }\n\n    desc = decorators\n      .slice()\n      .reverse()\n      .reduce(function(desc, decorator) {\n        return decorator(target, property, desc) || desc;\n      }, desc);\n\n    if (context && desc.initializer !== void 0) {\n      desc.value = desc.initializer ? desc.initializer.call(context) : void 0;\n      desc.initializer = undefined;\n    }\n\n    if (desc.initializer === void 0) {\n      Object.defineProperty(target, property, desc);\n      desc = null;\n    }\n\n    return desc;\n  }\n\n  var id = 0;\n\n  function _classPrivateFieldLooseKey(name) {\n    return '__private_' + id++ + '_' + name;\n  }\n\n  function _classPrivateFieldLooseBase(receiver, privateKey) {\n    if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {\n      throw new TypeError('attempted to use private field on non-instance');\n    }\n\n    return receiver;\n  }\n\n  function _classPrivateFieldGet(receiver, privateMap) {\n    var descriptor = privateMap.get(receiver);\n\n    if (!descriptor) {\n      throw new TypeError('attempted to get private field on non-instance');\n    }\n\n    if (descriptor.get) {\n      return descriptor.get.call(receiver);\n    }\n\n    return descriptor.value;\n  }\n\n  function _classPrivateFieldSet(receiver, privateMap, value) {\n    var descriptor = privateMap.get(receiver);\n\n    if (!descriptor) {\n      throw new TypeError('attempted to set private field on non-instance');\n    }\n\n    if (descriptor.set) {\n      descriptor.set.call(receiver, value);\n    } else {\n      if (!descriptor.writable) {\n        throw new TypeError('attempted to set read only private field');\n      }\n\n      descriptor.value = value;\n    }\n\n    return value;\n  }\n\n  function _classPrivateFieldDestructureSet(receiver, privateMap) {\n    if (!privateMap.has(receiver)) {\n      throw new TypeError('attempted to set private field on non-instance');\n    }\n\n    var descriptor = privateMap.get(receiver);\n\n    if (descriptor.set) {\n      if (!('__destrObj' in descriptor)) {\n        descriptor.__destrObj = {\n          set value(v) {\n            descriptor.set.call(receiver, v);\n          }\n        };\n      }\n\n      return descriptor.__destrObj;\n    } else {\n      if (!descriptor.writable) {\n        throw new TypeError('attempted to set read only private field');\n      }\n\n      return descriptor;\n    }\n  }\n\n  function _classStaticPrivateFieldSpecGet(\n    receiver,\n    classConstructor,\n    descriptor\n  ) {\n    if (receiver !== classConstructor) {\n      throw new TypeError('Private static access of wrong provenance');\n    }\n\n    return descriptor.value;\n  }\n\n  function _classStaticPrivateFieldSpecSet(\n    receiver,\n    classConstructor,\n    descriptor,\n    value\n  ) {\n    if (receiver !== classConstructor) {\n      throw new TypeError('Private static access of wrong provenance');\n    }\n\n    if (!descriptor.writable) {\n      throw new TypeError('attempted to set read only private field');\n    }\n\n    descriptor.value = value;\n    return value;\n  }\n\n  function _classStaticPrivateMethodGet(receiver, classConstructor, method) {\n    if (receiver !== classConstructor) {\n      throw new TypeError('Private static access of wrong provenance');\n    }\n\n    return method;\n  }\n\n  function _classStaticPrivateMethodSet() {\n    throw new TypeError('attempted to set read only static private field');\n  }\n\n  function _decorate(decorators, factory, superClass, mixins) {\n    var api = _getDecoratorsApi();\n\n    if (mixins) {\n      for (var i = 0; i < mixins.length; i++) {\n        api = mixins[i](api);\n      }\n    }\n\n    var r = factory(function initialize(O) {\n      api.initializeInstanceElements(O, decorated.elements);\n    }, superClass);\n    var decorated = api.decorateClass(\n      _coalesceClassElements(r.d.map(_createElementDescriptor)),\n      decorators\n    );\n    api.initializeClassElements(r.F, decorated.elements);\n    return api.runClassFinishers(r.F, decorated.finishers);\n  }\n\n  function _getDecoratorsApi() {\n    _getDecoratorsApi = function() {\n      return api;\n    };\n\n    var api = {\n      elementsDefinitionOrder: [['method'], ['field']],\n      initializeInstanceElements: function(O, elements) {\n        ['method', 'field'].forEach(function(kind) {\n          elements.forEach(function(element) {\n            if (element.kind === kind && element.placement === 'own') {\n              this.defineClassElement(O, element);\n            }\n          }, this);\n        }, this);\n      },\n      initializeClassElements: function(F, elements) {\n        var proto = F.prototype;\n        ['method', 'field'].forEach(function(kind) {\n          elements.forEach(function(element) {\n            var placement = element.placement;\n\n            if (\n              element.kind === kind &&\n              (placement === 'static' || placement === 'prototype')\n            ) {\n              var receiver = placement === 'static' ? F : proto;\n              this.defineClassElement(receiver, element);\n            }\n          }, this);\n        }, this);\n      },\n      defineClassElement: function(receiver, element) {\n        var descriptor = element.descriptor;\n\n        if (element.kind === 'field') {\n          var initializer = element.initializer;\n          descriptor = {\n            enumerable: descriptor.enumerable,\n            writable: descriptor.writable,\n            configurable: descriptor.configurable,\n            value: initializer === void 0 ? void 0 : initializer.call(receiver)\n          };\n        }\n\n        Object.defineProperty(receiver, element.key, descriptor);\n      },\n      decorateClass: function(elements, decorators) {\n        var newElements = [];\n        var finishers = [];\n        var placements = {\n          static: [],\n          prototype: [],\n          own: []\n        };\n        elements.forEach(function(element) {\n          this.addElementPlacement(element, placements);\n        }, this);\n        elements.forEach(function(element) {\n          if (!_hasDecorators(element)) return newElements.push(element);\n          var elementFinishersExtras = this.decorateElement(\n            element,\n            placements\n          );\n          newElements.push(elementFinishersExtras.element);\n          newElements.push.apply(newElements, elementFinishersExtras.extras);\n          finishers.push.apply(finishers, elementFinishersExtras.finishers);\n        }, this);\n\n        if (!decorators) {\n          return {\n            elements: newElements,\n            finishers: finishers\n          };\n        }\n\n        var result = this.decorateConstructor(newElements, decorators);\n        finishers.push.apply(finishers, result.finishers);\n        result.finishers = finishers;\n        return result;\n      },\n      addElementPlacement: function(element, placements, silent) {\n        var keys = placements[element.placement];\n\n        if (!silent && keys.indexOf(element.key) !== -1) {\n          throw new TypeError('Duplicated element (' + element.key + ')');\n        }\n\n        keys.push(element.key);\n      },\n      decorateElement: function(element, placements) {\n        var extras = [];\n        var finishers = [];\n\n        for (\n          var decorators = element.decorators, i = decorators.length - 1;\n          i >= 0;\n          i--\n        ) {\n          var keys = placements[element.placement];\n          keys.splice(keys.indexOf(element.key), 1);\n          var elementObject = this.fromElementDescriptor(element);\n          var elementFinisherExtras = this.toElementFinisherExtras(\n            (0, decorators[i])(elementObject) || elementObject\n          );\n          element = elementFinisherExtras.element;\n          this.addElementPlacement(element, placements);\n\n          if (elementFinisherExtras.finisher) {\n            finishers.push(elementFinisherExtras.finisher);\n          }\n\n          var newExtras = elementFinisherExtras.extras;\n\n          if (newExtras) {\n            for (var j = 0; j < newExtras.length; j++) {\n              this.addElementPlacement(newExtras[j], placements);\n            }\n\n            extras.push.apply(extras, newExtras);\n          }\n        }\n\n        return {\n          element: element,\n          finishers: finishers,\n          extras: extras\n        };\n      },\n      decorateConstructor: function(elements, decorators) {\n        var finishers = [];\n\n        for (var i = decorators.length - 1; i >= 0; i--) {\n          var obj = this.fromClassDescriptor(elements);\n          var elementsAndFinisher = this.toClassDescriptor(\n            (0, decorators[i])(obj) || obj\n          );\n\n          if (elementsAndFinisher.finisher !== undefined) {\n            finishers.push(elementsAndFinisher.finisher);\n          }\n\n          if (elementsAndFinisher.elements !== undefined) {\n            elements = elementsAndFinisher.elements;\n\n            for (var j = 0; j < elements.length - 1; j++) {\n              for (var k = j + 1; k < elements.length; k++) {\n                if (\n                  elements[j].key === elements[k].key &&\n                  elements[j].placement === elements[k].placement\n                ) {\n                  throw new TypeError(\n                    'Duplicated element (' + elements[j].key + ')'\n                  );\n                }\n              }\n            }\n          }\n        }\n\n        return {\n          elements: elements,\n          finishers: finishers\n        };\n      },\n      fromElementDescriptor: function(element) {\n        var obj = {\n          kind: element.kind,\n          key: element.key,\n          placement: element.placement,\n          descriptor: element.descriptor\n        };\n        var desc = {\n          value: 'Descriptor',\n          configurable: true\n        };\n        Object.defineProperty(obj, Symbol.toStringTag, desc);\n        if (element.kind === 'field') obj.initializer = element.initializer;\n        return obj;\n      },\n      toElementDescriptors: function(elementObjects) {\n        if (elementObjects === undefined) return;\n        return _toArray(elementObjects).map(function(elementObject) {\n          var element = this.toElementDescriptor(elementObject);\n          this.disallowProperty(\n            elementObject,\n            'finisher',\n            'An element descriptor'\n          );\n          this.disallowProperty(\n            elementObject,\n            'extras',\n            'An element descriptor'\n          );\n          return element;\n        }, this);\n      },\n      toElementDescriptor: function(elementObject) {\n        var kind = String(elementObject.kind);\n\n        if (kind !== 'method' && kind !== 'field') {\n          throw new TypeError(\n            'An element descriptor\\'s .kind property must be either \"method\" or' +\n              ' \"field\", but a decorator created an element descriptor with' +\n              ' .kind \"' +\n              kind +\n              '\"'\n          );\n        }\n\n        var key = _toPropertyKey(elementObject.key);\n\n        var placement = String(elementObject.placement);\n\n        if (\n          placement !== 'static' &&\n          placement !== 'prototype' &&\n          placement !== 'own'\n        ) {\n          throw new TypeError(\n            'An element descriptor\\'s .placement property must be one of \"static\",' +\n              ' \"prototype\" or \"own\", but a decorator created an element descriptor' +\n              ' with .placement \"' +\n              placement +\n              '\"'\n          );\n        }\n\n        var descriptor = elementObject.descriptor;\n        this.disallowProperty(\n          elementObject,\n          'elements',\n          'An element descriptor'\n        );\n        var element = {\n          kind: kind,\n          key: key,\n          placement: placement,\n          descriptor: Object.assign({}, descriptor)\n        };\n\n        if (kind !== 'field') {\n          this.disallowProperty(\n            elementObject,\n            'initializer',\n            'A method descriptor'\n          );\n        } else {\n          this.disallowProperty(\n            descriptor,\n            'get',\n            'The property descriptor of a field descriptor'\n          );\n          this.disallowProperty(\n            descriptor,\n            'set',\n            'The property descriptor of a field descriptor'\n          );\n          this.disallowProperty(\n            descriptor,\n            'value',\n            'The property descriptor of a field descriptor'\n          );\n          element.initializer = elementObject.initializer;\n        }\n\n        return element;\n      },\n      toElementFinisherExtras: function(elementObject) {\n        var element = this.toElementDescriptor(elementObject);\n\n        var finisher = _optionalCallableProperty(elementObject, 'finisher');\n\n        var extras = this.toElementDescriptors(elementObject.extras);\n        return {\n          element: element,\n          finisher: finisher,\n          extras: extras\n        };\n      },\n      fromClassDescriptor: function(elements) {\n        var obj = {\n          kind: 'class',\n          elements: elements.map(this.fromElementDescriptor, this)\n        };\n        var desc = {\n          value: 'Descriptor',\n          configurable: true\n        };\n        Object.defineProperty(obj, Symbol.toStringTag, desc);\n        return obj;\n      },\n      toClassDescriptor: function(obj) {\n        var kind = String(obj.kind);\n\n        if (kind !== 'class') {\n          throw new TypeError(\n            'A class descriptor\\'s .kind property must be \"class\", but a decorator' +\n              ' created a class descriptor with .kind \"' +\n              kind +\n              '\"'\n          );\n        }\n\n        this.disallowProperty(obj, 'key', 'A class descriptor');\n        this.disallowProperty(obj, 'placement', 'A class descriptor');\n        this.disallowProperty(obj, 'descriptor', 'A class descriptor');\n        this.disallowProperty(obj, 'initializer', 'A class descriptor');\n        this.disallowProperty(obj, 'extras', 'A class descriptor');\n\n        var finisher = _optionalCallableProperty(obj, 'finisher');\n\n        var elements = this.toElementDescriptors(obj.elements);\n        return {\n          elements: elements,\n          finisher: finisher\n        };\n      },\n      runClassFinishers: function(constructor, finishers) {\n        for (var i = 0; i < finishers.length; i++) {\n          var newConstructor = (0, finishers[i])(constructor);\n\n          if (newConstructor !== undefined) {\n            if (typeof newConstructor !== 'function') {\n              throw new TypeError('Finishers must return a constructor.');\n            }\n\n            constructor = newConstructor;\n          }\n        }\n\n        return constructor;\n      },\n      disallowProperty: function(obj, name, objectType) {\n        if (obj[name] !== undefined) {\n          throw new TypeError(\n            objectType + \" can't have a .\" + name + ' property.'\n          );\n        }\n      }\n    };\n    return api;\n  }\n\n  function _createElementDescriptor(def) {\n    var key = _toPropertyKey(def.key);\n\n    var descriptor;\n\n    if (def.kind === 'method') {\n      descriptor = {\n        value: def.value,\n        writable: true,\n        configurable: true,\n        enumerable: false\n      };\n    } else if (def.kind === 'get') {\n      descriptor = {\n        get: def.value,\n        configurable: true,\n        enumerable: false\n      };\n    } else if (def.kind === 'set') {\n      descriptor = {\n        set: def.value,\n        configurable: true,\n        enumerable: false\n      };\n    } else if (def.kind === 'field') {\n      descriptor = {\n        configurable: true,\n        writable: true,\n        enumerable: true\n      };\n    }\n\n    var element = {\n      kind: def.kind === 'field' ? 'field' : 'method',\n      key: key,\n      placement: def.static\n        ? 'static'\n        : def.kind === 'field'\n        ? 'own'\n        : 'prototype',\n      descriptor: descriptor\n    };\n    if (def.decorators) element.decorators = def.decorators;\n    if (def.kind === 'field') element.initializer = def.value;\n    return element;\n  }\n\n  function _coalesceGetterSetter(element, other) {\n    if (element.descriptor.get !== undefined) {\n      other.descriptor.get = element.descriptor.get;\n    } else {\n      other.descriptor.set = element.descriptor.set;\n    }\n  }\n\n  function _coalesceClassElements(elements) {\n    var newElements = [];\n\n    var isSameElement = function(other) {\n      return (\n        other.kind === 'method' &&\n        other.key === element.key &&\n        other.placement === element.placement\n      );\n    };\n\n    for (var i = 0; i < elements.length; i++) {\n      var element = elements[i];\n      var other;\n\n      if (\n        element.kind === 'method' &&\n        (other = newElements.find(isSameElement))\n      ) {\n        if (\n          _isDataDescriptor(element.descriptor) ||\n          _isDataDescriptor(other.descriptor)\n        ) {\n          if (_hasDecorators(element) || _hasDecorators(other)) {\n            throw new ReferenceError(\n              'Duplicated methods (' + element.key + \") can't be decorated.\"\n            );\n          }\n\n          other.descriptor = element.descriptor;\n        } else {\n          if (_hasDecorators(element)) {\n            if (_hasDecorators(other)) {\n              throw new ReferenceError(\n                \"Decorators can't be placed on different accessors with for \" +\n                  'the same property (' +\n                  element.key +\n                  ').'\n              );\n            }\n\n            other.decorators = element.decorators;\n          }\n\n          _coalesceGetterSetter(element, other);\n        }\n      } else {\n        newElements.push(element);\n      }\n    }\n\n    return newElements;\n  }\n\n  function _hasDecorators(element) {\n    return element.decorators && element.decorators.length;\n  }\n\n  function _isDataDescriptor(desc) {\n    return (\n      desc !== undefined &&\n      !(desc.value === undefined && desc.writable === undefined)\n    );\n  }\n\n  function _optionalCallableProperty(obj, name) {\n    var value = obj[name];\n\n    if (value !== undefined && typeof value !== 'function') {\n      throw new TypeError(\"Expected '\" + name + \"' to be a function\");\n    }\n\n    return value;\n  }\n\n  function _classPrivateMethodGet(receiver, privateSet, fn) {\n    if (!privateSet.has(receiver)) {\n      throw new TypeError('attempted to get private field on non-instance');\n    }\n\n    return fn;\n  }\n\n  function _classPrivateMethodSet() {\n    throw new TypeError('attempted to reassign private method');\n  }\n\n  function _wrapRegExp(re, groups) {\n    _wrapRegExp = function(re, groups) {\n      return new BabelRegExp(re, groups);\n    };\n\n    var _RegExp = _wrapNativeSuper(RegExp);\n\n    var _super = RegExp.prototype;\n\n    var _groups = new WeakMap();\n\n    function BabelRegExp(re, groups) {\n      var _this = _RegExp.call(this, re);\n\n      _groups.set(_this, groups);\n\n      return _this;\n    }\n\n    _inherits(BabelRegExp, _RegExp);\n\n    BabelRegExp.prototype.exec = function(str) {\n      var result = _super.exec.call(this, str);\n\n      if (result) result.groups = buildGroups(result, this);\n      return result;\n    };\n\n    BabelRegExp.prototype[Symbol.replace] = function(str, substitution) {\n      if (typeof substitution === 'string') {\n        var groups = _groups.get(this);\n\n        return _super[Symbol.replace].call(\n          this,\n          str,\n          substitution.replace(/\\$<([^>]+)>/g, function(_, name) {\n            return '$' + groups[name];\n          })\n        );\n      } else if (typeof substitution === 'function') {\n        var _this = this;\n\n        return _super[Symbol.replace].call(this, str, function() {\n          var args = [];\n          args.push.apply(args, arguments);\n\n          if (typeof args[args.length - 1] !== 'object') {\n            args.push(buildGroups(args, _this));\n          }\n\n          return substitution.apply(this, args);\n        });\n      } else {\n        return _super[Symbol.replace].call(this, str, substitution);\n      }\n    };\n\n    function buildGroups(result, re) {\n      var g = _groups.get(re);\n\n      return Object.keys(g).reduce(function(groups, name) {\n        groups[name] = result[g[name]];\n        return groups;\n      }, Object.create(null));\n    }\n\n    return _wrapRegExp.apply(this, arguments);\n  }\n\n  var arrayRemove = function arrayRemove(arr, index) {\n    return arr.splice(index, 1);\n  };\n\n  var run = function run(cb, sync) {\n    if (sync) {\n      cb();\n    } else if (document.hidden) {\n      Promise.resolve(1).then(cb);\n    } else {\n      setTimeout(cb, 0);\n    }\n  };\n\n  var on = function on() {\n    var listeners = [];\n    var off = function off(event, cb) {\n      arrayRemove(\n        listeners,\n        listeners.findIndex(function(listener) {\n          return listener.event === event && (listener.cb === cb || !cb);\n        })\n      );\n    };\n    var _fire = function fire(event, args, sync) {\n      listeners\n        .filter(function(listener) {\n          return listener.event === event;\n        })\n        .map(function(listener) {\n          return listener.cb;\n        })\n        .forEach(function(cb) {\n          return run(function() {\n            return cb.apply(void 0, _toConsumableArray(args));\n          }, sync);\n        });\n    };\n    return {\n      fireSync: function fireSync(event) {\n        for (\n          var _len = arguments.length,\n            args = new Array(_len > 1 ? _len - 1 : 0),\n            _key = 1;\n          _key < _len;\n          _key++\n        ) {\n          args[_key - 1] = arguments[_key];\n        }\n        _fire(event, args, true);\n      },\n      fire: function fire(event) {\n        for (\n          var _len2 = arguments.length,\n            args = new Array(_len2 > 1 ? _len2 - 1 : 0),\n            _key2 = 1;\n          _key2 < _len2;\n          _key2++\n        ) {\n          args[_key2 - 1] = arguments[_key2];\n        }\n        _fire(event, args, false);\n      },\n      on: function on(event, cb) {\n        listeners.push({ event: event, cb: cb });\n      },\n      onOnce: function onOnce(event, _cb) {\n        listeners.push({\n          event: event,\n          cb: function cb() {\n            off(event, _cb);\n            _cb.apply(void 0, arguments);\n          }\n        });\n      },\n      off: off\n    };\n  };\n\n  var copyObjectPropertiesToObject = function copyObjectPropertiesToObject(\n    src,\n    target,\n    excluded\n  ) {\n    Object.getOwnPropertyNames(src)\n      .filter(function(property) {\n        return !excluded.includes(property);\n      })\n      .forEach(function(key) {\n        return Object.defineProperty(\n          target,\n          key,\n          Object.getOwnPropertyDescriptor(src, key)\n        );\n      });\n  };\n\n  var PRIVATE = [\n    'fire',\n    'process',\n    'revert',\n    'load',\n    'on',\n    'off',\n    'onOnce',\n    'retryLoad',\n    'extend',\n    'archive',\n    'archived',\n    'release',\n    'released',\n    'requestProcessing',\n    'freeze'\n  ];\n\n  var createItemAPI = function createItemAPI(item) {\n    var api = {};\n    copyObjectPropertiesToObject(item, api, PRIVATE);\n    return api;\n  };\n\n  var removeReleasedItems = function removeReleasedItems(items) {\n    items.forEach(function(item, index) {\n      if (item.released) {\n        arrayRemove(items, index);\n      }\n    });\n  };\n\n  var ItemStatus = {\n    INIT: 1,\n    IDLE: 2,\n    PROCESSING_QUEUED: 9,\n    PROCESSING: 3,\n    PROCESSING_COMPLETE: 5,\n    PROCESSING_ERROR: 6,\n    PROCESSING_REVERT_ERROR: 10,\n    LOADING: 7,\n    LOAD_ERROR: 8\n  };\n\n  var FileOrigin = {\n    INPUT: 1,\n    LIMBO: 2,\n    LOCAL: 3\n  };\n\n  var getNonNumeric = function getNonNumeric(str) {\n    return /[^0-9]+/.exec(str);\n  };\n\n  var getDecimalSeparator = function getDecimalSeparator() {\n    return getNonNumeric((1.1).toLocaleString())[0];\n  };\n\n  var getThousandsSeparator = function getThousandsSeparator() {\n    // Added for browsers that do not return the thousands separator (happend on native browser Android 4.4.4)\n    // We check against the normal toString output and if they're the same return a comma when decimal separator is a dot\n    var decimalSeparator = getDecimalSeparator();\n    var thousandsStringWithSeparator = (1000.0).toLocaleString();\n    var thousandsStringWithoutSeparator = (1000.0).toString();\n    if (thousandsStringWithSeparator !== thousandsStringWithoutSeparator) {\n      return getNonNumeric(thousandsStringWithSeparator)[0];\n    }\n    return decimalSeparator === '.' ? ',' : '.';\n  };\n\n  var Type = {\n    BOOLEAN: 'boolean',\n    INT: 'int',\n    NUMBER: 'number',\n    STRING: 'string',\n    ARRAY: 'array',\n    OBJECT: 'object',\n    FUNCTION: 'function',\n    ACTION: 'action',\n    SERVER_API: 'serverapi',\n    REGEX: 'regex'\n  };\n\n  // all registered filters\n  var filters = [];\n\n  // loops over matching filters and passes options to each filter, returning the mapped results\n  var applyFilterChain = function applyFilterChain(key, value, utils) {\n    return new Promise(function(resolve, reject) {\n      // find matching filters for this key\n      var matchingFilters = filters\n        .filter(function(f) {\n          return f.key === key;\n        })\n        .map(function(f) {\n          return f.cb;\n        });\n\n      // resolve now\n      if (matchingFilters.length === 0) {\n        resolve(value);\n        return;\n      }\n\n      // first filter to kick things of\n      var initialFilter = matchingFilters.shift();\n\n      // chain filters\n      matchingFilters\n        .reduce(\n          // loop over promises passing value to next promise\n          function(current, next) {\n            return current.then(function(value) {\n              return next(value, utils);\n            });\n          },\n\n          // call initial filter, will return a promise\n          initialFilter(value, utils)\n\n          // all executed\n        )\n        .then(function(value) {\n          return resolve(value);\n        })\n        .catch(function(error) {\n          return reject(error);\n        });\n    });\n  };\n\n  var applyFilters = function applyFilters(key, value, utils) {\n    return filters\n      .filter(function(f) {\n        return f.key === key;\n      })\n      .map(function(f) {\n        return f.cb(value, utils);\n      });\n  };\n\n  // adds a new filter to the list\n  var addFilter = function addFilter(key, cb) {\n    return filters.push({ key: key, cb: cb });\n  };\n\n  var extendDefaultOptions = function extendDefaultOptions(additionalOptions) {\n    return Object.assign(defaultOptions, additionalOptions);\n  };\n\n  var getOptions = function getOptions() {\n    return Object.assign({}, defaultOptions);\n  };\n\n  var setOptions = function setOptions(opts) {\n    forin(opts, function(key, value) {\n      // key does not exist, so this option cannot be set\n      if (!defaultOptions[key]) {\n        return;\n      }\n      defaultOptions[key][0] = getValueByType(\n        value,\n        defaultOptions[key][0],\n        defaultOptions[key][1]\n      );\n    });\n  };\n\n  // default options on app\n  var defaultOptions = {\n    // the id to add to the root element\n    id: [null, Type.STRING],\n\n    // input field name to use\n    name: ['filepond', Type.STRING],\n\n    // disable the field\n    disabled: [false, Type.BOOLEAN],\n\n    // classname to put on wrapper\n    className: [null, Type.STRING],\n\n    // is the field required\n    required: [false, Type.BOOLEAN],\n\n    // Allow media capture when value is set\n    captureMethod: [null, Type.STRING],\n    // - \"camera\", \"microphone\" or \"camcorder\",\n    // - Does not work with multiple on apple devices\n    // - If set, acceptedFileTypes must be made to match with media wildcard \"image/*\", \"audio/*\" or \"video/*\"\n\n    // sync `acceptedFileTypes` property with `accept` attribute\n    allowSyncAcceptAttribute: [true, Type.BOOLEAN],\n\n    // Feature toggles\n    allowDrop: [true, Type.BOOLEAN], // Allow dropping of files\n    allowBrowse: [true, Type.BOOLEAN], // Allow browsing the file system\n    allowPaste: [true, Type.BOOLEAN], // Allow pasting files\n    allowMultiple: [false, Type.BOOLEAN], // Allow multiple files (disabled by default, as multiple attribute is also required on input to allow multiple)\n    allowReplace: [true, Type.BOOLEAN], // Allow dropping a file on other file to replace it (only works when multiple is set to false)\n    allowRevert: [true, Type.BOOLEAN], // Allows user to revert file upload\n    allowRemove: [true, Type.BOOLEAN], // Allow user to remove a file\n    allowProcess: [true, Type.BOOLEAN], // Allows user to process a file, when set to false, this removes the file upload button\n    allowReorder: [false, Type.BOOLEAN], // Allow reordering of files\n    allowDirectoriesOnly: [false, Type.BOOLEAN], // Allow only selecting directories with browse (no support for filtering dnd at this point)\n\n    // Revert mode\n    forceRevert: [false, Type.BOOLEAN], // Set to 'force' to require the file to be reverted before removal\n\n    // Input requirements\n    maxFiles: [null, Type.INT], // Max number of files\n    checkValidity: [false, Type.BOOLEAN], // Enables custom validity messages\n\n    // Where to put file\n    itemInsertLocationFreedom: [true, Type.BOOLEAN], // Set to false to always add items to begin or end of list\n    itemInsertLocation: ['before', Type.STRING], // Default index in list to add items that have been dropped at the top of the list\n    itemInsertInterval: [75, Type.INT],\n\n    // Drag 'n Drop related\n    dropOnPage: [false, Type.BOOLEAN], // Allow dropping of files anywhere on page (prevents browser from opening file if dropped outside of Up)\n    dropOnElement: [true, Type.BOOLEAN], // Drop needs to happen on element (set to false to also load drops outside of Up)\n    dropValidation: [false, Type.BOOLEAN], // Enable or disable validating files on drop\n    ignoredFiles: [['.ds_store', 'thumbs.db', 'desktop.ini'], Type.ARRAY],\n\n    // Upload related\n    instantUpload: [true, Type.BOOLEAN], // Should upload files immediately on drop\n    maxParallelUploads: [2, Type.INT], // Maximum files to upload in parallel\n\n    // Chunks\n    chunkUploads: [false, Type.BOOLEAN], // Enable chunked uploads\n    chunkForce: [false, Type.BOOLEAN], // Force use of chunk uploads even for files smaller than chunk size\n    chunkSize: [5000000, Type.INT], // Size of chunks (5MB default)\n    chunkRetryDelays: [[500, 1000, 3000], Type.Array], // Amount of times to retry upload of a chunk when it fails\n\n    // The server api end points to use for uploading (see docs)\n    server: [null, Type.SERVER_API],\n\n    // File size calculations, can set to 1024, this is only used for display, properties use file size base 1000\n    fileSizeBase: [1000, Type.INT],\n\n    // Labels and status messages\n    labelDecimalSeparator: [getDecimalSeparator(), Type.STRING], // Default is locale separator\n    labelThousandsSeparator: [getThousandsSeparator(), Type.STRING], // Default is locale separator\n\n    labelIdle: [\n      'Drag & Drop your files or <span class=\"filepond--label-action\">Browse</span>',\n      Type.STRING\n    ],\n    labelInvalidField: ['Field contains invalid files', Type.STRING],\n    labelFileWaitingForSize: ['Waiting for size', Type.STRING],\n    labelFileSizeNotAvailable: ['Size not available', Type.STRING],\n    labelFileCountSingular: ['file in list', Type.STRING],\n    labelFileCountPlural: ['files in list', Type.STRING],\n    labelFileLoading: ['Loading', Type.STRING],\n    labelFileAdded: ['Added', Type.STRING], // assistive only\n    labelFileLoadError: ['Error during load', Type.STRING],\n    labelFileRemoved: ['Removed', Type.STRING], // assistive only\n    labelFileRemoveError: ['Error during remove', Type.STRING],\n    labelFileProcessing: ['Uploading', Type.STRING],\n    labelFileProcessingComplete: ['Upload complete', Type.STRING],\n    labelFileProcessingAborted: ['Upload cancelled', Type.STRING],\n    labelFileProcessingError: ['Error during upload', Type.STRING],\n    labelFileProcessingRevertError: ['Error during revert', Type.STRING],\n\n    labelTapToCancel: ['tap to cancel', Type.STRING],\n    labelTapToRetry: ['tap to retry', Type.STRING],\n    labelTapToUndo: ['tap to undo', Type.STRING],\n\n    labelButtonRemoveItem: ['Remove', Type.STRING],\n    labelButtonAbortItemLoad: ['Abort', Type.STRING],\n    labelButtonRetryItemLoad: ['Retry', Type.STRING],\n    labelButtonAbortItemProcessing: ['Cancel', Type.STRING],\n    labelButtonUndoItemProcessing: ['Undo', Type.STRING],\n    labelButtonRetryItemProcessing: ['Retry', Type.STRING],\n    labelButtonProcessItem: ['Upload', Type.STRING],\n\n    // make sure width and height plus viewpox are even numbers so icons are nicely centered\n    iconRemove: [\n      '<svg width=\"26\" height=\"26\" viewBox=\"0 0 26 26\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M11.586 13l-2.293 2.293a1 1 0 0 0 1.414 1.414L13 14.414l2.293 2.293a1 1 0 0 0 1.414-1.414L14.414 13l2.293-2.293a1 1 0 0 0-1.414-1.414L13 11.586l-2.293-2.293a1 1 0 0 0-1.414 1.414L11.586 13z\" fill=\"currentColor\" fill-rule=\"nonzero\"/></svg>',\n      Type.STRING\n    ],\n\n    iconProcess: [\n      '<svg width=\"26\" height=\"26\" viewBox=\"0 0 26 26\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M14 10.414v3.585a1 1 0 0 1-2 0v-3.585l-1.293 1.293a1 1 0 0 1-1.414-1.415l3-3a1 1 0 0 1 1.414 0l3 3a1 1 0 0 1-1.414 1.415L14 10.414zM9 18a1 1 0 0 1 0-2h8a1 1 0 0 1 0 2H9z\" fill=\"currentColor\" fill-rule=\"evenodd\"/></svg>',\n      Type.STRING\n    ],\n\n    iconRetry: [\n      '<svg width=\"26\" height=\"26\" viewBox=\"0 0 26 26\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.81 9.185l-.038.02A4.997 4.997 0 0 0 8 13.683a5 5 0 0 0 5 5 5 5 0 0 0 5-5 1 1 0 0 1 2 0A7 7 0 1 1 9.722 7.496l-.842-.21a.999.999 0 1 1 .484-1.94l3.23.806c.535.133.86.675.73 1.21l-.804 3.233a.997.997 0 0 1-1.21.73.997.997 0 0 1-.73-1.21l.23-.928v-.002z\" fill=\"currentColor\" fill-rule=\"nonzero\"/></svg>',\n      Type.STRING\n    ],\n\n    iconUndo: [\n      '<svg width=\"26\" height=\"26\" viewBox=\"0 0 26 26\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M9.185 10.81l.02-.038A4.997 4.997 0 0 1 13.683 8a5 5 0 0 1 5 5 5 5 0 0 1-5 5 1 1 0 0 0 0 2A7 7 0 1 0 7.496 9.722l-.21-.842a.999.999 0 1 0-1.94.484l.806 3.23c.133.535.675.86 1.21.73l3.233-.803a.997.997 0 0 0 .73-1.21.997.997 0 0 0-1.21-.73l-.928.23-.002-.001z\" fill=\"currentColor\" fill-rule=\"nonzero\"/></svg>',\n      Type.STRING\n    ],\n\n    iconDone: [\n      '<svg width=\"26\" height=\"26\" viewBox=\"0 0 26 26\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M18.293 9.293a1 1 0 0 1 1.414 1.414l-7.002 7a1 1 0 0 1-1.414 0l-3.998-4a1 1 0 1 1 1.414-1.414L12 15.586l6.294-6.293z\" fill=\"currentColor\" fill-rule=\"nonzero\"/></svg>',\n      Type.STRING\n    ],\n\n    // event handlers\n    oninit: [null, Type.FUNCTION],\n    onwarning: [null, Type.FUNCTION],\n    onerror: [null, Type.FUNCTION],\n    onactivatefile: [null, Type.FUNCTION],\n    oninitfile: [null, Type.FUNCTION],\n    onaddfilestart: [null, Type.FUNCTION],\n    onaddfileprogress: [null, Type.FUNCTION],\n    onaddfile: [null, Type.FUNCTION],\n    onprocessfilestart: [null, Type.FUNCTION],\n    onprocessfileprogress: [null, Type.FUNCTION],\n    onprocessfileabort: [null, Type.FUNCTION],\n    onprocessfilerevert: [null, Type.FUNCTION],\n    onprocessfile: [null, Type.FUNCTION],\n    onprocessfiles: [null, Type.FUNCTION],\n    onremovefile: [null, Type.FUNCTION],\n    onpreparefile: [null, Type.FUNCTION],\n    onupdatefiles: [null, Type.FUNCTION],\n    onreorderfiles: [null, Type.FUNCTION],\n\n    // hooks\n    beforeDropFile: [null, Type.FUNCTION],\n    beforeAddFile: [null, Type.FUNCTION],\n    beforeRemoveFile: [null, Type.FUNCTION],\n    beforePrepareFile: [null, Type.FUNCTION],\n\n    // styles\n    stylePanelLayout: [null, Type.STRING], // null 'integrated', 'compact', 'circle'\n    stylePanelAspectRatio: [null, Type.STRING], // null or '3:2' or 1\n    styleItemPanelAspectRatio: [null, Type.STRING],\n    styleButtonRemoveItemPosition: ['left', Type.STRING],\n    styleButtonProcessItemPosition: ['right', Type.STRING],\n    styleLoadIndicatorPosition: ['right', Type.STRING],\n    styleProgressIndicatorPosition: ['right', Type.STRING],\n    styleButtonRemoveItemAlign: [false, Type.BOOLEAN],\n\n    // custom initial files array\n    files: [[], Type.ARRAY],\n\n    // show support by displaying credits\n    credits: [['https://pqina.nl/', 'Powered by PQINA'], Type.ARRAY]\n  };\n\n  var getItemByQuery = function getItemByQuery(items, query) {\n    // just return first index\n    if (isEmpty(query)) {\n      return items[0] || null;\n    }\n\n    // query is index\n    if (isInt(query)) {\n      return items[query] || null;\n    }\n\n    // if query is item, get the id\n    if (typeof query === 'object') {\n      query = query.id;\n    }\n\n    // assume query is a string and return item by id\n    return (\n      items.find(function(item) {\n        return item.id === query;\n      }) || null\n    );\n  };\n\n  var getNumericAspectRatioFromString = function getNumericAspectRatioFromString(\n    aspectRatio\n  ) {\n    if (isEmpty(aspectRatio)) {\n      return aspectRatio;\n    }\n    if (/:/.test(aspectRatio)) {\n      var parts = aspectRatio.split(':');\n      return parts[1] / parts[0];\n    }\n    return parseFloat(aspectRatio);\n  };\n\n  var getActiveItems = function getActiveItems(items) {\n    return items.filter(function(item) {\n      return !item.archived;\n    });\n  };\n\n  var Status = {\n    EMPTY: 0,\n    IDLE: 1, // waiting\n    ERROR: 2, // a file is in error state\n    BUSY: 3, // busy processing or loading\n    READY: 4 // all files uploaded\n  };\n\n  var ITEM_ERROR = [\n    ItemStatus.LOAD_ERROR,\n    ItemStatus.PROCESSING_ERROR,\n    ItemStatus.PROCESSING_REVERT_ERROR\n  ];\n  var ITEM_BUSY = [\n    ItemStatus.LOADING,\n    ItemStatus.PROCESSING,\n    ItemStatus.PROCESSING_QUEUED,\n    ItemStatus.INIT\n  ];\n  var ITEM_READY = [ItemStatus.PROCESSING_COMPLETE];\n\n  var isItemInErrorState = function isItemInErrorState(item) {\n    return ITEM_ERROR.includes(item.status);\n  };\n  var isItemInBusyState = function isItemInBusyState(item) {\n    return ITEM_BUSY.includes(item.status);\n  };\n  var isItemInReadyState = function isItemInReadyState(item) {\n    return ITEM_READY.includes(item.status);\n  };\n\n  var queries = function queries(state) {\n    return {\n      GET_STATUS: function GET_STATUS() {\n        var items = getActiveItems(state.items);\n        var EMPTY = Status.EMPTY,\n          ERROR = Status.ERROR,\n          BUSY = Status.BUSY,\n          IDLE = Status.IDLE,\n          READY = Status.READY;\n\n        if (items.length === 0) return EMPTY;\n\n        if (items.some(isItemInErrorState)) return ERROR;\n\n        if (items.some(isItemInBusyState)) return BUSY;\n\n        if (items.some(isItemInReadyState)) return READY;\n\n        return IDLE;\n      },\n\n      GET_ITEM: function GET_ITEM(query) {\n        return getItemByQuery(state.items, query);\n      },\n\n      GET_ACTIVE_ITEM: function GET_ACTIVE_ITEM(query) {\n        return getItemByQuery(getActiveItems(state.items), query);\n      },\n\n      GET_ACTIVE_ITEMS: function GET_ACTIVE_ITEMS() {\n        return getActiveItems(state.items);\n      },\n\n      GET_ITEMS: function GET_ITEMS() {\n        return state.items;\n      },\n\n      GET_ITEM_NAME: function GET_ITEM_NAME(query) {\n        var item = getItemByQuery(state.items, query);\n        return item ? item.filename : null;\n      },\n\n      GET_ITEM_SIZE: function GET_ITEM_SIZE(query) {\n        var item = getItemByQuery(state.items, query);\n        return item ? item.fileSize : null;\n      },\n\n      GET_STYLES: function GET_STYLES() {\n        return Object.keys(state.options)\n          .filter(function(key) {\n            return /^style/.test(key);\n          })\n          .map(function(option) {\n            return {\n              name: option,\n              value: state.options[option]\n            };\n          });\n      },\n\n      GET_PANEL_ASPECT_RATIO: function GET_PANEL_ASPECT_RATIO() {\n        var isShapeCircle = /circle/.test(state.options.stylePanelLayout);\n        var aspectRatio = isShapeCircle\n          ? 1\n          : getNumericAspectRatioFromString(\n              state.options.stylePanelAspectRatio\n            );\n        return aspectRatio;\n      },\n\n      GET_ITEM_PANEL_ASPECT_RATIO: function GET_ITEM_PANEL_ASPECT_RATIO() {\n        return state.options.styleItemPanelAspectRatio;\n      },\n\n      GET_ITEMS_BY_STATUS: function GET_ITEMS_BY_STATUS(status) {\n        return getActiveItems(state.items).filter(function(item) {\n          return item.status === status;\n        });\n      },\n\n      GET_TOTAL_ITEMS: function GET_TOTAL_ITEMS() {\n        return getActiveItems(state.items).length;\n      },\n\n      IS_ASYNC: function IS_ASYNC() {\n        return (\n          isObject(state.options.server) &&\n          (isObject(state.options.server.process) ||\n            isFunction(state.options.server.process))\n        );\n      }\n    };\n  };\n\n  var hasRoomForItem = function hasRoomForItem(state) {\n    var count = getActiveItems(state.items).length;\n\n    // if cannot have multiple items, to add one item it should currently not contain items\n    if (!state.options.allowMultiple) {\n      return count === 0;\n    }\n\n    // if allows multiple items, we check if a max item count has been set, if not, there's no limit\n    var maxFileCount = state.options.maxFiles;\n    if (maxFileCount === null) {\n      return true;\n    }\n\n    // we check if the current count is smaller than the max count, if so, another file can still be added\n    if (count < maxFileCount) {\n      return true;\n    }\n\n    // no more room for another file\n    return false;\n  };\n\n  var limit = function limit(value, min, max) {\n    return Math.max(Math.min(max, value), min);\n  };\n\n  var arrayInsert = function arrayInsert(arr, index, item) {\n    return arr.splice(index, 0, item);\n  };\n\n  var insertItem = function insertItem(items, item, index) {\n    if (isEmpty(item)) {\n      return null;\n    }\n\n    // if index is undefined, append\n    if (typeof index === 'undefined') {\n      items.push(item);\n      return item;\n    }\n\n    // limit the index to the size of the items array\n    index = limit(index, 0, items.length);\n\n    // add item to array\n    arrayInsert(items, index, item);\n\n    // expose\n    return item;\n  };\n\n  var isBase64DataURI = function isBase64DataURI(str) {\n    return /^\\s*data:([a-z]+\\/[a-z0-9-+.]+(;[a-z-]+=[a-z0-9-]+)?)?(;base64)?,([a-z0-9!$&',()*+;=\\-._~:@\\/?%\\s]*)\\s*$/i.test(\n      str\n    );\n  };\n\n  var getFilenameFromURL = function getFilenameFromURL(url) {\n    return url\n      .split('/')\n      .pop()\n      .split('?')\n      .shift();\n  };\n\n  var getExtensionFromFilename = function getExtensionFromFilename(name) {\n    return name.split('.').pop();\n  };\n\n  var guesstimateExtension = function guesstimateExtension(type) {\n    // if no extension supplied, exit here\n    if (typeof type !== 'string') {\n      return '';\n    }\n\n    // get subtype\n    var subtype = type.split('/').pop();\n\n    // is svg subtype\n    if (/svg/.test(subtype)) {\n      return 'svg';\n    }\n\n    if (/zip|compressed/.test(subtype)) {\n      return 'zip';\n    }\n\n    if (/plain/.test(subtype)) {\n      return 'txt';\n    }\n\n    if (/msword/.test(subtype)) {\n      return 'doc';\n    }\n\n    // if is valid subtype\n    if (/[a-z]+/.test(subtype)) {\n      // always use jpg extension\n      if (subtype === 'jpeg') {\n        return 'jpg';\n      }\n\n      // return subtype\n      return subtype;\n    }\n\n    return '';\n  };\n\n  var leftPad = function leftPad(value) {\n    var padding =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n    return (padding + value).slice(-padding.length);\n  };\n\n  var getDateString = function getDateString() {\n    var date =\n      arguments.length > 0 && arguments[0] !== undefined\n        ? arguments[0]\n        : new Date();\n    return (\n      date.getFullYear() +\n      '-' +\n      leftPad(date.getMonth() + 1, '00') +\n      '-' +\n      leftPad(date.getDate(), '00') +\n      '_' +\n      leftPad(date.getHours(), '00') +\n      '-' +\n      leftPad(date.getMinutes(), '00') +\n      '-' +\n      leftPad(date.getSeconds(), '00')\n    );\n  };\n\n  var getFileFromBlob = function getFileFromBlob(blob, filename) {\n    var type =\n      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n    var extension =\n      arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n    var file =\n      typeof type === 'string'\n        ? blob.slice(0, blob.size, type)\n        : blob.slice(0, blob.size, blob.type);\n    file.lastModifiedDate = new Date();\n\n    // copy relative path\n    if (blob._relativePath) file._relativePath = blob._relativePath;\n\n    // if blob has name property, use as filename if no filename supplied\n    if (!isString(filename)) {\n      filename = getDateString();\n    }\n\n    // if filename supplied but no extension and filename has extension\n    if (filename && extension === null && getExtensionFromFilename(filename)) {\n      file.name = filename;\n    } else {\n      extension = extension || guesstimateExtension(file.type);\n      file.name = filename + (extension ? '.' + extension : '');\n    }\n\n    return file;\n  };\n\n  var getBlobBuilder = function getBlobBuilder() {\n    return (window.BlobBuilder =\n      window.BlobBuilder ||\n      window.WebKitBlobBuilder ||\n      window.MozBlobBuilder ||\n      window.MSBlobBuilder);\n  };\n\n  var createBlob = function createBlob(arrayBuffer, mimeType) {\n    var BB = getBlobBuilder();\n\n    if (BB) {\n      var bb = new BB();\n      bb.append(arrayBuffer);\n      return bb.getBlob(mimeType);\n    }\n\n    return new Blob([arrayBuffer], {\n      type: mimeType\n    });\n  };\n\n  var getBlobFromByteStringWithMimeType = function getBlobFromByteStringWithMimeType(\n    byteString,\n    mimeType\n  ) {\n    var ab = new ArrayBuffer(byteString.length);\n    var ia = new Uint8Array(ab);\n\n    for (var i = 0; i < byteString.length; i++) {\n      ia[i] = byteString.charCodeAt(i);\n    }\n\n    return createBlob(ab, mimeType);\n  };\n\n  var getMimeTypeFromBase64DataURI = function getMimeTypeFromBase64DataURI(\n    dataURI\n  ) {\n    return (/^data:(.+);/.exec(dataURI) || [])[1] || null;\n  };\n\n  var getBase64DataFromBase64DataURI = function getBase64DataFromBase64DataURI(\n    dataURI\n  ) {\n    // get data part of string (remove data:image/jpeg...,)\n    var data = dataURI.split(',')[1];\n\n    // remove any whitespace as that causes InvalidCharacterError in IE\n    return data.replace(/\\s/g, '');\n  };\n\n  var getByteStringFromBase64DataURI = function getByteStringFromBase64DataURI(\n    dataURI\n  ) {\n    return atob(getBase64DataFromBase64DataURI(dataURI));\n  };\n\n  var getBlobFromBase64DataURI = function getBlobFromBase64DataURI(dataURI) {\n    var mimeType = getMimeTypeFromBase64DataURI(dataURI);\n    var byteString = getByteStringFromBase64DataURI(dataURI);\n\n    return getBlobFromByteStringWithMimeType(byteString, mimeType);\n  };\n\n  var getFileFromBase64DataURI = function getFileFromBase64DataURI(\n    dataURI,\n    filename,\n    extension\n  ) {\n    return getFileFromBlob(\n      getBlobFromBase64DataURI(dataURI),\n      filename,\n      null,\n      extension\n    );\n  };\n\n  var getFileNameFromHeader = function getFileNameFromHeader(header) {\n    // test if is content disposition header, if not exit\n    if (!/^content-disposition:/i.test(header)) return null;\n\n    // get filename parts\n    var matches = header\n      .split(/filename=|filename\\*=.+''/)\n      .splice(1)\n      .map(function(name) {\n        return name.trim().replace(/^[\"']|[;\"']{0,2}$/g, '');\n      })\n      .filter(function(name) {\n        return name.length;\n      });\n\n    return matches.length ? decodeURI(matches[matches.length - 1]) : null;\n  };\n\n  var getFileSizeFromHeader = function getFileSizeFromHeader(header) {\n    if (/content-length:/i.test(header)) {\n      var size = header.match(/[0-9]+/)[0];\n      return size ? parseInt(size, 10) : null;\n    }\n    return null;\n  };\n\n  var getTranfserIdFromHeader = function getTranfserIdFromHeader(header) {\n    if (/x-content-transfer-id:/i.test(header)) {\n      var id = (header.split(':')[1] || '').trim();\n      return id || null;\n    }\n    return null;\n  };\n\n  var getFileInfoFromHeaders = function getFileInfoFromHeaders(headers) {\n    var info = {\n      source: null,\n      name: null,\n      size: null\n    };\n\n    var rows = headers.split('\\n');\n    var _iteratorNormalCompletion = true;\n    var _didIteratorError = false;\n    var _iteratorError = undefined;\n    try {\n      for (\n        var _iterator = rows[Symbol.iterator](), _step;\n        !(_iteratorNormalCompletion = (_step = _iterator.next()).done);\n        _iteratorNormalCompletion = true\n      ) {\n        var header = _step.value;\n\n        var name = getFileNameFromHeader(header);\n        if (name) {\n          info.name = name;\n          continue;\n        }\n\n        var size = getFileSizeFromHeader(header);\n        if (size) {\n          info.size = size;\n          continue;\n        }\n\n        var source = getTranfserIdFromHeader(header);\n        if (source) {\n          info.source = source;\n          continue;\n        }\n      }\n    } catch (err) {\n      _didIteratorError = true;\n      _iteratorError = err;\n    } finally {\n      try {\n        if (!_iteratorNormalCompletion && _iterator.return != null) {\n          _iterator.return();\n        }\n      } finally {\n        if (_didIteratorError) {\n          throw _iteratorError;\n        }\n      }\n    }\n\n    return info;\n  };\n\n  var createFileLoader = function createFileLoader(fetchFn) {\n    var state = {\n      source: null,\n      complete: false,\n      progress: 0,\n      size: null,\n      timestamp: null,\n      duration: 0,\n      request: null\n    };\n\n    var getProgress = function getProgress() {\n      return state.progress;\n    };\n    var abort = function abort() {\n      if (state.request && state.request.abort) {\n        state.request.abort();\n      }\n    };\n\n    // load source\n    var load = function load() {\n      // get quick reference\n      var source = state.source;\n\n      api.fire('init', source);\n\n      // Load Files\n      if (source instanceof File) {\n        api.fire('load', source);\n      } else if (source instanceof Blob) {\n        // Load blobs, set default name to current date\n        api.fire('load', getFileFromBlob(source, source.name));\n      } else if (isBase64DataURI(source)) {\n        // Load base 64, set default name to current date\n        api.fire('load', getFileFromBase64DataURI(source));\n      } else {\n        // Deal as if is external URL, let's load it!\n        loadURL(source);\n      }\n    };\n\n    // loads a url\n    var loadURL = function loadURL(url) {\n      // is remote url and no fetch method supplied\n      if (!fetchFn) {\n        api.fire('error', {\n          type: 'error',\n          body: \"Can't load URL\",\n          code: 400\n        });\n\n        return;\n      }\n\n      // set request start\n      state.timestamp = Date.now();\n\n      // load file\n      state.request = fetchFn(\n        url,\n        function(response) {\n          // update duration\n          state.duration = Date.now() - state.timestamp;\n\n          // done!\n          state.complete = true;\n\n          // turn blob response into a file\n          if (response instanceof Blob) {\n            response = getFileFromBlob(\n              response,\n              response.name || getFilenameFromURL(url)\n            );\n          }\n\n          api.fire(\n            'load',\n            // if has received blob, we go with blob, if no response, we return null\n            response instanceof Blob\n              ? response\n              : response\n              ? response.body\n              : null\n          );\n        },\n        function(error) {\n          api.fire(\n            'error',\n            typeof error === 'string'\n              ? {\n                  type: 'error',\n                  code: 0,\n                  body: error\n                }\n              : error\n          );\n        },\n        function(computable, current, total) {\n          // collected some meta data already\n          if (total) {\n            state.size = total;\n          }\n\n          // update duration\n          state.duration = Date.now() - state.timestamp;\n\n          // if we can't compute progress, we're not going to fire progress events\n          if (!computable) {\n            state.progress = null;\n            return;\n          }\n\n          // update progress percentage\n          state.progress = current / total;\n\n          // expose\n          api.fire('progress', state.progress);\n        },\n        function() {\n          api.fire('abort');\n        },\n        function(response) {\n          var fileinfo = getFileInfoFromHeaders(\n            typeof response === 'string' ? response : response.headers\n          );\n          api.fire('meta', {\n            size: state.size || fileinfo.size,\n            filename: fileinfo.name,\n            source: fileinfo.source\n          });\n        }\n      );\n    };\n\n    var api = Object.assign({}, on(), {\n      setSource: function setSource(source) {\n        return (state.source = source);\n      },\n      getProgress: getProgress, // file load progress\n      abort: abort, // abort file load\n      load: load // start load\n    });\n\n    return api;\n  };\n\n  var isGet = function isGet(method) {\n    return /GET|HEAD/.test(method);\n  };\n\n  var sendRequest = function sendRequest(data, url, options) {\n    var api = {\n      onheaders: function onheaders() {},\n      onprogress: function onprogress() {},\n      onload: function onload() {},\n      ontimeout: function ontimeout() {},\n      onerror: function onerror() {},\n      onabort: function onabort() {},\n      abort: function abort() {\n        aborted = true;\n        xhr.abort();\n      }\n    };\n\n    // timeout identifier, only used when timeout is defined\n    var aborted = false;\n    var headersReceived = false;\n\n    // set default options\n    options = Object.assign(\n      {\n        method: 'POST',\n        headers: {},\n        withCredentials: false\n      },\n      options\n    );\n\n    // encode url\n    url = encodeURI(url);\n\n    // if method is GET, add any received data to url\n\n    if (isGet(options.method) && data) {\n      url =\n        '' +\n        url +\n        encodeURIComponent(\n          typeof data === 'string' ? data : JSON.stringify(data)\n        );\n    }\n\n    // create request\n    var xhr = new XMLHttpRequest();\n\n    // progress of load\n    var process = isGet(options.method) ? xhr : xhr.upload;\n    process.onprogress = function(e) {\n      // no progress event when aborted ( onprogress is called once after abort() )\n      if (aborted) {\n        return;\n      }\n\n      api.onprogress(e.lengthComputable, e.loaded, e.total);\n    };\n\n    // tries to get header info to the app as fast as possible\n    xhr.onreadystatechange = function() {\n      // not interesting in these states ('unsent' and 'openend' as they don't give us any additional info)\n      if (xhr.readyState < 2) {\n        return;\n      }\n\n      // no server response\n      if (xhr.readyState === 4 && xhr.status === 0) {\n        return;\n      }\n\n      if (headersReceived) {\n        return;\n      }\n\n      headersReceived = true;\n\n      // we've probably received some useful data in response headers\n      api.onheaders(xhr);\n    };\n\n    // load successful\n    xhr.onload = function() {\n      // is classified as valid response\n      if (xhr.status >= 200 && xhr.status < 300) {\n        api.onload(xhr);\n      } else {\n        api.onerror(xhr);\n      }\n    };\n\n    // error during load\n    xhr.onerror = function() {\n      return api.onerror(xhr);\n    };\n\n    // request aborted\n    xhr.onabort = function() {\n      aborted = true;\n      api.onabort();\n    };\n\n    // request timeout\n    xhr.ontimeout = function() {\n      return api.ontimeout(xhr);\n    };\n\n    // open up open up!\n    xhr.open(options.method, url, true);\n\n    // set timeout if defined (do it after open so IE11 plays ball)\n    if (isInt(options.timeout)) {\n      xhr.timeout = options.timeout;\n    }\n\n    // add headers\n    Object.keys(options.headers).forEach(function(key) {\n      var value = unescape(encodeURIComponent(options.headers[key]));\n      xhr.setRequestHeader(key, value);\n    });\n\n    // set type of response\n    if (options.responseType) {\n      xhr.responseType = options.responseType;\n    }\n\n    // set credentials\n    if (options.withCredentials) {\n      xhr.withCredentials = true;\n    }\n\n    // let's send our data\n    xhr.send(data);\n\n    return api;\n  };\n\n  var createResponse = function createResponse(type, code, body, headers) {\n    return {\n      type: type,\n      code: code,\n      body: body,\n      headers: headers\n    };\n  };\n\n  var createTimeoutResponse = function createTimeoutResponse(cb) {\n    return function(xhr) {\n      cb(createResponse('error', 0, 'Timeout', xhr.getAllResponseHeaders()));\n    };\n  };\n\n  var hasQS = function hasQS(str) {\n    return /\\?/.test(str);\n  };\n  var buildURL = function buildURL() {\n    var url = '';\n    for (\n      var _len = arguments.length, parts = new Array(_len), _key = 0;\n      _key < _len;\n      _key++\n    ) {\n      parts[_key] = arguments[_key];\n    }\n    parts.forEach(function(part) {\n      url += hasQS(url) && hasQS(part) ? part.replace(/\\?/, '&') : part;\n    });\n    return url;\n  };\n\n  var createFetchFunction = function createFetchFunction() {\n    var apiUrl =\n      arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n    var action = arguments.length > 1 ? arguments[1] : undefined;\n    // custom handler (should also handle file, load, error, progress and abort)\n    if (typeof action === 'function') {\n      return action;\n    }\n\n    // no action supplied\n    if (!action || !isString(action.url)) {\n      return null;\n    }\n\n    // set onload hanlder\n    var onload =\n      action.onload ||\n      function(res) {\n        return res;\n      };\n    var onerror =\n      action.onerror ||\n      function(res) {\n        return null;\n      };\n\n    // internal handler\n    return function(url, load, error, progress, abort, headers) {\n      // do local or remote request based on if the url is external\n      var request = sendRequest(\n        url,\n        buildURL(apiUrl, action.url),\n        Object.assign({}, action, {\n          responseType: 'blob'\n        })\n      );\n\n      request.onload = function(xhr) {\n        // get headers\n        var headers = xhr.getAllResponseHeaders();\n\n        // get filename\n        var filename =\n          getFileInfoFromHeaders(headers).name || getFilenameFromURL(url);\n\n        // create response\n        load(\n          createResponse(\n            'load',\n            xhr.status,\n            action.method === 'HEAD'\n              ? null\n              : getFileFromBlob(onload(xhr.response), filename),\n            headers\n          )\n        );\n      };\n\n      request.onerror = function(xhr) {\n        error(\n          createResponse(\n            'error',\n            xhr.status,\n            onerror(xhr.response) || xhr.statusText,\n            xhr.getAllResponseHeaders()\n          )\n        );\n      };\n\n      request.onheaders = function(xhr) {\n        headers(\n          createResponse(\n            'headers',\n            xhr.status,\n            null,\n            xhr.getAllResponseHeaders()\n          )\n        );\n      };\n\n      request.ontimeout = createTimeoutResponse(error);\n      request.onprogress = progress;\n      request.onabort = abort;\n\n      // should return request\n      return request;\n    };\n  };\n\n  var ChunkStatus = {\n    QUEUED: 0,\n    COMPLETE: 1,\n    PROCESSING: 2,\n    ERROR: 3,\n    WAITING: 4\n  };\n\n  /*\n                                                       function signature:\n                                                         (file, metadata, load, error, progress, abort, transfer, options) => {\n                                                           return {\n                                                           abort:() => {}\n                                                         }\n                                                       }\n                                                       */\n\n  // apiUrl, action, name, file, metadata, load, error, progress, abort, transfer, options\n  var processFileChunked = function processFileChunked(\n    apiUrl,\n    action,\n    name,\n    file,\n    metadata,\n    load,\n    error,\n    progress,\n    abort,\n    transfer,\n    options\n  ) {\n    // all chunks\n    var chunks = [];\n    var chunkTransferId = options.chunkTransferId,\n      chunkServer = options.chunkServer,\n      chunkSize = options.chunkSize,\n      chunkRetryDelays = options.chunkRetryDelays;\n\n    // default state\n    var state = {\n      serverId: chunkTransferId,\n      aborted: false\n    };\n\n    // set onload handlers\n    var ondata =\n      action.ondata ||\n      function(fd) {\n        return fd;\n      };\n    var onload =\n      action.onload ||\n      function(xhr, method) {\n        return method === 'HEAD'\n          ? xhr.getResponseHeader('Upload-Offset')\n          : xhr.response;\n      };\n    var onerror =\n      action.onerror ||\n      function(res) {\n        return null;\n      };\n\n    // create server hook\n    var requestTransferId = function requestTransferId(cb) {\n      var formData = new FormData();\n\n      // add metadata under same name\n      if (isObject(metadata)) formData.append(name, JSON.stringify(metadata));\n\n      var headers =\n        typeof action.headers === 'function'\n          ? action.headers(file, metadata)\n          : Object.assign({}, action.headers, {\n              'Upload-Length': file.size\n            });\n\n      var requestParams = Object.assign({}, action, {\n        headers: headers\n      });\n\n      // send request object\n      var request = sendRequest(\n        ondata(formData),\n        buildURL(apiUrl, action.url),\n        requestParams\n      );\n\n      request.onload = function(xhr) {\n        return cb(onload(xhr, requestParams.method));\n      };\n\n      request.onerror = function(xhr) {\n        return error(\n          createResponse(\n            'error',\n            xhr.status,\n            onerror(xhr.response) || xhr.statusText,\n            xhr.getAllResponseHeaders()\n          )\n        );\n      };\n\n      request.ontimeout = createTimeoutResponse(error);\n    };\n\n    var requestTransferOffset = function requestTransferOffset(cb) {\n      var requestUrl = buildURL(apiUrl, chunkServer.url, state.serverId);\n\n      var headers =\n        typeof action.headers === 'function'\n          ? action.headers(state.serverId)\n          : Object.assign({}, action.headers);\n\n      var requestParams = {\n        headers: headers,\n        method: 'HEAD'\n      };\n\n      var request = sendRequest(null, requestUrl, requestParams);\n\n      request.onload = function(xhr) {\n        return cb(onload(xhr, requestParams.method));\n      };\n\n      request.onerror = function(xhr) {\n        return error(\n          createResponse(\n            'error',\n            xhr.status,\n            onerror(xhr.response) || xhr.statusText,\n            xhr.getAllResponseHeaders()\n          )\n        );\n      };\n\n      request.ontimeout = createTimeoutResponse(error);\n    };\n\n    // create chunks\n    var lastChunkIndex = Math.floor(file.size / chunkSize);\n    for (var i = 0; i <= lastChunkIndex; i++) {\n      var offset = i * chunkSize;\n      var data = file.slice(\n        offset,\n        offset + chunkSize,\n        'application/offset+octet-stream'\n      );\n      chunks[i] = {\n        index: i,\n        size: data.size,\n        offset: offset,\n        data: data,\n        file: file,\n        progress: 0,\n        retries: _toConsumableArray(chunkRetryDelays),\n        status: ChunkStatus.QUEUED,\n        error: null,\n        request: null,\n        timeout: null\n      };\n    }\n\n    var completeProcessingChunks = function completeProcessingChunks() {\n      return load(state.serverId);\n    };\n\n    var canProcessChunk = function canProcessChunk(chunk) {\n      return (\n        chunk.status === ChunkStatus.QUEUED ||\n        chunk.status === ChunkStatus.ERROR\n      );\n    };\n\n    var processChunk = function processChunk(chunk) {\n      // processing is paused, wait here\n      if (state.aborted) return;\n\n      // get next chunk to process\n      chunk = chunk || chunks.find(canProcessChunk);\n\n      // no more chunks to process\n      if (!chunk) {\n        // all done?\n        if (\n          chunks.every(function(chunk) {\n            return chunk.status === ChunkStatus.COMPLETE;\n          })\n        ) {\n          completeProcessingChunks();\n        }\n\n        // no chunk to handle\n        return;\n      }\n\n      // now processing this chunk\n      chunk.status = ChunkStatus.PROCESSING;\n      chunk.progress = null;\n\n      // allow parsing of formdata\n      var ondata =\n        chunkServer.ondata ||\n        function(fd) {\n          return fd;\n        };\n      var onerror =\n        chunkServer.onerror ||\n        function(res) {\n          return null;\n        };\n\n      // send request object\n      var requestUrl = buildURL(apiUrl, chunkServer.url, state.serverId);\n\n      var headers =\n        typeof chunkServer.headers === 'function'\n          ? chunkServer.headers(chunk)\n          : Object.assign({}, chunkServer.headers, {\n              'Content-Type': 'application/offset+octet-stream',\n              'Upload-Offset': chunk.offset,\n              'Upload-Length': file.size,\n              'Upload-Name': file.name\n            });\n\n      var request = (chunk.request = sendRequest(\n        ondata(chunk.data),\n        requestUrl,\n        Object.assign({}, chunkServer, {\n          headers: headers\n        })\n      ));\n\n      request.onload = function() {\n        // done!\n        chunk.status = ChunkStatus.COMPLETE;\n\n        // remove request reference\n        chunk.request = null;\n\n        // start processing more chunks\n        processChunks();\n      };\n\n      request.onprogress = function(lengthComputable, loaded, total) {\n        chunk.progress = lengthComputable ? loaded : null;\n        updateTotalProgress();\n      };\n\n      request.onerror = function(xhr) {\n        chunk.status = ChunkStatus.ERROR;\n        chunk.request = null;\n        chunk.error = onerror(xhr.response) || xhr.statusText;\n        if (!retryProcessChunk(chunk)) {\n          error(\n            createResponse(\n              'error',\n              xhr.status,\n              onerror(xhr.response) || xhr.statusText,\n              xhr.getAllResponseHeaders()\n            )\n          );\n        }\n      };\n\n      request.ontimeout = function(xhr) {\n        chunk.status = ChunkStatus.ERROR;\n        chunk.request = null;\n        if (!retryProcessChunk(chunk)) {\n          createTimeoutResponse(error)(xhr);\n        }\n      };\n\n      request.onabort = function() {\n        chunk.status = ChunkStatus.QUEUED;\n        chunk.request = null;\n        abort();\n      };\n    };\n\n    var retryProcessChunk = function retryProcessChunk(chunk) {\n      // no more retries left\n      if (chunk.retries.length === 0) return false;\n\n      // new retry\n      chunk.status = ChunkStatus.WAITING;\n      clearTimeout(chunk.timeout);\n      chunk.timeout = setTimeout(function() {\n        processChunk(chunk);\n      }, chunk.retries.shift());\n\n      // we're going to retry\n      return true;\n    };\n\n    var updateTotalProgress = function updateTotalProgress() {\n      // calculate total progress fraction\n      var totalBytesTransfered = chunks.reduce(function(p, chunk) {\n        if (p === null || chunk.progress === null) return null;\n        return p + chunk.progress;\n      }, 0);\n\n      // can't compute progress\n      if (totalBytesTransfered === null) return progress(false, 0, 0);\n\n      // calculate progress values\n      var totalSize = chunks.reduce(function(total, chunk) {\n        return total + chunk.size;\n      }, 0);\n\n      // can update progress indicator\n      progress(true, totalBytesTransfered, totalSize);\n    };\n\n    // process new chunks\n    var processChunks = function processChunks() {\n      var totalProcessing = chunks.filter(function(chunk) {\n        return chunk.status === ChunkStatus.PROCESSING;\n      }).length;\n      if (totalProcessing >= 1) return;\n      processChunk();\n    };\n\n    var abortChunks = function abortChunks() {\n      chunks.forEach(function(chunk) {\n        clearTimeout(chunk.timeout);\n        if (chunk.request) {\n          chunk.request.abort();\n        }\n      });\n    };\n\n    // let's go!\n    if (!state.serverId) {\n      requestTransferId(function(serverId) {\n        // stop here if aborted, might have happened in between request and callback\n        if (state.aborted) return;\n\n        // pass back to item so we can use it if something goes wrong\n        transfer(serverId);\n\n        // store internally\n        state.serverId = serverId;\n        processChunks();\n      });\n    } else {\n      requestTransferOffset(function(offset) {\n        // stop here if aborted, might have happened in between request and callback\n        if (state.aborted) return;\n\n        // mark chunks with lower offset as complete\n        chunks\n          .filter(function(chunk) {\n            return chunk.offset < offset;\n          })\n          .forEach(function(chunk) {\n            chunk.status = ChunkStatus.COMPLETE;\n            chunk.progress = chunk.size;\n          });\n\n        // continue processing\n        processChunks();\n      });\n    }\n\n    return {\n      abort: function abort() {\n        state.aborted = true;\n        abortChunks();\n      }\n    };\n  };\n\n  /*\n                                                               function signature:\n                                                                 (file, metadata, load, error, progress, abort) => {\n                                                                   return {\n                                                                   abort:() => {}\n                                                                 }\n                                                               }\n                                                               */\n  var createFileProcessorFunction = function createFileProcessorFunction(\n    apiUrl,\n    action,\n    name,\n    options\n  ) {\n    return function(file, metadata, load, error, progress, abort, transfer) {\n      // no file received\n      if (!file) return;\n\n      // if was passed a file, and we can chunk it, exit here\n      var canChunkUpload = options.chunkUploads;\n      var shouldChunkUpload = canChunkUpload && file.size > options.chunkSize;\n      var willChunkUpload =\n        canChunkUpload && (shouldChunkUpload || options.chunkForce);\n      if (file instanceof Blob && willChunkUpload)\n        return processFileChunked(\n          apiUrl,\n          action,\n          name,\n          file,\n          metadata,\n          load,\n          error,\n          progress,\n          abort,\n          transfer,\n          options\n        );\n\n      // set handlers\n      var ondata =\n        action.ondata ||\n        function(fd) {\n          return fd;\n        };\n      var onload =\n        action.onload ||\n        function(res) {\n          return res;\n        };\n      var onerror =\n        action.onerror ||\n        function(res) {\n          return null;\n        };\n\n      // create formdata object\n      var formData = new FormData();\n\n      // add metadata under same name\n      if (isObject(metadata)) {\n        formData.append(name, JSON.stringify(metadata));\n      }\n\n      // Turn into an array of objects so no matter what the input, we can handle it the same way\n      (file instanceof Blob ? [{ name: null, file: file }] : file).forEach(\n        function(item) {\n          formData.append(\n            name,\n            item.file,\n            item.name === null\n              ? item.file.name\n              : '' + item.name + item.file.name\n          );\n        }\n      );\n\n      // send request object\n      var request = sendRequest(\n        ondata(formData),\n        buildURL(apiUrl, action.url),\n        action\n      );\n      request.onload = function(xhr) {\n        load(\n          createResponse(\n            'load',\n            xhr.status,\n            onload(xhr.response),\n            xhr.getAllResponseHeaders()\n          )\n        );\n      };\n\n      request.onerror = function(xhr) {\n        error(\n          createResponse(\n            'error',\n            xhr.status,\n            onerror(xhr.response) || xhr.statusText,\n            xhr.getAllResponseHeaders()\n          )\n        );\n      };\n\n      request.ontimeout = createTimeoutResponse(error);\n      request.onprogress = progress;\n      request.onabort = abort;\n\n      // should return request\n      return request;\n    };\n  };\n\n  var createProcessorFunction = function createProcessorFunction() {\n    var apiUrl =\n      arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n    var action = arguments.length > 1 ? arguments[1] : undefined;\n    var name = arguments.length > 2 ? arguments[2] : undefined;\n    var options = arguments.length > 3 ? arguments[3] : undefined;\n\n    // custom handler (should also handle file, load, error, progress and abort)\n    if (typeof action === 'function')\n      return function() {\n        for (\n          var _len = arguments.length, params = new Array(_len), _key = 0;\n          _key < _len;\n          _key++\n        ) {\n          params[_key] = arguments[_key];\n        }\n        return action.apply(void 0, [name].concat(params, [options]));\n      };\n\n    // no action supplied\n    if (!action || !isString(action.url)) return null;\n\n    // internal handler\n    return createFileProcessorFunction(apiUrl, action, name, options);\n  };\n\n  /*\n                                                      function signature:\n                                                      (uniqueFileId, load, error) => { }\n                                                      */\n  var createRevertFunction = function createRevertFunction() {\n    var apiUrl =\n      arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n    var action = arguments.length > 1 ? arguments[1] : undefined;\n    // is custom implementation\n    if (typeof action === 'function') {\n      return action;\n    }\n\n    // no action supplied, return stub function, interface will work, but file won't be removed\n    if (!action || !isString(action.url)) {\n      return function(uniqueFileId, load) {\n        return load();\n      };\n    }\n\n    // set onload hanlder\n    var onload =\n      action.onload ||\n      function(res) {\n        return res;\n      };\n    var onerror =\n      action.onerror ||\n      function(res) {\n        return null;\n      };\n\n    // internal implementation\n    return function(uniqueFileId, load, error) {\n      var request = sendRequest(\n        uniqueFileId,\n        apiUrl + action.url,\n        action // contains method, headers and withCredentials properties\n      );\n      request.onload = function(xhr) {\n        load(\n          createResponse(\n            'load',\n            xhr.status,\n            onload(xhr.response),\n            xhr.getAllResponseHeaders()\n          )\n        );\n      };\n\n      request.onerror = function(xhr) {\n        error(\n          createResponse(\n            'error',\n            xhr.status,\n            onerror(xhr.response) || xhr.statusText,\n            xhr.getAllResponseHeaders()\n          )\n        );\n      };\n\n      request.ontimeout = createTimeoutResponse(error);\n\n      return request;\n    };\n  };\n\n  var getRandomNumber = function getRandomNumber() {\n    var min =\n      arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n    var max =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;\n    return min + Math.random() * (max - min);\n  };\n\n  var createPerceivedPerformanceUpdater = function createPerceivedPerformanceUpdater(\n    cb\n  ) {\n    var duration =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;\n    var offset =\n      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n    var tickMin =\n      arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 25;\n    var tickMax =\n      arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 250;\n    var timeout = null;\n    var start = Date.now();\n\n    var tick = function tick() {\n      var runtime = Date.now() - start;\n      var delay = getRandomNumber(tickMin, tickMax);\n\n      if (runtime + delay > duration) {\n        delay = runtime + delay - duration;\n      }\n\n      var progress = runtime / duration;\n      if (progress >= 1 || document.hidden) {\n        cb(1);\n        return;\n      }\n\n      cb(progress);\n\n      timeout = setTimeout(tick, delay);\n    };\n\n    tick();\n\n    return {\n      clear: function clear() {\n        clearTimeout(timeout);\n      }\n    };\n  };\n\n  var createFileProcessor = function createFileProcessor(processFn) {\n    var state = {\n      complete: false,\n      perceivedProgress: 0,\n      perceivedPerformanceUpdater: null,\n      progress: null,\n      timestamp: null,\n      perceivedDuration: 0,\n      duration: 0,\n      request: null,\n      response: null\n    };\n\n    var process = function process(file, metadata) {\n      var progressFn = function progressFn() {\n        // we've not yet started the real download, stop here\n        // the request might not go through, for instance, there might be some server trouble\n        // if state.progress is null, the server does not allow computing progress and we show the spinner instead\n        if (state.duration === 0 || state.progress === null) return;\n\n        // as we're now processing, fire the progress event\n        api.fire('progress', api.getProgress());\n      };\n\n      var completeFn = function completeFn() {\n        state.complete = true;\n        api.fire('load-perceived', state.response.body);\n      };\n\n      // let's start processing\n      api.fire('start');\n\n      // set request start\n      state.timestamp = Date.now();\n\n      // create perceived performance progress indicator\n      state.perceivedPerformanceUpdater = createPerceivedPerformanceUpdater(\n        function(progress) {\n          state.perceivedProgress = progress;\n          state.perceivedDuration = Date.now() - state.timestamp;\n\n          progressFn();\n\n          // if fake progress is done, and a response has been received,\n          // and we've not yet called the complete method\n          if (\n            state.response &&\n            state.perceivedProgress === 1 &&\n            !state.complete\n          ) {\n            // we done!\n            completeFn();\n          }\n        },\n        // random delay as in a list of files you start noticing\n        // files uploading at the exact same speed\n        getRandomNumber(750, 1500)\n      );\n\n      // remember request so we can abort it later\n      state.request = processFn(\n        // the file to process\n        file,\n\n        // the metadata to send along\n        metadata,\n\n        // callbacks (load, error, progress, abort, transfer)\n        // load expects the body to be a server id if\n        // you want to make use of revert\n        function(response) {\n          // we put the response in state so we can access\n          // it outside of this method\n          state.response = isObject(response)\n            ? response\n            : {\n                type: 'load',\n                code: 200,\n                body: '' + response,\n                headers: {}\n              };\n\n          // update duration\n          state.duration = Date.now() - state.timestamp;\n\n          // force progress to 1 as we're now done\n          state.progress = 1;\n\n          // actual load is done let's share results\n          api.fire('load', state.response.body);\n\n          // we are really done\n          // if perceived progress is 1 ( wait for perceived progress to complete )\n          // or if server does not support progress ( null )\n          if (state.perceivedProgress === 1) {\n            completeFn();\n          }\n        },\n\n        // error is expected to be an object with type, code, body\n        function(error) {\n          // cancel updater\n          state.perceivedPerformanceUpdater.clear();\n\n          // update others about this error\n          api.fire(\n            'error',\n            isObject(error)\n              ? error\n              : {\n                  type: 'error',\n                  code: 0,\n                  body: '' + error\n                }\n          );\n        },\n\n        // actual processing progress\n        function(computable, current, total) {\n          // update actual duration\n          state.duration = Date.now() - state.timestamp;\n\n          // update actual progress\n          state.progress = computable ? current / total : null;\n\n          progressFn();\n        },\n\n        // abort does not expect a value\n        function() {\n          // stop updater\n          state.perceivedPerformanceUpdater.clear();\n\n          // fire the abort event so we can switch visuals\n          api.fire('abort', state.response ? state.response.body : null);\n        },\n\n        // register the id for this transfer\n        function(transferId) {\n          api.fire('transfer', transferId);\n        }\n      );\n    };\n\n    var abort = function abort() {\n      // no request running, can't abort\n      if (!state.request) return;\n\n      // stop updater\n      state.perceivedPerformanceUpdater.clear();\n\n      // abort actual request\n      if (state.request.abort) state.request.abort();\n\n      // if has response object, we've completed the request\n      state.complete = true;\n    };\n\n    var reset = function reset() {\n      abort();\n      state.complete = false;\n      state.perceivedProgress = 0;\n      state.progress = 0;\n      state.timestamp = null;\n      state.perceivedDuration = 0;\n      state.duration = 0;\n      state.request = null;\n      state.response = null;\n    };\n\n    var getProgress = function getProgress() {\n      return state.progress\n        ? Math.min(state.progress, state.perceivedProgress)\n        : null;\n    };\n    var getDuration = function getDuration() {\n      return Math.min(state.duration, state.perceivedDuration);\n    };\n\n    var api = Object.assign({}, on(), {\n      process: process, // start processing file\n      abort: abort, // abort active process request\n      getProgress: getProgress,\n      getDuration: getDuration,\n      reset: reset\n    });\n\n    return api;\n  };\n\n  var getFilenameWithoutExtension = function getFilenameWithoutExtension(name) {\n    return name.substr(0, name.lastIndexOf('.')) || name;\n  };\n\n  var createFileStub = function createFileStub(source) {\n    var data = [source.name, source.size, source.type];\n\n    // is blob or base64, then we need to set the name\n    if (source instanceof Blob || isBase64DataURI(source)) {\n      data[0] = source.name || getDateString();\n    } else if (isBase64DataURI(source)) {\n      // if is base64 data uri we need to determine the average size and type\n      data[1] = source.length;\n      data[2] = getMimeTypeFromBase64DataURI(source);\n    } else if (isString(source)) {\n      // url\n      data[0] = getFilenameFromURL(source);\n      data[1] = 0;\n      data[2] = 'application/octet-stream';\n    }\n\n    return {\n      name: data[0],\n      size: data[1],\n      type: data[2]\n    };\n  };\n\n  var isFile = function isFile(value) {\n    return !!(value instanceof File || (value instanceof Blob && value.name));\n  };\n\n  var deepCloneObject = function deepCloneObject(src) {\n    if (!isObject(src)) return src;\n    var target = isArray(src) ? [] : {};\n    for (var key in src) {\n      if (!src.hasOwnProperty(key)) continue;\n      var v = src[key];\n      target[key] = v && isObject(v) ? deepCloneObject(v) : v;\n    }\n    return target;\n  };\n\n  var createItem = function createItem() {\n    var origin =\n      arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n    var serverFileReference =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n    var file =\n      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n    // unique id for this item, is used to identify the item across views\n    var id = getUniqueId();\n\n    /**\n     * Internal item state\n     */\n    var state = {\n      // is archived\n      archived: false,\n\n      // if is frozen, no longer fires events\n      frozen: false,\n\n      // removed from view\n      released: false,\n\n      // original source\n      source: null,\n\n      // file model reference\n      file: file,\n\n      // id of file on server\n      serverFileReference: serverFileReference,\n\n      // id of file transfer on server\n      transferId: null,\n\n      // is aborted\n      processingAborted: false,\n\n      // current item status\n      status: serverFileReference\n        ? ItemStatus.PROCESSING_COMPLETE\n        : ItemStatus.INIT,\n\n      // active processes\n      activeLoader: null,\n      activeProcessor: null\n    };\n\n    // callback used when abort processing is called to link back to the resolve method\n    var abortProcessingRequestComplete = null;\n\n    /**\n     * Externally added item metadata\n     */\n    var metadata = {};\n\n    // item data\n    var setStatus = function setStatus(status) {\n      return (state.status = status);\n    };\n\n    // fire event unless the item has been archived\n    var fire = function fire(event) {\n      if (state.released || state.frozen) return;\n      for (\n        var _len = arguments.length,\n          params = new Array(_len > 1 ? _len - 1 : 0),\n          _key = 1;\n        _key < _len;\n        _key++\n      ) {\n        params[_key - 1] = arguments[_key];\n      }\n      api.fire.apply(api, [event].concat(params));\n    };\n\n    // file data\n    var getFileExtension = function getFileExtension() {\n      return getExtensionFromFilename(state.file.name);\n    };\n    var getFileType = function getFileType() {\n      return state.file.type;\n    };\n    var getFileSize = function getFileSize() {\n      return state.file.size;\n    };\n    var getFile = function getFile() {\n      return state.file;\n    };\n\n    //\n    // logic to load a file\n    //\n    var load = function load(source, loader, onload) {\n      // remember the original item source\n      state.source = source;\n\n      // source is known\n      api.fireSync('init');\n\n      // file stub is already there\n      if (state.file) {\n        api.fireSync('load-skip');\n        return;\n      }\n\n      // set a stub file object while loading the actual data\n      state.file = createFileStub(source);\n\n      // starts loading\n      loader.on('init', function() {\n        fire('load-init');\n      });\n\n      // we'eve received a size indication, let's update the stub\n      loader.on('meta', function(meta) {\n        // set size of file stub\n        state.file.size = meta.size;\n\n        // set name of file stub\n        state.file.filename = meta.filename;\n\n        // if has received source, we done\n        if (meta.source) {\n          origin = FileOrigin.LIMBO;\n          state.serverFileReference = meta.source;\n          state.status = ItemStatus.PROCESSING_COMPLETE;\n        }\n\n        // size has been updated\n        fire('load-meta');\n      });\n\n      // the file is now loading we need to update the progress indicators\n      loader.on('progress', function(progress) {\n        setStatus(ItemStatus.LOADING);\n\n        fire('load-progress', progress);\n      });\n\n      // an error was thrown while loading the file, we need to switch to error state\n      loader.on('error', function(error) {\n        setStatus(ItemStatus.LOAD_ERROR);\n\n        fire('load-request-error', error);\n      });\n\n      // user or another process aborted the file load (cannot retry)\n      loader.on('abort', function() {\n        setStatus(ItemStatus.INIT);\n        fire('load-abort');\n      });\n\n      // done loading\n      loader.on('load', function(file) {\n        // as we've now loaded the file the loader is no longer required\n        state.activeLoader = null;\n\n        // called when file has loaded succesfully\n        var success = function success(result) {\n          // set (possibly) transformed file\n          state.file = isFile(result) ? result : state.file;\n\n          // file received\n          if (origin === FileOrigin.LIMBO && state.serverFileReference) {\n            setStatus(ItemStatus.PROCESSING_COMPLETE);\n          } else {\n            setStatus(ItemStatus.IDLE);\n          }\n\n          fire('load');\n        };\n\n        var error = function error(result) {\n          // set original file\n          state.file = file;\n          fire('load-meta');\n\n          setStatus(ItemStatus.LOAD_ERROR);\n          fire('load-file-error', result);\n        };\n\n        // if we already have a server file reference, we don't need to call the onload method\n        if (state.serverFileReference) {\n          success(file);\n          return;\n        }\n\n        // no server id, let's give this file the full treatment\n        onload(file, success, error);\n      });\n\n      // set loader source data\n      loader.setSource(source);\n\n      // set as active loader\n      state.activeLoader = loader;\n\n      // load the source data\n      loader.load();\n    };\n\n    var retryLoad = function retryLoad() {\n      if (!state.activeLoader) {\n        return;\n      }\n      state.activeLoader.load();\n    };\n\n    var abortLoad = function abortLoad() {\n      if (state.activeLoader) {\n        state.activeLoader.abort();\n        return;\n      }\n      setStatus(ItemStatus.INIT);\n      fire('load-abort');\n    };\n\n    //\n    // logic to process a file\n    //\n    var process = function process(processor, onprocess) {\n      // processing was aborted\n      if (state.processingAborted) {\n        state.processingAborted = false;\n        return;\n      }\n\n      // now processing\n      setStatus(ItemStatus.PROCESSING);\n\n      // reset abort callback\n      abortProcessingRequestComplete = null;\n\n      // if no file loaded we'll wait for the load event\n      if (!(state.file instanceof Blob)) {\n        api.on('load', function() {\n          process(processor, onprocess);\n        });\n        return;\n      }\n\n      // setup processor\n      processor.on('load', function(serverFileReference) {\n        // need this id to be able to revert the upload\n        state.transferId = null;\n        state.serverFileReference = serverFileReference;\n      });\n\n      // register transfer id\n      processor.on('transfer', function(transferId) {\n        // need this id to be able to revert the upload\n        state.transferId = transferId;\n      });\n\n      processor.on('load-perceived', function(serverFileReference) {\n        // no longer required\n        state.activeProcessor = null;\n\n        // need this id to be able to rever the upload\n        state.transferId = null;\n        state.serverFileReference = serverFileReference;\n\n        setStatus(ItemStatus.PROCESSING_COMPLETE);\n        fire('process-complete', serverFileReference);\n      });\n\n      processor.on('start', function() {\n        fire('process-start');\n      });\n\n      processor.on('error', function(error) {\n        state.activeProcessor = null;\n        setStatus(ItemStatus.PROCESSING_ERROR);\n        fire('process-error', error);\n      });\n\n      processor.on('abort', function(serverFileReference) {\n        state.activeProcessor = null;\n\n        // if file was uploaded but processing was cancelled during perceived processor time store file reference\n        state.transferId = null;\n        state.serverFileReference = serverFileReference;\n\n        setStatus(ItemStatus.IDLE);\n        fire('process-abort');\n\n        // has timeout so doesn't interfere with remove action\n        if (abortProcessingRequestComplete) {\n          abortProcessingRequestComplete();\n        }\n      });\n\n      processor.on('progress', function(progress) {\n        fire('process-progress', progress);\n      });\n\n      // when successfully transformed\n      var success = function success(file) {\n        // if was archived in the mean time, don't process\n        if (state.archived) return;\n\n        // process file!\n        processor.process(file, Object.assign({}, metadata));\n      };\n\n      // something went wrong during transform phase\n      var error = console.error;\n\n      // start processing the file\n      onprocess(state.file, success, error);\n\n      // set as active processor\n      state.activeProcessor = processor;\n    };\n\n    var requestProcessing = function requestProcessing() {\n      state.processingAborted = false;\n      setStatus(ItemStatus.PROCESSING_QUEUED);\n    };\n\n    var abortProcessing = function abortProcessing() {\n      return new Promise(function(resolve) {\n        if (!state.activeProcessor) {\n          state.processingAborted = true;\n\n          setStatus(ItemStatus.IDLE);\n          fire('process-abort');\n\n          resolve();\n          return;\n        }\n\n        abortProcessingRequestComplete = function abortProcessingRequestComplete() {\n          resolve();\n        };\n\n        state.activeProcessor.abort();\n      });\n    };\n\n    //\n    // logic to revert a processed file\n    //\n    var revert = function revert(revertFileUpload, forceRevert) {\n      return new Promise(function(resolve, reject) {\n        // cannot revert without a server id for this process\n        if (state.serverFileReference === null) {\n          resolve();\n          return;\n        }\n\n        // revert the upload (fire and forget)\n        revertFileUpload(\n          state.serverFileReference,\n          function() {\n            // reset file server id as now it's no available on the server\n            state.serverFileReference = null;\n            resolve();\n          },\n          function(error) {\n            // don't set error state when reverting is optional, it will always resolve\n            if (!forceRevert) {\n              resolve();\n              return;\n            }\n\n            // oh no errors\n            setStatus(ItemStatus.PROCESSING_REVERT_ERROR);\n            fire('process-revert-error');\n            reject(error);\n          }\n        );\n\n        // fire event\n        setStatus(ItemStatus.IDLE);\n        fire('process-revert');\n      });\n    };\n\n    // exposed methods\n    var _setMetadata = function setMetadata(key, value, silent) {\n      var keys = key.split('.');\n      var root = keys[0];\n      var last = keys.pop();\n      var data = metadata;\n      keys.forEach(function(key) {\n        return (data = data[key]);\n      });\n\n      // compare old value against new value, if they're the same, we're not updating\n      if (JSON.stringify(data[last]) === JSON.stringify(value)) return;\n\n      // update value\n      data[last] = value;\n\n      // don't fire update\n      if (silent) return;\n\n      // fire update\n      fire('metadata-update', {\n        key: root,\n        value: metadata[root]\n      });\n    };\n\n    var getMetadata = function getMetadata(key) {\n      return deepCloneObject(key ? metadata[key] : metadata);\n    };\n\n    var api = Object.assign(\n      {\n        id: {\n          get: function get() {\n            return id;\n          }\n        },\n        origin: {\n          get: function get() {\n            return origin;\n          }\n        },\n        serverId: {\n          get: function get() {\n            return state.serverFileReference;\n          }\n        },\n        transferId: {\n          get: function get() {\n            return state.transferId;\n          }\n        },\n        status: {\n          get: function get() {\n            return state.status;\n          }\n        },\n        filename: {\n          get: function get() {\n            return state.file.name;\n          }\n        },\n        filenameWithoutExtension: {\n          get: function get() {\n            return getFilenameWithoutExtension(state.file.name);\n          }\n        },\n        fileExtension: { get: getFileExtension },\n        fileType: { get: getFileType },\n        fileSize: { get: getFileSize },\n        file: { get: getFile },\n        relativePath: {\n          get: function get() {\n            return state.file._relativePath;\n          }\n        },\n\n        source: {\n          get: function get() {\n            return state.source;\n          }\n        },\n\n        getMetadata: getMetadata,\n        setMetadata: function setMetadata(key, value, silent) {\n          if (isObject(key)) {\n            var data = key;\n            Object.keys(data).forEach(function(key) {\n              _setMetadata(key, data[key], value);\n            });\n            return key;\n          }\n          _setMetadata(key, value, silent);\n          return value;\n        },\n\n        extend: function extend(name, handler) {\n          return (itemAPI[name] = handler);\n        },\n\n        abortLoad: abortLoad,\n        retryLoad: retryLoad,\n        requestProcessing: requestProcessing,\n        abortProcessing: abortProcessing,\n\n        load: load,\n        process: process,\n        revert: revert\n      },\n\n      on(),\n      {\n        freeze: function freeze() {\n          return (state.frozen = true);\n        },\n\n        release: function release() {\n          return (state.released = true);\n        },\n        released: {\n          get: function get() {\n            return state.released;\n          }\n        },\n\n        archive: function archive() {\n          return (state.archived = true);\n        },\n        archived: {\n          get: function get() {\n            return state.archived;\n          }\n        }\n      }\n    );\n\n    // create it here instead of returning it instantly so we can extend it later\n    var itemAPI = createObject(api);\n\n    return itemAPI;\n  };\n\n  var getItemIndexByQuery = function getItemIndexByQuery(items, query) {\n    // just return first index\n    if (isEmpty(query)) {\n      return 0;\n    }\n\n    // invalid queries\n    if (!isString(query)) {\n      return -1;\n    }\n\n    // return item by id (or -1 if not found)\n    return items.findIndex(function(item) {\n      return item.id === query;\n    });\n  };\n\n  var getItemById = function getItemById(items, itemId) {\n    var index = getItemIndexByQuery(items, itemId);\n    if (index < 0) {\n      return;\n    }\n    return items[index] || null;\n  };\n\n  var fetchBlob = function fetchBlob(\n    url,\n    load,\n    error,\n    progress,\n    abort,\n    headers\n  ) {\n    var request = sendRequest(null, url, {\n      method: 'GET',\n      responseType: 'blob'\n    });\n\n    request.onload = function(xhr) {\n      // get headers\n      var headers = xhr.getAllResponseHeaders();\n\n      // get filename\n      var filename =\n        getFileInfoFromHeaders(headers).name || getFilenameFromURL(url);\n\n      // create response\n      load(\n        createResponse(\n          'load',\n          xhr.status,\n          getFileFromBlob(xhr.response, filename),\n          headers\n        )\n      );\n    };\n\n    request.onerror = function(xhr) {\n      error(\n        createResponse(\n          'error',\n          xhr.status,\n          xhr.statusText,\n          xhr.getAllResponseHeaders()\n        )\n      );\n    };\n\n    request.onheaders = function(xhr) {\n      headers(\n        createResponse('headers', xhr.status, null, xhr.getAllResponseHeaders())\n      );\n    };\n\n    request.ontimeout = createTimeoutResponse(error);\n    request.onprogress = progress;\n    request.onabort = abort;\n\n    // should return request\n    return request;\n  };\n\n  var getDomainFromURL = function getDomainFromURL(url) {\n    if (url.indexOf('//') === 0) {\n      url = location.protocol + url;\n    }\n    return url\n      .toLowerCase()\n      .replace('blob:', '')\n      .replace(/([a-z])?:\\/\\//, '$1')\n      .split('/')[0];\n  };\n\n  var isExternalURL = function isExternalURL(url) {\n    return (\n      (url.indexOf(':') > -1 || url.indexOf('//') > -1) &&\n      getDomainFromURL(location.href) !== getDomainFromURL(url)\n    );\n  };\n\n  var dynamicLabel = function dynamicLabel(label) {\n    return function() {\n      return isFunction(label) ? label.apply(void 0, arguments) : label;\n    };\n  };\n\n  var isMockItem = function isMockItem(item) {\n    return !isFile(item.file);\n  };\n\n  var listUpdated = function listUpdated(dispatch, state) {\n    clearTimeout(state.listUpdateTimeout);\n    state.listUpdateTimeout = setTimeout(function() {\n      dispatch('DID_UPDATE_ITEMS', { items: getActiveItems(state.items) });\n    }, 0);\n  };\n\n  var optionalPromise = function optionalPromise(fn) {\n    for (\n      var _len = arguments.length,\n        params = new Array(_len > 1 ? _len - 1 : 0),\n        _key = 1;\n      _key < _len;\n      _key++\n    ) {\n      params[_key - 1] = arguments[_key];\n    }\n    return new Promise(function(resolve) {\n      if (!fn) {\n        return resolve(true);\n      }\n\n      var result = fn.apply(void 0, params);\n\n      if (result == null) {\n        return resolve(true);\n      }\n\n      if (typeof result === 'boolean') {\n        return resolve(result);\n      }\n\n      if (typeof result.then === 'function') {\n        result.then(resolve);\n      }\n    });\n  };\n\n  var sortItems = function sortItems(state, compare) {\n    state.items.sort(function(a, b) {\n      return compare(createItemAPI(a), createItemAPI(b));\n    });\n  };\n\n  // returns item based on state\n  var getItemByQueryFromState = function getItemByQueryFromState(\n    state,\n    itemHandler\n  ) {\n    return function() {\n      var _ref =\n        arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n      var query = _ref.query,\n        _ref$success = _ref.success,\n        success = _ref$success === void 0 ? function() {} : _ref$success,\n        _ref$failure = _ref.failure,\n        failure = _ref$failure === void 0 ? function() {} : _ref$failure,\n        options = _objectWithoutProperties(_ref, [\n          'query',\n          'success',\n          'failure'\n        ]);\n      var item = getItemByQuery(state.items, query);\n      if (!item) {\n        failure({\n          error: createResponse('error', 0, 'Item not found'),\n\n          file: null\n        });\n\n        return;\n      }\n      itemHandler(item, success, failure, options || {});\n    };\n  };\n\n  var actions = function actions(dispatch, query, state) {\n    return {\n      /**\n       * Aborts all ongoing processes\n       */\n      ABORT_ALL: function ABORT_ALL() {\n        getActiveItems(state.items).forEach(function(item) {\n          item.freeze();\n          item.abortLoad();\n          item.abortProcessing();\n        });\n      },\n\n      /**\n       * Sets initial files\n       */\n      DID_SET_FILES: function DID_SET_FILES(_ref2) {\n        var _ref2$value = _ref2.value,\n          value = _ref2$value === void 0 ? [] : _ref2$value;\n\n        // map values to file objects\n        var files = value.map(function(file) {\n          return {\n            source: file.source ? file.source : file,\n            options: file.options\n          };\n        });\n\n        // loop over files, if file is in list, leave it be, if not, remove\n        // test if items should be moved\n        var activeItems = getActiveItems(state.items);\n\n        activeItems.forEach(function(item) {\n          // if item not is in new value, remove\n          if (\n            !files.find(function(file) {\n              return file.source === item.source || file.source === item.file;\n            })\n          ) {\n            dispatch('REMOVE_ITEM', { query: item, remove: false });\n          }\n        });\n\n        // add new files\n        activeItems = getActiveItems(state.items);\n        files.forEach(function(file, index) {\n          // if file is already in list\n          if (\n            activeItems.find(function(item) {\n              return item.source === file.source || item.file === file.source;\n            })\n          )\n            return;\n\n          // not in list, add\n          dispatch(\n            'ADD_ITEM',\n            Object.assign({}, file, {\n              interactionMethod: InteractionMethod.NONE,\n              index: index\n            })\n          );\n        });\n      },\n\n      DID_UPDATE_ITEM_METADATA: function DID_UPDATE_ITEM_METADATA(_ref3) {\n        var id = _ref3.id,\n          action = _ref3.action;\n\n        // if is called multiple times in close succession we combined all calls together to save resources\n        clearTimeout(state.itemUpdateTimeout);\n        state.itemUpdateTimeout = setTimeout(function() {\n          var item = getItemById(state.items, id);\n\n          // only revert and attempt to upload when we're uploading to a server\n          if (!query('IS_ASYNC')) {\n            // should we update the output data\n            applyFilterChain('SHOULD_PREPARE_OUTPUT', false, {\n              item: item,\n              query: query,\n              action: action\n            }).then(function(shouldPrepareOutput) {\n              // plugins determined the output data should be prepared (or not), can be adjusted with beforePrepareOutput hook\n              var beforePrepareFile = query('GET_BEFORE_PREPARE_FILE');\n              if (beforePrepareFile)\n                shouldPrepareOutput = beforePrepareFile(\n                  item,\n                  shouldPrepareOutput\n                );\n\n              if (!shouldPrepareOutput) return;\n\n              dispatch(\n                'REQUEST_PREPARE_OUTPUT',\n                {\n                  query: id,\n                  item: item,\n                  success: function success(file) {\n                    dispatch('DID_PREPARE_OUTPUT', { id: id, file: file });\n                  }\n                },\n                true\n              );\n            });\n\n            return;\n          }\n\n          // for async scenarios\n          var upload = function upload() {\n            // we push this forward a bit so the interface is updated correctly\n            setTimeout(function() {\n              dispatch('REQUEST_ITEM_PROCESSING', { query: id });\n            }, 32);\n          };\n\n          var revert = function revert(doUpload) {\n            item\n              .revert(\n                createRevertFunction(\n                  state.options.server.url,\n                  state.options.server.revert\n                ),\n                query('GET_FORCE_REVERT')\n              )\n              .then(doUpload ? upload : function() {})\n              .catch(function() {});\n          };\n\n          var abort = function abort(doUpload) {\n            item.abortProcessing().then(doUpload ? upload : function() {});\n          };\n\n          // if we should re-upload the file immediately\n          if (item.status === ItemStatus.PROCESSING_COMPLETE) {\n            return revert(state.options.instantUpload);\n          }\n\n          // if currently uploading, cancel upload\n          if (item.status === ItemStatus.PROCESSING) {\n            return abort(state.options.instantUpload);\n          }\n\n          if (state.options.instantUpload) {\n            upload();\n          }\n        }, 0);\n      },\n\n      MOVE_ITEM: function MOVE_ITEM(_ref4) {\n        var query = _ref4.query,\n          index = _ref4.index;\n        var item = getItemByQuery(state.items, query);\n        if (!item) return;\n        var currentIndex = state.items.indexOf(item);\n        index = limit(index, 0, state.items.length - 1);\n        if (currentIndex === index) return;\n        state.items.splice(index, 0, state.items.splice(currentIndex, 1)[0]);\n      },\n\n      SORT: function SORT(_ref5) {\n        var compare = _ref5.compare;\n        sortItems(state, compare);\n        dispatch('DID_SORT_ITEMS', {\n          items: query('GET_ACTIVE_ITEMS')\n        });\n      },\n\n      ADD_ITEMS: function ADD_ITEMS(_ref6) {\n        var items = _ref6.items,\n          index = _ref6.index,\n          interactionMethod = _ref6.interactionMethod,\n          _ref6$success = _ref6.success,\n          success = _ref6$success === void 0 ? function() {} : _ref6$success,\n          _ref6$failure = _ref6.failure,\n          failure = _ref6$failure === void 0 ? function() {} : _ref6$failure;\n\n        var currentIndex = index;\n\n        if (index === -1 || typeof index === 'undefined') {\n          var insertLocation = query('GET_ITEM_INSERT_LOCATION');\n          var totalItems = query('GET_TOTAL_ITEMS');\n          currentIndex = insertLocation === 'before' ? 0 : totalItems;\n        }\n\n        var ignoredFiles = query('GET_IGNORED_FILES');\n        var isValidFile = function isValidFile(source) {\n          return isFile(source)\n            ? !ignoredFiles.includes(source.name.toLowerCase())\n            : !isEmpty(source);\n        };\n        var validItems = items.filter(isValidFile);\n\n        var promises = validItems.map(function(source) {\n          return new Promise(function(resolve, reject) {\n            dispatch('ADD_ITEM', {\n              interactionMethod: interactionMethod,\n              source: source.source || source,\n              success: resolve,\n              failure: reject,\n              index: currentIndex++,\n              options: source.options || {}\n            });\n          });\n        });\n\n        Promise.all(promises)\n          .then(success)\n          .catch(failure);\n      },\n\n      /**\n       * @param source\n       * @param index\n       * @param interactionMethod\n       */\n      ADD_ITEM: function ADD_ITEM(_ref7) {\n        var source = _ref7.source,\n          _ref7$index = _ref7.index,\n          index = _ref7$index === void 0 ? -1 : _ref7$index,\n          interactionMethod = _ref7.interactionMethod,\n          _ref7$success = _ref7.success,\n          success = _ref7$success === void 0 ? function() {} : _ref7$success,\n          _ref7$failure = _ref7.failure,\n          failure = _ref7$failure === void 0 ? function() {} : _ref7$failure,\n          _ref7$options = _ref7.options,\n          options = _ref7$options === void 0 ? {} : _ref7$options;\n\n        // if no source supplied\n        if (isEmpty(source)) {\n          failure({\n            error: createResponse('error', 0, 'No source'),\n\n            file: null\n          });\n\n          return;\n        }\n\n        // filter out invalid file items, used to filter dropped directory contents\n        if (\n          isFile(source) &&\n          state.options.ignoredFiles.includes(source.name.toLowerCase())\n        ) {\n          // fail silently\n          return;\n        }\n\n        // test if there's still room in the list of files\n        if (!hasRoomForItem(state)) {\n          // if multiple allowed, we can't replace\n          // or if only a single item is allowed but we're not allowed to replace it we exit\n          if (\n            state.options.allowMultiple ||\n            (!state.options.allowMultiple && !state.options.allowReplace)\n          ) {\n            var error = createResponse('warning', 0, 'Max files');\n\n            dispatch('DID_THROW_MAX_FILES', {\n              source: source,\n              error: error\n            });\n\n            failure({ error: error, file: null });\n\n            return;\n          }\n\n          // let's replace the item\n          // id of first item we're about to remove\n          var _item = getActiveItems(state.items)[0];\n\n          // if has been processed remove it from the server as well\n          if (\n            _item.status === ItemStatus.PROCESSING_COMPLETE ||\n            _item.status === ItemStatus.PROCESSING_REVERT_ERROR\n          ) {\n            var forceRevert = query('GET_FORCE_REVERT');\n            _item\n              .revert(\n                createRevertFunction(\n                  state.options.server.url,\n                  state.options.server.revert\n                ),\n                forceRevert\n              )\n              .then(function() {\n                if (!forceRevert) return;\n\n                // try to add now\n                dispatch('ADD_ITEM', {\n                  source: source,\n                  index: index,\n                  interactionMethod: interactionMethod,\n                  success: success,\n                  failure: failure,\n                  options: options\n                });\n              })\n              .catch(function() {}); // no need to handle this catch state for now\n\n            if (forceRevert) return;\n          }\n\n          // remove first item as it will be replaced by this item\n          dispatch('REMOVE_ITEM', { query: _item.id });\n        }\n\n        // where did the file originate\n        var origin =\n          options.type === 'local'\n            ? FileOrigin.LOCAL\n            : options.type === 'limbo'\n            ? FileOrigin.LIMBO\n            : FileOrigin.INPUT;\n\n        // create a new blank item\n        var item = createItem(\n          // where did this file come from\n          origin,\n\n          // an input file never has a server file reference\n          origin === FileOrigin.INPUT ? null : source,\n\n          // file mock data, if defined\n          options.file\n        );\n\n        // set initial meta data\n        Object.keys(options.metadata || {}).forEach(function(key) {\n          item.setMetadata(key, options.metadata[key]);\n        });\n\n        // created the item, let plugins add methods\n        applyFilters('DID_CREATE_ITEM', item, {\n          query: query,\n          dispatch: dispatch\n        });\n\n        // where to insert new items\n        var itemInsertLocation = query('GET_ITEM_INSERT_LOCATION');\n\n        // adjust index if is not allowed to pick location\n        if (!state.options.itemInsertLocationFreedom) {\n          index = itemInsertLocation === 'before' ? -1 : state.items.length;\n        }\n\n        // add item to list\n        insertItem(state.items, item, index);\n\n        // sort items in list\n        if (isFunction(itemInsertLocation) && source) {\n          sortItems(state, itemInsertLocation);\n        }\n\n        // get a quick reference to the item id\n        var id = item.id;\n\n        // observe item events\n        item.on('init', function() {\n          dispatch('DID_INIT_ITEM', { id: id });\n        });\n\n        item.on('load-init', function() {\n          dispatch('DID_START_ITEM_LOAD', { id: id });\n        });\n\n        item.on('load-meta', function() {\n          dispatch('DID_UPDATE_ITEM_META', { id: id });\n        });\n\n        item.on('load-progress', function(progress) {\n          dispatch('DID_UPDATE_ITEM_LOAD_PROGRESS', {\n            id: id,\n            progress: progress\n          });\n        });\n\n        item.on('load-request-error', function(error) {\n          var mainStatus = dynamicLabel(state.options.labelFileLoadError)(\n            error\n          );\n\n          // is client error, no way to recover\n          if (error.code >= 400 && error.code < 500) {\n            dispatch('DID_THROW_ITEM_INVALID', {\n              id: id,\n              error: error,\n              status: {\n                main: mainStatus,\n                sub: error.code + ' (' + error.body + ')'\n              }\n            });\n\n            // reject the file so can be dealt with through API\n            failure({ error: error, file: createItemAPI(item) });\n            return;\n          }\n\n          // is possible server error, so might be possible to retry\n          dispatch('DID_THROW_ITEM_LOAD_ERROR', {\n            id: id,\n            error: error,\n            status: {\n              main: mainStatus,\n              sub: state.options.labelTapToRetry\n            }\n          });\n        });\n\n        item.on('load-file-error', function(error) {\n          dispatch('DID_THROW_ITEM_INVALID', {\n            id: id,\n            error: error.status,\n            status: error.status\n          });\n\n          failure({ error: error.status, file: createItemAPI(item) });\n        });\n\n        item.on('load-abort', function() {\n          dispatch('REMOVE_ITEM', { query: id });\n        });\n\n        item.on('load-skip', function() {\n          dispatch('COMPLETE_LOAD_ITEM', {\n            query: id,\n            item: item,\n            data: {\n              source: source,\n              success: success\n            }\n          });\n        });\n\n        item.on('load', function() {\n          var handleAdd = function handleAdd(shouldAdd) {\n            // no should not add this file\n            if (!shouldAdd) {\n              dispatch('REMOVE_ITEM', {\n                query: id\n              });\n\n              return;\n            }\n\n            // now interested in metadata updates\n            item.on('metadata-update', function(change) {\n              dispatch('DID_UPDATE_ITEM_METADATA', { id: id, change: change });\n            });\n\n            // let plugins decide if the output data should be prepared at this point\n            // means we'll do this and wait for idle state\n            applyFilterChain('SHOULD_PREPARE_OUTPUT', false, {\n              item: item,\n              query: query\n            }).then(function(shouldPrepareOutput) {\n              // plugins determined the output data should be prepared (or not), can be adjusted with beforePrepareOutput hook\n              var beforePrepareFile = query('GET_BEFORE_PREPARE_FILE');\n              if (beforePrepareFile)\n                shouldPrepareOutput = beforePrepareFile(\n                  item,\n                  shouldPrepareOutput\n                );\n\n              var loadComplete = function loadComplete() {\n                dispatch('COMPLETE_LOAD_ITEM', {\n                  query: id,\n                  item: item,\n                  data: {\n                    source: source,\n                    success: success\n                  }\n                });\n\n                listUpdated(dispatch, state);\n              };\n\n              // exit\n              if (shouldPrepareOutput) {\n                // wait for idle state and then run PREPARE_OUTPUT\n                dispatch(\n                  'REQUEST_PREPARE_OUTPUT',\n                  {\n                    query: id,\n                    item: item,\n                    success: function success(file) {\n                      dispatch('DID_PREPARE_OUTPUT', { id: id, file: file });\n                      loadComplete();\n                    }\n                  },\n                  true\n                );\n\n                return;\n              }\n\n              loadComplete();\n            });\n          };\n\n          // item loaded, allow plugins to\n          // - read data (quickly)\n          // - add metadata\n          applyFilterChain('DID_LOAD_ITEM', item, {\n            query: query,\n            dispatch: dispatch\n          })\n            .then(function() {\n              optionalPromise(\n                query('GET_BEFORE_ADD_FILE'),\n                createItemAPI(item)\n              ).then(handleAdd);\n            })\n            .catch(function() {\n              handleAdd(false);\n            });\n        });\n\n        item.on('process-start', function() {\n          dispatch('DID_START_ITEM_PROCESSING', { id: id });\n        });\n\n        item.on('process-progress', function(progress) {\n          dispatch('DID_UPDATE_ITEM_PROCESS_PROGRESS', {\n            id: id,\n            progress: progress\n          });\n        });\n\n        item.on('process-error', function(error) {\n          dispatch('DID_THROW_ITEM_PROCESSING_ERROR', {\n            id: id,\n            error: error,\n            status: {\n              main: dynamicLabel(state.options.labelFileProcessingError)(error),\n              sub: state.options.labelTapToRetry\n            }\n          });\n        });\n\n        item.on('process-revert-error', function(error) {\n          dispatch('DID_THROW_ITEM_PROCESSING_REVERT_ERROR', {\n            id: id,\n            error: error,\n            status: {\n              main: dynamicLabel(state.options.labelFileProcessingRevertError)(\n                error\n              ),\n              sub: state.options.labelTapToRetry\n            }\n          });\n        });\n\n        item.on('process-complete', function(serverFileReference) {\n          dispatch('DID_COMPLETE_ITEM_PROCESSING', {\n            id: id,\n            error: null,\n            serverFileReference: serverFileReference\n          });\n\n          dispatch('DID_DEFINE_VALUE', { id: id, value: serverFileReference });\n        });\n\n        item.on('process-abort', function() {\n          dispatch('DID_ABORT_ITEM_PROCESSING', { id: id });\n        });\n\n        item.on('process-revert', function() {\n          dispatch('DID_REVERT_ITEM_PROCESSING', { id: id });\n          dispatch('DID_DEFINE_VALUE', { id: id, value: null });\n        });\n\n        // let view know the item has been inserted\n        dispatch('DID_ADD_ITEM', {\n          id: id,\n          index: index,\n          interactionMethod: interactionMethod\n        });\n\n        listUpdated(dispatch, state);\n\n        // start loading the source\n        var _ref8 = state.options.server || {},\n          url = _ref8.url,\n          load = _ref8.load,\n          restore = _ref8.restore,\n          fetch = _ref8.fetch;\n\n        item.load(\n          source,\n\n          // this creates a function that loads the file based on the type of file (string, base64, blob, file) and location of file (local, remote, limbo)\n          createFileLoader(\n            origin === FileOrigin.INPUT\n              ? // input, if is remote, see if should use custom fetch, else use default fetchBlob\n                isString(source) && isExternalURL(source)\n                ? fetch\n                  ? createFetchFunction(url, fetch)\n                  : fetchBlob // remote url\n                : fetchBlob // try to fetch url\n              : // limbo or local\n              origin === FileOrigin.LIMBO\n              ? createFetchFunction(url, restore) // limbo\n              : createFetchFunction(url, load) // local\n          ),\n\n          // called when the file is loaded so it can be piped through the filters\n          function(file, success, error) {\n            // let's process the file\n            applyFilterChain('LOAD_FILE', file, { query: query })\n              .then(success)\n              .catch(error);\n          }\n        );\n      },\n\n      REQUEST_PREPARE_OUTPUT: function REQUEST_PREPARE_OUTPUT(_ref9) {\n        var item = _ref9.item,\n          success = _ref9.success,\n          _ref9$failure = _ref9.failure,\n          failure = _ref9$failure === void 0 ? function() {} : _ref9$failure;\n\n        // error response if item archived\n        var err = {\n          error: createResponse('error', 0, 'Item not found'),\n\n          file: null\n        };\n\n        // don't handle archived items, an item could have been archived (load aborted) while waiting to be prepared\n        if (item.archived) return failure(err);\n\n        // allow plugins to alter the file data\n        applyFilterChain('PREPARE_OUTPUT', item.file, {\n          query: query,\n          item: item\n        }).then(function(result) {\n          applyFilterChain('COMPLETE_PREPARE_OUTPUT', result, {\n            query: query,\n            item: item\n          }).then(function(result) {\n            // don't handle archived items, an item could have been archived (load aborted) while being prepared\n            if (item.archived) return failure(err);\n\n            // we done!\n            success(result);\n          });\n        });\n      },\n\n      COMPLETE_LOAD_ITEM: function COMPLETE_LOAD_ITEM(_ref10) {\n        var item = _ref10.item,\n          data = _ref10.data;\n        var success = data.success,\n          source = data.source;\n\n        // sort items in list\n        var itemInsertLocation = query('GET_ITEM_INSERT_LOCATION');\n        if (isFunction(itemInsertLocation) && source) {\n          sortItems(state, itemInsertLocation);\n        }\n\n        // let interface know the item has loaded\n        dispatch('DID_LOAD_ITEM', {\n          id: item.id,\n          error: null,\n          serverFileReference: item.origin === FileOrigin.INPUT ? null : source\n        });\n\n        // item has been successfully loaded and added to the\n        // list of items so can now be safely returned for use\n        success(createItemAPI(item));\n\n        // if this is a local server file we need to show a different state\n        if (item.origin === FileOrigin.LOCAL) {\n          dispatch('DID_LOAD_LOCAL_ITEM', { id: item.id });\n          return;\n        }\n\n        // if is a temp server file we prevent async upload call here (as the file is already on the server)\n        if (item.origin === FileOrigin.LIMBO) {\n          dispatch('DID_COMPLETE_ITEM_PROCESSING', {\n            id: item.id,\n            error: null,\n            serverFileReference: source\n          });\n\n          dispatch('DID_DEFINE_VALUE', {\n            id: item.id,\n            value: source\n          });\n\n          return;\n        }\n\n        // id we are allowed to upload the file immediately, lets do it\n        if (query('IS_ASYNC') && state.options.instantUpload) {\n          dispatch('REQUEST_ITEM_PROCESSING', { query: item.id });\n        }\n      },\n\n      RETRY_ITEM_LOAD: getItemByQueryFromState(state, function(item) {\n        // try loading the source one more time\n        item.retryLoad();\n      }),\n\n      REQUEST_ITEM_PREPARE: getItemByQueryFromState(state, function(\n        item,\n        _success,\n        failure\n      ) {\n        dispatch(\n          'REQUEST_PREPARE_OUTPUT',\n          {\n            query: item.id,\n            item: item,\n            success: function success(file) {\n              dispatch('DID_PREPARE_OUTPUT', { id: item.id, file: file });\n              _success({\n                file: item,\n                output: file\n              });\n            },\n            failure: failure\n          },\n          true\n        );\n      }),\n\n      REQUEST_ITEM_PROCESSING: getItemByQueryFromState(state, function(\n        item,\n        success,\n        failure\n      ) {\n        // cannot be queued (or is already queued)\n        var itemCanBeQueuedForProcessing =\n          // waiting for something\n          item.status === ItemStatus.IDLE ||\n          // processing went wrong earlier\n          item.status === ItemStatus.PROCESSING_ERROR;\n\n        // not ready to be processed\n        if (!itemCanBeQueuedForProcessing) {\n          var processNow = function processNow() {\n            return dispatch('REQUEST_ITEM_PROCESSING', {\n              query: item,\n              success: success,\n              failure: failure\n            });\n          };\n\n          var process = function process() {\n            return document.hidden ? processNow() : setTimeout(processNow, 32);\n          };\n\n          // if already done processing or tried to revert but didn't work, try again\n          if (\n            item.status === ItemStatus.PROCESSING_COMPLETE ||\n            item.status === ItemStatus.PROCESSING_REVERT_ERROR\n          ) {\n            item\n              .revert(\n                createRevertFunction(\n                  state.options.server.url,\n                  state.options.server.revert\n                ),\n                query('GET_FORCE_REVERT')\n              )\n              .then(process)\n              .catch(function() {}); // don't continue with processing if something went wrong\n          } else if (item.status === ItemStatus.PROCESSING) {\n            item.abortProcessing().then(process);\n          }\n\n          return;\n        }\n\n        // already queued for processing\n        if (item.status === ItemStatus.PROCESSING_QUEUED) return;\n\n        item.requestProcessing();\n\n        dispatch('DID_REQUEST_ITEM_PROCESSING', { id: item.id });\n\n        dispatch(\n          'PROCESS_ITEM',\n          { query: item, success: success, failure: failure },\n          true\n        );\n      }),\n\n      PROCESS_ITEM: getItemByQueryFromState(state, function(\n        item,\n        success,\n        failure\n      ) {\n        var maxParallelUploads = query('GET_MAX_PARALLEL_UPLOADS');\n        var totalCurrentUploads = query(\n          'GET_ITEMS_BY_STATUS',\n          ItemStatus.PROCESSING\n        ).length;\n\n        // queue and wait till queue is freed up\n        if (totalCurrentUploads === maxParallelUploads) {\n          // queue for later processing\n          state.processingQueue.push({\n            id: item.id,\n            success: success,\n            failure: failure\n          });\n\n          // stop it!\n          return;\n        }\n\n        // if was not queued or is already processing exit here\n        if (item.status === ItemStatus.PROCESSING) return;\n\n        var processNext = function processNext() {\n          // process queueud items\n          var queueEntry = state.processingQueue.shift();\n\n          // no items left\n          if (!queueEntry) return;\n\n          // get item reference\n          var id = queueEntry.id,\n            success = queueEntry.success,\n            failure = queueEntry.failure;\n          var itemReference = getItemByQuery(state.items, id);\n\n          // if item was archived while in queue, jump to next\n          if (!itemReference || itemReference.archived) {\n            processNext();\n            return;\n          }\n\n          // process queued item\n          dispatch(\n            'PROCESS_ITEM',\n            { query: id, success: success, failure: failure },\n            true\n          );\n        };\n\n        // we done function\n        item.onOnce('process-complete', function() {\n          success(createItemAPI(item));\n          processNext();\n\n          // All items processed? No errors?\n          var allItemsProcessed =\n            query('GET_ITEMS_BY_STATUS', ItemStatus.PROCESSING_COMPLETE)\n              .length === state.items.length;\n          if (allItemsProcessed) {\n            dispatch('DID_COMPLETE_ITEM_PROCESSING_ALL');\n          }\n        });\n\n        // we error function\n        item.onOnce('process-error', function(error) {\n          failure({ error: error, file: createItemAPI(item) });\n          processNext();\n        });\n\n        // start file processing\n        var options = state.options;\n        item.process(\n          createFileProcessor(\n            createProcessorFunction(\n              options.server.url,\n              options.server.process,\n              options.name,\n              {\n                chunkTransferId: item.transferId,\n                chunkServer: options.server.patch,\n                chunkUploads: options.chunkUploads,\n                chunkForce: options.chunkForce,\n                chunkSize: options.chunkSize,\n                chunkRetryDelays: options.chunkRetryDelays\n              }\n            )\n          ),\n\n          // called when the file is about to be processed so it can be piped through the transform filters\n          function(file, success, error) {\n            // allow plugins to alter the file data\n            applyFilterChain('PREPARE_OUTPUT', file, {\n              query: query,\n              item: item\n            })\n              .then(function(file) {\n                dispatch('DID_PREPARE_OUTPUT', { id: item.id, file: file });\n\n                success(file);\n              })\n              .catch(error);\n          }\n        );\n      }),\n\n      RETRY_ITEM_PROCESSING: getItemByQueryFromState(state, function(item) {\n        dispatch('REQUEST_ITEM_PROCESSING', { query: item });\n      }),\n\n      REQUEST_REMOVE_ITEM: getItemByQueryFromState(state, function(item) {\n        optionalPromise(\n          query('GET_BEFORE_REMOVE_FILE'),\n          createItemAPI(item)\n        ).then(function(shouldRemove) {\n          if (!shouldRemove) {\n            return;\n          }\n          dispatch('REMOVE_ITEM', { query: item });\n        });\n      }),\n\n      RELEASE_ITEM: getItemByQueryFromState(state, function(item) {\n        item.release();\n      }),\n\n      REMOVE_ITEM: getItemByQueryFromState(state, function(\n        item,\n        success,\n        failure,\n        options\n      ) {\n        var removeFromView = function removeFromView() {\n          // get id reference\n          var id = item.id;\n\n          // archive the item, this does not remove it from the list\n          getItemById(state.items, id).archive();\n\n          // tell the view the item has been removed\n          dispatch('DID_REMOVE_ITEM', { error: null, id: id, item: item });\n\n          // now the list has been modified\n          listUpdated(dispatch, state);\n\n          // correctly removed\n          success(createItemAPI(item));\n        };\n\n        // if this is a local file and the server.remove function has been configured, send source there so dev can remove file from server\n        var server = state.options.server;\n        if (\n          item.origin === FileOrigin.LOCAL &&\n          server &&\n          isFunction(server.remove) &&\n          options.remove !== false\n        ) {\n          dispatch('DID_START_ITEM_REMOVE', { id: item.id });\n\n          server.remove(\n            item.source,\n            function() {\n              return removeFromView();\n            },\n            function(status) {\n              dispatch('DID_THROW_ITEM_REMOVE_ERROR', {\n                id: item.id,\n                error: createResponse('error', 0, status, null),\n                status: {\n                  main: dynamicLabel(state.options.labelFileRemoveError)(\n                    status\n                  ),\n                  sub: state.options.labelTapToRetry\n                }\n              });\n            }\n          );\n        } else {\n          // if is requesting revert and can revert need to call revert handler (not calling request_ because that would also trigger beforeRemoveHook)\n          if (\n            options.revert &&\n            item.origin !== FileOrigin.LOCAL &&\n            item.serverId !== null\n          ) {\n            item.revert(\n              createRevertFunction(\n                state.options.server.url,\n                state.options.server.revert\n              ),\n              query('GET_FORCE_REVERT')\n            );\n          }\n\n          // can now safely remove from view\n          removeFromView();\n        }\n      }),\n\n      ABORT_ITEM_LOAD: getItemByQueryFromState(state, function(item) {\n        item.abortLoad();\n      }),\n\n      ABORT_ITEM_PROCESSING: getItemByQueryFromState(state, function(item) {\n        // test if is already processed\n        if (item.serverId) {\n          dispatch('REVERT_ITEM_PROCESSING', { id: item.id });\n          return;\n        }\n\n        // abort\n        item.abortProcessing().then(function() {\n          var shouldRemove = state.options.instantUpload;\n          if (shouldRemove) {\n            dispatch('REMOVE_ITEM', { query: item.id });\n          }\n        });\n      }),\n\n      REQUEST_REVERT_ITEM_PROCESSING: getItemByQueryFromState(state, function(\n        item\n      ) {\n        // not instant uploading, revert immediately\n        if (!state.options.instantUpload) {\n          dispatch('REVERT_ITEM_PROCESSING', { query: item });\n          return;\n        }\n\n        // if we're instant uploading the file will also be removed if we revert,\n        // so if a before remove file hook is defined we need to run it now\n        var handleRevert = function handleRevert(shouldRevert) {\n          if (!shouldRevert) return;\n          dispatch('REVERT_ITEM_PROCESSING', { query: item });\n        };\n\n        var fn = query('GET_BEFORE_REMOVE_FILE');\n        if (!fn) {\n          return handleRevert(true);\n        }\n\n        var requestRemoveResult = fn(createItemAPI(item));\n        if (requestRemoveResult == null) {\n          // undefined or null\n          return handleRevert(true);\n        }\n\n        if (typeof requestRemoveResult === 'boolean') {\n          return handleRevert(requestRemoveResult);\n        }\n\n        if (typeof requestRemoveResult.then === 'function') {\n          requestRemoveResult.then(handleRevert);\n        }\n      }),\n\n      REVERT_ITEM_PROCESSING: getItemByQueryFromState(state, function(item) {\n        item\n          .revert(\n            createRevertFunction(\n              state.options.server.url,\n              state.options.server.revert\n            ),\n            query('GET_FORCE_REVERT')\n          )\n          .then(function() {\n            var shouldRemove = state.options.instantUpload || isMockItem(item);\n            if (shouldRemove) {\n              dispatch('REMOVE_ITEM', { query: item.id });\n            }\n          })\n          .catch(function() {});\n      }),\n\n      SET_OPTIONS: function SET_OPTIONS(_ref11) {\n        var options = _ref11.options;\n        forin(options, function(key, value) {\n          dispatch('SET_' + fromCamels(key, '_').toUpperCase(), {\n            value: value\n          });\n        });\n      }\n    };\n  };\n\n  var formatFilename = function formatFilename(name) {\n    return name;\n  };\n\n  var createElement$1 = function createElement(tagName) {\n    return document.createElement(tagName);\n  };\n\n  var text = function text(node, value) {\n    var textNode = node.childNodes[0];\n    if (!textNode) {\n      textNode = document.createTextNode(value);\n      node.appendChild(textNode);\n    } else if (value !== textNode.nodeValue) {\n      textNode.nodeValue = value;\n    }\n  };\n\n  var polarToCartesian = function polarToCartesian(\n    centerX,\n    centerY,\n    radius,\n    angleInDegrees\n  ) {\n    var angleInRadians = (((angleInDegrees % 360) - 90) * Math.PI) / 180.0;\n    return {\n      x: centerX + radius * Math.cos(angleInRadians),\n      y: centerY + radius * Math.sin(angleInRadians)\n    };\n  };\n\n  var describeArc = function describeArc(\n    x,\n    y,\n    radius,\n    startAngle,\n    endAngle,\n    arcSweep\n  ) {\n    var start = polarToCartesian(x, y, radius, endAngle);\n    var end = polarToCartesian(x, y, radius, startAngle);\n    return [\n      'M',\n      start.x,\n      start.y,\n      'A',\n      radius,\n      radius,\n      0,\n      arcSweep,\n      0,\n      end.x,\n      end.y\n    ].join(' ');\n  };\n\n  var percentageArc = function percentageArc(x, y, radius, from, to) {\n    var arcSweep = 1;\n    if (to > from && to - from <= 0.5) {\n      arcSweep = 0;\n    }\n    if (from > to && from - to >= 0.5) {\n      arcSweep = 0;\n    }\n    return describeArc(\n      x,\n      y,\n      radius,\n      Math.min(0.9999, from) * 360,\n      Math.min(0.9999, to) * 360,\n      arcSweep\n    );\n  };\n\n  var create = function create(_ref) {\n    var root = _ref.root,\n      props = _ref.props;\n    // start at 0\n    props.spin = false;\n    props.progress = 0;\n    props.opacity = 0;\n\n    // svg\n    var svg = createElement('svg');\n    root.ref.path = createElement('path', {\n      'stroke-width': 2,\n      'stroke-linecap': 'round'\n    });\n\n    svg.appendChild(root.ref.path);\n\n    root.ref.svg = svg;\n\n    root.appendChild(svg);\n  };\n\n  var write = function write(_ref2) {\n    var root = _ref2.root,\n      props = _ref2.props;\n\n    if (props.opacity === 0) {\n      return;\n    }\n\n    if (props.align) {\n      root.element.dataset.align = props.align;\n    }\n\n    // get width of stroke\n    var ringStrokeWidth = parseInt(attr(root.ref.path, 'stroke-width'), 10);\n\n    // calculate size of ring\n    var size = root.rect.element.width * 0.5;\n\n    // ring state\n    var ringFrom = 0;\n    var ringTo = 0;\n\n    // now in busy mode\n    if (props.spin) {\n      ringFrom = 0;\n      ringTo = 0.5;\n    } else {\n      ringFrom = 0;\n      ringTo = props.progress;\n    }\n\n    // get arc path\n    var coordinates = percentageArc(\n      size,\n      size,\n      size - ringStrokeWidth,\n      ringFrom,\n      ringTo\n    );\n\n    // update progress bar\n    attr(root.ref.path, 'd', coordinates);\n\n    // hide while contains 0 value\n    attr(\n      root.ref.path,\n      'stroke-opacity',\n      props.spin || props.progress > 0 ? 1 : 0\n    );\n  };\n\n  var progressIndicator = createView({\n    tag: 'div',\n    name: 'progress-indicator',\n    ignoreRectUpdate: true,\n    ignoreRect: true,\n    create: create,\n    write: write,\n    mixins: {\n      apis: ['progress', 'spin', 'align'],\n      styles: ['opacity'],\n      animations: {\n        opacity: { type: 'tween', duration: 500 },\n        progress: {\n          type: 'spring',\n          stiffness: 0.95,\n          damping: 0.65,\n          mass: 10\n        }\n      }\n    }\n  });\n\n  var create$1 = function create(_ref) {\n    var root = _ref.root,\n      props = _ref.props;\n    root.element.innerHTML =\n      (props.icon || '') + ('<span>' + props.label + '</span>');\n\n    props.isDisabled = false;\n  };\n\n  var write$1 = function write(_ref2) {\n    var root = _ref2.root,\n      props = _ref2.props;\n    var isDisabled = props.isDisabled;\n    var shouldDisable = root.query('GET_DISABLED') || props.opacity === 0;\n\n    if (shouldDisable && !isDisabled) {\n      props.isDisabled = true;\n      attr(root.element, 'disabled', 'disabled');\n    } else if (!shouldDisable && isDisabled) {\n      props.isDisabled = false;\n      root.element.removeAttribute('disabled');\n    }\n  };\n\n  var fileActionButton = createView({\n    tag: 'button',\n    attributes: {\n      type: 'button'\n    },\n\n    ignoreRect: true,\n    ignoreRectUpdate: true,\n    name: 'file-action-button',\n    mixins: {\n      apis: ['label'],\n      styles: ['translateX', 'translateY', 'scaleX', 'scaleY', 'opacity'],\n      animations: {\n        scaleX: 'spring',\n        scaleY: 'spring',\n        translateX: 'spring',\n        translateY: 'spring',\n        opacity: { type: 'tween', duration: 250 }\n      },\n\n      listeners: true\n    },\n\n    create: create$1,\n    write: write$1\n  });\n\n  var toNaturalFileSize = function toNaturalFileSize(bytes) {\n    var decimalSeparator =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '.';\n    var base =\n      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1000;\n    // no negative byte sizes\n    bytes = Math.round(Math.abs(bytes));\n\n    var KB = base;\n    var MB = base * base;\n    var GB = base * base * base;\n\n    // just bytes\n    if (bytes < KB) {\n      return bytes + ' bytes';\n    }\n\n    // kilobytes\n    if (bytes < MB) {\n      return Math.floor(bytes / KB) + ' KB';\n    }\n\n    // megabytes\n    if (bytes < GB) {\n      return removeDecimalsWhenZero(bytes / MB, 1, decimalSeparator) + ' MB';\n    }\n\n    // gigabytes\n    return removeDecimalsWhenZero(bytes / GB, 2, decimalSeparator) + ' GB';\n  };\n\n  var removeDecimalsWhenZero = function removeDecimalsWhenZero(\n    value,\n    decimalCount,\n    separator\n  ) {\n    return value\n      .toFixed(decimalCount)\n      .split('.')\n      .filter(function(part) {\n        return part !== '0';\n      })\n      .join(separator);\n  };\n\n  var create$2 = function create(_ref) {\n    var root = _ref.root,\n      props = _ref.props;\n    // filename\n    var fileName = createElement$1('span');\n    fileName.className = 'filepond--file-info-main';\n    // hide for screenreaders\n    // the file is contained in a fieldset with legend that contains the filename\n    // no need to read it twice\n    attr(fileName, 'aria-hidden', 'true');\n    root.appendChild(fileName);\n    root.ref.fileName = fileName;\n\n    // filesize\n    var fileSize = createElement$1('span');\n    fileSize.className = 'filepond--file-info-sub';\n    root.appendChild(fileSize);\n    root.ref.fileSize = fileSize;\n\n    // set initial values\n    text(fileSize, root.query('GET_LABEL_FILE_WAITING_FOR_SIZE'));\n    text(fileName, formatFilename(root.query('GET_ITEM_NAME', props.id)));\n  };\n\n  var updateFile = function updateFile(_ref2) {\n    var root = _ref2.root,\n      props = _ref2.props;\n    text(\n      root.ref.fileSize,\n      toNaturalFileSize(\n        root.query('GET_ITEM_SIZE', props.id),\n        '.',\n        root.query('GET_FILE_SIZE_BASE')\n      )\n    );\n\n    text(\n      root.ref.fileName,\n      formatFilename(root.query('GET_ITEM_NAME', props.id))\n    );\n  };\n\n  var updateFileSizeOnError = function updateFileSizeOnError(_ref3) {\n    var root = _ref3.root,\n      props = _ref3.props;\n    // if size is available don't fallback to unknown size message\n    if (isInt(root.query('GET_ITEM_SIZE', props.id))) {\n      return;\n    }\n\n    text(root.ref.fileSize, root.query('GET_LABEL_FILE_SIZE_NOT_AVAILABLE'));\n  };\n\n  var fileInfo = createView({\n    name: 'file-info',\n    ignoreRect: true,\n    ignoreRectUpdate: true,\n    write: createRoute({\n      DID_LOAD_ITEM: updateFile,\n      DID_UPDATE_ITEM_META: updateFile,\n      DID_THROW_ITEM_LOAD_ERROR: updateFileSizeOnError,\n      DID_THROW_ITEM_INVALID: updateFileSizeOnError\n    }),\n\n    didCreateView: function didCreateView(root) {\n      applyFilters('CREATE_VIEW', Object.assign({}, root, { view: root }));\n    },\n    create: create$2,\n    mixins: {\n      styles: ['translateX', 'translateY'],\n      animations: {\n        translateX: 'spring',\n        translateY: 'spring'\n      }\n    }\n  });\n\n  var toPercentage = function toPercentage(value) {\n    return Math.round(value * 100);\n  };\n\n  var create$3 = function create(_ref) {\n    var root = _ref.root;\n\n    // main status\n    var main = createElement$1('span');\n    main.className = 'filepond--file-status-main';\n    root.appendChild(main);\n    root.ref.main = main;\n\n    // sub status\n    var sub = createElement$1('span');\n    sub.className = 'filepond--file-status-sub';\n    root.appendChild(sub);\n    root.ref.sub = sub;\n\n    didSetItemLoadProgress({ root: root, action: { progress: null } });\n  };\n\n  var didSetItemLoadProgress = function didSetItemLoadProgress(_ref2) {\n    var root = _ref2.root,\n      action = _ref2.action;\n    var title =\n      action.progress === null\n        ? root.query('GET_LABEL_FILE_LOADING')\n        : root.query('GET_LABEL_FILE_LOADING') +\n          ' ' +\n          toPercentage(action.progress) +\n          '%';\n\n    text(root.ref.main, title);\n    text(root.ref.sub, root.query('GET_LABEL_TAP_TO_CANCEL'));\n  };\n\n  var didSetItemProcessProgress = function didSetItemProcessProgress(_ref3) {\n    var root = _ref3.root,\n      action = _ref3.action;\n    var title =\n      action.progress === null\n        ? root.query('GET_LABEL_FILE_PROCESSING')\n        : root.query('GET_LABEL_FILE_PROCESSING') +\n          ' ' +\n          toPercentage(action.progress) +\n          '%';\n\n    text(root.ref.main, title);\n    text(root.ref.sub, root.query('GET_LABEL_TAP_TO_CANCEL'));\n  };\n\n  var didRequestItemProcessing = function didRequestItemProcessing(_ref4) {\n    var root = _ref4.root;\n    text(root.ref.main, root.query('GET_LABEL_FILE_PROCESSING'));\n    text(root.ref.sub, root.query('GET_LABEL_TAP_TO_CANCEL'));\n  };\n\n  var didAbortItemProcessing = function didAbortItemProcessing(_ref5) {\n    var root = _ref5.root;\n    text(root.ref.main, root.query('GET_LABEL_FILE_PROCESSING_ABORTED'));\n    text(root.ref.sub, root.query('GET_LABEL_TAP_TO_RETRY'));\n  };\n\n  var didCompleteItemProcessing = function didCompleteItemProcessing(_ref6) {\n    var root = _ref6.root;\n    text(root.ref.main, root.query('GET_LABEL_FILE_PROCESSING_COMPLETE'));\n    text(root.ref.sub, root.query('GET_LABEL_TAP_TO_UNDO'));\n  };\n\n  var clear = function clear(_ref7) {\n    var root = _ref7.root;\n    text(root.ref.main, '');\n    text(root.ref.sub, '');\n  };\n\n  var error = function error(_ref8) {\n    var root = _ref8.root,\n      action = _ref8.action;\n    text(root.ref.main, action.status.main);\n    text(root.ref.sub, action.status.sub);\n  };\n\n  var fileStatus = createView({\n    name: 'file-status',\n    ignoreRect: true,\n    ignoreRectUpdate: true,\n    write: createRoute({\n      DID_LOAD_ITEM: clear,\n      DID_REVERT_ITEM_PROCESSING: clear,\n      DID_REQUEST_ITEM_PROCESSING: didRequestItemProcessing,\n      DID_ABORT_ITEM_PROCESSING: didAbortItemProcessing,\n      DID_COMPLETE_ITEM_PROCESSING: didCompleteItemProcessing,\n      DID_UPDATE_ITEM_PROCESS_PROGRESS: didSetItemProcessProgress,\n      DID_UPDATE_ITEM_LOAD_PROGRESS: didSetItemLoadProgress,\n      DID_THROW_ITEM_LOAD_ERROR: error,\n      DID_THROW_ITEM_INVALID: error,\n      DID_THROW_ITEM_PROCESSING_ERROR: error,\n      DID_THROW_ITEM_PROCESSING_REVERT_ERROR: error,\n      DID_THROW_ITEM_REMOVE_ERROR: error\n    }),\n\n    didCreateView: function didCreateView(root) {\n      applyFilters('CREATE_VIEW', Object.assign({}, root, { view: root }));\n    },\n    create: create$3,\n    mixins: {\n      styles: ['translateX', 'translateY', 'opacity'],\n      animations: {\n        opacity: { type: 'tween', duration: 250 },\n        translateX: 'spring',\n        translateY: 'spring'\n      }\n    }\n  });\n\n  /**\n   * Button definitions for the file view\n   */\n\n  var Buttons = {\n    AbortItemLoad: {\n      label: 'GET_LABEL_BUTTON_ABORT_ITEM_LOAD',\n      action: 'ABORT_ITEM_LOAD',\n      className: 'filepond--action-abort-item-load',\n      align: 'LOAD_INDICATOR_POSITION' // right\n    },\n    RetryItemLoad: {\n      label: 'GET_LABEL_BUTTON_RETRY_ITEM_LOAD',\n      action: 'RETRY_ITEM_LOAD',\n      icon: 'GET_ICON_RETRY',\n      className: 'filepond--action-retry-item-load',\n      align: 'BUTTON_PROCESS_ITEM_POSITION' // right\n    },\n    RemoveItem: {\n      label: 'GET_LABEL_BUTTON_REMOVE_ITEM',\n      action: 'REQUEST_REMOVE_ITEM',\n      icon: 'GET_ICON_REMOVE',\n      className: 'filepond--action-remove-item',\n      align: 'BUTTON_REMOVE_ITEM_POSITION' // left\n    },\n    ProcessItem: {\n      label: 'GET_LABEL_BUTTON_PROCESS_ITEM',\n      action: 'REQUEST_ITEM_PROCESSING',\n      icon: 'GET_ICON_PROCESS',\n      className: 'filepond--action-process-item',\n      align: 'BUTTON_PROCESS_ITEM_POSITION' // right\n    },\n    AbortItemProcessing: {\n      label: 'GET_LABEL_BUTTON_ABORT_ITEM_PROCESSING',\n      action: 'ABORT_ITEM_PROCESSING',\n      className: 'filepond--action-abort-item-processing',\n      align: 'BUTTON_PROCESS_ITEM_POSITION' // right\n    },\n    RetryItemProcessing: {\n      label: 'GET_LABEL_BUTTON_RETRY_ITEM_PROCESSING',\n      action: 'RETRY_ITEM_PROCESSING',\n      icon: 'GET_ICON_RETRY',\n      className: 'filepond--action-retry-item-processing',\n      align: 'BUTTON_PROCESS_ITEM_POSITION' // right\n    },\n    RevertItemProcessing: {\n      label: 'GET_LABEL_BUTTON_UNDO_ITEM_PROCESSING',\n      action: 'REQUEST_REVERT_ITEM_PROCESSING',\n      icon: 'GET_ICON_UNDO',\n      className: 'filepond--action-revert-item-processing',\n      align: 'BUTTON_PROCESS_ITEM_POSITION' // right\n    }\n  };\n\n  // make a list of buttons, we can then remove buttons from this list if they're disabled\n  var ButtonKeys = [];\n  forin(Buttons, function(key) {\n    ButtonKeys.push(key);\n  });\n\n  var calculateFileInfoOffset = function calculateFileInfoOffset(root) {\n    var buttonRect = root.ref.buttonRemoveItem.rect.element;\n    return buttonRect.hidden ? null : buttonRect.width + buttonRect.left;\n  };\n\n  var calculateButtonWidth = function calculateButtonWidth(root) {\n    var buttonRect = root.ref.buttonAbortItemLoad.rect.element;\n    return buttonRect.width;\n  };\n\n  // Force on full pixels so text stays crips\n  var calculateFileVerticalCenterOffset = function calculateFileVerticalCenterOffset(\n    root\n  ) {\n    return Math.floor(root.ref.buttonRemoveItem.rect.element.height / 4);\n  };\n  var calculateFileHorizontalCenterOffset = function calculateFileHorizontalCenterOffset(\n    root\n  ) {\n    return Math.floor(root.ref.buttonRemoveItem.rect.element.left / 2);\n  };\n\n  var getLoadIndicatorAlignment = function getLoadIndicatorAlignment(root) {\n    return root.query('GET_STYLE_LOAD_INDICATOR_POSITION');\n  };\n  var getProcessIndicatorAlignment = function getProcessIndicatorAlignment(\n    root\n  ) {\n    return root.query('GET_STYLE_PROGRESS_INDICATOR_POSITION');\n  };\n  var getRemoveIndicatorAligment = function getRemoveIndicatorAligment(root) {\n    return root.query('GET_STYLE_BUTTON_REMOVE_ITEM_POSITION');\n  };\n\n  var DefaultStyle = {\n    buttonAbortItemLoad: { opacity: 0 },\n    buttonRetryItemLoad: { opacity: 0 },\n    buttonRemoveItem: { opacity: 0 },\n    buttonProcessItem: { opacity: 0 },\n    buttonAbortItemProcessing: { opacity: 0 },\n    buttonRetryItemProcessing: { opacity: 0 },\n    buttonRevertItemProcessing: { opacity: 0 },\n    loadProgressIndicator: { opacity: 0, align: getLoadIndicatorAlignment },\n    processProgressIndicator: {\n      opacity: 0,\n      align: getProcessIndicatorAlignment\n    },\n    processingCompleteIndicator: { opacity: 0, scaleX: 0.75, scaleY: 0.75 },\n    info: { translateX: 0, translateY: 0, opacity: 0 },\n    status: { translateX: 0, translateY: 0, opacity: 0 }\n  };\n\n  var IdleStyle = {\n    buttonRemoveItem: { opacity: 1 },\n    buttonProcessItem: { opacity: 1 },\n    info: { translateX: calculateFileInfoOffset },\n    status: { translateX: calculateFileInfoOffset }\n  };\n\n  var ProcessingStyle = {\n    buttonAbortItemProcessing: { opacity: 1 },\n    processProgressIndicator: { opacity: 1 },\n    status: { opacity: 1 }\n  };\n\n  var StyleMap = {\n    DID_THROW_ITEM_INVALID: {\n      buttonRemoveItem: { opacity: 1 },\n      info: { translateX: calculateFileInfoOffset },\n      status: { translateX: calculateFileInfoOffset, opacity: 1 }\n    },\n\n    DID_START_ITEM_LOAD: {\n      buttonAbortItemLoad: { opacity: 1 },\n      loadProgressIndicator: { opacity: 1 },\n      status: { opacity: 1 }\n    },\n\n    DID_THROW_ITEM_LOAD_ERROR: {\n      buttonRetryItemLoad: { opacity: 1 },\n      buttonRemoveItem: { opacity: 1 },\n      info: { translateX: calculateFileInfoOffset },\n      status: { opacity: 1 }\n    },\n\n    DID_START_ITEM_REMOVE: {\n      processProgressIndicator: {\n        opacity: 1,\n        align: getRemoveIndicatorAligment\n      },\n      info: { translateX: calculateFileInfoOffset },\n      status: { opacity: 0 }\n    },\n\n    DID_THROW_ITEM_REMOVE_ERROR: {\n      processProgressIndicator: {\n        opacity: 0,\n        align: getRemoveIndicatorAligment\n      },\n      buttonRemoveItem: { opacity: 1 },\n      info: { translateX: calculateFileInfoOffset },\n      status: { opacity: 1, translateX: calculateFileInfoOffset }\n    },\n\n    DID_LOAD_ITEM: IdleStyle,\n    DID_LOAD_LOCAL_ITEM: {\n      buttonRemoveItem: { opacity: 1 },\n      info: { translateX: calculateFileInfoOffset },\n      status: { translateX: calculateFileInfoOffset }\n    },\n\n    DID_START_ITEM_PROCESSING: ProcessingStyle,\n    DID_REQUEST_ITEM_PROCESSING: ProcessingStyle,\n    DID_UPDATE_ITEM_PROCESS_PROGRESS: ProcessingStyle,\n    DID_COMPLETE_ITEM_PROCESSING: {\n      buttonRevertItemProcessing: { opacity: 1 },\n      info: { opacity: 1 },\n      status: { opacity: 1 }\n    },\n\n    DID_THROW_ITEM_PROCESSING_ERROR: {\n      buttonRemoveItem: { opacity: 1 },\n      buttonRetryItemProcessing: { opacity: 1 },\n      status: { opacity: 1 },\n      info: { translateX: calculateFileInfoOffset }\n    },\n\n    DID_THROW_ITEM_PROCESSING_REVERT_ERROR: {\n      buttonRevertItemProcessing: { opacity: 1 },\n      status: { opacity: 1 },\n      info: { opacity: 1 }\n    },\n\n    DID_ABORT_ITEM_PROCESSING: {\n      buttonRemoveItem: { opacity: 1 },\n      buttonProcessItem: { opacity: 1 },\n      info: { translateX: calculateFileInfoOffset },\n      status: { opacity: 1 }\n    },\n\n    DID_REVERT_ITEM_PROCESSING: IdleStyle\n  };\n\n  // complete indicator view\n  var processingCompleteIndicatorView = createView({\n    create: function create(_ref) {\n      var root = _ref.root;\n      root.element.innerHTML = root.query('GET_ICON_DONE');\n    },\n    name: 'processing-complete-indicator',\n    ignoreRect: true,\n    mixins: {\n      styles: ['scaleX', 'scaleY', 'opacity'],\n      animations: {\n        scaleX: 'spring',\n        scaleY: 'spring',\n        opacity: { type: 'tween', duration: 250 }\n      }\n    }\n  });\n\n  /**\n   * Creates the file view\n   */\n  var create$4 = function create(_ref2) {\n    var root = _ref2.root,\n      props = _ref2.props;\n    var id = props.id;\n\n    // allow reverting upload\n    var allowRevert = root.query('GET_ALLOW_REVERT');\n\n    // allow remove file\n    var allowRemove = root.query('GET_ALLOW_REMOVE');\n\n    // allow processing upload\n    var allowProcess = root.query('GET_ALLOW_PROCESS');\n\n    // is instant uploading, need this to determine the icon of the undo button\n    var instantUpload = root.query('GET_INSTANT_UPLOAD');\n\n    // is async set up\n    var isAsync = root.query('IS_ASYNC');\n\n    // should align remove item buttons\n    var alignRemoveItemButton = root.query(\n      'GET_STYLE_BUTTON_REMOVE_ITEM_ALIGN'\n    );\n\n    // enabled buttons array\n    var buttonFilter;\n    if (isAsync) {\n      if (allowProcess && !allowRevert) {\n        // only remove revert button\n        buttonFilter = function buttonFilter(key) {\n          return !/RevertItemProcessing/.test(key);\n        };\n      } else if (!allowProcess && allowRevert) {\n        // only remove process button\n        buttonFilter = function buttonFilter(key) {\n          return !/ProcessItem|RetryItemProcessing|AbortItemProcessing/.test(\n            key\n          );\n        };\n      } else if (!allowProcess && !allowRevert) {\n        // remove all process buttons\n        buttonFilter = function buttonFilter(key) {\n          return !/Process/.test(key);\n        };\n      }\n    } else {\n      // no process controls available\n      buttonFilter = function buttonFilter(key) {\n        return !/Process/.test(key);\n      };\n    }\n\n    var enabledButtons = buttonFilter\n      ? ButtonKeys.filter(buttonFilter)\n      : ButtonKeys.concat();\n\n    // update icon and label for revert button when instant uploading\n    if (instantUpload && allowRevert) {\n      Buttons['RevertItemProcessing'].label = 'GET_LABEL_BUTTON_REMOVE_ITEM';\n      Buttons['RevertItemProcessing'].icon = 'GET_ICON_REMOVE';\n    }\n\n    // remove last button (revert) if not allowed\n    if (isAsync && !allowRevert) {\n      var map = StyleMap['DID_COMPLETE_ITEM_PROCESSING'];\n      map.info.translateX = calculateFileHorizontalCenterOffset;\n      map.info.translateY = calculateFileVerticalCenterOffset;\n      map.status.translateY = calculateFileVerticalCenterOffset;\n      map.processingCompleteIndicator = { opacity: 1, scaleX: 1, scaleY: 1 };\n    }\n\n    // should align center\n    if (isAsync && !allowProcess) {\n      [\n        'DID_START_ITEM_PROCESSING',\n        'DID_REQUEST_ITEM_PROCESSING',\n        'DID_UPDATE_ITEM_PROCESS_PROGRESS',\n        'DID_THROW_ITEM_PROCESSING_ERROR'\n      ].forEach(function(key) {\n        StyleMap[key].status.translateY = calculateFileVerticalCenterOffset;\n      });\n      StyleMap[\n        'DID_THROW_ITEM_PROCESSING_ERROR'\n      ].status.translateX = calculateButtonWidth;\n    }\n\n    // move remove button to right\n    if (alignRemoveItemButton && allowRevert) {\n      Buttons['RevertItemProcessing'].align = 'BUTTON_REMOVE_ITEM_POSITION';\n      var _map = StyleMap['DID_COMPLETE_ITEM_PROCESSING'];\n      _map.info.translateX = calculateFileInfoOffset;\n      _map.status.translateY = calculateFileVerticalCenterOffset;\n      _map.processingCompleteIndicator = { opacity: 1, scaleX: 1, scaleY: 1 };\n    }\n\n    if (!allowRemove) {\n      Buttons['RemoveItem'].disabled = true;\n    }\n\n    // create the button views\n    forin(Buttons, function(key, definition) {\n      // create button\n      var buttonView = root.createChildView(fileActionButton, {\n        label: root.query(definition.label),\n        icon: root.query(definition.icon),\n        opacity: 0\n      });\n\n      // should be appended?\n      if (enabledButtons.includes(key)) {\n        root.appendChildView(buttonView);\n      }\n\n      // toggle\n      if (definition.disabled) {\n        buttonView.element.setAttribute('disabled', 'disabled');\n        buttonView.element.setAttribute('hidden', 'hidden');\n      }\n\n      // add position attribute\n      buttonView.element.dataset.align = root.query(\n        'GET_STYLE_' + definition.align\n      );\n\n      // add class\n      buttonView.element.classList.add(definition.className);\n\n      // handle interactions\n      buttonView.on('click', function(e) {\n        e.stopPropagation();\n        if (definition.disabled) return;\n        root.dispatch(definition.action, { query: id });\n      });\n\n      // set reference\n      root.ref['button' + key] = buttonView;\n    });\n\n    // checkmark\n    root.ref.processingCompleteIndicator = root.appendChildView(\n      root.createChildView(processingCompleteIndicatorView)\n    );\n    root.ref.processingCompleteIndicator.element.dataset.align = root.query(\n      'GET_STYLE_BUTTON_PROCESS_ITEM_POSITION'\n    );\n\n    // create file info view\n    root.ref.info = root.appendChildView(\n      root.createChildView(fileInfo, { id: id })\n    );\n\n    // create file status view\n    root.ref.status = root.appendChildView(\n      root.createChildView(fileStatus, { id: id })\n    );\n\n    // add progress indicators\n    var loadIndicatorView = root.appendChildView(\n      root.createChildView(progressIndicator, {\n        opacity: 0,\n        align: root.query('GET_STYLE_LOAD_INDICATOR_POSITION')\n      })\n    );\n\n    loadIndicatorView.element.classList.add('filepond--load-indicator');\n    root.ref.loadProgressIndicator = loadIndicatorView;\n\n    var progressIndicatorView = root.appendChildView(\n      root.createChildView(progressIndicator, {\n        opacity: 0,\n        align: root.query('GET_STYLE_PROGRESS_INDICATOR_POSITION')\n      })\n    );\n\n    progressIndicatorView.element.classList.add('filepond--process-indicator');\n    root.ref.processProgressIndicator = progressIndicatorView;\n\n    // current active styles\n    root.ref.activeStyles = [];\n  };\n\n  var write$2 = function write(_ref3) {\n    var root = _ref3.root,\n      actions = _ref3.actions,\n      props = _ref3.props;\n\n    // route actions\n    route({ root: root, actions: actions, props: props });\n\n    // select last state change action\n    var action = actions\n      .concat()\n      .filter(function(action) {\n        return /^DID_/.test(action.type);\n      })\n      .reverse()\n      .find(function(action) {\n        return StyleMap[action.type];\n      });\n\n    // a new action happened, let's get the matching styles\n    if (action) {\n      // define new active styles\n      root.ref.activeStyles = [];\n\n      var stylesToApply = StyleMap[action.type];\n      forin(DefaultStyle, function(name, defaultStyles) {\n        // get reference to control\n        var control = root.ref[name];\n\n        // loop over all styles for this control\n        forin(defaultStyles, function(key, defaultValue) {\n          var value =\n            stylesToApply[name] &&\n            typeof stylesToApply[name][key] !== 'undefined'\n              ? stylesToApply[name][key]\n              : defaultValue;\n          root.ref.activeStyles.push({\n            control: control,\n            key: key,\n            value: value\n          });\n        });\n      });\n    }\n\n    // apply active styles to element\n    root.ref.activeStyles.forEach(function(_ref4) {\n      var control = _ref4.control,\n        key = _ref4.key,\n        value = _ref4.value;\n      control[key] = typeof value === 'function' ? value(root) : value;\n    });\n  };\n\n  var route = createRoute({\n    DID_SET_LABEL_BUTTON_ABORT_ITEM_PROCESSING: function DID_SET_LABEL_BUTTON_ABORT_ITEM_PROCESSING(\n      _ref5\n    ) {\n      var root = _ref5.root,\n        action = _ref5.action;\n      root.ref.buttonAbortItemProcessing.label = action.value;\n    },\n    DID_SET_LABEL_BUTTON_ABORT_ITEM_LOAD: function DID_SET_LABEL_BUTTON_ABORT_ITEM_LOAD(\n      _ref6\n    ) {\n      var root = _ref6.root,\n        action = _ref6.action;\n      root.ref.buttonAbortItemLoad.label = action.value;\n    },\n    DID_SET_LABEL_BUTTON_ABORT_ITEM_REMOVAL: function DID_SET_LABEL_BUTTON_ABORT_ITEM_REMOVAL(\n      _ref7\n    ) {\n      var root = _ref7.root,\n        action = _ref7.action;\n      root.ref.buttonAbortItemRemoval.label = action.value;\n    },\n    DID_REQUEST_ITEM_PROCESSING: function DID_REQUEST_ITEM_PROCESSING(_ref8) {\n      var root = _ref8.root;\n      root.ref.processProgressIndicator.spin = true;\n      root.ref.processProgressIndicator.progress = 0;\n    },\n    DID_START_ITEM_LOAD: function DID_START_ITEM_LOAD(_ref9) {\n      var root = _ref9.root;\n      root.ref.loadProgressIndicator.spin = true;\n      root.ref.loadProgressIndicator.progress = 0;\n    },\n    DID_START_ITEM_REMOVE: function DID_START_ITEM_REMOVE(_ref10) {\n      var root = _ref10.root;\n      root.ref.processProgressIndicator.spin = true;\n      root.ref.processProgressIndicator.progress = 0;\n    },\n    DID_UPDATE_ITEM_LOAD_PROGRESS: function DID_UPDATE_ITEM_LOAD_PROGRESS(\n      _ref11\n    ) {\n      var root = _ref11.root,\n        action = _ref11.action;\n      root.ref.loadProgressIndicator.spin = false;\n      root.ref.loadProgressIndicator.progress = action.progress;\n    },\n    DID_UPDATE_ITEM_PROCESS_PROGRESS: function DID_UPDATE_ITEM_PROCESS_PROGRESS(\n      _ref12\n    ) {\n      var root = _ref12.root,\n        action = _ref12.action;\n      root.ref.processProgressIndicator.spin = false;\n      root.ref.processProgressIndicator.progress = action.progress;\n    }\n  });\n\n  var file = createView({\n    create: create$4,\n    write: write$2,\n    didCreateView: function didCreateView(root) {\n      applyFilters('CREATE_VIEW', Object.assign({}, root, { view: root }));\n    },\n    name: 'file'\n  });\n\n  /**\n   * Creates the file view\n   */\n  var create$5 = function create(_ref) {\n    var root = _ref.root,\n      props = _ref.props;\n\n    // filename\n    root.ref.fileName = createElement$1('legend');\n    root.appendChild(root.ref.fileName);\n\n    // file appended\n    root.ref.file = root.appendChildView(\n      root.createChildView(file, { id: props.id })\n    );\n\n    // data has moved to data.js\n    root.ref.data = false;\n  };\n\n  /**\n   * Data storage\n   */\n  var didLoadItem = function didLoadItem(_ref2) {\n    var root = _ref2.root,\n      props = _ref2.props;\n    // updates the legend of the fieldset so screenreaders can better group buttons\n    text(\n      root.ref.fileName,\n      formatFilename(root.query('GET_ITEM_NAME', props.id))\n    );\n  };\n\n  var fileWrapper = createView({\n    create: create$5,\n    ignoreRect: true,\n    write: createRoute({\n      DID_LOAD_ITEM: didLoadItem\n    }),\n\n    didCreateView: function didCreateView(root) {\n      applyFilters('CREATE_VIEW', Object.assign({}, root, { view: root }));\n    },\n    tag: 'fieldset',\n    name: 'file-wrapper'\n  });\n\n  var PANEL_SPRING_PROPS = { type: 'spring', damping: 0.6, mass: 7 };\n\n  var create$6 = function create(_ref) {\n    var root = _ref.root,\n      props = _ref.props;\n    [\n      {\n        name: 'top'\n      },\n\n      {\n        name: 'center',\n        props: {\n          translateY: null,\n          scaleY: null\n        },\n\n        mixins: {\n          animations: {\n            scaleY: PANEL_SPRING_PROPS\n          },\n\n          styles: ['translateY', 'scaleY']\n        }\n      },\n\n      {\n        name: 'bottom',\n        props: {\n          translateY: null\n        },\n\n        mixins: {\n          animations: {\n            translateY: PANEL_SPRING_PROPS\n          },\n\n          styles: ['translateY']\n        }\n      }\n    ].forEach(function(section) {\n      createSection(root, section, props.name);\n    });\n\n    root.element.classList.add('filepond--' + props.name);\n\n    root.ref.scalable = null;\n  };\n\n  var createSection = function createSection(root, section, className) {\n    var viewConstructor = createView({\n      name: 'panel-' + section.name + ' filepond--' + className,\n      mixins: section.mixins,\n      ignoreRectUpdate: true\n    });\n\n    var view = root.createChildView(viewConstructor, section.props);\n\n    root.ref[section.name] = root.appendChildView(view);\n  };\n\n  var write$3 = function write(_ref2) {\n    var root = _ref2.root,\n      props = _ref2.props;\n\n    // update scalable state\n    if (root.ref.scalable === null || props.scalable !== root.ref.scalable) {\n      root.ref.scalable = isBoolean(props.scalable) ? props.scalable : true;\n      root.element.dataset.scalable = root.ref.scalable;\n    }\n\n    // no height, can't set\n    if (!props.height) return;\n\n    // get child rects\n    var topRect = root.ref.top.rect.element;\n    var bottomRect = root.ref.bottom.rect.element;\n\n    // make sure height never is smaller than bottom and top seciton heights combined (will probably never happen, but who knows)\n    var height = Math.max(topRect.height + bottomRect.height, props.height);\n\n    // offset center part\n    root.ref.center.translateY = topRect.height;\n\n    // scale center part\n    // use math ceil to prevent transparent lines because of rounding errors\n    root.ref.center.scaleY =\n      (height - topRect.height - bottomRect.height) / 100;\n\n    // offset bottom part\n    root.ref.bottom.translateY = height - bottomRect.height;\n  };\n\n  var panel = createView({\n    name: 'panel',\n    read: function read(_ref3) {\n      var root = _ref3.root,\n        props = _ref3.props;\n      return (props.heightCurrent = root.ref.bottom.translateY);\n    },\n    write: write$3,\n    create: create$6,\n    ignoreRect: true,\n    mixins: {\n      apis: ['height', 'heightCurrent', 'scalable']\n    }\n  });\n\n  var createDragHelper = function createDragHelper(items) {\n    var itemIds = items.map(function(item) {\n      return item.id;\n    });\n    var prevIndex = undefined;\n    return {\n      setIndex: function setIndex(index) {\n        prevIndex = index;\n      },\n      getIndex: function getIndex() {\n        return prevIndex;\n      },\n      getItemIndex: function getItemIndex(item) {\n        return itemIds.indexOf(item.id);\n      }\n    };\n  };\n\n  var ITEM_TRANSLATE_SPRING = {\n    type: 'spring',\n    stiffness: 0.75,\n    damping: 0.45,\n    mass: 10\n  };\n\n  var ITEM_SCALE_SPRING = 'spring';\n\n  var StateMap = {\n    DID_START_ITEM_LOAD: 'busy',\n    DID_UPDATE_ITEM_LOAD_PROGRESS: 'loading',\n    DID_THROW_ITEM_INVALID: 'load-invalid',\n    DID_THROW_ITEM_LOAD_ERROR: 'load-error',\n    DID_LOAD_ITEM: 'idle',\n    DID_THROW_ITEM_REMOVE_ERROR: 'remove-error',\n    DID_START_ITEM_REMOVE: 'busy',\n    DID_START_ITEM_PROCESSING: 'busy processing',\n    DID_REQUEST_ITEM_PROCESSING: 'busy processing',\n    DID_UPDATE_ITEM_PROCESS_PROGRESS: 'processing',\n    DID_COMPLETE_ITEM_PROCESSING: 'processing-complete',\n    DID_THROW_ITEM_PROCESSING_ERROR: 'processing-error',\n    DID_THROW_ITEM_PROCESSING_REVERT_ERROR: 'processing-revert-error',\n    DID_ABORT_ITEM_PROCESSING: 'cancelled',\n    DID_REVERT_ITEM_PROCESSING: 'idle'\n  };\n\n  /**\n   * Creates the file view\n   */\n  var create$7 = function create(_ref) {\n    var root = _ref.root,\n      props = _ref.props;\n\n    // select\n    root.ref.handleClick = function(e) {\n      return root.dispatch('DID_ACTIVATE_ITEM', { id: props.id });\n    };\n\n    // set id\n    root.element.id = 'filepond--item-' + props.id;\n    root.element.addEventListener('click', root.ref.handleClick);\n\n    // file view\n    root.ref.container = root.appendChildView(\n      root.createChildView(fileWrapper, { id: props.id })\n    );\n\n    // file panel\n    root.ref.panel = root.appendChildView(\n      root.createChildView(panel, { name: 'item-panel' })\n    );\n\n    // default start height\n    root.ref.panel.height = null;\n\n    // by default not marked for removal\n    props.markedForRemoval = false;\n\n    // if not allowed to reorder file items, exit here\n    if (!root.query('GET_ALLOW_REORDER')) return;\n\n    // set to idle so shows grab cursor\n    root.element.dataset.dragState = 'idle';\n\n    var grab = function grab(e) {\n      if (!e.isPrimary) return;\n\n      var removedActivateListener = false;\n\n      var origin = {\n        x: e.pageX,\n        y: e.pageY\n      };\n\n      props.dragOrigin = {\n        x: root.translateX,\n        y: root.translateY\n      };\n\n      props.dragCenter = {\n        x: e.offsetX,\n        y: e.offsetY\n      };\n\n      var dragState = createDragHelper(root.query('GET_ACTIVE_ITEMS'));\n\n      root.dispatch('DID_GRAB_ITEM', { id: props.id, dragState: dragState });\n\n      var drag = function drag(e) {\n        if (!e.isPrimary) return;\n\n        e.stopPropagation();\n        e.preventDefault();\n\n        props.dragOffset = {\n          x: e.pageX - origin.x,\n          y: e.pageY - origin.y\n        };\n\n        // if dragged stop listening to clicks, will re-add when done dragging\n        var dist =\n          props.dragOffset.x * props.dragOffset.x +\n          props.dragOffset.y * props.dragOffset.y;\n        if (dist > 16 && !removedActivateListener) {\n          removedActivateListener = true;\n          root.element.removeEventListener('click', root.ref.handleClick);\n        }\n\n        root.dispatch('DID_DRAG_ITEM', { id: props.id, dragState: dragState });\n      };\n\n      var drop = function drop(e) {\n        if (!e.isPrimary) return;\n\n        document.removeEventListener('pointermove', drag);\n        document.removeEventListener('pointerup', drop);\n\n        props.dragOffset = {\n          x: e.pageX - origin.x,\n          y: e.pageY - origin.y\n        };\n\n        root.dispatch('DID_DROP_ITEM', { id: props.id, dragState: dragState });\n\n        // start listening to clicks again\n        if (removedActivateListener) {\n          setTimeout(function() {\n            return root.element.addEventListener('click', root.ref.handleClick);\n          }, 0);\n        }\n      };\n\n      document.addEventListener('pointermove', drag);\n      document.addEventListener('pointerup', drop);\n    };\n\n    root.element.addEventListener('pointerdown', grab);\n  };\n\n  var route$1 = createRoute({\n    DID_UPDATE_PANEL_HEIGHT: function DID_UPDATE_PANEL_HEIGHT(_ref2) {\n      var root = _ref2.root,\n        action = _ref2.action;\n      root.height = action.height;\n    }\n  });\n\n  var write$4 = createRoute(\n    {\n      DID_GRAB_ITEM: function DID_GRAB_ITEM(_ref3) {\n        var root = _ref3.root,\n          props = _ref3.props;\n        props.dragOrigin = {\n          x: root.translateX,\n          y: root.translateY\n        };\n      },\n      DID_DRAG_ITEM: function DID_DRAG_ITEM(_ref4) {\n        var root = _ref4.root;\n        root.element.dataset.dragState = 'drag';\n      },\n      DID_DROP_ITEM: function DID_DROP_ITEM(_ref5) {\n        var root = _ref5.root,\n          props = _ref5.props;\n        props.dragOffset = null;\n        props.dragOrigin = null;\n        root.element.dataset.dragState = 'drop';\n      }\n    },\n    function(_ref6) {\n      var root = _ref6.root,\n        actions = _ref6.actions,\n        props = _ref6.props,\n        shouldOptimize = _ref6.shouldOptimize;\n\n      if (root.element.dataset.dragState === 'drop') {\n        if (root.scaleX <= 1) {\n          root.element.dataset.dragState = 'idle';\n        }\n      }\n\n      // select last state change action\n      var action = actions\n        .concat()\n        .filter(function(action) {\n          return /^DID_/.test(action.type);\n        })\n        .reverse()\n        .find(function(action) {\n          return StateMap[action.type];\n        });\n\n      // no need to set same state twice\n      if (action && action.type !== props.currentState) {\n        // set current state\n        props.currentState = action.type;\n\n        // set state\n        root.element.dataset.filepondItemState =\n          StateMap[props.currentState] || '';\n      }\n\n      // route actions\n      var aspectRatio =\n        root.query('GET_ITEM_PANEL_ASPECT_RATIO') ||\n        root.query('GET_PANEL_ASPECT_RATIO');\n      if (!aspectRatio) {\n        route$1({ root: root, actions: actions, props: props });\n        if (!root.height && root.ref.container.rect.element.height > 0) {\n          root.height = root.ref.container.rect.element.height;\n        }\n      } else if (!shouldOptimize) {\n        root.height = root.rect.element.width * aspectRatio;\n      }\n\n      // sync panel height with item height\n      if (shouldOptimize) {\n        root.ref.panel.height = null;\n      }\n\n      root.ref.panel.height = root.height;\n    }\n  );\n\n  var item = createView({\n    create: create$7,\n    write: write$4,\n    destroy: function destroy(_ref7) {\n      var root = _ref7.root,\n        props = _ref7.props;\n      root.element.removeEventListener('click', root.ref.handleClick);\n      root.dispatch('RELEASE_ITEM', { query: props.id });\n    },\n    tag: 'li',\n    name: 'item',\n    mixins: {\n      apis: [\n        'id',\n        'interactionMethod',\n        'markedForRemoval',\n        'spawnDate',\n        'dragCenter',\n        'dragOrigin',\n        'dragOffset'\n      ],\n      styles: [\n        'translateX',\n        'translateY',\n        'scaleX',\n        'scaleY',\n        'opacity',\n        'height'\n      ],\n\n      animations: {\n        scaleX: ITEM_SCALE_SPRING,\n        scaleY: ITEM_SCALE_SPRING,\n        translateX: ITEM_TRANSLATE_SPRING,\n        translateY: ITEM_TRANSLATE_SPRING,\n        opacity: { type: 'tween', duration: 150 }\n      }\n    }\n  });\n\n  var getItemIndexByPosition = function getItemIndexByPosition(\n    view,\n    children,\n    positionInView\n  ) {\n    if (!positionInView) return;\n\n    var horizontalSpace = view.rect.element.width;\n    // const children = view.childViews;\n    var l = children.length;\n    var last = null;\n\n    // -1, don't move items to accomodate (either add to top or bottom)\n    if (l === 0 || positionInView.top < children[0].rect.element.top) return -1;\n\n    // let's get the item width\n    var item = children[0];\n    var itemRect = item.rect.element;\n    var itemHorizontalMargin = itemRect.marginLeft + itemRect.marginRight;\n    var itemWidth = itemRect.width + itemHorizontalMargin;\n    var itemsPerRow = Math.round(horizontalSpace / itemWidth);\n\n    // stack\n    if (itemsPerRow === 1) {\n      for (var index = 0; index < l; index++) {\n        var child = children[index];\n        var childMid = child.rect.outer.top + child.rect.element.height * 0.5;\n        if (positionInView.top < childMid) {\n          return index;\n        }\n      }\n      return l;\n    }\n\n    // grid\n    var itemVerticalMargin = itemRect.marginTop + itemRect.marginBottom;\n    var itemHeight = itemRect.height + itemVerticalMargin;\n    for (var _index = 0; _index < l; _index++) {\n      var indexX = _index % itemsPerRow;\n      var indexY = Math.floor(_index / itemsPerRow);\n\n      var offsetX = indexX * itemWidth;\n      var offsetY = indexY * itemHeight;\n\n      var itemTop = offsetY - itemRect.marginTop;\n      var itemRight = offsetX + itemWidth;\n      var itemBottom = offsetY + itemHeight + itemRect.marginBottom;\n\n      if (positionInView.top < itemBottom && positionInView.top > itemTop) {\n        if (positionInView.left < itemRight) {\n          return _index;\n        } else if (_index !== l - 1) {\n          last = _index;\n        } else {\n          last = null;\n        }\n      }\n    }\n\n    if (last !== null) {\n      return last;\n    }\n\n    return l;\n  };\n\n  var dropAreaDimensions = {\n    height: 0,\n    width: 0,\n    get getHeight() {\n      return this.height;\n    },\n    set setHeight(val) {\n      if (this.height === 0 || val === 0) this.height = val;\n    },\n    get getWidth() {\n      return this.width;\n    },\n    set setWidth(val) {\n      if (this.width === 0 || val === 0) this.width = val;\n    },\n    setDimensions: function setDimensions(height, width) {\n      if (this.height === 0 || height === 0) this.height = height;\n      if (this.width === 0 || width === 0) this.width = width;\n    }\n  };\n\n  var create$8 = function create(_ref) {\n    var root = _ref.root;\n    // need to set role to list as otherwise it won't be read as a list by VoiceOver\n    attr(root.element, 'role', 'list');\n\n    root.ref.lastItemSpanwDate = Date.now();\n  };\n\n  /**\n   * Inserts a new item\n   * @param root\n   * @param action\n   */\n  var addItemView = function addItemView(_ref2) {\n    var root = _ref2.root,\n      action = _ref2.action;\n    var id = action.id,\n      index = action.index,\n      interactionMethod = action.interactionMethod;\n\n    root.ref.addIndex = index;\n\n    var now = Date.now();\n    var spawnDate = now;\n    var opacity = 1;\n\n    if (interactionMethod !== InteractionMethod.NONE) {\n      opacity = 0;\n      var cooldown = root.query('GET_ITEM_INSERT_INTERVAL');\n      var dist = now - root.ref.lastItemSpanwDate;\n      spawnDate = dist < cooldown ? now + (cooldown - dist) : now;\n    }\n\n    root.ref.lastItemSpanwDate = spawnDate;\n\n    root.appendChildView(\n      root.createChildView(\n        // view type\n        item,\n\n        // props\n        {\n          spawnDate: spawnDate,\n          id: id,\n          opacity: opacity,\n          interactionMethod: interactionMethod\n        }\n      ),\n\n      index\n    );\n  };\n\n  var moveItem = function moveItem(item, x, y) {\n    var vx =\n      arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n    var vy =\n      arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;\n\n    // set to null to remove animation while dragging\n    if (item.dragOffset) {\n      item.translateX = null;\n      item.translateY = null;\n      item.translateX = item.dragOrigin.x + item.dragOffset.x;\n      item.translateY = item.dragOrigin.y + item.dragOffset.y;\n      item.scaleX = 1.025;\n      item.scaleY = 1.025;\n    } else {\n      item.translateX = x;\n      item.translateY = y;\n\n      if (Date.now() > item.spawnDate) {\n        // reveal element\n        if (item.opacity === 0) {\n          introItemView(item, x, y, vx, vy);\n        }\n\n        // make sure is default scale every frame\n        item.scaleX = 1;\n        item.scaleY = 1;\n        item.opacity = 1;\n      }\n    }\n  };\n\n  var introItemView = function introItemView(item, x, y, vx, vy) {\n    if (item.interactionMethod === InteractionMethod.NONE) {\n      item.translateX = null;\n      item.translateX = x;\n      item.translateY = null;\n      item.translateY = y;\n    } else if (item.interactionMethod === InteractionMethod.DROP) {\n      item.translateX = null;\n      item.translateX = x - vx * 20;\n\n      item.translateY = null;\n      item.translateY = y - vy * 10;\n\n      item.scaleX = 0.8;\n      item.scaleY = 0.8;\n    } else if (item.interactionMethod === InteractionMethod.BROWSE) {\n      item.translateY = null;\n      item.translateY = y - 30;\n    } else if (item.interactionMethod === InteractionMethod.API) {\n      item.translateX = null;\n      item.translateX = x - 30;\n      item.translateY = null;\n    }\n  };\n\n  /**\n   * Removes an existing item\n   * @param root\n   * @param action\n   */\n  var removeItemView = function removeItemView(_ref3) {\n    var root = _ref3.root,\n      action = _ref3.action;\n    var id = action.id;\n\n    // get the view matching the given id\n    var view = root.childViews.find(function(child) {\n      return child.id === id;\n    });\n\n    // if no view found, exit\n    if (!view) {\n      return;\n    }\n\n    // animate view out of view\n    view.scaleX = 0.9;\n    view.scaleY = 0.9;\n    view.opacity = 0;\n\n    // mark for removal\n    view.markedForRemoval = true;\n  };\n\n  var getItemHeight = function getItemHeight(child) {\n    return (\n      child.rect.element.height +\n      child.rect.element.marginBottom * 0.5 +\n      child.rect.element.marginTop * 0.5\n    );\n  };\n  var getItemWidth = function getItemWidth(child) {\n    return (\n      child.rect.element.width +\n      child.rect.element.marginLeft * 0.5 +\n      child.rect.element.marginRight * 0.5\n    );\n  };\n\n  var dragItem = function dragItem(_ref4) {\n    var root = _ref4.root,\n      action = _ref4.action;\n    var id = action.id,\n      dragState = action.dragState;\n\n    // reference to item\n    var item = root.query('GET_ITEM', { id: id });\n\n    // get the view matching the given id\n    var view = root.childViews.find(function(child) {\n      return child.id === id;\n    });\n\n    var numItems = root.childViews.length;\n    var oldIndex = dragState.getItemIndex(item);\n\n    // if no view found, exit\n    if (!view) return;\n\n    var dragPosition = {\n      x: view.dragOrigin.x + view.dragOffset.x + view.dragCenter.x,\n      y: view.dragOrigin.y + view.dragOffset.y + view.dragCenter.y\n\n      // get drag area dimensions\n    };\n    var dragHeight = getItemHeight(view);\n    var dragWidth = getItemWidth(view);\n\n    // get rows and columns (There will always be at least one row and one column if a file is present)\n    var cols = Math.floor(root.rect.outer.width / dragWidth);\n    if (cols > numItems) cols = numItems;\n\n    // rows are used to find when we have left the preview area bounding box\n    var rows = Math.floor(numItems / cols + 1);\n\n    dropAreaDimensions.setHeight = dragHeight * rows;\n    dropAreaDimensions.setWidth = dragWidth * cols;\n\n    // get new index of dragged item\n    var location = {\n      y: Math.floor(dragPosition.y / dragHeight),\n      x: Math.floor(dragPosition.x / dragWidth),\n      getGridIndex: function getGridIndex() {\n        if (\n          dragPosition.y > dropAreaDimensions.getHeight ||\n          dragPosition.y < 0 ||\n          dragPosition.x > dropAreaDimensions.getWidth ||\n          dragPosition.x < 0\n        )\n          return oldIndex;\n        return this.y * cols + this.x;\n      },\n      getColIndex: function getColIndex() {\n        var items = root.query('GET_ACTIVE_ITEMS');\n        var visibleChildren = root.childViews.filter(function(child) {\n          return child.rect.element.height;\n        });\n        var children = items.map(function(item) {\n          return visibleChildren.find(function(childView) {\n            return childView.id === item.id;\n          });\n        });\n        var currentIndex = children.findIndex(function(child) {\n          return child === view;\n        });\n        var dragHeight = getItemHeight(view);\n        var l = children.length;\n        var idx = l;\n        var childHeight = 0;\n        var childBottom = 0;\n        var childTop = 0;\n        for (var i = 0; i < l; i++) {\n          childHeight = getItemHeight(children[i]);\n          childTop = childBottom;\n          childBottom = childTop + childHeight;\n          if (dragPosition.y < childBottom) {\n            if (currentIndex > i) {\n              if (dragPosition.y < childTop + dragHeight) {\n                idx = i;\n                break;\n              }\n              continue;\n            }\n            idx = i;\n            break;\n          }\n        }\n        return idx;\n      }\n\n      // get new index\n    };\n    var index = cols > 1 ? location.getGridIndex() : location.getColIndex();\n    root.dispatch('MOVE_ITEM', { query: view, index: index });\n\n    // if the index of the item changed, dispatch reorder action\n    var currentIndex = dragState.getIndex();\n\n    if (currentIndex === undefined || currentIndex !== index) {\n      dragState.setIndex(index);\n\n      if (currentIndex === undefined) return;\n\n      root.dispatch('DID_REORDER_ITEMS', {\n        items: root.query('GET_ACTIVE_ITEMS'),\n        origin: oldIndex,\n        target: index\n      });\n    }\n  };\n\n  /**\n   * Setup action routes\n   */\n  var route$2 = createRoute({\n    DID_ADD_ITEM: addItemView,\n    DID_REMOVE_ITEM: removeItemView,\n    DID_DRAG_ITEM: dragItem\n  });\n\n  /**\n   * Write to view\n   * @param root\n   * @param actions\n   * @param props\n   */\n  var write$5 = function write(_ref5) {\n    var root = _ref5.root,\n      props = _ref5.props,\n      actions = _ref5.actions,\n      shouldOptimize = _ref5.shouldOptimize;\n\n    // route actions\n    route$2({ root: root, props: props, actions: actions });\n    var dragCoordinates = props.dragCoordinates;\n\n    // available space on horizontal axis\n    var horizontalSpace = root.rect.element.width;\n\n    // only draw children that have dimensions\n    var visibleChildren = root.childViews.filter(function(child) {\n      return child.rect.element.height;\n    });\n\n    // sort based on current active items\n    var children = root\n      .query('GET_ACTIVE_ITEMS')\n      .map(function(item) {\n        return visibleChildren.find(function(child) {\n          return child.id === item.id;\n        });\n      })\n      .filter(function(item) {\n        return item;\n      });\n\n    // get index\n    var dragIndex = dragCoordinates\n      ? getItemIndexByPosition(root, children, dragCoordinates)\n      : null;\n\n    // add index is used to reserve the dropped/added item index till the actual item is rendered\n    var addIndex = root.ref.addIndex || null;\n\n    // add index no longer needed till possibly next draw\n    root.ref.addIndex = null;\n\n    var dragIndexOffset = 0;\n    var removeIndexOffset = 0;\n    var addIndexOffset = 0;\n\n    if (children.length === 0) return;\n\n    var childRect = children[0].rect.element;\n    var itemVerticalMargin = childRect.marginTop + childRect.marginBottom;\n    var itemHorizontalMargin = childRect.marginLeft + childRect.marginRight;\n    var itemWidth = childRect.width + itemHorizontalMargin;\n    var itemHeight = childRect.height + itemVerticalMargin;\n    var itemsPerRow = Math.round(horizontalSpace / itemWidth);\n\n    // stack\n    if (itemsPerRow === 1) {\n      var offsetY = 0;\n      var dragOffset = 0;\n\n      children.forEach(function(child, index) {\n        if (dragIndex) {\n          var dist = index - dragIndex;\n          if (dist === -2) {\n            dragOffset = -itemVerticalMargin * 0.25;\n          } else if (dist === -1) {\n            dragOffset = -itemVerticalMargin * 0.75;\n          } else if (dist === 0) {\n            dragOffset = itemVerticalMargin * 0.75;\n          } else if (dist === 1) {\n            dragOffset = itemVerticalMargin * 0.25;\n          } else {\n            dragOffset = 0;\n          }\n        }\n\n        if (shouldOptimize) {\n          child.translateX = null;\n          child.translateY = null;\n        }\n\n        if (!child.markedForRemoval) {\n          moveItem(child, 0, offsetY + dragOffset);\n        }\n\n        var itemHeight = child.rect.element.height + itemVerticalMargin;\n\n        var visualHeight =\n          itemHeight * (child.markedForRemoval ? child.opacity : 1);\n\n        offsetY += visualHeight;\n      });\n    }\n    // grid\n    else {\n      var prevX = 0;\n      var prevY = 0;\n\n      children.forEach(function(child, index) {\n        if (index === dragIndex) {\n          dragIndexOffset = 1;\n        }\n\n        if (index === addIndex) {\n          addIndexOffset += 1;\n        }\n\n        if (child.markedForRemoval && child.opacity < 0.5) {\n          removeIndexOffset -= 1;\n        }\n\n        var visualIndex =\n          index + addIndexOffset + dragIndexOffset + removeIndexOffset;\n\n        var indexX = visualIndex % itemsPerRow;\n        var indexY = Math.floor(visualIndex / itemsPerRow);\n\n        var offsetX = indexX * itemWidth;\n        var offsetY = indexY * itemHeight;\n\n        var vectorX = Math.sign(offsetX - prevX);\n        var vectorY = Math.sign(offsetY - prevY);\n\n        prevX = offsetX;\n        prevY = offsetY;\n\n        if (child.markedForRemoval) return;\n\n        if (shouldOptimize) {\n          child.translateX = null;\n          child.translateY = null;\n        }\n\n        moveItem(child, offsetX, offsetY, vectorX, vectorY);\n      });\n    }\n  };\n\n  /**\n   * Filters actions that are meant specifically for a certain child of the list\n   * @param child\n   * @param actions\n   */\n  var filterSetItemActions = function filterSetItemActions(child, actions) {\n    return actions.filter(function(action) {\n      // if action has an id, filter out actions that don't have this child id\n      if (action.data && action.data.id) {\n        return child.id === action.data.id;\n      }\n\n      // allow all other actions\n      return true;\n    });\n  };\n\n  var list = createView({\n    create: create$8,\n    write: write$5,\n    tag: 'ul',\n    name: 'list',\n    didWriteView: function didWriteView(_ref6) {\n      var root = _ref6.root;\n      root.childViews\n        .filter(function(view) {\n          return view.markedForRemoval && view.opacity === 0 && view.resting;\n        })\n        .forEach(function(view) {\n          view._destroy();\n          root.removeChildView(view);\n        });\n    },\n    filterFrameActionsForChild: filterSetItemActions,\n    mixins: {\n      apis: ['dragCoordinates']\n    }\n  });\n\n  var create$9 = function create(_ref) {\n    var root = _ref.root,\n      props = _ref.props;\n    root.ref.list = root.appendChildView(root.createChildView(list));\n    props.dragCoordinates = null;\n    props.overflowing = false;\n  };\n\n  var storeDragCoordinates = function storeDragCoordinates(_ref2) {\n    var root = _ref2.root,\n      props = _ref2.props,\n      action = _ref2.action;\n    if (!root.query('GET_ITEM_INSERT_LOCATION_FREEDOM')) return;\n    props.dragCoordinates = {\n      left: action.position.scopeLeft - root.ref.list.rect.element.left,\n      top:\n        action.position.scopeTop -\n        (root.rect.outer.top +\n          root.rect.element.marginTop +\n          root.rect.element.scrollTop)\n    };\n  };\n\n  var clearDragCoordinates = function clearDragCoordinates(_ref3) {\n    var props = _ref3.props;\n    props.dragCoordinates = null;\n  };\n\n  var route$3 = createRoute({\n    DID_DRAG: storeDragCoordinates,\n    DID_END_DRAG: clearDragCoordinates\n  });\n\n  var write$6 = function write(_ref4) {\n    var root = _ref4.root,\n      props = _ref4.props,\n      actions = _ref4.actions;\n\n    // route actions\n    route$3({ root: root, props: props, actions: actions });\n\n    // current drag position\n    root.ref.list.dragCoordinates = props.dragCoordinates;\n\n    // if currently overflowing but no longer received overflow\n    if (props.overflowing && !props.overflow) {\n      props.overflowing = false;\n\n      // reset overflow state\n      root.element.dataset.state = '';\n      root.height = null;\n    }\n\n    // if is not overflowing currently but does receive overflow value\n    if (props.overflow) {\n      var newHeight = Math.round(props.overflow);\n      if (newHeight !== root.height) {\n        props.overflowing = true;\n        root.element.dataset.state = 'overflow';\n        root.height = newHeight;\n      }\n    }\n  };\n\n  var listScroller = createView({\n    create: create$9,\n    write: write$6,\n    name: 'list-scroller',\n    mixins: {\n      apis: ['overflow', 'dragCoordinates'],\n      styles: ['height', 'translateY'],\n      animations: {\n        translateY: 'spring'\n      }\n    }\n  });\n\n  var attrToggle = function attrToggle(element, name, state) {\n    var enabledValue =\n      arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';\n    if (state) {\n      attr(element, name, enabledValue);\n    } else {\n      element.removeAttribute(name);\n    }\n  };\n\n  var resetFileInput = function resetFileInput(input) {\n    // no value, no need to reset\n    if (!input || input.value === '') {\n      return;\n    }\n\n    try {\n      // for modern browsers\n      input.value = '';\n    } catch (err) {}\n\n    // for IE10\n    if (input.value) {\n      // quickly append input to temp form and reset form\n      var form = createElement$1('form');\n      var parentNode = input.parentNode;\n      var ref = input.nextSibling;\n      form.appendChild(input);\n      form.reset();\n\n      // re-inject input where it originally was\n      if (ref) {\n        parentNode.insertBefore(input, ref);\n      } else {\n        parentNode.appendChild(input);\n      }\n    }\n  };\n\n  var create$a = function create(_ref) {\n    var root = _ref.root,\n      props = _ref.props;\n\n    // set id so can be referenced from outside labels\n    root.element.id = 'filepond--browser-' + props.id;\n\n    // set name of element (is removed when a value is set)\n    attr(root.element, 'name', root.query('GET_NAME'));\n\n    // we have to link this element to the status element\n    attr(root.element, 'aria-controls', 'filepond--assistant-' + props.id);\n\n    // set label, we use labelled by as otherwise the screenreader does not read the \"browse\" text in the label (as it has tabindex: 0)\n    attr(root.element, 'aria-labelledby', 'filepond--drop-label-' + props.id);\n\n    // set configurable props\n    setAcceptedFileTypes({\n      root: root,\n      action: { value: root.query('GET_ACCEPTED_FILE_TYPES') }\n    });\n    toggleAllowMultiple({\n      root: root,\n      action: { value: root.query('GET_ALLOW_MULTIPLE') }\n    });\n    toggleDirectoryFilter({\n      root: root,\n      action: { value: root.query('GET_ALLOW_DIRECTORIES_ONLY') }\n    });\n    toggleDisabled({ root: root });\n    toggleRequired({\n      root: root,\n      action: { value: root.query('GET_REQUIRED') }\n    });\n    setCaptureMethod({\n      root: root,\n      action: { value: root.query('GET_CAPTURE_METHOD') }\n    });\n\n    // handle changes to the input field\n    root.ref.handleChange = function(e) {\n      if (!root.element.value) {\n        return;\n      }\n\n      // extract files and move value of webkitRelativePath path to _relativePath\n      var files = Array.from(root.element.files).map(function(file) {\n        file._relativePath = file.webkitRelativePath;\n        return file;\n      });\n\n      // we add a little delay so the OS file select window can move out of the way before we add our file\n      setTimeout(function() {\n        // load files\n        props.onload(files);\n\n        // reset input, it's just for exposing a method to drop files, should not retain any state\n        resetFileInput(root.element);\n      }, 250);\n    };\n\n    root.element.addEventListener('change', root.ref.handleChange);\n  };\n\n  var setAcceptedFileTypes = function setAcceptedFileTypes(_ref2) {\n    var root = _ref2.root,\n      action = _ref2.action;\n    if (!root.query('GET_ALLOW_SYNC_ACCEPT_ATTRIBUTE')) return;\n    attrToggle(\n      root.element,\n      'accept',\n      !!action.value,\n      action.value ? action.value.join(',') : ''\n    );\n  };\n\n  var toggleAllowMultiple = function toggleAllowMultiple(_ref3) {\n    var root = _ref3.root,\n      action = _ref3.action;\n    attrToggle(root.element, 'multiple', action.value);\n  };\n\n  var toggleDirectoryFilter = function toggleDirectoryFilter(_ref4) {\n    var root = _ref4.root,\n      action = _ref4.action;\n    attrToggle(root.element, 'webkitdirectory', action.value);\n  };\n\n  var toggleDisabled = function toggleDisabled(_ref5) {\n    var root = _ref5.root;\n    var isDisabled = root.query('GET_DISABLED');\n    var doesAllowBrowse = root.query('GET_ALLOW_BROWSE');\n    var disableField = isDisabled || !doesAllowBrowse;\n    attrToggle(root.element, 'disabled', disableField);\n  };\n\n  var toggleRequired = function toggleRequired(_ref6) {\n    var root = _ref6.root,\n      action = _ref6.action;\n    // want to remove required, always possible\n    if (!action.value) {\n      attrToggle(root.element, 'required', false);\n    }\n    // if want to make required, only possible when zero items\n    else if (root.query('GET_TOTAL_ITEMS') === 0) {\n      attrToggle(root.element, 'required', true);\n    }\n  };\n\n  var setCaptureMethod = function setCaptureMethod(_ref7) {\n    var root = _ref7.root,\n      action = _ref7.action;\n    attrToggle(\n      root.element,\n      'capture',\n      !!action.value,\n      action.value === true ? '' : action.value\n    );\n  };\n\n  var updateRequiredStatus = function updateRequiredStatus(_ref8) {\n    var root = _ref8.root;\n    var element = root.element;\n    // always remove the required attribute when more than zero items\n    if (root.query('GET_TOTAL_ITEMS') > 0) {\n      attrToggle(element, 'required', false);\n      attrToggle(element, 'name', false);\n    } else {\n      // add name attribute\n      attrToggle(element, 'name', true, root.query('GET_NAME'));\n\n      // remove any validation messages\n      var shouldCheckValidity = root.query('GET_CHECK_VALIDITY');\n      if (shouldCheckValidity) {\n        element.setCustomValidity('');\n      }\n\n      // we only add required if the field has been deemed required\n      if (root.query('GET_REQUIRED')) {\n        attrToggle(element, 'required', true);\n      }\n    }\n  };\n\n  var updateFieldValidityStatus = function updateFieldValidityStatus(_ref9) {\n    var root = _ref9.root;\n    var shouldCheckValidity = root.query('GET_CHECK_VALIDITY');\n    if (!shouldCheckValidity) return;\n    root.element.setCustomValidity(root.query('GET_LABEL_INVALID_FIELD'));\n  };\n\n  var browser = createView({\n    tag: 'input',\n    name: 'browser',\n    ignoreRect: true,\n    ignoreRectUpdate: true,\n    attributes: {\n      type: 'file'\n    },\n\n    create: create$a,\n    destroy: function destroy(_ref10) {\n      var root = _ref10.root;\n      root.element.removeEventListener('change', root.ref.handleChange);\n    },\n    write: createRoute({\n      DID_LOAD_ITEM: updateRequiredStatus,\n      DID_REMOVE_ITEM: updateRequiredStatus,\n      DID_THROW_ITEM_INVALID: updateFieldValidityStatus,\n\n      DID_SET_DISABLED: toggleDisabled,\n      DID_SET_ALLOW_BROWSE: toggleDisabled,\n      DID_SET_ALLOW_DIRECTORIES_ONLY: toggleDirectoryFilter,\n      DID_SET_ALLOW_MULTIPLE: toggleAllowMultiple,\n      DID_SET_ACCEPTED_FILE_TYPES: setAcceptedFileTypes,\n      DID_SET_CAPTURE_METHOD: setCaptureMethod,\n      DID_SET_REQUIRED: toggleRequired\n    })\n  });\n\n  var Key = {\n    ENTER: 13,\n    SPACE: 32\n  };\n\n  var create$b = function create(_ref) {\n    var root = _ref.root,\n      props = _ref.props;\n\n    // create the label and link it to the file browser\n    var label = createElement$1('label');\n    attr(label, 'for', 'filepond--browser-' + props.id);\n\n    // use for labeling file input (aria-labelledby on file input)\n    attr(label, 'id', 'filepond--drop-label-' + props.id);\n\n    // hide the label for screenreaders, the input element will read the contents of the label when it's focussed. If we don't set aria-hidden the screenreader will also navigate the contents of the label separately from the input.\n    attr(label, 'aria-hidden', 'true');\n\n    // handle keys\n    root.ref.handleKeyDown = function(e) {\n      var isActivationKey = e.keyCode === Key.ENTER || e.keyCode === Key.SPACE;\n      if (!isActivationKey) return;\n      // stops from triggering the element a second time\n      e.preventDefault();\n\n      // click link (will then in turn activate file input)\n      root.ref.label.click();\n    };\n\n    root.ref.handleClick = function(e) {\n      var isLabelClick = e.target === label || label.contains(e.target);\n\n      // don't want to click twice\n      if (isLabelClick) return;\n\n      // click link (will then in turn activate file input)\n      root.ref.label.click();\n    };\n\n    // attach events\n    label.addEventListener('keydown', root.ref.handleKeyDown);\n    root.element.addEventListener('click', root.ref.handleClick);\n\n    // update\n    updateLabelValue(label, props.caption);\n\n    // add!\n    root.appendChild(label);\n    root.ref.label = label;\n  };\n\n  var updateLabelValue = function updateLabelValue(label, value) {\n    label.innerHTML = value;\n    var clickable = label.querySelector('.filepond--label-action');\n    if (clickable) {\n      attr(clickable, 'tabindex', '0');\n    }\n    return value;\n  };\n\n  var dropLabel = createView({\n    name: 'drop-label',\n    ignoreRect: true,\n    create: create$b,\n    destroy: function destroy(_ref2) {\n      var root = _ref2.root;\n      root.ref.label.addEventListener('keydown', root.ref.handleKeyDown);\n      root.element.removeEventListener('click', root.ref.handleClick);\n    },\n    write: createRoute({\n      DID_SET_LABEL_IDLE: function DID_SET_LABEL_IDLE(_ref3) {\n        var root = _ref3.root,\n          action = _ref3.action;\n        updateLabelValue(root.ref.label, action.value);\n      }\n    }),\n\n    mixins: {\n      styles: ['opacity', 'translateX', 'translateY'],\n      animations: {\n        opacity: { type: 'tween', duration: 150 },\n        translateX: 'spring',\n        translateY: 'spring'\n      }\n    }\n  });\n\n  var blob = createView({\n    name: 'drip-blob',\n    ignoreRect: true,\n    mixins: {\n      styles: ['translateX', 'translateY', 'scaleX', 'scaleY', 'opacity'],\n      animations: {\n        scaleX: 'spring',\n        scaleY: 'spring',\n        translateX: 'spring',\n        translateY: 'spring',\n        opacity: { type: 'tween', duration: 250 }\n      }\n    }\n  });\n\n  var addBlob = function addBlob(_ref) {\n    var root = _ref.root;\n    var centerX = root.rect.element.width * 0.5;\n    var centerY = root.rect.element.height * 0.5;\n\n    root.ref.blob = root.appendChildView(\n      root.createChildView(blob, {\n        opacity: 0,\n        scaleX: 2.5,\n        scaleY: 2.5,\n        translateX: centerX,\n        translateY: centerY\n      })\n    );\n  };\n\n  var moveBlob = function moveBlob(_ref2) {\n    var root = _ref2.root,\n      action = _ref2.action;\n    if (!root.ref.blob) {\n      addBlob({ root: root });\n      return;\n    }\n\n    root.ref.blob.translateX = action.position.scopeLeft;\n    root.ref.blob.translateY = action.position.scopeTop;\n    root.ref.blob.scaleX = 1;\n    root.ref.blob.scaleY = 1;\n    root.ref.blob.opacity = 1;\n  };\n\n  var hideBlob = function hideBlob(_ref3) {\n    var root = _ref3.root;\n    if (!root.ref.blob) {\n      return;\n    }\n    root.ref.blob.opacity = 0;\n  };\n\n  var explodeBlob = function explodeBlob(_ref4) {\n    var root = _ref4.root;\n    if (!root.ref.blob) {\n      return;\n    }\n    root.ref.blob.scaleX = 2.5;\n    root.ref.blob.scaleY = 2.5;\n    root.ref.blob.opacity = 0;\n  };\n\n  var write$7 = function write(_ref5) {\n    var root = _ref5.root,\n      props = _ref5.props,\n      actions = _ref5.actions;\n    route$4({ root: root, props: props, actions: actions });\n    var blob = root.ref.blob;\n\n    if (actions.length === 0 && blob && blob.opacity === 0) {\n      root.removeChildView(blob);\n      root.ref.blob = null;\n    }\n  };\n\n  var route$4 = createRoute({\n    DID_DRAG: moveBlob,\n    DID_DROP: explodeBlob,\n    DID_END_DRAG: hideBlob\n  });\n\n  var drip = createView({\n    ignoreRect: true,\n    ignoreRectUpdate: true,\n    name: 'drip',\n    write: write$7\n  });\n\n  var create$c = function create(_ref) {\n    var root = _ref.root;\n    return (root.ref.fields = {});\n  };\n\n  var getField = function getField(root, id) {\n    return root.ref.fields[id];\n  };\n\n  var syncFieldPositionsWithItems = function syncFieldPositionsWithItems(root) {\n    root.query('GET_ACTIVE_ITEMS').forEach(function(item) {\n      if (!root.ref.fields[item.id]) return;\n      root.element.appendChild(root.ref.fields[item.id]);\n    });\n  };\n\n  var didReorderItems = function didReorderItems(_ref2) {\n    var root = _ref2.root;\n    return syncFieldPositionsWithItems(root);\n  };\n\n  var didAddItem = function didAddItem(_ref3) {\n    var root = _ref3.root,\n      action = _ref3.action;\n    var dataContainer = createElement$1('input');\n    dataContainer.type = 'hidden';\n    dataContainer.name = root.query('GET_NAME');\n    dataContainer.disabled = root.query('GET_DISABLED');\n    root.ref.fields[action.id] = dataContainer;\n    syncFieldPositionsWithItems(root);\n  };\n\n  var didLoadItem$1 = function didLoadItem(_ref4) {\n    var root = _ref4.root,\n      action = _ref4.action;\n    var field = getField(root, action.id);\n    if (!field || action.serverFileReference === null) return;\n    field.value = action.serverFileReference;\n  };\n\n  var didSetDisabled = function didSetDisabled(_ref5) {\n    var root = _ref5.root;\n    root.element.disabled = root.query('GET_DISABLED');\n  };\n\n  var didRemoveItem = function didRemoveItem(_ref6) {\n    var root = _ref6.root,\n      action = _ref6.action;\n    var field = getField(root, action.id);\n    if (!field) return;\n    if (field.parentNode) field.parentNode.removeChild(field);\n    delete root.ref.fields[action.id];\n  };\n\n  var didDefineValue = function didDefineValue(_ref7) {\n    var root = _ref7.root,\n      action = _ref7.action;\n    var field = getField(root, action.id);\n    if (!field) return;\n    if (action.value === null) {\n      field.removeAttribute('value');\n    } else {\n      field.value = action.value;\n    }\n    syncFieldPositionsWithItems(root);\n  };\n\n  var write$8 = createRoute({\n    DID_SET_DISABLED: didSetDisabled,\n    DID_ADD_ITEM: didAddItem,\n    DID_LOAD_ITEM: didLoadItem$1,\n    DID_REMOVE_ITEM: didRemoveItem,\n    DID_DEFINE_VALUE: didDefineValue,\n    DID_REORDER_ITEMS: didReorderItems,\n    DID_SORT_ITEMS: didReorderItems\n  });\n\n  var data = createView({\n    tag: 'fieldset',\n    name: 'data',\n    create: create$c,\n    write: write$8,\n    ignoreRect: true\n  });\n\n  var getRootNode = function getRootNode(element) {\n    return 'getRootNode' in element ? element.getRootNode() : document;\n  };\n\n  var images = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp', 'svg', 'tiff'];\n  var text$1 = ['css', 'csv', 'html', 'txt'];\n  var map = {\n    zip: 'zip|compressed',\n    epub: 'application/epub+zip'\n  };\n\n  var guesstimateMimeType = function guesstimateMimeType() {\n    var extension =\n      arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n    extension = extension.toLowerCase();\n    if (images.includes(extension)) {\n      return (\n        'image/' +\n        (extension === 'jpg'\n          ? 'jpeg'\n          : extension === 'svg'\n          ? 'svg+xml'\n          : extension)\n      );\n    }\n    if (text$1.includes(extension)) {\n      return 'text/' + extension;\n    }\n\n    return map[extension] || '';\n  };\n\n  var requestDataTransferItems = function requestDataTransferItems(\n    dataTransfer\n  ) {\n    return new Promise(function(resolve, reject) {\n      // try to get links from transfer, if found we'll exit immediately (unless a file is in the dataTransfer as well, this is because Firefox could represent the file as a URL and a file object at the same time)\n      var links = getLinks(dataTransfer);\n      if (links.length && !hasFiles(dataTransfer)) {\n        return resolve(links);\n      }\n      // try to get files from the transfer\n      getFiles(dataTransfer).then(resolve);\n    });\n  };\n\n  /**\n   * Test if datatransfer has files\n   */\n  var hasFiles = function hasFiles(dataTransfer) {\n    if (dataTransfer.files) return dataTransfer.files.length > 0;\n    return false;\n  };\n\n  /**\n   * Extracts files from a DataTransfer object\n   */\n  var getFiles = function getFiles(dataTransfer) {\n    return new Promise(function(resolve, reject) {\n      // get the transfer items as promises\n      var promisedFiles = (dataTransfer.items\n        ? Array.from(dataTransfer.items)\n        : []\n      )\n        // only keep file system items (files and directories)\n        .filter(function(item) {\n          return isFileSystemItem(item);\n        })\n\n        // map each item to promise\n        .map(function(item) {\n          return getFilesFromItem(item);\n        });\n\n      // if is empty, see if we can extract some info from the files property as a fallback\n      if (!promisedFiles.length) {\n        // TODO: test for directories (should not be allowed)\n        // Use FileReader, problem is that the files property gets lost in the process\n        resolve(dataTransfer.files ? Array.from(dataTransfer.files) : []);\n        return;\n      }\n\n      // done!\n      Promise.all(promisedFiles)\n        .then(function(returnedFileGroups) {\n          // flatten groups\n          var files = [];\n          returnedFileGroups.forEach(function(group) {\n            files.push.apply(files, group);\n          });\n\n          // done (filter out empty files)!\n          resolve(\n            files\n              .filter(function(file) {\n                return file;\n              })\n              .map(function(file) {\n                if (!file._relativePath)\n                  file._relativePath = file.webkitRelativePath;\n                return file;\n              })\n          );\n        })\n        .catch(console.error);\n    });\n  };\n\n  var isFileSystemItem = function isFileSystemItem(item) {\n    if (isEntry(item)) {\n      var entry = getAsEntry(item);\n      if (entry) {\n        return entry.isFile || entry.isDirectory;\n      }\n    }\n    return item.kind === 'file';\n  };\n\n  var getFilesFromItem = function getFilesFromItem(item) {\n    return new Promise(function(resolve, reject) {\n      if (isDirectoryEntry(item)) {\n        getFilesInDirectory(getAsEntry(item))\n          .then(resolve)\n          .catch(reject);\n        return;\n      }\n\n      resolve([item.getAsFile()]);\n    });\n  };\n\n  var getFilesInDirectory = function getFilesInDirectory(entry) {\n    return new Promise(function(resolve, reject) {\n      var files = [];\n\n      // the total entries to read\n      var dirCounter = 0;\n      var fileCounter = 0;\n\n      var resolveIfDone = function resolveIfDone() {\n        if (fileCounter === 0 && dirCounter === 0) {\n          resolve(files);\n        }\n      };\n\n      // the recursive function\n      var readEntries = function readEntries(dirEntry) {\n        dirCounter++;\n\n        var directoryReader = dirEntry.createReader();\n\n        // directories are returned in batches, we need to process all batches before we're done\n        var readBatch = function readBatch() {\n          directoryReader.readEntries(function(entries) {\n            if (entries.length === 0) {\n              dirCounter--;\n              resolveIfDone();\n              return;\n            }\n\n            entries.forEach(function(entry) {\n              // recursively read more directories\n              if (entry.isDirectory) {\n                readEntries(entry);\n              } else {\n                // read as file\n                fileCounter++;\n\n                entry.file(function(file) {\n                  var correctedFile = correctMissingFileType(file);\n                  if (entry.fullPath)\n                    correctedFile._relativePath = entry.fullPath;\n                  files.push(correctedFile);\n                  fileCounter--;\n                  resolveIfDone();\n                });\n              }\n            });\n\n            // try to get next batch of files\n            readBatch();\n          }, reject);\n        };\n\n        // read first batch of files\n        readBatch();\n      };\n\n      // go!\n      readEntries(entry);\n    });\n  };\n\n  var correctMissingFileType = function correctMissingFileType(file) {\n    if (file.type.length) return file;\n    var date = file.lastModifiedDate;\n    var name = file.name;\n    var type = guesstimateMimeType(getExtensionFromFilename(file.name));\n    if (!type.length) return file;\n    file = file.slice(0, file.size, type);\n    file.name = name;\n    file.lastModifiedDate = date;\n    return file;\n  };\n\n  var isDirectoryEntry = function isDirectoryEntry(item) {\n    return isEntry(item) && (getAsEntry(item) || {}).isDirectory;\n  };\n\n  var isEntry = function isEntry(item) {\n    return 'webkitGetAsEntry' in item;\n  };\n\n  var getAsEntry = function getAsEntry(item) {\n    return item.webkitGetAsEntry();\n  };\n\n  /**\n   * Extracts links from a DataTransfer object\n   */\n  var getLinks = function getLinks(dataTransfer) {\n    var links = [];\n    try {\n      // look in meta data property\n      links = getLinksFromTransferMetaData(dataTransfer);\n      if (links.length) {\n        return links;\n      }\n      links = getLinksFromTransferURLData(dataTransfer);\n    } catch (e) {\n      // nope nope nope (probably IE trouble)\n    }\n    return links;\n  };\n\n  var getLinksFromTransferURLData = function getLinksFromTransferURLData(\n    dataTransfer\n  ) {\n    var data = dataTransfer.getData('url');\n    if (typeof data === 'string' && data.length) {\n      return [data];\n    }\n    return [];\n  };\n\n  var getLinksFromTransferMetaData = function getLinksFromTransferMetaData(\n    dataTransfer\n  ) {\n    var data = dataTransfer.getData('text/html');\n    if (typeof data === 'string' && data.length) {\n      var matches = data.match(/src\\s*=\\s*\"(.+?)\"/);\n      if (matches) {\n        return [matches[1]];\n      }\n    }\n    return [];\n  };\n\n  var dragNDropObservers = [];\n\n  var eventPosition = function eventPosition(e) {\n    return {\n      pageLeft: e.pageX,\n      pageTop: e.pageY,\n      scopeLeft: e.offsetX || e.layerX,\n      scopeTop: e.offsetY || e.layerY\n    };\n  };\n\n  var createDragNDropClient = function createDragNDropClient(\n    element,\n    scopeToObserve,\n    filterElement\n  ) {\n    var observer = getDragNDropObserver(scopeToObserve);\n\n    var client = {\n      element: element,\n      filterElement: filterElement,\n      state: null,\n      ondrop: function ondrop() {},\n      onenter: function onenter() {},\n      ondrag: function ondrag() {},\n      onexit: function onexit() {},\n      onload: function onload() {},\n      allowdrop: function allowdrop() {}\n    };\n\n    client.destroy = observer.addListener(client);\n\n    return client;\n  };\n\n  var getDragNDropObserver = function getDragNDropObserver(element) {\n    // see if already exists, if so, return\n    var observer = dragNDropObservers.find(function(item) {\n      return item.element === element;\n    });\n    if (observer) {\n      return observer;\n    }\n\n    // create new observer, does not yet exist for this element\n    var newObserver = createDragNDropObserver(element);\n    dragNDropObservers.push(newObserver);\n    return newObserver;\n  };\n\n  var createDragNDropObserver = function createDragNDropObserver(element) {\n    var clients = [];\n\n    var routes = {\n      dragenter: dragenter,\n      dragover: dragover,\n      dragleave: dragleave,\n      drop: drop\n    };\n\n    var handlers = {};\n\n    forin(routes, function(event, createHandler) {\n      handlers[event] = createHandler(element, clients);\n      element.addEventListener(event, handlers[event], false);\n    });\n\n    var observer = {\n      element: element,\n      addListener: function addListener(client) {\n        // add as client\n        clients.push(client);\n\n        // return removeListener function\n        return function() {\n          // remove client\n          clients.splice(clients.indexOf(client), 1);\n\n          // if no more clients, clean up observer\n          if (clients.length === 0) {\n            dragNDropObservers.splice(dragNDropObservers.indexOf(observer), 1);\n\n            forin(routes, function(event) {\n              element.removeEventListener(event, handlers[event], false);\n            });\n          }\n        };\n      }\n    };\n\n    return observer;\n  };\n\n  var elementFromPoint = function elementFromPoint(root, point) {\n    if (!('elementFromPoint' in root)) {\n      root = document;\n    }\n    return root.elementFromPoint(point.x, point.y);\n  };\n\n  var isEventTarget = function isEventTarget(e, target) {\n    // get root\n    var root = getRootNode(target);\n\n    // get element at position\n    // if root is not actual shadow DOM and does not have elementFromPoint method, use the one on document\n    var elementAtPosition = elementFromPoint(root, {\n      x: e.pageX - window.pageXOffset,\n      y: e.pageY - window.pageYOffset\n    });\n\n    // test if target is the element or if one of its children is\n    return elementAtPosition === target || target.contains(elementAtPosition);\n  };\n\n  var initialTarget = null;\n\n  var setDropEffect = function setDropEffect(dataTransfer, effect) {\n    // is in try catch as IE11 will throw error if not\n    try {\n      dataTransfer.dropEffect = effect;\n    } catch (e) {}\n  };\n\n  var dragenter = function dragenter(root, clients) {\n    return function(e) {\n      e.preventDefault();\n\n      initialTarget = e.target;\n\n      clients.forEach(function(client) {\n        var element = client.element,\n          onenter = client.onenter;\n\n        if (isEventTarget(e, element)) {\n          client.state = 'enter';\n\n          // fire enter event\n          onenter(eventPosition(e));\n        }\n      });\n    };\n  };\n\n  var dragover = function dragover(root, clients) {\n    return function(e) {\n      e.preventDefault();\n\n      var dataTransfer = e.dataTransfer;\n\n      requestDataTransferItems(dataTransfer).then(function(items) {\n        var overDropTarget = false;\n\n        clients.some(function(client) {\n          var filterElement = client.filterElement,\n            element = client.element,\n            onenter = client.onenter,\n            onexit = client.onexit,\n            ondrag = client.ondrag,\n            allowdrop = client.allowdrop;\n\n          // by default we can drop\n          setDropEffect(dataTransfer, 'copy');\n\n          // allow transfer of these items\n          var allowsTransfer = allowdrop(items);\n\n          // only used when can be dropped on page\n          if (!allowsTransfer) {\n            setDropEffect(dataTransfer, 'none');\n            return;\n          }\n\n          // targetting this client\n          if (isEventTarget(e, element)) {\n            overDropTarget = true;\n\n            // had no previous state, means we are entering this client\n            if (client.state === null) {\n              client.state = 'enter';\n              onenter(eventPosition(e));\n              return;\n            }\n\n            // now over element (no matter if it allows the drop or not)\n            client.state = 'over';\n\n            // needs to allow transfer\n            if (filterElement && !allowsTransfer) {\n              setDropEffect(dataTransfer, 'none');\n              return;\n            }\n\n            // dragging\n            ondrag(eventPosition(e));\n          } else {\n            // should be over an element to drop\n            if (filterElement && !overDropTarget) {\n              setDropEffect(dataTransfer, 'none');\n            }\n\n            // might have just left this client?\n            if (client.state) {\n              client.state = null;\n              onexit(eventPosition(e));\n            }\n          }\n        });\n      });\n    };\n  };\n\n  var drop = function drop(root, clients) {\n    return function(e) {\n      e.preventDefault();\n\n      var dataTransfer = e.dataTransfer;\n\n      requestDataTransferItems(dataTransfer).then(function(items) {\n        clients.forEach(function(client) {\n          var filterElement = client.filterElement,\n            element = client.element,\n            ondrop = client.ondrop,\n            onexit = client.onexit,\n            allowdrop = client.allowdrop;\n\n          client.state = null;\n\n          // if we're filtering on element we need to be over the element to drop\n          if (filterElement && !isEventTarget(e, element)) return;\n\n          // no transfer for this client\n          if (!allowdrop(items)) return onexit(eventPosition(e));\n\n          // we can drop these items on this client\n          ondrop(eventPosition(e), items);\n        });\n      });\n    };\n  };\n\n  var dragleave = function dragleave(root, clients) {\n    return function(e) {\n      if (initialTarget !== e.target) {\n        return;\n      }\n\n      clients.forEach(function(client) {\n        var onexit = client.onexit;\n\n        client.state = null;\n\n        onexit(eventPosition(e));\n      });\n    };\n  };\n\n  var createHopper = function createHopper(scope, validateItems, options) {\n    // is now hopper scope\n    scope.classList.add('filepond--hopper');\n\n    // shortcuts\n    var catchesDropsOnPage = options.catchesDropsOnPage,\n      requiresDropOnElement = options.requiresDropOnElement,\n      _options$filterItems = options.filterItems,\n      filterItems =\n        _options$filterItems === void 0\n          ? function(items) {\n              return items;\n            }\n          : _options$filterItems;\n\n    // create a dnd client\n    var client = createDragNDropClient(\n      scope,\n      catchesDropsOnPage ? document.documentElement : scope,\n      requiresDropOnElement\n    );\n\n    // current client state\n    var lastState = '';\n    var currentState = '';\n\n    // determines if a file may be dropped\n    client.allowdrop = function(items) {\n      // TODO: if we can, throw error to indicate the items cannot by dropped\n\n      return validateItems(filterItems(items));\n    };\n\n    client.ondrop = function(position, items) {\n      var filteredItems = filterItems(items);\n\n      if (!validateItems(filteredItems)) {\n        api.ondragend(position);\n        return;\n      }\n\n      currentState = 'drag-drop';\n\n      api.onload(filteredItems, position);\n    };\n\n    client.ondrag = function(position) {\n      api.ondrag(position);\n    };\n\n    client.onenter = function(position) {\n      currentState = 'drag-over';\n\n      api.ondragstart(position);\n    };\n\n    client.onexit = function(position) {\n      currentState = 'drag-exit';\n\n      api.ondragend(position);\n    };\n\n    var api = {\n      updateHopperState: function updateHopperState() {\n        if (lastState !== currentState) {\n          scope.dataset.hopperState = currentState;\n          lastState = currentState;\n        }\n      },\n      onload: function onload() {},\n      ondragstart: function ondragstart() {},\n      ondrag: function ondrag() {},\n      ondragend: function ondragend() {},\n      destroy: function destroy() {\n        // destroy client\n        client.destroy();\n      }\n    };\n\n    return api;\n  };\n\n  var listening = false;\n  var listeners$1 = [];\n\n  var handlePaste = function handlePaste(e) {\n    // if is pasting in input or textarea and the target is outside of a filepond scope, ignore\n    var activeEl = document.activeElement;\n    if (activeEl && /textarea|input/i.test(activeEl.nodeName)) {\n      // test textarea or input is contained in filepond root\n      var inScope = false;\n      var element = activeEl;\n      while (element !== document.body) {\n        if (element.classList.contains('filepond--root')) {\n          inScope = true;\n          break;\n        }\n        element = element.parentNode;\n      }\n\n      if (!inScope) return;\n    }\n\n    requestDataTransferItems(e.clipboardData).then(function(files) {\n      // no files received\n      if (!files.length) {\n        return;\n      }\n\n      // notify listeners of received files\n      listeners$1.forEach(function(listener) {\n        return listener(files);\n      });\n    });\n  };\n\n  var listen = function listen(cb) {\n    // can't add twice\n    if (listeners$1.includes(cb)) {\n      return;\n    }\n\n    // add initial listener\n    listeners$1.push(cb);\n\n    // setup paste listener for entire page\n    if (listening) {\n      return;\n    }\n\n    listening = true;\n    document.addEventListener('paste', handlePaste);\n  };\n\n  var unlisten = function unlisten(listener) {\n    arrayRemove(listeners$1, listeners$1.indexOf(listener));\n\n    // clean up\n    if (listeners$1.length === 0) {\n      document.removeEventListener('paste', handlePaste);\n      listening = false;\n    }\n  };\n\n  var createPaster = function createPaster() {\n    var cb = function cb(files) {\n      api.onload(files);\n    };\n\n    var api = {\n      destroy: function destroy() {\n        unlisten(cb);\n      },\n      onload: function onload() {}\n    };\n\n    listen(cb);\n\n    return api;\n  };\n\n  /**\n   * Creates the file view\n   */\n  var create$d = function create(_ref) {\n    var root = _ref.root,\n      props = _ref.props;\n    root.element.id = 'filepond--assistant-' + props.id;\n    attr(root.element, 'role', 'status');\n    attr(root.element, 'aria-live', 'polite');\n    attr(root.element, 'aria-relevant', 'additions');\n  };\n\n  var addFilesNotificationTimeout = null;\n  var notificationClearTimeout = null;\n\n  var filenames = [];\n\n  var assist = function assist(root, message) {\n    root.element.textContent = message;\n  };\n\n  var clear$1 = function clear(root) {\n    root.element.textContent = '';\n  };\n\n  var listModified = function listModified(root, filename, label) {\n    var total = root.query('GET_TOTAL_ITEMS');\n    assist(\n      root,\n      label +\n        ' ' +\n        filename +\n        ', ' +\n        total +\n        ' ' +\n        (total === 1\n          ? root.query('GET_LABEL_FILE_COUNT_SINGULAR')\n          : root.query('GET_LABEL_FILE_COUNT_PLURAL'))\n    );\n\n    // clear group after set amount of time so the status is not read twice\n    clearTimeout(notificationClearTimeout);\n    notificationClearTimeout = setTimeout(function() {\n      clear$1(root);\n    }, 1500);\n  };\n\n  var isUsingFilePond = function isUsingFilePond(root) {\n    return root.element.parentNode.contains(document.activeElement);\n  };\n\n  var itemAdded = function itemAdded(_ref2) {\n    var root = _ref2.root,\n      action = _ref2.action;\n    if (!isUsingFilePond(root)) {\n      return;\n    }\n\n    root.element.textContent = '';\n    var item = root.query('GET_ITEM', action.id);\n    filenames.push(item.filename);\n\n    clearTimeout(addFilesNotificationTimeout);\n    addFilesNotificationTimeout = setTimeout(function() {\n      listModified(\n        root,\n        filenames.join(', '),\n        root.query('GET_LABEL_FILE_ADDED')\n      );\n\n      filenames.length = 0;\n    }, 750);\n  };\n\n  var itemRemoved = function itemRemoved(_ref3) {\n    var root = _ref3.root,\n      action = _ref3.action;\n    if (!isUsingFilePond(root)) {\n      return;\n    }\n\n    var item = action.item;\n    listModified(root, item.filename, root.query('GET_LABEL_FILE_REMOVED'));\n  };\n\n  var itemProcessed = function itemProcessed(_ref4) {\n    var root = _ref4.root,\n      action = _ref4.action;\n    // will also notify the user when FilePond is not being used, as the user might be occupied with other activities while uploading a file\n\n    var item = root.query('GET_ITEM', action.id);\n    var filename = item.filename;\n    var label = root.query('GET_LABEL_FILE_PROCESSING_COMPLETE');\n\n    assist(root, filename + ' ' + label);\n  };\n\n  var itemProcessedUndo = function itemProcessedUndo(_ref5) {\n    var root = _ref5.root,\n      action = _ref5.action;\n    var item = root.query('GET_ITEM', action.id);\n    var filename = item.filename;\n    var label = root.query('GET_LABEL_FILE_PROCESSING_ABORTED');\n\n    assist(root, filename + ' ' + label);\n  };\n\n  var itemError = function itemError(_ref6) {\n    var root = _ref6.root,\n      action = _ref6.action;\n    var item = root.query('GET_ITEM', action.id);\n    var filename = item.filename;\n\n    // will also notify the user when FilePond is not being used, as the user might be occupied with other activities while uploading a file\n\n    assist(root, action.status.main + ' ' + filename + ' ' + action.status.sub);\n  };\n\n  var assistant = createView({\n    create: create$d,\n    ignoreRect: true,\n    ignoreRectUpdate: true,\n    write: createRoute({\n      DID_LOAD_ITEM: itemAdded,\n      DID_REMOVE_ITEM: itemRemoved,\n      DID_COMPLETE_ITEM_PROCESSING: itemProcessed,\n\n      DID_ABORT_ITEM_PROCESSING: itemProcessedUndo,\n      DID_REVERT_ITEM_PROCESSING: itemProcessedUndo,\n\n      DID_THROW_ITEM_REMOVE_ERROR: itemError,\n      DID_THROW_ITEM_LOAD_ERROR: itemError,\n      DID_THROW_ITEM_INVALID: itemError,\n      DID_THROW_ITEM_PROCESSING_ERROR: itemError\n    }),\n\n    tag: 'span',\n    name: 'assistant'\n  });\n\n  var toCamels = function toCamels(string) {\n    var separator =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '-';\n    return string.replace(new RegExp(separator + '.', 'g'), function(sub) {\n      return sub.charAt(1).toUpperCase();\n    });\n  };\n\n  var debounce = function debounce(func) {\n    var interval =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 16;\n    var immidiateOnly =\n      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n    var last = Date.now();\n    var timeout = null;\n\n    return function() {\n      for (\n        var _len = arguments.length, args = new Array(_len), _key = 0;\n        _key < _len;\n        _key++\n      ) {\n        args[_key] = arguments[_key];\n      }\n      clearTimeout(timeout);\n\n      var dist = Date.now() - last;\n\n      var fn = function fn() {\n        last = Date.now();\n        func.apply(void 0, args);\n      };\n\n      if (dist < interval) {\n        // we need to delay by the difference between interval and dist\n        // for example: if distance is 10 ms and interval is 16 ms,\n        // we need to wait an additional 6ms before calling the function)\n        if (!immidiateOnly) {\n          timeout = setTimeout(fn, interval - dist);\n        }\n      } else {\n        // go!\n        fn();\n      }\n    };\n  };\n\n  var MAX_FILES_LIMIT = 1000000;\n\n  var prevent = function prevent(e) {\n    return e.preventDefault();\n  };\n\n  var create$e = function create(_ref) {\n    var root = _ref.root,\n      props = _ref.props;\n\n    // Add id\n    var id = root.query('GET_ID');\n    if (id) {\n      root.element.id = id;\n    }\n\n    // Add className\n    var className = root.query('GET_CLASS_NAME');\n    if (className) {\n      className\n        .split(' ')\n        .filter(function(name) {\n          return name.length;\n        })\n        .forEach(function(name) {\n          root.element.classList.add(name);\n        });\n    }\n\n    // Field label\n    root.ref.label = root.appendChildView(\n      root.createChildView(\n        dropLabel,\n        Object.assign({}, props, {\n          translateY: null,\n          caption: root.query('GET_LABEL_IDLE')\n        })\n      )\n    );\n\n    // List of items\n    root.ref.list = root.appendChildView(\n      root.createChildView(listScroller, { translateY: null })\n    );\n\n    // Background panel\n    root.ref.panel = root.appendChildView(\n      root.createChildView(panel, { name: 'panel-root' })\n    );\n\n    // Assistant notifies assistive tech when content changes\n    root.ref.assistant = root.appendChildView(\n      root.createChildView(assistant, Object.assign({}, props))\n    );\n\n    // Data\n    root.ref.data = root.appendChildView(\n      root.createChildView(data, Object.assign({}, props))\n    );\n\n    // Measure (tests if fixed height was set)\n    // DOCTYPE needs to be set for this to work\n    root.ref.measure = createElement$1('div');\n    root.ref.measure.style.height = '100%';\n    root.element.appendChild(root.ref.measure);\n\n    // information on the root height or fixed height status\n    root.ref.bounds = null;\n\n    // apply initial style properties\n    root\n      .query('GET_STYLES')\n      .filter(function(style) {\n        return !isEmpty(style.value);\n      })\n      .map(function(_ref2) {\n        var name = _ref2.name,\n          value = _ref2.value;\n        root.element.dataset[name] = value;\n      });\n\n    // determine if width changed\n    root.ref.widthPrevious = null;\n    root.ref.widthUpdated = debounce(function() {\n      root.ref.updateHistory = [];\n      root.dispatch('DID_RESIZE_ROOT');\n    }, 250);\n\n    // history of updates\n    root.ref.previousAspectRatio = null;\n    root.ref.updateHistory = [];\n\n    // prevent scrolling and zooming on iOS (only if supports pointer events, for then we can enable reorder)\n    var canHover = window.matchMedia('(pointer: fine) and (hover: hover)')\n      .matches;\n    var hasPointerEvents = 'PointerEvent' in window;\n    if (root.query('GET_ALLOW_REORDER') && hasPointerEvents && !canHover) {\n      root.element.addEventListener('touchmove', prevent, { passive: false });\n      root.element.addEventListener('gesturestart', prevent);\n    }\n\n    // add credits\n    var credits = root.query('GET_CREDITS');\n    var hasCredits = credits.length === 2;\n    if (hasCredits) {\n      var frag = document.createElement('a');\n      frag.className = 'filepond--credits';\n      frag.setAttribute('aria-hidden', 'true');\n      frag.href = credits[0];\n      frag.tabindex = -1;\n      frag.target = '_blank';\n      frag.rel = 'noopener noreferrer';\n      frag.textContent = credits[1];\n      root.element.appendChild(frag);\n      root.ref.credits = frag;\n    }\n  };\n\n  var write$9 = function write(_ref3) {\n    var root = _ref3.root,\n      props = _ref3.props,\n      actions = _ref3.actions;\n\n    // route actions\n    route$5({ root: root, props: props, actions: actions });\n\n    // apply style properties\n    actions\n      .filter(function(action) {\n        return /^DID_SET_STYLE_/.test(action.type);\n      })\n      .filter(function(action) {\n        return !isEmpty(action.data.value);\n      })\n      .map(function(_ref4) {\n        var type = _ref4.type,\n          data = _ref4.data;\n        var name = toCamels(type.substr(8).toLowerCase(), '_');\n        root.element.dataset[name] = data.value;\n        root.invalidateLayout();\n      });\n\n    if (root.rect.element.hidden) return;\n\n    if (root.rect.element.width !== root.ref.widthPrevious) {\n      root.ref.widthPrevious = root.rect.element.width;\n      root.ref.widthUpdated();\n    }\n\n    // get box bounds, we do this only once\n    var bounds = root.ref.bounds;\n    if (!bounds) {\n      bounds = root.ref.bounds = calculateRootBoundingBoxHeight(root);\n\n      // destroy measure element\n      root.element.removeChild(root.ref.measure);\n      root.ref.measure = null;\n    }\n\n    // get quick references to various high level parts of the upload tool\n    var _root$ref = root.ref,\n      hopper = _root$ref.hopper,\n      label = _root$ref.label,\n      list = _root$ref.list,\n      panel = _root$ref.panel;\n\n    // sets correct state to hopper scope\n    if (hopper) {\n      hopper.updateHopperState();\n    }\n\n    // bool to indicate if we're full or not\n    var aspectRatio = root.query('GET_PANEL_ASPECT_RATIO');\n    var isMultiItem = root.query('GET_ALLOW_MULTIPLE');\n    var totalItems = root.query('GET_TOTAL_ITEMS');\n    var maxItems = isMultiItem\n      ? root.query('GET_MAX_FILES') || MAX_FILES_LIMIT\n      : 1;\n    var atMaxCapacity = totalItems === maxItems;\n\n    // action used to add item\n    var addAction = actions.find(function(action) {\n      return action.type === 'DID_ADD_ITEM';\n    });\n\n    // if reached max capacity and we've just reached it\n    if (atMaxCapacity && addAction) {\n      // get interaction type\n      var interactionMethod = addAction.data.interactionMethod;\n\n      // hide label\n      label.opacity = 0;\n\n      if (isMultiItem) {\n        label.translateY = -40;\n      } else {\n        if (interactionMethod === InteractionMethod.API) {\n          label.translateX = 40;\n        } else if (interactionMethod === InteractionMethod.BROWSE) {\n          label.translateY = 40;\n        } else {\n          label.translateY = 30;\n        }\n      }\n    } else if (!atMaxCapacity) {\n      label.opacity = 1;\n      label.translateX = 0;\n      label.translateY = 0;\n    }\n\n    var listItemMargin = calculateListItemMargin(root);\n\n    var listHeight = calculateListHeight(root);\n\n    var labelHeight = label.rect.element.height;\n    var currentLabelHeight = !isMultiItem || atMaxCapacity ? 0 : labelHeight;\n\n    var listMarginTop = atMaxCapacity ? list.rect.element.marginTop : 0;\n    var listMarginBottom =\n      totalItems === 0 ? 0 : list.rect.element.marginBottom;\n\n    var visualHeight =\n      currentLabelHeight + listMarginTop + listHeight.visual + listMarginBottom;\n    var boundsHeight =\n      currentLabelHeight + listMarginTop + listHeight.bounds + listMarginBottom;\n\n    // link list to label bottom position\n    list.translateY =\n      Math.max(0, currentLabelHeight - list.rect.element.marginTop) -\n      listItemMargin.top;\n\n    if (aspectRatio) {\n      // fixed aspect ratio\n\n      // calculate height based on width\n      var width = root.rect.element.width;\n      var height = width * aspectRatio;\n\n      // clear history if aspect ratio has changed\n      if (aspectRatio !== root.ref.previousAspectRatio) {\n        root.ref.previousAspectRatio = aspectRatio;\n        root.ref.updateHistory = [];\n      }\n\n      // remember this width\n      var history = root.ref.updateHistory;\n      history.push(width);\n\n      var MAX_BOUNCES = 2;\n      if (history.length > MAX_BOUNCES * 2) {\n        var l = history.length;\n        var bottom = l - 10;\n        var bounces = 0;\n        for (var i = l; i >= bottom; i--) {\n          if (history[i] === history[i - 2]) {\n            bounces++;\n          }\n\n          if (bounces >= MAX_BOUNCES) {\n            // dont adjust height\n            return;\n          }\n        }\n      }\n\n      // fix height of panel so it adheres to aspect ratio\n      panel.scalable = false;\n      panel.height = height;\n\n      // available height for list\n      var listAvailableHeight =\n        // the height of the panel minus the label height\n        height -\n        currentLabelHeight -\n        // the room we leave open between the end of the list and the panel bottom\n        (listMarginBottom - listItemMargin.bottom) -\n        // if we're full we need to leave some room between the top of the panel and the list\n        (atMaxCapacity ? listMarginTop : 0);\n\n      if (listHeight.visual > listAvailableHeight) {\n        list.overflow = listAvailableHeight;\n      } else {\n        list.overflow = null;\n      }\n\n      // set container bounds (so pushes siblings downwards)\n      root.height = height;\n    } else if (bounds.fixedHeight) {\n      // fixed height\n\n      // fix height of panel\n      panel.scalable = false;\n\n      // available height for list\n      var _listAvailableHeight =\n        // the height of the panel minus the label height\n        bounds.fixedHeight -\n        currentLabelHeight -\n        // the room we leave open between the end of the list and the panel bottom\n        (listMarginBottom - listItemMargin.bottom) -\n        // if we're full we need to leave some room between the top of the panel and the list\n        (atMaxCapacity ? listMarginTop : 0);\n\n      // set list height\n      if (listHeight.visual > _listAvailableHeight) {\n        list.overflow = _listAvailableHeight;\n      } else {\n        list.overflow = null;\n      }\n\n      // no need to set container bounds as these are handles by CSS fixed height\n    } else if (bounds.cappedHeight) {\n      // max-height\n\n      // not a fixed height panel\n      var isCappedHeight = visualHeight >= bounds.cappedHeight;\n      var panelHeight = Math.min(bounds.cappedHeight, visualHeight);\n      panel.scalable = true;\n      panel.height = isCappedHeight\n        ? panelHeight\n        : panelHeight - listItemMargin.top - listItemMargin.bottom;\n\n      // available height for list\n      var _listAvailableHeight2 =\n        // the height of the panel minus the label height\n        panelHeight -\n        currentLabelHeight -\n        // the room we leave open between the end of the list and the panel bottom\n        (listMarginBottom - listItemMargin.bottom) -\n        // if we're full we need to leave some room between the top of the panel and the list\n        (atMaxCapacity ? listMarginTop : 0);\n\n      // set list height (if is overflowing)\n      if (\n        visualHeight > bounds.cappedHeight &&\n        listHeight.visual > _listAvailableHeight2\n      ) {\n        list.overflow = _listAvailableHeight2;\n      } else {\n        list.overflow = null;\n      }\n\n      // set container bounds (so pushes siblings downwards)\n      root.height = Math.min(\n        bounds.cappedHeight,\n        boundsHeight - listItemMargin.top - listItemMargin.bottom\n      );\n    } else {\n      // flexible height\n\n      // not a fixed height panel\n      var itemMargin =\n        totalItems > 0 ? listItemMargin.top + listItemMargin.bottom : 0;\n      panel.scalable = true;\n      panel.height = Math.max(labelHeight, visualHeight - itemMargin);\n\n      // set container bounds (so pushes siblings downwards)\n      root.height = Math.max(labelHeight, boundsHeight - itemMargin);\n    }\n\n    // move credits to bottom\n    if (root.ref.credits && panel.heightCurrent)\n      root.ref.credits.style.transform =\n        'translateY(' + panel.heightCurrent + 'px)';\n  };\n\n  var calculateListItemMargin = function calculateListItemMargin(root) {\n    var item = root.ref.list.childViews[0].childViews[0];\n    return item\n      ? {\n          top: item.rect.element.marginTop,\n          bottom: item.rect.element.marginBottom\n        }\n      : {\n          top: 0,\n          bottom: 0\n        };\n  };\n\n  var calculateListHeight = function calculateListHeight(root) {\n    var visual = 0;\n    var bounds = 0;\n\n    // get file list reference\n    var scrollList = root.ref.list;\n    var itemList = scrollList.childViews[0];\n    var visibleChildren = itemList.childViews.filter(function(child) {\n      return child.rect.element.height;\n    });\n    var children = root\n      .query('GET_ACTIVE_ITEMS')\n      .map(function(item) {\n        return visibleChildren.find(function(child) {\n          return child.id === item.id;\n        });\n      })\n      .filter(function(item) {\n        return item;\n      });\n\n    // no children, done!\n    if (children.length === 0) return { visual: visual, bounds: bounds };\n\n    var horizontalSpace = itemList.rect.element.width;\n    var dragIndex = getItemIndexByPosition(\n      itemList,\n      children,\n      scrollList.dragCoordinates\n    );\n\n    var childRect = children[0].rect.element;\n\n    var itemVerticalMargin = childRect.marginTop + childRect.marginBottom;\n    var itemHorizontalMargin = childRect.marginLeft + childRect.marginRight;\n\n    var itemWidth = childRect.width + itemHorizontalMargin;\n    var itemHeight = childRect.height + itemVerticalMargin;\n\n    var newItem = typeof dragIndex !== 'undefined' && dragIndex >= 0 ? 1 : 0;\n    var removedItem = children.find(function(child) {\n      return child.markedForRemoval && child.opacity < 0.45;\n    })\n      ? -1\n      : 0;\n    var verticalItemCount = children.length + newItem + removedItem;\n    var itemsPerRow = Math.round(horizontalSpace / itemWidth);\n\n    // stack\n    if (itemsPerRow === 1) {\n      children.forEach(function(item) {\n        var height = item.rect.element.height + itemVerticalMargin;\n        bounds += height;\n        visual += height * item.opacity;\n      });\n    }\n    // grid\n    else {\n      bounds = Math.ceil(verticalItemCount / itemsPerRow) * itemHeight;\n      visual = bounds;\n    }\n\n    return { visual: visual, bounds: bounds };\n  };\n\n  var calculateRootBoundingBoxHeight = function calculateRootBoundingBoxHeight(\n    root\n  ) {\n    var height = root.ref.measureHeight || null;\n    var cappedHeight = parseInt(root.style.maxHeight, 10) || null;\n    var fixedHeight = height === 0 ? null : height;\n\n    return {\n      cappedHeight: cappedHeight,\n      fixedHeight: fixedHeight\n    };\n  };\n\n  var exceedsMaxFiles = function exceedsMaxFiles(root, items) {\n    var allowReplace = root.query('GET_ALLOW_REPLACE');\n    var allowMultiple = root.query('GET_ALLOW_MULTIPLE');\n    var totalItems = root.query('GET_TOTAL_ITEMS');\n    var maxItems = root.query('GET_MAX_FILES');\n\n    // total amount of items being dragged\n    var totalBrowseItems = items.length;\n\n    // if does not allow multiple items and dragging more than one item\n    if (!allowMultiple && totalBrowseItems > 1) {\n      return true;\n    }\n\n    // limit max items to one if not allowed to drop multiple items\n    maxItems = allowMultiple ? maxItems : allowReplace ? maxItems : 1;\n\n    // no more room?\n    var hasMaxItems = isInt(maxItems);\n    if (hasMaxItems && totalItems + totalBrowseItems > maxItems) {\n      root.dispatch('DID_THROW_MAX_FILES', {\n        source: items,\n        error: createResponse('warning', 0, 'Max files')\n      });\n\n      return true;\n    }\n\n    return false;\n  };\n\n  var getDragIndex = function getDragIndex(list, children, position) {\n    var itemList = list.childViews[0];\n    return getItemIndexByPosition(itemList, children, {\n      left: position.scopeLeft - itemList.rect.element.left,\n      top:\n        position.scopeTop -\n        (list.rect.outer.top +\n          list.rect.element.marginTop +\n          list.rect.element.scrollTop)\n    });\n  };\n\n  /**\n   * Enable or disable file drop functionality\n   */\n  var toggleDrop = function toggleDrop(root) {\n    var isAllowed = root.query('GET_ALLOW_DROP');\n    var isDisabled = root.query('GET_DISABLED');\n    var enabled = isAllowed && !isDisabled;\n    if (enabled && !root.ref.hopper) {\n      var hopper = createHopper(\n        root.element,\n        function(items) {\n          // allow quick validation of dropped items\n          var beforeDropFile =\n            root.query('GET_BEFORE_DROP_FILE') ||\n            function() {\n              return true;\n            };\n\n          // all items should be validated by all filters as valid\n          var dropValidation = root.query('GET_DROP_VALIDATION');\n          return dropValidation\n            ? items.every(function(item) {\n                return (\n                  applyFilters('ALLOW_HOPPER_ITEM', item, {\n                    query: root.query\n                  }).every(function(result) {\n                    return result === true;\n                  }) && beforeDropFile(item)\n                );\n              })\n            : true;\n        },\n        {\n          filterItems: function filterItems(items) {\n            var ignoredFiles = root.query('GET_IGNORED_FILES');\n            return items.filter(function(item) {\n              if (isFile(item)) {\n                return !ignoredFiles.includes(item.name.toLowerCase());\n              }\n              return true;\n            });\n          },\n          catchesDropsOnPage: root.query('GET_DROP_ON_PAGE'),\n          requiresDropOnElement: root.query('GET_DROP_ON_ELEMENT')\n        }\n      );\n\n      hopper.onload = function(items, position) {\n        // get item children elements and sort based on list sort\n        var list = root.ref.list.childViews[0];\n        var visibleChildren = list.childViews.filter(function(child) {\n          return child.rect.element.height;\n        });\n        var children = root\n          .query('GET_ACTIVE_ITEMS')\n          .map(function(item) {\n            return visibleChildren.find(function(child) {\n              return child.id === item.id;\n            });\n          })\n          .filter(function(item) {\n            return item;\n          });\n\n        applyFilterChain('ADD_ITEMS', items, { dispatch: root.dispatch }).then(\n          function(queue) {\n            // these files don't fit so stop here\n            if (exceedsMaxFiles(root, queue)) return false;\n\n            // go\n            root.dispatch('ADD_ITEMS', {\n              items: queue,\n              index: getDragIndex(root.ref.list, children, position),\n              interactionMethod: InteractionMethod.DROP\n            });\n          }\n        );\n\n        root.dispatch('DID_DROP', { position: position });\n\n        root.dispatch('DID_END_DRAG', { position: position });\n      };\n\n      hopper.ondragstart = function(position) {\n        root.dispatch('DID_START_DRAG', { position: position });\n      };\n\n      hopper.ondrag = debounce(function(position) {\n        root.dispatch('DID_DRAG', { position: position });\n      });\n\n      hopper.ondragend = function(position) {\n        root.dispatch('DID_END_DRAG', { position: position });\n      };\n\n      root.ref.hopper = hopper;\n\n      root.ref.drip = root.appendChildView(root.createChildView(drip));\n    } else if (!enabled && root.ref.hopper) {\n      root.ref.hopper.destroy();\n      root.ref.hopper = null;\n      root.removeChildView(root.ref.drip);\n    }\n  };\n\n  /**\n   * Enable or disable browse functionality\n   */\n  var toggleBrowse = function toggleBrowse(root, props) {\n    var isAllowed = root.query('GET_ALLOW_BROWSE');\n    var isDisabled = root.query('GET_DISABLED');\n    var enabled = isAllowed && !isDisabled;\n    if (enabled && !root.ref.browser) {\n      root.ref.browser = root.appendChildView(\n        root.createChildView(\n          browser,\n          Object.assign({}, props, {\n            onload: function onload(items) {\n              applyFilterChain('ADD_ITEMS', items, {\n                dispatch: root.dispatch\n              }).then(function(queue) {\n                // these files don't fit so stop here\n                if (exceedsMaxFiles(root, queue)) return false;\n\n                // add items!\n                root.dispatch('ADD_ITEMS', {\n                  items: queue,\n                  index: -1,\n                  interactionMethod: InteractionMethod.BROWSE\n                });\n              });\n            }\n          })\n        ),\n\n        0\n      );\n    } else if (!enabled && root.ref.browser) {\n      root.removeChildView(root.ref.browser);\n      root.ref.browser = null;\n    }\n  };\n\n  /**\n   * Enable or disable paste functionality\n   */\n  var togglePaste = function togglePaste(root) {\n    var isAllowed = root.query('GET_ALLOW_PASTE');\n    var isDisabled = root.query('GET_DISABLED');\n    var enabled = isAllowed && !isDisabled;\n    if (enabled && !root.ref.paster) {\n      root.ref.paster = createPaster();\n      root.ref.paster.onload = function(items) {\n        applyFilterChain('ADD_ITEMS', items, { dispatch: root.dispatch }).then(\n          function(queue) {\n            // these files don't fit so stop here\n            if (exceedsMaxFiles(root, queue)) return false;\n\n            // add items!\n            root.dispatch('ADD_ITEMS', {\n              items: queue,\n              index: -1,\n              interactionMethod: InteractionMethod.PASTE\n            });\n          }\n        );\n      };\n    } else if (!enabled && root.ref.paster) {\n      root.ref.paster.destroy();\n      root.ref.paster = null;\n    }\n  };\n\n  /**\n   * Route actions\n   */\n  var route$5 = createRoute({\n    DID_SET_ALLOW_BROWSE: function DID_SET_ALLOW_BROWSE(_ref5) {\n      var root = _ref5.root,\n        props = _ref5.props;\n      toggleBrowse(root, props);\n    },\n    DID_SET_ALLOW_DROP: function DID_SET_ALLOW_DROP(_ref6) {\n      var root = _ref6.root;\n      toggleDrop(root);\n    },\n    DID_SET_ALLOW_PASTE: function DID_SET_ALLOW_PASTE(_ref7) {\n      var root = _ref7.root;\n      togglePaste(root);\n    },\n    DID_SET_DISABLED: function DID_SET_DISABLED(_ref8) {\n      var root = _ref8.root,\n        props = _ref8.props;\n      toggleDrop(root);\n      togglePaste(root);\n      toggleBrowse(root, props);\n      var isDisabled = root.query('GET_DISABLED');\n      if (isDisabled) {\n        root.element.dataset.disabled = 'disabled';\n      } else {\n        // delete root.element.dataset.disabled; <= this does not work on iOS 10\n        root.element.removeAttribute('data-disabled');\n      }\n    }\n  });\n\n  var root = createView({\n    name: 'root',\n    read: function read(_ref9) {\n      var root = _ref9.root;\n      if (root.ref.measure) {\n        root.ref.measureHeight = root.ref.measure.offsetHeight;\n      }\n    },\n    create: create$e,\n    write: write$9,\n    destroy: function destroy(_ref10) {\n      var root = _ref10.root;\n      if (root.ref.paster) {\n        root.ref.paster.destroy();\n      }\n      if (root.ref.hopper) {\n        root.ref.hopper.destroy();\n      }\n      root.element.removeEventListener('touchmove', prevent);\n      root.element.removeEventListener('gesturestart', prevent);\n    },\n    mixins: {\n      styles: ['height']\n    }\n  });\n\n  // creates the app\n  var createApp = function createApp() {\n    var initialOptions =\n      arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    // let element\n    var originalElement = null;\n\n    // get default options\n    var defaultOptions = getOptions();\n\n    // create the data store, this will contain all our app info\n    var store = createStore(\n      // initial state (should be serializable)\n      createInitialState(defaultOptions),\n\n      // queries\n      [queries, createOptionQueries(defaultOptions)],\n\n      // action handlers\n      [actions, createOptionActions(defaultOptions)]\n    );\n\n    // set initial options\n    store.dispatch('SET_OPTIONS', { options: initialOptions });\n\n    // kick thread if visibility changes\n    var visibilityHandler = function visibilityHandler() {\n      if (document.hidden) return;\n      store.dispatch('KICK');\n    };\n    document.addEventListener('visibilitychange', visibilityHandler);\n\n    // re-render on window resize start and finish\n    var resizeDoneTimer = null;\n    var isResizing = false;\n    var isResizingHorizontally = false;\n    var initialWindowWidth = null;\n    var currentWindowWidth = null;\n    var resizeHandler = function resizeHandler() {\n      if (!isResizing) {\n        isResizing = true;\n      }\n      clearTimeout(resizeDoneTimer);\n      resizeDoneTimer = setTimeout(function() {\n        isResizing = false;\n        initialWindowWidth = null;\n        currentWindowWidth = null;\n        if (isResizingHorizontally) {\n          isResizingHorizontally = false;\n          store.dispatch('DID_STOP_RESIZE');\n        }\n      }, 500);\n    };\n    window.addEventListener('resize', resizeHandler);\n\n    // render initial view\n    var view = root(store, { id: getUniqueId() });\n\n    //\n    // PRIVATE API -------------------------------------------------------------------------------------\n    //\n    var isResting = false;\n    var isHidden = false;\n\n    var readWriteApi = {\n      // necessary for update loop\n\n      /**\n       * Reads from dom (never call manually)\n       * @private\n       */\n      _read: function _read() {\n        // test if we're resizing horizontally\n        // TODO: see if we can optimize this by measuring root rect\n        if (isResizing) {\n          currentWindowWidth = window.innerWidth;\n          if (!initialWindowWidth) {\n            initialWindowWidth = currentWindowWidth;\n          }\n\n          if (\n            !isResizingHorizontally &&\n            currentWindowWidth !== initialWindowWidth\n          ) {\n            store.dispatch('DID_START_RESIZE');\n            isResizingHorizontally = true;\n          }\n        }\n\n        if (isHidden && isResting) {\n          // test if is no longer hidden\n          isResting = view.element.offsetParent === null;\n        }\n\n        // if resting, no need to read as numbers will still all be correct\n        if (isResting) return;\n\n        // read view data\n        view._read();\n\n        // if is hidden we need to know so we exit rest mode when revealed\n        isHidden = view.rect.element.hidden;\n      },\n\n      /**\n       * Writes to dom (never call manually)\n       * @private\n       */\n      _write: function _write(ts) {\n        // get all actions from store\n        var actions = store\n          .processActionQueue()\n\n          // filter out set actions (these will automatically trigger DID_SET)\n          .filter(function(action) {\n            return !/^SET_/.test(action.type);\n          });\n\n        // if was idling and no actions stop here\n        if (isResting && !actions.length) return;\n\n        // some actions might trigger events\n        routeActionsToEvents(actions);\n\n        // update the view\n        isResting = view._write(ts, actions, isResizingHorizontally);\n\n        // will clean up all archived items\n        removeReleasedItems(store.query('GET_ITEMS'));\n\n        // now idling\n        if (isResting) {\n          store.processDispatchQueue();\n        }\n      }\n    };\n\n    //\n    // EXPOSE EVENTS -------------------------------------------------------------------------------------\n    //\n    var createEvent = function createEvent(name) {\n      return function(data) {\n        // create default event\n        var event = {\n          type: name\n        };\n\n        // no data to add\n        if (!data) {\n          return event;\n        }\n\n        // copy relevant props\n        if (data.hasOwnProperty('error')) {\n          event.error = data.error ? Object.assign({}, data.error) : null;\n        }\n\n        if (data.status) {\n          event.status = Object.assign({}, data.status);\n        }\n\n        if (data.file) {\n          event.output = data.file;\n        }\n\n        // only source is available, else add item if possible\n        if (data.source) {\n          event.file = data.source;\n        } else if (data.item || data.id) {\n          var item = data.item ? data.item : store.query('GET_ITEM', data.id);\n          event.file = item ? createItemAPI(item) : null;\n        }\n\n        // map all items in a possible items array\n        if (data.items) {\n          event.items = data.items.map(createItemAPI);\n        }\n\n        // if this is a progress event add the progress amount\n        if (/progress/.test(name)) {\n          event.progress = data.progress;\n        }\n\n        // copy relevant props\n        if (data.hasOwnProperty('origin') && data.hasOwnProperty('target')) {\n          event.origin = data.origin;\n          event.target = data.target;\n        }\n\n        return event;\n      };\n    };\n\n    var eventRoutes = {\n      DID_DESTROY: createEvent('destroy'),\n\n      DID_INIT: createEvent('init'),\n\n      DID_THROW_MAX_FILES: createEvent('warning'),\n\n      DID_INIT_ITEM: createEvent('initfile'),\n      DID_START_ITEM_LOAD: createEvent('addfilestart'),\n      DID_UPDATE_ITEM_LOAD_PROGRESS: createEvent('addfileprogress'),\n      DID_LOAD_ITEM: createEvent('addfile'),\n\n      DID_THROW_ITEM_INVALID: [createEvent('error'), createEvent('addfile')],\n\n      DID_THROW_ITEM_LOAD_ERROR: [createEvent('error'), createEvent('addfile')],\n\n      DID_THROW_ITEM_REMOVE_ERROR: [\n        createEvent('error'),\n        createEvent('removefile')\n      ],\n\n      DID_PREPARE_OUTPUT: createEvent('preparefile'),\n\n      DID_START_ITEM_PROCESSING: createEvent('processfilestart'),\n      DID_UPDATE_ITEM_PROCESS_PROGRESS: createEvent('processfileprogress'),\n      DID_ABORT_ITEM_PROCESSING: createEvent('processfileabort'),\n      DID_COMPLETE_ITEM_PROCESSING: createEvent('processfile'),\n      DID_COMPLETE_ITEM_PROCESSING_ALL: createEvent('processfiles'),\n      DID_REVERT_ITEM_PROCESSING: createEvent('processfilerevert'),\n\n      DID_THROW_ITEM_PROCESSING_ERROR: [\n        createEvent('error'),\n        createEvent('processfile')\n      ],\n\n      DID_REMOVE_ITEM: createEvent('removefile'),\n\n      DID_UPDATE_ITEMS: createEvent('updatefiles'),\n\n      DID_ACTIVATE_ITEM: createEvent('activatefile'),\n\n      DID_REORDER_ITEMS: createEvent('reorderfiles')\n    };\n\n    var exposeEvent = function exposeEvent(event) {\n      // create event object to be dispatched\n      var detail = Object.assign({ pond: exports }, event);\n      delete detail.type;\n      view.element.dispatchEvent(\n        new CustomEvent('FilePond:' + event.type, {\n          // event info\n          detail: detail,\n\n          // event behaviour\n          bubbles: true,\n          cancelable: true,\n          composed: true // triggers listeners outside of shadow root\n        })\n      );\n\n      // event object to params used for `on()` event handlers and callbacks `oninit()`\n      var params = [];\n\n      // if is possible error event, make it the first param\n      if (event.hasOwnProperty('error')) {\n        params.push(event.error);\n      }\n\n      // file is always section\n      if (event.hasOwnProperty('file')) {\n        params.push(event.file);\n      }\n\n      // append other props\n      var filtered = ['type', 'error', 'file'];\n      Object.keys(event)\n        .filter(function(key) {\n          return !filtered.includes(key);\n        })\n        .forEach(function(key) {\n          return params.push(event[key]);\n        });\n\n      // on(type, () => { })\n      exports.fire.apply(exports, [event.type].concat(params));\n\n      // oninit = () => {}\n      var handler = store.query('GET_ON' + event.type.toUpperCase());\n      if (handler) {\n        handler.apply(void 0, params);\n      }\n    };\n\n    var routeActionsToEvents = function routeActionsToEvents(actions) {\n      if (!actions.length) return;\n      actions\n        .filter(function(action) {\n          return eventRoutes[action.type];\n        })\n        .forEach(function(action) {\n          var routes = eventRoutes[action.type];\n          (Array.isArray(routes) ? routes : [routes]).forEach(function(route) {\n            // this isn't fantastic, but because of the stacking of settimeouts plugins can handle the did_load before the did_init\n            if (action.type === 'DID_INIT_ITEM') {\n              exposeEvent(route(action.data));\n            } else {\n              setTimeout(function() {\n                exposeEvent(route(action.data));\n              }, 0);\n            }\n          });\n        });\n    };\n\n    //\n    // PUBLIC API -------------------------------------------------------------------------------------\n    //\n    var setOptions = function setOptions(options) {\n      return store.dispatch('SET_OPTIONS', { options: options });\n    };\n\n    var getFile = function getFile(query) {\n      return store.query('GET_ACTIVE_ITEM', query);\n    };\n\n    var prepareFile = function prepareFile(query) {\n      return new Promise(function(resolve, reject) {\n        store.dispatch('REQUEST_ITEM_PREPARE', {\n          query: query,\n          success: function success(item) {\n            resolve(item);\n          },\n          failure: function failure(error) {\n            reject(error);\n          }\n        });\n      });\n    };\n\n    var addFile = function addFile(source) {\n      var options =\n        arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      return new Promise(function(resolve, reject) {\n        addFiles([{ source: source, options: options }], {\n          index: options.index\n        })\n          .then(function(items) {\n            return resolve(items && items[0]);\n          })\n          .catch(reject);\n      });\n    };\n\n    var isFilePondFile = function isFilePondFile(obj) {\n      return obj.file && obj.id;\n    };\n\n    var removeFile = function removeFile(query, options) {\n      // if only passed options\n      if (typeof query === 'object' && !isFilePondFile(query) && !options) {\n        options = query;\n        query = undefined;\n      }\n\n      // request item removal\n      store.dispatch(\n        'REMOVE_ITEM',\n        Object.assign({}, options, { query: query })\n      );\n\n      // see if item has been removed\n      return store.query('GET_ACTIVE_ITEM', query) === null;\n    };\n\n    var addFiles = function addFiles() {\n      for (\n        var _len = arguments.length, args = new Array(_len), _key = 0;\n        _key < _len;\n        _key++\n      ) {\n        args[_key] = arguments[_key];\n      }\n      return new Promise(function(resolve, reject) {\n        var sources = [];\n        var options = {};\n\n        // user passed a sources array\n        if (isArray(args[0])) {\n          sources.push.apply(sources, args[0]);\n          Object.assign(options, args[1] || {});\n        } else {\n          // user passed sources as arguments, last one might be options object\n          var lastArgument = args[args.length - 1];\n          if (\n            typeof lastArgument === 'object' &&\n            !(lastArgument instanceof Blob)\n          ) {\n            Object.assign(options, args.pop());\n          }\n\n          // add rest to sources\n          sources.push.apply(sources, args);\n        }\n\n        store.dispatch('ADD_ITEMS', {\n          items: sources,\n          index: options.index,\n          interactionMethod: InteractionMethod.API,\n          success: resolve,\n          failure: reject\n        });\n      });\n    };\n\n    var getFiles = function getFiles() {\n      return store.query('GET_ACTIVE_ITEMS');\n    };\n\n    var processFile = function processFile(query) {\n      return new Promise(function(resolve, reject) {\n        store.dispatch('REQUEST_ITEM_PROCESSING', {\n          query: query,\n          success: function success(item) {\n            resolve(item);\n          },\n          failure: function failure(error) {\n            reject(error);\n          }\n        });\n      });\n    };\n\n    var prepareFiles = function prepareFiles() {\n      for (\n        var _len2 = arguments.length, args = new Array(_len2), _key2 = 0;\n        _key2 < _len2;\n        _key2++\n      ) {\n        args[_key2] = arguments[_key2];\n      }\n      var queries = Array.isArray(args[0]) ? args[0] : args;\n      var items = queries.length ? queries : getFiles();\n      return Promise.all(items.map(prepareFile));\n    };\n\n    var processFiles = function processFiles() {\n      for (\n        var _len3 = arguments.length, args = new Array(_len3), _key3 = 0;\n        _key3 < _len3;\n        _key3++\n      ) {\n        args[_key3] = arguments[_key3];\n      }\n      var queries = Array.isArray(args[0]) ? args[0] : args;\n      if (!queries.length) {\n        var files = getFiles().filter(function(item) {\n          return (\n            !(\n              item.status === ItemStatus.IDLE &&\n              item.origin === FileOrigin.LOCAL\n            ) &&\n            item.status !== ItemStatus.PROCESSING &&\n            item.status !== ItemStatus.PROCESSING_COMPLETE &&\n            item.status !== ItemStatus.PROCESSING_REVERT_ERROR\n          );\n        });\n\n        return Promise.all(files.map(processFile));\n      }\n      return Promise.all(queries.map(processFile));\n    };\n\n    var removeFiles = function removeFiles() {\n      for (\n        var _len4 = arguments.length, args = new Array(_len4), _key4 = 0;\n        _key4 < _len4;\n        _key4++\n      ) {\n        args[_key4] = arguments[_key4];\n      }\n\n      var queries = Array.isArray(args[0]) ? args[0] : args;\n\n      var options;\n      if (typeof queries[queries.length - 1] === 'object') {\n        options = queries.pop();\n      } else if (Array.isArray(args[0])) {\n        options = args[1];\n      }\n\n      var files = getFiles();\n\n      if (!queries.length)\n        return Promise.all(\n          files.map(function(file) {\n            return removeFile(file, options);\n          })\n        );\n\n      // when removing by index the indexes shift after each file removal so we need to convert indexes to ids\n      var mappedQueries = queries\n        .map(function(query) {\n          return isNumber(query)\n            ? files[query]\n              ? files[query].id\n              : null\n            : query;\n        })\n        .filter(function(query) {\n          return query;\n        });\n\n      return mappedQueries.map(function(q) {\n        return removeFile(q, options);\n      });\n    };\n\n    var exports = Object.assign(\n      {},\n\n      on(),\n      {},\n\n      readWriteApi,\n      {},\n\n      createOptionAPI(store, defaultOptions),\n      {\n        /**\n         * Override options defined in options object\n         * @param options\n         */\n        setOptions: setOptions,\n\n        /**\n         * Load the given file\n         * @param source - the source of the file (either a File, base64 data uri or url)\n         * @param options - object, { index: 0 }\n         */\n        addFile: addFile,\n\n        /**\n         * Load the given files\n         * @param sources - the sources of the files to load\n         * @param options - object, { index: 0 }\n         */\n        addFiles: addFiles,\n\n        /**\n         * Returns the file objects matching the given query\n         * @param query { string, number, null }\n         */\n        getFile: getFile,\n\n        /**\n         * Upload file with given name\n         * @param query { string, number, null  }\n         */\n        processFile: processFile,\n\n        /**\n         * Request prepare output for file with given name\n         * @param query { string, number, null  }\n         */\n        prepareFile: prepareFile,\n\n        /**\n         * Removes a file by its name\n         * @param query { string, number, null  }\n         */\n        removeFile: removeFile,\n\n        /**\n         * Moves a file to a new location in the files list\n         */\n        moveFile: function moveFile(query, index) {\n          return store.dispatch('MOVE_ITEM', { query: query, index: index });\n        },\n\n        /**\n         * Returns all files (wrapped in public api)\n         */\n        getFiles: getFiles,\n\n        /**\n         * Starts uploading all files\n         */\n        processFiles: processFiles,\n\n        /**\n         * Clears all files from the files list\n         */\n        removeFiles: removeFiles,\n\n        /**\n         * Starts preparing output of all files\n         */\n        prepareFiles: prepareFiles,\n\n        /**\n         * Sort list of files\n         */\n        sort: function sort(compare) {\n          return store.dispatch('SORT', { compare: compare });\n        },\n\n        /**\n         * Browse the file system for a file\n         */\n        browse: function browse() {\n          // needs to be trigger directly as user action needs to be traceable (is not traceable in requestAnimationFrame)\n          var input = view.element.querySelector('input[type=file]');\n          if (input) {\n            input.click();\n          }\n        },\n\n        /**\n         * Destroys the app\n         */\n        destroy: function destroy() {\n          // request destruction\n          exports.fire('destroy', view.element);\n\n          // stop active processes (file uploads, fetches, stuff like that)\n          // loop over items and depending on states call abort for ongoing processes\n          store.dispatch('ABORT_ALL');\n\n          // destroy view\n          view._destroy();\n\n          // stop listening to resize\n          window.removeEventListener('resize', resizeHandler);\n\n          // stop listening to the visiblitychange event\n          document.removeEventListener('visibilitychange', visibilityHandler);\n\n          // dispatch destroy\n          store.dispatch('DID_DESTROY');\n        },\n\n        /**\n         * Inserts the plugin before the target element\n         */\n        insertBefore: function insertBefore$1(element) {\n          return insertBefore(view.element, element);\n        },\n\n        /**\n         * Inserts the plugin after the target element\n         */\n        insertAfter: function insertAfter$1(element) {\n          return insertAfter(view.element, element);\n        },\n\n        /**\n         * Appends the plugin to the target element\n         */\n        appendTo: function appendTo(element) {\n          return element.appendChild(view.element);\n        },\n\n        /**\n         * Replaces an element with the app\n         */\n        replaceElement: function replaceElement(element) {\n          // insert the app before the element\n          insertBefore(view.element, element);\n\n          // remove the original element\n          element.parentNode.removeChild(element);\n\n          // remember original element\n          originalElement = element;\n        },\n\n        /**\n         * Restores the original element\n         */\n        restoreElement: function restoreElement() {\n          if (!originalElement) {\n            return; // no element to restore\n          }\n\n          // restore original element\n          insertAfter(originalElement, view.element);\n\n          // remove our element\n          view.element.parentNode.removeChild(view.element);\n\n          // remove reference\n          originalElement = null;\n        },\n\n        /**\n         * Returns true if the app root is attached to given element\n         * @param element\n         */\n        isAttachedTo: function isAttachedTo(element) {\n          return view.element === element || originalElement === element;\n        },\n\n        /**\n         * Returns the root element\n         */\n        element: {\n          get: function get() {\n            return view.element;\n          }\n        },\n\n        /**\n         * Returns the current pond status\n         */\n        status: {\n          get: function get() {\n            return store.query('GET_STATUS');\n          }\n        }\n      }\n    );\n\n    // Done!\n    store.dispatch('DID_INIT');\n\n    // create actual api object\n    return createObject(exports);\n  };\n\n  var createAppObject = function createAppObject() {\n    var customOptions =\n      arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    // default options\n    var defaultOptions = {};\n    forin(getOptions(), function(key, value) {\n      defaultOptions[key] = value[0];\n    });\n\n    // set app options\n    var app = createApp(\n      Object.assign(\n        {},\n\n        defaultOptions,\n        {},\n\n        customOptions\n      )\n    );\n\n    // return the plugin instance\n    return app;\n  };\n\n  var lowerCaseFirstLetter = function lowerCaseFirstLetter(string) {\n    return string.charAt(0).toLowerCase() + string.slice(1);\n  };\n\n  var attributeNameToPropertyName = function attributeNameToPropertyName(\n    attributeName\n  ) {\n    return toCamels(attributeName.replace(/^data-/, ''));\n  };\n\n  var mapObject = function mapObject(object, propertyMap) {\n    // remove unwanted\n    forin(propertyMap, function(selector, mapping) {\n      forin(object, function(property, value) {\n        // create regexp shortcut\n        var selectorRegExp = new RegExp(selector);\n\n        // tests if\n        var matches = selectorRegExp.test(property);\n\n        // no match, skip\n        if (!matches) {\n          return;\n        }\n\n        // if there's a mapping, the original property is always removed\n        delete object[property];\n\n        // should only remove, we done!\n        if (mapping === false) {\n          return;\n        }\n\n        // move value to new property\n        if (isString(mapping)) {\n          object[mapping] = value;\n          return;\n        }\n\n        // move to group\n        var group = mapping.group;\n        if (isObject(mapping) && !object[group]) {\n          object[group] = {};\n        }\n\n        object[group][\n          lowerCaseFirstLetter(property.replace(selectorRegExp, ''))\n        ] = value;\n      });\n\n      // do submapping\n      if (mapping.mapping) {\n        mapObject(object[mapping.group], mapping.mapping);\n      }\n    });\n  };\n\n  var getAttributesAsObject = function getAttributesAsObject(node) {\n    var attributeMapping =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    // turn attributes into object\n    var attributes = [];\n    forin(node.attributes, function(index) {\n      attributes.push(node.attributes[index]);\n    });\n\n    var output = attributes\n      .filter(function(attribute) {\n        return attribute.name;\n      })\n      .reduce(function(obj, attribute) {\n        var value = attr(node, attribute.name);\n\n        obj[attributeNameToPropertyName(attribute.name)] =\n          value === attribute.name ? true : value;\n        return obj;\n      }, {});\n\n    // do mapping of object properties\n    mapObject(output, attributeMapping);\n\n    return output;\n  };\n\n  var createAppAtElement = function createAppAtElement(element) {\n    var options =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    // how attributes of the input element are mapped to the options for the plugin\n    var attributeMapping = {\n      // translate to other name\n      '^class$': 'className',\n      '^multiple$': 'allowMultiple',\n      '^capture$': 'captureMethod',\n      '^webkitdirectory$': 'allowDirectoriesOnly',\n\n      // group under single property\n      '^server': {\n        group: 'server',\n        mapping: {\n          '^process': {\n            group: 'process'\n          },\n\n          '^revert': {\n            group: 'revert'\n          },\n\n          '^fetch': {\n            group: 'fetch'\n          },\n\n          '^restore': {\n            group: 'restore'\n          },\n\n          '^load': {\n            group: 'load'\n          }\n        }\n      },\n\n      // don't include in object\n      '^type$': false,\n      '^files$': false\n    };\n\n    // add additional option translators\n    applyFilters('SET_ATTRIBUTE_TO_OPTION_MAP', attributeMapping);\n\n    // create final options object by setting options object and then overriding options supplied on element\n    var mergedOptions = Object.assign({}, options);\n\n    var attributeOptions = getAttributesAsObject(\n      element.nodeName === 'FIELDSET'\n        ? element.querySelector('input[type=file]')\n        : element,\n      attributeMapping\n    );\n\n    // merge with options object\n    Object.keys(attributeOptions).forEach(function(key) {\n      if (isObject(attributeOptions[key])) {\n        if (!isObject(mergedOptions[key])) {\n          mergedOptions[key] = {};\n        }\n        Object.assign(mergedOptions[key], attributeOptions[key]);\n      } else {\n        mergedOptions[key] = attributeOptions[key];\n      }\n    });\n\n    // if parent is a fieldset, get files from parent by selecting all input fields that are not file upload fields\n    // these will then be automatically set to the initial files\n    mergedOptions.files = (options.files || []).concat(\n      Array.from(element.querySelectorAll('input:not([type=file])')).map(\n        function(input) {\n          return {\n            source: input.value,\n            options: {\n              type: input.dataset.type\n            }\n          };\n        }\n      )\n    );\n\n    // build plugin\n    var app = createAppObject(mergedOptions);\n\n    // add already selected files\n    if (element.files) {\n      Array.from(element.files).forEach(function(file) {\n        app.addFile(file);\n      });\n    }\n\n    // replace the target element\n    app.replaceElement(element);\n\n    // expose\n    return app;\n  };\n\n  // if an element is passed, we create the instance at that element, if not, we just create an up object\n  var createApp$1 = function createApp() {\n    return isNode(arguments.length <= 0 ? undefined : arguments[0])\n      ? createAppAtElement.apply(void 0, arguments)\n      : createAppObject.apply(void 0, arguments);\n  };\n\n  var PRIVATE_METHODS = ['fire', '_read', '_write'];\n\n  var createAppAPI = function createAppAPI(app) {\n    var api = {};\n\n    copyObjectPropertiesToObject(app, api, PRIVATE_METHODS);\n\n    return api;\n  };\n\n  /**\n   * Replaces placeholders in given string with replacements\n   * @param string - \"Foo {bar}\"\"\n   * @param replacements - { \"bar\": 10 }\n   */\n  var replaceInString = function replaceInString(string, replacements) {\n    return string.replace(/(?:{([a-zA-Z]+)})/g, function(match, group) {\n      return replacements[group];\n    });\n  };\n\n  var createWorker = function createWorker(fn) {\n    var workerBlob = new Blob(['(', fn.toString(), ')()'], {\n      type: 'application/javascript'\n    });\n\n    var workerURL = URL.createObjectURL(workerBlob);\n    var worker = new Worker(workerURL);\n\n    return {\n      transfer: function transfer(message, cb) {},\n      post: function post(message, cb, transferList) {\n        var id = getUniqueId();\n\n        worker.onmessage = function(e) {\n          if (e.data.id === id) {\n            cb(e.data.message);\n          }\n        };\n\n        worker.postMessage(\n          {\n            id: id,\n            message: message\n          },\n\n          transferList\n        );\n      },\n      terminate: function terminate() {\n        worker.terminate();\n        URL.revokeObjectURL(workerURL);\n      }\n    };\n  };\n\n  var loadImage = function loadImage(url) {\n    return new Promise(function(resolve, reject) {\n      var img = new Image();\n      img.onload = function() {\n        resolve(img);\n      };\n      img.onerror = function(e) {\n        reject(e);\n      };\n      img.src = url;\n    });\n  };\n\n  var renameFile = function renameFile(file, name) {\n    var renamedFile = file.slice(0, file.size, file.type);\n    renamedFile.lastModifiedDate = file.lastModifiedDate;\n    renamedFile.name = name;\n    return renamedFile;\n  };\n\n  var copyFile = function copyFile(file) {\n    return renameFile(file, file.name);\n  };\n\n  // already registered plugins (can't register twice)\n  var registeredPlugins = [];\n\n  // pass utils to plugin\n  var createAppPlugin = function createAppPlugin(plugin) {\n    // already registered\n    if (registeredPlugins.includes(plugin)) {\n      return;\n    }\n\n    // remember this plugin\n    registeredPlugins.push(plugin);\n\n    // setup!\n    var pluginOutline = plugin({\n      addFilter: addFilter,\n      utils: {\n        Type: Type,\n        forin: forin,\n        isString: isString,\n        isFile: isFile,\n        toNaturalFileSize: toNaturalFileSize,\n        replaceInString: replaceInString,\n        getExtensionFromFilename: getExtensionFromFilename,\n        getFilenameWithoutExtension: getFilenameWithoutExtension,\n        guesstimateMimeType: guesstimateMimeType,\n        getFileFromBlob: getFileFromBlob,\n        getFilenameFromURL: getFilenameFromURL,\n        createRoute: createRoute,\n        createWorker: createWorker,\n        createView: createView,\n        createItemAPI: createItemAPI,\n        loadImage: loadImage,\n        copyFile: copyFile,\n        renameFile: renameFile,\n        createBlob: createBlob,\n        applyFilterChain: applyFilterChain,\n        text: text,\n        getNumericAspectRatioFromString: getNumericAspectRatioFromString\n      },\n\n      views: {\n        fileActionButton: fileActionButton\n      }\n    });\n\n    // add plugin options to default options\n    extendDefaultOptions(pluginOutline.options);\n  };\n\n  // feature detection used by supported() method\n  var isOperaMini = function isOperaMini() {\n    return (\n      Object.prototype.toString.call(window.operamini) === '[object OperaMini]'\n    );\n  };\n  var hasPromises = function hasPromises() {\n    return 'Promise' in window;\n  };\n  var hasBlobSlice = function hasBlobSlice() {\n    return 'slice' in Blob.prototype;\n  };\n  var hasCreateObjectURL = function hasCreateObjectURL() {\n    return 'URL' in window && 'createObjectURL' in window.URL;\n  };\n  var hasVisibility = function hasVisibility() {\n    return 'visibilityState' in document;\n  };\n  var hasTiming = function hasTiming() {\n    return 'performance' in window;\n  }; // iOS 8.x\n  var hasCSSSupports = function hasCSSSupports() {\n    return 'supports' in (window.CSS || {});\n  }; // use to detect Safari 9+\n  var isIE11 = function isIE11() {\n    return /MSIE|Trident/.test(window.navigator.userAgent);\n  };\n\n  var supported = (function() {\n    // Runs immediately and then remembers result for subsequent calls\n    var isSupported =\n      // Has to be a browser\n      isBrowser() &&\n      // Can't run on Opera Mini due to lack of everything\n      !isOperaMini() &&\n      // Require these APIs to feature detect a modern browser\n      hasVisibility() &&\n      hasPromises() &&\n      hasBlobSlice() &&\n      hasCreateObjectURL() &&\n      hasTiming() &&\n      // doesn't need CSSSupports but is a good way to detect Safari 9+ (we do want to support IE11 though)\n      (hasCSSSupports() || isIE11());\n\n    return function() {\n      return isSupported;\n    };\n  })();\n\n  /**\n   * Plugin internal state (over all instances)\n   */\n  var state = {\n    // active app instances, used to redraw the apps and to find the later\n    apps: []\n  };\n\n  // plugin name\n  var name = 'filepond';\n\n  /**\n   * Public Plugin methods\n   */\n  var fn = function fn() {};\n  exports.Status = {};\n  exports.FileStatus = {};\n  exports.FileOrigin = {};\n  exports.OptionTypes = {};\n  exports.create = fn;\n  exports.destroy = fn;\n  exports.parse = fn;\n  exports.find = fn;\n  exports.registerPlugin = fn;\n  exports.getOptions = fn;\n  exports.setOptions = fn;\n\n  // if not supported, no API\n  if (supported()) {\n    // start painter and fire load event\n    createPainter(\n      function() {\n        state.apps.forEach(function(app) {\n          return app._read();\n        });\n      },\n      function(ts) {\n        state.apps.forEach(function(app) {\n          return app._write(ts);\n        });\n      }\n    );\n\n    // fire loaded event so we know when FilePond is available\n    var dispatch = function dispatch() {\n      // let others know we have area ready\n      document.dispatchEvent(\n        new CustomEvent('FilePond:loaded', {\n          detail: {\n            supported: supported,\n            create: exports.create,\n            destroy: exports.destroy,\n            parse: exports.parse,\n            find: exports.find,\n            registerPlugin: exports.registerPlugin,\n            setOptions: exports.setOptions\n          }\n        })\n      );\n\n      // clean up event\n      document.removeEventListener('DOMContentLoaded', dispatch);\n    };\n\n    if (document.readyState !== 'loading') {\n      // move to back of execution queue, FilePond should have been exported by then\n      setTimeout(function() {\n        return dispatch();\n      }, 0);\n    } else {\n      document.addEventListener('DOMContentLoaded', dispatch);\n    }\n\n    // updates the OptionTypes object based on the current options\n    var updateOptionTypes = function updateOptionTypes() {\n      return forin(getOptions(), function(key, value) {\n        exports.OptionTypes[key] = value[1];\n      });\n    };\n\n    exports.Status = Object.assign({}, Status);\n    exports.FileOrigin = Object.assign({}, FileOrigin);\n    exports.FileStatus = Object.assign({}, ItemStatus);\n\n    exports.OptionTypes = {};\n    updateOptionTypes();\n\n    // create method, creates apps and adds them to the app array\n    exports.create = function create() {\n      var app = createApp$1.apply(void 0, arguments);\n      app.on('destroy', exports.destroy);\n      state.apps.push(app);\n      return createAppAPI(app);\n    };\n\n    // destroys apps and removes them from the app array\n    exports.destroy = function destroy(hook) {\n      // returns true if the app was destroyed successfully\n      var indexToRemove = state.apps.findIndex(function(app) {\n        return app.isAttachedTo(hook);\n      });\n      if (indexToRemove >= 0) {\n        // remove from apps\n        var app = state.apps.splice(indexToRemove, 1)[0];\n\n        // restore original dom element\n        app.restoreElement();\n\n        return true;\n      }\n\n      return false;\n    };\n\n    // parses the given context for plugins (does not include the context element itself)\n    exports.parse = function parse(context) {\n      // get all possible hooks\n      var matchedHooks = Array.from(context.querySelectorAll('.' + name));\n\n      // filter out already active hooks\n      var newHooks = matchedHooks.filter(function(newHook) {\n        return !state.apps.find(function(app) {\n          return app.isAttachedTo(newHook);\n        });\n      });\n\n      // create new instance for each hook\n      return newHooks.map(function(hook) {\n        return exports.create(hook);\n      });\n    };\n\n    // returns an app based on the given element hook\n    exports.find = function find(hook) {\n      var app = state.apps.find(function(app) {\n        return app.isAttachedTo(hook);\n      });\n      if (!app) {\n        return null;\n      }\n      return createAppAPI(app);\n    };\n\n    // adds a plugin extension\n    exports.registerPlugin = function registerPlugin() {\n      for (\n        var _len = arguments.length, plugins = new Array(_len), _key = 0;\n        _key < _len;\n        _key++\n      ) {\n        plugins[_key] = arguments[_key];\n      }\n\n      // register plugins\n      plugins.forEach(createAppPlugin);\n\n      // update OptionTypes, each plugin might have extended the default options\n      updateOptionTypes();\n    };\n\n    exports.getOptions = function getOptions$1() {\n      var opts = {};\n      forin(getOptions(), function(key, value) {\n        opts[key] = value[0];\n      });\n      return opts;\n    };\n\n    exports.setOptions = function setOptions$1(opts) {\n      if (isObject(opts)) {\n        // update existing plugins\n        state.apps.forEach(function(app) {\n          app.setOptions(opts);\n        });\n\n        // override defaults\n        setOptions(opts);\n      }\n\n      // return new options\n      return exports.getOptions();\n    };\n  }\n\n  exports.supported = supported;\n\n  Object.defineProperty(exports, '__esModule', { value: true });\n});\n","/*!\n * FilePondPluginGetFile 1.0.7\n * Licensed under MIT, https://opensource.org/licenses/MIT/\n * Please visit undefined for details.\n */\n\n/* eslint-disable */\n\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined'\n    ? (module.exports = factory())\n    : typeof define === 'function' && define.amd\n    ? define(factory)\n    : ((global =\n        typeof globalThis !== 'undefined' ? globalThis : global || self),\n      (global.FilePondPluginGetFile = factory()));\n})(this, function () {\n  'use strict';\n\n  /**\n   * Register the download component by inserting the download icon\n   */\n  const registerDownloadComponent = (\n    item,\n    el,\n    labelButtonDownload,\n    allowDownloadByUrl\n  ) => {\n    const info = el.querySelector('.filepond--file-info-main'),\n      downloadIcon = getDownloadIcon(labelButtonDownload);\n    info.prepend(downloadIcon);\n    downloadIcon.addEventListener('click', () =>\n      downloadFile(item, allowDownloadByUrl)\n    );\n  };\n  /**\n   * Generates the download icon\n   */\n\n  const getDownloadIcon = (labelButtonDownload) => {\n    let icon = document.createElement('span');\n    icon.className = 'filepond--download-icon';\n    icon.title = labelButtonDownload;\n    return icon;\n  };\n  /**\n   * Triggers the actual download of the uploaded file\n   */\n\n  const downloadFile = (item, allowDownloadByUrl) => {\n    // if client want to download file from remote server\n    if (allowDownloadByUrl && item.getMetadata('url')) {\n      location.href = item.getMetadata('url'); // full path to remote server is stored in metadata with key 'url'\n    } else {\n      // create a temporary hyperlink to force the browser to download the file\n      const a = document.createElement('a');\n      const url = window.URL.createObjectURL(item.file);\n      document.body.appendChild(a);\n      a.style.display = 'none';\n      a.href = url;\n      a.download = item.file.name;\n      a.click();\n      window.URL.revokeObjectURL(url);\n      a.remove();\n    }\n  };\n\n  /**\n   * Download Plugin\n   */\n\n  const plugin = (fpAPI) => {\n    const { addFilter, utils } = fpAPI;\n    const { Type, createRoute } = utils; // called for each view that is created right after the 'create' method\n\n    addFilter('CREATE_VIEW', (viewAPI) => {\n      // get reference to created view\n      const { is, view, query } = viewAPI; // only hook up to item view\n\n      if (!is('file')) {\n        return;\n      } // create the get file plugin\n\n      const didLoadItem = ({ root, props }) => {\n        const { id } = props;\n        const item = query('GET_ITEM', id);\n\n        if (!item || item.archived) {\n          return;\n        }\n\n        const labelButtonDownload = root.query(\n          'GET_LABEL_BUTTON_DOWNLOAD_ITEM'\n        );\n        const allowDownloadByUrl = root.query('GET_ALLOW_DOWNLOAD_BY_URL');\n        registerDownloadComponent(\n          item,\n          root.element,\n          labelButtonDownload,\n          allowDownloadByUrl\n        );\n      }; // start writing\n\n      view.registerWriter(\n        createRoute(\n          {\n            DID_LOAD_ITEM: didLoadItem,\n          },\n          ({ root, props }) => {\n            const { id } = props;\n            const item = query('GET_ITEM', id); // don't do anything while hidden\n\n            if (root.rect.element.hidden) return;\n          }\n        )\n      );\n    }); // expose plugin\n\n    return {\n      options: {\n        labelButtonDownloadItem: ['Download file', Type.STRING],\n        allowDownloadByUrl: [false, Type.BOOLEAN],\n      },\n    };\n  }; // fire pluginloaded event if running in browser, this allows registering the plugin when using async script tags\n\n  const isBrowser =\n    typeof window !== 'undefined' && typeof window.document !== 'undefined';\n\n  if (isBrowser) {\n    document.dispatchEvent(\n      new CustomEvent('FilePond:pluginloaded', {\n        detail: plugin,\n      })\n    );\n  }\n\n  return plugin;\n});\n"],"sourceRoot":""}