{"version":3,"file":"6475dc2fc9a0c6cf901bf00d.js?3.6.14.7428b935c.1723600572441","mappings":"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","sources":["webpack://mono-repo/./node_modules/@uppy/core/lib/Uppy.js"],"sourcesContent":["let _Symbol$for, _Symbol$for2;\nfunction _classPrivateFieldLooseBase(receiver, privateKey) { if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { throw new TypeError(\"attempted to use private field on non-instance\"); } return receiver; }\nvar id = 0;\nfunction _classPrivateFieldLooseKey(name) { return \"__private_\" + id++ + \"_\" + name; }\n/* eslint-disable max-classes-per-file */\n/* global AggregateError */\n\nimport Translator from '@uppy/utils/lib/Translator';\nimport ee from 'namespace-emitter';\nimport { nanoid } from 'nanoid/non-secure';\nimport throttle from 'lodash/throttle.js';\nimport DefaultStore from '@uppy/store-default';\nimport getFileType from '@uppy/utils/lib/getFileType';\nimport getFileNameAndExtension from '@uppy/utils/lib/getFileNameAndExtension';\nimport { getSafeFileId } from '@uppy/utils/lib/generateFileID';\nimport supportsUploadProgress from './supportsUploadProgress.js';\nimport getFileName from './getFileName.js';\nimport { justErrorsLogger, debugLogger } from './loggers.js';\nimport { Restricter, defaultOptions as defaultRestrictionOptions, RestrictionError } from './Restricter.js';\nconst packageJson = {\n  \"version\": \"3.3.1\"\n};\nimport locale from './locale.js';\n\n/**\n * Uppy Core module.\n * Manages plugins, state updates, acts as an event bus,\n * adds/removes files and metadata.\n */\nvar _plugins = /*#__PURE__*/_classPrivateFieldLooseKey(\"plugins\");\nvar _restricter = /*#__PURE__*/_classPrivateFieldLooseKey(\"restricter\");\nvar _storeUnsubscribe = /*#__PURE__*/_classPrivateFieldLooseKey(\"storeUnsubscribe\");\nvar _emitter = /*#__PURE__*/_classPrivateFieldLooseKey(\"emitter\");\nvar _preProcessors = /*#__PURE__*/_classPrivateFieldLooseKey(\"preProcessors\");\nvar _uploaders = /*#__PURE__*/_classPrivateFieldLooseKey(\"uploaders\");\nvar _postProcessors = /*#__PURE__*/_classPrivateFieldLooseKey(\"postProcessors\");\nvar _informAndEmit = /*#__PURE__*/_classPrivateFieldLooseKey(\"informAndEmit\");\nvar _checkRequiredMetaFieldsOnFile = /*#__PURE__*/_classPrivateFieldLooseKey(\"checkRequiredMetaFieldsOnFile\");\nvar _checkRequiredMetaFields = /*#__PURE__*/_classPrivateFieldLooseKey(\"checkRequiredMetaFields\");\nvar _assertNewUploadAllowed = /*#__PURE__*/_classPrivateFieldLooseKey(\"assertNewUploadAllowed\");\nvar _transformFile = /*#__PURE__*/_classPrivateFieldLooseKey(\"transformFile\");\nvar _startIfAutoProceed = /*#__PURE__*/_classPrivateFieldLooseKey(\"startIfAutoProceed\");\nvar _checkAndUpdateFileState = /*#__PURE__*/_classPrivateFieldLooseKey(\"checkAndUpdateFileState\");\nvar _addListeners = /*#__PURE__*/_classPrivateFieldLooseKey(\"addListeners\");\nvar _updateOnlineStatus = /*#__PURE__*/_classPrivateFieldLooseKey(\"updateOnlineStatus\");\nvar _createUpload = /*#__PURE__*/_classPrivateFieldLooseKey(\"createUpload\");\nvar _getUpload = /*#__PURE__*/_classPrivateFieldLooseKey(\"getUpload\");\nvar _removeUpload = /*#__PURE__*/_classPrivateFieldLooseKey(\"removeUpload\");\nvar _runUpload = /*#__PURE__*/_classPrivateFieldLooseKey(\"runUpload\");\n_Symbol$for = Symbol.for('uppy test: getPlugins');\n_Symbol$for2 = Symbol.for('uppy test: createUpload');\nclass Uppy {\n  /**\n   * Instantiate Uppy\n   *\n   * @param {object} opts — Uppy options\n   */\n  constructor(_opts) {\n    /**\n     * Run an upload. This picks up where it left off in case the upload is being restored.\n     *\n     * @private\n     */\n    Object.defineProperty(this, _runUpload, {\n      value: _runUpload2\n    });\n    /**\n     * Remove an upload, eg. if it has been canceled or completed.\n     *\n     * @param {string} uploadID The ID of the upload.\n     */\n    Object.defineProperty(this, _removeUpload, {\n      value: _removeUpload2\n    });\n    Object.defineProperty(this, _getUpload, {\n      value: _getUpload2\n    });\n    /**\n     * Create an upload for a bunch of files.\n     *\n     * @param {Array<string>} fileIDs File IDs to include in this upload.\n     * @returns {string} ID of this upload.\n     */\n    Object.defineProperty(this, _createUpload, {\n      value: _createUpload2\n    });\n    /**\n     * Registers listeners for all global actions, like:\n     * `error`, `file-removed`, `upload-progress`\n     */\n    Object.defineProperty(this, _addListeners, {\n      value: _addListeners2\n    });\n    Object.defineProperty(this, _checkAndUpdateFileState, {\n      value: _checkAndUpdateFileState2\n    });\n    // Schedule an upload if `autoProceed` is enabled.\n    Object.defineProperty(this, _startIfAutoProceed, {\n      value: _startIfAutoProceed2\n    });\n    /**\n     * Create a file state object based on user-provided `addFile()` options.\n     */\n    Object.defineProperty(this, _transformFile, {\n      value: _transformFile2\n    });\n    Object.defineProperty(this, _assertNewUploadAllowed, {\n      value: _assertNewUploadAllowed2\n    });\n    Object.defineProperty(this, _checkRequiredMetaFields, {\n      value: _checkRequiredMetaFields2\n    });\n    Object.defineProperty(this, _checkRequiredMetaFieldsOnFile, {\n      value: _checkRequiredMetaFieldsOnFile2\n    });\n    /*\n    * @constructs\n    * @param { Error[] } errors\n    * @param { undefined } file\n    */\n    /*\n    * @constructs\n    * @param { RestrictionError } error\n    */\n    Object.defineProperty(this, _informAndEmit, {\n      value: _informAndEmit2\n    });\n    /** @type {Record<string, BasePlugin[]>} */\n    Object.defineProperty(this, _plugins, {\n      writable: true,\n      value: Object.create(null)\n    });\n    Object.defineProperty(this, _restricter, {\n      writable: true,\n      value: void 0\n    });\n    Object.defineProperty(this, _storeUnsubscribe, {\n      writable: true,\n      value: void 0\n    });\n    Object.defineProperty(this, _emitter, {\n      writable: true,\n      value: ee()\n    });\n    Object.defineProperty(this, _preProcessors, {\n      writable: true,\n      value: new Set()\n    });\n    Object.defineProperty(this, _uploaders, {\n      writable: true,\n      value: new Set()\n    });\n    Object.defineProperty(this, _postProcessors, {\n      writable: true,\n      value: new Set()\n    });\n    // ___Why throttle at 500ms?\n    //    - We must throttle at >250ms for superfocus in Dashboard to work well\n    //    (because animation takes 0.25s, and we want to wait for all animations to be over before refocusing).\n    //    [Practical Check]: if thottle is at 100ms, then if you are uploading a file,\n    //    and click 'ADD MORE FILES', - focus won't activate in Firefox.\n    //    - We must throttle at around >500ms to avoid performance lags.\n    //    [Practical Check] Firefox, try to upload a big file for a prolonged period of time. Laptop will start to heat up.\n    this.calculateProgress = throttle((file, data) => {\n      const fileInState = this.getFile(file == null ? void 0 : file.id);\n      if (file == null || !fileInState) {\n        this.log(`Not setting progress for a file that has been removed: ${file == null ? void 0 : file.id}`);\n        return;\n      }\n      if (fileInState.progress.percentage === 100) {\n        this.log(`Not setting progress for a file that has been already uploaded: ${file.id}`);\n        return;\n      }\n\n      // bytesTotal may be null or zero; in that case we can't divide by it\n      const canHavePercentage = Number.isFinite(data.bytesTotal) && data.bytesTotal > 0;\n      this.setFileState(file.id, {\n        progress: {\n          ...fileInState.progress,\n          bytesUploaded: data.bytesUploaded,\n          bytesTotal: data.bytesTotal,\n          percentage: canHavePercentage ? Math.round(data.bytesUploaded / data.bytesTotal * 100) : 0\n        }\n      });\n      this.calculateTotalProgress();\n    }, 500, {\n      leading: true,\n      trailing: true\n    });\n    Object.defineProperty(this, _updateOnlineStatus, {\n      writable: true,\n      value: this.updateOnlineStatus.bind(this)\n    });\n    this.defaultLocale = locale;\n    const defaultOptions = {\n      id: 'uppy',\n      autoProceed: false,\n      allowMultipleUploadBatches: true,\n      debug: false,\n      restrictions: defaultRestrictionOptions,\n      meta: {},\n      onBeforeFileAdded: currentFile => currentFile,\n      onBeforeUpload: files => files,\n      store: new DefaultStore(),\n      logger: justErrorsLogger,\n      infoTimeout: 5000\n    };\n\n    // Merge default options with the ones set by user,\n    // making sure to merge restrictions too\n    this.opts = {\n      ...defaultOptions,\n      ..._opts,\n      restrictions: {\n        ...defaultOptions.restrictions,\n        ...(_opts && _opts.restrictions)\n      }\n    };\n\n    // Support debug: true for backwards-compatability, unless logger is set in opts\n    // opts instead of this.opts to avoid comparing objects — we set logger: justErrorsLogger in defaultOptions\n    if (_opts && _opts.logger && _opts.debug) {\n      this.log('You are using a custom `logger`, but also set `debug: true`, which uses built-in logger to output logs to console. Ignoring `debug: true` and using your custom `logger`.', 'warning');\n    } else if (_opts && _opts.debug) {\n      this.opts.logger = debugLogger;\n    }\n    this.log(`Using Core v${this.constructor.VERSION}`);\n    this.i18nInit();\n    this.store = this.opts.store;\n    this.setState({\n      plugins: {},\n      files: {},\n      currentUploads: {},\n      allowNewUpload: true,\n      capabilities: {\n        uploadProgress: supportsUploadProgress(),\n        individualCancellation: true,\n        resumableUploads: false\n      },\n      totalProgress: 0,\n      meta: {\n        ...this.opts.meta\n      },\n      info: [],\n      recoveredState: null\n    });\n    _classPrivateFieldLooseBase(this, _restricter)[_restricter] = new Restricter(() => this.opts, this.i18n);\n    _classPrivateFieldLooseBase(this, _storeUnsubscribe)[_storeUnsubscribe] = this.store.subscribe((prevState, nextState, patch) => {\n      this.emit('state-update', prevState, nextState, patch);\n      this.updateAll(nextState);\n    });\n\n    // Exposing uppy object on window for debugging and testing\n    if (this.opts.debug && typeof window !== 'undefined') {\n      window[this.opts.id] = this;\n    }\n    _classPrivateFieldLooseBase(this, _addListeners)[_addListeners]();\n  }\n  emit(event) {\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n    _classPrivateFieldLooseBase(this, _emitter)[_emitter].emit(event, ...args);\n  }\n  on(event, callback) {\n    _classPrivateFieldLooseBase(this, _emitter)[_emitter].on(event, callback);\n    return this;\n  }\n  once(event, callback) {\n    _classPrivateFieldLooseBase(this, _emitter)[_emitter].once(event, callback);\n    return this;\n  }\n  off(event, callback) {\n    _classPrivateFieldLooseBase(this, _emitter)[_emitter].off(event, callback);\n    return this;\n  }\n\n  /**\n   * Iterate on all plugins and run `update` on them.\n   * Called each time state changes.\n   *\n   */\n  updateAll(state) {\n    this.iteratePlugins(plugin => {\n      plugin.update(state);\n    });\n  }\n\n  /**\n   * Updates state with a patch\n   *\n   * @param {object} patch {foo: 'bar'}\n   */\n  setState(patch) {\n    this.store.setState(patch);\n  }\n\n  /**\n   * Returns current state.\n   *\n   * @returns {object}\n   */\n  getState() {\n    return this.store.getState();\n  }\n  patchFilesState(filesWithNewState) {\n    const existingFilesState = this.getState().files;\n    this.setState({\n      files: {\n        ...existingFilesState,\n        ...Object.fromEntries(Object.entries(filesWithNewState).map(_ref => {\n          let [fileID, newFileState] = _ref;\n          return [fileID, {\n            ...existingFilesState[fileID],\n            ...newFileState\n          }];\n        }))\n      }\n    });\n  }\n\n  /**\n   * Shorthand to set state for a specific file.\n   */\n  setFileState(fileID, state) {\n    if (!this.getState().files[fileID]) {\n      throw new Error(`Can’t set state for ${fileID} (the file could have been removed)`);\n    }\n    this.patchFilesState({\n      [fileID]: state\n    });\n  }\n  i18nInit() {\n    const translator = new Translator([this.defaultLocale, this.opts.locale]);\n    this.i18n = translator.translate.bind(translator);\n    this.i18nArray = translator.translateArray.bind(translator);\n    this.locale = translator.locale;\n  }\n  setOptions(newOpts) {\n    this.opts = {\n      ...this.opts,\n      ...newOpts,\n      restrictions: {\n        ...this.opts.restrictions,\n        ...(newOpts && newOpts.restrictions)\n      }\n    };\n    if (newOpts.meta) {\n      this.setMeta(newOpts.meta);\n    }\n    this.i18nInit();\n    if (newOpts.locale) {\n      this.iteratePlugins(plugin => {\n        plugin.setOptions(newOpts);\n      });\n    }\n\n    // Note: this is not the preact `setState`, it's an internal function that has the same name.\n    this.setState(); // so that UI re-renders with new options\n  }\n\n  resetProgress() {\n    const defaultProgress = {\n      percentage: 0,\n      bytesUploaded: 0,\n      uploadComplete: false,\n      uploadStarted: null\n    };\n    const files = {\n      ...this.getState().files\n    };\n    const updatedFiles = {};\n    Object.keys(files).forEach(fileID => {\n      updatedFiles[fileID] = {\n        ...files[fileID],\n        progress: {\n          ...files[fileID].progress,\n          ...defaultProgress\n        }\n      };\n    });\n    this.setState({\n      files: updatedFiles,\n      totalProgress: 0,\n      allowNewUpload: true,\n      error: null,\n      recoveredState: null\n    });\n    this.emit('reset-progress');\n  }\n  addPreProcessor(fn) {\n    _classPrivateFieldLooseBase(this, _preProcessors)[_preProcessors].add(fn);\n  }\n  removePreProcessor(fn) {\n    return _classPrivateFieldLooseBase(this, _preProcessors)[_preProcessors].delete(fn);\n  }\n  addPostProcessor(fn) {\n    _classPrivateFieldLooseBase(this, _postProcessors)[_postProcessors].add(fn);\n  }\n  removePostProcessor(fn) {\n    return _classPrivateFieldLooseBase(this, _postProcessors)[_postProcessors].delete(fn);\n  }\n  addUploader(fn) {\n    _classPrivateFieldLooseBase(this, _uploaders)[_uploaders].add(fn);\n  }\n  removeUploader(fn) {\n    return _classPrivateFieldLooseBase(this, _uploaders)[_uploaders].delete(fn);\n  }\n  setMeta(data) {\n    const updatedMeta = {\n      ...this.getState().meta,\n      ...data\n    };\n    const updatedFiles = {\n      ...this.getState().files\n    };\n    Object.keys(updatedFiles).forEach(fileID => {\n      updatedFiles[fileID] = {\n        ...updatedFiles[fileID],\n        meta: {\n          ...updatedFiles[fileID].meta,\n          ...data\n        }\n      };\n    });\n    this.log('Adding metadata:');\n    this.log(data);\n    this.setState({\n      meta: updatedMeta,\n      files: updatedFiles\n    });\n  }\n  setFileMeta(fileID, data) {\n    const updatedFiles = {\n      ...this.getState().files\n    };\n    if (!updatedFiles[fileID]) {\n      this.log('Was trying to set metadata for a file that has been removed: ', fileID);\n      return;\n    }\n    const newMeta = {\n      ...updatedFiles[fileID].meta,\n      ...data\n    };\n    updatedFiles[fileID] = {\n      ...updatedFiles[fileID],\n      meta: newMeta\n    };\n    this.setState({\n      files: updatedFiles\n    });\n  }\n\n  /**\n   * Get a file object.\n   *\n   * @param {string} fileID The ID of the file object to return.\n   */\n  getFile(fileID) {\n    return this.getState().files[fileID];\n  }\n\n  /**\n   * Get all files in an array.\n   */\n  getFiles() {\n    const {\n      files\n    } = this.getState();\n    return Object.values(files);\n  }\n  getFilesByIds(ids) {\n    return ids.map(id => this.getFile(id));\n  }\n  getObjectOfFilesPerState() {\n    const {\n      files: filesObject,\n      totalProgress,\n      error\n    } = this.getState();\n    const files = Object.values(filesObject);\n    const inProgressFiles = files.filter(_ref2 => {\n      let {\n        progress\n      } = _ref2;\n      return !progress.uploadComplete && progress.uploadStarted;\n    });\n    const newFiles = files.filter(file => !file.progress.uploadStarted);\n    const startedFiles = files.filter(file => file.progress.uploadStarted || file.progress.preprocess || file.progress.postprocess);\n    const uploadStartedFiles = files.filter(file => file.progress.uploadStarted);\n    const pausedFiles = files.filter(file => file.isPaused);\n    const completeFiles = files.filter(file => file.progress.uploadComplete);\n    const erroredFiles = files.filter(file => file.error);\n    const inProgressNotPausedFiles = inProgressFiles.filter(file => !file.isPaused);\n    const processingFiles = files.filter(file => file.progress.preprocess || file.progress.postprocess);\n    return {\n      newFiles,\n      startedFiles,\n      uploadStartedFiles,\n      pausedFiles,\n      completeFiles,\n      erroredFiles,\n      inProgressFiles,\n      inProgressNotPausedFiles,\n      processingFiles,\n      isUploadStarted: uploadStartedFiles.length > 0,\n      isAllComplete: totalProgress === 100 && completeFiles.length === files.length && processingFiles.length === 0,\n      isAllErrored: !!error && erroredFiles.length === files.length,\n      isAllPaused: inProgressFiles.length !== 0 && pausedFiles.length === inProgressFiles.length,\n      isUploadInProgress: inProgressFiles.length > 0,\n      isSomeGhost: files.some(file => file.isGhost)\n    };\n  }\n  validateRestrictions(file, files) {\n    if (files === void 0) {\n      files = this.getFiles();\n    }\n    try {\n      _classPrivateFieldLooseBase(this, _restricter)[_restricter].validate(files, [file]);\n    } catch (err) {\n      return err;\n    }\n    return null;\n  }\n  checkIfFileAlreadyExists(fileID) {\n    const {\n      files\n    } = this.getState();\n    if (files[fileID] && !files[fileID].isGhost) {\n      return true;\n    }\n    return false;\n  }\n  /**\n   * Add a new file to `state.files`. This will run `onBeforeFileAdded`,\n   * try to guess file type in a clever way, check file against restrictions,\n   * and start an upload if `autoProceed === true`.\n   *\n   * @param {object} file object to add\n   * @returns {string} id for the added file\n   */\n  addFile(file) {\n    _classPrivateFieldLooseBase(this, _assertNewUploadAllowed)[_assertNewUploadAllowed](file);\n    const {\n      nextFilesState,\n      validFilesToAdd,\n      errors\n    } = _classPrivateFieldLooseBase(this, _checkAndUpdateFileState)[_checkAndUpdateFileState]([file]);\n    const restrictionErrors = errors.filter(error => error.isRestriction);\n    _classPrivateFieldLooseBase(this, _informAndEmit)[_informAndEmit](restrictionErrors);\n    if (errors.length > 0) throw errors[0];\n    this.setState({\n      files: nextFilesState\n    });\n    const [firstValidFileToAdd] = validFilesToAdd;\n    this.emit('file-added', firstValidFileToAdd);\n    this.emit('files-added', validFilesToAdd);\n    this.log(`Added file: ${firstValidFileToAdd.name}, ${firstValidFileToAdd.id}, mime type: ${firstValidFileToAdd.type}`);\n    _classPrivateFieldLooseBase(this, _startIfAutoProceed)[_startIfAutoProceed]();\n    return firstValidFileToAdd.id;\n  }\n\n  /**\n   * Add multiple files to `state.files`. See the `addFile()` documentation.\n   *\n   * If an error occurs while adding a file, it is logged and the user is notified.\n   * This is good for UI plugins, but not for programmatic use.\n   * Programmatic users should usually still use `addFile()` on individual files.\n   */\n  addFiles(fileDescriptors) {\n    _classPrivateFieldLooseBase(this, _assertNewUploadAllowed)[_assertNewUploadAllowed]();\n    const {\n      nextFilesState,\n      validFilesToAdd,\n      errors\n    } = _classPrivateFieldLooseBase(this, _checkAndUpdateFileState)[_checkAndUpdateFileState](fileDescriptors);\n    const restrictionErrors = errors.filter(error => error.isRestriction);\n    _classPrivateFieldLooseBase(this, _informAndEmit)[_informAndEmit](restrictionErrors);\n    const nonRestrictionErrors = errors.filter(error => !error.isRestriction);\n    if (nonRestrictionErrors.length > 0) {\n      let message = 'Multiple errors occurred while adding files:\\n';\n      nonRestrictionErrors.forEach(subError => {\n        message += `\\n * ${subError.message}`;\n      });\n      this.info({\n        message: this.i18n('addBulkFilesFailed', {\n          smart_count: nonRestrictionErrors.length\n        }),\n        details: message\n      }, 'error', this.opts.infoTimeout);\n      if (typeof AggregateError === 'function') {\n        throw new AggregateError(nonRestrictionErrors, message);\n      } else {\n        const err = new Error(message);\n        err.errors = nonRestrictionErrors;\n        throw err;\n      }\n    }\n\n    // OK, we haven't thrown an error, we can start updating state and emitting events now:\n\n    this.setState({\n      files: nextFilesState\n    });\n    validFilesToAdd.forEach(file => {\n      this.emit('file-added', file);\n    });\n    this.emit('files-added', validFilesToAdd);\n    if (validFilesToAdd.length > 5) {\n      this.log(`Added batch of ${validFilesToAdd.length} files`);\n    } else {\n      Object.values(validFilesToAdd).forEach(file => {\n        this.log(`Added file: ${file.name}\\n id: ${file.id}\\n type: ${file.type}`);\n      });\n    }\n    if (validFilesToAdd.length > 0) {\n      _classPrivateFieldLooseBase(this, _startIfAutoProceed)[_startIfAutoProceed]();\n    }\n  }\n  removeFiles(fileIDs, reason) {\n    const {\n      files,\n      currentUploads\n    } = this.getState();\n    const updatedFiles = {\n      ...files\n    };\n    const updatedUploads = {\n      ...currentUploads\n    };\n    const removedFiles = Object.create(null);\n    fileIDs.forEach(fileID => {\n      if (files[fileID]) {\n        removedFiles[fileID] = files[fileID];\n        delete updatedFiles[fileID];\n      }\n    });\n\n    // Remove files from the `fileIDs` list in each upload.\n    function fileIsNotRemoved(uploadFileID) {\n      return removedFiles[uploadFileID] === undefined;\n    }\n    Object.keys(updatedUploads).forEach(uploadID => {\n      const newFileIDs = currentUploads[uploadID].fileIDs.filter(fileIsNotRemoved);\n\n      // Remove the upload if no files are associated with it anymore.\n      if (newFileIDs.length === 0) {\n        delete updatedUploads[uploadID];\n        return;\n      }\n      const {\n        capabilities\n      } = this.getState();\n      if (newFileIDs.length !== currentUploads[uploadID].fileIDs.length && !capabilities.individualCancellation) {\n        throw new Error('individualCancellation is disabled');\n      }\n      updatedUploads[uploadID] = {\n        ...currentUploads[uploadID],\n        fileIDs: newFileIDs\n      };\n    });\n    const stateUpdate = {\n      currentUploads: updatedUploads,\n      files: updatedFiles\n    };\n\n    // If all files were removed - allow new uploads,\n    // and clear recoveredState\n    if (Object.keys(updatedFiles).length === 0) {\n      stateUpdate.allowNewUpload = true;\n      stateUpdate.error = null;\n      stateUpdate.recoveredState = null;\n    }\n    this.setState(stateUpdate);\n    this.calculateTotalProgress();\n    const removedFileIDs = Object.keys(removedFiles);\n    removedFileIDs.forEach(fileID => {\n      this.emit('file-removed', removedFiles[fileID], reason);\n    });\n    if (removedFileIDs.length > 5) {\n      this.log(`Removed ${removedFileIDs.length} files`);\n    } else {\n      this.log(`Removed files: ${removedFileIDs.join(', ')}`);\n    }\n  }\n  removeFile(fileID, reason) {\n    if (reason === void 0) {\n      reason = null;\n    }\n    this.removeFiles([fileID], reason);\n  }\n  pauseResume(fileID) {\n    if (!this.getState().capabilities.resumableUploads || this.getFile(fileID).uploadComplete) {\n      return undefined;\n    }\n    const wasPaused = this.getFile(fileID).isPaused || false;\n    const isPaused = !wasPaused;\n    this.setFileState(fileID, {\n      isPaused\n    });\n    this.emit('upload-pause', fileID, isPaused);\n    return isPaused;\n  }\n  pauseAll() {\n    const updatedFiles = {\n      ...this.getState().files\n    };\n    const inProgressUpdatedFiles = Object.keys(updatedFiles).filter(file => {\n      return !updatedFiles[file].progress.uploadComplete && updatedFiles[file].progress.uploadStarted;\n    });\n    inProgressUpdatedFiles.forEach(file => {\n      const updatedFile = {\n        ...updatedFiles[file],\n        isPaused: true\n      };\n      updatedFiles[file] = updatedFile;\n    });\n    this.setState({\n      files: updatedFiles\n    });\n    this.emit('pause-all');\n  }\n  resumeAll() {\n    const updatedFiles = {\n      ...this.getState().files\n    };\n    const inProgressUpdatedFiles = Object.keys(updatedFiles).filter(file => {\n      return !updatedFiles[file].progress.uploadComplete && updatedFiles[file].progress.uploadStarted;\n    });\n    inProgressUpdatedFiles.forEach(file => {\n      const updatedFile = {\n        ...updatedFiles[file],\n        isPaused: false,\n        error: null\n      };\n      updatedFiles[file] = updatedFile;\n    });\n    this.setState({\n      files: updatedFiles\n    });\n    this.emit('resume-all');\n  }\n  retryAll() {\n    const updatedFiles = {\n      ...this.getState().files\n    };\n    const filesToRetry = Object.keys(updatedFiles).filter(file => {\n      return updatedFiles[file].error;\n    });\n    filesToRetry.forEach(file => {\n      const updatedFile = {\n        ...updatedFiles[file],\n        isPaused: false,\n        error: null\n      };\n      updatedFiles[file] = updatedFile;\n    });\n    this.setState({\n      files: updatedFiles,\n      error: null\n    });\n    this.emit('retry-all', filesToRetry);\n    if (filesToRetry.length === 0) {\n      return Promise.resolve({\n        successful: [],\n        failed: []\n      });\n    }\n    const uploadID = _classPrivateFieldLooseBase(this, _createUpload)[_createUpload](filesToRetry, {\n      forceAllowNewUpload: true // create new upload even if allowNewUpload: false\n    });\n\n    return _classPrivateFieldLooseBase(this, _runUpload)[_runUpload](uploadID);\n  }\n  cancelAll(_temp) {\n    let {\n      reason = 'user'\n    } = _temp === void 0 ? {} : _temp;\n    this.emit('cancel-all', {\n      reason\n    });\n\n    // Only remove existing uploads if user is canceling\n    if (reason === 'user') {\n      const {\n        files\n      } = this.getState();\n      const fileIDs = Object.keys(files);\n      if (fileIDs.length) {\n        this.removeFiles(fileIDs, 'cancel-all');\n      }\n      this.setState({\n        totalProgress: 0,\n        error: null,\n        recoveredState: null\n      });\n    }\n  }\n  retryUpload(fileID) {\n    this.setFileState(fileID, {\n      error: null,\n      isPaused: false\n    });\n    this.emit('upload-retry', fileID);\n    const uploadID = _classPrivateFieldLooseBase(this, _createUpload)[_createUpload]([fileID], {\n      forceAllowNewUpload: true // create new upload even if allowNewUpload: false\n    });\n\n    return _classPrivateFieldLooseBase(this, _runUpload)[_runUpload](uploadID);\n  }\n  logout() {\n    this.iteratePlugins(plugin => {\n      if (plugin.provider && plugin.provider.logout) {\n        plugin.provider.logout();\n      }\n    });\n  }\n  calculateTotalProgress() {\n    // calculate total progress, using the number of files currently uploading,\n    // multiplied by 100 and the summ of individual progress of each file\n    const files = this.getFiles();\n    const inProgress = files.filter(file => {\n      return file.progress.uploadStarted || file.progress.preprocess || file.progress.postprocess;\n    });\n    if (inProgress.length === 0) {\n      this.emit('progress', 0);\n      this.setState({\n        totalProgress: 0\n      });\n      return;\n    }\n    const sizedFiles = inProgress.filter(file => file.progress.bytesTotal != null);\n    const unsizedFiles = inProgress.filter(file => file.progress.bytesTotal == null);\n    if (sizedFiles.length === 0) {\n      const progressMax = inProgress.length * 100;\n      const currentProgress = unsizedFiles.reduce((acc, file) => {\n        return acc + file.progress.percentage;\n      }, 0);\n      const totalProgress = Math.round(currentProgress / progressMax * 100);\n      this.setState({\n        totalProgress\n      });\n      return;\n    }\n    let totalSize = sizedFiles.reduce((acc, file) => {\n      return acc + file.progress.bytesTotal;\n    }, 0);\n    const averageSize = totalSize / sizedFiles.length;\n    totalSize += averageSize * unsizedFiles.length;\n    let uploadedSize = 0;\n    sizedFiles.forEach(file => {\n      uploadedSize += file.progress.bytesUploaded;\n    });\n    unsizedFiles.forEach(file => {\n      uploadedSize += averageSize * (file.progress.percentage || 0) / 100;\n    });\n    let totalProgress = totalSize === 0 ? 0 : Math.round(uploadedSize / totalSize * 100);\n\n    // hot fix, because:\n    // uploadedSize ended up larger than totalSize, resulting in 1325% total\n    if (totalProgress > 100) {\n      totalProgress = 100;\n    }\n    this.setState({\n      totalProgress\n    });\n    this.emit('progress', totalProgress);\n  }\n  updateOnlineStatus() {\n    const online = typeof window.navigator.onLine !== 'undefined' ? window.navigator.onLine : true;\n    if (!online) {\n      this.emit('is-offline');\n      this.info(this.i18n('noInternetConnection'), 'error', 0);\n      this.wasOffline = true;\n    } else {\n      this.emit('is-online');\n      if (this.wasOffline) {\n        this.emit('back-online');\n        this.info(this.i18n('connectedToInternet'), 'success', 3000);\n        this.wasOffline = false;\n      }\n    }\n  }\n  getID() {\n    return this.opts.id;\n  }\n\n  /**\n   * Registers a plugin with Core.\n   *\n   * @param {object} Plugin object\n   * @param {object} [opts] object with options to be passed to Plugin\n   * @returns {object} self for chaining\n   */\n  // eslint-disable-next-line no-shadow\n  use(Plugin, opts) {\n    if (typeof Plugin !== 'function') {\n      const msg = `Expected a plugin class, but got ${Plugin === null ? 'null' : typeof Plugin}.` + ' Please verify that the plugin was imported and spelled correctly.';\n      throw new TypeError(msg);\n    }\n\n    // Instantiate\n    const plugin = new Plugin(this, opts);\n    const pluginId = plugin.id;\n    if (!pluginId) {\n      throw new Error('Your plugin must have an id');\n    }\n    if (!plugin.type) {\n      throw new Error('Your plugin must have a type');\n    }\n    const existsPluginAlready = this.getPlugin(pluginId);\n    if (existsPluginAlready) {\n      const msg = `Already found a plugin named '${existsPluginAlready.id}'. ` + `Tried to use: '${pluginId}'.\\n` + 'Uppy plugins must have unique `id` options. See https://uppy.io/docs/plugins/#id.';\n      throw new Error(msg);\n    }\n    if (Plugin.VERSION) {\n      this.log(`Using ${pluginId} v${Plugin.VERSION}`);\n    }\n    if (plugin.type in _classPrivateFieldLooseBase(this, _plugins)[_plugins]) {\n      _classPrivateFieldLooseBase(this, _plugins)[_plugins][plugin.type].push(plugin);\n    } else {\n      _classPrivateFieldLooseBase(this, _plugins)[_plugins][plugin.type] = [plugin];\n    }\n    plugin.install();\n    return this;\n  }\n\n  /**\n   * Find one Plugin by name.\n   *\n   * @param {string} id plugin id\n   * @returns {BasePlugin|undefined}\n   */\n  getPlugin(id) {\n    for (const plugins of Object.values(_classPrivateFieldLooseBase(this, _plugins)[_plugins])) {\n      const foundPlugin = plugins.find(plugin => plugin.id === id);\n      if (foundPlugin != null) return foundPlugin;\n    }\n    return undefined;\n  }\n  [_Symbol$for](type) {\n    return _classPrivateFieldLooseBase(this, _plugins)[_plugins][type];\n  }\n\n  /**\n   * Iterate through all `use`d plugins.\n   *\n   * @param {Function} method that will be run on each plugin\n   */\n  iteratePlugins(method) {\n    Object.values(_classPrivateFieldLooseBase(this, _plugins)[_plugins]).flat(1).forEach(method);\n  }\n\n  /**\n   * Uninstall and remove a plugin.\n   *\n   * @param {object} instance The plugin instance to remove.\n   */\n  removePlugin(instance) {\n    this.log(`Removing plugin ${instance.id}`);\n    this.emit('plugin-remove', instance);\n    if (instance.uninstall) {\n      instance.uninstall();\n    }\n    const list = _classPrivateFieldLooseBase(this, _plugins)[_plugins][instance.type];\n    // list.indexOf failed here, because Vue3 converted the plugin instance\n    // to a Proxy object, which failed the strict comparison test:\n    // obj !== objProxy\n    const index = list.findIndex(item => item.id === instance.id);\n    if (index !== -1) {\n      list.splice(index, 1);\n    }\n    const state = this.getState();\n    const updatedState = {\n      plugins: {\n        ...state.plugins,\n        [instance.id]: undefined\n      }\n    };\n    this.setState(updatedState);\n  }\n\n  /**\n   * Uninstall all plugins and close down this Uppy instance.\n   */\n  close(_temp2) {\n    let {\n      reason\n    } = _temp2 === void 0 ? {} : _temp2;\n    this.log(`Closing Uppy instance ${this.opts.id}: removing all files and uninstalling plugins`);\n    this.cancelAll({\n      reason\n    });\n    _classPrivateFieldLooseBase(this, _storeUnsubscribe)[_storeUnsubscribe]();\n    this.iteratePlugins(plugin => {\n      this.removePlugin(plugin);\n    });\n    if (typeof window !== 'undefined' && window.removeEventListener) {\n      window.removeEventListener('online', _classPrivateFieldLooseBase(this, _updateOnlineStatus)[_updateOnlineStatus]);\n      window.removeEventListener('offline', _classPrivateFieldLooseBase(this, _updateOnlineStatus)[_updateOnlineStatus]);\n    }\n  }\n  hideInfo() {\n    const {\n      info\n    } = this.getState();\n    this.setState({\n      info: info.slice(1)\n    });\n    this.emit('info-hidden');\n  }\n\n  /**\n   * Set info message in `state.info`, so that UI plugins like `Informer`\n   * can display the message.\n   *\n   * @param {string | object} message Message to be displayed by the informer\n   * @param {string} [type]\n   * @param {number} [duration]\n   */\n  info(message, type, duration) {\n    if (type === void 0) {\n      type = 'info';\n    }\n    if (duration === void 0) {\n      duration = 3000;\n    }\n    const isComplexMessage = typeof message === 'object';\n    this.setState({\n      info: [...this.getState().info, {\n        type,\n        message: isComplexMessage ? message.message : message,\n        details: isComplexMessage ? message.details : null\n      }]\n    });\n    setTimeout(() => this.hideInfo(), duration);\n    this.emit('info-visible');\n  }\n\n  /**\n   * Passes messages to a function, provided in `opts.logger`.\n   * If `opts.logger: Uppy.debugLogger` or `opts.debug: true`, logs to the browser console.\n   *\n   * @param {string|object} message to log\n   * @param {string} [type] optional `error` or `warning`\n   */\n  log(message, type) {\n    const {\n      logger\n    } = this.opts;\n    switch (type) {\n      case 'error':\n        logger.error(message);\n        break;\n      case 'warning':\n        logger.warn(message);\n        break;\n      default:\n        logger.debug(message);\n        break;\n    }\n  }\n\n  /**\n   * Restore an upload by its ID.\n   */\n  restore(uploadID) {\n    this.log(`Core: attempting to restore upload \"${uploadID}\"`);\n    if (!this.getState().currentUploads[uploadID]) {\n      _classPrivateFieldLooseBase(this, _removeUpload)[_removeUpload](uploadID);\n      return Promise.reject(new Error('Nonexistent upload'));\n    }\n    return _classPrivateFieldLooseBase(this, _runUpload)[_runUpload](uploadID);\n  }\n  [_Symbol$for2]() {\n    return _classPrivateFieldLooseBase(this, _createUpload)[_createUpload](...arguments);\n  }\n  /**\n   * Add data to an upload's result object.\n   *\n   * @param {string} uploadID The ID of the upload.\n   * @param {object} data Data properties to add to the result object.\n   */\n  addResultData(uploadID, data) {\n    if (!_classPrivateFieldLooseBase(this, _getUpload)[_getUpload](uploadID)) {\n      this.log(`Not setting result for an upload that has been removed: ${uploadID}`);\n      return;\n    }\n    const {\n      currentUploads\n    } = this.getState();\n    const currentUpload = {\n      ...currentUploads[uploadID],\n      result: {\n        ...currentUploads[uploadID].result,\n        ...data\n      }\n    };\n    this.setState({\n      currentUploads: {\n        ...currentUploads,\n        [uploadID]: currentUpload\n      }\n    });\n  }\n  /**\n   * Start an upload for all the files that are not currently being uploaded.\n   *\n   * @returns {Promise}\n   */\n  upload() {\n    var _classPrivateFieldLoo;\n    if (!((_classPrivateFieldLoo = _classPrivateFieldLooseBase(this, _plugins)[_plugins].uploader) != null && _classPrivateFieldLoo.length)) {\n      this.log('No uploader type plugins are used', 'warning');\n    }\n    let {\n      files\n    } = this.getState();\n    const onBeforeUploadResult = this.opts.onBeforeUpload(files);\n    if (onBeforeUploadResult === false) {\n      return Promise.reject(new Error('Not starting the upload because onBeforeUpload returned false'));\n    }\n    if (onBeforeUploadResult && typeof onBeforeUploadResult === 'object') {\n      files = onBeforeUploadResult;\n      // Updating files in state, because uploader plugins receive file IDs,\n      // and then fetch the actual file object from state\n      this.setState({\n        files\n      });\n    }\n    return Promise.resolve().then(() => _classPrivateFieldLooseBase(this, _restricter)[_restricter].validateMinNumberOfFiles(files)).catch(err => {\n      _classPrivateFieldLooseBase(this, _informAndEmit)[_informAndEmit]([err]);\n      throw err;\n    }).then(() => {\n      if (!_classPrivateFieldLooseBase(this, _checkRequiredMetaFields)[_checkRequiredMetaFields](files)) {\n        throw new RestrictionError(this.i18n('missingRequiredMetaField'));\n      }\n    }).catch(err => {\n      // Doing this in a separate catch because we already emited and logged\n      // all the errors in `checkRequiredMetaFields` so we only throw a generic\n      // missing fields error here.\n      throw err;\n    }).then(() => {\n      const {\n        currentUploads\n      } = this.getState();\n      // get a list of files that are currently assigned to uploads\n      const currentlyUploadingFiles = Object.values(currentUploads).flatMap(curr => curr.fileIDs);\n      const waitingFileIDs = [];\n      Object.keys(files).forEach(fileID => {\n        const file = this.getFile(fileID);\n        // if the file hasn't started uploading and hasn't already been assigned to an upload..\n        if (!file.progress.uploadStarted && currentlyUploadingFiles.indexOf(fileID) === -1) {\n          waitingFileIDs.push(file.id);\n        }\n      });\n      const uploadID = _classPrivateFieldLooseBase(this, _createUpload)[_createUpload](waitingFileIDs);\n      return _classPrivateFieldLooseBase(this, _runUpload)[_runUpload](uploadID);\n    }).catch(err => {\n      this.emit('error', err);\n      this.log(err, 'error');\n      throw err;\n    });\n  }\n}\nfunction _informAndEmit2(errors) {\n  for (const error of errors) {\n    const {\n      file,\n      isRestriction\n    } = error;\n    if (isRestriction) {\n      this.emit('restriction-failed', file, error);\n    } else {\n      this.emit('error', error);\n    }\n    this.log(error, 'warning');\n  }\n  const userFacingErrors = errors.filter(error => error.isUserFacing);\n\n  // don't flood the user: only show the first 4 toasts\n  const maxNumToShow = 4;\n  const firstErrors = userFacingErrors.slice(0, maxNumToShow);\n  const additionalErrors = userFacingErrors.slice(maxNumToShow);\n  firstErrors.forEach(_ref3 => {\n    let {\n      message,\n      details = ''\n    } = _ref3;\n    this.info({\n      message,\n      details\n    }, 'error', this.opts.infoTimeout);\n  });\n  if (additionalErrors.length > 0) {\n    this.info({\n      message: this.i18n('additionalRestrictionsFailed', {\n        count: additionalErrors.length\n      })\n    });\n  }\n}\nfunction _checkRequiredMetaFieldsOnFile2(file) {\n  const {\n    missingFields,\n    error\n  } = _classPrivateFieldLooseBase(this, _restricter)[_restricter].getMissingRequiredMetaFields(file);\n  if (missingFields.length > 0) {\n    this.setFileState(file.id, {\n      missingRequiredMetaFields: missingFields\n    });\n    this.log(error.message);\n    this.emit('restriction-failed', file, error);\n    return false;\n  }\n  return true;\n}\nfunction _checkRequiredMetaFields2(files) {\n  let success = true;\n  for (const file of Object.values(files)) {\n    if (!_classPrivateFieldLooseBase(this, _checkRequiredMetaFieldsOnFile)[_checkRequiredMetaFieldsOnFile](file)) {\n      success = false;\n    }\n  }\n  return success;\n}\nfunction _assertNewUploadAllowed2(file) {\n  const {\n    allowNewUpload\n  } = this.getState();\n  if (allowNewUpload === false) {\n    const error = new RestrictionError(this.i18n('noMoreFilesAllowed'), {\n      file\n    });\n    _classPrivateFieldLooseBase(this, _informAndEmit)[_informAndEmit]([error]);\n    throw error;\n  }\n}\nfunction _transformFile2(fileDescriptorOrFile) {\n  // Uppy expects files in { name, type, size, data } format.\n  // If the actual File object is passed from input[type=file] or drag-drop,\n  // we normalize it to match Uppy file object\n  const fileDescriptor = fileDescriptorOrFile instanceof File ? {\n    name: fileDescriptorOrFile.name,\n    type: fileDescriptorOrFile.type,\n    size: fileDescriptorOrFile.size,\n    data: fileDescriptorOrFile\n  } : fileDescriptorOrFile;\n  const fileType = getFileType(fileDescriptor);\n  const fileName = getFileName(fileType, fileDescriptor);\n  const fileExtension = getFileNameAndExtension(fileName).extension;\n  const isRemote = Boolean(fileDescriptor.isRemote);\n  const id = getSafeFileId(fileDescriptor);\n  const meta = fileDescriptor.meta || {};\n  meta.name = fileName;\n  meta.type = fileType;\n\n  // `null` means the size is unknown.\n  const size = Number.isFinite(fileDescriptor.data.size) ? fileDescriptor.data.size : null;\n  return {\n    source: fileDescriptor.source || '',\n    id,\n    name: fileName,\n    extension: fileExtension || '',\n    meta: {\n      ...this.getState().meta,\n      ...meta\n    },\n    type: fileType,\n    data: fileDescriptor.data,\n    progress: {\n      percentage: 0,\n      bytesUploaded: 0,\n      bytesTotal: size,\n      uploadComplete: false,\n      uploadStarted: null\n    },\n    size,\n    isRemote,\n    remote: fileDescriptor.remote || '',\n    preview: fileDescriptor.preview\n  };\n}\nfunction _startIfAutoProceed2() {\n  if (this.opts.autoProceed && !this.scheduledAutoProceed) {\n    this.scheduledAutoProceed = setTimeout(() => {\n      this.scheduledAutoProceed = null;\n      this.upload().catch(err => {\n        if (!err.isRestriction) {\n          this.log(err.stack || err.message || err);\n        }\n      });\n    }, 4);\n  }\n}\nfunction _checkAndUpdateFileState2(filesToAdd) {\n  const {\n    files: existingFiles\n  } = this.getState();\n\n  // create a copy of the files object only once\n  const nextFilesState = {\n    ...existingFiles\n  };\n  const validFilesToAdd = [];\n  const errors = [];\n  for (const fileToAdd of filesToAdd) {\n    try {\n      var _existingFiles$newFil;\n      let newFile = _classPrivateFieldLooseBase(this, _transformFile)[_transformFile](fileToAdd);\n\n      // If a file has been recovered (Golden Retriever), but we were unable to recover its data (probably too large),\n      // users are asked to re-select these half-recovered files and then this method will be called again.\n      // In order to keep the progress, meta and everthing else, we keep the existing file,\n      // but we replace `data`, and we remove `isGhost`, because the file is no longer a ghost now\n      if ((_existingFiles$newFil = existingFiles[newFile.id]) != null && _existingFiles$newFil.isGhost) {\n        const {\n          isGhost,\n          ...existingFileState\n        } = existingFiles[newFile.id];\n        newFile = {\n          ...existingFileState,\n          data: fileToAdd.data\n        };\n        this.log(`Replaced the blob in the restored ghost file: ${newFile.name}, ${newFile.id}`);\n      }\n      if (this.checkIfFileAlreadyExists(newFile.id)) {\n        throw new RestrictionError(this.i18n('noDuplicates', {\n          fileName: newFile.name\n        }), {\n          file: fileToAdd\n        });\n      }\n      const onBeforeFileAddedResult = this.opts.onBeforeFileAdded(newFile, nextFilesState);\n      if (onBeforeFileAddedResult === false) {\n        // Don’t show UI info for this error, as it should be done by the developer\n        throw new RestrictionError('Cannot add the file because onBeforeFileAdded returned false.', {\n          isUserFacing: false,\n          file: fileToAdd\n        });\n      } else if (typeof onBeforeFileAddedResult === 'object' && onBeforeFileAddedResult !== null) {\n        newFile = onBeforeFileAddedResult;\n      }\n      _classPrivateFieldLooseBase(this, _restricter)[_restricter].validateSingleFile(newFile);\n\n      // need to add it to the new local state immediately, so we can use the state to validate the next files too\n      nextFilesState[newFile.id] = newFile;\n      validFilesToAdd.push(newFile);\n    } catch (err) {\n      errors.push(err);\n    }\n  }\n  try {\n    // need to run this separately because it's much more slow, so if we run it inside the for-loop it will be very slow\n    // when many files are added\n    _classPrivateFieldLooseBase(this, _restricter)[_restricter].validateAggregateRestrictions(Object.values(existingFiles), validFilesToAdd);\n  } catch (err) {\n    errors.push(err);\n\n    // If we have any aggregate error, don't allow adding this batch\n    return {\n      nextFilesState: existingFiles,\n      validFilesToAdd: [],\n      errors\n    };\n  }\n  return {\n    nextFilesState,\n    validFilesToAdd,\n    errors\n  };\n}\nfunction _addListeners2() {\n  /**\n   * @param {Error} error\n   * @param {object} [file]\n   * @param {object} [response]\n   */\n  const errorHandler = (error, file, response) => {\n    let errorMsg = error.message || 'Unknown error';\n    if (error.details) {\n      errorMsg += ` ${error.details}`;\n    }\n    this.setState({\n      error: errorMsg\n    });\n    if (file != null && file.id in this.getState().files) {\n      this.setFileState(file.id, {\n        error: errorMsg,\n        response\n      });\n    }\n  };\n  this.on('error', errorHandler);\n  this.on('upload-error', (file, error, response) => {\n    errorHandler(error, file, response);\n    if (typeof error === 'object' && error.message) {\n      this.log(error.message, 'error');\n      const newError = new Error(this.i18n('failedToUpload', {\n        file: file == null ? void 0 : file.name\n      }));\n      newError.isUserFacing = true; // todo maybe don't do this with all errors?\n      newError.details = error.message;\n      if (error.details) {\n        newError.details += ` ${error.details}`;\n      }\n      _classPrivateFieldLooseBase(this, _informAndEmit)[_informAndEmit]([newError]);\n    } else {\n      _classPrivateFieldLooseBase(this, _informAndEmit)[_informAndEmit]([error]);\n    }\n  });\n  let uploadStalledWarningRecentlyEmitted;\n  this.on('upload-stalled', (error, files) => {\n    const {\n      message\n    } = error;\n    const details = files.map(file => file.meta.name).join(', ');\n    if (!uploadStalledWarningRecentlyEmitted) {\n      this.info({\n        message,\n        details\n      }, 'warning', this.opts.infoTimeout);\n      uploadStalledWarningRecentlyEmitted = setTimeout(() => {\n        uploadStalledWarningRecentlyEmitted = null;\n      }, this.opts.infoTimeout);\n    }\n    this.log(`${message} ${details}`.trim(), 'warning');\n  });\n  this.on('upload', () => {\n    this.setState({\n      error: null\n    });\n  });\n  const onUploadStarted = files => {\n    const filesFiltered = files.filter(file => {\n      const exists = file != null && this.getFile(file.id);\n      if (!exists) this.log(`Not setting progress for a file that has been removed: ${file == null ? void 0 : file.id}`);\n      return exists;\n    });\n    const filesState = Object.fromEntries(filesFiltered.map(file => [file.id, {\n      progress: {\n        uploadStarted: Date.now(),\n        uploadComplete: false,\n        percentage: 0,\n        bytesUploaded: 0,\n        bytesTotal: file.size\n      }\n    }]));\n    this.patchFilesState(filesState);\n  };\n  this.on('upload-start', files => {\n    files.forEach(file => {\n      // todo backward compat, remove this event in a next major\n      this.emit('upload-started', file);\n    });\n    onUploadStarted(files);\n  });\n  this.on('upload-progress', this.calculateProgress);\n  this.on('upload-success', (file, uploadResp) => {\n    if (file == null || !this.getFile(file.id)) {\n      this.log(`Not setting progress for a file that has been removed: ${file == null ? void 0 : file.id}`);\n      return;\n    }\n    const currentProgress = this.getFile(file.id).progress;\n    this.setFileState(file.id, {\n      progress: {\n        ...currentProgress,\n        postprocess: _classPrivateFieldLooseBase(this, _postProcessors)[_postProcessors].size > 0 ? {\n          mode: 'indeterminate'\n        } : null,\n        uploadComplete: true,\n        percentage: 100,\n        bytesUploaded: currentProgress.bytesTotal\n      },\n      response: uploadResp,\n      uploadURL: uploadResp.uploadURL,\n      isPaused: false\n    });\n\n    // Remote providers sometimes don't tell us the file size,\n    // but we can know how many bytes we uploaded once the upload is complete.\n    if (file.size == null) {\n      this.setFileState(file.id, {\n        size: uploadResp.bytesUploaded || currentProgress.bytesTotal\n      });\n    }\n    this.calculateTotalProgress();\n  });\n  this.on('preprocess-progress', (file, progress) => {\n    if (file == null || !this.getFile(file.id)) {\n      this.log(`Not setting progress for a file that has been removed: ${file == null ? void 0 : file.id}`);\n      return;\n    }\n    this.setFileState(file.id, {\n      progress: {\n        ...this.getFile(file.id).progress,\n        preprocess: progress\n      }\n    });\n  });\n  this.on('preprocess-complete', file => {\n    if (file == null || !this.getFile(file.id)) {\n      this.log(`Not setting progress for a file that has been removed: ${file == null ? void 0 : file.id}`);\n      return;\n    }\n    const files = {\n      ...this.getState().files\n    };\n    files[file.id] = {\n      ...files[file.id],\n      progress: {\n        ...files[file.id].progress\n      }\n    };\n    delete files[file.id].progress.preprocess;\n    this.setState({\n      files\n    });\n  });\n  this.on('postprocess-progress', (file, progress) => {\n    if (file == null || !this.getFile(file.id)) {\n      this.log(`Not setting progress for a file that has been removed: ${file == null ? void 0 : file.id}`);\n      return;\n    }\n    this.setFileState(file.id, {\n      progress: {\n        ...this.getState().files[file.id].progress,\n        postprocess: progress\n      }\n    });\n  });\n  this.on('postprocess-complete', file => {\n    if (file == null || !this.getFile(file.id)) {\n      this.log(`Not setting progress for a file that has been removed: ${file == null ? void 0 : file.id}`);\n      return;\n    }\n    const files = {\n      ...this.getState().files\n    };\n    files[file.id] = {\n      ...files[file.id],\n      progress: {\n        ...files[file.id].progress\n      }\n    };\n    delete files[file.id].progress.postprocess;\n    this.setState({\n      files\n    });\n  });\n  this.on('restored', () => {\n    // Files may have changed--ensure progress is still accurate.\n    this.calculateTotalProgress();\n  });\n  this.on('dashboard:file-edit-complete', file => {\n    if (file) {\n      _classPrivateFieldLooseBase(this, _checkRequiredMetaFieldsOnFile)[_checkRequiredMetaFieldsOnFile](file);\n    }\n  });\n\n  // show informer if offline\n  if (typeof window !== 'undefined' && window.addEventListener) {\n    window.addEventListener('online', _classPrivateFieldLooseBase(this, _updateOnlineStatus)[_updateOnlineStatus]);\n    window.addEventListener('offline', _classPrivateFieldLooseBase(this, _updateOnlineStatus)[_updateOnlineStatus]);\n    setTimeout(_classPrivateFieldLooseBase(this, _updateOnlineStatus)[_updateOnlineStatus], 3000);\n  }\n}\nfunction _createUpload2(fileIDs, opts) {\n  if (opts === void 0) {\n    opts = {};\n  }\n  // uppy.retryAll sets this to true — when retrying we want to ignore `allowNewUpload: false`\n  const {\n    forceAllowNewUpload = false\n  } = opts;\n  const {\n    allowNewUpload,\n    currentUploads\n  } = this.getState();\n  if (!allowNewUpload && !forceAllowNewUpload) {\n    throw new Error('Cannot create a new upload: already uploading.');\n  }\n  const uploadID = nanoid();\n  this.emit('upload', {\n    id: uploadID,\n    fileIDs\n  });\n  this.setState({\n    allowNewUpload: this.opts.allowMultipleUploadBatches !== false && this.opts.allowMultipleUploads !== false,\n    currentUploads: {\n      ...currentUploads,\n      [uploadID]: {\n        fileIDs,\n        step: 0,\n        result: {}\n      }\n    }\n  });\n  return uploadID;\n}\nfunction _getUpload2(uploadID) {\n  const {\n    currentUploads\n  } = this.getState();\n  return currentUploads[uploadID];\n}\nfunction _removeUpload2(uploadID) {\n  const currentUploads = {\n    ...this.getState().currentUploads\n  };\n  delete currentUploads[uploadID];\n  this.setState({\n    currentUploads\n  });\n}\nasync function _runUpload2(uploadID) {\n  const getCurrentUpload = () => {\n    const {\n      currentUploads\n    } = this.getState();\n    return currentUploads[uploadID];\n  };\n  let currentUpload = getCurrentUpload();\n  const steps = [..._classPrivateFieldLooseBase(this, _preProcessors)[_preProcessors], ..._classPrivateFieldLooseBase(this, _uploaders)[_uploaders], ..._classPrivateFieldLooseBase(this, _postProcessors)[_postProcessors]];\n  try {\n    for (let step = currentUpload.step || 0; step < steps.length; step++) {\n      if (!currentUpload) {\n        break;\n      }\n      const fn = steps[step];\n      this.setState({\n        currentUploads: {\n          ...this.getState().currentUploads,\n          [uploadID]: {\n            ...currentUpload,\n            step\n          }\n        }\n      });\n      const {\n        fileIDs\n      } = currentUpload;\n\n      // TODO give this the `updatedUpload` object as its only parameter maybe?\n      // Otherwise when more metadata may be added to the upload this would keep getting more parameters\n      await fn(fileIDs, uploadID);\n\n      // Update currentUpload value in case it was modified asynchronously.\n      currentUpload = getCurrentUpload();\n    }\n  } catch (err) {\n    _classPrivateFieldLooseBase(this, _removeUpload)[_removeUpload](uploadID);\n    throw err;\n  }\n\n  // Set result data.\n  if (currentUpload) {\n    // Mark postprocessing step as complete if necessary; this addresses a case where we might get\n    // stuck in the postprocessing UI while the upload is fully complete.\n    // If the postprocessing steps do not do any work, they may not emit postprocessing events at\n    // all, and never mark the postprocessing as complete. This is fine on its own but we\n    // introduced code in the @uppy/core upload-success handler to prepare postprocessing progress\n    // state if any postprocessors are registered. That is to avoid a \"flash of completed state\"\n    // before the postprocessing plugins can emit events.\n    //\n    // So, just in case an upload with postprocessing plugins *has* completed *without* emitting\n    // postprocessing completion, we do it instead.\n    currentUpload.fileIDs.forEach(fileID => {\n      const file = this.getFile(fileID);\n      if (file && file.progress.postprocess) {\n        this.emit('postprocess-complete', file);\n      }\n    });\n    const files = currentUpload.fileIDs.map(fileID => this.getFile(fileID));\n    const successful = files.filter(file => !file.error);\n    const failed = files.filter(file => file.error);\n    await this.addResultData(uploadID, {\n      successful,\n      failed,\n      uploadID\n    });\n\n    // Update currentUpload value in case it was modified asynchronously.\n    currentUpload = getCurrentUpload();\n  }\n  // Emit completion events.\n  // This is in a separate function so that the `currentUploads` variable\n  // always refers to the latest state. In the handler right above it refers\n  // to an outdated object without the `.result` property.\n  let result;\n  if (currentUpload) {\n    result = currentUpload.result;\n    this.emit('complete', result);\n    _classPrivateFieldLooseBase(this, _removeUpload)[_removeUpload](uploadID);\n  }\n  if (result == null) {\n    this.log(`Not setting result for an upload that has been removed: ${uploadID}`);\n  }\n  return result;\n}\nUppy.VERSION = packageJson.version;\nexport default Uppy;"],"names":["_Symbol$for","_Symbol$for2","_classPrivateFieldLooseBase","receiver","privateKey","Object","prototype","hasOwnProperty","call","TypeError","id","_classPrivateFieldLooseKey","name","_plugins","_restricter","_storeUnsubscribe","_emitter","_preProcessors","_uploaders","_postProcessors","_informAndEmit","_checkRequiredMetaFieldsOnFile","_checkRequiredMetaFields","_assertNewUploadAllowed","_transformFile","_startIfAutoProceed","_checkAndUpdateFileState","_addListeners","_updateOnlineStatus","_createUpload","_getUpload","_removeUpload","_runUpload","Symbol","for","Uppy","constructor","_opts","defineProperty","this","value","_runUpload2","_removeUpload2","_getUpload2","_createUpload2","_addListeners2","_checkAndUpdateFileState2","_startIfAutoProceed2","_transformFile2","_assertNewUploadAllowed2","_checkRequiredMetaFields2","_checkRequiredMetaFieldsOnFile2","_informAndEmit2","writable","create","Set","calculateProgress","file","data","fileInState","getFile","log","progress","percentage","canHavePercentage","Number","isFinite","bytesTotal","setFileState","bytesUploaded","Math","round","calculateTotalProgress","leading","trailing","updateOnlineStatus","bind","defaultLocale","defaultOptions","autoProceed","allowMultipleUploadBatches","debug","restrictions","meta","onBeforeFileAdded","currentFile","onBeforeUpload","files","store","logger","infoTimeout","opts","VERSION","i18nInit","setState","plugins","currentUploads","allowNewUpload","capabilities","uploadProgress","individualCancellation","resumableUploads","totalProgress","info","recoveredState","i18n","subscribe","prevState","nextState","patch","emit","updateAll","window","event","_len","arguments","length","args","Array","_key","on","callback","once","off","state","iteratePlugins","plugin","update","getState","patchFilesState","filesWithNewState","existingFilesState","fromEntries","entries","map","_ref","fileID","newFileState","Error","translator","locale","translate","i18nArray","translateArray","setOptions","newOpts","setMeta","resetProgress","defaultProgress","uploadComplete","uploadStarted","updatedFiles","keys","forEach","error","addPreProcessor","fn","add","removePreProcessor","delete","addPostProcessor","removePostProcessor","addUploader","removeUploader","updatedMeta","setFileMeta","newMeta","getFiles","values","getFilesByIds","ids","getObjectOfFilesPerState","filesObject","inProgressFiles","filter","_ref2","newFiles","startedFiles","preprocess","postprocess","uploadStartedFiles","pausedFiles","isPaused","completeFiles","erroredFiles","inProgressNotPausedFiles","processingFiles","isUploadStarted","isAllComplete","isAllErrored","isAllPaused","isUploadInProgress","isSomeGhost","some","isGhost","validateRestrictions","validate","err","checkIfFileAlreadyExists","addFile","nextFilesState","validFilesToAdd","errors","restrictionErrors","isRestriction","firstValidFileToAdd","type","addFiles","fileDescriptors","nonRestrictionErrors","message","subError","smart_count","details","AggregateError","removeFiles","fileIDs","reason","updatedUploads","removedFiles","fileIsNotRemoved","uploadFileID","undefined","uploadID","newFileIDs","stateUpdate","removedFileIDs","join","removeFile","pauseResume","pauseAll","updatedFile","resumeAll","retryAll","filesToRetry","Promise","resolve","successful","failed","forceAllowNewUpload","cancelAll","_temp","retryUpload","logout","provider","inProgress","sizedFiles","unsizedFiles","progressMax","currentProgress","reduce","acc","totalSize","averageSize","uploadedSize","navigator","onLine","wasOffline","getID","use","Plugin","pluginId","existsPluginAlready","getPlugin","msg","push","install","foundPlugin","find","method","flat","removePlugin","instance","uninstall","list","index","findIndex","item","splice","updatedState","close","_temp2","removeEventListener","hideInfo","slice","duration","isComplexMessage","setTimeout","warn","restore","reject","addResultData","currentUpload","result","upload","_classPrivateFieldLoo","uploader","onBeforeUploadResult","then","validateMinNumberOfFiles","catch","currentlyUploadingFiles","flatMap","curr","waitingFileIDs","indexOf","userFacingErrors","isUserFacing","firstErrors","additionalErrors","_ref3","count","missingFields","getMissingRequiredMetaFields","missingRequiredMetaFields","success","fileDescriptorOrFile","fileDescriptor","File","size","fileType","fileName","fileExtension","extension","isRemote","Boolean","source","remote","preview","scheduledAutoProceed","stack","filesToAdd","existingFiles","fileToAdd","_existingFiles$newFil","newFile","existingFileState","onBeforeFileAddedResult","validateSingleFile","validateAggregateRestrictions","errorHandler","response","errorMsg","uploadStalledWarningRecentlyEmitted","newError","trim","onUploadStarted","filesFiltered","exists","filesState","Date","now","uploadResp","mode","uploadURL","addEventListener","allowMultipleUploads","step","async","getCurrentUpload","steps"],"sourceRoot":""}