{"version":3,"sources":["webpack:///./node_modules/vue-filepond/dist/vue-filepond.js","webpack:///./node_modules/filepond-plugin-image-preview/dist/filepond-plugin-image-preview.js","webpack:///./node_modules/filepond-plugin-file-validate-size/dist/filepond-plugin-file-validate-size.js","webpack:///./node_modules/filepond-plugin-file-encode/dist/filepond-plugin-file-encode.js","webpack:///./node_modules/filepond-plugin-image-exif-orientation/dist/filepond-plugin-image-exif-orientation.js","webpack:///./node_modules/filepond/dist/filepond.js"],"names":["global","factory","globalThis","self","_exports","_vue","_filepond","_interopRequireDefault","obj","__esModule","default","Object","defineProperty","value","setOptions","filteredComponentMethods","isSupported","supported","getNativeConstructorFromType","type","string","String","boolean","Boolean","array","Array","function","Function","int","Number","serverapi","object","props","events","watch","instances","globalOptions","options","assign","forEach","instance","_default","registerPlugin","apply","arguments","length","_loop","prop","test","push","OptionTypes","this","_pond","component","name","render","h","attrs","id","className","required","multiple","allowMultiple","accept","acceptedFileTypes","capture","captureMethod","mounted","_this","_element","$el","querySelector","reduce","$emit","getFiles","_len","args","_key","substr","concat","$attrs","create","$options","propsData","keys","filter","key","includes","destroyed","_this2","detached","offsetParent","mutationHandler","mutations","observer","removedNodes","removedNode","contains","disconnect","call","MutationObserver","observe","document","documentElement","childList","subtree","destroy","index","indexOf","splice","module","exports","isPreviewableImage","file","_AwaitValue","wrapped","_AsyncGenerator","gen","front","back","send","arg","Promise","resolve","reject","request","next","resume","result","wrappedAwait","then","settle","done","err","_invoke","return","undefined","Symbol","asyncIterator","prototype","throw","_slicedToArray","arr","i","_arrayWithHoles","_iterableToArrayLimit","_nonIterableRest","isArray","_arr","_n","_d","_e","_s","_i","iterator","TypeError","vectorMultiply","v","amount","createVector","x","y","vectorAdd","a","b","vectorNormalize","l","Math","sqrt","vectorRotate","radians","origin","cos","sin","t","getMarkupValue","size","scalar","axis","parseFloat","min","width","height","getMarkupStyles","markup","scale","lineStyle","borderStyle","fill","backgroundColor","fontColor","stroke","borderColor","lineColor","strokeWidth","borderWidth","lineWidth","lineCap","lineJoin","dashes","map","join","opacity","isDefined","getMarkupRect","rect","left","top","right","bottom","pointsToPathShape","points","point","setAttributes","element","attr","setAttribute","ns","svg","tag","createElementNS","updateRect","styles","updateEllipse","cx","cy","rx","ry","IMAGE_FIT_STYLE","contain","cover","updateImage","preserveAspectRatio","fit","TEXT_ANCHOR","center","updateText","fontSize","fontFamily","fontWeight","textAlign","text","textContent","updateLine","line","childNodes","begin","end","target","x1","y1","x2","y2","lineDecoration","style","display","arrowBeginRotationPoint","arrowBeginCenter","arrowBeginA","arrowBeginB","d","arrowEndRotationPoint","arrowEndCenter","arrowEndA","arrowEndB","updatePath","createShape","node","createImage","shape","onload","setAttributeNS","src","createLine","appendChild","CREATE_TYPE_ROUTES","image","ellipse","path","UPDATE_TYPE_ROUTES","createMarkupByType","updateMarkupByType","MARKUP_RECT","toOptionalFraction","prepareMarkup","_markup","prev","curr","zIndex","sortMarkupByZIndex","createMarkupView","_","utils","createView","ignoreRect","mixins","apis","write","_ref","root","dirty","crop","resize","viewWidth","viewHeight","cropWidth","cropHeight","_size","outputWidth","outputHeight","outputFit","mode","outputUpscale","upscale","shouldUpscale","scalarWidth","scalarHeight","max","innerHTML","markupFilter","query","sort","settings","createVector$1","vectorDot","vectorSubtract","vectorDistanceSquared","vectorDistance","getOffsetPointOnEdge","rotation","A","B","C","sinA","sinB","sinC","cosC","ratio","c","getRotatedRectSize","w","hor","ver","tl","abs","tr","bl","calculateCanvasSize","canvasAspectRatio","zoom","imageAspectRatio","canvasWidth","canvasHeight","imgWidth","imgHeight","getImageRectZoomFactor","imageRect","cropRect","imageWidth","imageHeight","rotatedCropSize","getCenteredCropRect","container","aspectRatio","getCurrentCropSize","imageSize","canvasSize","canvasCenter","stage","shouldLimit","scaleToFit","stageZoomFactor","widthFloat","heightFloat","round","IMAGE_SCALE_SPRING_PROPS","stiffness","damping","mass","createBitmapView","createImageCanvasWrapper","animations","originX","originY","scaleX","scaleY","translateX","translateY","rotateZ","_ref2","ref","bitmap","appendChildView","createChildView","_ref3","flip","horizontal","vertical","createClipView","duration","didWriteView","_ref4","background","_ref5","createMarkup","destroyMarkup","removeChildView","transparencyIndicator","dataset","_ref6","shouldOptimize","translation","PI","cropAspectRatio","imageView","createImageView","_ref7","clip","_ref8","hidden","containerWidth","inner","containerHeight","fixedPreviewHeight","minPreviewHeight","maxPreviewHeight","panelAspectRatio","clipHeight","clipWidth","SVG_MASK","SVGMaskUniqueId","createImageOverlayView","fpAPI","mask","url","URL","window","location","href","replace","hash","classList","add","status","BitmapWorker","onmessage","e","createImageBitmap","data","message","postMessage","ColorMatrixWorker","imageData","matrix","colorMatrix","m11","m12","m13","m14","m15","m21","m22","m23","m24","m25","m31","m32","m33","m34","m35","m41","m42","m43","m44","m45","r","g","buffer","getImageSize","cb","Image","naturalWidth","naturalHeight","transforms","1","2","3","4","5","6","7","8","fixImageOrientation","ctx","orientation","transform","createPreviewImage","canvas","createElement","getContext","drawImage","isBitmap","MAX_WIDTH","MAX_HEIGHT","calculateAverageColor","ceil","getImageData","averageColor","floor","cloneCanvas","cloneImageData","ImageData","createImageData","set","Uint8ClampedArray","loadImage","img","crossOrigin","onerror","createImageWrapperView","OverlayView","ImageView","createWorker","applyFilter","putImageData","worker","post","response","terminate","removeImageView","_destroy","shiftImage","images","shift","imageViewBin","pushImage","item","getMetadata","childViews","setTimeout","dispatch","didUpdateItemMetadata","action","change","_imageView","canCreateImageBitmap","userAgent","navigator","isFirefox","match","firefoxVersion","parseInt","didCreatePreviewContainer","fileURL","createObjectURL","drawPreview","loadPreviewFallback","previewImageLoaded","revokeObjectURL","exif","pixelDensityFactor","devicePixelRatio","zoomFactor","scaleFactor","previewImageRatio","previewContainerWidth","previewContainerHeight","previewImage","setMetadata","close","overlayShadow","imageBitmap","didDrawPreview","restoreOverlay","_ref9","overlayError","overlaySuccess","didThrowError","_ref10","didCompleteProcessing","_ref11","_ref12","_ref13","_ref14","createRoute","DID_IMAGE_PREVIEW_DRAW","DID_IMAGE_PREVIEW_CONTAINER_CREATE","DID_FINISH_CALCULATE_PREVIEWSIZE","DID_UPDATE_ITEM_METADATA","DID_THROW_ITEM_LOAD_ERROR","DID_THROW_ITEM_PROCESSING_ERROR","DID_THROW_ITEM_INVALID","DID_COMPLETE_ITEM_PROCESSING","DID_START_ITEM_PROCESSING","DID_REVERT_ITEM_PROCESSING","_ref15","viewsToRemove","plugin","addFilter","Type","isFile","imagePreviewView","viewAPI","is","view","didLoadItem","archived","supportsCreateImageBitmap","maxPreviewFileSize","imagePreview","queue","rescaleItem","itemPanelAspectRatio","fixedHeight","_root$ref","previewAspectRatio","previewHeightMax","itemWidth","previewHeight","didResizeView","shouldRescale","didCalculatePreviewSize","shouldDrawPreview","registerWriter","DID_RESIZE_ROOT","DID_STOP_RESIZE","DID_LOAD_ITEM","DID_IMAGE_PREVIEW_CALCULATE_SIZE","requestAnimationFrame","allowImagePreview","BOOLEAN","imagePreviewFilterItem","FUNCTION","imagePreviewHeight","INT","imagePreviewMinHeight","imagePreviewMaxHeight","imagePreviewMaxFileSize","imagePreviewZoomFactor","imagePreviewUpscale","imagePreviewMaxInstantPreviewFileSize","imagePreviewTransparencyIndicator","STRING","imagePreviewCalculateAverageImageColor","imagePreviewMarkupShow","imagePreviewMarkupFilter","isBrowser","dispatchEvent","CustomEvent","detail","replaceInString","toNaturalFileSize","sizeMax","sizeMin","fileFilter","main","sub","filesize","totalSizeMax","currentTotalSize","total","fileSize","allowFileSizeValidation","maxFileSize","minFileSize","maxTotalFileSize","fileValidateSizeFilter","labelMinFileSizeExceeded","labelMinFileSize","labelMaxFileSizeExceeded","labelMaxFileSize","labelMaxTotalFileSizeExceeded","labelMaxTotalFileSize","DataURIWorker","convert","reader","FileReader","onloadend","readAsDataURL","encode","base64Cache","extend","fileType","shouldPrepareOutput","metadata","all","Blob","dataItems","DID_PREPARE_OUTPUT","cache","JSON","stringify","DID_REMOVE_ITEM","allowFileEncode","isJPEG","Marker","JPEG","APP1","EXIF","TIFF","Orientation","Unknown","getUint16","offset","little","getUint32","getImageOrientation","DataView","byteLength","marker","tags","readAsArrayBuffer","slice","IS_BROWSER","testSrc","shouldCorrect","testImage","shouldCorrectImageExifOrientation","allowImageExifOrientation","isBrowser$1","isNode","HTMLElement","createStore","initialState","queries","actions","state","actionQueue","dispatchQueue","getState","processActionQueue","processDispatchQueue","isBlocking","actionHandlers","str","_queryHandles","queryHandles","api","property","definition","forin","hasOwnProperty","createObject","getAttribute","hasAttribute","svgElements","isSVGElement","attributes","parent","child","children","insertBefore","parentNode","removeChild","testElement","getChildCount","el","getViewRect","elementRect","outer","childView","isRectIgnored","childViewRect","expandRect","calculateRectSize","marginBottom","marginRight","isNumber","thereYet","position","destination","velocity","errorMargin","spring","_ref$stiffness","_ref$damping","_ref$mass","resting","interpolate","ts","skipToEndState","f","onupdate","oncomplete","setTarget","get","easeInOutQuad","tween","p","_ref$duration","_ref$easing","easing","_ref$delay","delay","start","reverse","animator","createAnimator","category","def","addGetSet","overwrite","o","getter","setter","mixinConfig","viewProps","viewInternalAPI","viewExternalAPI","initialProps","animation","addEvent","fn","addEventListener","removeEvent","removeEventListener","listeners","viewState","remove","on","off","findIndex","event","defaults","rotateX","rotateY","currentProps","getOffset","getScale","getRect","propsHaveChanged","applyStyles","newProps","perspective","elementCurrentStyle","cssText","Mixins","layoutCalculated","paddingTop","marginTop","marginLeft","offsetLeft","offsetTop","offsetWidth","offsetHeight","scrollTop","_ref$tag","_ref$name","_ref$attributes","_ref$read","read","_ref$write","_ref$create","_ref$destroy","_ref$filterFrameActio","filterFrameActionsForChild","_ref$didCreateView","didCreateView","_ref$didWriteView","_ref$ignoreRect","_ref$ignoreRectUpdate","ignoreRectUpdate","_ref$mixins","store","getComputedStyle","frameRect","isResting","activeMixins","writers","readers","destroyers","getElement","getChildViews","getReference","getStyle","_read","shouldUpdate","internalAPI","_write","frameActions","writer","writerResting","timestamp","mixin","mixinResting","childResting","destroyer","sharedAPIDefinition","internalAPIDefinition","needle","linkView","unlinkView","registerReader","registerDestroyer","invalidateLayout","externalAPIDefinition","mixinAPIDefinition","mixinAPI","childCount","createPainter","fps","painter","interval","last","requestTick","cancelTick","setTimerType","tick","performance","now","clearTimeout","cancelAnimationFrame","delta","pause","routes","_ref$actions","newNode","referenceNode","insertAfter","nextSibling","isEmpty","trim","toString","toArray","splitter","split","isBoolean","toBoolean","isString","toNumber","toInt","toFloat","isInt","isFinite","toBytes","base","naturalFileSize","isFunction","toFunctionReference","levels","level","methods","process","patch","revert","fetch","restore","load","createServerAPI","outline","timeout","headers","createAction","method","withCredentials","ondata","parts","header","toServerAPI","isNull","isObject","isAPI","getType","replaceSingleQuotes","conversionTable","number","float","bytes","parse","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","substring","_objectWithoutPropertiesLoose","source","excluded","sourceKeys","_objectWithoutProperties","getOwnPropertySymbols","sourceSymbolKeys","propertyIsEnumerable","_toConsumableArray","_arrayWithoutHoles","_iterableToArray","_nonIterableSpread","arr2","iter","from","arrayRemove","run","sync","listener","_fire","fireSync","fire","_len2","_key2","onOnce","_cb","copyObjectPropertiesToObject","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","exec","getDecimalSeparator","toLocaleString","getThousandsSeparator","decimalSeparator","thousandsStringWithSeparator","thousandsStringWithoutSeparator","NUMBER","ARRAY","OBJECT","ACTION","SERVER_API","REGEX","filters","applyFilterChain","matchingFilters","initialFilter","current","catch","error","applyFilters","extendDefaultOptions","additionalOptions","defaultOptions","getOptions","opts","disabled","allowSyncAcceptAttribute","allowDrop","allowBrowse","allowPaste","allowReplace","allowRevert","allowRemove","allowProcess","allowReorder","allowDirectoriesOnly","storeAsFile","forceRevert","maxFiles","checkValidity","itemInsertLocationFreedom","itemInsertLocation","itemInsertInterval","dropOnPage","dropOnElement","dropValidation","ignoredFiles","instantUpload","maxParallelUploads","allowMinimumUploadDuration","chunkUploads","chunkForce","chunkSize","chunkRetryDelays","server","fileSizeBase","labelFileSizeBytes","labelFileSizeKilobytes","labelFileSizeMegabytes","labelFileSizeGigabytes","labelDecimalSeparator","labelThousandsSeparator","labelIdle","labelInvalidField","labelFileWaitingForSize","labelFileSizeNotAvailable","labelFileCountSingular","labelFileCountPlural","labelFileLoading","labelFileAdded","labelFileLoadError","labelFileRemoved","labelFileRemoveError","labelFileProcessing","labelFileProcessingComplete","labelFileProcessingAborted","labelFileProcessingError","labelFileProcessingRevertError","labelTapToCancel","labelTapToRetry","labelTapToUndo","labelButtonRemoveItem","labelButtonAbortItemLoad","labelButtonRetryItemLoad","labelButtonAbortItemProcessing","labelButtonUndoItemProcessing","labelButtonRetryItemProcessing","labelButtonProcessItem","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","files","credits","getItemByQuery","find","getNumericAspectRatioFromString","getActiveItems","Status","EMPTY","ERROR","BUSY","READY","res","canUpdateFileInput","dataTransfer","DataTransfer","File","ITEM_ERROR","ITEM_BUSY","ITEM_READY","isItemInErrorState","isItemInBusyState","isItemInReadyState","isAsync","GET_STATUS","some","GET_ITEM","GET_ACTIVE_ITEM","GET_ACTIVE_ITEMS","GET_ITEMS","GET_ITEM_NAME","filename","GET_ITEM_SIZE","GET_STYLES","GET_PANEL_ASPECT_RATIO","isShapeCircle","GET_ITEM_PANEL_ASPECT_RATIO","GET_ITEMS_BY_STATUS","GET_TOTAL_ITEMS","SHOULD_UPDATE_FILE_INPUT","IS_ASYNC","GET_FILE_SIZE_LABELS","labelBytes","labelKilobytes","labelMegabytes","labelGigabytes","hasRoomForItem","count","maxFileCount","limit","arrayInsert","insertItem","isBase64DataURI","getFilenameFromURL","pop","getExtensionFromFilename","guesstimateExtension","subtype","leftPad","padding","getDateString","date","Date","getFullYear","getMonth","getDate","getHours","getMinutes","getSeconds","getFileFromBlob","blob","extension","lastModifiedDate","_relativePath","getBlobBuilder","BlobBuilder","WebKitBlobBuilder","MozBlobBuilder","MSBlobBuilder","createBlob","arrayBuffer","mimeType","BB","bb","append","getBlob","getBlobFromByteStringWithMimeType","byteString","ab","ArrayBuffer","ia","Uint8Array","charCodeAt","getMimeTypeFromBase64DataURI","dataURI","getBase64DataFromBase64DataURI","getByteStringFromBase64DataURI","atob","getBlobFromBase64DataURI","getFileFromBase64DataURI","getFileNameFromHeader","matches","decodeURI","getFileSizeFromHeader","getTranfserIdFromHeader","getFileInfoFromHeaders","info","rows","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_step","_iterator","createFileLoader","fetchFn","complete","progress","getProgress","abort","loadURL","body","code","computable","fileinfo","setSource","isGet","sendRequest","onheaders","onprogress","ontimeout","onabort","aborted","xhr","headersReceived","encodeURI","encodeURIComponent","XMLHttpRequest","upload","lengthComputable","loaded","onreadystatechange","readyState","open","unescape","setRequestHeader","responseType","createResponse","createTimeoutResponse","getAllResponseHeaders","hasQS","buildURL","createFetchFunction","apiUrl","statusText","ChunkStatus","QUEUED","COMPLETE","WAITING","processFileChunked","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","deepCloneObject","createItem","serverFileReference","frozen","processingAborted","activeLoader","activeProcessor","abortProcessingRequestComplete","setStatus","getFileExtension","getFileType","getFileSize","getFile","loader","meta","success","retryLoad","abortLoad","processor","onprocess","console","requestProcessing","abortProcessing","revertFileUpload","serverTransferId","_setMetadata","silent","filenameWithoutExtension","fileExtension","relativePath","handler","itemAPI","freeze","release","archive","setFile","getItemIndexByQuery","getItemById","itemId","fetchBlob","getDomainFromURL","protocol","isExternalURL","dynamicLabel","label","isMockItem","listUpdated","optionalPromise","sortItems","compare","getItemByQueryFromState","itemHandler","_ref$success","_ref$failure","failure","ABORT_ALL","DID_SET_FILES","_ref2$value","activeItems","interactionMethod","doUpload","MOVE_ITEM","currentIndex","SORT","ADD_ITEMS","_ref6$success","_ref6$failure","insertLocation","totalItems","isValidFile","validItems","promises","ADD_ITEM","_ref7$index","_ref7$success","_ref7$failure","_ref7$options","_item","mainStatus","handleAdd","shouldAdd","loadComplete","REQUEST_PREPARE_OUTPUT","_ref9$failure","COMPLETE_LOAD_ITEM","RETRY_ITEM_LOAD","REQUEST_ITEM_PREPARE","_success","output","REQUEST_ITEM_PROCESSING","itemCanBeQueuedForProcessing","processNow","PROCESS_ITEM","totalCurrentUploads","processNext","queueEntry","itemReference","noop","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","optionKeys","prioritizedOptionKeys","PrioritizedOptions","orderedOptionKeys","formatFilename","createElement$1","tagName","textNode","nodeValue","createTextNode","polarToCartesian","centerX","centerY","radius","angleInDegrees","angleInRadians","describeArc","startAngle","endAngle","arcSweep","percentageArc","to","spin","align","ringStrokeWidth","ringFrom","ringTo","coordinates","progressIndicator","create$1","icon","isDisabled","write$1","shouldDisable","removeAttribute","fileActionButton","_options$labelBytes","_options$labelKilobyt","_options$labelMegabyt","_options$labelGigabyt","KB","MB","GB","removeDecimalsWhenZero","decimalCount","toFixed","create$2","fileName","updateFile","updateFileSizeOnError","fileInfo","DID_UPDATE_ITEM_META","toPercentage","create$3","didSetItemLoadProgress","title","didSetItemProcessProgress","didRequestItemProcessing","didAbortItemProcessing","didCompleteItemProcessing","fileStatus","DID_REQUEST_ITEM_PROCESSING","DID_ABORT_ITEM_PROCESSING","DID_UPDATE_ITEM_PROCESS_PROGRESS","DID_UPDATE_ITEM_LOAD_PROGRESS","DID_THROW_ITEM_PROCESSING_REVERT_ERROR","DID_THROW_ITEM_REMOVE_ERROR","Buttons","AbortItemLoad","RetryItemLoad","RemoveItem","ProcessItem","AbortItemProcessing","RetryItemProcessing","RevertItemProcessing","ButtonKeys","calculateFileInfoOffset","getRemoveIndicatorAligment","buttonRect","buttonRemoveItem","calculateButtonWidth","buttonAbortItemLoad","calculateFileVerticalCenterOffset","calculateFileHorizontalCenterOffset","getLoadIndicatorAlignment","getProcessIndicatorAlignment","DefaultStyle","buttonRetryItemLoad","buttonProcessItem","buttonAbortItemProcessing","buttonRetryItemProcessing","buttonRevertItemProcessing","loadProgressIndicator","processProgressIndicator","processingCompleteIndicator","IdleStyle","ProcessingStyle","StyleMap","DID_START_ITEM_LOAD","DID_START_ITEM_REMOVE","DID_LOAD_LOCAL_ITEM","processingCompleteIndicatorView","create$4","buttonFilter","LocalButtons","alignRemoveItemButton","enabledButtons","_map","buttonView","stopPropagation","loadIndicatorView","progressIndicatorView","activeStyles","write$2","route","stylesToApply","defaultStyles","control","DID_SET_LABEL_BUTTON_ABORT_ITEM_PROCESSING","DID_SET_LABEL_BUTTON_ABORT_ITEM_LOAD","DID_SET_LABEL_BUTTON_ABORT_ITEM_REMOVAL","buttonAbortItemRemoval","create$5","fileWrapper","PANEL_SPRING_PROPS","create$6","section","createSection","scalable","viewConstructor","write$3","topRect","bottomRect","panel","heightCurrent","createDragHelper","itemIds","prevIndex","setIndex","getIndex","getItemIndex","ITEM_TRANSLATE_SPRING","ITEM_SCALE_SPRING","StateMap","create$7","handleClick","markedForRemoval","dragState","grab","isPrimary","removedActivateListener","pageX","pageY","dragOrigin","dragCenter","offsetX","offsetY","drag","preventDefault","dragOffset","dist","drop","cancel","route$1","DID_UPDATE_PANEL_HEIGHT","write$4","DID_GRAB_ITEM","DID_DRAG_ITEM","DID_DROP_ITEM","currentState","filepondItemState","getItemsPerRow","horizontalSpace","getItemIndexByPosition","positionInView","itemRect","itemHorizontalMargin","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","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","form","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","setInputFiles","create$c","fields","getField","syncFieldPositionsWithItems","didReorderItems","didAddItem","fileItem","isLocalFile","shouldUseFileInput","dataContainer","didLoadItem$1","field","didPrepareOutput","didSetDisabled","didRemoveItem","didDefineValue","write$8","DID_DEFINE_VALUE","DID_REORDER_ITEMS","DID_SORT_ITEMS","getRootNode","text$1","zip","epub","guesstimateMimeType","requestDataTransferItems","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","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","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","hopper","isMultiItem","maxItems","atMaxCapacity","addAction","listItemMargin","calculateListItemMargin","listHeight","calculateListHeight","labelHeight","currentLabelHeight","listMarginTop","listMarginBottom","visual","boundsHeight","history","MAX_BOUNCES","bounces","listAvailableHeight","_listAvailableHeight","cappedHeight","isCappedHeight","panelHeight","_listAvailableHeight2","itemMargin","scrollList","itemList","newItem","removedItem","verticalItemCount","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_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","workerBlob","workerURL","Worker","transferList","renameFile","renamedFile","copyFile","registeredPlugins","createAppPlugin","pluginOutline","views","isOperaMini","operamini","hasPromises","hasBlobSlice","hasCreateObjectURL","hasVisibility","hasTiming","hasCSSSupports","CSS","isIE11","apps","FileStatus","updateOptionTypes","hook","indexToRemove","context","matchedHooks","newHooks","newHook","plugins"],"mappings":"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","file":"js/chunk-333332fd.b25cca29.js","sourcesContent":["/*!\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 * FilePondPluginImagePreview 4.6.12\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.FilePondPluginImagePreview = factory()));\n})(this, function() {\n  'use strict';\n\n  // test if file is of type image and can be viewed in canvas\n  var isPreviewableImage = function isPreviewableImage(file) {\n    return /^image/.test(file.type);\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 === 'function') {\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 _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    if (!privateMap.has(receiver)) {\n      throw new TypeError('attempted to get private field on non-instance');\n    }\n\n    var descriptor = privateMap.get(receiver);\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    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      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 _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 vectorMultiply = function vectorMultiply(v, amount) {\n    return createVector(v.x * amount, v.y * amount);\n  };\n\n  var vectorAdd = function vectorAdd(a, b) {\n    return createVector(a.x + b.x, a.y + b.y);\n  };\n\n  var vectorNormalize = function vectorNormalize(v) {\n    var l = Math.sqrt(v.x * v.x + v.y * v.y);\n    if (l === 0) {\n      return {\n        x: 0,\n        y: 0\n      };\n    }\n    return createVector(v.x / l, v.y / l);\n  };\n\n  var vectorRotate = function vectorRotate(v, radians, origin) {\n    var cos = Math.cos(radians);\n    var sin = Math.sin(radians);\n    var t = createVector(v.x - origin.x, v.y - origin.y);\n    return createVector(\n      origin.x + cos * t.x - sin * t.y,\n      origin.y + sin * t.x + cos * t.y\n    );\n  };\n\n  var createVector = function createVector() {\n    var x =\n      arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n    var y =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n    return { x: x, y: y };\n  };\n\n  var getMarkupValue = function getMarkupValue(value, size) {\n    var scalar =\n      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;\n    var axis = arguments.length > 3 ? arguments[3] : undefined;\n    if (typeof value === 'string') {\n      return parseFloat(value) * scalar;\n    }\n    if (typeof value === 'number') {\n      return value * (axis ? size[axis] : Math.min(size.width, size.height));\n    }\n    return;\n  };\n\n  var getMarkupStyles = function getMarkupStyles(markup, size, scale) {\n    var lineStyle = markup.borderStyle || markup.lineStyle || 'solid';\n    var fill = markup.backgroundColor || markup.fontColor || 'transparent';\n    var stroke = markup.borderColor || markup.lineColor || 'transparent';\n    var strokeWidth = getMarkupValue(\n      markup.borderWidth || markup.lineWidth,\n      size,\n      scale\n    );\n    var lineCap = markup.lineCap || 'round';\n    var lineJoin = markup.lineJoin || 'round';\n    var dashes =\n      typeof lineStyle === 'string'\n        ? ''\n        : lineStyle\n            .map(function(v) {\n              return getMarkupValue(v, size, scale);\n            })\n            .join(',');\n    var opacity = markup.opacity || 1;\n    return {\n      'stroke-linecap': lineCap,\n      'stroke-linejoin': lineJoin,\n      'stroke-width': strokeWidth || 0,\n      'stroke-dasharray': dashes,\n      stroke: stroke,\n      fill: fill,\n      opacity: opacity\n    };\n  };\n\n  var isDefined = function isDefined(value) {\n    return value != null;\n  };\n\n  var getMarkupRect = function getMarkupRect(rect, size) {\n    var scalar =\n      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;\n\n    var left =\n      getMarkupValue(rect.x, size, scalar, 'width') ||\n      getMarkupValue(rect.left, size, scalar, 'width');\n    var top =\n      getMarkupValue(rect.y, size, scalar, 'height') ||\n      getMarkupValue(rect.top, size, scalar, 'height');\n    var width = getMarkupValue(rect.width, size, scalar, 'width');\n    var height = getMarkupValue(rect.height, size, scalar, 'height');\n    var right = getMarkupValue(rect.right, size, scalar, 'width');\n    var bottom = getMarkupValue(rect.bottom, size, scalar, 'height');\n\n    if (!isDefined(top)) {\n      if (isDefined(height) && isDefined(bottom)) {\n        top = size.height - height - bottom;\n      } else {\n        top = bottom;\n      }\n    }\n\n    if (!isDefined(left)) {\n      if (isDefined(width) && isDefined(right)) {\n        left = size.width - width - right;\n      } else {\n        left = right;\n      }\n    }\n\n    if (!isDefined(width)) {\n      if (isDefined(left) && isDefined(right)) {\n        width = size.width - left - right;\n      } else {\n        width = 0;\n      }\n    }\n\n    if (!isDefined(height)) {\n      if (isDefined(top) && isDefined(bottom)) {\n        height = size.height - top - bottom;\n      } else {\n        height = 0;\n      }\n    }\n\n    return {\n      x: left || 0,\n      y: top || 0,\n      width: width || 0,\n      height: height || 0\n    };\n  };\n\n  var pointsToPathShape = function pointsToPathShape(points) {\n    return points\n      .map(function(point, index) {\n        return ''\n          .concat(index === 0 ? 'M' : 'L', ' ')\n          .concat(point.x, ' ')\n          .concat(point.y);\n      })\n      .join(' ');\n  };\n\n  var setAttributes = function setAttributes(element, attr) {\n    return Object.keys(attr).forEach(function(key) {\n      return element.setAttribute(key, attr[key]);\n    });\n  };\n\n  var ns = 'http://www.w3.org/2000/svg';\n  var svg = function svg(tag, attr) {\n    var element = document.createElementNS(ns, tag);\n    if (attr) {\n      setAttributes(element, attr);\n    }\n    return element;\n  };\n\n  var updateRect = function updateRect(element) {\n    return setAttributes(\n      element,\n      Object.assign({}, element.rect, element.styles)\n    );\n  };\n\n  var updateEllipse = function updateEllipse(element) {\n    var cx = element.rect.x + element.rect.width * 0.5;\n    var cy = element.rect.y + element.rect.height * 0.5;\n    var rx = element.rect.width * 0.5;\n    var ry = element.rect.height * 0.5;\n    return setAttributes(\n      element,\n      Object.assign(\n        {\n          cx: cx,\n          cy: cy,\n          rx: rx,\n          ry: ry\n        },\n        element.styles\n      )\n    );\n  };\n\n  var IMAGE_FIT_STYLE = {\n    contain: 'xMidYMid meet',\n    cover: 'xMidYMid slice'\n  };\n\n  var updateImage = function updateImage(element, markup) {\n    setAttributes(\n      element,\n      Object.assign({}, element.rect, element.styles, {\n        preserveAspectRatio: IMAGE_FIT_STYLE[markup.fit] || 'none'\n      })\n    );\n  };\n\n  var TEXT_ANCHOR = {\n    left: 'start',\n    center: 'middle',\n    right: 'end'\n  };\n\n  var updateText = function updateText(element, markup, size, scale) {\n    var fontSize = getMarkupValue(markup.fontSize, size, scale);\n    var fontFamily = markup.fontFamily || 'sans-serif';\n    var fontWeight = markup.fontWeight || 'normal';\n    var textAlign = TEXT_ANCHOR[markup.textAlign] || 'start';\n\n    setAttributes(\n      element,\n      Object.assign({}, element.rect, element.styles, {\n        'stroke-width': 0,\n        'font-weight': fontWeight,\n        'font-size': fontSize,\n        'font-family': fontFamily,\n        'text-anchor': textAlign\n      })\n    );\n\n    // update text\n    if (element.text !== markup.text) {\n      element.text = markup.text;\n      element.textContent = markup.text.length ? markup.text : ' ';\n    }\n  };\n\n  var updateLine = function updateLine(element, markup, size, scale) {\n    setAttributes(\n      element,\n      Object.assign({}, element.rect, element.styles, {\n        fill: 'none'\n      })\n    );\n\n    var line = element.childNodes[0];\n    var begin = element.childNodes[1];\n    var end = element.childNodes[2];\n\n    var origin = element.rect;\n\n    var target = {\n      x: element.rect.x + element.rect.width,\n      y: element.rect.y + element.rect.height\n    };\n\n    setAttributes(line, {\n      x1: origin.x,\n      y1: origin.y,\n      x2: target.x,\n      y2: target.y\n    });\n\n    if (!markup.lineDecoration) return;\n\n    begin.style.display = 'none';\n    end.style.display = 'none';\n\n    var v = vectorNormalize({\n      x: target.x - origin.x,\n      y: target.y - origin.y\n    });\n\n    var l = getMarkupValue(0.05, size, scale);\n\n    if (markup.lineDecoration.indexOf('arrow-begin') !== -1) {\n      var arrowBeginRotationPoint = vectorMultiply(v, l);\n      var arrowBeginCenter = vectorAdd(origin, arrowBeginRotationPoint);\n      var arrowBeginA = vectorRotate(origin, 2, arrowBeginCenter);\n      var arrowBeginB = vectorRotate(origin, -2, arrowBeginCenter);\n\n      setAttributes(begin, {\n        style: 'display:block;',\n        d: 'M'\n          .concat(arrowBeginA.x, ',')\n          .concat(arrowBeginA.y, ' L')\n          .concat(origin.x, ',')\n          .concat(origin.y, ' L')\n          .concat(arrowBeginB.x, ',')\n          .concat(arrowBeginB.y)\n      });\n    }\n\n    if (markup.lineDecoration.indexOf('arrow-end') !== -1) {\n      var arrowEndRotationPoint = vectorMultiply(v, -l);\n      var arrowEndCenter = vectorAdd(target, arrowEndRotationPoint);\n      var arrowEndA = vectorRotate(target, 2, arrowEndCenter);\n      var arrowEndB = vectorRotate(target, -2, arrowEndCenter);\n\n      setAttributes(end, {\n        style: 'display:block;',\n        d: 'M'\n          .concat(arrowEndA.x, ',')\n          .concat(arrowEndA.y, ' L')\n          .concat(target.x, ',')\n          .concat(target.y, ' L')\n          .concat(arrowEndB.x, ',')\n          .concat(arrowEndB.y)\n      });\n    }\n  };\n\n  var updatePath = function updatePath(element, markup, size, scale) {\n    setAttributes(\n      element,\n      Object.assign({}, element.styles, {\n        fill: 'none',\n        d: pointsToPathShape(\n          markup.points.map(function(point) {\n            return {\n              x: getMarkupValue(point.x, size, scale, 'width'),\n              y: getMarkupValue(point.y, size, scale, 'height')\n            };\n          })\n        )\n      })\n    );\n  };\n\n  var createShape = function createShape(node) {\n    return function(markup) {\n      return svg(node, { id: markup.id });\n    };\n  };\n\n  var createImage = function createImage(markup) {\n    var shape = svg('image', {\n      id: markup.id,\n      'stroke-linecap': 'round',\n      'stroke-linejoin': 'round',\n      opacity: '0'\n    });\n\n    shape.onload = function() {\n      shape.setAttribute('opacity', markup.opacity || 1);\n    };\n    shape.setAttributeNS(\n      'http://www.w3.org/1999/xlink',\n      'xlink:href',\n      markup.src\n    );\n    return shape;\n  };\n\n  var createLine = function createLine(markup) {\n    var shape = svg('g', {\n      id: markup.id,\n      'stroke-linecap': 'round',\n      'stroke-linejoin': 'round'\n    });\n\n    var line = svg('line');\n    shape.appendChild(line);\n\n    var begin = svg('path');\n    shape.appendChild(begin);\n\n    var end = svg('path');\n    shape.appendChild(end);\n\n    return shape;\n  };\n\n  var CREATE_TYPE_ROUTES = {\n    image: createImage,\n    rect: createShape('rect'),\n    ellipse: createShape('ellipse'),\n    text: createShape('text'),\n    path: createShape('path'),\n    line: createLine\n  };\n\n  var UPDATE_TYPE_ROUTES = {\n    rect: updateRect,\n    ellipse: updateEllipse,\n    image: updateImage,\n    text: updateText,\n    path: updatePath,\n    line: updateLine\n  };\n\n  var createMarkupByType = function createMarkupByType(type, markup) {\n    return CREATE_TYPE_ROUTES[type](markup);\n  };\n\n  var updateMarkupByType = function updateMarkupByType(\n    element,\n    type,\n    markup,\n    size,\n    scale\n  ) {\n    if (type !== 'path') {\n      element.rect = getMarkupRect(markup, size, scale);\n    }\n    element.styles = getMarkupStyles(markup, size, scale);\n    UPDATE_TYPE_ROUTES[type](element, markup, size, scale);\n  };\n\n  var MARKUP_RECT = [\n    'x',\n    'y',\n    'left',\n    'top',\n    'right',\n    'bottom',\n    'width',\n    'height'\n  ];\n\n  var toOptionalFraction = function toOptionalFraction(value) {\n    return typeof value === 'string' && /%/.test(value)\n      ? parseFloat(value) / 100\n      : value;\n  };\n\n  // adds default markup properties, clones markup\n  var prepareMarkup = function prepareMarkup(markup) {\n    var _markup = _slicedToArray(markup, 2),\n      type = _markup[0],\n      props = _markup[1];\n\n    var rect = props.points\n      ? {}\n      : MARKUP_RECT.reduce(function(prev, curr) {\n          prev[curr] = toOptionalFraction(props[curr]);\n          return prev;\n        }, {});\n\n    return [\n      type,\n      Object.assign(\n        {\n          zIndex: 0\n        },\n        props,\n        rect\n      )\n    ];\n  };\n\n  var sortMarkupByZIndex = function sortMarkupByZIndex(a, b) {\n    if (a[1].zIndex > b[1].zIndex) {\n      return 1;\n    }\n    if (a[1].zIndex < b[1].zIndex) {\n      return -1;\n    }\n    return 0;\n  };\n\n  var createMarkupView = function createMarkupView(_) {\n    return _.utils.createView({\n      name: 'image-preview-markup',\n      tag: 'svg',\n      ignoreRect: true,\n      mixins: {\n        apis: ['width', 'height', 'crop', 'markup', 'resize', 'dirty']\n      },\n\n      write: function write(_ref) {\n        var root = _ref.root,\n          props = _ref.props;\n\n        if (!props.dirty) return;\n        var crop = props.crop,\n          resize = props.resize,\n          markup = props.markup;\n\n        var viewWidth = props.width;\n        var viewHeight = props.height;\n\n        var cropWidth = crop.width;\n        var cropHeight = crop.height;\n\n        if (resize) {\n          var _size = resize.size;\n\n          var outputWidth = _size && _size.width;\n          var outputHeight = _size && _size.height;\n          var outputFit = resize.mode;\n          var outputUpscale = resize.upscale;\n\n          if (outputWidth && !outputHeight) outputHeight = outputWidth;\n          if (outputHeight && !outputWidth) outputWidth = outputHeight;\n\n          var shouldUpscale =\n            cropWidth < outputWidth && cropHeight < outputHeight;\n\n          if (!shouldUpscale || (shouldUpscale && outputUpscale)) {\n            var scalarWidth = outputWidth / cropWidth;\n            var scalarHeight = outputHeight / cropHeight;\n\n            if (outputFit === 'force') {\n              cropWidth = outputWidth;\n              cropHeight = outputHeight;\n            } else {\n              var scalar;\n              if (outputFit === 'cover') {\n                scalar = Math.max(scalarWidth, scalarHeight);\n              } else if (outputFit === 'contain') {\n                scalar = Math.min(scalarWidth, scalarHeight);\n              }\n              cropWidth = cropWidth * scalar;\n              cropHeight = cropHeight * scalar;\n            }\n          }\n        }\n\n        var size = {\n          width: viewWidth,\n          height: viewHeight\n        };\n\n        root.element.setAttribute('width', size.width);\n        root.element.setAttribute('height', size.height);\n\n        var scale = Math.min(viewWidth / cropWidth, viewHeight / cropHeight);\n\n        // clear\n        root.element.innerHTML = '';\n\n        // get filter\n        var markupFilter = root.query('GET_IMAGE_PREVIEW_MARKUP_FILTER');\n\n        // draw new\n        markup\n          .filter(markupFilter)\n          .map(prepareMarkup)\n          .sort(sortMarkupByZIndex)\n          .forEach(function(markup) {\n            var _markup = _slicedToArray(markup, 2),\n              type = _markup[0],\n              settings = _markup[1];\n\n            // create\n            var element = createMarkupByType(type, settings);\n\n            // update\n            updateMarkupByType(element, type, settings, size, scale);\n\n            // add\n            root.element.appendChild(element);\n          });\n      }\n    });\n  };\n\n  var createVector$1 = function createVector(x, y) {\n    return { x: x, y: y };\n  };\n\n  var vectorDot = function vectorDot(a, b) {\n    return a.x * b.x + a.y * b.y;\n  };\n\n  var vectorSubtract = function vectorSubtract(a, b) {\n    return createVector$1(a.x - b.x, a.y - b.y);\n  };\n\n  var vectorDistanceSquared = function vectorDistanceSquared(a, b) {\n    return vectorDot(vectorSubtract(a, b), vectorSubtract(a, b));\n  };\n\n  var vectorDistance = function vectorDistance(a, b) {\n    return Math.sqrt(vectorDistanceSquared(a, b));\n  };\n\n  var getOffsetPointOnEdge = function getOffsetPointOnEdge(length, rotation) {\n    var a = length;\n\n    var A = 1.5707963267948966;\n    var B = rotation;\n    var C = 1.5707963267948966 - rotation;\n\n    var sinA = Math.sin(A);\n    var sinB = Math.sin(B);\n    var sinC = Math.sin(C);\n    var cosC = Math.cos(C);\n    var ratio = a / sinA;\n    var b = ratio * sinB;\n    var c = ratio * sinC;\n\n    return createVector$1(cosC * b, cosC * c);\n  };\n\n  var getRotatedRectSize = function getRotatedRectSize(rect, rotation) {\n    var w = rect.width;\n    var h = rect.height;\n\n    var hor = getOffsetPointOnEdge(w, rotation);\n    var ver = getOffsetPointOnEdge(h, rotation);\n\n    var tl = createVector$1(rect.x + Math.abs(hor.x), rect.y - Math.abs(hor.y));\n\n    var tr = createVector$1(\n      rect.x + rect.width + Math.abs(ver.y),\n      rect.y + Math.abs(ver.x)\n    );\n\n    var bl = createVector$1(\n      rect.x - Math.abs(ver.y),\n      rect.y + rect.height - Math.abs(ver.x)\n    );\n\n    return {\n      width: vectorDistance(tl, tr),\n      height: vectorDistance(tl, bl)\n    };\n  };\n\n  var calculateCanvasSize = function calculateCanvasSize(\n    image,\n    canvasAspectRatio\n  ) {\n    var zoom =\n      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;\n\n    var imageAspectRatio = image.height / image.width;\n\n    // determine actual pixels on x and y axis\n    var canvasWidth = 1;\n    var canvasHeight = canvasAspectRatio;\n    var imgWidth = 1;\n    var imgHeight = imageAspectRatio;\n    if (imgHeight > canvasHeight) {\n      imgHeight = canvasHeight;\n      imgWidth = imgHeight / imageAspectRatio;\n    }\n\n    var scalar = Math.max(canvasWidth / imgWidth, canvasHeight / imgHeight);\n    var width = image.width / (zoom * scalar * imgWidth);\n    var height = width * canvasAspectRatio;\n\n    return {\n      width: width,\n      height: height\n    };\n  };\n\n  var getImageRectZoomFactor = function getImageRectZoomFactor(\n    imageRect,\n    cropRect,\n    rotation,\n    center\n  ) {\n    // calculate available space round image center position\n    var cx = center.x > 0.5 ? 1 - center.x : center.x;\n    var cy = center.y > 0.5 ? 1 - center.y : center.y;\n    var imageWidth = cx * 2 * imageRect.width;\n    var imageHeight = cy * 2 * imageRect.height;\n\n    // calculate rotated crop rectangle size\n    var rotatedCropSize = getRotatedRectSize(cropRect, rotation);\n\n    // calculate scalar required to fit image\n    return Math.max(\n      rotatedCropSize.width / imageWidth,\n      rotatedCropSize.height / imageHeight\n    );\n  };\n\n  var getCenteredCropRect = function getCenteredCropRect(\n    container,\n    aspectRatio\n  ) {\n    var width = container.width;\n    var height = width * aspectRatio;\n    if (height > container.height) {\n      height = container.height;\n      width = height / aspectRatio;\n    }\n    var x = (container.width - width) * 0.5;\n    var y = (container.height - height) * 0.5;\n\n    return {\n      x: x,\n      y: y,\n      width: width,\n      height: height\n    };\n  };\n\n  var getCurrentCropSize = function getCurrentCropSize(imageSize) {\n    var crop =\n      arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var zoom = crop.zoom,\n      rotation = crop.rotation,\n      center = crop.center,\n      aspectRatio = crop.aspectRatio;\n\n    if (!aspectRatio) aspectRatio = imageSize.height / imageSize.width;\n\n    var canvasSize = calculateCanvasSize(imageSize, aspectRatio, zoom);\n\n    var canvasCenter = {\n      x: canvasSize.width * 0.5,\n      y: canvasSize.height * 0.5\n    };\n\n    var stage = {\n      x: 0,\n      y: 0,\n      width: canvasSize.width,\n      height: canvasSize.height,\n      center: canvasCenter\n    };\n\n    var shouldLimit = typeof crop.scaleToFit === 'undefined' || crop.scaleToFit;\n\n    var stageZoomFactor = getImageRectZoomFactor(\n      imageSize,\n      getCenteredCropRect(stage, aspectRatio),\n      rotation,\n      shouldLimit ? center : { x: 0.5, y: 0.5 }\n    );\n\n    var scale = zoom * stageZoomFactor;\n\n    // start drawing\n    return {\n      widthFloat: canvasSize.width / scale,\n      heightFloat: canvasSize.height / scale,\n      width: Math.round(canvasSize.width / scale),\n      height: Math.round(canvasSize.height / scale)\n    };\n  };\n\n  var IMAGE_SCALE_SPRING_PROPS = {\n    type: 'spring',\n    stiffness: 0.5,\n    damping: 0.45,\n    mass: 10\n  };\n\n  // does horizontal and vertical flipping\n  var createBitmapView = function createBitmapView(_) {\n    return _.utils.createView({\n      name: 'image-bitmap',\n      ignoreRect: true,\n      mixins: { styles: ['scaleX', 'scaleY'] },\n      create: function create(_ref) {\n        var root = _ref.root,\n          props = _ref.props;\n        root.appendChild(props.image);\n      }\n    });\n  };\n\n  // shifts and rotates image\n  var createImageCanvasWrapper = function createImageCanvasWrapper(_) {\n    return _.utils.createView({\n      name: 'image-canvas-wrapper',\n      tag: 'div',\n      ignoreRect: true,\n      mixins: {\n        apis: ['crop', 'width', 'height'],\n\n        styles: [\n          'originX',\n          'originY',\n          'translateX',\n          'translateY',\n          'scaleX',\n          'scaleY',\n          'rotateZ'\n        ],\n\n        animations: {\n          originX: IMAGE_SCALE_SPRING_PROPS,\n          originY: IMAGE_SCALE_SPRING_PROPS,\n          scaleX: IMAGE_SCALE_SPRING_PROPS,\n          scaleY: IMAGE_SCALE_SPRING_PROPS,\n          translateX: IMAGE_SCALE_SPRING_PROPS,\n          translateY: IMAGE_SCALE_SPRING_PROPS,\n          rotateZ: IMAGE_SCALE_SPRING_PROPS\n        }\n      },\n\n      create: function create(_ref2) {\n        var root = _ref2.root,\n          props = _ref2.props;\n        props.width = props.image.width;\n        props.height = props.image.height;\n        root.ref.bitmap = root.appendChildView(\n          root.createChildView(createBitmapView(_), { image: props.image })\n        );\n      },\n      write: function write(_ref3) {\n        var root = _ref3.root,\n          props = _ref3.props;\n        var flip = props.crop.flip;\n        var bitmap = root.ref.bitmap;\n        bitmap.scaleX = flip.horizontal ? -1 : 1;\n        bitmap.scaleY = flip.vertical ? -1 : 1;\n      }\n    });\n  };\n\n  // clips canvas to correct aspect ratio\n  var createClipView = function createClipView(_) {\n    return _.utils.createView({\n      name: 'image-clip',\n      tag: 'div',\n      ignoreRect: true,\n      mixins: {\n        apis: [\n          'crop',\n          'markup',\n          'resize',\n          'width',\n          'height',\n          'dirty',\n          'background'\n        ],\n\n        styles: ['width', 'height', 'opacity'],\n        animations: {\n          opacity: { type: 'tween', duration: 250 }\n        }\n      },\n\n      didWriteView: function didWriteView(_ref4) {\n        var root = _ref4.root,\n          props = _ref4.props;\n        if (!props.background) return;\n        root.element.style.backgroundColor = props.background;\n      },\n      create: function create(_ref5) {\n        var root = _ref5.root,\n          props = _ref5.props;\n\n        root.ref.image = root.appendChildView(\n          root.createChildView(\n            createImageCanvasWrapper(_),\n            Object.assign({}, props)\n          )\n        );\n\n        root.ref.createMarkup = function() {\n          if (root.ref.markup) return;\n          root.ref.markup = root.appendChildView(\n            root.createChildView(createMarkupView(_), Object.assign({}, props))\n          );\n        };\n\n        root.ref.destroyMarkup = function() {\n          if (!root.ref.markup) return;\n          root.removeChildView(root.ref.markup);\n          root.ref.markup = null;\n        };\n\n        // set up transparency grid\n        var transparencyIndicator = root.query(\n          'GET_IMAGE_PREVIEW_TRANSPARENCY_INDICATOR'\n        );\n        if (transparencyIndicator === null) return;\n\n        // grid pattern\n        if (transparencyIndicator === 'grid') {\n          root.element.dataset.transparencyIndicator = transparencyIndicator;\n        }\n        // basic color\n        else {\n          root.element.dataset.transparencyIndicator = 'color';\n        }\n      },\n      write: function write(_ref6) {\n        var root = _ref6.root,\n          props = _ref6.props,\n          shouldOptimize = _ref6.shouldOptimize;\n        var crop = props.crop,\n          markup = props.markup,\n          resize = props.resize,\n          dirty = props.dirty,\n          width = props.width,\n          height = props.height;\n\n        root.ref.image.crop = crop;\n\n        var stage = {\n          x: 0,\n          y: 0,\n          width: width,\n          height: height,\n          center: {\n            x: width * 0.5,\n            y: height * 0.5\n          }\n        };\n\n        var image = {\n          width: root.ref.image.width,\n          height: root.ref.image.height\n        };\n\n        var origin = {\n          x: crop.center.x * image.width,\n          y: crop.center.y * image.height\n        };\n\n        var translation = {\n          x: stage.center.x - image.width * crop.center.x,\n          y: stage.center.y - image.height * crop.center.y\n        };\n\n        var rotation = Math.PI * 2 + (crop.rotation % (Math.PI * 2));\n\n        var cropAspectRatio = crop.aspectRatio || image.height / image.width;\n\n        var shouldLimit =\n          typeof crop.scaleToFit === 'undefined' || crop.scaleToFit;\n\n        var stageZoomFactor = getImageRectZoomFactor(\n          image,\n          getCenteredCropRect(stage, cropAspectRatio),\n\n          rotation,\n          shouldLimit ? crop.center : { x: 0.5, y: 0.5 }\n        );\n\n        var scale = crop.zoom * stageZoomFactor;\n\n        // update markup view\n        if (markup && markup.length) {\n          root.ref.createMarkup();\n          root.ref.markup.width = width;\n          root.ref.markup.height = height;\n          root.ref.markup.resize = resize;\n          root.ref.markup.dirty = dirty;\n          root.ref.markup.markup = markup;\n          root.ref.markup.crop = getCurrentCropSize(image, crop);\n        } else if (root.ref.markup) {\n          root.ref.destroyMarkup();\n        }\n\n        // update image view\n        var imageView = root.ref.image;\n\n        // don't update clip layout\n        if (shouldOptimize) {\n          imageView.originX = null;\n          imageView.originY = null;\n          imageView.translateX = null;\n          imageView.translateY = null;\n          imageView.rotateZ = null;\n          imageView.scaleX = null;\n          imageView.scaleY = null;\n          return;\n        }\n\n        imageView.originX = origin.x;\n        imageView.originY = origin.y;\n        imageView.translateX = translation.x;\n        imageView.translateY = translation.y;\n        imageView.rotateZ = rotation;\n        imageView.scaleX = scale;\n        imageView.scaleY = scale;\n      }\n    });\n  };\n\n  var createImageView = function createImageView(_) {\n    return _.utils.createView({\n      name: 'image-preview',\n      tag: 'div',\n      ignoreRect: true,\n      mixins: {\n        apis: ['image', 'crop', 'markup', 'resize', 'dirty', 'background'],\n\n        styles: ['translateY', 'scaleX', 'scaleY', 'opacity'],\n\n        animations: {\n          scaleX: IMAGE_SCALE_SPRING_PROPS,\n          scaleY: IMAGE_SCALE_SPRING_PROPS,\n          translateY: IMAGE_SCALE_SPRING_PROPS,\n          opacity: { type: 'tween', duration: 400 }\n        }\n      },\n\n      create: function create(_ref7) {\n        var root = _ref7.root,\n          props = _ref7.props;\n        root.ref.clip = root.appendChildView(\n          root.createChildView(createClipView(_), {\n            id: props.id,\n            image: props.image,\n            crop: props.crop,\n            markup: props.markup,\n            resize: props.resize,\n            dirty: props.dirty,\n            background: props.background\n          })\n        );\n      },\n      write: function write(_ref8) {\n        var root = _ref8.root,\n          props = _ref8.props,\n          shouldOptimize = _ref8.shouldOptimize;\n        var clip = root.ref.clip;\n        var image = props.image,\n          crop = props.crop,\n          markup = props.markup,\n          resize = props.resize,\n          dirty = props.dirty;\n\n        clip.crop = crop;\n        clip.markup = markup;\n        clip.resize = resize;\n        clip.dirty = dirty;\n\n        // don't update clip layout\n        clip.opacity = shouldOptimize ? 0 : 1;\n\n        // don't re-render if optimizing or hidden (width will be zero resulting in weird animations)\n        if (shouldOptimize || root.rect.element.hidden) return;\n\n        // calculate scaled preview image size\n        var imageAspectRatio = image.height / image.width;\n        var aspectRatio = crop.aspectRatio || imageAspectRatio;\n\n        // calculate container size\n        var containerWidth = root.rect.inner.width;\n        var containerHeight = root.rect.inner.height;\n\n        var fixedPreviewHeight = root.query('GET_IMAGE_PREVIEW_HEIGHT');\n        var minPreviewHeight = root.query('GET_IMAGE_PREVIEW_MIN_HEIGHT');\n        var maxPreviewHeight = root.query('GET_IMAGE_PREVIEW_MAX_HEIGHT');\n\n        var panelAspectRatio = root.query('GET_PANEL_ASPECT_RATIO');\n        var allowMultiple = root.query('GET_ALLOW_MULTIPLE');\n\n        if (panelAspectRatio && !allowMultiple) {\n          fixedPreviewHeight = containerWidth * panelAspectRatio;\n          aspectRatio = panelAspectRatio;\n        }\n\n        // determine clip width and height\n        var clipHeight =\n          fixedPreviewHeight !== null\n            ? fixedPreviewHeight\n            : Math.max(\n                minPreviewHeight,\n                Math.min(containerWidth * aspectRatio, maxPreviewHeight)\n              );\n\n        var clipWidth = clipHeight / aspectRatio;\n        if (clipWidth > containerWidth) {\n          clipWidth = containerWidth;\n          clipHeight = clipWidth * aspectRatio;\n        }\n\n        if (clipHeight > containerHeight) {\n          clipHeight = containerHeight;\n          clipWidth = containerHeight / aspectRatio;\n        }\n\n        clip.width = clipWidth;\n        clip.height = clipHeight;\n      }\n    });\n  };\n\n  var SVG_MASK =\n    '<svg width=\"500\" height=\"200\" viewBox=\"0 0 500 200\" preserveAspectRatio=\"none\">\\n    <defs>\\n        <radialGradient id=\"gradient-__UID__\" cx=\".5\" cy=\"1.25\" r=\"1.15\">\\n            <stop offset=\\'50%\\' stop-color=\\'#000000\\'/>\\n            <stop offset=\\'56%\\' stop-color=\\'#0a0a0a\\'/>\\n            <stop offset=\\'63%\\' stop-color=\\'#262626\\'/>\\n            <stop offset=\\'69%\\' stop-color=\\'#4f4f4f\\'/>\\n            <stop offset=\\'75%\\' stop-color=\\'#808080\\'/>\\n            <stop offset=\\'81%\\' stop-color=\\'#b1b1b1\\'/>\\n            <stop offset=\\'88%\\' stop-color=\\'#dadada\\'/>\\n            <stop offset=\\'94%\\' stop-color=\\'#f6f6f6\\'/>\\n            <stop offset=\\'100%\\' stop-color=\\'#ffffff\\'/>\\n        </radialGradient>\\n        <mask id=\"mask-__UID__\">\\n            <rect x=\"0\" y=\"0\" width=\"500\" height=\"200\" fill=\"url(#gradient-__UID__)\"></rect>\\n        </mask>\\n    </defs>\\n    <rect x=\"0\" width=\"500\" height=\"200\" fill=\"currentColor\" mask=\"url(#mask-__UID__)\"></rect>\\n</svg>';\n\n  var SVGMaskUniqueId = 0;\n\n  var createImageOverlayView = function createImageOverlayView(fpAPI) {\n    return fpAPI.utils.createView({\n      name: 'image-preview-overlay',\n      tag: 'div',\n      ignoreRect: true,\n      create: function create(_ref) {\n        var root = _ref.root,\n          props = _ref.props;\n        var mask = SVG_MASK;\n        if (document.querySelector('base')) {\n          var url = new URL(\n            window.location.href.replace(window.location.hash, '')\n          ).href;\n          mask = mask.replace(/url\\(\\#/g, 'url(' + url + '#');\n        }\n\n        SVGMaskUniqueId++;\n        root.element.classList.add(\n          'filepond--image-preview-overlay-'.concat(props.status)\n        );\n\n        root.element.innerHTML = mask.replace(/__UID__/g, SVGMaskUniqueId);\n      },\n      mixins: {\n        styles: ['opacity'],\n        animations: {\n          opacity: { type: 'spring', mass: 25 }\n        }\n      }\n    });\n  };\n\n  /**\n   * Bitmap Worker\n   */\n  var BitmapWorker = function BitmapWorker() {\n    self.onmessage = function(e) {\n      createImageBitmap(e.data.message.file).then(function(bitmap) {\n        self.postMessage({ id: e.data.id, message: bitmap }, [bitmap]);\n      });\n    };\n  };\n\n  /**\n   * ColorMatrix Worker\n   */\n  var ColorMatrixWorker = function ColorMatrixWorker() {\n    self.onmessage = function(e) {\n      var imageData = e.data.message.imageData;\n      var matrix = e.data.message.colorMatrix;\n\n      var data = imageData.data;\n      var l = data.length;\n\n      var m11 = matrix[0];\n      var m12 = matrix[1];\n      var m13 = matrix[2];\n      var m14 = matrix[3];\n      var m15 = matrix[4];\n\n      var m21 = matrix[5];\n      var m22 = matrix[6];\n      var m23 = matrix[7];\n      var m24 = matrix[8];\n      var m25 = matrix[9];\n\n      var m31 = matrix[10];\n      var m32 = matrix[11];\n      var m33 = matrix[12];\n      var m34 = matrix[13];\n      var m35 = matrix[14];\n\n      var m41 = matrix[15];\n      var m42 = matrix[16];\n      var m43 = matrix[17];\n      var m44 = matrix[18];\n      var m45 = matrix[19];\n\n      var index = 0,\n        r = 0.0,\n        g = 0.0,\n        b = 0.0,\n        a = 0.0;\n\n      for (; index < l; index += 4) {\n        r = data[index] / 255;\n        g = data[index + 1] / 255;\n        b = data[index + 2] / 255;\n        a = data[index + 3] / 255;\n        data[index] = Math.max(\n          0,\n          Math.min((r * m11 + g * m12 + b * m13 + a * m14 + m15) * 255, 255)\n        );\n        data[index + 1] = Math.max(\n          0,\n          Math.min((r * m21 + g * m22 + b * m23 + a * m24 + m25) * 255, 255)\n        );\n        data[index + 2] = Math.max(\n          0,\n          Math.min((r * m31 + g * m32 + b * m33 + a * m34 + m35) * 255, 255)\n        );\n        data[index + 3] = Math.max(\n          0,\n          Math.min((r * m41 + g * m42 + b * m43 + a * m44 + m45) * 255, 255)\n        );\n      }\n\n      self.postMessage({ id: e.data.id, message: imageData }, [\n        imageData.data.buffer\n      ]);\n    };\n  };\n\n  var getImageSize = function getImageSize(url, cb) {\n    var image = new Image();\n    image.onload = function() {\n      var width = image.naturalWidth;\n      var height = image.naturalHeight;\n      image = null;\n      cb(width, height);\n    };\n    image.src = url;\n  };\n\n  var transforms = {\n    1: function _() {\n      return [1, 0, 0, 1, 0, 0];\n    },\n    2: function _(width) {\n      return [-1, 0, 0, 1, width, 0];\n    },\n    3: function _(width, height) {\n      return [-1, 0, 0, -1, width, height];\n    },\n    4: function _(width, height) {\n      return [1, 0, 0, -1, 0, height];\n    },\n    5: function _() {\n      return [0, 1, 1, 0, 0, 0];\n    },\n    6: function _(width, height) {\n      return [0, 1, -1, 0, height, 0];\n    },\n    7: function _(width, height) {\n      return [0, -1, -1, 0, height, width];\n    },\n    8: function _(width) {\n      return [0, -1, 1, 0, 0, width];\n    }\n  };\n\n  var fixImageOrientation = function fixImageOrientation(\n    ctx,\n    width,\n    height,\n    orientation\n  ) {\n    // no orientation supplied\n    if (orientation === -1) {\n      return;\n    }\n\n    ctx.transform.apply(ctx, transforms[orientation](width, height));\n  };\n\n  // draws the preview image to canvas\n  var createPreviewImage = function createPreviewImage(\n    data,\n    width,\n    height,\n    orientation\n  ) {\n    // can't draw on half pixels\n    width = Math.round(width);\n    height = Math.round(height);\n\n    // draw image\n    var canvas = document.createElement('canvas');\n    canvas.width = width;\n    canvas.height = height;\n    var ctx = canvas.getContext('2d');\n\n    // if is rotated incorrectly swap width and height\n    if (orientation >= 5 && orientation <= 8) {\n      var _ref = [height, width];\n      width = _ref[0];\n      height = _ref[1];\n    }\n\n    // correct image orientation\n    fixImageOrientation(ctx, width, height, orientation);\n\n    // draw the image\n    ctx.drawImage(data, 0, 0, width, height);\n\n    return canvas;\n  };\n\n  var isBitmap = function isBitmap(file) {\n    return /^image/.test(file.type) && !/svg/.test(file.type);\n  };\n\n  var MAX_WIDTH = 10;\n  var MAX_HEIGHT = 10;\n\n  var calculateAverageColor = function calculateAverageColor(image) {\n    var scalar = Math.min(MAX_WIDTH / image.width, MAX_HEIGHT / image.height);\n\n    var canvas = document.createElement('canvas');\n    var ctx = canvas.getContext('2d');\n    var width = (canvas.width = Math.ceil(image.width * scalar));\n    var height = (canvas.height = Math.ceil(image.height * scalar));\n    ctx.drawImage(image, 0, 0, width, height);\n    var data = null;\n    try {\n      data = ctx.getImageData(0, 0, width, height).data;\n    } catch (e) {\n      return null;\n    }\n    var l = data.length;\n\n    var r = 0;\n    var g = 0;\n    var b = 0;\n    var i = 0;\n\n    for (; i < l; i += 4) {\n      r += data[i] * data[i];\n      g += data[i + 1] * data[i + 1];\n      b += data[i + 2] * data[i + 2];\n    }\n\n    r = averageColor(r, l);\n    g = averageColor(g, l);\n    b = averageColor(b, l);\n\n    return { r: r, g: g, b: b };\n  };\n\n  var averageColor = function averageColor(c, l) {\n    return Math.floor(Math.sqrt(c / (l / 4)));\n  };\n\n  var cloneCanvas = function cloneCanvas(origin, target) {\n    target = target || document.createElement('canvas');\n    target.width = origin.width;\n    target.height = origin.height;\n    var ctx = target.getContext('2d');\n    ctx.drawImage(origin, 0, 0);\n    return target;\n  };\n\n  var cloneImageData = function cloneImageData(imageData) {\n    var id;\n    try {\n      id = new ImageData(imageData.width, imageData.height);\n    } catch (e) {\n      var canvas = document.createElement('canvas');\n      var ctx = canvas.getContext('2d');\n      id = ctx.createImageData(imageData.width, imageData.height);\n    }\n    id.data.set(new Uint8ClampedArray(imageData.data));\n    return id;\n  };\n\n  var loadImage = function loadImage(url) {\n    return new Promise(function(resolve, reject) {\n      var img = new Image();\n      img.crossOrigin = 'Anonymous';\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 createImageWrapperView = function createImageWrapperView(_) {\n    // create overlay view\n    var OverlayView = createImageOverlayView(_);\n\n    var ImageView = createImageView(_);\n    var createWorker = _.utils.createWorker;\n\n    var applyFilter = function applyFilter(root, filter, target) {\n      return new Promise(function(resolve) {\n        // will store image data for future filter updates\n        if (!root.ref.imageData) {\n          root.ref.imageData = target\n            .getContext('2d')\n            .getImageData(0, 0, target.width, target.height);\n        }\n\n        // get image data reference\n        var imageData = cloneImageData(root.ref.imageData);\n\n        if (!filter || filter.length !== 20) {\n          target.getContext('2d').putImageData(imageData, 0, 0);\n          return resolve();\n        }\n\n        var worker = createWorker(ColorMatrixWorker);\n        worker.post(\n          {\n            imageData: imageData,\n            colorMatrix: filter\n          },\n\n          function(response) {\n            // apply filtered colors\n            target.getContext('2d').putImageData(response, 0, 0);\n\n            // stop worker\n            worker.terminate();\n\n            // done!\n            resolve();\n          },\n          [imageData.data.buffer]\n        );\n      });\n    };\n\n    var removeImageView = function removeImageView(root, imageView) {\n      root.removeChildView(imageView);\n      imageView.image.width = 1;\n      imageView.image.height = 1;\n      imageView._destroy();\n    };\n\n    // remove an image\n    var shiftImage = function shiftImage(_ref) {\n      var root = _ref.root;\n      var imageView = root.ref.images.shift();\n      imageView.opacity = 0;\n      imageView.translateY = -15;\n      root.ref.imageViewBin.push(imageView);\n      return imageView;\n    };\n\n    // add new image\n    var pushImage = function pushImage(_ref2) {\n      var root = _ref2.root,\n        props = _ref2.props,\n        image = _ref2.image;\n      var id = props.id;\n      var item = root.query('GET_ITEM', { id: id });\n      if (!item) return;\n\n      var crop = item.getMetadata('crop') || {\n        center: {\n          x: 0.5,\n          y: 0.5\n        },\n\n        flip: {\n          horizontal: false,\n          vertical: false\n        },\n\n        zoom: 1,\n        rotation: 0,\n        aspectRatio: null\n      };\n\n      var background = root.query(\n        'GET_IMAGE_TRANSFORM_CANVAS_BACKGROUND_COLOR'\n      );\n\n      var markup;\n      var resize;\n      var dirty = false;\n      if (root.query('GET_IMAGE_PREVIEW_MARKUP_SHOW')) {\n        markup = item.getMetadata('markup') || [];\n        resize = item.getMetadata('resize');\n        dirty = true;\n      }\n\n      // append image presenter\n      var imageView = root.appendChildView(\n        root.createChildView(ImageView, {\n          id: id,\n          image: image,\n          crop: crop,\n          resize: resize,\n          markup: markup,\n          dirty: dirty,\n          background: background,\n          opacity: 0,\n          scaleX: 1.15,\n          scaleY: 1.15,\n          translateY: 15\n        }),\n\n        root.childViews.length\n      );\n\n      root.ref.images.push(imageView);\n\n      // reveal the preview image\n      imageView.opacity = 1;\n      imageView.scaleX = 1;\n      imageView.scaleY = 1;\n      imageView.translateY = 0;\n\n      // the preview is now ready to be drawn\n      setTimeout(function() {\n        root.dispatch('DID_IMAGE_PREVIEW_SHOW', { id: id });\n      }, 250);\n    };\n\n    var updateImage = function updateImage(_ref3) {\n      var root = _ref3.root,\n        props = _ref3.props;\n      var item = root.query('GET_ITEM', { id: props.id });\n      if (!item) return;\n      var imageView = root.ref.images[root.ref.images.length - 1];\n      imageView.crop = item.getMetadata('crop');\n      imageView.background = root.query(\n        'GET_IMAGE_TRANSFORM_CANVAS_BACKGROUND_COLOR'\n      );\n\n      if (root.query('GET_IMAGE_PREVIEW_MARKUP_SHOW')) {\n        imageView.dirty = true;\n        imageView.resize = item.getMetadata('resize');\n        imageView.markup = item.getMetadata('markup');\n      }\n    };\n\n    // replace image preview\n    var didUpdateItemMetadata = function didUpdateItemMetadata(_ref4) {\n      var root = _ref4.root,\n        props = _ref4.props,\n        action = _ref4.action;\n      // only filter and crop trigger redraw\n      if (!/crop|filter|markup|resize/.test(action.change.key)) return;\n\n      // no images to update, exit\n      if (!root.ref.images.length) return;\n\n      // no item found, exit\n      var item = root.query('GET_ITEM', { id: props.id });\n      if (!item) return;\n\n      // for now, update existing image when filtering\n      if (/filter/.test(action.change.key)) {\n        var imageView = root.ref.images[root.ref.images.length - 1];\n        applyFilter(root, action.change.value, imageView.image);\n        return;\n      }\n\n      if (/crop|markup|resize/.test(action.change.key)) {\n        var crop = item.getMetadata('crop');\n        var image = root.ref.images[root.ref.images.length - 1];\n\n        // if aspect ratio has changed, we need to create a new image\n        if (\n          crop &&\n          crop.aspectRatio &&\n          image.crop &&\n          image.crop.aspectRatio &&\n          Math.abs(crop.aspectRatio - image.crop.aspectRatio) > 0.00001\n        ) {\n          var _imageView = shiftImage({ root: root });\n          pushImage({\n            root: root,\n            props: props,\n            image: cloneCanvas(_imageView.image)\n          });\n        }\n        // if not, we can update the current image\n        else {\n          updateImage({ root: root, props: props });\n        }\n      }\n    };\n\n    var canCreateImageBitmap = function canCreateImageBitmap(file) {\n      // Firefox versions before 58 will freeze when running createImageBitmap\n      // in a Web Worker so we detect those versions and return false for support\n      var userAgent = window.navigator.userAgent;\n      var isFirefox = userAgent.match(/Firefox\\/([0-9]+)\\./);\n      var firefoxVersion = isFirefox ? parseInt(isFirefox[1]) : null;\n      if (firefoxVersion !== null && firefoxVersion <= 58) return false;\n\n      return 'createImageBitmap' in window && isBitmap(file);\n    };\n\n    /**\n     * Write handler for when preview container has been created\n     */\n    var didCreatePreviewContainer = function didCreatePreviewContainer(_ref5) {\n      var root = _ref5.root,\n        props = _ref5.props;\n      var id = props.id;\n\n      // we need to get the file data to determine the eventual image size\n      var item = root.query('GET_ITEM', id);\n      if (!item) return;\n\n      // get url to file (we'll revoke it later on when done)\n      var fileURL = URL.createObjectURL(item.file);\n\n      // determine image size of this item\n      getImageSize(fileURL, function(width, height) {\n        // we can now scale the panel to the final size\n        root.dispatch('DID_IMAGE_PREVIEW_CALCULATE_SIZE', {\n          id: id,\n          width: width,\n          height: height\n        });\n      });\n    };\n\n    var drawPreview = function drawPreview(_ref6) {\n      var root = _ref6.root,\n        props = _ref6.props;\n      var id = props.id;\n\n      // we need to get the file data to determine the eventual image size\n      var item = root.query('GET_ITEM', id);\n      if (!item) return;\n\n      // get url to file (we'll revoke it later on when done)\n      var fileURL = URL.createObjectURL(item.file);\n\n      // fallback\n      var loadPreviewFallback = function loadPreviewFallback() {\n        // let's scale the image in the main thread :(\n        loadImage(fileURL).then(previewImageLoaded);\n      };\n\n      // image is now ready\n      var previewImageLoaded = function previewImageLoaded(imageData) {\n        // the file url is no longer needed\n        URL.revokeObjectURL(fileURL);\n\n        // draw the scaled down version here and use that as source so bitmapdata can be closed\n        // orientation info\n        var exif = item.getMetadata('exif') || {};\n        var orientation = exif.orientation || -1;\n\n        // get width and height from action, and swap if orientation is incorrect\n        var width = imageData.width,\n          height = imageData.height;\n\n        // if no width or height, just return early.\n        if (!width || !height) return;\n\n        if (orientation >= 5 && orientation <= 8) {\n          var _ref7 = [height, width];\n          width = _ref7[0];\n          height = _ref7[1];\n        }\n\n        // scale canvas based on pixel density\n        // we multiply by .75 as that creates smaller but still clear images on screens with high res displays\n        var pixelDensityFactor = Math.max(1, window.devicePixelRatio * 0.75);\n\n        // we want as much pixels to work with as possible,\n        // this multiplies the minimum image resolution,\n        // so when zooming in it doesn't get too blurry\n        var zoomFactor = root.query('GET_IMAGE_PREVIEW_ZOOM_FACTOR');\n\n        // imaeg scale factor\n        var scaleFactor = zoomFactor * pixelDensityFactor;\n\n        // calculate scaled preview image size\n        var previewImageRatio = height / width;\n\n        // calculate image preview height and width\n        var previewContainerWidth = root.rect.element.width;\n        var previewContainerHeight = root.rect.element.height;\n\n        var imageWidth = previewContainerWidth;\n        var imageHeight = imageWidth * previewImageRatio;\n\n        if (previewImageRatio > 1) {\n          imageWidth = Math.min(width, previewContainerWidth * scaleFactor);\n          imageHeight = imageWidth * previewImageRatio;\n        } else {\n          imageHeight = Math.min(height, previewContainerHeight * scaleFactor);\n          imageWidth = imageHeight / previewImageRatio;\n        }\n\n        // transfer to image tag so no canvas memory wasted on iOS\n        var previewImage = createPreviewImage(\n          imageData,\n          imageWidth,\n          imageHeight,\n          orientation\n        );\n\n        // done\n        var done = function done() {\n          // calculate average image color, disabled for now\n          var averageColor = root.query(\n            'GET_IMAGE_PREVIEW_CALCULATE_AVERAGE_IMAGE_COLOR'\n          )\n            ? calculateAverageColor(data)\n            : null;\n          item.setMetadata('color', averageColor, true);\n\n          // data has been transferred to canvas ( if was ImageBitmap )\n          if ('close' in imageData) {\n            imageData.close();\n          }\n\n          // show the overlay\n          root.ref.overlayShadow.opacity = 1;\n\n          // create the first image\n          pushImage({ root: root, props: props, image: previewImage });\n        };\n\n        // apply filter\n        var filter = item.getMetadata('filter');\n        if (filter) {\n          applyFilter(root, filter, previewImage).then(done);\n        } else {\n          done();\n        }\n      };\n\n      // if we support scaling using createImageBitmap we use a worker\n      if (canCreateImageBitmap(item.file)) {\n        // let's scale the image in a worker\n        var worker = createWorker(BitmapWorker);\n\n        worker.post(\n          {\n            file: item.file\n          },\n\n          function(imageBitmap) {\n            // destroy worker\n            worker.terminate();\n\n            // no bitmap returned, must be something wrong,\n            // try the oldschool way\n            if (!imageBitmap) {\n              loadPreviewFallback();\n              return;\n            }\n\n            // yay we got our bitmap, let's continue showing the preview\n            previewImageLoaded(imageBitmap);\n          }\n        );\n      } else {\n        // create fallback preview\n        loadPreviewFallback();\n      }\n    };\n\n    /**\n     * Write handler for when the preview image is ready to be animated\n     */\n    var didDrawPreview = function didDrawPreview(_ref8) {\n      var root = _ref8.root;\n      // get last added image\n      var image = root.ref.images[root.ref.images.length - 1];\n      image.translateY = 0;\n      image.scaleX = 1.0;\n      image.scaleY = 1.0;\n      image.opacity = 1;\n    };\n\n    /**\n     * Write handler for when the preview has been loaded\n     */\n    var restoreOverlay = function restoreOverlay(_ref9) {\n      var root = _ref9.root;\n      root.ref.overlayShadow.opacity = 1;\n      root.ref.overlayError.opacity = 0;\n      root.ref.overlaySuccess.opacity = 0;\n    };\n\n    var didThrowError = function didThrowError(_ref10) {\n      var root = _ref10.root;\n      root.ref.overlayShadow.opacity = 0.25;\n      root.ref.overlayError.opacity = 1;\n    };\n\n    var didCompleteProcessing = function didCompleteProcessing(_ref11) {\n      var root = _ref11.root;\n      root.ref.overlayShadow.opacity = 0.25;\n      root.ref.overlaySuccess.opacity = 1;\n    };\n\n    /**\n     * Constructor\n     */\n    var create = function create(_ref12) {\n      var root = _ref12.root;\n      // image view\n      root.ref.images = [];\n\n      // the preview image data (we need this to filter the image)\n      root.ref.imageData = null;\n\n      // image bin\n      root.ref.imageViewBin = [];\n\n      // image overlays\n      root.ref.overlayShadow = root.appendChildView(\n        root.createChildView(OverlayView, {\n          opacity: 0,\n          status: 'idle'\n        })\n      );\n\n      root.ref.overlaySuccess = root.appendChildView(\n        root.createChildView(OverlayView, {\n          opacity: 0,\n          status: 'success'\n        })\n      );\n\n      root.ref.overlayError = root.appendChildView(\n        root.createChildView(OverlayView, {\n          opacity: 0,\n          status: 'failure'\n        })\n      );\n    };\n\n    return _.utils.createView({\n      name: 'image-preview-wrapper',\n      create: create,\n      styles: ['height'],\n      apis: ['height'],\n      destroy: function destroy(_ref13) {\n        var root = _ref13.root;\n        // we resize the image so memory on iOS 12 is released more quickly (it seems)\n        root.ref.images.forEach(function(imageView) {\n          imageView.image.width = 1;\n          imageView.image.height = 1;\n        });\n      },\n      didWriteView: function didWriteView(_ref14) {\n        var root = _ref14.root;\n        root.ref.images.forEach(function(imageView) {\n          imageView.dirty = false;\n        });\n      },\n      write: _.utils.createRoute(\n        {\n          // image preview stated\n          DID_IMAGE_PREVIEW_DRAW: didDrawPreview,\n          DID_IMAGE_PREVIEW_CONTAINER_CREATE: didCreatePreviewContainer,\n          DID_FINISH_CALCULATE_PREVIEWSIZE: drawPreview,\n          DID_UPDATE_ITEM_METADATA: didUpdateItemMetadata,\n\n          // file states\n          DID_THROW_ITEM_LOAD_ERROR: didThrowError,\n          DID_THROW_ITEM_PROCESSING_ERROR: didThrowError,\n          DID_THROW_ITEM_INVALID: didThrowError,\n          DID_COMPLETE_ITEM_PROCESSING: didCompleteProcessing,\n          DID_START_ITEM_PROCESSING: restoreOverlay,\n          DID_REVERT_ITEM_PROCESSING: restoreOverlay\n        },\n\n        function(_ref15) {\n          var root = _ref15.root;\n          // views on death row\n          var viewsToRemove = root.ref.imageViewBin.filter(function(imageView) {\n            return imageView.opacity === 0;\n          });\n\n          // views to retain\n          root.ref.imageViewBin = root.ref.imageViewBin.filter(function(\n            imageView\n          ) {\n            return imageView.opacity > 0;\n          });\n\n          // remove these views\n          viewsToRemove.forEach(function(imageView) {\n            return removeImageView(root, imageView);\n          });\n          viewsToRemove.length = 0;\n        }\n      )\n    });\n  };\n\n  /**\n   * Image Preview Plugin\n   */\n  var plugin = function plugin(fpAPI) {\n    var addFilter = fpAPI.addFilter,\n      utils = fpAPI.utils;\n    var Type = utils.Type,\n      createRoute = utils.createRoute,\n      isFile = utils.isFile;\n\n    // imagePreviewView\n    var imagePreviewView = createImageWrapperView(fpAPI);\n\n    // called for each view that is created right after the 'create' method\n    addFilter('CREATE_VIEW', function(viewAPI) {\n      // get reference to created view\n      var is = viewAPI.is,\n        view = viewAPI.view,\n        query = viewAPI.query;\n\n      // only hook up to item view and only if is enabled for this cropper\n      if (!is('file') || !query('GET_ALLOW_IMAGE_PREVIEW')) return;\n\n      // create the image preview plugin, but only do so if the item is an image\n      var didLoadItem = function didLoadItem(_ref) {\n        var root = _ref.root,\n          props = _ref.props;\n        var id = props.id;\n        var item = query('GET_ITEM', id);\n\n        // item could theoretically have been removed in the mean time\n        if (!item || !isFile(item.file) || item.archived) return;\n\n        // get the file object\n        var file = item.file;\n\n        // exit if this is not an image\n        if (!isPreviewableImage(file)) return;\n\n        // test if is filtered\n        if (!query('GET_IMAGE_PREVIEW_FILTER_ITEM')(item)) return;\n\n        // exit if image size is too high and no createImageBitmap support\n        // this would simply bring the browser to its knees and that is not what we want\n        var supportsCreateImageBitmap = 'createImageBitmap' in (window || {});\n        var maxPreviewFileSize = query('GET_IMAGE_PREVIEW_MAX_FILE_SIZE');\n        if (\n          !supportsCreateImageBitmap &&\n          maxPreviewFileSize &&\n          file.size > maxPreviewFileSize\n        )\n          return;\n\n        // set preview view\n        root.ref.imagePreview = view.appendChildView(\n          view.createChildView(imagePreviewView, { id: id })\n        );\n\n        // update height if is fixed\n        var fixedPreviewHeight = root.query('GET_IMAGE_PREVIEW_HEIGHT');\n        if (fixedPreviewHeight) {\n          root.dispatch('DID_UPDATE_PANEL_HEIGHT', {\n            id: item.id,\n            height: fixedPreviewHeight\n          });\n        }\n\n        // now ready\n        var queue =\n          !supportsCreateImageBitmap &&\n          file.size > query('GET_IMAGE_PREVIEW_MAX_INSTANT_PREVIEW_FILE_SIZE');\n        root.dispatch('DID_IMAGE_PREVIEW_CONTAINER_CREATE', { id: id }, queue);\n      };\n\n      var rescaleItem = function rescaleItem(root, props) {\n        if (!root.ref.imagePreview) return;\n        var id = props.id;\n\n        // get item\n        var item = root.query('GET_ITEM', { id: id });\n        if (!item) return;\n\n        // if is fixed height or panel has aspect ratio, exit here, height has already been defined\n        var panelAspectRatio = root.query('GET_PANEL_ASPECT_RATIO');\n        var itemPanelAspectRatio = root.query('GET_ITEM_PANEL_ASPECT_RATIO');\n        var fixedHeight = root.query('GET_IMAGE_PREVIEW_HEIGHT');\n        if (panelAspectRatio || itemPanelAspectRatio || fixedHeight) return;\n\n        // no data!\n        var _root$ref = root.ref,\n          imageWidth = _root$ref.imageWidth,\n          imageHeight = _root$ref.imageHeight;\n        if (!imageWidth || !imageHeight) return;\n\n        // get height min and max\n        var minPreviewHeight = root.query('GET_IMAGE_PREVIEW_MIN_HEIGHT');\n        var maxPreviewHeight = root.query('GET_IMAGE_PREVIEW_MAX_HEIGHT');\n\n        // orientation info\n        var exif = item.getMetadata('exif') || {};\n        var orientation = exif.orientation || -1;\n\n        // get width and height from action, and swap of orientation is incorrect\n        if (orientation >= 5 && orientation <= 8) {\n          var _ref2 = [imageHeight, imageWidth];\n          imageWidth = _ref2[0];\n          imageHeight = _ref2[1];\n        }\n\n        // scale up width and height when we're dealing with an SVG\n        if (!isBitmap(item.file) || root.query('GET_IMAGE_PREVIEW_UPSCALE')) {\n          var scalar = 2048 / imageWidth;\n          imageWidth *= scalar;\n          imageHeight *= scalar;\n        }\n\n        // image aspect ratio\n        var imageAspectRatio = imageHeight / imageWidth;\n\n        // we need the item to get to the crop size\n        var previewAspectRatio =\n          (item.getMetadata('crop') || {}).aspectRatio || imageAspectRatio;\n\n        // preview height range\n        var previewHeightMax = Math.max(\n          minPreviewHeight,\n          Math.min(imageHeight, maxPreviewHeight)\n        );\n\n        var itemWidth = root.rect.element.width;\n        var previewHeight = Math.min(\n          itemWidth * previewAspectRatio,\n          previewHeightMax\n        );\n\n        // request update to panel height\n        root.dispatch('DID_UPDATE_PANEL_HEIGHT', {\n          id: item.id,\n          height: previewHeight\n        });\n      };\n\n      var didResizeView = function didResizeView(_ref3) {\n        var root = _ref3.root;\n        // actions in next write operation\n        root.ref.shouldRescale = true;\n      };\n\n      var didUpdateItemMetadata = function didUpdateItemMetadata(_ref4) {\n        var root = _ref4.root,\n          action = _ref4.action;\n        if (action.change.key !== 'crop') return;\n\n        // actions in next write operation\n        root.ref.shouldRescale = true;\n      };\n\n      var didCalculatePreviewSize = function didCalculatePreviewSize(_ref5) {\n        var root = _ref5.root,\n          action = _ref5.action;\n        // remember dimensions\n        root.ref.imageWidth = action.width;\n        root.ref.imageHeight = action.height;\n\n        // actions in next write operation\n        root.ref.shouldRescale = true;\n        root.ref.shouldDrawPreview = true;\n\n        // as image load could take a while and fire when draw loop is resting we need to give it a kick\n        root.dispatch('KICK');\n      };\n\n      // start writing\n      view.registerWriter(\n        createRoute(\n          {\n            DID_RESIZE_ROOT: didResizeView,\n            DID_STOP_RESIZE: didResizeView,\n            DID_LOAD_ITEM: didLoadItem,\n            DID_IMAGE_PREVIEW_CALCULATE_SIZE: didCalculatePreviewSize,\n            DID_UPDATE_ITEM_METADATA: didUpdateItemMetadata\n          },\n\n          function(_ref6) {\n            var root = _ref6.root,\n              props = _ref6.props;\n            // no preview view attached\n            if (!root.ref.imagePreview) return;\n\n            // don't do anything while hidden\n            if (root.rect.element.hidden) return;\n\n            // resize the item panel\n            if (root.ref.shouldRescale) {\n              rescaleItem(root, props);\n              root.ref.shouldRescale = false;\n            }\n\n            if (root.ref.shouldDrawPreview) {\n              // queue till next frame so we're sure the height has been applied this forces the draw image call inside the wrapper view to use the correct height\n              requestAnimationFrame(function() {\n                // this requestAnimationFrame nesting is horrible but it fixes an issue with 100hz displays on Chrome\n                // https://github.com/pqina/filepond-plugin-image-preview/issues/57\n                requestAnimationFrame(function() {\n                  root.dispatch('DID_FINISH_CALCULATE_PREVIEWSIZE', {\n                    id: props.id\n                  });\n                });\n              });\n\n              root.ref.shouldDrawPreview = false;\n            }\n          }\n        )\n      );\n    });\n\n    // expose plugin\n    return {\n      options: {\n        // Enable or disable image preview\n        allowImagePreview: [true, Type.BOOLEAN],\n\n        // filters file items to determine which are shown as preview\n        imagePreviewFilterItem: [\n          function() {\n            return true;\n          },\n          Type.FUNCTION\n        ],\n\n        // Fixed preview height\n        imagePreviewHeight: [null, Type.INT],\n\n        // Min image height\n        imagePreviewMinHeight: [44, Type.INT],\n\n        // Max image height\n        imagePreviewMaxHeight: [256, Type.INT],\n\n        // Max size of preview file for when createImageBitmap is not supported\n        imagePreviewMaxFileSize: [null, Type.INT],\n\n        // The amount of extra pixels added to the image preview to allow comfortable zooming\n        imagePreviewZoomFactor: [2, Type.INT],\n\n        // Should we upscale small images to fit the max bounding box of the preview area\n        imagePreviewUpscale: [false, Type.BOOLEAN],\n\n        // Max size of preview file that we allow to try to instant preview if createImageBitmap is not supported, else image is queued for loading\n        imagePreviewMaxInstantPreviewFileSize: [1000000, Type.INT],\n\n        // Style of the transparancy indicator used behind images\n        imagePreviewTransparencyIndicator: [null, Type.STRING],\n\n        // Enables or disables reading average image color\n        imagePreviewCalculateAverageImageColor: [false, Type.BOOLEAN],\n\n        // Enables or disables the previewing of markup\n        imagePreviewMarkupShow: [true, Type.BOOLEAN],\n\n        // Allows filtering of markup to only show certain shapes\n        imagePreviewMarkupFilter: [\n          function() {\n            return true;\n          },\n          Type.FUNCTION\n        ]\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.8\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","/*!\n * FilePondPluginFileEncode 2.1.14\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.FilePondPluginFileEncode = factory()));\n})(this, function() {\n    'use strict';\n\n    var DataURIWorker = function DataURIWorker() {\n        // route messages\n        self.onmessage = function(e) {\n            convert(e.data.message, function(response) {\n                self.postMessage({ id: e.data.id, message: response });\n            });\n        };\n\n        // convert file to data uri\n        var convert = function convert(options, cb) {\n            var file = options.file;\n\n            var reader = new FileReader();\n            reader.onloadend = function() {\n                cb(reader.result.replace('data:', '').replace(/^.+,/, ''));\n            };\n            reader.readAsDataURL(file);\n        };\n    };\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            createWorker = utils.createWorker,\n            createRoute = utils.createRoute,\n            isFile = utils.isFile;\n\n        var encode = function encode(_ref2) {\n            var name = _ref2.name,\n                file = _ref2.file;\n            return new Promise(function(resolve) {\n                var worker = createWorker(DataURIWorker);\n                worker.post({ file: file }, function(data) {\n                    resolve({ name: name, data: data });\n                    worker.terminate();\n                });\n            });\n        };\n\n        // holds base64 strings till can be moved to item\n        var base64Cache = [];\n        addFilter('DID_CREATE_ITEM', function(item, _ref3) {\n            var query = _ref3.query;\n            if (!query('GET_ALLOW_FILE_ENCODE')) return;\n\n            item.extend('getFileEncodeBase64String', function() {\n                return base64Cache[item.id] && base64Cache[item.id].data;\n            });\n\n            item.extend('getFileEncodeDataURL', function() {\n                return (\n                    base64Cache[item.id] &&\n                    'data:'.concat(item.fileType, ';base64,').concat(base64Cache[item.id].data)\n                );\n            });\n        });\n\n        addFilter('SHOULD_PREPARE_OUTPUT', function(shouldPrepareOutput, _ref4) {\n            var query = _ref4.query;\n            return new Promise(function(resolve) {\n                resolve(query('GET_ALLOW_FILE_ENCODE'));\n            });\n        });\n\n        addFilter('COMPLETE_PREPARE_OUTPUT', function(file, _ref5) {\n            var item = _ref5.item,\n                query = _ref5.query;\n            return new Promise(function(resolve) {\n                // if it's not a file or a list of files, continue\n                if (!query('GET_ALLOW_FILE_ENCODE') || (!isFile(file) && !Array.isArray(file))) {\n                    return resolve(file);\n                }\n\n                // store metadata settings for this cache\n                base64Cache[item.id] = {\n                    metadata: item.getMetadata(),\n                    data: null,\n                };\n\n                // wait for all file items to be encoded\n                Promise.all(\n                    (file instanceof Blob ? [{ name: null, file: file }] : file).map(encode)\n                ).then(function(dataItems) {\n                    base64Cache[item.id].data =\n                        file instanceof Blob ? dataItems[0].data : dataItems;\n                    resolve(file);\n                });\n            });\n        });\n\n        // called for each view that is created right after the 'create' method\n        addFilter('CREATE_VIEW', function(viewAPI) {\n            // get reference to created view\n            var is = viewAPI.is,\n                view = viewAPI.view,\n                query = viewAPI.query;\n\n            // only hook up to item view\n            if (!is('file-wrapper') || !query('GET_ALLOW_FILE_ENCODE')) {\n                return;\n            }\n\n            view.registerWriter(\n                createRoute({\n                    DID_PREPARE_OUTPUT: function DID_PREPARE_OUTPUT(_ref6) {\n                        var root = _ref6.root,\n                            action = _ref6.action;\n                        // only do this if is not uploading async\n                        if (query('IS_ASYNC')) {\n                            return;\n                        }\n\n                        var item = query('GET_ITEM', action.id);\n                        if (!item) return;\n\n                        // extract base64 string\n                        var cache = base64Cache[item.id];\n                        var metadata = cache.metadata;\n                        var data = cache.data;\n\n                        // create JSON string from encoded data\n                        var value = JSON.stringify({\n                            id: item.id,\n                            name: item.file.name,\n                            type: item.file.type,\n                            size: item.file.size,\n                            metadata: metadata,\n                            data: data,\n                        });\n\n                        // for filepond < 4.13.0\n                        if (root.ref.data) {\n                            root.ref.data.value = value;\n                        }\n                        // newer versions\n                        else {\n                            root.dispatch('DID_DEFINE_VALUE', {\n                                id: item.id,\n                                value: value,\n                            });\n                        }\n                    },\n                    DID_REMOVE_ITEM: function DID_REMOVE_ITEM(_ref7) {\n                        var action = _ref7.action;\n                        var item = query('GET_ITEM', action.id);\n                        if (!item) return;\n                        delete base64Cache[item.id];\n                    },\n                })\n            );\n        });\n\n        return {\n            options: {\n                // Enable or disable file encoding\n                allowFileEncode: [true, Type.BOOLEAN],\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","/*!\n * FilePondPluginImageExifOrientation 1.0.11\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.FilePondPluginImageExifOrientation = factory()));\n})(this, function() {\n  'use strict';\n\n  // test if file is of type image\n  var isJPEG = function isJPEG(file) {\n    return /^image\\/jpeg/.test(file.type);\n  };\n\n  var Marker = {\n    JPEG: 0xffd8,\n    APP1: 0xffe1,\n    EXIF: 0x45786966,\n    TIFF: 0x4949,\n    Orientation: 0x0112,\n    Unknown: 0xff00\n  };\n\n  var getUint16 = function getUint16(view, offset) {\n    var little =\n      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n    return view.getUint16(offset, little);\n  };\n  var getUint32 = function getUint32(view, offset) {\n    var little =\n      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n    return view.getUint32(offset, little);\n  };\n\n  var getImageOrientation = function getImageOrientation(file) {\n    return new Promise(function(resolve, reject) {\n      var reader = new FileReader();\n      reader.onload = function(e) {\n        var view = new DataView(e.target.result);\n\n        // Every JPEG file starts from binary value '0xFFD8'\n        if (getUint16(view, 0) !== Marker.JPEG) {\n          // This aint no JPEG\n          resolve(-1);\n          return;\n        }\n\n        var length = view.byteLength;\n        var offset = 2;\n\n        while (offset < length) {\n          var marker = getUint16(view, offset);\n          offset += 2;\n\n          // There's our APP1 Marker\n          if (marker === Marker.APP1) {\n            if (getUint32(view, (offset += 2)) !== Marker.EXIF) {\n              // no EXIF info defined\n              break;\n            }\n\n            // Get TIFF Header\n            var little = getUint16(view, (offset += 6)) === Marker.TIFF;\n            offset += getUint32(view, offset + 4, little);\n\n            var tags = getUint16(view, offset, little);\n            offset += 2;\n\n            for (var i = 0; i < tags; i++) {\n              // found the orientation tag\n              if (\n                getUint16(view, offset + i * 12, little) === Marker.Orientation\n              ) {\n                resolve(getUint16(view, offset + i * 12 + 8, little));\n\n                return;\n              }\n            }\n          } else if ((marker & Marker.Unknown) !== Marker.Unknown) {\n            // Invalid\n            break;\n          } else {\n            offset += getUint16(view, offset);\n          }\n        }\n\n        // Nothing found\n        resolve(-1);\n      };\n\n      // we don't need to read the entire file to get the orientation\n      reader.readAsArrayBuffer(file.slice(0, 64 * 1024));\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  // 2x1 pixel image 90CW rotated with orientation header\n  var testSrc =\n    'data:image/jpg;base64,/9j/4AAQSkZJRgABAQEASABIAAD/4QA6RXhpZgAATU0AKgAAAAgAAwESAAMAAAABAAYAAAEoAAMAAAABAAIAAAITAAMAAAABAAEAAAAAAAD/2wBDAP//////////////////////////////////////////////////////////////////////////////////////wAALCAABAAIBASIA/8QAJgABAAAAAAAAAAAAAAAAAAAAAxABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQAAPwBH/9k=';\n\n  // should correct orientation if is presented in landscape, in which case the browser doesn't autocorrect\n  var shouldCorrect = undefined;\n  var testImage = isBrowser() ? new Image() : {};\n  testImage.onload = function() {\n    return (shouldCorrect = testImage.naturalWidth > testImage.naturalHeight);\n  };\n  testImage.src = testSrc;\n\n  var shouldCorrectImageExifOrientation = function shouldCorrectImageExifOrientation() {\n    return shouldCorrect;\n  };\n\n  /**\n   * Read Image Orientation Plugin\n   */\n  var plugin = function plugin(_ref) {\n    var addFilter = _ref.addFilter,\n      utils = _ref.utils;\n    var Type = utils.Type,\n      isFile = utils.isFile;\n\n    // subscribe to file load and append required info\n    addFilter('DID_LOAD_ITEM', function(item, _ref2) {\n      var query = _ref2.query;\n      return new Promise(function(resolve, reject) {\n        // get file reference\n        var file = item.file;\n\n        // if this is not a jpeg image we are not interested\n        if (\n          !isFile(file) ||\n          !isJPEG(file) ||\n          !query('GET_ALLOW_IMAGE_EXIF_ORIENTATION') ||\n          !shouldCorrectImageExifOrientation()\n        ) {\n          // continue with the unaltered dataset\n          return resolve(item);\n        }\n\n        // get orientation from exif data\n        getImageOrientation(file).then(function(orientation) {\n          item.setMetadata('exif', { orientation: orientation });\n          resolve(item);\n        });\n      });\n    });\n\n    // Expose plugin options\n    return {\n      options: {\n        // Enable or disable image orientation reading\n        allowImageExifOrientation: [true, Type.BOOLEAN]\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$1 =\n    typeof window !== 'undefined' && typeof window.document !== 'undefined';\n  if (isBrowser$1) {\n    document.dispatchEvent(\n      new CustomEvent('FilePond:pluginloaded', { detail: plugin })\n    );\n  }\n\n  return plugin;\n});\n","/*!\n * FilePond 4.31.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 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n        var actions = 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, args = new Array(_len > 1 ? _len - 1 : 0), _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({}, action(dispatch, query, state), {}, actionHandlers);\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 = 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 = 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 typeof window !== 'undefined' && typeof window.document !== 'undefined';\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(elementRect, childViews, offset, scale) {\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 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0.001;\n        return Math.abs(position - destination) < errorMargin && Math.abs(velocity) < errorMargin;\n    };\n\n    /**\n     * Spring animation\n     */\n    var spring =\n        // default options\n        function spring() // method definition\n        {\n            var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\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 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\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 = 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' ? defaults[key] : 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 += '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(' + (translateX || 0) + 'px, ' + (translateY || 0) + '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 (styles.length !== elementCurrentStyle.length || styles !== elementCurrentStyle) {\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 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n        var element = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n        var style = 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 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\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 = _ref$didCreateView === void 0 ? function() {} : _ref$didCreateView,\n                _ref$didWriteView = _ref.didWriteView,\n                didWriteView = _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 = _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 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\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 = 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(newNode, referenceNode.nextSibling);\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 = 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 = 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(key, outline[key], methods[key], api.timeout, api.headers);\n        });\n\n        // remove process if no url or process on outline\n        api.process = outline.process || isString(outline) || outline.url ? api.process : null;\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(name, outline, method, timeout, headers) {\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(newValue, defaultValue, valueType) {\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 = 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            .substring(2, 11);\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' && Symbol['for'] && 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(gen, resolve, reject, _next, _throw, 'next', value);\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(target, Object.getOwnPropertyDescriptors(source));\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('Super expression must either be null or a function');\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 (right != null && typeof Symbol !== 'undefined' && right[Symbol.hasInstance]) {\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(\"this hasn't been initialised - super() hasn't been called\");\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('Class \"' + name + '\" cannot be referenced in computed property keys.');\n    }\n\n    var _temporalUndefined = {};\n\n    function _slicedToArray(arr, i) {\n        return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();\n    }\n\n    function _slicedToArrayLoose(arr, i) {\n        return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _nonIterableRest();\n    }\n\n    function _toArray(arr) {\n        return _arrayWithHoles(arr) || _iterableToArray(arr) || _nonIterableRest();\n    }\n\n    function _toConsumableArray(arr) {\n        return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\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++) 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 (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\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 (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done; ) {\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 ? descriptor.initializer.call(context) : void 0,\n        });\n    }\n\n    function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {\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(receiver, classConstructor, descriptor) {\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(receiver, classConstructor, descriptor, value) {\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(element, placements);\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 (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) {\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(elementObject, 'finisher', 'An element descriptor');\n                    this.disallowProperty(elementObject, 'extras', 'An element descriptor');\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 (placement !== 'static' && placement !== 'prototype' && placement !== 'own') {\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(elementObject, 'elements', 'An element descriptor');\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(elementObject, 'initializer', 'A method descriptor');\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(objectType + \" can't have a .\" + name + ' property.');\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 ? 'static' : def.kind === 'field' ? 'own' : '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 (element.kind === 'method' && (other = newElements.find(isSameElement))) {\n                if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) {\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 desc !== undefined && !(desc.value === undefined && desc.writable === undefined);\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        // Try store file if `server` not set\n        storeAsFile: [false, Type.BOOLEAN],\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        allowMinimumUploadDuration: [true, Type.BOOLEAN], // if true uploads take at least 750 ms, this ensures the user sees the upload progress giving trust the upload actually happened\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        labelFileSizeBytes: ['bytes', Type.STRING],\n        labelFileSizeKilobytes: ['KB', Type.STRING],\n        labelFileSizeMegabytes: ['MB', Type.STRING],\n        labelFileSizeGigabytes: ['GB', Type.STRING],\n\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\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(aspectRatio) {\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 res = null;\n    var canUpdateFileInput = function canUpdateFileInput() {\n        if (res === null) {\n            try {\n                var dataTransfer = new DataTransfer();\n                dataTransfer.items.add(new File(['hello world'], 'This_Works.txt'));\n                var el = document.createElement('input');\n                el.setAttribute('type', 'file');\n                el.files = dataTransfer.files;\n                res = el.files.length === 1;\n            } catch (err) {\n                res = false;\n            }\n        }\n        return res;\n    };\n\n    var ITEM_ERROR = [\n        ItemStatus.LOAD_ERROR,\n        ItemStatus.PROCESSING_ERROR,\n        ItemStatus.PROCESSING_REVERT_ERROR,\n    ];\n\n    var ITEM_BUSY = [\n        ItemStatus.LOADING,\n        ItemStatus.PROCESSING,\n        ItemStatus.PROCESSING_QUEUED,\n        ItemStatus.INIT,\n    ];\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 isAsync = function isAsync(state) {\n        return (\n            isObject(state.options.server) &&\n            (isObject(state.options.server.process) || isFunction(state.options.server.process))\n        );\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(state.options.stylePanelAspectRatio);\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            SHOULD_UPDATE_FILE_INPUT: function SHOULD_UPDATE_FILE_INPUT() {\n                return state.options.storeAsFile && canUpdateFileInput() && !isAsync(state);\n            },\n\n            IS_ASYNC: function IS_ASYNC() {\n                return isAsync(state);\n            },\n\n            GET_FILE_SIZE_LABELS: function GET_FILE_SIZE_LABELS(query) {\n                return {\n                    labelBytes: query('GET_LABEL_FILE_SIZE_BYTES') || undefined,\n                    labelKilobytes: query('GET_LABEL_FILE_SIZE_KILOBYTES') || undefined,\n                    labelMegabytes: query('GET_LABEL_FILE_SIZE_MEGABYTES') || undefined,\n                    labelGigabytes: query('GET_LABEL_FILE_SIZE_GIGABYTES') || undefined,\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 = 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 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 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 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n        var extension = 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(dataURI) {\n        return (/^data:(.+);/.exec(dataURI) || [])[1] || null;\n    };\n\n    var getBase64DataFromBase64DataURI = function getBase64DataFromBase64DataURI(dataURI) {\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(dataURI) {\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(dataURI, filename, extension) {\n        return getFileFromBlob(getBlobFromBase64DataURI(dataURI), filename, null, extension);\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 ? response : response ? response.body : 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(typeof data === 'string' ? data : JSON.stringify(data));\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 (var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++) {\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 = 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 = 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(createResponse('headers', xhr.status, null, xhr.getAllResponseHeaders()));\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' ? xhr.getResponseHeader('Upload-Offset') : 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(offset, offset + chunkSize, 'application/offset+octet-stream');\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 chunk.status === ChunkStatus.QUEUED || chunk.status === ChunkStatus.ERROR;\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 = 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            var headers =\n                typeof action.headers === 'function'\n                    ? action.headers(file, metadata) || {}\n                    : Object.assign(\n                          {},\n\n                          action.headers\n                      );\n\n            var requestParams = Object.assign({}, action, {\n                headers: headers,\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(function(item) {\n                formData.append(\n                    name,\n                    item.file,\n                    item.name === null ? item.file.name : '' + item.name + item.file.name\n                );\n            });\n\n            // send request object\n            var request = sendRequest(\n                ondata(formData),\n                buildURL(apiUrl, action.url),\n                requestParams\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 = 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 = 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 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n        var max = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;\n        return min + Math.random() * (max - min);\n    };\n\n    var createPerceivedPerformanceUpdater = function createPerceivedPerformanceUpdater(cb) {\n        var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;\n        var offset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n        var tickMin = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 25;\n        var tickMax = 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        if (duration > 0) tick();\n\n        return {\n            clear: function clear() {\n                clearTimeout(timeout);\n            },\n        };\n    };\n\n    var createFileProcessor = function createFileProcessor(processFn, options) {\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        var allowMinimumUploadDuration = options.allowMinimumUploadDuration;\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 (state.response && state.perceivedProgress === 1 && !state.complete) {\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                allowMinimumUploadDuration ? getRandomNumber(750, 1500) : 0\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 (\n                        !allowMinimumUploadDuration ||\n                        (allowMinimumUploadDuration && state.perceivedProgress === 1)\n                    ) {\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 = allowMinimumUploadDuration\n            ? function() {\n                  return state.progress ? Math.min(state.progress, state.perceivedProgress) : null;\n              }\n            : function() {\n                  return state.progress || null;\n              };\n\n        var getDuration = allowMinimumUploadDuration\n            ? function() {\n                  return Math.min(state.duration, state.perceivedDuration);\n              }\n            : function() {\n                  return state.duration;\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.substring(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 = 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 = 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 ? ItemStatus.PROCESSING_COMPLETE : 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, params = new Array(_len > 1 ? _len - 1 : 0), _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.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                // a completed upload will have a serverFileReference, a failed chunked upload where\n                // getting a serverId succeeded but >=0 chunks have been uploaded will have transferId set\n                var serverTransferId =\n                    state.serverFileReference !== null\n                        ? state.serverFileReference\n                        : state.transferId;\n\n                // cannot revert without a server id for this process\n                if (serverTransferId === null) {\n                    resolve();\n                    return;\n                }\n\n                // revert the upload (fire and forget)\n                revertFileUpload(\n                    serverTransferId,\n                    function() {\n                        // reset file server id and transfer id as now it's not available on the server\n                        state.serverFileReference = null;\n                        state.transferId = 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            // fire update\n            fire('metadata-update', {\n                key: root,\n                value: metadata[root],\n                silent: silent,\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                    set: function set(value) {\n                        return (origin = value);\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                // replace source and file object\n                setFile: function setFile(file) {\n                    return (state.file = file);\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(url, load, error, progress, abort, headers) {\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 = getFileInfoFromHeaders(headers).name || getFilenameFromURL(url);\n\n            // create response\n            load(\n                createResponse('load', xhr.status, getFileFromBlob(xhr.response, filename), headers)\n            );\n        };\n\n        request.onerror = function(xhr) {\n            error(createResponse('error', xhr.status, xhr.statusText, xhr.getAllResponseHeaders()));\n        };\n\n        request.onheaders = function(xhr) {\n            headers(createResponse('headers', xhr.status, null, xhr.getAllResponseHeaders()));\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, params = new Array(_len > 1 ? _len - 1 : 0), _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(state, itemHandler) {\n        return function() {\n            var _ref = 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, ['query', 'success', 'failure']);\n            var item = getItemByQuery(state.items, query);\n            if (!item) {\n                failure({\n                    error: createResponse('error', 0, 'Item not found'),\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                // 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                    change = _ref3.change;\n                // don't do anything\n                if (change.silent) return;\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                            change: change,\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(item, shouldPrepareOutput);\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\n                                true\n                            );\n                        });\n\n                        return;\n                    }\n\n                    // if is local item we need to enable upload button so change can be propagated to server\n                    if (item.origin === FileOrigin.LOCAL) {\n                        dispatch('DID_LOAD_ITEM', {\n                            id: item.id,\n                            error: null,\n                            serverFileReference: item.source,\n                        });\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.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                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                // if no source supplied\n                if (isEmpty(source)) {\n                    failure({\n                        error: createResponse('error', 0, 'No source'),\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, { query: query, dispatch: dispatch });\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', { id: id, progress: progress });\n                });\n\n                item.on('load-request-error', function(error) {\n                    var mainStatus = dynamicLabel(state.options.labelFileLoadError)(error);\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                    item.on('metadata-update', function(change) {\n                        if (!isFile(item.file)) return;\n                        dispatch('DID_UPDATE_ITEM_METADATA', { id: id, change: change });\n                    });\n\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(item, shouldPrepareOutput);\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\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, { query: query, dispatch: dispatch })\n                        .then(function() {\n                            optionalPromise(query('GET_BEFORE_ADD_FILE'), createItemAPI(item)).then(\n                                handleAdd\n                            );\n                        })\n                        .catch(function(e) {\n                            if (!e || !e.error || !e.status) return handleAdd(false);\n                            dispatch('DID_THROW_ITEM_INVALID', {\n                                id: id,\n                                error: e.error,\n                                status: e.status,\n                            });\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', { id: id, progress: progress });\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)(error),\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                // error response if item archived\n                var err = {\n                    error: createResponse('error', 0, 'Item not found'),\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, { query: query, item: item }).then(\n                    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\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: item.serverId || 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(item, _success, failure) {\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\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.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('PROCESS_ITEM', { query: item, success: success, failure: failure }, true);\n            }),\n\n            PROCESS_ITEM: getItemByQueryFromState(state, function(item, success, failure) {\n                var maxParallelUploads = query('GET_MAX_PARALLEL_UPLOADS');\n                var totalCurrentUploads = query('GET_ITEMS_BY_STATUS', 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                    // if origin is local, and we're instant uploading, trigger remove of original\n                    // as revert will remove file from list\n                    var server = state.options.server;\n                    var instantUpload = state.options.instantUpload;\n                    if (\n                        instantUpload &&\n                        item.origin === FileOrigin.LOCAL &&\n                        isFunction(server.remove)\n                    ) {\n                        var noop = function noop() {};\n                        item.origin = FileOrigin.LIMBO;\n                        state.options.server.remove(item.source, noop, noop);\n                    }\n\n                    // All items processed? No errors?\n                    var allItemsProcessed =\n                        query('GET_ITEMS_BY_STATUS', ItemStatus.PROCESSING_COMPLETE).length ===\n                        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                            allowMinimumUploadDuration: query('GET_ALLOW_MINIMUM_UPLOAD_DURATION'),\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, { query: query, item: item })\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(query('GET_BEFORE_REMOVE_FILE'), createItemAPI(item)).then(function(\n                    shouldRemove\n                ) {\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(item, success, failure, options) {\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,\n                // 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)(status),\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                        // if chunked uploads are enabled and we're uploading in chunks for this specific file\n                        // or if the file isn't big enough for chunked uploads but chunkForce is set then call\n                        // revert before removing from the view...\n                        (state.options.chunkUploads && item.file.size > state.options.chunkSize) ||\n                        (state.options.chunkUploads && state.options.chunkForce)\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(item) {\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.revert(\n                    createRevertFunction(state.options.server.url, state.options.server.revert),\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                // get all keys passed\n                var optionKeys = Object.keys(options);\n\n                // get prioritized keyed to include (remove once not in options object)\n                var prioritizedOptionKeys = PrioritizedOptions.filter(function(key) {\n                    return optionKeys.includes(key);\n                });\n\n                // order the keys, prioritized first, then rest\n                var orderedOptionKeys = [].concat(\n                    _toConsumableArray(prioritizedOptionKeys),\n                    _toConsumableArray(\n                        Object.keys(options).filter(function(key) {\n                            return !prioritizedOptionKeys.includes(key);\n                        })\n                    )\n                );\n\n                // dispatch set event for each option\n                orderedOptionKeys.forEach(function(key) {\n                    dispatch('SET_' + fromCamels(key, '_').toUpperCase(), {\n                        value: options[key],\n                    });\n                });\n            },\n        };\n    };\n\n    var PrioritizedOptions = ['server'];\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(centerX, centerY, radius, angleInDegrees) {\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(x, y, radius, startAngle, endAngle, arcSweep) {\n        var start = polarToCartesian(x, y, radius, endAngle);\n        var end = polarToCartesian(x, y, radius, startAngle);\n        return ['M', start.x, start.y, 'A', radius, radius, 0, arcSweep, 0, end.x, end.y].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        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(size, size, size - ringStrokeWidth, ringFrom, ringTo);\n\n        // update progress bar\n        attr(root.ref.path, 'd', coordinates);\n\n        // hide while contains 0 value\n        attr(root.ref.path, 'stroke-opacity', props.spin || props.progress > 0 ? 1 : 0);\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 = (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 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1000;\n        var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n        var _options$labelBytes = options.labelBytes,\n            labelBytes = _options$labelBytes === void 0 ? 'bytes' : _options$labelBytes,\n            _options$labelKilobyt = options.labelKilobytes,\n            labelKilobytes = _options$labelKilobyt === void 0 ? 'KB' : _options$labelKilobyt,\n            _options$labelMegabyt = options.labelMegabytes,\n            labelMegabytes = _options$labelMegabyt === void 0 ? 'MB' : _options$labelMegabyt,\n            _options$labelGigabyt = options.labelGigabytes,\n            labelGigabytes = _options$labelGigabyt === void 0 ? 'GB' : _options$labelGigabyt;\n\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 + ' ' + labelBytes;\n        }\n\n        // kilobytes\n        if (bytes < MB) {\n            return Math.floor(bytes / KB) + ' ' + labelKilobytes;\n        }\n\n        // megabytes\n        if (bytes < GB) {\n            return removeDecimalsWhenZero(bytes / MB, 1, decimalSeparator) + ' ' + labelMegabytes;\n        }\n\n        // gigabytes\n        return removeDecimalsWhenZero(bytes / GB, 2, decimalSeparator) + ' ' + labelGigabytes;\n    };\n\n    var removeDecimalsWhenZero = function removeDecimalsWhenZero(value, decimalCount, separator) {\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                root.query('GET_FILE_SIZE_LABELS', root.query)\n            )\n        );\n\n        text(root.ref.fileName, formatFilename(root.query('GET_ITEM_NAME', props.id)));\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            updateFile({ root: root, props: props });\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') + ' ' + toPercentage(action.progress) + '%';\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        if (getRemoveIndicatorAligment(root) === 'right') return 0;\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(root) {\n        return Math.floor(root.ref.buttonRemoveItem.rect.element.height / 4);\n    };\n    var calculateFileHorizontalCenterOffset = function calculateFileHorizontalCenterOffset(root) {\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(root) {\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: { opacity: 0, align: getProcessIndicatorAlignment },\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: { opacity: 1, align: getRemoveIndicatorAligment },\n            info: { translateX: calculateFileInfoOffset },\n            status: { opacity: 0 },\n        },\n\n        DID_THROW_ITEM_REMOVE_ERROR: {\n            processProgressIndicator: { opacity: 0, align: getRemoveIndicatorAligment },\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        // copy Buttons object\n        var LocalButtons = Object.keys(Buttons).reduce(function(prev, curr) {\n            prev[curr] = Object.assign({}, Buttons[curr]);\n            return prev;\n        }, {});\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('GET_STYLE_BUTTON_REMOVE_ITEM_ALIGN');\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(key);\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 ? ButtonKeys.filter(buttonFilter) : ButtonKeys.concat();\n\n        // update icon and label for revert button when instant uploading\n        if (instantUpload && allowRevert) {\n            LocalButtons['RevertItemProcessing'].label = 'GET_LABEL_BUTTON_REMOVE_ITEM';\n            LocalButtons['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['DID_THROW_ITEM_PROCESSING_ERROR'].status.translateX = calculateButtonWidth;\n        }\n\n        // move remove button to right\n        if (alignRemoveItemButton && allowRevert) {\n            LocalButtons['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        // show/hide RemoveItem button\n        if (!allowRemove) {\n            LocalButtons['RemoveItem'].disabled = true;\n        }\n\n        // create the button views\n        forin(LocalButtons, 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('GET_STYLE_' + definition.align);\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\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(root.createChildView(fileInfo, { id: id }));\n\n        // create file status view\n        root.ref.status = root.appendChildView(root.createChildView(fileStatus, { id: id }));\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        // 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] && typeof stylesToApply[name][key] !== 'undefined'\n                            ? stylesToApply[name][key]\n                            : defaultValue;\n                    root.ref.activeStyles.push({ control: control, key: key, value: value });\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(_ref6) {\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(_ref11) {\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(_ref12) {\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(root.createChildView(file, { id: props.id }));\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(root.ref.fileName, formatFilename(root.query('GET_ITEM_NAME', props.id)));\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 = (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        // 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(root.createChildView(panel, { name: 'item-panel' }));\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                props.dragOffset = {\n                    x: e.pageX - origin.x,\n                    y: e.pageY - origin.y,\n                };\n\n                reset();\n            };\n\n            var cancel = function cancel() {\n                reset();\n            };\n\n            var reset = function reset() {\n                document.removeEventListener('pointercancel', cancel);\n                document.removeEventListener('pointermove', drag);\n                document.removeEventListener('pointerup', drop);\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('pointercancel', cancel);\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\n        function(_ref6) {\n            var root = _ref6.root,\n                actions = _ref6.actions,\n                props = _ref6.props,\n                shouldOptimize = _ref6.shouldOptimize;\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 = StateMap[props.currentState] || '';\n            }\n\n            // route actions\n            var aspectRatio =\n                root.query('GET_ITEM_PANEL_ASPECT_RATIO') || 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\n            styles: ['translateX', 'translateY', 'scaleX', 'scaleY', 'opacity', 'height'],\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 getItemsPerRow = function(horizontalSpace, itemWidth) {\n        // add one pixel leeway, when using percentages for item width total items can be 1.99 per row\n\n        return Math.max(1, Math.floor((horizontalSpace + 1) / itemWidth));\n    };\n\n    var getItemIndexByPosition = function getItemIndexByPosition(view, children, positionInView) {\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 = getItemsPerRow(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 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n        var vy = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;\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\n        // get drag area dimensions\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\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\n        // get new index\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        // 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 = getItemsPerRow(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 = 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 = 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 + root.rect.element.marginTop + 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 = 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({ root: root, action: { value: root.query('GET_ALLOW_MULTIPLE') } });\n        toggleDirectoryFilter({\n            root: root,\n            action: { value: root.query('GET_ALLOW_DIRECTORIES_ONLY') },\n        });\n        toggleDisabled({ root: root });\n        toggleRequired({ root: root, action: { value: root.query('GET_REQUIRED') } });\n        setCaptureMethod({ root: root, action: { value: root.query('GET_CAPTURE_METHOD') } });\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 setInputFiles = function setInputFiles(element, files) {\n        try {\n            // Create a DataTransfer instance and add a newly created file\n            var dataTransfer = new DataTransfer();\n            files.forEach(function(file) {\n                if (file instanceof File) {\n                    dataTransfer.items.add(file);\n                } else {\n                    dataTransfer.items.add(\n                        new File([file], file.name, {\n                            type: file.type,\n                        })\n                    );\n                }\n            });\n\n            // Assign the DataTransfer files list to the file input\n            element.files = dataTransfer.files;\n        } catch (err) {\n            return false;\n        }\n        return true;\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 fileItem = root.query('GET_ITEM', action.id);\n        var isLocalFile = fileItem.origin === FileOrigin.LOCAL;\n        var shouldUseFileInput = !isLocalFile && root.query('SHOULD_UPDATE_FILE_INPUT');\n        var dataContainer = createElement$1('input');\n        dataContainer.type = shouldUseFileInput ? 'file' : '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) return;\n\n        // store server ref in hidden input\n        if (action.serverFileReference !== null) field.value = action.serverFileReference;\n\n        // store file item in file input\n        if (!root.query('SHOULD_UPDATE_FILE_INPUT')) return;\n\n        var fileItem = root.query('GET_ITEM', action.id);\n        setInputFiles(field, [fileItem.file]);\n    };\n\n    var didPrepareOutput = function didPrepareOutput(_ref5) {\n        var root = _ref5.root,\n            action = _ref5.action;\n        // this timeout pushes the handler after 'load'\n        if (!root.query('SHOULD_UPDATE_FILE_INPUT')) return;\n        setTimeout(function() {\n            var field = getField(root, action.id);\n            if (!field) return;\n            setInputFiles(field, [action.file]);\n        }, 0);\n    };\n\n    var didSetDisabled = function didSetDisabled(_ref6) {\n        var root = _ref6.root;\n        root.element.disabled = root.query('GET_DISABLED');\n    };\n\n    var didRemoveItem = function didRemoveItem(_ref7) {\n        var root = _ref7.root,\n            action = _ref7.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    // only runs for server files. will refuse to update the value if the field\n    // is a file field\n    var didDefineValue = function didDefineValue(_ref8) {\n        var root = _ref8.root,\n            action = _ref8.action;\n        var field = getField(root, action.id);\n        if (!field) return;\n        if (action.value === null) {\n            // clear field value\n            field.removeAttribute('value');\n        } else {\n            // set field value\n            if (field.type != 'file') {\n                field.value = action.value;\n            }\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_PREPARE_OUTPUT: didPrepareOutput,\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 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n        extension = extension.toLowerCase();\n        if (images.includes(extension)) {\n            return (\n                'image/' +\n                (extension === 'jpg' ? 'jpeg' : extension === 'svg' ? 'svg+xml' : 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(dataTransfer) {\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 ? Array.from(dataTransfer.items) : [])\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(dataTransfer) {\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(dataTransfer) {\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(root, filenames.join(', '), root.query('GET_LABEL_FILE_ADDED'));\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 = 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 = 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        // 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(root.createChildView(panel, { name: 'panel-root' }));\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(root.createChildView(data, Object.assign({}, props)));\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.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)').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        // 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.substring(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 ? root.query('GET_MAX_FILES') || MAX_FILES_LIMIT : 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 = 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) - 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 (visualHeight > bounds.cappedHeight && listHeight.visual > _listAvailableHeight2) {\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 = 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 = '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(itemList, children, scrollList.dragCoordinates);\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 = getItemsPerRow(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(root) {\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            root.dispatch('DID_THROW_MAX_FILES', {\n                source: items,\n                error: createResponse('warning', 0, 'Max files'),\n            });\n\n            return true;\n        }\n\n        // limit max items to one if not allowed to drop multiple items\n        maxItems = allowMultiple ? maxItems : 1;\n\n        if (!allowMultiple && allowReplace) {\n            // There is only one item, so there is room to replace or add an item\n            return false;\n        }\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 + list.rect.element.marginTop + 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(function(\n                    queue\n                ) {\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                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(function(\n                    queue\n                ) {\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        } 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 = 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 (!isResizingHorizontally && currentWindowWidth !== initialWindowWidth) {\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: [createEvent('error'), createEvent('removefile')],\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: [createEvent('error'), createEvent('processfile')],\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 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n            return new Promise(function(resolve, reject) {\n                addFiles([{ source: source, options: options }], { index: options.index })\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('REMOVE_ITEM', Object.assign({}, options, { query: query }));\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 (typeof lastArgument === 'object' && !(lastArgument instanceof Blob)) {\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                        !(item.status === ItemStatus.IDLE && item.origin === FileOrigin.LOCAL) &&\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) ? (files[query] ? files[query].id : null) : 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 = 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(attributeName) {\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][lowerCaseFirstLetter(property.replace(selectorRegExp, ''))] = 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 = 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' ? element.querySelector('input[type=file]') : 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(function(input) {\n                return {\n                    source: input.value,\n                    options: {\n                        type: input.dataset.type,\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 Object.prototype.toString.call(window.operamini) === '[object OperaMini]';\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"],"sourceRoot":""}