Actualización

app/Resources/public/assets/blueimp-load-image/.bower.json

@@ -0,0 +1,14 @@
+{
+  "name": "blueimp-load-image",
+  "homepage": "https://github.com/blueimp/JavaScript-Load-Image",
+  "version": "5.13.0",
+  "_release": "5.13.0",
+  "_resolution": {
+    "type": "version",
+    "tag": "v5.13.0",
+    "commit": "0a7c9cbc977debeb94962446f1db69afbdaa1720"
+  },
+  "_source": "https://github.com/blueimp/JavaScript-Load-Image.git",
+  "_target": ">=1.13.0",
+  "_originalSource": "blueimp-load-image"
+}

app/Resources/public/assets/blueimp-load-image/.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [blueimp]

app/Resources/public/assets/blueimp-load-image/.github/workflows/test.yml

@@ -0,0 +1,34 @@
+name: Node CI
+
+on: [push, pull_request]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup Node.js
+        uses: actions/setup-node@v1
+        with:
+          node-version: 12.x
+      - name: npm install
+        run: npm install
+        env:
+          CI: true
+      - name: lint
+        run: npm run lint
+        env:
+          CI: true
+
+  unit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: mocha
+        run: docker-compose run --rm mocha
+      - name: docker-compose logs
+        if: always()
+        run: docker-compose logs nginx
+      - name: docker-compose down
+        if: always()
+        run: docker-compose down -v

app/Resources/public/assets/blueimp-load-image/.gitignore

@@ -0,0 +1 @@
+node_modules

app/Resources/public/assets/blueimp-load-image/LICENSE.txt

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright © 2011 Sebastian Tschan, https://blueimp.net
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

app/Resources/public/assets/blueimp-load-image/css/demo.css

@@ -0,0 +1,239 @@
+/*
+ * JavaScript Load Image Demo CSS
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ */
+
+body {
+  max-width: 990px;
+  margin: 0 auto;
+  padding: 1em;
+  font-family: system-ui, -apple-system, 'Segoe UI', Roboto, 'Helvetica Neue',
+    Arial, sans-serif;
+  -webkit-text-size-adjust: 100%;
+  line-height: 1.4;
+  background: #212121;
+  color: #dedede;
+}
+a {
+  color: #61afef;
+  text-decoration: none;
+}
+a:visited {
+  color: #56b6c2;
+}
+a:hover {
+  color: #98c379;
+}
+table {
+  width: 100%;
+  word-wrap: break-word;
+  table-layout: fixed;
+  border-collapse: collapse;
+}
+figure {
+  margin: 0;
+  padding: 0.75em;
+  border-radius: 5px;
+  display: inline-block;
+}
+table,
+figure {
+  margin-bottom: 1.25em;
+}
+tr,
+figure {
+  background: #363636;
+}
+tr:nth-child(odd) {
+  background: #414141;
+}
+td,
+th {
+  padding: 0.5em 0.75em;
+  text-align: left;
+}
+img,
+canvas {
+  max-width: 100%;
+  border: 0;
+  vertical-align: middle;
+}
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  margin-top: 1.5em;
+  margin-bottom: 0.5em;
+}
+h1 {
+  margin-top: 0.5em;
+}
+label {
+  display: inline-block;
+  margin-bottom: 0.25em;
+}
+button,
+select,
+input,
+textarea {
+  -webkit-appearance: none;
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0.5em 0.75em;
+  font-family: inherit;
+  font-size: 100%;
+  line-height: 1.4;
+  background: #414141;
+  color: #dedede;
+  border: 1px solid #363636;
+  border-radius: 5px;
+  box-shadow: 0 0 4px rgba(0, 0, 0, 0.07);
+}
+input,
+textarea {
+  width: 100%;
+  box-shadow: inset 0 0 4px rgba(0, 0, 0, 0.07);
+}
+textarea {
+  display: block;
+  overflow: auto;
+}
+button {
+  background: #3c76a7;
+  background: linear-gradient(180deg, #3c76a7, #225c8d);
+  border-color: #225c8d;
+  color: #fff;
+}
+button[type='submit'] {
+  background: #6fa349;
+  background: linear-gradient(180deg, #6fa349, #568a30);
+  border-color: #568a30;
+}
+button[type='reset'] {
+  background: #d79435;
+  background: linear-gradient(180deg, #d79435, #be7b1c);
+  border-color: #be7b1c;
+}
+select {
+  display: block;
+  padding-right: 2.25em;
+  background: #3c76a7;
+  background: url('data:image/svg+xml;charset=utf8,%3Csvg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 4 5"%3E%3Cpath fill="%23fff" d="M2 0L0 2h4zm0 5L0 3h4z"/%3E%3C/svg%3E')
+      no-repeat right 0.75em center/0.75em,
+    linear-gradient(180deg, #3c76a7, #225c8d);
+  border-color: #225c8d;
+  color: #fff;
+}
+button:active,
+select:active {
+  box-shadow: inset 0 0 8px rgba(0, 0, 0, 0.5);
+}
+select::-ms-expand {
+  display: none;
+}
+option {
+  color: #212121;
+}
+input[type='checkbox'] {
+  -webkit-appearance: checkbox;
+  width: auto;
+  padding: initial;
+  box-shadow: none;
+}
+input[type='file'] {
+  max-width: 100%;
+  padding: 0;
+  background: none;
+  border: 0;
+  border-radius: 0;
+  box-shadow: none;
+}
+
+input[type='file']::-webkit-file-upload-button {
+  -webkit-appearance: none;
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0.5em 0.75em;
+  font-family: inherit;
+  font-size: 100%;
+  line-height: 1.4;
+  background: linear-gradient(180deg, #3c76a7, #225c8d);
+  border: 1px solid #225c8d;
+  color: #fff;
+  border-radius: 5px;
+  box-shadow: 0 0 4px rgba(0, 0, 0, 0.07);
+}
+input[type='file']::-webkit-file-upload-button:active {
+  box-shadow: inset 0 0 8px rgba(0, 0, 0, 0.5);
+}
+input[type='file']::-ms-browse {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0.5em 0.75em;
+  font-family: inherit;
+  font-size: 100%;
+  line-height: 1.4;
+  background: linear-gradient(180deg, #3c76a7, #225c8d);
+  border: 1px solid #225c8d;
+  color: #fff;
+  border-radius: 5px;
+  box-shadow: 0 0 4px rgba(0, 0, 0, 0.07);
+}
+input[type='file']::-ms-browse:active {
+  box-shadow: inset 0 0 8px rgba(0, 0, 0, 0.5);
+}
+
+@media (prefers-color-scheme: light) {
+  body {
+    background: #ececec;
+    color: #212121;
+  }
+  a {
+    color: #225c8d;
+  }
+  a:visited {
+    color: #378f9a;
+  }
+  a:hover {
+    color: #6fa349;
+  }
+  figure,
+  tr {
+    background: #fff;
+    color: #212121;
+  }
+  tr:nth-child(odd) {
+    background: #f6f6f6;
+  }
+  input,
+  textarea {
+    background: #fff;
+    border-color: #d1d1d1;
+    color: #212121;
+  }
+}
+
+#result {
+  display: block;
+}
+
+@media (min-width: 540px) {
+  #navigation {
+    list-style: none;
+    padding: 0;
+  }
+  #navigation li {
+    display: inline-block;
+  }
+  #navigation li:not(:first-child)::before {
+    content: ' | ';
+  }
+}

app/Resources/public/assets/blueimp-load-image/docker-compose.yml

@@ -0,0 +1,16 @@
+version: '3.7'
+services:
+  nginx:
+    image: nginx:alpine
+    ports:
+      - 127.0.0.1:80:80
+      - ${SERVER_HOST:-127.0.0.1}:${SERVER_PORT-}:80
+    volumes:
+      - .:/usr/share/nginx/html:ro
+  mocha:
+    image: blueimp/mocha-chrome
+    command: http://nginx/test
+    environment:
+      - WAIT_FOR_HOSTS=nginx:80
+    depends_on:
+      - nginx

app/Resources/public/assets/blueimp-load-image/index.html

@@ -0,0 +1,157 @@
+<!DOCTYPE html>
+<!--
+  /*
+   * JavaScript Load Image Demo
+   * https://github.com/blueimp/JavaScript-Load-Image
+   *
+   * Copyright 2011, Sebastian Tschan
+   * https://blueimp.net
+   *
+   * Licensed under the MIT license:
+   * https://opensource.org/licenses/MIT
+   */
+-->
+<html lang="en">
+  <head>
+    <!--[if IE]>
+      <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <![endif]-->
+    <meta charset="utf-8" />
+    <title>JavaScript Load Image</title>
+    <meta
+      name="description"
+      content="JavaScript Load Image is a library to load images provided as File or Blob objects or via URL. It returns an optionally scaled, cropped or rotated HTML img or canvas element. It also provides methods to parse image metadata to extract IPTC and Exif tags as well as embedded thumbnail images, to overwrite the Exif Orientation value and to restore the complete image header after resizing."
+    />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <!--
+      Jcrop is not required by JavaScript Load Image, but included for the demo
+    -->
+    <link rel="stylesheet" href="css/vendor/jquery.Jcrop.css" />
+    <link rel="stylesheet" href="css/demo.css" />
+    <!--[if lt IE 9]>
+      <script>
+        // Basic HTML5 elements support:
+        'figure figcaption'.replace(/\w+/g, function (n) {
+          document.createElement(n)
+        })
+      </script>
+    <![endif]-->
+  </head>
+  <body>
+    <h1>JavaScript Load Image Demo</h1>
+    <p>
+      <a href="https://github.com/blueimp/JavaScript-Load-Image"
+        >JavaScript Load Image</a
+      >
+      is a library to load images provided as
+      <a href="https://developer.mozilla.org/en-US/docs/Web/API/File">File</a>
+      or
+      <a href="https://developer.mozilla.org/en-US/docs/Web/API/Blob">Blob</a>
+      objects or via URL.<br />
+      It returns an optionally <strong>scaled</strong>,
+      <strong>cropped</strong> or <strong>rotated</strong> HTML
+      <a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/Img"
+        >img</a
+      >
+      or
+      <a href="https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API"
+        >canvas</a
+      >
+      element.
+    </p>
+    <p>
+      It also provides methods to parse image metadata to extract
+      <a href="https://iptc.org/standards/photo-metadata/">IPTC</a> and
+      <a href="https://en.wikipedia.org/wiki/Exif">Exif</a> tags as well as
+      embedded thumbnail images, to overwrite the Exif Orientation value and to
+      restore the complete image header after resizing.
+    </p>
+    <ul id="navigation">
+      <li>
+        <a href="https://github.com/blueimp/JavaScript-Load-Image/releases"
+          >Download</a
+        >
+      </li>
+      <li>
+        <a href="https://github.com/blueimp/JavaScript-Load-Image"
+          >Source Code</a
+        >
+      </li>
+      <li>
+        <a
+          href="https://github.com/blueimp/JavaScript-Load-Image/blob/master/README.md"
+          >Documentation</a
+        >
+      </li>
+      <li><a href="test/">Test</a></li>
+      <li><a href="https://blueimp.net">&copy; Sebastian Tschan</a></li>
+    </ul>
+    <h2>Select an image file</h2>
+    <p>
+      <input type="file" id="file-input" />
+    </p>
+    <p>
+      <label for="url">Or enter an image URL into the following field:</label>
+      <input type="url" id="url" placeholder="Image URL" />
+    </p>
+    <p>Or <strong>drag &amp; drop</strong> an image file onto this webpage.</p>
+    <h3>Options</h3>
+    <p>
+      <label for="orientation">Orientation:</label>
+      <select id="orientation">
+        <option value="-1">undefined: Browser default</option>
+        <option value="0" selected>true: Automatic</option>
+        <option value="1">1: Original</option>
+        <option value="2">2: Horizontal flip</option>
+        <option value="3">3: Rotate 180° CCW</option>
+        <option value="4">4: Vertical flip</option>
+        <option value="5">5: Vertical flip + Rotate 90° CW</option>
+        <option value="6">6: Rotate 90° CW</option>
+        <option value="7">7: Horizontal flip + Rotate 90° CW</option>
+        <option value="8">8: Rotate 90° CCW</option>
+      </select>
+    </p>
+    <p>
+      <input type="checkbox" id="image-smoothing" checked />
+      <label for="image-smoothing">Image smoothing</label>
+    </p>
+    <h2>Result</h2>
+    <p id="actions" style="display: none;">
+      <button type="button" id="edit">Edit</button>
+      <button type="submit" id="crop">Crop</button>
+      <button type="reset" id="cancel">Cancel</button>
+    </p>
+    <figure id="result">
+      <figcaption style="display: none;">
+        Loading images from File objects requires support for the
+        <a href="https://developer.mozilla.org/en-US/docs/Web/API/URL">URL</a>
+        or
+        <a href="https://developer.mozilla.org/en-US/docs/Web/API/FileReader"
+          >FileReader</a
+        >
+        API.
+      </figcaption>
+    </figure>
+    <div id="meta" style="display: none;">
+      <h3>Image metadata</h3>
+      <figure id="thumbnail" style="display: none;"></figure>
+    </div>
+    <script src="js/vendor/canvas-to-blob.js"></script>
+    <script src="js/load-image.js"></script>
+    <script src="js/load-image-scale.js"></script>
+    <script src="js/load-image-meta.js"></script>
+    <script src="js/load-image-fetch.js"></script>
+    <script src="js/load-image-orientation.js"></script>
+    <script src="js/load-image-exif.js"></script>
+    <script src="js/load-image-exif-map.js"></script>
+    <script src="js/load-image-iptc.js"></script>
+    <script src="js/load-image-iptc-map.js"></script>
+    <!--
+      jQuery and Jcrop are not required by JavaScript Load Image,
+      but included for the demo
+    -->
+    <script src="js/vendor/jquery.js"></script>
+    <script src="js/vendor/jquery.Jcrop.js"></script>
+    <script src="js/demo/demo.js"></script>
+  </body>
+</html>

app/Resources/public/assets/blueimp-load-image/js/demo/demo.js

@@ -0,0 +1,317 @@
+/*
+ * JavaScript Load Image Demo JS
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ */
+
+/* global loadImage, $ */
+
+$(function () {
+  'use strict'
+
+  var resultNode = $('#result')
+  var metaNode = $('#meta')
+  var thumbNode = $('#thumbnail')
+  var actionsNode = $('#actions')
+  var orientationNode = $('#orientation')
+  var imageSmoothingNode = $('#image-smoothing')
+  var fileInputNode = $('#file-input')
+  var urlNode = $('#url')
+  var editNode = $('#edit')
+  var cropNode = $('#crop')
+  var cancelNode = $('#cancel')
+  var coordinates
+  var jcropAPI
+
+  /**
+   * Displays tag data
+   *
+   * @param {*} node jQuery node
+   * @param {object} tags Tags map
+   * @param {string} title Tags title
+   */
+  function displayTagData(node, tags, title) {
+    var table = $('<table></table>')
+    var row = $('<tr></tr>')
+    var cell = $('<td></td>')
+    var headerCell = $('<th colspan="2"></th>')
+    var prop
+    table.append(row.clone().append(headerCell.clone().text(title)))
+    for (prop in tags) {
+      if (Object.prototype.hasOwnProperty.call(tags, prop)) {
+        if (typeof tags[prop] === 'object') {
+          displayTagData(node, tags[prop], prop)
+          continue
+        }
+        table.append(
+          row
+            .clone()
+            .append(cell.clone().text(prop))
+            .append(cell.clone().text(tags[prop]))
+        )
+      }
+    }
+    node.append(table).show()
+  }
+
+  /**
+   * Displays the thumbnal image
+   *
+   * @param {*} node jQuery node
+   * @param {string} thumbnail Thumbnail URL
+   * @param {object} [options] Options object
+   */
+  function displayThumbnailImage(node, thumbnail, options) {
+    if (thumbnail) {
+      var link = $('<a></a>')
+        .attr('href', loadImage.createObjectURL(thumbnail))
+        .attr('download', 'thumbnail.jpg')
+        .appendTo(node)
+      loadImage(
+        thumbnail,
+        function (img) {
+          link.append(img)
+          node.show()
+        },
+        options
+      )
+    }
+  }
+
+  /**
+   * Displays metadata
+   *
+   * @param {object} [data] Metadata object
+   */
+  function displayMetaData(data) {
+    if (!data) return
+    metaNode.data(data)
+    var exif = data.exif
+    var iptc = data.iptc
+    if (exif) {
+      var thumbnail = exif.get('Thumbnail')
+      if (thumbnail) {
+        displayThumbnailImage(thumbNode, thumbnail.get('Blob'), {
+          orientation: exif.get('Orientation')
+        })
+      }
+      displayTagData(metaNode, exif.getAll(), 'TIFF')
+    }
+    if (iptc) {
+      displayTagData(metaNode, iptc.getAll(), 'IPTC')
+    }
+  }
+
+  /**
+   * Removes meta data from the page
+   */
+  function removeMetaData() {
+    metaNode.hide().removeData().find('table').remove()
+    thumbNode.hide().empty()
+  }
+
+  /**
+   * Updates the results view
+   *
+   * @param {*} img Image or canvas element
+   * @param {object} [data] Metadata object
+   * @param {boolean} [keepMetaData] Keep meta data if true
+   */
+  function updateResults(img, data, keepMetaData) {
+    var isCanvas = window.HTMLCanvasElement && img instanceof HTMLCanvasElement
+    if (!keepMetaData) {
+      removeMetaData()
+      if (data) {
+        displayMetaData(data)
+      }
+      if (isCanvas) {
+        actionsNode.show()
+      } else {
+        actionsNode.hide()
+      }
+    }
+    if (!(isCanvas || img.src)) {
+      resultNode
+        .children()
+        .replaceWith($('<span>Loading image file failed</span>'))
+      return
+    }
+    var content = $('<a></a>').append(img)
+    resultNode.children().replaceWith(content)
+    if (data.imageHead) {
+      if (data.exif) {
+        // Reset Exif Orientation data:
+        loadImage.writeExifData(data.imageHead, data, 'Orientation', 1)
+      }
+      img.toBlob(function (blob) {
+        if (!blob) return
+        loadImage.replaceHead(blob, data.imageHead, function (newBlob) {
+          content
+            .attr('href', loadImage.createObjectURL(newBlob))
+            .attr('download', 'image.jpg')
+        })
+      }, 'image/jpeg')
+    }
+  }
+
+  /**
+   * Displays the image
+   *
+   * @param {File|Blob|string} file File or Blob object or image URL
+   */
+  function displayImage(file) {
+    var options = {
+      maxWidth: resultNode.width(),
+      canvas: true,
+      pixelRatio: window.devicePixelRatio,
+      downsamplingRatio: 0.5,
+      orientation: Number(orientationNode.val()) || true,
+      imageSmoothingEnabled: imageSmoothingNode.is(':checked'),
+      meta: true
+    }
+    if (!loadImage(file, updateResults, options)) {
+      removeMetaData()
+      resultNode
+        .children()
+        .replaceWith(
+          $(
+            '<span>' +
+              'Your browser does not support the URL or FileReader API.' +
+              '</span>'
+          )
+        )
+    }
+  }
+
+  /**
+   * Handles drop and file selection change events
+   *
+   * @param {event} event Drop or file selection change event
+   */
+  function fileChangeHandler(event) {
+    event.preventDefault()
+    var originalEvent = event.originalEvent
+    var target = originalEvent.dataTransfer || originalEvent.target
+    var file = target && target.files && target.files[0]
+    if (!file) {
+      return
+    }
+    displayImage(file)
+  }
+
+  /**
+   * Handles URL change events
+   */
+  function urlChangeHandler() {
+    var url = $(this).val()
+    if (url) displayImage(url)
+  }
+
+  // Show the URL/FileReader API requirement message if not supported:
+  if (
+    window.createObjectURL ||
+    window.URL ||
+    window.webkitURL ||
+    window.FileReader
+  ) {
+    resultNode.children().hide()
+  } else {
+    resultNode.children().show()
+  }
+
+  $(document)
+    .on('dragover', function (e) {
+      e.preventDefault()
+      if (event.dataTransfer) event.dataTransfer.dropEffect = 'copy'
+    })
+    .on('drop', fileChangeHandler)
+
+  fileInputNode.on('change', fileChangeHandler)
+
+  urlNode.on('change paste input', urlChangeHandler)
+
+  orientationNode.on('change', function () {
+    var img = resultNode.find('img, canvas')[0]
+    if (img) {
+      updateResults(
+        loadImage.scale(img, {
+          maxWidth: resultNode.width() * (window.devicePixelRatio || 1),
+          pixelRatio: window.devicePixelRatio,
+          orientation: Number(orientationNode.val()) || true,
+          imageSmoothingEnabled: imageSmoothingNode.is(':checked')
+        }),
+        metaNode.data(),
+        true
+      )
+    }
+  })
+
+  editNode.on('click', function (event) {
+    event.preventDefault()
+    var imgNode = resultNode.find('img, canvas')
+    var img = imgNode[0]
+    var pixelRatio = window.devicePixelRatio || 1
+    var margin = img.width / pixelRatio >= 140 ? 40 : 0
+    imgNode
+      // eslint-disable-next-line new-cap
+      .Jcrop(
+        {
+          setSelect: [
+            margin,
+            margin,
+            img.width / pixelRatio - margin,
+            img.height / pixelRatio - margin
+          ],
+          onSelect: function (coords) {
+            coordinates = coords
+          },
+          onRelease: function () {
+            coordinates = null
+          }
+        },
+        function () {
+          jcropAPI = this
+        }
+      )
+      .parent()
+      .on('click', function (event) {
+        event.preventDefault()
+      })
+  })
+
+  cropNode.on('click', function (event) {
+    event.preventDefault()
+    var img = resultNode.find('img, canvas')[0]
+    var pixelRatio = window.devicePixelRatio || 1
+    if (img && coordinates) {
+      updateResults(
+        loadImage.scale(img, {
+          left: coordinates.x * pixelRatio,
+          top: coordinates.y * pixelRatio,
+          sourceWidth: coordinates.w * pixelRatio,
+          sourceHeight: coordinates.h * pixelRatio,
+          maxWidth: resultNode.width() * pixelRatio,
+          contain: true,
+          pixelRatio: pixelRatio,
+          imageSmoothingEnabled: imageSmoothingNode.is(':checked')
+        }),
+        metaNode.data(),
+        true
+      )
+      coordinates = null
+    }
+  })
+
+  cancelNode.on('click', function (event) {
+    event.preventDefault()
+    if (jcropAPI) {
+      jcropAPI.release()
+      jcropAPI.disable()
+    }
+  })
+})

app/Resources/public/assets/blueimp-load-image/js/index.js

@@ -0,0 +1,12 @@
+/* global module, require */
+
+module.exports = require('./load-image')
+
+require('./load-image-scale')
+require('./load-image-meta')
+require('./load-image-fetch')
+require('./load-image-exif')
+require('./load-image-exif-map')
+require('./load-image-iptc')
+require('./load-image-iptc-map')
+require('./load-image-orientation')

app/Resources/public/assets/blueimp-load-image/js/load-image-exif-map.js

@@ -0,0 +1,420 @@
+/*
+ * JavaScript Load Image Exif Map
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Exif tags mapping based on
+ * https://github.com/jseidelin/exif-js
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ */
+
+/* global define, module, require */
+
+;(function (factory) {
+  'use strict'
+  if (typeof define === 'function' && define.amd) {
+    // Register as an anonymous AMD module:
+    define(['./load-image', './load-image-exif'], factory)
+  } else if (typeof module === 'object' && module.exports) {
+    factory(require('./load-image'), require('./load-image-exif'))
+  } else {
+    // Browser globals:
+    factory(window.loadImage)
+  }
+})(function (loadImage) {
+  'use strict'
+
+  var ExifMapProto = loadImage.ExifMap.prototype
+
+  ExifMapProto.tags = {
+    // =================
+    // TIFF tags (IFD0):
+    // =================
+    0x0100: 'ImageWidth',
+    0x0101: 'ImageHeight',
+    0x0102: 'BitsPerSample',
+    0x0103: 'Compression',
+    0x0106: 'PhotometricInterpretation',
+    0x0112: 'Orientation',
+    0x0115: 'SamplesPerPixel',
+    0x011c: 'PlanarConfiguration',
+    0x0212: 'YCbCrSubSampling',
+    0x0213: 'YCbCrPositioning',
+    0x011a: 'XResolution',
+    0x011b: 'YResolution',
+    0x0128: 'ResolutionUnit',
+    0x0111: 'StripOffsets',
+    0x0116: 'RowsPerStrip',
+    0x0117: 'StripByteCounts',
+    0x0201: 'JPEGInterchangeFormat',
+    0x0202: 'JPEGInterchangeFormatLength',
+    0x012d: 'TransferFunction',
+    0x013e: 'WhitePoint',
+    0x013f: 'PrimaryChromaticities',
+    0x0211: 'YCbCrCoefficients',
+    0x0214: 'ReferenceBlackWhite',
+    0x0132: 'DateTime',
+    0x010e: 'ImageDescription',
+    0x010f: 'Make',
+    0x0110: 'Model',
+    0x0131: 'Software',
+    0x013b: 'Artist',
+    0x8298: 'Copyright',
+    0x8769: {
+      // ExifIFDPointer
+      0x9000: 'ExifVersion', // EXIF version
+      0xa000: 'FlashpixVersion', // Flashpix format version
+      0xa001: 'ColorSpace', // Color space information tag
+      0xa002: 'PixelXDimension', // Valid width of meaningful image
+      0xa003: 'PixelYDimension', // Valid height of meaningful image
+      0xa500: 'Gamma',
+      0x9101: 'ComponentsConfiguration', // Information about channels
+      0x9102: 'CompressedBitsPerPixel', // Compressed bits per pixel
+      0x927c: 'MakerNote', // Any desired information written by the manufacturer
+      0x9286: 'UserComment', // Comments by user
+      0xa004: 'RelatedSoundFile', // Name of related sound file
+      0x9003: 'DateTimeOriginal', // Date and time when the original image was generated
+      0x9004: 'DateTimeDigitized', // Date and time when the image was stored digitally
+      0x9010: 'OffsetTime', // Time zone when the image file was last changed
+      0x9011: 'OffsetTimeOriginal', // Time zone when the image was stored digitally
+      0x9012: 'OffsetTimeDigitized', // Time zone when the image was stored digitally
+      0x9290: 'SubSecTime', // Fractions of seconds for DateTime
+      0x9291: 'SubSecTimeOriginal', // Fractions of seconds for DateTimeOriginal
+      0x9292: 'SubSecTimeDigitized', // Fractions of seconds for DateTimeDigitized
+      0x829a: 'ExposureTime', // Exposure time (in seconds)
+      0x829d: 'FNumber',
+      0x8822: 'ExposureProgram', // Exposure program
+      0x8824: 'SpectralSensitivity', // Spectral sensitivity
+      0x8827: 'PhotographicSensitivity', // EXIF 2.3, ISOSpeedRatings in EXIF 2.2
+      0x8828: 'OECF', // Optoelectric conversion factor
+      0x8830: 'SensitivityType',
+      0x8831: 'StandardOutputSensitivity',
+      0x8832: 'RecommendedExposureIndex',
+      0x8833: 'ISOSpeed',
+      0x8834: 'ISOSpeedLatitudeyyy',
+      0x8835: 'ISOSpeedLatitudezzz',
+      0x9201: 'ShutterSpeedValue', // Shutter speed
+      0x9202: 'ApertureValue', // Lens aperture
+      0x9203: 'BrightnessValue', // Value of brightness
+      0x9204: 'ExposureBias', // Exposure bias
+      0x9205: 'MaxApertureValue', // Smallest F number of lens
+      0x9206: 'SubjectDistance', // Distance to subject in meters
+      0x9207: 'MeteringMode', // Metering mode
+      0x9208: 'LightSource', // Kind of light source
+      0x9209: 'Flash', // Flash status
+      0x9214: 'SubjectArea', // Location and area of main subject
+      0x920a: 'FocalLength', // Focal length of the lens in mm
+      0xa20b: 'FlashEnergy', // Strobe energy in BCPS
+      0xa20c: 'SpatialFrequencyResponse',
+      0xa20e: 'FocalPlaneXResolution', // Number of pixels in width direction per FPRUnit
+      0xa20f: 'FocalPlaneYResolution', // Number of pixels in height direction per FPRUnit
+      0xa210: 'FocalPlaneResolutionUnit', // Unit for measuring the focal plane resolution
+      0xa214: 'SubjectLocation', // Location of subject in image
+      0xa215: 'ExposureIndex', // Exposure index selected on camera
+      0xa217: 'SensingMethod', // Image sensor type
+      0xa300: 'FileSource', // Image source (3 == DSC)
+      0xa301: 'SceneType', // Scene type (1 == directly photographed)
+      0xa302: 'CFAPattern', // Color filter array geometric pattern
+      0xa401: 'CustomRendered', // Special processing
+      0xa402: 'ExposureMode', // Exposure mode
+      0xa403: 'WhiteBalance', // 1 = auto white balance, 2 = manual
+      0xa404: 'DigitalZoomRatio', // Digital zoom ratio
+      0xa405: 'FocalLengthIn35mmFilm',
+      0xa406: 'SceneCaptureType', // Type of scene
+      0xa407: 'GainControl', // Degree of overall image gain adjustment
+      0xa408: 'Contrast', // Direction of contrast processing applied by camera
+      0xa409: 'Saturation', // Direction of saturation processing applied by camera
+      0xa40a: 'Sharpness', // Direction of sharpness processing applied by camera
+      0xa40b: 'DeviceSettingDescription',
+      0xa40c: 'SubjectDistanceRange', // Distance to subject
+      0xa420: 'ImageUniqueID', // Identifier assigned uniquely to each image
+      0xa430: 'CameraOwnerName',
+      0xa431: 'BodySerialNumber',
+      0xa432: 'LensSpecification',
+      0xa433: 'LensMake',
+      0xa434: 'LensModel',
+      0xa435: 'LensSerialNumber'
+    },
+    0x8825: {
+      // GPSInfoIFDPointer
+      0x0000: 'GPSVersionID',
+      0x0001: 'GPSLatitudeRef',
+      0x0002: 'GPSLatitude',
+      0x0003: 'GPSLongitudeRef',
+      0x0004: 'GPSLongitude',
+      0x0005: 'GPSAltitudeRef',
+      0x0006: 'GPSAltitude',
+      0x0007: 'GPSTimeStamp',
+      0x0008: 'GPSSatellites',
+      0x0009: 'GPSStatus',
+      0x000a: 'GPSMeasureMode',
+      0x000b: 'GPSDOP',
+      0x000c: 'GPSSpeedRef',
+      0x000d: 'GPSSpeed',
+      0x000e: 'GPSTrackRef',
+      0x000f: 'GPSTrack',
+      0x0010: 'GPSImgDirectionRef',
+      0x0011: 'GPSImgDirection',
+      0x0012: 'GPSMapDatum',
+      0x0013: 'GPSDestLatitudeRef',
+      0x0014: 'GPSDestLatitude',
+      0x0015: 'GPSDestLongitudeRef',
+      0x0016: 'GPSDestLongitude',
+      0x0017: 'GPSDestBearingRef',
+      0x0018: 'GPSDestBearing',
+      0x0019: 'GPSDestDistanceRef',
+      0x001a: 'GPSDestDistance',
+      0x001b: 'GPSProcessingMethod',
+      0x001c: 'GPSAreaInformation',
+      0x001d: 'GPSDateStamp',
+      0x001e: 'GPSDifferential',
+      0x001f: 'GPSHPositioningError'
+    },
+    0xa005: {
+      // InteroperabilityIFDPointer
+      0x0001: 'InteroperabilityIndex'
+    }
+  }
+
+  // IFD1 directory can contain any IFD0 tags:
+  ExifMapProto.tags.ifd1 = ExifMapProto.tags
+
+  ExifMapProto.stringValues = {
+    ExposureProgram: {
+      0: 'Undefined',
+      1: 'Manual',
+      2: 'Normal program',
+      3: 'Aperture priority',
+      4: 'Shutter priority',
+      5: 'Creative program',
+      6: 'Action program',
+      7: 'Portrait mode',
+      8: 'Landscape mode'
+    },
+    MeteringMode: {
+      0: 'Unknown',
+      1: 'Average',
+      2: 'CenterWeightedAverage',
+      3: 'Spot',
+      4: 'MultiSpot',
+      5: 'Pattern',
+      6: 'Partial',
+      255: 'Other'
+    },
+    LightSource: {
+      0: 'Unknown',
+      1: 'Daylight',
+      2: 'Fluorescent',
+      3: 'Tungsten (incandescent light)',
+      4: 'Flash',
+      9: 'Fine weather',
+      10: 'Cloudy weather',
+      11: 'Shade',
+      12: 'Daylight fluorescent (D 5700 - 7100K)',
+      13: 'Day white fluorescent (N 4600 - 5400K)',
+      14: 'Cool white fluorescent (W 3900 - 4500K)',
+      15: 'White fluorescent (WW 3200 - 3700K)',
+      17: 'Standard light A',
+      18: 'Standard light B',
+      19: 'Standard light C',
+      20: 'D55',
+      21: 'D65',
+      22: 'D75',
+      23: 'D50',
+      24: 'ISO studio tungsten',
+      255: 'Other'
+    },
+    Flash: {
+      0x0000: 'Flash did not fire',
+      0x0001: 'Flash fired',
+      0x0005: 'Strobe return light not detected',
+      0x0007: 'Strobe return light detected',
+      0x0009: 'Flash fired, compulsory flash mode',
+      0x000d: 'Flash fired, compulsory flash mode, return light not detected',
+      0x000f: 'Flash fired, compulsory flash mode, return light detected',
+      0x0010: 'Flash did not fire, compulsory flash mode',
+      0x0018: 'Flash did not fire, auto mode',
+      0x0019: 'Flash fired, auto mode',
+      0x001d: 'Flash fired, auto mode, return light not detected',
+      0x001f: 'Flash fired, auto mode, return light detected',
+      0x0020: 'No flash function',
+      0x0041: 'Flash fired, red-eye reduction mode',
+      0x0045: 'Flash fired, red-eye reduction mode, return light not detected',
+      0x0047: 'Flash fired, red-eye reduction mode, return light detected',
+      0x0049: 'Flash fired, compulsory flash mode, red-eye reduction mode',
+      0x004d: 'Flash fired, compulsory flash mode, red-eye reduction mode, return light not detected',
+      0x004f: 'Flash fired, compulsory flash mode, red-eye reduction mode, return light detected',
+      0x0059: 'Flash fired, auto mode, red-eye reduction mode',
+      0x005d: 'Flash fired, auto mode, return light not detected, red-eye reduction mode',
+      0x005f: 'Flash fired, auto mode, return light detected, red-eye reduction mode'
+    },
+    SensingMethod: {
+      1: 'Undefined',
+      2: 'One-chip color area sensor',
+      3: 'Two-chip color area sensor',
+      4: 'Three-chip color area sensor',
+      5: 'Color sequential area sensor',
+      7: 'Trilinear sensor',
+      8: 'Color sequential linear sensor'
+    },
+    SceneCaptureType: {
+      0: 'Standard',
+      1: 'Landscape',
+      2: 'Portrait',
+      3: 'Night scene'
+    },
+    SceneType: {
+      1: 'Directly photographed'
+    },
+    CustomRendered: {
+      0: 'Normal process',
+      1: 'Custom process'
+    },
+    WhiteBalance: {
+      0: 'Auto white balance',
+      1: 'Manual white balance'
+    },
+    GainControl: {
+      0: 'None',
+      1: 'Low gain up',
+      2: 'High gain up',
+      3: 'Low gain down',
+      4: 'High gain down'
+    },
+    Contrast: {
+      0: 'Normal',
+      1: 'Soft',
+      2: 'Hard'
+    },
+    Saturation: {
+      0: 'Normal',
+      1: 'Low saturation',
+      2: 'High saturation'
+    },
+    Sharpness: {
+      0: 'Normal',
+      1: 'Soft',
+      2: 'Hard'
+    },
+    SubjectDistanceRange: {
+      0: 'Unknown',
+      1: 'Macro',
+      2: 'Close view',
+      3: 'Distant view'
+    },
+    FileSource: {
+      3: 'DSC'
+    },
+    ComponentsConfiguration: {
+      0: '',
+      1: 'Y',
+      2: 'Cb',
+      3: 'Cr',
+      4: 'R',
+      5: 'G',
+      6: 'B'
+    },
+    Orientation: {
+      1: 'Original',
+      2: 'Horizontal flip',
+      3: 'Rotate 180° CCW',
+      4: 'Vertical flip',
+      5: 'Vertical flip + Rotate 90° CW',
+      6: 'Rotate 90° CW',
+      7: 'Horizontal flip + Rotate 90° CW',
+      8: 'Rotate 90° CCW'
+    }
+  }
+
+  ExifMapProto.getText = function (name) {
+    var value = this.get(name)
+    switch (name) {
+      case 'LightSource':
+      case 'Flash':
+      case 'MeteringMode':
+      case 'ExposureProgram':
+      case 'SensingMethod':
+      case 'SceneCaptureType':
+      case 'SceneType':
+      case 'CustomRendered':
+      case 'WhiteBalance':
+      case 'GainControl':
+      case 'Contrast':
+      case 'Saturation':
+      case 'Sharpness':
+      case 'SubjectDistanceRange':
+      case 'FileSource':
+      case 'Orientation':
+        return this.stringValues[name][value]
+      case 'ExifVersion':
+      case 'FlashpixVersion':
+        if (!value) return
+        return String.fromCharCode(value[0], value[1], value[2], value[3])
+      case 'ComponentsConfiguration':
+        if (!value) return
+        return (
+          this.stringValues[name][value[0]] +
+          this.stringValues[name][value[1]] +
+          this.stringValues[name][value[2]] +
+          this.stringValues[name][value[3]]
+        )
+      case 'GPSVersionID':
+        if (!value) return
+        return value[0] + '.' + value[1] + '.' + value[2] + '.' + value[3]
+    }
+    return String(value)
+  }
+
+  ExifMapProto.getAll = function () {
+    var map = {}
+    var prop
+    var obj
+    var name
+    for (prop in this) {
+      if (Object.prototype.hasOwnProperty.call(this, prop)) {
+        obj = this[prop]
+        if (obj && obj.getAll) {
+          map[this.ifds[prop].name] = obj.getAll()
+        } else {
+          name = this.tags[prop]
+          if (name) map[name] = this.getText(name)
+        }
+      }
+    }
+    return map
+  }
+
+  ExifMapProto.getName = function (tagCode) {
+    var name = this.tags[tagCode]
+    if (typeof name === 'object') return this.ifds[tagCode].name
+    return name
+  }
+
+  // Extend the map of tag names to tag codes:
+  ;(function () {
+    var tags = ExifMapProto.tags
+    var prop
+    var ifd
+    var subTags
+    // Map the tag names to tags:
+    for (prop in tags) {
+      if (Object.prototype.hasOwnProperty.call(tags, prop)) {
+        ifd = ExifMapProto.ifds[prop]
+        if (ifd) {
+          subTags = tags[prop]
+          for (prop in subTags) {
+            if (Object.prototype.hasOwnProperty.call(subTags, prop)) {
+              ifd.map[subTags[prop]] = Number(prop)
+            }
+          }
+        } else {
+          ExifMapProto.map[tags[prop]] = Number(prop)
+        }
+      }
+    }
+  })()
+})

app/Resources/public/assets/blueimp-load-image/js/load-image-exif.js

@@ -0,0 +1,460 @@
+/*
+ * JavaScript Load Image Exif Parser
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ */
+
+/* global define, module, require, DataView */
+
+/* eslint-disable no-console */
+
+;(function (factory) {
+  'use strict'
+  if (typeof define === 'function' && define.amd) {
+    // Register as an anonymous AMD module:
+    define(['./load-image', './load-image-meta'], factory)
+  } else if (typeof module === 'object' && module.exports) {
+    factory(require('./load-image'), require('./load-image-meta'))
+  } else {
+    // Browser globals:
+    factory(window.loadImage)
+  }
+})(function (loadImage) {
+  'use strict'
+
+  /**
+   * Exif tag map
+   *
+   * @name ExifMap
+   * @class
+   * @param {number|string} tagCode IFD tag code
+   */
+  function ExifMap(tagCode) {
+    if (tagCode) {
+      Object.defineProperty(this, 'map', {
+        value: this.ifds[tagCode].map
+      })
+      Object.defineProperty(this, 'tags', {
+        value: (this.tags && this.tags[tagCode]) || {}
+      })
+    }
+  }
+
+  ExifMap.prototype.map = {
+    Orientation: 0x0112,
+    Thumbnail: 'ifd1',
+    Blob: 0x0201, // Alias for JPEGInterchangeFormat
+    Exif: 0x8769,
+    GPSInfo: 0x8825,
+    Interoperability: 0xa005
+  }
+
+  ExifMap.prototype.ifds = {
+    ifd1: { name: 'Thumbnail', map: ExifMap.prototype.map },
+    0x8769: { name: 'Exif', map: {} },
+    0x8825: { name: 'GPSInfo', map: {} },
+    0xa005: { name: 'Interoperability', map: {} }
+  }
+
+  /**
+   * Retrieves exif tag value
+   *
+   * @param {number|string} id Exif tag code or name
+   * @returns {object} Exif tag value
+   */
+  ExifMap.prototype.get = function (id) {
+    return this[id] || this[this.map[id]]
+  }
+
+  /**
+   * Returns the Exif Thumbnail data as Blob.
+   *
+   * @param {DataView} dataView Data view interface
+   * @param {number} offset Thumbnail data offset
+   * @param {number} length Thumbnail data length
+   * @returns {undefined|Blob} Returns the Thumbnail Blob or undefined
+   */
+  function getExifThumbnail(dataView, offset, length) {
+    if (!length) return
+    if (offset + length > dataView.byteLength) {
+      console.log('Invalid Exif data: Invalid thumbnail data.')
+      return
+    }
+    return new Blob(
+      [loadImage.bufferSlice.call(dataView.buffer, offset, offset + length)],
+      {
+        type: 'image/jpeg'
+      }
+    )
+  }
+
+  var ExifTagTypes = {
+    // byte, 8-bit unsigned int:
+    1: {
+      getValue: function (dataView, dataOffset) {
+        return dataView.getUint8(dataOffset)
+      },
+      size: 1
+    },
+    // ascii, 8-bit byte:
+    2: {
+      getValue: function (dataView, dataOffset) {
+        return String.fromCharCode(dataView.getUint8(dataOffset))
+      },
+      size: 1,
+      ascii: true
+    },
+    // short, 16 bit int:
+    3: {
+      getValue: function (dataView, dataOffset, littleEndian) {
+        return dataView.getUint16(dataOffset, littleEndian)
+      },
+      size: 2
+    },
+    // long, 32 bit int:
+    4: {
+      getValue: function (dataView, dataOffset, littleEndian) {
+        return dataView.getUint32(dataOffset, littleEndian)
+      },
+      size: 4
+    },
+    // rational = two long values, first is numerator, second is denominator:
+    5: {
+      getValue: function (dataView, dataOffset, littleEndian) {
+        return (
+          dataView.getUint32(dataOffset, littleEndian) /
+          dataView.getUint32(dataOffset + 4, littleEndian)
+        )
+      },
+      size: 8
+    },
+    // slong, 32 bit signed int:
+    9: {
+      getValue: function (dataView, dataOffset, littleEndian) {
+        return dataView.getInt32(dataOffset, littleEndian)
+      },
+      size: 4
+    },
+    // srational, two slongs, first is numerator, second is denominator:
+    10: {
+      getValue: function (dataView, dataOffset, littleEndian) {
+        return (
+          dataView.getInt32(dataOffset, littleEndian) /
+          dataView.getInt32(dataOffset + 4, littleEndian)
+        )
+      },
+      size: 8
+    }
+  }
+  // undefined, 8-bit byte, value depending on field:
+  ExifTagTypes[7] = ExifTagTypes[1]
+
+  /**
+   * Returns Exif tag value.
+   *
+   * @param {DataView} dataView Data view interface
+   * @param {number} tiffOffset TIFF offset
+   * @param {number} offset Tag offset
+   * @param {number} type Tag type
+   * @param {number} length Tag length
+   * @param {boolean} littleEndian Little endian encoding
+   * @returns {object} Tag value
+   */
+  function getExifValue(
+    dataView,
+    tiffOffset,
+    offset,
+    type,
+    length,
+    littleEndian
+  ) {
+    var tagType = ExifTagTypes[type]
+    var tagSize
+    var dataOffset
+    var values
+    var i
+    var str
+    var c
+    if (!tagType) {
+      console.log('Invalid Exif data: Invalid tag type.')
+      return
+    }
+    tagSize = tagType.size * length
+    // Determine if the value is contained in the dataOffset bytes,
+    // or if the value at the dataOffset is a pointer to the actual data:
+    dataOffset =
+      tagSize > 4
+        ? tiffOffset + dataView.getUint32(offset + 8, littleEndian)
+        : offset + 8
+    if (dataOffset + tagSize > dataView.byteLength) {
+      console.log('Invalid Exif data: Invalid data offset.')
+      return
+    }
+    if (length === 1) {
+      return tagType.getValue(dataView, dataOffset, littleEndian)
+    }
+    values = []
+    for (i = 0; i < length; i += 1) {
+      values[i] = tagType.getValue(
+        dataView,
+        dataOffset + i * tagType.size,
+        littleEndian
+      )
+    }
+    if (tagType.ascii) {
+      str = ''
+      // Concatenate the chars:
+      for (i = 0; i < values.length; i += 1) {
+        c = values[i]
+        // Ignore the terminating NULL byte(s):
+        if (c === '\u0000') {
+          break
+        }
+        str += c
+      }
+      return str
+    }
+    return values
+  }
+
+  /**
+   * Determines if the given tag should be included.
+   *
+   * @param {object} includeTags Map of tags to include
+   * @param {object} excludeTags Map of tags to exclude
+   * @param {number|string} tagCode Tag code to check
+   * @returns {boolean} True if the tag should be included
+   */
+  function shouldIncludeTag(includeTags, excludeTags, tagCode) {
+    return (
+      (!includeTags || includeTags[tagCode]) &&
+      (!excludeTags || excludeTags[tagCode] !== true)
+    )
+  }
+
+  /**
+   * Parses Exif tags.
+   *
+   * @param {DataView} dataView Data view interface
+   * @param {number} tiffOffset TIFF offset
+   * @param {number} dirOffset Directory offset
+   * @param {boolean} littleEndian Little endian encoding
+   * @param {ExifMap} tags Map to store parsed exif tags
+   * @param {ExifMap} tagOffsets Map to store parsed exif tag offsets
+   * @param {object} includeTags Map of tags to include
+   * @param {object} excludeTags Map of tags to exclude
+   * @returns {number} Next directory offset
+   */
+  function parseExifTags(
+    dataView,
+    tiffOffset,
+    dirOffset,
+    littleEndian,
+    tags,
+    tagOffsets,
+    includeTags,
+    excludeTags
+  ) {
+    var tagsNumber, dirEndOffset, i, tagOffset, tagNumber, tagValue
+    if (dirOffset + 6 > dataView.byteLength) {
+      console.log('Invalid Exif data: Invalid directory offset.')
+      return
+    }
+    tagsNumber = dataView.getUint16(dirOffset, littleEndian)
+    dirEndOffset = dirOffset + 2 + 12 * tagsNumber
+    if (dirEndOffset + 4 > dataView.byteLength) {
+      console.log('Invalid Exif data: Invalid directory size.')
+      return
+    }
+    for (i = 0; i < tagsNumber; i += 1) {
+      tagOffset = dirOffset + 2 + 12 * i
+      tagNumber = dataView.getUint16(tagOffset, littleEndian)
+      if (!shouldIncludeTag(includeTags, excludeTags, tagNumber)) continue
+      tagValue = getExifValue(
+        dataView,
+        tiffOffset,
+        tagOffset,
+        dataView.getUint16(tagOffset + 2, littleEndian), // tag type
+        dataView.getUint32(tagOffset + 4, littleEndian), // tag length
+        littleEndian
+      )
+      tags[tagNumber] = tagValue
+      if (tagOffsets) {
+        tagOffsets[tagNumber] = tagOffset
+      }
+    }
+    // Return the offset to the next directory:
+    return dataView.getUint32(dirEndOffset, littleEndian)
+  }
+
+  /**
+   * Parses tags in a given IFD (Image File Directory).
+   *
+   * @param {object} data Data object to store exif tags and offsets
+   * @param {number|string} tagCode IFD tag code
+   * @param {DataView} dataView Data view interface
+   * @param {number} tiffOffset TIFF offset
+   * @param {boolean} littleEndian Little endian encoding
+   * @param {object} includeTags Map of tags to include
+   * @param {object} excludeTags Map of tags to exclude
+   */
+  function parseExifIFD(
+    data,
+    tagCode,
+    dataView,
+    tiffOffset,
+    littleEndian,
+    includeTags,
+    excludeTags
+  ) {
+    var dirOffset = data.exif[tagCode]
+    if (dirOffset) {
+      data.exif[tagCode] = new ExifMap(tagCode)
+      if (data.exifOffsets) {
+        data.exifOffsets[tagCode] = new ExifMap(tagCode)
+      }
+      parseExifTags(
+        dataView,
+        tiffOffset,
+        tiffOffset + dirOffset,
+        littleEndian,
+        data.exif[tagCode],
+        data.exifOffsets && data.exifOffsets[tagCode],
+        includeTags && includeTags[tagCode],
+        excludeTags && excludeTags[tagCode]
+      )
+    }
+  }
+
+  loadImage.parseExifData = function (dataView, offset, length, data, options) {
+    if (options.disableExif) {
+      return
+    }
+    var includeTags = options.includeExifTags
+    var excludeTags = options.excludeExifTags || {
+      0x8769: {
+        // ExifIFDPointer
+        0x927c: true // MakerNote
+      }
+    }
+    var tiffOffset = offset + 10
+    var littleEndian
+    var dirOffset
+    var thumbnailIFD
+    // Check for the ASCII code for "Exif" (0x45786966):
+    if (dataView.getUint32(offset + 4) !== 0x45786966) {
+      // No Exif data, might be XMP data instead
+      return
+    }
+    if (tiffOffset + 8 > dataView.byteLength) {
+      console.log('Invalid Exif data: Invalid segment size.')
+      return
+    }
+    // Check for the two null bytes:
+    if (dataView.getUint16(offset + 8) !== 0x0000) {
+      console.log('Invalid Exif data: Missing byte alignment offset.')
+      return
+    }
+    // Check the byte alignment:
+    switch (dataView.getUint16(tiffOffset)) {
+      case 0x4949:
+        littleEndian = true
+        break
+      case 0x4d4d:
+        littleEndian = false
+        break
+      default:
+        console.log('Invalid Exif data: Invalid byte alignment marker.')
+        return
+    }
+    // Check for the TIFF tag marker (0x002A):
+    if (dataView.getUint16(tiffOffset + 2, littleEndian) !== 0x002a) {
+      console.log('Invalid Exif data: Missing TIFF marker.')
+      return
+    }
+    // Retrieve the directory offset bytes, usually 0x00000008 or 8 decimal:
+    dirOffset = dataView.getUint32(tiffOffset + 4, littleEndian)
+    // Create the exif object to store the tags:
+    data.exif = new ExifMap()
+    if (!options.disableExifOffsets) {
+      data.exifOffsets = new ExifMap()
+      data.exifTiffOffset = tiffOffset
+      data.exifLittleEndian = littleEndian
+    }
+    // Parse the tags of the main image directory (IFD0) and retrieve the
+    // offset to the next directory (IFD1), usually the thumbnail directory:
+    dirOffset = parseExifTags(
+      dataView,
+      tiffOffset,
+      tiffOffset + dirOffset,
+      littleEndian,
+      data.exif,
+      data.exifOffsets,
+      includeTags,
+      excludeTags
+    )
+    if (dirOffset && shouldIncludeTag(includeTags, excludeTags, 'ifd1')) {
+      data.exif.ifd1 = dirOffset
+      if (data.exifOffsets) {
+        data.exifOffsets.ifd1 = tiffOffset + dirOffset
+      }
+    }
+    Object.keys(data.exif.ifds).forEach(function (tagCode) {
+      parseExifIFD(
+        data,
+        tagCode,
+        dataView,
+        tiffOffset,
+        littleEndian,
+        includeTags,
+        excludeTags
+      )
+    })
+    thumbnailIFD = data.exif.ifd1
+    // Check for JPEG Thumbnail offset and data length:
+    if (thumbnailIFD && thumbnailIFD[0x0201]) {
+      thumbnailIFD[0x0201] = getExifThumbnail(
+        dataView,
+        tiffOffset + thumbnailIFD[0x0201],
+        thumbnailIFD[0x0202] // Thumbnail data length
+      )
+    }
+  }
+
+  // Registers the Exif parser for the APP1 JPEG metadata segment:
+  loadImage.metaDataParsers.jpeg[0xffe1].push(loadImage.parseExifData)
+
+  loadImage.exifWriters = {
+    // Orientation writer:
+    0x0112: function (buffer, data, value) {
+      var orientationOffset = data.exifOffsets[0x0112]
+      if (!orientationOffset) return buffer
+      var view = new DataView(buffer, orientationOffset + 8, 2)
+      view.setUint16(0, value, data.exifLittleEndian)
+      return buffer
+    }
+  }
+
+  loadImage.writeExifData = function (buffer, data, id, value) {
+    return loadImage.exifWriters[data.exif.map[id]](buffer, data, value)
+  }
+
+  loadImage.ExifMap = ExifMap
+
+  // Adds the following properties to the parseMetaData callback data:
+  // - exif: The parsed Exif tags
+  // - exifOffsets: The parsed Exif tag offsets
+  // - exifTiffOffset: TIFF header offset (used for offset pointers)
+  // - exifLittleEndian: little endian order if true, big endian if false
+
+  // Adds the following options to the parseMetaData method:
+  // - disableExif: Disables Exif parsing when true.
+  // - disableExifOffsets: Disables storing Exif tag offsets when true.
+  // - includeExifTags: A map of Exif tags to include for parsing.
+  // - excludeExifTags: A map of Exif tags to exclude from parsing.
+})

app/Resources/public/assets/blueimp-load-image/js/load-image-fetch.js

@@ -0,0 +1,103 @@
+/*
+ * JavaScript Load Image Fetch
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2017, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ */
+
+/* global define, module, require, Promise */
+
+;(function (factory) {
+  'use strict'
+  if (typeof define === 'function' && define.amd) {
+    // Register as an anonymous AMD module:
+    define(['./load-image'], factory)
+  } else if (typeof module === 'object' && module.exports) {
+    factory(require('./load-image'))
+  } else {
+    // Browser globals:
+    factory(window.loadImage)
+  }
+})(function (loadImage) {
+  'use strict'
+
+  var global = loadImage.global
+
+  if (
+    global.fetch &&
+    global.Request &&
+    global.Response &&
+    global.Response.prototype.blob
+  ) {
+    loadImage.fetchBlob = function (url, callback, options) {
+      /**
+       * Fetch response handler.
+       *
+       * @param {Response} response Fetch response
+       * @returns {Blob} Fetched Blob.
+       */
+      function responseHandler(response) {
+        return response.blob()
+      }
+      if (global.Promise && typeof callback !== 'function') {
+        return fetch(new Request(url, callback)).then(responseHandler)
+      }
+      fetch(new Request(url, options))
+        .then(responseHandler)
+        .then(callback)
+        [
+          // Avoid parsing error in IE<9, where catch is a reserved word.
+          // eslint-disable-next-line dot-notation
+          'catch'
+        ](function (err) {
+          callback(null, err)
+        })
+    }
+  } else if (
+    global.XMLHttpRequest &&
+    // https://xhr.spec.whatwg.org/#the-responsetype-attribute
+    new XMLHttpRequest().responseType === ''
+  ) {
+    loadImage.fetchBlob = function (url, callback, options) {
+      /**
+       * Promise executor
+       *
+       * @param {Function} resolve Resolution function
+       * @param {Function} reject Rejection function
+       */
+      function executor(resolve, reject) {
+        options = options || {} // eslint-disable-line no-param-reassign
+        var req = new XMLHttpRequest()
+        req.open(options.method || 'GET', url)
+        if (options.headers) {
+          Object.keys(options.headers).forEach(function (key) {
+            req.setRequestHeader(key, options.headers[key])
+          })
+        }
+        req.withCredentials = options.credentials === 'include'
+        req.responseType = 'blob'
+        req.onload = function () {
+          resolve(req.response)
+        }
+        req.onerror = req.onabort = req.ontimeout = function (err) {
+          if (resolve === reject) {
+            // Not using Promises
+            reject(null, err)
+          } else {
+            reject(err)
+          }
+        }
+        req.send(options.body)
+      }
+      if (global.Promise && typeof callback !== 'function') {
+        options = callback // eslint-disable-line no-param-reassign
+        return new Promise(executor)
+      }
+      return executor(callback, callback)
+    }
+  }
+})

app/Resources/public/assets/blueimp-load-image/js/load-image-iptc-map.js

@@ -0,0 +1,169 @@
+/*
+ * JavaScript Load Image IPTC Map
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2013, Sebastian Tschan
+ * Copyright 2018, Dave Bevan
+ *
+ * IPTC tags mapping based on
+ * https://iptc.org/standards/photo-metadata
+ * https://exiftool.org/TagNames/IPTC.html
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ */
+
+/* global define, module, require */
+
+;(function (factory) {
+  'use strict'
+  if (typeof define === 'function' && define.amd) {
+    // Register as an anonymous AMD module:
+    define(['./load-image', './load-image-iptc'], factory)
+  } else if (typeof module === 'object' && module.exports) {
+    factory(require('./load-image'), require('./load-image-iptc'))
+  } else {
+    // Browser globals:
+    factory(window.loadImage)
+  }
+})(function (loadImage) {
+  'use strict'
+
+  var IptcMapProto = loadImage.IptcMap.prototype
+
+  IptcMapProto.tags = {
+    0: 'ApplicationRecordVersion',
+    3: 'ObjectTypeReference',
+    4: 'ObjectAttributeReference',
+    5: 'ObjectName',
+    7: 'EditStatus',
+    8: 'EditorialUpdate',
+    10: 'Urgency',
+    12: 'SubjectReference',
+    15: 'Category',
+    20: 'SupplementalCategories',
+    22: 'FixtureIdentifier',
+    25: 'Keywords',
+    26: 'ContentLocationCode',
+    27: 'ContentLocationName',
+    30: 'ReleaseDate',
+    35: 'ReleaseTime',
+    37: 'ExpirationDate',
+    38: 'ExpirationTime',
+    40: 'SpecialInstructions',
+    42: 'ActionAdvised',
+    45: 'ReferenceService',
+    47: 'ReferenceDate',
+    50: 'ReferenceNumber',
+    55: 'DateCreated',
+    60: 'TimeCreated',
+    62: 'DigitalCreationDate',
+    63: 'DigitalCreationTime',
+    65: 'OriginatingProgram',
+    70: 'ProgramVersion',
+    75: 'ObjectCycle',
+    80: 'Byline',
+    85: 'BylineTitle',
+    90: 'City',
+    92: 'Sublocation',
+    95: 'State',
+    100: 'CountryCode',
+    101: 'Country',
+    103: 'OriginalTransmissionReference',
+    105: 'Headline',
+    110: 'Credit',
+    115: 'Source',
+    116: 'CopyrightNotice',
+    118: 'Contact',
+    120: 'Caption',
+    121: 'LocalCaption',
+    122: 'Writer',
+    125: 'RasterizedCaption',
+    130: 'ImageType',
+    131: 'ImageOrientation',
+    135: 'LanguageIdentifier',
+    150: 'AudioType',
+    151: 'AudioSamplingRate',
+    152: 'AudioSamplingResolution',
+    153: 'AudioDuration',
+    154: 'AudioOutcue',
+    184: 'JobID',
+    185: 'MasterDocumentID',
+    186: 'ShortDocumentID',
+    187: 'UniqueDocumentID',
+    188: 'OwnerID',
+    200: 'ObjectPreviewFileFormat',
+    201: 'ObjectPreviewFileVersion',
+    202: 'ObjectPreviewData',
+    221: 'Prefs',
+    225: 'ClassifyState',
+    228: 'SimilarityIndex',
+    230: 'DocumentNotes',
+    231: 'DocumentHistory',
+    232: 'ExifCameraInfo',
+    255: 'CatalogSets'
+  }
+
+  IptcMapProto.stringValues = {
+    10: {
+      0: '0 (reserved)',
+      1: '1 (most urgent)',
+      2: '2',
+      3: '3',
+      4: '4',
+      5: '5 (normal urgency)',
+      6: '6',
+      7: '7',
+      8: '8 (least urgent)',
+      9: '9 (user-defined priority)'
+    },
+    75: {
+      a: 'Morning',
+      b: 'Both Morning and Evening',
+      p: 'Evening'
+    },
+    131: {
+      L: 'Landscape',
+      P: 'Portrait',
+      S: 'Square'
+    }
+  }
+
+  IptcMapProto.getText = function (id) {
+    var value = this.get(id)
+    var tagCode = this.map[id]
+    var stringValue = this.stringValues[tagCode]
+    if (stringValue) return stringValue[value]
+    return String(value)
+  }
+
+  IptcMapProto.getAll = function () {
+    var map = {}
+    var prop
+    var name
+    for (prop in this) {
+      if (Object.prototype.hasOwnProperty.call(this, prop)) {
+        name = this.tags[prop]
+        if (name) map[name] = this.getText(name)
+      }
+    }
+    return map
+  }
+
+  IptcMapProto.getName = function (tagCode) {
+    return this.tags[tagCode]
+  }
+
+  // Extend the map of tag names to tag codes:
+  ;(function () {
+    var tags = IptcMapProto.tags
+    var map = IptcMapProto.map || {}
+    var prop
+    // Map the tag names to tags:
+    for (prop in tags) {
+      if (Object.prototype.hasOwnProperty.call(tags, prop)) {
+        map[tags[prop]] = Number(prop)
+      }
+    }
+  })()
+})

app/Resources/public/assets/blueimp-load-image/js/load-image-iptc.js

@@ -0,0 +1,239 @@
+/*
+ * JavaScript Load Image IPTC Parser
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2013, Sebastian Tschan
+ * Copyright 2018, Dave Bevan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ */
+
+/* global define, module, require, DataView */
+
+;(function (factory) {
+  'use strict'
+  if (typeof define === 'function' && define.amd) {
+    // Register as an anonymous AMD module:
+    define(['./load-image', './load-image-meta'], factory)
+  } else if (typeof module === 'object' && module.exports) {
+    factory(require('./load-image'), require('./load-image-meta'))
+  } else {
+    // Browser globals:
+    factory(window.loadImage)
+  }
+})(function (loadImage) {
+  'use strict'
+
+  /**
+   * IPTC tag map
+   *
+   * @name IptcMap
+   * @class
+   */
+  function IptcMap() {}
+
+  IptcMap.prototype.map = {
+    ObjectName: 5
+  }
+
+  IptcMap.prototype.types = {
+    0: 'Uint16', // ApplicationRecordVersion
+    200: 'Uint16', // ObjectPreviewFileFormat
+    201: 'Uint16', // ObjectPreviewFileVersion
+    202: 'binary' // ObjectPreviewData
+  }
+
+  /**
+   * Retrieves IPTC tag value
+   *
+   * @param {number|string} id IPTC tag code or name
+   * @returns {object} IPTC tag value
+   */
+  IptcMap.prototype.get = function (id) {
+    return this[id] || this[this.map[id]]
+  }
+
+  /**
+   * Retrieves string for the given DataView and range
+   *
+   * @param {DataView} dataView Data view interface
+   * @param {number} offset Offset start
+   * @param {number} length Offset length
+   * @returns {string} String value
+   */
+  function getStringValue(dataView, offset, length) {
+    var outstr = ''
+    var end = offset + length
+    for (var n = offset; n < end; n += 1) {
+      outstr += String.fromCharCode(dataView.getUint8(n))
+    }
+    return outstr
+  }
+
+  /**
+   * Retrieves tag value for the given DataView and range
+   *
+   * @param {number} tagCode tag code
+   * @param {IptcMap} map IPTC tag map
+   * @param {DataView} dataView Data view interface
+   * @param {number} offset Range start
+   * @param {number} length Range length
+   * @returns {object} Tag value
+   */
+  function getTagValue(tagCode, map, dataView, offset, length) {
+    if (map.types[tagCode] === 'binary') {
+      return new Blob([dataView.buffer.slice(offset, offset + length)])
+    }
+    if (map.types[tagCode] === 'Uint16') {
+      return dataView.getUint16(offset)
+    }
+    return getStringValue(dataView, offset, length)
+  }
+
+  /**
+   * Combines IPTC value with existing ones.
+   *
+   * @param {object} value Existing IPTC field value
+   * @param {object} newValue New IPTC field value
+   * @returns {object} Resulting IPTC field value
+   */
+  function combineTagValues(value, newValue) {
+    if (value === undefined) return newValue
+    if (value instanceof Array) {
+      value.push(newValue)
+      return value
+    }
+    return [value, newValue]
+  }
+
+  /**
+   * Parses IPTC tags.
+   *
+   * @param {DataView} dataView Data view interface
+   * @param {number} segmentOffset Segment offset
+   * @param {number} segmentLength Segment length
+   * @param {object} data Data export object
+   * @param {object} includeTags Map of tags to include
+   * @param {object} excludeTags Map of tags to exclude
+   */
+  function parseIptcTags(
+    dataView,
+    segmentOffset,
+    segmentLength,
+    data,
+    includeTags,
+    excludeTags
+  ) {
+    var value, tagSize, tagCode
+    var segmentEnd = segmentOffset + segmentLength
+    var offset = segmentOffset
+    while (offset < segmentEnd) {
+      if (
+        dataView.getUint8(offset) === 0x1c && // tag marker
+        dataView.getUint8(offset + 1) === 0x02 // record number, only handles v2
+      ) {
+        tagCode = dataView.getUint8(offset + 2)
+        if (
+          (!includeTags || includeTags[tagCode]) &&
+          (!excludeTags || !excludeTags[tagCode])
+        ) {
+          tagSize = dataView.getInt16(offset + 3)
+          value = getTagValue(tagCode, data.iptc, dataView, offset + 5, tagSize)
+          data.iptc[tagCode] = combineTagValues(data.iptc[tagCode], value)
+          if (data.iptcOffsets) {
+            data.iptcOffsets[tagCode] = offset
+          }
+        }
+      }
+      offset += 1
+    }
+  }
+
+  /**
+   * Tests if field segment starts at offset.
+   *
+   * @param {DataView} dataView Data view interface
+   * @param {number} offset Segment offset
+   * @returns {boolean} True if '8BIM<EOT><EOT>' exists at offset
+   */
+  function isSegmentStart(dataView, offset) {
+    return (
+      dataView.getUint32(offset) === 0x3842494d && // Photoshop segment start
+      dataView.getUint16(offset + 4) === 0x0404 // IPTC segment start
+    )
+  }
+
+  /**
+   * Returns header length.
+   *
+   * @param {DataView} dataView Data view interface
+   * @param {number} offset Segment offset
+   * @returns {number} Header length
+   */
+  function getHeaderLength(dataView, offset) {
+    var length = dataView.getUint8(offset + 7)
+    if (length % 2 !== 0) length += 1
+    // Check for pre photoshop 6 format
+    if (length === 0) {
+      // Always 4
+      length = 4
+    }
+    return length
+  }
+
+  loadImage.parseIptcData = function (dataView, offset, length, data, options) {
+    if (options.disableIptc) {
+      return
+    }
+    var markerLength = offset + length
+    while (offset + 8 < markerLength) {
+      if (isSegmentStart(dataView, offset)) {
+        var headerLength = getHeaderLength(dataView, offset)
+        var segmentOffset = offset + 8 + headerLength
+        if (segmentOffset > markerLength) {
+          // eslint-disable-next-line no-console
+          console.log('Invalid IPTC data: Invalid segment offset.')
+          break
+        }
+        var segmentLength = dataView.getUint16(offset + 6 + headerLength)
+        if (offset + segmentLength > markerLength) {
+          // eslint-disable-next-line no-console
+          console.log('Invalid IPTC data: Invalid segment size.')
+          break
+        }
+        // Create the iptc object to store the tags:
+        data.iptc = new IptcMap()
+        if (!options.disableIptcOffsets) {
+          data.iptcOffsets = new IptcMap()
+        }
+        parseIptcTags(
+          dataView,
+          segmentOffset,
+          segmentLength,
+          data,
+          options.includeIptcTags,
+          options.excludeIptcTags || { 202: true } // ObjectPreviewData
+        )
+        return
+      }
+      // eslint-disable-next-line no-param-reassign
+      offset += 1
+    }
+  }
+
+  // Registers this IPTC parser for the APP13 JPEG metadata segment:
+  loadImage.metaDataParsers.jpeg[0xffed].push(loadImage.parseIptcData)
+
+  loadImage.IptcMap = IptcMap
+
+  // Adds the following properties to the parseMetaData callback data:
+  // - iptc: The iptc tags, parsed by the parseIptcData method
+
+  // Adds the following options to the parseMetaData method:
+  // - disableIptc: Disables IPTC parsing when true.
+  // - disableIptcOffsets: Disables storing IPTC tag offsets when true.
+  // - includeIptcTags: A map of IPTC tags to include for parsing.
+  // - excludeIptcTags: A map of IPTC tags to exclude from parsing.
+})

app/Resources/public/assets/blueimp-load-image/js/load-image-meta.js

@@ -0,0 +1,259 @@
+/*
+ * JavaScript Load Image Meta
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Image metadata handling implementation
+ * based on the help and contribution of
+ * Achim Stöhr.
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ */
+
+/* global define, module, require, Promise, DataView, Uint8Array, ArrayBuffer */
+
+;(function (factory) {
+  'use strict'
+  if (typeof define === 'function' && define.amd) {
+    // Register as an anonymous AMD module:
+    define(['./load-image'], factory)
+  } else if (typeof module === 'object' && module.exports) {
+    factory(require('./load-image'))
+  } else {
+    // Browser globals:
+    factory(window.loadImage)
+  }
+})(function (loadImage) {
+  'use strict'
+
+  var global = loadImage.global
+  var originalTransform = loadImage.transform
+
+  var blobSlice =
+    global.Blob &&
+    (Blob.prototype.slice ||
+      Blob.prototype.webkitSlice ||
+      Blob.prototype.mozSlice)
+
+  var bufferSlice =
+    (global.ArrayBuffer && ArrayBuffer.prototype.slice) ||
+    function (begin, end) {
+      // Polyfill for IE10, which does not support ArrayBuffer.slice
+      // eslint-disable-next-line no-param-reassign
+      end = end || this.byteLength - begin
+      var arr1 = new Uint8Array(this, begin, end)
+      var arr2 = new Uint8Array(end)
+      arr2.set(arr1)
+      return arr2.buffer
+    }
+
+  var metaDataParsers = {
+    jpeg: {
+      0xffe1: [], // APP1 marker
+      0xffed: [] // APP13 marker
+    }
+  }
+
+  /**
+   * Parses image metadata and calls the callback with an object argument
+   * with the following property:
+   * - imageHead: The complete image head as ArrayBuffer
+   * The options argument accepts an object and supports the following
+   * properties:
+   * - maxMetaDataSize: Defines the maximum number of bytes to parse.
+   * - disableImageHead: Disables creating the imageHead property.
+   *
+   * @param {Blob} file Blob object
+   * @param {Function} [callback] Callback function
+   * @param {object} [options] Parsing options
+   * @param {object} [data] Result data object
+   * @returns {Promise<object>|undefined} Returns Promise if no callback given.
+   */
+  function parseMetaData(file, callback, options, data) {
+    var that = this
+    /**
+     * Promise executor
+     *
+     * @param {Function} resolve Resolution function
+     * @param {Function} reject Rejection function
+     * @returns {undefined} Undefined
+     */
+    function executor(resolve, reject) {
+      if (
+        !(
+          global.DataView &&
+          blobSlice &&
+          file &&
+          file.size >= 12 &&
+          file.type === 'image/jpeg'
+        )
+      ) {
+        // Nothing to parse
+        return resolve(data)
+      }
+      // 256 KiB should contain all EXIF/ICC/IPTC segments:
+      var maxMetaDataSize = options.maxMetaDataSize || 262144
+      if (
+        !loadImage.readFile(
+          blobSlice.call(file, 0, maxMetaDataSize),
+          function (buffer) {
+            // Note on endianness:
+            // Since the marker and length bytes in JPEG files are always
+            // stored in big endian order, we can leave the endian parameter
+            // of the DataView methods undefined, defaulting to big endian.
+            var dataView = new DataView(buffer)
+            // Check for the JPEG marker (0xffd8):
+            if (dataView.getUint16(0) !== 0xffd8) {
+              return reject(
+                new Error('Invalid JPEG file: Missing JPEG marker.')
+              )
+            }
+            var offset = 2
+            var maxOffset = dataView.byteLength - 4
+            var headLength = offset
+            var markerBytes
+            var markerLength
+            var parsers
+            var i
+            while (offset < maxOffset) {
+              markerBytes = dataView.getUint16(offset)
+              // Search for APPn (0xffeN) and COM (0xfffe) markers,
+              // which contain application-specific metadata like
+              // Exif, ICC and IPTC data and text comments:
+              if (
+                (markerBytes >= 0xffe0 && markerBytes <= 0xffef) ||
+                markerBytes === 0xfffe
+              ) {
+                // The marker bytes (2) are always followed by
+                // the length bytes (2), indicating the length of the
+                // marker segment, which includes the length bytes,
+                // but not the marker bytes, so we add 2:
+                markerLength = dataView.getUint16(offset + 2) + 2
+                if (offset + markerLength > dataView.byteLength) {
+                  // eslint-disable-next-line no-console
+                  console.log('Invalid JPEG metadata: Invalid segment size.')
+                  break
+                }
+                parsers = metaDataParsers.jpeg[markerBytes]
+                if (parsers && !options.disableMetaDataParsers) {
+                  for (i = 0; i < parsers.length; i += 1) {
+                    parsers[i].call(
+                      that,
+                      dataView,
+                      offset,
+                      markerLength,
+                      data,
+                      options
+                    )
+                  }
+                }
+                offset += markerLength
+                headLength = offset
+              } else {
+                // Not an APPn or COM marker, probably safe to
+                // assume that this is the end of the metadata
+                break
+              }
+            }
+            // Meta length must be longer than JPEG marker (2)
+            // plus APPn marker (2), followed by length bytes (2):
+            if (!options.disableImageHead && headLength > 6) {
+              data.imageHead = bufferSlice.call(buffer, 0, headLength)
+            }
+            resolve(data)
+          },
+          reject,
+          'readAsArrayBuffer'
+        )
+      ) {
+        // No support for the FileReader interface, nothing to parse
+        resolve(data)
+      }
+    }
+    options = options || {} // eslint-disable-line no-param-reassign
+    if (global.Promise && typeof callback !== 'function') {
+      options = callback || {} // eslint-disable-line no-param-reassign
+      data = options // eslint-disable-line no-param-reassign
+      return new Promise(executor)
+    }
+    data = data || {} // eslint-disable-line no-param-reassign
+    return executor(callback, callback)
+  }
+
+  /**
+   * Replaces the head of a JPEG Blob
+   *
+   * @param {Blob} blob Blob object
+   * @param {ArrayBuffer} oldHead Old JPEG head
+   * @param {ArrayBuffer} newHead New JPEG head
+   * @returns {Blob} Combined Blob
+   */
+  function replaceJPEGHead(blob, oldHead, newHead) {
+    if (!blob || !oldHead || !newHead) return null
+    return new Blob([newHead, blobSlice.call(blob, oldHead.byteLength)], {
+      type: 'image/jpeg'
+    })
+  }
+
+  /**
+   * Replaces the image head of a JPEG blob with the given one.
+   * Returns a Promise or calls the callback with the new Blob.
+   *
+   * @param {Blob} blob Blob object
+   * @param {ArrayBuffer} head New JPEG head
+   * @param {Function} [callback] Callback function
+   * @returns {Promise<Blob|null>|undefined} Combined Blob
+   */
+  function replaceHead(blob, head, callback) {
+    var options = { maxMetaDataSize: 256, disableMetaDataParsers: true }
+    if (!callback && global.Promise) {
+      return parseMetaData(blob, options).then(function (data) {
+        return replaceJPEGHead(blob, data.imageHead, head)
+      })
+    }
+    parseMetaData(
+      blob,
+      function (data) {
+        callback(replaceJPEGHead(blob, data.imageHead, head))
+      },
+      options
+    )
+  }
+
+  loadImage.transform = function (img, options, callback, file, data) {
+    if (loadImage.requiresMetaData(options)) {
+      data = data || {} // eslint-disable-line no-param-reassign
+      parseMetaData(
+        file,
+        function (result) {
+          if (result !== data) {
+            // eslint-disable-next-line no-console
+            if (global.console) console.log(result)
+            result = data // eslint-disable-line no-param-reassign
+          }
+          originalTransform.call(
+            loadImage,
+            img,
+            options,
+            callback,
+            file,
+            result
+          )
+        },
+        options,
+        data
+      )
+    } else {
+      originalTransform.apply(loadImage, arguments)
+    }
+  }
+
+  loadImage.blobSlice = blobSlice
+  loadImage.bufferSlice = bufferSlice
+  loadImage.replaceHead = replaceHead
+  loadImage.parseMetaData = parseMetaData
+  loadImage.metaDataParsers = metaDataParsers
+})

app/Resources/public/assets/blueimp-load-image/js/load-image-orientation.js

@@ -0,0 +1,481 @@
+/*
+ * JavaScript Load Image Orientation
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ */
+
+/*
+Exif orientation values to correctly display the letter F:
+
+    1             2
+  ██████        ██████
+  ██                ██
+  ████            ████
+  ██                ██
+  ██                ██
+
+    3             4
+      ██        ██
+      ██        ██
+    ████        ████
+      ██        ██
+  ██████        ██████
+
+    5             6
+██████████    ██
+██  ██        ██  ██
+██            ██████████
+
+    7             8
+        ██    ██████████
+    ██  ██        ██  ██
+██████████            ██
+
+*/
+
+/* global define, module, require */
+
+;(function (factory) {
+  'use strict'
+  if (typeof define === 'function' && define.amd) {
+    // Register as an anonymous AMD module:
+    define(['./load-image', './load-image-scale', './load-image-meta'], factory)
+  } else if (typeof module === 'object' && module.exports) {
+    factory(
+      require('./load-image'),
+      require('./load-image-scale'),
+      require('./load-image-meta')
+    )
+  } else {
+    // Browser globals:
+    factory(window.loadImage)
+  }
+})(function (loadImage) {
+  'use strict'
+
+  var originalTransform = loadImage.transform
+  var originalRequiresCanvas = loadImage.requiresCanvas
+  var originalRequiresMetaData = loadImage.requiresMetaData
+  var originalTransformCoordinates = loadImage.transformCoordinates
+  var originalGetTransformedOptions = loadImage.getTransformedOptions
+
+  ;(function ($) {
+    // Guard for non-browser environments (e.g. server-side rendering):
+    if (!$.global.document) return
+    // black+white 3x2 JPEG, with the following meta information set:
+    // - EXIF Orientation: 6 (Rotated 90° CCW)
+    // Image data layout (B=black, F=white):
+    // BFF
+    // BBB
+    var testImageURL =
+      'data:image/jpeg;base64,/9j/4QAiRXhpZgAATU0AKgAAAAgAAQESAAMAAAABAAYAAAA' +
+      'AAAD/2wCEAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBA' +
+      'QEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE' +
+      'BAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAf/AABEIAAIAAwMBEQACEQEDEQH/x' +
+      'ABRAAEAAAAAAAAAAAAAAAAAAAAKEAEBAQADAQEAAAAAAAAAAAAGBQQDCAkCBwEBAAAAAAA' +
+      'AAAAAAAAAAAAAABEBAAAAAAAAAAAAAAAAAAAAAP/aAAwDAQACEQMRAD8AG8T9NfSMEVMhQ' +
+      'voP3fFiRZ+MTHDifa/95OFSZU5OzRzxkyejv8ciEfhSceSXGjS8eSdLnZc2HDm4M3BxcXw' +
+      'H/9k='
+    var img = document.createElement('img')
+    img.onload = function () {
+      // Check if the browser supports automatic image orientation:
+      $.orientation = img.width === 2 && img.height === 3
+      if ($.orientation) {
+        var canvas = $.createCanvas(1, 1, true)
+        var ctx = canvas.getContext('2d')
+        ctx.drawImage(img, 1, 1, 1, 1, 0, 0, 1, 1)
+        // Check if the source image coordinates (sX, sY, sWidth, sHeight) are
+        // correctly applied to the auto-orientated image, which should result
+        // in a white opaque pixel (e.g. in Safari).
+        // Browsers that show a transparent pixel (e.g. Chromium) fail to crop
+        // auto-oriented images correctly and require a workaround, e.g.
+        // drawing the complete source image to an intermediate canvas first.
+        // See https://bugs.chromium.org/p/chromium/issues/detail?id=1074354
+        $.orientationCropBug =
+          ctx.getImageData(0, 0, 1, 1).data.toString() !== '255,255,255,255'
+      }
+    }
+    img.src = testImageURL
+  })(loadImage)
+
+  /**
+   * Determines if the orientation requires a canvas element.
+   *
+   * @param {object} [options] Options object
+   * @param {boolean} [withMetaData] Is metadata required for orientation
+   * @returns {boolean} Returns true if orientation requires canvas/meta
+   */
+  function requiresCanvasOrientation(options, withMetaData) {
+    var orientation = options && options.orientation
+    return (
+      // Exif orientation for browsers without automatic image orientation:
+      (orientation === true && !loadImage.orientation) ||
+      // Orientation reset for browsers with automatic image orientation:
+      (orientation === 1 && loadImage.orientation) ||
+      // Orientation to defined value, requires meta for orientation reset only:
+      ((!withMetaData || loadImage.orientation) &&
+        orientation > 1 &&
+        orientation < 9)
+    )
+  }
+
+  /**
+   * Determines if the image requires an orientation change.
+   *
+   * @param {number} [orientation] Defined orientation value
+   * @param {number} [autoOrientation] Auto-orientation based on Exif data
+   * @returns {boolean} Returns true if an orientation change is required
+   */
+  function requiresOrientationChange(orientation, autoOrientation) {
+    return (
+      orientation !== autoOrientation &&
+      ((orientation === 1 && autoOrientation > 1 && autoOrientation < 9) ||
+        (orientation > 1 && orientation < 9))
+    )
+  }
+
+  /**
+   * Determines orientation combinations that require a rotation by 180°.
+   *
+   * The following is a list of combinations that return true:
+   *
+   * 2 (flip) => 5 (rot90,flip), 7 (rot90,flip), 6 (rot90), 8 (rot90)
+   * 4 (flip) => 5 (rot90,flip), 7 (rot90,flip), 6 (rot90), 8 (rot90)
+   *
+   * 5 (rot90,flip) => 2 (flip), 4 (flip), 6 (rot90), 8 (rot90)
+   * 7 (rot90,flip) => 2 (flip), 4 (flip), 6 (rot90), 8 (rot90)
+   *
+   * 6 (rot90) => 2 (flip), 4 (flip), 5 (rot90,flip), 7 (rot90,flip)
+   * 8 (rot90) => 2 (flip), 4 (flip), 5 (rot90,flip), 7 (rot90,flip)
+   *
+   * @param {number} [orientation] Defined orientation value
+   * @param {number} [autoOrientation] Auto-orientation based on Exif data
+   * @returns {boolean} Returns true if rotation by 180° is required
+   */
+  function requiresRot180(orientation, autoOrientation) {
+    if (autoOrientation > 1 && autoOrientation < 9) {
+      switch (orientation) {
+        case 2:
+        case 4:
+          return autoOrientation > 4
+        case 5:
+        case 7:
+          return autoOrientation % 2 === 0
+        case 6:
+        case 8:
+          return (
+            autoOrientation === 2 ||
+            autoOrientation === 4 ||
+            autoOrientation === 5 ||
+            autoOrientation === 7
+          )
+      }
+    }
+    return false
+  }
+
+  // Determines if the target image should be a canvas element:
+  loadImage.requiresCanvas = function (options) {
+    return (
+      requiresCanvasOrientation(options) ||
+      originalRequiresCanvas.call(loadImage, options)
+    )
+  }
+
+  // Determines if metadata should be loaded automatically:
+  loadImage.requiresMetaData = function (options) {
+    return (
+      requiresCanvasOrientation(options, true) ||
+      originalRequiresMetaData.call(loadImage, options)
+    )
+  }
+
+  loadImage.transform = function (img, options, callback, file, data) {
+    originalTransform.call(
+      loadImage,
+      img,
+      options,
+      function (img, data) {
+        if (data) {
+          var autoOrientation =
+            loadImage.orientation && data.exif && data.exif.get('Orientation')
+          if (autoOrientation > 4 && autoOrientation < 9) {
+            // Automatic image orientation switched image dimensions
+            var originalWidth = data.originalWidth
+            var originalHeight = data.originalHeight
+            data.originalWidth = originalHeight
+            data.originalHeight = originalWidth
+          }
+        }
+        callback(img, data)
+      },
+      file,
+      data
+    )
+  }
+
+  // Transforms coordinate and dimension options
+  // based on the given orientation option:
+  loadImage.getTransformedOptions = function (img, opts, data) {
+    var options = originalGetTransformedOptions.call(loadImage, img, opts)
+    var exifOrientation = data.exif && data.exif.get('Orientation')
+    var orientation = options.orientation
+    var autoOrientation = loadImage.orientation && exifOrientation
+    if (orientation === true) orientation = exifOrientation
+    if (!requiresOrientationChange(orientation, autoOrientation)) {
+      return options
+    }
+    var top = options.top
+    var right = options.right
+    var bottom = options.bottom
+    var left = options.left
+    var newOptions = {}
+    for (var i in options) {
+      if (Object.prototype.hasOwnProperty.call(options, i)) {
+        newOptions[i] = options[i]
+      }
+    }
+    newOptions.orientation = orientation
+    if (
+      (orientation > 4 && !(autoOrientation > 4)) ||
+      (orientation < 5 && autoOrientation > 4)
+    ) {
+      // Image dimensions and target dimensions are switched
+      newOptions.maxWidth = options.maxHeight
+      newOptions.maxHeight = options.maxWidth
+      newOptions.minWidth = options.minHeight
+      newOptions.minHeight = options.minWidth
+      newOptions.sourceWidth = options.sourceHeight
+      newOptions.sourceHeight = options.sourceWidth
+    }
+    if (autoOrientation > 1) {
+      // Browsers which correctly apply source image coordinates to
+      // auto-oriented images
+      switch (autoOrientation) {
+        case 2:
+          // Horizontal flip
+          right = options.left
+          left = options.right
+          break
+        case 3:
+          // 180° Rotate CCW
+          top = options.bottom
+          right = options.left
+          bottom = options.top
+          left = options.right
+          break
+        case 4:
+          // Vertical flip
+          top = options.bottom
+          bottom = options.top
+          break
+        case 5:
+          // Horizontal flip + 90° Rotate CCW
+          top = options.left
+          right = options.bottom
+          bottom = options.right
+          left = options.top
+          break
+        case 6:
+          // 90° Rotate CCW
+          top = options.left
+          right = options.top
+          bottom = options.right
+          left = options.bottom
+          break
+        case 7:
+          // Vertical flip + 90° Rotate CCW
+          top = options.right
+          right = options.top
+          bottom = options.left
+          left = options.bottom
+          break
+        case 8:
+          // 90° Rotate CW
+          top = options.right
+          right = options.bottom
+          bottom = options.left
+          left = options.top
+          break
+      }
+      // Some orientation combinations require additional rotation by 180°:
+      if (requiresRot180(orientation, autoOrientation)) {
+        var tmpTop = top
+        var tmpRight = right
+        top = bottom
+        right = left
+        bottom = tmpTop
+        left = tmpRight
+      }
+    }
+    newOptions.top = top
+    newOptions.right = right
+    newOptions.bottom = bottom
+    newOptions.left = left
+    // Account for defined browser orientation:
+    switch (orientation) {
+      case 2:
+        // Horizontal flip
+        newOptions.right = left
+        newOptions.left = right
+        break
+      case 3:
+        // 180° Rotate CCW
+        newOptions.top = bottom
+        newOptions.right = left
+        newOptions.bottom = top
+        newOptions.left = right
+        break
+      case 4:
+        // Vertical flip
+        newOptions.top = bottom
+        newOptions.bottom = top
+        break
+      case 5:
+        // Vertical flip + 90° Rotate CW
+        newOptions.top = left
+        newOptions.right = bottom
+        newOptions.bottom = right
+        newOptions.left = top
+        break
+      case 6:
+        // 90° Rotate CW
+        newOptions.top = right
+        newOptions.right = bottom
+        newOptions.bottom = left
+        newOptions.left = top
+        break
+      case 7:
+        // Horizontal flip + 90° Rotate CW
+        newOptions.top = right
+        newOptions.right = top
+        newOptions.bottom = left
+        newOptions.left = bottom
+        break
+      case 8:
+        // 90° Rotate CCW
+        newOptions.top = left
+        newOptions.right = top
+        newOptions.bottom = right
+        newOptions.left = bottom
+        break
+    }
+    return newOptions
+  }
+
+  // Transform image orientation based on the given EXIF orientation option:
+  loadImage.transformCoordinates = function (canvas, options, data) {
+    originalTransformCoordinates.call(loadImage, canvas, options, data)
+    var orientation = options.orientation
+    var autoOrientation =
+      loadImage.orientation && data.exif && data.exif.get('Orientation')
+    if (!requiresOrientationChange(orientation, autoOrientation)) {
+      return
+    }
+    var ctx = canvas.getContext('2d')
+    var width = canvas.width
+    var height = canvas.height
+    var sourceWidth = width
+    var sourceHeight = height
+    if (
+      (orientation > 4 && !(autoOrientation > 4)) ||
+      (orientation < 5 && autoOrientation > 4)
+    ) {
+      // Image dimensions and target dimensions are switched
+      canvas.width = height
+      canvas.height = width
+    }
+    if (orientation > 4) {
+      // Destination and source dimensions are switched
+      sourceWidth = height
+      sourceHeight = width
+    }
+    // Reset automatic browser orientation:
+    switch (autoOrientation) {
+      case 2:
+        // Horizontal flip
+        ctx.translate(sourceWidth, 0)
+        ctx.scale(-1, 1)
+        break
+      case 3:
+        // 180° Rotate CCW
+        ctx.translate(sourceWidth, sourceHeight)
+        ctx.rotate(Math.PI)
+        break
+      case 4:
+        // Vertical flip
+        ctx.translate(0, sourceHeight)
+        ctx.scale(1, -1)
+        break
+      case 5:
+        // Horizontal flip + 90° Rotate CCW
+        ctx.rotate(-0.5 * Math.PI)
+        ctx.scale(-1, 1)
+        break
+      case 6:
+        // 90° Rotate CCW
+        ctx.rotate(-0.5 * Math.PI)
+        ctx.translate(-sourceWidth, 0)
+        break
+      case 7:
+        // Vertical flip + 90° Rotate CCW
+        ctx.rotate(-0.5 * Math.PI)
+        ctx.translate(-sourceWidth, sourceHeight)
+        ctx.scale(1, -1)
+        break
+      case 8:
+        // 90° Rotate CW
+        ctx.rotate(0.5 * Math.PI)
+        ctx.translate(0, -sourceHeight)
+        break
+    }
+    // Some orientation combinations require additional rotation by 180°:
+    if (requiresRot180(orientation, autoOrientation)) {
+      ctx.translate(sourceWidth, sourceHeight)
+      ctx.rotate(Math.PI)
+    }
+    switch (orientation) {
+      case 2:
+        // Horizontal flip
+        ctx.translate(width, 0)
+        ctx.scale(-1, 1)
+        break
+      case 3:
+        // 180° Rotate CCW
+        ctx.translate(width, height)
+        ctx.rotate(Math.PI)
+        break
+      case 4:
+        // Vertical flip
+        ctx.translate(0, height)
+        ctx.scale(1, -1)
+        break
+      case 5:
+        // Vertical flip + 90° Rotate CW
+        ctx.rotate(0.5 * Math.PI)
+        ctx.scale(1, -1)
+        break
+      case 6:
+        // 90° Rotate CW
+        ctx.rotate(0.5 * Math.PI)
+        ctx.translate(0, -height)
+        break
+      case 7:
+        // Horizontal flip + 90° Rotate CW
+        ctx.rotate(0.5 * Math.PI)
+        ctx.translate(width, -height)
+        ctx.scale(-1, 1)
+        break
+      case 8:
+        // 90° Rotate CCW
+        ctx.rotate(-0.5 * Math.PI)
+        ctx.translate(-width, 0)
+        break
+    }
+  }
+})

app/Resources/public/assets/blueimp-load-image/js/load-image-scale.js

@@ -0,0 +1,327 @@
+/*
+ * JavaScript Load Image Scaling
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2011, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ */
+
+/* global define, module, require */
+
+;(function (factory) {
+  'use strict'
+  if (typeof define === 'function' && define.amd) {
+    // Register as an anonymous AMD module:
+    define(['./load-image'], factory)
+  } else if (typeof module === 'object' && module.exports) {
+    factory(require('./load-image'))
+  } else {
+    // Browser globals:
+    factory(window.loadImage)
+  }
+})(function (loadImage) {
+  'use strict'
+
+  var originalTransform = loadImage.transform
+
+  loadImage.createCanvas = function (width, height, offscreen) {
+    if (offscreen && loadImage.global.OffscreenCanvas) {
+      return new OffscreenCanvas(width, height)
+    }
+    var canvas = document.createElement('canvas')
+    canvas.width = width
+    canvas.height = height
+    return canvas
+  }
+
+  loadImage.transform = function (img, options, callback, file, data) {
+    originalTransform.call(
+      loadImage,
+      loadImage.scale(img, options, data),
+      options,
+      callback,
+      file,
+      data
+    )
+  }
+
+  // Transform image coordinates, allows to override e.g.
+  // the canvas orientation based on the orientation option,
+  // gets canvas, options and data passed as arguments:
+  loadImage.transformCoordinates = function () {}
+
+  // Returns transformed options, allows to override e.g.
+  // maxWidth, maxHeight and crop options based on the aspectRatio.
+  // gets img, options, data passed as arguments:
+  loadImage.getTransformedOptions = function (img, options) {
+    var aspectRatio = options.aspectRatio
+    var newOptions
+    var i
+    var width
+    var height
+    if (!aspectRatio) {
+      return options
+    }
+    newOptions = {}
+    for (i in options) {
+      if (Object.prototype.hasOwnProperty.call(options, i)) {
+        newOptions[i] = options[i]
+      }
+    }
+    newOptions.crop = true
+    width = img.naturalWidth || img.width
+    height = img.naturalHeight || img.height
+    if (width / height > aspectRatio) {
+      newOptions.maxWidth = height * aspectRatio
+      newOptions.maxHeight = height
+    } else {
+      newOptions.maxWidth = width
+      newOptions.maxHeight = width / aspectRatio
+    }
+    return newOptions
+  }
+
+  // Canvas render method, allows to implement a different rendering algorithm:
+  loadImage.drawImage = function (
+    img,
+    canvas,
+    sourceX,
+    sourceY,
+    sourceWidth,
+    sourceHeight,
+    destWidth,
+    destHeight,
+    options
+  ) {
+    var ctx = canvas.getContext('2d')
+    if (options.imageSmoothingEnabled === false) {
+      ctx.msImageSmoothingEnabled = false
+      ctx.imageSmoothingEnabled = false
+    } else if (options.imageSmoothingQuality) {
+      ctx.imageSmoothingQuality = options.imageSmoothingQuality
+    }
+    ctx.drawImage(
+      img,
+      sourceX,
+      sourceY,
+      sourceWidth,
+      sourceHeight,
+      0,
+      0,
+      destWidth,
+      destHeight
+    )
+    return ctx
+  }
+
+  // Determines if the target image should be a canvas element:
+  loadImage.requiresCanvas = function (options) {
+    return options.canvas || options.crop || !!options.aspectRatio
+  }
+
+  // Scales and/or crops the given image (img or canvas HTML element)
+  // using the given options:
+  loadImage.scale = function (img, options, data) {
+    // eslint-disable-next-line no-param-reassign
+    options = options || {}
+    // eslint-disable-next-line no-param-reassign
+    data = data || {}
+    var useCanvas =
+      img.getContext ||
+      (loadImage.requiresCanvas(options) &&
+        !!loadImage.global.HTMLCanvasElement)
+    var width = img.naturalWidth || img.width
+    var height = img.naturalHeight || img.height
+    var destWidth = width
+    var destHeight = height
+    var maxWidth
+    var maxHeight
+    var minWidth
+    var minHeight
+    var sourceWidth
+    var sourceHeight
+    var sourceX
+    var sourceY
+    var pixelRatio
+    var downsamplingRatio
+    var tmp
+    var canvas
+    /**
+     * Scales up image dimensions
+     */
+    function scaleUp() {
+      var scale = Math.max(
+        (minWidth || destWidth) / destWidth,
+        (minHeight || destHeight) / destHeight
+      )
+      if (scale > 1) {
+        destWidth *= scale
+        destHeight *= scale
+      }
+    }
+    /**
+     * Scales down image dimensions
+     */
+    function scaleDown() {
+      var scale = Math.min(
+        (maxWidth || destWidth) / destWidth,
+        (maxHeight || destHeight) / destHeight
+      )
+      if (scale < 1) {
+        destWidth *= scale
+        destHeight *= scale
+      }
+    }
+    if (useCanvas) {
+      // eslint-disable-next-line no-param-reassign
+      options = loadImage.getTransformedOptions(img, options, data)
+      sourceX = options.left || 0
+      sourceY = options.top || 0
+      if (options.sourceWidth) {
+        sourceWidth = options.sourceWidth
+        if (options.right !== undefined && options.left === undefined) {
+          sourceX = width - sourceWidth - options.right
+        }
+      } else {
+        sourceWidth = width - sourceX - (options.right || 0)
+      }
+      if (options.sourceHeight) {
+        sourceHeight = options.sourceHeight
+        if (options.bottom !== undefined && options.top === undefined) {
+          sourceY = height - sourceHeight - options.bottom
+        }
+      } else {
+        sourceHeight = height - sourceY - (options.bottom || 0)
+      }
+      destWidth = sourceWidth
+      destHeight = sourceHeight
+    }
+    maxWidth = options.maxWidth
+    maxHeight = options.maxHeight
+    minWidth = options.minWidth
+    minHeight = options.minHeight
+    if (useCanvas && maxWidth && maxHeight && options.crop) {
+      destWidth = maxWidth
+      destHeight = maxHeight
+      tmp = sourceWidth / sourceHeight - maxWidth / maxHeight
+      if (tmp < 0) {
+        sourceHeight = (maxHeight * sourceWidth) / maxWidth
+        if (options.top === undefined && options.bottom === undefined) {
+          sourceY = (height - sourceHeight) / 2
+        }
+      } else if (tmp > 0) {
+        sourceWidth = (maxWidth * sourceHeight) / maxHeight
+        if (options.left === undefined && options.right === undefined) {
+          sourceX = (width - sourceWidth) / 2
+        }
+      }
+    } else {
+      if (options.contain || options.cover) {
+        minWidth = maxWidth = maxWidth || minWidth
+        minHeight = maxHeight = maxHeight || minHeight
+      }
+      if (options.cover) {
+        scaleDown()
+        scaleUp()
+      } else {
+        scaleUp()
+        scaleDown()
+      }
+    }
+    if (useCanvas) {
+      pixelRatio = options.pixelRatio
+      if (
+        pixelRatio > 1 &&
+        // Check if the image has not yet had the device pixel ratio applied:
+        !(
+          img.style.width &&
+          Math.floor(parseFloat(img.style.width, 10)) ===
+            Math.floor(width / pixelRatio)
+        )
+      ) {
+        destWidth *= pixelRatio
+        destHeight *= pixelRatio
+      }
+      // Check if workaround for Chromium orientation crop bug is required:
+      // https://bugs.chromium.org/p/chromium/issues/detail?id=1074354
+      if (
+        loadImage.orientationCropBug &&
+        !img.getContext &&
+        (sourceX || sourceY || sourceWidth !== width || sourceHeight !== height)
+      ) {
+        // Write the complete source image to an intermediate canvas first:
+        tmp = img
+        // eslint-disable-next-line no-param-reassign
+        img = loadImage.createCanvas(width, height, true)
+        loadImage.drawImage(
+          tmp,
+          img,
+          0,
+          0,
+          width,
+          height,
+          width,
+          height,
+          options
+        )
+      }
+      downsamplingRatio = options.downsamplingRatio
+      if (
+        downsamplingRatio > 0 &&
+        downsamplingRatio < 1 &&
+        destWidth < sourceWidth &&
+        destHeight < sourceHeight
+      ) {
+        while (sourceWidth * downsamplingRatio > destWidth) {
+          canvas = loadImage.createCanvas(
+            sourceWidth * downsamplingRatio,
+            sourceHeight * downsamplingRatio,
+            true
+          )
+          loadImage.drawImage(
+            img,
+            canvas,
+            sourceX,
+            sourceY,
+            sourceWidth,
+            sourceHeight,
+            canvas.width,
+            canvas.height,
+            options
+          )
+          sourceX = 0
+          sourceY = 0
+          sourceWidth = canvas.width
+          sourceHeight = canvas.height
+          // eslint-disable-next-line no-param-reassign
+          img = canvas
+        }
+      }
+      canvas = loadImage.createCanvas(destWidth, destHeight)
+      loadImage.transformCoordinates(canvas, options, data)
+      if (pixelRatio > 1) {
+        canvas.style.width = canvas.width / pixelRatio + 'px'
+      }
+      loadImage
+        .drawImage(
+          img,
+          canvas,
+          sourceX,
+          sourceY,
+          sourceWidth,
+          sourceHeight,
+          destWidth,
+          destHeight,
+          options
+        )
+        .setTransform(1, 0, 0, 1, 0, 0) // reset to the identity matrix
+      return canvas
+    }
+    img.width = destWidth
+    img.height = destHeight
+    return img
+  }
+})

app/Resources/public/assets/blueimp-load-image/js/load-image.js

@@ -0,0 +1,229 @@
+/*
+ * JavaScript Load Image
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2011, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * https://opensource.org/licenses/MIT
+ */
+
+/* global define, module, Promise */
+
+;(function ($) {
+  'use strict'
+
+  var urlAPI = $.URL || $.webkitURL
+
+  /**
+   * Creates an object URL for a given File object.
+   *
+   * @param {Blob} blob Blob object
+   * @returns {string|boolean} Returns object URL if API exists, else false.
+   */
+  function createObjectURL(blob) {
+    return urlAPI ? urlAPI.createObjectURL(blob) : false
+  }
+
+  /**
+   * Revokes a given object URL.
+   *
+   * @param {string} url Blob object URL
+   * @returns {undefined|boolean} Returns undefined if API exists, else false.
+   */
+  function revokeObjectURL(url) {
+    return urlAPI ? urlAPI.revokeObjectURL(url) : false
+  }
+
+  /**
+   * Helper function to revoke an object URL
+   *
+   * @param {string} url Blob Object URL
+   * @param {object} [options] Options object
+   */
+  function revokeHelper(url, options) {
+    if (url && url.slice(0, 5) === 'blob:' && !(options && options.noRevoke)) {
+      revokeObjectURL(url)
+    }
+  }
+
+  /**
+   * Loads a given File object via FileReader interface.
+   *
+   * @param {Blob} file Blob object
+   * @param {Function} onload Load event callback
+   * @param {Function} [onerror] Error/Abort event callback
+   * @param {string} [method=readAsDataURL] FileReader method
+   * @returns {FileReader|boolean} Returns FileReader if API exists, else false.
+   */
+  function readFile(file, onload, onerror, method) {
+    if (!$.FileReader) return false
+    var reader = new FileReader()
+    reader.onload = function () {
+      onload.call(reader, this.result)
+    }
+    if (onerror) {
+      reader.onabort = reader.onerror = function () {
+        onerror.call(reader, this.error)
+      }
+    }
+    var readerMethod = reader[method || 'readAsDataURL']
+    if (readerMethod) {
+      readerMethod.call(reader, file)
+      return reader
+    }
+  }
+
+  /**
+   * Cross-frame instanceof check.
+   *
+   * @param {string} type Instance type
+   * @param {object} obj Object instance
+   * @returns {boolean} Returns true if the object is of the given instance.
+   */
+  function isInstanceOf(type, obj) {
+    // Cross-frame instanceof check
+    return Object.prototype.toString.call(obj) === '[object ' + type + ']'
+  }
+
+  /**
+   * @typedef { HTMLImageElement|HTMLCanvasElement } Result
+   */
+
+  /**
+   * Loads an image for a given File object.
+   *
+   * @param {Blob|string} file Blob object or image URL
+   * @param {Function|object} [callback] Image load event callback or options
+   * @param {object} [options] Options object
+   * @returns {HTMLImageElement|FileReader|Promise<Result>} Object
+   */
+  function loadImage(file, callback, options) {
+    /**
+     * Promise executor
+     *
+     * @param {Function} resolve Resolution function
+     * @param {Function} reject Rejection function
+     * @returns {HTMLImageElement|FileReader} Object
+     */
+    function executor(resolve, reject) {
+      var img = document.createElement('img')
+      var url
+      /**
+       * Callback for the fetchBlob call.
+       *
+       * @param {HTMLImageElement|HTMLCanvasElement} img Error object
+       * @param {object} data Data object
+       * @returns {undefined} Undefined
+       */
+      function resolveWrapper(img, data) {
+        if (resolve === reject) {
+          // Not using Promises
+          if (resolve) resolve(img, data)
+          return
+        } else if (img instanceof Error) {
+          reject(img)
+          return
+        }
+        data = data || {} // eslint-disable-line no-param-reassign
+        data.image = img
+        resolve(data)
+      }
+      /**
+       * Callback for the fetchBlob call.
+       *
+       * @param {Blob} blob Blob object
+       * @param {Error} err Error object
+       */
+      function fetchBlobCallback(blob, err) {
+        if (err && $.console) console.log(err) // eslint-disable-line no-console
+        if (blob && isInstanceOf('Blob', blob)) {
+          file = blob // eslint-disable-line no-param-reassign
+          url = createObjectURL(file)
+        } else {
+          url = file
+          if (options && options.crossOrigin) {
+            img.crossOrigin = options.crossOrigin
+          }
+        }
+        img.src = url
+      }
+      img.onerror = function (event) {
+        revokeHelper(url, options)
+        if (reject) reject.call(img, event)
+      }
+      img.onload = function () {
+        revokeHelper(url, options)
+        var data = {
+          originalWidth: img.naturalWidth || img.width,
+          originalHeight: img.naturalHeight || img.height
+        }
+        try {
+          loadImage.transform(img, options, resolveWrapper, file, data)
+        } catch (error) {
+          if (reject) reject(error)
+        }
+      }
+      if (typeof file === 'string') {
+        if (loadImage.requiresMetaData(options)) {
+          loadImage.fetchBlob(file, fetchBlobCallback, options)
+        } else {
+          fetchBlobCallback()
+        }
+        return img
+      } else if (isInstanceOf('Blob', file) || isInstanceOf('File', file)) {
+        url = createObjectURL(file)
+        if (url) {
+          img.src = url
+          return img
+        }
+        return readFile(
+          file,
+          function (url) {
+            img.src = url
+          },
+          reject
+        )
+      }
+    }
+    if ($.Promise && typeof callback !== 'function') {
+      options = callback // eslint-disable-line no-param-reassign
+      return new Promise(executor)
+    }
+    return executor(callback, callback)
+  }
+
+  // Determines if metadata should be loaded automatically.
+  // Requires the load image meta extension to load metadata.
+  loadImage.requiresMetaData = function (options) {
+    return options && options.meta
+  }
+
+  // If the callback given to this function returns a blob, it is used as image
+  // source instead of the original url and overrides the file argument used in
+  // the onload and onerror event callbacks:
+  loadImage.fetchBlob = function (url, callback) {
+    callback()
+  }
+
+  loadImage.transform = function (img, options, callback, file, data) {
+    callback(img, data)
+  }
+
+  loadImage.global = $
+  loadImage.readFile = readFile
+  loadImage.isInstanceOf = isInstanceOf
+  loadImage.createObjectURL = createObjectURL
+  loadImage.revokeObjectURL = revokeObjectURL
+
+  if (typeof define === 'function' && define.amd) {
+    define(function () {
+      return loadImage
+    })
+  } else if (typeof module === 'object' && module.exports) {
+    module.exports = loadImage
+  } else {
+    $.loadImage = loadImage
+  }
+})((typeof window !== 'undefined' && window) || this)

app/Resources/public/assets/blueimp-load-image/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "blueimp-load-image",
+  "version": "5.13.0",
+  "title": "JavaScript Load Image",
+  "description": "JavaScript Load Image is a library to load images provided as File or Blob objects or via URL. It returns an optionally scaled, cropped or rotated HTML img or canvas element. It also provides methods to parse image metadata to extract IPTC and Exif tags as well as embedded thumbnail images, to overwrite the Exif Orientation value and to restore the complete image header after resizing.",
+  "keywords": [
+    "javascript",
+    "load",
+    "loading",
+    "image",
+    "file",
+    "blob",
+    "url",
+    "scale",
+    "crop",
+    "rotate",
+    "img",
+    "canvas",
+    "meta",
+    "exif",
+    "orientation",
+    "thumbnail",
+    "iptc"
+  ],
+  "homepage": "https://github.com/blueimp/JavaScript-Load-Image",
+  "author": {
+    "name": "Sebastian Tschan",
+    "url": "https://blueimp.net"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/blueimp/JavaScript-Load-Image.git"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "eslint": "7",
+    "eslint-config-blueimp": "2",
+    "eslint-config-prettier": "6",
+    "eslint-plugin-jsdoc": "25",
+    "eslint-plugin-prettier": "3",
+    "prettier": "2",
+    "uglify-js": "3"
+  },
+  "eslintConfig": {
+    "extends": [
+      "blueimp",
+      "plugin:jsdoc/recommended",
+      "plugin:prettier/recommended"
+    ],
+    "env": {
+      "browser": true
+    }
+  },
+  "eslintIgnore": [
+    "js/*.min.js",
+    "js/vendor",
+    "test/vendor"
+  ],
+  "prettier": {
+    "arrowParens": "avoid",
+    "proseWrap": "always",
+    "semi": false,
+    "singleQuote": true,
+    "trailingComma": "none"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "unit": "docker-compose run --rm mocha",
+    "test": "npm run lint && npm run unit",
+    "posttest": "docker-compose down -v",
+    "build": "cd js && uglifyjs load-image.js load-image-scale.js load-image-meta.js load-image-fetch.js load-image-orientation.js load-image-exif.js load-image-exif-map.js load-image-iptc.js load-image-iptc-map.js --ie8 -c -m -o load-image.all.min.js --source-map url=load-image.all.min.js.map",
+    "preversion": "npm test",
+    "version": "npm run build && git add -A js",
+    "postversion": "git push --tags origin master master:gh-pages && npm publish"
+  },
+  "files": [
+    "js/*.js",
+    "js/*.js.map"
+  ],
+  "main": "js/index.js"
+}