El error desconocido $jscomp no está definido en uploadFile

Estoy enfrentando un error extraño que no puedo rastrear correctamente. Ocurre cuando arrastro y suelto una imagen para subirla.

! imagen

Cuando hago clic en la línea "at fetchFile (grapes.js:17107)" veo esta función

fetchFile: función fetchFile() {
    var model = this.model;
    var file = model.get('file');

if (archivo) {
      var fu = this.em.get('Gestor de Activos'). FileUploader();
      fu.uploadFile({
        dataTransfer: { archivos: [archivo] }
      }, función (res) {
        var obj = res && res.data && res.data[0];
        var src = obj & & obj.src;
        src && model.set({ src: src });
      });
      model.set ('archivo', '');
    }
  },

Por favor, ten en cuenta que he modificado el uploadFile con el siguiente código que he adaptado de la fuente original

Gestor de activos
    const initialAsset = {
        Upload: True, //Desactivar las subidas
        assets: assetsImágenes, //Assets como array
        openAssetsOnDrop: 0, //// Abre el gestor de activos una vez que los archivos se hayan dejado a través de la zona de caída
        dropzone: false, //Active the dropzone desactiva/oculta la zona de subida en el modal de assets
        dropzoneContent: dropzone_content,
        noAssets: 'No&nbsp;<b>hay recursos</b>&nbsp;aquí, arrastra para subir', //Mensaje de sin recursos
        uploadFile: (e) => {
            Archivos de lista eliminados
            const files = e.dataTransfer ? e.dataTransfer.files: e.target.files;
            respuesta const = {
                datos: [],
            };
            Poco probable, ahora está ampliamente apoyado
            si (! FileReader) {
                this.onUploadError(
                    nuevo error ('Plataforma no soportada, el lector de archivos no está definido')
                );
                regresar;
            }
            promesas const = [];
            const mimeTypeMatcher = /^(.+)\/(.+)$/;
            for (const file of files) {
                Para cada archivo un lector (para leer la URL base64)
                y una promesa (de rastrear y fusionar resultados y errores)
                promesa const = nueva Promesa((resolver, rechazar) => {
                    lector const = nuevo lector de archivos();
                    reader.addEventListener('load', (event) => {
                        sea tipificar;
                        nombre de const = file.name;
                        Intenta encontrar el tipo MIME del archivo.
                        const match = mimeTypeMatcher.exec(file.type);
                        si (coincidir) {
                            tipo = coincidencia[1]; La primera parte en MIME, "imagen" en imagen/png
                        } else {
                            tipo = archivo.tipo;
                        }
                        Si es una imagen, intenta encontrar su tamaño
                        si (tipo === 'imagen') {
                            const data = {
                                src: lector.resultado,
                                Nombre,
                                tipo,
                                altura: 0,
                                Ancho: 0,
                            };
                            const image = nueva Image();
                            image.addEventListener('error', (error) => {
                                rechazar (error);
                            });
                            image.addEventListener('load', () => {
                                data.altura = imagen.altura;
                                data.width = image.width;
                                resolve(data);
                            });
                            image.src = data.src;
                        } si no (tipo) {
                            No es una imagen, pero tiene un tipo
                            resolve({
                                src: lector.resultado,
                                Nombre,
                                tipo,
                            });
                        } else {
                            No se encontró ningún tipo, resuelve solo con la URL
                            resolve(reader.result);
                        }
                    });
                    reader.addEventListener('error', (error) => {
                        rechazar (error);
                    });
                    reader.addEventListener('abort', (error) => {
                        rechazar ('Abortado');
                    });
                    reader.readAsDataURL(archivo);
                });
                promesas.push(promise);
            }
            Promise.all(promises).then(
                (datos) => {
                    response.data = datos;
                    Iniciar subida de burbujas
                    attachImages(response.data, make_private, attach_to);
                },
                (error) => {
                    Uso - instance.publishState(cadena: Nombre del estado expuesto, Valor);
                    instance.publishState('error_messages', error.toString());
                    Uso - instance.triggerEvent(cadena: nombre del evento);
                    instance.triggerEvent('error');
                    console.warn(error);
                }
            );
        },

};

Agradecemos mucho vuestra ayuda