wonder-image 1.2.0

package/dist/lib/filepond/filepond.js.LICENSE.txt

@@ -0,0 +1,2797 @@
+/* eslint-disable */
+
+/* harmony import */
+
+/* webpack/runtime/compat get default export */
+
+/*!
+ * FilePond 4.31.1
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/*!
+ * FilePondPluginFileMetadata 1.0.8
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/*!
+ * FilePondPluginFileValidateSize 2.2.8
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/*!
+ * FilePondPluginFileValidateType 1.2.9
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/*!
+ * FilePondPluginGetFile 1.1.0
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit undefined for details.
+ */
+
+/*!
+ * FilePondPluginImageCrop 2.0.6
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/*!
+ * FilePondPluginImageEdit 1.6.3
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/*!
+ * FilePondPluginImageExifOrientation 1.0.11
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/*!
+ * FilePondPluginImagePreview 4.6.12
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/*!
+ * FilePondPluginImageResize 2.0.10
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/*!
+ * FilePondPluginImageTransform 3.8.7
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/*!
+ * FilePondPluginImageValidateSize 1.2.7
+ * Licensed under MIT, https://opensource.org/licenses/MIT/
+ * Please visit https://pqina.nl/filepond/ for details.
+ */
+
+/*#__PURE__*/
+
+/**
+                 * Appends the plugin to the target element
+                 */
+
+/**
+                 * Browse the file system for a file
+                 */
+
+/**
+                 * Clears all files from the files list
+                 */
+
+/**
+                 * Destroys the app
+                 */
+
+/**
+                 * Inserts the plugin after the target element
+                 */
+
+/**
+                 * Inserts the plugin before the target element
+                 */
+
+/**
+                 * Load the given file
+                 * @param source - the source of the file (either a File, base64 data uri or url)
+                 * @param options - object, { index: 0 }
+                 */
+
+/**
+                 * Load the given files
+                 * @param sources - the sources of the files to load
+                 * @param options - object, { index: 0 }
+                 */
+
+/**
+                 * Moves a file to a new location in the files list
+                 */
+
+/**
+                 * Override options defined in options object
+                 * @param options
+                 */
+
+/**
+                 * Removes a file by its name
+                 * @param query { string, number, null  }
+                 */
+
+/**
+                 * Replaces an element with the app
+                 */
+
+/**
+                 * Request prepare output for file with given name
+                 * @param query { string, number, null  }
+                 */
+
+/**
+                 * Restores the original element
+                 */
+
+/**
+                 * Returns all files (wrapped in public api)
+                 */
+
+/**
+                 * Returns the current pond status
+                 */
+
+/**
+                 * Returns the file objects matching the given query
+                 * @param query { string, number, null }
+                 */
+
+/**
+                 * Returns the root element
+                 */
+
+/**
+                 * Returns true if the app root is attached to given element
+                 * @param element
+                 */
+
+/**
+                 * Sort list of files
+                 */
+
+/**
+                 * Starts preparing output of all files
+                 */
+
+/**
+                 * Starts uploading all files
+                 */
+
+/**
+                 * Upload file with given name
+                 * @param query { string, number, null  }
+                 */
+
+/**
+             * @param source
+             * @param index
+             * @param interactionMethod
+             */
+
+/**
+             * Aborts all ongoing processes
+             */
+
+/**
+             * Reads from dom (never call manually)
+             * @private
+             */
+
+/**
+             * Sets initial files
+             */
+
+/**
+             * Writes to dom (never call manually)
+             * @private
+             */
+
+/**
+         * Filters
+         */
+
+/**
+       * Image Preview related
+       */
+
+/**
+     * Polyfill Edge and IE when in Browser
+     */
+
+/**
+   * Generates the download icon
+   */
+
+/**
+   * Image Auto Crop Plugin
+   */
+
+/**
+   * Image Edit Proxy Plugin
+   */
+
+/**
+   * Read Image Orientation Plugin
+   */
+
+/**
+   * Register the download component by inserting the download icon
+   */
+
+/************************************************************************/
+
+/******/
+
+/***/
+
+//
+
+// 'always'
+
+// 'mismatch' (future feature, only applied if quality differs from input)
+
+// 'optional'
+
+// (message, cb) => {}
+
+// - "camera", "microphone" or "camcorder",
+
+// - Does not work with multiple on apple devices
+
+// - If set, acceptedFileTypes must be made to match with media wildcard "image/*", "audio/*" or "video/*"
+
+// - add metadata
+
+// - contain => pick smaller dimension
+
+// - cover => pick biggest dimension
+
+// - extensions: .png, .jpg, .jpeg ( not enabled yet )
+
+// - force => force set size
+
+// - mime types: image/png, image/jpeg, image/gif
+
+// - must be comma separated
+
+// - read data (quickly)
+
+// - wildcards: image/*
+
+// -1, don't move items to accomodate (either add to top or bottom)
+
+// 0. perspective
+
+// 1. translate
+
+// 2. scale
+
+// 3. rotate
+
+// A metadata object to add to all files
+
+// Add className
+
+// Add id
+
+// Added for browsers that do not return the thousands separator (happend on native browser Android 4.4.4)
+
+// All items processed? No errors?
+
+// Allow browsing the file system
+
+// Allow dropping a file on other file to replace it (only works when multiple is set to false)
+
+// Allow dropping of files
+
+// Allow dropping of files anywhere on page (prevents browser from opening file if dropped outside of Up)
+
+// Allow media capture when value is set
+
+// Allow multiple files (disabled by default, as multiple attribute is also required on input to allow multiple)
+
+// Allow only selecting directories with browse (no support for filtering dnd at this point)
+
+// Allow pasting files
+
+// Allow reordering of files
+
+// Allow user to remove a file
+
+// Allows filtering of markup to only show certain shapes
+
+// Allows user to process a file, when set to false, this removes the file upload button
+
+// Allows user to revert file upload
+
+// Amount of times to retry upload of a chunk when it fails
+
+// Assign the DataTransfer files list to the file input
+
+// Assistant notifies assistive tech when content changes
+
+// Background panel
+
+// Can't run on Opera Mini due to lack of everything
+
+// Check if module is in cache
+
+// Chunks
+
+// Create a DataTransfer instance and add a newly created file
+
+// Create a new module (and put it into the cache)
+
+// Custom function to detect type of file
+
+// Custom function to use as image measure
+
+// DOCTYPE needs to be set for this to work
+
+// Data
+
+// Deal as if is external URL, let's load it!
+
+// Default index in list to add items that have been dropped at the top of the list
+
+// Default is locale separator
+
+// Done!
+
+// Drag 'n Drop related
+
+// Drop needs to happen on element (set to false to also load drops outside of Up)
+
+// Enable chunked uploads
+
+// Enable or disable file renaming
+
+// Enable or disable file type validation
+
+// Enable or disable image orientation reading
+
+// Enable or disable image preview
+
+// Enable or disable image resizing
+
+// Enable or disable validating files on drop
+
+// Enables custom validity messages
+
+// Enables or disables reading average image color
+
+// Enables or disables the previewing of markup
+
+// Error thrown when image can not be loaded
+
+// Every JPEG file starts from binary value '0xFFD8'
+
+// Execute the module function
+
+// Expose plugin options
+
+// Feature toggles
+
+// Field label
+
+// File size calculations, can set to 1024, this is only used for display, properties use file size base 1000
+
+// FilePond
+
+// Filter the files that need to be validated for size
+
+// Firefox versions before 58 will freeze when running createImageBitmap
+
+// First 2bytes defines byte align of TIFF data.
+
+// Fixed preview height
+
+// Force use of chunk uploads even for files smaller than chunk size
+
+// Get TIFF Header
+
+// Has to be a browser
+
+// If is not async should prepare now
+
+// If it is 0x4949="I I", it means "Intel" type byte align
+
+// If it's not present, exit here
+
+// Input requirements
+
+// Invalid
+
+// Label to show when an image is too small or image is too big
+
+// Labels and status messages
+
+// List of items
+
+// Load Files
+
+// Load base 64, set default name to current date
+
+// Load blobs, set default name to current date
+
+// Max image height
+
+// Max individual file size in bytes
+
+// Max number of files
+
+// Max size of preview file for when createImageBitmap is not supported
+
+// Max size of preview file that we allow to try to instant preview if createImageBitmap is not supported, else image is queued for loading
+
+// Max total file size in bytes
+
+// Maximum files to upload in parallel
+
+// Measure (tests if fixed height was set)
+
+// Min image height
+
+// Min individual file size in bytes
+
+// Missing 0x45786966 Marker? No Exif Header, stop here
+
+// Nothing found
+
+// PRIVATE API -------------------------------------------------------------------------------------
+
+// Require these APIs to feature detect a modern browser
+
+// Required amount of pixels in the image
+
+// Required dimensions
+
+// Return the exports of the module
+
+// Revert mode
+
+// Set to 'force' to require the file to be reverted before removal
+
+// Set to false to always add items to begin or end of list
+
+// Should upload files immediately on drop
+
+// Should we upscale small images to fit the max bounding box of the preview area
+
+// Size of chunks (5MB default)
+
+// Start at 2 as we skipped two bytes (FFD8)
+
+// Style of the transparancy indicator used behind images
+
+// TODO: Fix, should not be needed to kick the internal loop in case no processes are running
+
+// TODO: if we can, throw error to indicate the items cannot by dropped
+
+// TODO: see if we can optimize this by measuring root rect
+
+// TODO: test for directories (should not be allowed)
+
+// The amount of extra pixels added to the image preview to allow comfortable zooming
+
+// The module cache
+
+// The require function
+
+// The server api end points to use for uploading (see docs)
+
+// There's our APP1 Marker
+
+// This aint no JPEG
+
+// This entry need to be wrapped in an IIFE because it need to be in strict mode.
+
+// Try store file if `server` not set
+
+// Turn into an array of objects so no matter what the input, we can handle it the same way
+
+// Upload related
+
+// Use FileReader, problem is that the files property gets lost in the process
+
+// We check against the normal toString output and if they're the same return a comma when decimal separator is a dot
+
+// What file types to accept
+
+// Where to put file
+
+// [ https://github.com/nielsboogaard/filepond-plugin-get-file ]
+
+// [ https://pqina.nl/filepond/docs/api/plugins/file-metadata/ ]
+
+// [ https://pqina.nl/filepond/docs/api/plugins/file-validate-size/ ]
+
+// [ https://pqina.nl/filepond/docs/api/plugins/file-validate-type/ ]
+
+// [ https://pqina.nl/filepond/docs/api/plugins/image-crop/ ]
+
+// [ https://pqina.nl/filepond/docs/api/plugins/image-edit/ ]
+
+// [ https://pqina.nl/filepond/docs/api/plugins/image-exif-orientation/ ]
+
+// [ https://pqina.nl/filepond/docs/api/plugins/image-preview/ ]
+
+// [ https://pqina.nl/filepond/docs/api/plugins/image-resize/ ]
+
+// [ https://pqina.nl/filepond/docs/api/plugins/image-transform/ ]
+
+// [ https://pqina.nl/filepond/docs/api/plugins/image-validate-size/ ]
+
+// [-1, 0, 0, 1, width, 0]
+
+// [1, 0, 0, -1, 0, height]
+
+// _not_ getting the style value is faster
+
+// a completed upload will have a serverFileReference, a failed chunked upload where
+
+// a file is in error state
+
+// a new action happened, let's get the matching styles
+
+// abort
+
+// abort active process request
+
+// abort actual request
+
+// abort does not expect a value
+
+// abort file load
+
+// accepted is wildcard mime type
+
+// access to custom children references
+
+// access to data store
+
+// action handlers
+
+// actions in next write operation
+
+// active app instances, used to redraw the apps and to find the later
+
+// active processes
+
+// actual load is done let's share results
+
+// actual processing progress
+
+// add
+
+// add additional option translators
+
+// add already selected files
+
+// add as client
+
+// add class
+
+// add credits
+
+// add default output version if output default set to true or if no variants defined
+
+// add edit button to preview
+
+// add filters
+
+// add getters and setters
+
+// add headers
+
+// add height
+
+// add index no longer needed till possibly next draw
+
+// add initial listener
+
+// add it to the list for easy updating from the _write method
+
+// add item to array
+
+// add item to list
+
+// add items!
+
+// add metadata under same name
+
+// add mixin functionality
+
+// add name attribute
+
+// add new files
+
+// add one pixel leeway, when using percentages for item width total items can be 1.99 per row
+
+// add opacity
+
+// add original file
+
+// add plugin options to default options
+
+// add position attribute
+
+// add progress indicators
+
+// add resize transforms if set
+
+// add rest to sources
+
+// add transforms
+
+// add width
+
+// add!
+
+// adds a plugin extension
+
+// adjust for parent offset
+
+// adjust index if is not allowed to pick location
+
+// align next frame
+
+// all chunks
+
+// all done?
+
+// all is well
+
+// all items should be validated by all filters as valid
+
+// allow all other actions
+
+// allow editing
+
+// allow parsing of formdata
+
+// allow plugins to alter the file data
+
+// allow quick validation of dropped items
+
+// allow transfer of these items
+
+// already at target
+
+// already contained?
+
+// already has crop metadata set?
+
+// already queued for processing
+
+// already registered
+
+// also 0 is not a valid width or height
+
+// always remove the required attribute when more than zero items
+
+// always use jpg extension
+
+// an error was thrown while loading the file, we need to switch to error state
+
+// an input file never has a server file reference
+
+// and we've not yet called the complete method
+
+// animate view out of view
+
+// append additional margin (top and left margins are included in top and left automatically)
+
+// append created child views to root node
+
+// append crop data
+
+// append image presenter
+
+// append new elements to DOM and update those
+
+// append other props
+
+// append size data
+
+// append to DOM
+
+// applies all image transforms to the image data array
+
+// apply active styles to element
+
+// apply filtered colors
+
+// apply initial style properties
+
+// apply style properties
+
+// apply styles
+
+// apply view props
+
+// archive the item, this does not remove it from the list
+
+// as image load could take a while and fire when draw loop is resting we need to give it a kick
+
+// as revert will remove file from list
+
+// as we're now processing, fire the progress event
+
+// as we've now loaded the file the loader is no longer required
+
+// assign new value
+
+// assistive only
+
+// attach events
+
+// available height for list
+
+// available space on horizontal axis
+
+// background image of the output canvas
+
+// bool to indicate if we're full or not
+
+// build action object
+
+// build plugin
+
+// busy processing or loading
+
+// by default not marked for removal
+
+// by default we can drop
+
+// calculate available space round image center position
+
+// calculate average image color, disabled for now
+
+// calculate height based on width
+
+// calculate inner width and height
+
+// calculate new heights and widths
+
+// calculate outer width and height
+
+// calculate progress values
+
+// calculate scalar required to fit image
+
+// calculate scaled preview image size
+
+// calculate size of ring
+
+// calculate spring force
+
+// calculate total progress fraction
+
+// call
+
+// call did create
+
+// call initial filter, will return a promise
+
+// call read (need to know the size of these elements)
+
+// callbacks (load, error, progress, abort, transfer)
+
+// called before creating the blob, receives canvas, expects promise resolve with canvas
+
+// called for each file that is loaded
+
+// called for each view that is created right after the 'create' method
+
+// called when file has loaded succesfully
+
+// called when the file is about to be processed so it can be piped through the transform filters
+
+// called when the file is loaded so it can be piped through the filters
+
+// can always assign default value
+
+// can now safely remove from view
+
+// can update progress indicator
+
+// can't add twice
+
+// can't compute progress
+
+// can't draw on half pixels
+
+// can't upscale image, so if already at correct scale, exit
+
+// cancel updater
+
+// cannot revert without a server id for this process
+
+// canvas memory limit
+
+// chain filters
+
+// check if file should be filtered
+
+// checkmark
+
+// classname to put on wrapper
+
+// clean up
+
+// clean up event
+
+// clear
+
+// clear actions queue (we don't want no double actions)
+
+// clear field value
+
+// clear group after set amount of time so the status is not read twice
+
+// clear history if aspect ratio has changed
+
+// click link (will then in turn activate file input)
+
+// collected some meta data already
+
+// compare old value against new value, if they're the same, we're not updating
+
+// const children = view.childViews;
+
+// construct private api
+
+// continue processing
+
+// continue with the unaltered dataset
+
+// copy Buttons object
+
+// copy relative path
+
+// copy relevant props
+
+// correct image orientation
+
+// correctly removed
+
+// covering target size
+
+// create
+
+// create a dnd client
+
+// create a new blank item
+
+// create a temporary hyperlink to force the browser to download the file
+
+// create actual api object
+
+// create button
+
+// create copy of actions queue
+
+// create default event
+
+// create element with svg and get size
+
+// create event object to be dispatched
+
+// create fallback preview
+
+// create file info view
+
+// create file status view
+
+// create final options object by setting options object and then overriding options supplied on element
+
+// create method, creates apps and adds them to the app array
+
+// create new instance for each hook
+
+// create new observer, does not yet exist for this element
+
+// create new svg file
+
+// create overlay view
+
+// create perceived performance progress indicator
+
+// create regexp shortcut
+
+// create request
+
+// create response
+
+// create the button views
+
+// create the first image
+
+// create the get file plugin
+
+// create the image edit plugin, but only do so if the item is an image
+
+// create the image preview plugin, but only do so if the item is an image
+
+// create the label and link it to the file browser
+
+// create the view
+
+// created the item, let plugins add methods
+
+// crop data to pass to editor
+
+// current active styles
+
+// current drag position
+
+// current item status
+
+// custom handler (should also handle file, load, error, progress and abort)
+
+// custom initial files array
+
+// custom type detector method
+
+// data has been transferred to canvas ( if was ImageBitmap )
+
+// data has moved to data.js
+
+// default is single definition
+
+// default options
+
+// default start height
+
+// default values
+
+// default view definition
+
+// define __esModule on exports
+
+// define getter functions for harmony exports
+
+// define new active styles
+
+// delete root.element.dataset.disabled; <= this does not work on iOS 10
+
+// destroy client
+
+// destroy measure element
+
+// destroy view
+
+// destroy worker
+
+// destroys apps and removes them from the app array
+
+// determine clip width and height
+
+// determine if file type will change
+
+// determine if width changed
+
+// determine image size of this item
+
+// determine the format of the blob that we will output
+
+// determines if a file may be dropped
+
+// different amount of keys
+
+// directories are returned in batches, we need to process all batches before we're done
+
+// disable the field
+
+// dispatch destroy
+
+// dispatch set event for each option
+
+// do local or remote request based on if the url is external
+
+// do mapping of object properties
+
+// do submapping
+
+// doesn't need CSSSupports but is a good way to detect Safari 9+ (we do want to support IE11 though)
+
+// dom modifiers
+
+// don't do anything
+
+// don't do anything while hidden
+
+// don't handle archived items, an item could have been archived (load aborted) while being prepared
+
+// don't handle archived items, an item could have been archived (load aborted) while waiting to be prepared
+
+// don't include in object
+
+// don't re-render if optimizing or hidden (width will be zero resulting in weird animations)
+
+// don't set error state when reverting is optional, it will always resolve
+
+// don't update clip layout
+
+// don't want to click twice
+
+// done
+
+// done (filter out empty files)!
+
+// done loading
+
+// done!
+
+// dont adjust height
+
+// dragging
+
+// draw image
+
+// draw new
+
+// draw the image
+
+// draw the image but first fix orientation and set correct flip
+
+// draw the scaled down version here and use that as source so bitmapdata can be closed
+
+// draw to canvas and start transform chain
+
+// each view requires reference to store
+
+// edit item classname
+
+// editor object
+
+// enable or disable image cropping
+
+// enable or disable image editing
+
+// encode url
+
+// error during load
+
+// error is expected to be an object with type, code, body
+
+// error labels
+
+// error response if item archived
+
+// eslint-disable-next-line no-restricted-globals
+
+// event behaviour
+
+// event handlers
+
+// event info
+
+// event object to params used for `on()` event handlers and callbacks `oninit()`
+
+// exit
+
+// exit if image size is too high and no createImageBitmap support
+
+// exit if this is not an image
+
+// expand rect to fit all child rectangles
+
+// expects promise resolved with blob
+
+// expose
+
+// expose api
+
+// expose internal write api
+
+// expose plugin
+
+// expose public api
+
+// extend item methods
+
+// extract files and move value of webkitRelativePath path to _relativePath
+
+// fallback
+
+// file appended
+
+// file is always section
+
+// file is fine, let's pass it back
+
+// file load progress
+
+// file mock data, if defined
+
+// file model reference
+
+// file panel
+
+// file received
+
+// file states
+
+// file stub is already there
+
+// file to open
+
+// file view
+
+// filename
+
+// files uploading at the exact same speed
+
+// filesize
+
+// filter images to transform
+
+// filter out invalid file items, used to filter dropped directory contents
+
+// filtering if an item is allowed in hopper
+
+// filters file items to determine which are shown as preview
+
+// find Orientation tag
+
+// find matching filters for this key
+
+// find resize
+
+// finish up
+
+// fire enter event
+
+// fire event
+
+// fire loaded event so we know when FilePond is available
+
+// fire pluginloaded event if running in browser, this allows registering the plugin when using async script tags
+
+// fire the abort event so we can switch visuals
+
+// fire update
+
+// first filter to kick things of
+
+// fix height of panel
+
+// fix height of panel so it adheres to aspect ratio
+
+// fixed aspect ratio
+
+// fixed height
+
+// flatten groups
+
+// flexible height
+
+// flip horizontal
+
+// flip vertical
+
+// for IE10
+
+// for async scenarios
+
+// for example: if distance is 10 ms and interval is 16 ms,
+
+// for modern browsers
+
+// for now, update existing image when filtering
+
+// force progress to 1 as we're now done
+
+// force release of canvas memory
+
+// found the orientation tag
+
+// full path to remote server is stored in metadata with key 'url'
+
+// get a quick reference to the item id
+
+// get all actions from store
+
+// get all keys passed
+
+// get arc path
+
+// get base transformation matrix
+
+// get box bounds, we do this only once
+
+// get child rects
+
+// get crop
+
+// get data from canvas
+
+// get default object and add as metadata
+
+// get drag area dimensions
+
+// get element at position
+
+// get exif orientation
+
+// get file reference
+
+// get file url
+
+// get filename
+
+// get filename parts
+
+// get filter
+
+// get headers
+
+// get height min and max
+
+// get id reference
+
+// get image data reference
+
+// get image transform variants
+
+// get interaction type
+
+// get item
+
+// get item children elements and sort based on list sort
+
+// get item reference
+
+// get last added image
+
+// get new index
+
+// get new index of dragged item
+
+// get next chunk to process
+
+// get optional custom measure function
+
+// get orientation from exif data
+
+// get other variants
+
+// get quick reference
+
+// get quick reference to Type utils
+
+// get quick references to various high level parts of the upload tool
+
+// get reference to control
+
+// get reference to created view
+
+// get required dimensions
+
+// get root
+
+// get separate options for easier use
+
+// get subtype
+
+// get svg text
+
+// get the file object
+
+// get the required aspect ratio and exit if it's not set
+
+// get the transfer items as promises
+
+// get the type of the new value
+
+// get title
+
+// get url to file (we'll revoke it later on when done)
+
+// get variants
+
+// get width and height from action, and swap of orientation is incorrect
+
+// get width of stroke
+
+// getDefaultExport function for compatibility with non-harmony modules
+
+// gets the item type
+
+// getting a serverId succeeded but >=0 chunks have been uploaded will have transferId set
+
+// go
+
+// go!
+
+// grid
+
+// grid pattern
+
+// group under single property
+
+// had no previous state, means we are entering this client
+
+// handle changes to the input field
+
+// handle interactions
+
+// handle item
+
+// handle keys
+
+// handle next item!
+
+// handle transform origin
+
+// has returned new filename immidiately
+
+// has timeout so doesn't interfere with remove action
+
+// hide for screenreaders
+
+// hide label
+
+// 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.
+
+// hide while contains 0 value
+
+// history of updates
+
+// hooks
+
+// how attributes of the input element are mapped to the options for the plugin
+
+// https://github.com/pqina/filepond-plugin-image-preview/issues/57
+
+// id of file on server
+
+// id of file transfer on server
+
+// id of first item we're about to remove
+
+// id we are allowed to upload the file immediately, lets do it
+
+// if action has an id, filter out actions that don't have this child id
+
+// if allows multiple items, we check if a max item count has been set, if not, there's no limit
+
+// if already at target, we done!
+
+// if already done processing or tried to revert but didn't work, try again
+
+// if aspect ratio has changed, we need to create a new image
+
+// if blob has name property, use as filename if no filename supplied
+
+// if cannot have multiple items, to add one item it should currently not contain items
+
+// if chunked uploads are enabled and we're uploading in chunks for this specific file
+
+// if client want to download file from remote server
+
+// if currently has no position, set target and position to this value
+
+// if currently overflowing but no longer received overflow
+
+// if currently uploading, cancel upload
+
+// if does not allow multiple items and dragging more than one item
+
+// if fake progress is done, and a response has been received,
+
+// if file is already in list
+
+// if file was uploaded but processing was cancelled during perceived processor time store file reference
+
+// if filename supplied but no extension and filename has extension
+
+// if has been processed remove it from the server as well
+
+// if has filter and has resize, move filter to resize operation
+
+// if has received blob, we go with blob, if no response, we return null
+
+// if has received source, we done
+
+// if has response object, we've completed the request
+
+// if image is too small, exit here with original image
+
+// if index is undefined, append
+
+// if is a temp server file we prevent async upload call here (as the file is already on the server)
+
+// if is base64 data uri we need to determine the average size and type
+
+// if is bool withCredentials
+
+// if is called multiple times in close succession we combined all calls together to save resources
+
+// if is cross origin image add cross origin attribute
+
+// if is custom function, done! Dev handles everything.
+
+// if is empty, see if we can extract some info from the files property as a fallback
+
+// if is fixed height or panel has aspect ratio, exit here, height has already been defined
+
+// if is frozen, no longer fires events
+
+// if is hidden we need to know so we exit rest mode when revealed
+
+// if is local item we need to enable upload button so change can be propagated to server
+
+// if is not overflowing currently but does receive overflow value
+
+// if is pasting in input or textarea and the target is outside of a filepond scope, ignore
+
+// if is possible error event, make it the first param
+
+// if is requesting revert and can revert need to call revert handler (not calling request_ because that would also trigger beforeRemoveHook)
+
+// if is rotated incorrectly swap width and height
+
+// if is temp or local file
+
+// if is valid subtype
+
+// if is value in kilobytes
+
+// if is value in megabytes
+
+// if item not is in new value, remove
+
+// if item was archived while in queue, jump to next
+
+// if method is GET, add any received data to url
+
+// if multiple allowed, we can't replace
+
+// if new styles does not match current styles, lets update!
+
+// if no actions, we assume that the view is resting
+
+// if no extension supplied, exit here
+
+// if no file loaded we'll wait for the load event
+
+// if no more clients, clean up observer
+
+// if no source supplied
+
+// if no view found, exit
+
+// if no width or height, just return early.
+
+// if not allowed to reorder file items, exit here
+
+// if not allowed, all fine, exit
+
+// if not in list, remove from object, the instruction will be handled by the server
+
+// if not supported, no API
+
+// if not, we can update the current image
+
+// if one of edges is smaller than target size, exit
+
+// if only passed options
+
+// if origin is local, and we're instant uploading, trigger remove of original
+
+// if parent is a fieldset, get files from parent by selecting all input fields that are not file upload fields
+
+// if perceived progress is 1 ( wait for perceived progress to complete )
+
+// if query is item, get the id
+
+// if reached max capacity and we've just reached it
+
+// if resting, no need to read as numbers will still all be correct
+
+// if root is not actual shadow DOM and does not have elementFromPoint method, use the one on document
+
+// if single file object in array, return the single file object else, return array of
+
+// if size can't be read this browser doesn't support image
+
+// if size is available don't fallback to unknown size message
+
+// if state.progress is null, the server does not allow computing progress and we show the spinner instead
+
+// if the file cannot be edited it should be removed on revert
+
+// if the file is not an image we do not have any business transforming it
+
+// if the index of the item changed, dispatch reorder action
+
+// if the item is a url we guess the mime type by the extension
+
+// if there's a mapping, the original property is always removed
+
+// if this action has a handler, handle the action
+
+// if this file is editable it shouldn't be removed immidiately even when instant uploading
+
+// if this is a local file and the `server.remove` function has been configured,
+
+// if this is a local server file we need to show a different state
+
+// if this is a progress event add the progress amount
+
+// if this is an svg and we want it to stay an svg
+
+// if this is not a jpeg image we are not interested
+
+// if this is not an image we do not have any business cropping it
+
+// if this is not an image we do not have any business cropping it and we'll continue with the unaltered dataset
+
+// if true uploads take at least 750 ms, this ensures the user sees the upload progress giving trust the upload actually happened
+
+// if was archived in the mean time, don't process
+
+// if was idling and no actions stop here
+
+// if was not queued or is already processing exit here
+
+// if was passed a file, and we can chunk it, exit here
+
+// if we already have a server file reference, we don't need to call the onload method
+
+// if we are not doing file type validation exit
+
+// if we can't compute progress, we're not going to fire progress events
+
+// if we reach zero, we make the element inaccessible
+
+// if we should re-upload the file immediately
+
+// if we support scaling using createImageBitmap we use a worker
+
+// if we're below 100% opacity this element can't be clicked
+
+// if we're filtering on element we need to be over the element to drop
+
+// if we're full we need to leave some room between the top of the panel and the list
+
+// if we're instant uploading the file will also be removed if we revert,
+
+// if we're not modifying the image data then we don't have to modify the output
+
+// image aspect ratio
+
+// image bin
+
+// image is already perfect size, no transformations required
+
+// image overlays
+
+// image preview stated
+
+// image view
+
+// image/* -> image
+
+// in a Web Worker so we detect those versions and return false for support
+
+// in rest, don't animate
+
+// information on the root height or fixed height status
+
+// initial properties
+
+// initial props
+
+// initial state (should be serializable)
+
+// input field name to use
+
+// input, if is remote, see if should use custom fetch, else use default fetchBlob
+
+// insert the app before the element
+
+// internal handler
+
+// internal implementation
+
+// invalid queries
+
+// is a single url
+
+// is aborted
+
+// is archived
+
+// is blob or base64, then we need to set the name
+
+// is blocking action (should never block if document is hidden)
+
+// is classified as valid response
+
+// is client error, no way to recover
+
+// is custom implementation
+
+// is explicitely set to null so disable
+
+// is in bytes
+
+// is in try catch as IE11 will throw error if not
+
+// is initial value
+
+// is natural file size
+
+// is normal mime type
+
+// is now hopper scope
+
+// is possible server error, so might be possible to retry
+
+// is promise
+
+// is remote url and no fetch method supplied
+
+// is string input, let's attempt to convert
+
+// is svg subtype
+
+// is the field required
+
+// is valid type?
+
+// it outside of this method
+
+// item could theoretically have been removed in the mean time
+
+// item has been successfully loaded and added to the
+
+// item loaded, allow plugins to
+
+// just bytes
+
+// just return first index
+
+// key does not exist, so this option cannot be set
+
+// kick thread if visibility changes
+
+// kilobytes
+
+// label to show when a type is not allowed
+
+// let element
+
+// let interface know the item has loaded
+
+// let others know we have area ready
+
+// let parent know if we are resting
+
+// let plugins decide if the output data should be prepared at this point
+
+// let start moving to target
+
+// let view know the item has been inserted
+
+// let's get the item width
+
+// let's go!
+
+// let's process the file
+
+// let's replace the item
+
+// let's scale the image in a worker
+
+// let's scale the image in the main thread :(
+
+// let's send our data
+
+// let's start processing
+
+// lets analyze the individual props
+
+// limbo or local
+
+// limit fps
+
+// limit max items to one if not allowed to drop multiple items
+
+// limit the index to the size of the items array
+
+// link list to label bottom position
+
+// list of items so can now be safely returned for use
+
+// load blob contents and wrap in crop svg
+
+// load expects the body to be a server id if
+
+// load file
+
+// load files
+
+// load successful
+
+// load the source data
+
+// location of processing button
+
+// look in meta data property
+
+// loop over all styles for this control
+
+// loop over items and depending on states call abort for ongoing processes
+
+// loop over promises passing value to next promise
+
+// main status
+
+// make sure all bounds are set
+
+// make sure is default scale every frame
+
+// make sure width and height plus viewpox are even numbers so icons are nicely centered
+
+// map all items in a possible items array
+
+// map mime types to extensions
+
+// map values to file objects
+
+// maps transform types to transform functions
+
+// margins will be added after we've recalculated the size
+
+// mark chunks with lower offset as complete
+
+// mark for removal
+
+// markup
+
+// max-height
+
+// maximum size of JPEG, fine for now I guess
+
+// means we'll do this and wait for idle state
+
+// megabytes
+
+// merge with options object
+
+// might have just left this client?
+
+// model
+
+// move credits to bottom
+
+// move remove button to right
+
+// move styles to the back of the mixin list (so adjustments of other mixins are applied to the props correctly)
+
+// move to back of execution queue, FilePond should have been exported by then
+
+// move to draw offset
+
+// move to group
+
+// move value to new property
+
+// moves element to correct position on screen
+
+// necessary for update loop
+
+// need at least a target or position to do springy things
+
+// need at least a width or a height
+
+// need this id to be able to rever the upload
+
+// need this id to be able to revert the upload
+
+// need to know the current child count so appending happens in correct order
+
+// need to set role to list as otherwise it won't be read as a list by VoiceOver
+
+// needs to allow transfer
+
+// needs to be at least one pixel
+
+// needs to be trigger directly as user action needs to be traceable (is not traceable in requestAnimationFrame)
+
+// new retry
+
+// next byte!
+
+// next target value will not be animated to
+
+// nicer label
+
+// no EXIF info defined
+
+// no action supplied
+
+// no action supplied, return stub function, interface will work, but file won't be removed
+
+// no bitmap returned, must be something wrong,
+
+// no children, done!
+
+// no chunk to handle
+
+// no custom measure method supplied, exit here
+
+// no data to add
+
+// no data!
+
+// no editor defined, then exit
+
+// no file received
+
+// no files received
+
+// no height, can't set
+
+// no images to update, exit
+
+// no item found, exit
+
+// no items left
+
+// no longer busy
+
+// no longer required
+
+// no match, skip
+
+// no module.id needed
+
+// no module.loaded needed
+
+// no more chunks to process
+
+// no more retries left
+
+// no need to handle this catch state for now
+
+// no need to read it twice
+
+// no need to set container bounds as these are handles by CSS fixed height
+
+// no need to set same state twice
+
+// no need to transform, exit
+
+// no negative byte sizes
+
+// no orientation supplied
+
+// no preview view attached
+
+// no process controls available
+
+// no progress event when aborted ( onprogress is called once after abort() )
+
+// no request running, can't abort
+
+// no resizing to be done
+
+// no server id, let's give this file the full treatment
+
+// no server response
+
+// no should not add this file
+
+// no transfer for this client
+
+// no transforms necessary, we done!
+
+// no type detector, test now
+
+// no types defined, everything is allowed \o/
+
+// no valid conversions found
+
+// no value, no need to reset
+
+// nope nope nope (probably IE trouble)
+
+// nope, failed
+
+// not a fixed height panel
+
+// not busy
+
+// not in list, add
+
+// not instant uploading, revert immediately
+
+// not interesting in these states ('unsent' and 'openend' as they don't give us any additional info)
+
+// not ready to be processed
+
+// not tweening to a smaller value
+
+// notify listeners of received files
+
+// now add action
+
+// now dispatch these actions
+
+// now idling
+
+// now in busy mode
+
+// now interested in metadata updates
+
+// now over element (no matter if it allows the drop or not)
+
+// now processing
+
+// now processing this chunk
+
+// now ready
+
+// now resting as target is current position, stop moving
+
+// now the list has been modified
+
+// null 'integrated', 'compact', 'circle'
+
+// null or '3:2' or 1
+
+// null, 'image/jpeg', 'image/png'
+
+// null, 0 - 100
+
+// observe item events
+
+// offset
+
+// offset bottom part
+
+// offset center part
+
+// oh no errors
+
+// on(type, () => { })
+
+// oninit = () => {}
+
+// only apply output quality when a transform is required
+
+// only apply transforms in this list
+
+// only filter and crop trigger redraw
+
+// only hook up to item view
+
+// only hook up to item view and only if is enabled for this cropper
+
+// only remove process button
+
+// only remove revert button
+
+// only revert and attempt to upload when we're uploading to a server
+
+// only run for either the file or the file info panel
+
+// only source is available, else add item if possible
+
+// only used when can be dropped on page
+
+// open editor when image is dropped
+
+// open editor when loading a new item
+
+// open up open up!
+
+// opens the editor, if it does not already exist, it creates the editor
+
+// options
+
+// or if only a single item is allowed but we're not allowed to replace it we exit
+
+// or if server does not support progress ( null )
+
+// or if the file isn't big enough for chunked uploads but chunkForce is set then call
+
+// orientation info
+
+// original source
+
+// output format (quality 0 => 100)
+
+// override defaults
+
+// override rect on internal and external rect getter so it takes in account transforms
+
+// overwrite
+
+// parses the given context for plugins (does not include the context element itself)
+
+// pass back to item so we can use it if something goes wrong
+
+// plugins determined the output data should be prepared (or not), can be adjusted with beforePrepareOutput hook
+
+// prevent scrolling and zooming on iOS (only if supports pointer events, for then we can enable reorder)
+
+// process file!
+
+// process queued item
+
+// process queueud items
+
+// processing is paused, wait here
+
+// processing was aborted
+
+// processing went wrong earlier
+
+// progress of load
+
+// progress update
+
+// props
+
+// quality set
+
+// queries
+
+// query is index
+
+// queue and wait till queue is freed up
+
+// queue for later processing
+
+// queue next tick
+
+// queue of items waiting to be processed
+
+// 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
+
+// quickly append input to temp form and reset form
+
+// random delay as in a list of files you start noticing
+
+// re-call write
+
+// re-inject image head in case of JPEG, as the image head is removed by canvas export
+
+// re-inject input where it originally was
+
+// re-render on window resize start and finish
+
+// read as file
+
+// read child views
+
+// read first batch of files
+
+// read view data
+
+// readers
+
+// recursively read more directories
+
+// register plugins
+
+// register the id for this transfer
+
+// register transfer id
+
+// reject or resolve based on file size
+
+// reject the file so can be dealt with through API
+
+// release canvas
+
+// remember dimensions
+
+// remember original element
+
+// remember request so we can abort it later
+
+// remember the original item source
+
+// remember this plugin
+
+// remember this width
+
+// remove all process buttons
+
+// remove any whitespace as that causes InvalidCharacterError in IE
+
+// remove client
+
+// remove filter
+
+// remove first item as it will be replaced by this item
+
+// remove from child views
+
+// remove generic headers from api object
+
+// remove image head (default)
+
+// remove item
+
+// remove last button (revert) if not allowed
+
+// remove our element
+
+// remove process if no url or process on outline
+
+// remove reference
+
+// remove request reference
+
+// remove the element
+
+// remove the original element
+
+// remove these views
+
+// remove unwanted
+
+// removed from view
+
+// rename the original filename to match the mime type of the output image
+
+// render initial view
+
+// replace source and file object
+
+// replace the target element
+
+// request aborted
+
+// request bounding box dimensions
+
+// request destruction
+
+// request item removal
+
+// request timeout
+
+// request update to panel height
+
+// reset abort callback
+
+// reset file server id and transfer id as now it's not available on the server
+
+// reset input, it's just for exposing a method to drop files, should not retain any state
+
+// reset overflow state
+
+// resize the item panel
+
+// resolve now
+
+// resolves with supplied blob
+
+// restore original dom element
+
+// restore original element
+
+// return an array of files { name:'name', file:File }
+
+// return data
+
+// return new options
+
+// return removeListener function
+
+// return the File object
+
+// return the plugin instance
+
+// returns an app based on the given element hook
+
+// returns the current option value
+
+// returns true if the app was destroyed successfully
+
+// reveal element
+
+// reveal the preview image
+
+// revert before removing from the view...
+
+// revert the upload (fire and forget)
+
+// right before it is set to the item state
+
+// root element should not be changed
+
+// rotate
+
+// route actions
+
+// rows are used to find when we have left the preview area bounding box
+
+// run mixins
+
+// scale
+
+// scale canvas based on pixel density
+
+// scale center part
+
+// scale up width and height when we're dealing with an SVG
+
+// see if already exists, if so, return
+
+// see if item has been removed
+
+// see if props have changed
+
+// see if should reformat headers;
+
+// select
+
+// select last state change action
+
+// send request object
+
+// send source there so dev can remove file from server
+
+// send to the transform worker to transform the blob on a separate thread
+
+// set (possibly) transformed file
+
+// set a stub file object while loading the actual data
+
+// set animator target
+
+// set as active loader
+
+// set as active processor
+
+// set configurable props
+
+// set container bounds (so pushes siblings downwards)
+
+// set credentials
+
+// set current state
+
+// set default FilePond options and add bridge once
+
+// set default crop rectangle
+
+// set default options
+
+// set field value
+
+// set file object
+
+// set filters and colors so we can restore them when re-editing the image
+
+// set global painter
+
+// set handlers
+
+// set id
+
+// set id so can be referenced from outside labels
+
+// set initial meta data
+
+// set initial options
+
+// set initial values
+
+// set label, we use labelled by as otherwise the screenreader does not read the "browse" text in the label (as it has tabindex: 0)
+
+// set list height
+
+// set list height (if is overflowing)
+
+// set loader source data
+
+// set merged color matrix to use in preview plugin
+
+// set name of element (is removed when a value is set)
+
+// set name of file stub
+
+// set onload hanlder
+
+// set original file
+
+// set preview view
+
+// set reference
+
+// set request start
+
+// set size of file stub
+
+// set state
+
+// set timeout if defined (do it after open so IE11 plays ball)
+
+// set to false to copy image exif data to output
+
+// set to false to disable upscaling of image smaller than the target width / height
+
+// set to idle so shows grab cursor
+
+// set to null to remove animation while dragging
+
+// set type of response
+
+// set up transparency grid
+
+// sets correct state to hopper scope
+
+// setup animators
+
+// setup attribute mapping for accept
+
+// setup paste listener for entire page
+
+// setup processor
+
+// setup!
+
+// shortcuts
+
+// should align center
+
+// should be appended?
+
+// should be over an element to drop
+
+// should return a promise
+
+// should return request
+
+// should we post the default transformed file
+
+// should we post the original file
+
+// should we update the output data
+
+// show support by displaying credits
+
+// show the overlay
+
+// show/hide RemoveItem button
+
+// size has been updated
+
+// skip
+
+// slow down based on amount of damping
+
+// so if a before remove file hook is defined we need to run it now
+
+// so when zooming in it doesn't get too blurry
+
+// some actions might trigger events
+
+// something went wrong
+
+// something went wrong during transform phase
+
+// sort items in list
+
+// source is known
+
+// special treatment for remove
+
+// stack
+
+// start at 0
+
+// start creating variants
+
+// start drawing
+
+// start file processing
+
+// start listening to clicks again
+
+// start loading the source
+
+// start painter and fire load event
+
+// start processing file
+
+// start processing more chunks
+
+// start processing the file
+
+// start testing size
+
+// start writing
+
+// starts loading
+
+// stop active processes (file uploads, fetches, stuff like that)
+
+// stop here if aborted, might have happened in between request and callback
+
+// stop listening to resize
+
+// stop listening to the visiblitychange event
+
+// stop updater
+
+// stop worker
+
+// stops from triggering the element a second time
+
+// store current styles so we can compare them to new styles later on
+
+// store file item in file input
+
+// store internally
+
+// store new transforms
+
+// store server ref in hidden input
+
+// styles
+
+// sub status
+
+// subscribe to file load and append required info
+
+// subscribe to file load and append required transformations
+
+// subscribe to file transformations
+
+// svg
+
+// swap width and height if orientation needs correcting
+
+// sync `acceptedFileTypes` property with `accept` attribute
+
+// sync panel height with item height
+
+// target height
+
+// target width
+
+// targetting this client
+
+// tell the view the item has been removed
+
+// test if file is of type image
+
+// test if file is of type image and can be viewed in canvas
+
+// test if is already processed
+
+// test if is content disposition header, if not exit
+
+// test if is filtered
+
+// test if is identity matrix
+
+// test if is no longer hidden
+
+// test if target is the element or if one of its children is
+
+// test if there's still room in the list of files
+
+// test if we're resizing horizontally
+
+// test textarea or input is contained in filepond root
+
+// tests if
+
+// the aspect ratio of the crop ('1:1', '16:9', etc)
+
+// the file is contained in a fieldset with legend that contains the filename
+
+// the file is now loading we need to update the progress indicators
+
+// the file to process
+
+// the file url is no longer needed
+
+// the function that is used to apply the file transformations
+
+// the height of the panel minus the label height
+
+// the icon to use for the edit button
+
+// the id to add to the root element
+
+// the image needs to be resized
+
+// the metadata to send along
+
+// the method of rescaling
+
+// the preview image data (we need this to filter the image)
+
+// the preview is now ready to be drawn
+
+// the rectangle of the element expanded to contain its children including own margin and child margins
+
+// the rectangle of the element expanded to contain its children, does not include any margins
+
+// the rectangle of the element itself
+
+// the request might not go through, for instance, there might be some server trouble
+
+// the room we leave open between the end of the list and the panel bottom
+
+// the total entries to read
+
+// these files don't fit so stop here
+
+// these will then be automatically set to the initial files
+
+// 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)
+
+// this isn't fantastic, but because of the stacking of settimeouts plugins can handle the did_load before the did_init
+
+// this multiplies the minimum image resolution,
+
+// this requestAnimationFrame nesting is horrible but it fixes an issue with 100hz displays on Chrome
+
+// this timeout pushes the handler after 'load'
+
+// this would simply bring the browser to its knees and that is not what we want
+
+// timeout identifier, only used when timeout is defined
+
+// timeout used for calling update items
+
+// timeout used for stacking metadata updates
+
+// toggle
+
+// transfer to image tag so no canvas memory wasted on iOS
+
+// transform order is relevant
+
+// translate to other name
+
+// tries to get header info to the app as fast as possible
+
+// try fallback if defined by user, else reject
+
+// try loading the source one more time
+
+// try the oldschool way
+
+// try to access item
+
+// try to add now
+
+// try to copy image head from original file to generated blob
+
+// try to get files from the transfer
+
+// 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)
+
+// try to get next batch of files
+
+// turn attributes into object
+
+// turn blob response into a file
+
+// turn the file into an image
+
+// type set
+
+// undefined or null
+
+// update
+
+// update OptionTypes, each plugin might have extended the default options
+
+// update actual duration
+
+// update actual progress
+
+// update crop metadata
+
+// update duration
+
+// update editor props that could have changed
+
+// update existing plugins
+
+// update height if is fixed
+
+// update icon and label for revert button when instant uploading
+
+// update image view
+
+// update markup view
+
+// update others about this error
+
+// update position by adding velocity
+
+// update progress bar
+
+// update progress percentage
+
+// update resize operation
+
+// update resting state
+
+// update scalable state
+
+// update text
+
+// update the view
+
+// update transform metadata object
+
+// update value
+
+// update velocity by adding force based on mass
+
+// update view
+
+// updates child views that are currently attached to the DOM
+
+// updates the OptionTypes object based on the current options
+
+// updates the legend of the fieldset so screenreaders can better group buttons
+
+// url
+
+// url is no longer needed
+
+// use for labeling file input (aria-labelledby on file input)
+
+// use math ceil to prevent transparent lines because of rounding errors
+
+// use type detector
+
+// used in instant edit mode
+
+// user or another process aborted the file load (cannot retry)
+
+// user passed a sources array
+
+// user passed sources as arguments, last one might be options object
+
+// validation result
+
+// view is file
+
+// view is file info
+
+// view type
+
+// views on death row
+
+// views to retain
+
+// wait for idle state and then run PREPARE_OUTPUT
+
+// wait for results
+
+// waiting
+
+// waiting for something
+
+// want to remove required, always possible
+
+// want to tween to a smaller value and have a current value
+
+// we add a little delay so the OS file select window can move out of the way before we add our file
+
+// we are really done
+
+// we can drop these items on this client
+
+// we can now scale the panel to the final size
+
+// we check if the current count is smaller than the max count, if so, another file can still be added
+
+// we check if transform is set, if so, we check if property is set
+
+// we don't need to read the entire file to get the orientation
+
+// we done
+
+// we done function
+
+// we done!
+
+// we error function
+
+// we have to link this element to the status element
+
+// we just added somthing to the dom, no rest
+
+// we multiply by .75 as that creates smaller but still clear images on screens with high res displays
+
+// we need the item to get to the crop size
+
+// we need to delay by the difference between interval and dist
+
+// we need to wait an additional 6ms before calling the function)
+
+// we only add required if the field has been deemed required
+
+// we push this forward a bit so the interface is updated correctly
+
+// we put the response in state so we can access
+
+// we resize the image so memory on iOS 12 is released more quickly (it seems)
+
+// we successfully set the value of this option
+
+// we validate the file against the accepted file types
+
+// we want as much pixels to work with as possible,
+
+// we will add those properties to the external API and link them to the viewState
+
+// we'eve received a size indication, let's update the stub
+
+// we've arrived if we're near target and our velocity is near zero
+
+// we've not yet started the real download, stop here
+
+// we've probably received some useful data in response headers
+
+// webpackBootstrap
+
+// what is the type now
+
+// when removing by index the indexes shift after each file removal so we need to convert indexes to ids
+
+// when successfully transformed
+
+// when the animator updates, update the view state value
+
+// where did the file originate
+
+// where did this file come from
+
+// where to insert new items
+
+// which name to prefix the default transformed file with
+
+// which name to prefix the original file with
+
+// will also notify the user when FilePond is not being used, as the user might be occupied with other activities while uploading a file
+
+// will clean up all archived items
+
+// will store image data for future filter updates
+
+// writers
+
+// yay we got our bitmap, let's continue showing the preview
+
+// you want to make use of revert