ng2-file-upload 2.0.0-3 → 4.0.0

package/esm2020/file-upload/file-uploader.class.mjs

@@ -0,0 +1,404 @@
+import { EventEmitter } from '@angular/core';
+import { FileLikeObject } from './file-like-object.class';
+import { FileItem } from './file-item.class';
+import { FileType } from './file-type.class';
+function isFile(value) {
+    return (File && value instanceof File);
+}
+export class FileUploader {
+    constructor(options) {
+        this.isUploading = false;
+        this.queue = [];
+        this.progress = 0;
+        this._nextIndex = 0;
+        this.options = {
+            autoUpload: false,
+            isHTML5: true,
+            filters: [],
+            removeAfterUpload: false,
+            disableMultipart: false,
+            formatDataFunction: (item) => item._file,
+            formatDataFunctionIsAsync: false,
+            url: ''
+        };
+        this.setOptions(options);
+        this.response = new EventEmitter();
+    }
+    setOptions(options) {
+        this.options = Object.assign(this.options, options);
+        this.authToken = this.options.authToken;
+        this.authTokenHeader = this.options.authTokenHeader || 'Authorization';
+        this.autoUpload = this.options.autoUpload;
+        this.options.filters?.unshift({ name: 'queueLimit', fn: this._queueLimitFilter });
+        if (this.options.maxFileSize) {
+            this.options.filters?.unshift({ name: 'fileSize', fn: this._fileSizeFilter });
+        }
+        if (this.options.allowedFileType) {
+            this.options.filters?.unshift({ name: 'fileType', fn: this._fileTypeFilter });
+        }
+        if (this.options.allowedMimeType) {
+            this.options.filters?.unshift({ name: 'mimeType', fn: this._mimeTypeFilter });
+        }
+        for (let i = 0; i < this.queue.length; i++) {
+            this.queue[i].url = this.options.url;
+        }
+    }
+    addToQueue(files, _options, filters) {
+        let options = _options;
+        const list = [];
+        for (const file of files) {
+            list.push(file);
+        }
+        const arrayOfFilters = this._getFilters(filters);
+        const count = this.queue.length;
+        const addedFileItems = [];
+        list.map((some) => {
+            if (!options) {
+                options = this.options;
+            }
+            const temp = new FileLikeObject(some);
+            if (this._isValidFile(temp, arrayOfFilters, options)) {
+                const fileItem = new FileItem(this, some, options);
+                addedFileItems.push(fileItem);
+                this.queue.push(fileItem);
+                this._onAfterAddingFile(fileItem);
+            }
+            else {
+                if (typeof this._failFilterIndex === 'number' && this._failFilterIndex >= 0) {
+                    const filter = arrayOfFilters[this._failFilterIndex];
+                    this._onWhenAddingFileFailed(temp, filter, options);
+                }
+            }
+        });
+        if (this.queue.length !== count) {
+            this._onAfterAddingAll(addedFileItems);
+            this.progress = this._getTotalProgress();
+        }
+        this._render();
+        if (this.options.autoUpload) {
+            this.uploadAll();
+        }
+    }
+    removeFromQueue(value) {
+        const index = this.getIndexOfItem(value);
+        const item = this.queue[index];
+        if (item.isUploading) {
+            item.cancel();
+        }
+        this.queue.splice(index, 1);
+        this.progress = this._getTotalProgress();
+    }
+    clearQueue() {
+        while (this.queue.length) {
+            this.queue[0].remove();
+        }
+        this.progress = 0;
+    }
+    uploadItem(value) {
+        const index = this.getIndexOfItem(value);
+        const item = this.queue[index];
+        const transport = this.options.isHTML5 ? '_xhrTransport' : '_iframeTransport';
+        item._prepareToUploading();
+        if (this.isUploading) {
+            return;
+        }
+        this.isUploading = true;
+        this[transport](item);
+    }
+    cancelItem(value) {
+        const index = this.getIndexOfItem(value);
+        const item = this.queue[index];
+        const prop = this.options.isHTML5 ? item._xhr : item._form;
+        if (item && item.isUploading) {
+            prop.abort();
+        }
+    }
+    uploadAll() {
+        const items = this.getNotUploadedItems().filter((item) => !item.isUploading);
+        if (!items.length) {
+            return;
+        }
+        items.map((item) => item._prepareToUploading());
+        items[0].upload();
+    }
+    cancelAll() {
+        const items = this.getNotUploadedItems();
+        items.map((item) => item.cancel());
+    }
+    isFile(value) {
+        return isFile(value);
+    }
+    isFileLikeObject(value) {
+        return value instanceof FileLikeObject;
+    }
+    getIndexOfItem(value) {
+        return typeof value === 'number' ? value : this.queue.indexOf(value);
+    }
+    getNotUploadedItems() {
+        return this.queue.filter((item) => !item.isUploaded);
+    }
+    getReadyItems() {
+        return this.queue
+            .filter((item) => (item.isReady && !item.isUploading))
+            .sort((item1, item2) => item1.index - item2.index);
+    }
+    onAfterAddingAll(fileItems) {
+        return { fileItems };
+    }
+    onBuildItemForm(fileItem, form) {
+        return { fileItem, form };
+    }
+    onAfterAddingFile(fileItem) {
+        return { fileItem };
+    }
+    onWhenAddingFileFailed(item, filter, options) {
+        return { item, filter, options };
+    }
+    onBeforeUploadItem(fileItem) {
+        return { fileItem };
+    }
+    onProgressItem(fileItem, progress) {
+        return { fileItem, progress };
+    }
+    onProgressAll(progress) {
+        return { progress };
+    }
+    onSuccessItem(item, response, status, headers) {
+        return { item, response, status, headers };
+    }
+    onErrorItem(item, response, status, headers) {
+        return { item, response, status, headers };
+    }
+    onCancelItem(item, response, status, headers) {
+        return { item, response, status, headers };
+    }
+    onCompleteItem(item, response, status, headers) {
+        return { item, response, status, headers };
+    }
+    onCompleteAll() {
+        return void 0;
+    }
+    _mimeTypeFilter(item) {
+        return !(item?.type && this.options.allowedMimeType && this.options.allowedMimeType?.indexOf(item.type) === -1);
+    }
+    _fileSizeFilter(item) {
+        return !(this.options.maxFileSize && item.size > this.options.maxFileSize);
+    }
+    _fileTypeFilter(item) {
+        return !(this.options.allowedFileType &&
+            this.options.allowedFileType.indexOf(FileType.getMimeClass(item)) === -1);
+    }
+    _onErrorItem(item, response, status, headers) {
+        item._onError(response, status, headers);
+        this.onErrorItem(item, response, status, headers);
+    }
+    _onCompleteItem(item, response, status, headers) {
+        item._onComplete(response, status, headers);
+        this.onCompleteItem(item, response, status, headers);
+        const nextItem = this.getReadyItems()[0];
+        this.isUploading = false;
+        if (nextItem) {
+            nextItem.upload();
+            return;
+        }
+        this.onCompleteAll();
+        this.progress = this._getTotalProgress();
+        this._render();
+    }
+    _headersGetter(parsedHeaders) {
+        return (name) => {
+            if (name) {
+                return parsedHeaders[name.toLowerCase()] || undefined;
+            }
+            return parsedHeaders;
+        };
+    }
+    _xhrTransport(item) {
+        // tslint:disable-next-line:no-this-assignment
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const that = this;
+        const xhr = item._xhr = new XMLHttpRequest();
+        let sendable;
+        this._onBeforeUploadItem(item);
+        if (typeof item._file.size !== 'number') {
+            throw new TypeError('The file specified is no longer valid');
+        }
+        if (!this.options.disableMultipart) {
+            sendable = new FormData();
+            this._onBuildItemForm(item, sendable);
+            const appendFile = () => sendable.append(item.alias, item._file, item.file.name);
+            if (!this.options.parametersBeforeFiles) {
+                appendFile();
+            }
+            // For AWS, Additional Parameters must come BEFORE Files
+            if (this.options.additionalParameter !== undefined) {
+                Object.keys(this.options.additionalParameter).forEach((key) => {
+                    let paramVal = this.options.additionalParameter?.[key];
+                    // Allow an additional parameter to include the filename
+                    if (typeof paramVal === 'string' && paramVal.indexOf('{{file_name}}') >= 0 && item.file?.name) {
+                        paramVal = paramVal.replace('{{file_name}}', item.file.name);
+                    }
+                    sendable.append(key, paramVal);
+                });
+            }
+            if (appendFile && this.options.parametersBeforeFiles) {
+                appendFile();
+            }
+        }
+        else {
+            if (this.options.formatDataFunction) {
+                sendable = this.options.formatDataFunction(item);
+            }
+        }
+        xhr.upload.onprogress = (event) => {
+            const progress = Math.round(event.lengthComputable ? event.loaded * 100 / event.total : 0);
+            this._onProgressItem(item, progress);
+        };
+        xhr.onload = () => {
+            const headers = this._parseHeaders(xhr.getAllResponseHeaders());
+            const response = this._transformResponse(xhr.response, headers);
+            const gist = this._isSuccessCode(xhr.status) ? 'Success' : 'Error';
+            const method = `_on${gist}Item`;
+            this[method](item, response, xhr.status, headers);
+            this._onCompleteItem(item, response, xhr.status, headers);
+        };
+        xhr.onerror = () => {
+            const headers = this._parseHeaders(xhr.getAllResponseHeaders());
+            const response = this._transformResponse(xhr.response, headers);
+            this._onErrorItem(item, response, xhr.status, headers);
+            this._onCompleteItem(item, response, xhr.status, headers);
+        };
+        xhr.onabort = () => {
+            const headers = this._parseHeaders(xhr.getAllResponseHeaders());
+            const response = this._transformResponse(xhr.response, headers);
+            this._onCancelItem(item, response, xhr.status, headers);
+            this._onCompleteItem(item, response, xhr.status, headers);
+        };
+        if (item.method && item.url) {
+            xhr.open(item.method, item.url, true);
+        }
+        xhr.withCredentials = item.withCredentials;
+        if (this.options.headers) {
+            for (const header of this.options.headers) {
+                xhr.setRequestHeader(header.name, header.value);
+            }
+        }
+        if (item.headers.length) {
+            for (const header of item.headers) {
+                xhr.setRequestHeader(header.name, header.value);
+            }
+        }
+        if (this.authToken && this.authTokenHeader) {
+            xhr.setRequestHeader(this.authTokenHeader, this.authToken);
+        }
+        xhr.onreadystatechange = function () {
+            if (xhr.readyState == XMLHttpRequest.DONE) {
+                that.response.emit(xhr.responseText);
+            }
+        };
+        if (this.options.formatDataFunctionIsAsync) {
+            sendable.then((result) => xhr.send(JSON.stringify(result)));
+        }
+        else {
+            xhr.send(sendable);
+        }
+        this._render();
+    }
+    _getTotalProgress(value = 0) {
+        if (this.options.removeAfterUpload) {
+            return value;
+        }
+        const notUploaded = this.getNotUploadedItems().length;
+        const uploaded = notUploaded ? this.queue.length - notUploaded : this.queue.length;
+        const ratio = 100 / this.queue.length;
+        const current = value * ratio / 100;
+        return Math.round(uploaded * ratio + current);
+    }
+    _getFilters(filters) {
+        if (!filters) {
+            return this.options?.filters || [];
+        }
+        if (Array.isArray(filters)) {
+            return filters;
+        }
+        if (typeof filters === 'string') {
+            const names = filters.match(/[^\s,]+/g);
+            return this.options?.filters || []
+                .filter((filter) => names?.indexOf(filter.name) !== -1);
+        }
+        return this.options?.filters || [];
+    }
+    _render() {
+        return void 0;
+    }
+    _queueLimitFilter() {
+        return this.options.queueLimit === undefined || this.queue.length < this.options.queueLimit;
+    }
+    _isValidFile(file, filters, options) {
+        this._failFilterIndex = -1;
+        return !filters.length ? true : filters.every((filter) => {
+            if (typeof this._failFilterIndex === 'number') {
+                this._failFilterIndex++;
+            }
+            return filter.fn.call(this, file, options);
+        });
+    }
+    _isSuccessCode(status) {
+        return (status >= 200 && status < 300) || status === 304;
+    }
+    _transformResponse(response, headers) {
+        return response;
+    }
+    _parseHeaders(headers) {
+        const parsed = {};
+        let key;
+        let val;
+        let i;
+        if (!headers) {
+            return parsed;
+        }
+        headers.split('\n').map((line) => {
+            i = line.indexOf(':');
+            key = line.slice(0, i).trim().toLowerCase();
+            val = line.slice(i + 1).trim();
+            if (key) {
+                parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
+            }
+        });
+        return parsed;
+    }
+    _onWhenAddingFileFailed(item, filter, options) {
+        this.onWhenAddingFileFailed(item, filter, options);
+    }
+    _onAfterAddingFile(item) {
+        this.onAfterAddingFile(item);
+    }
+    _onAfterAddingAll(items) {
+        this.onAfterAddingAll(items);
+    }
+    _onBeforeUploadItem(item) {
+        item._onBeforeUpload();
+        this.onBeforeUploadItem(item);
+    }
+    _onBuildItemForm(item, form) {
+        item._onBuildForm(form);
+        this.onBuildItemForm(item, form);
+    }
+    _onProgressItem(item, progress) {
+        const total = this._getTotalProgress(progress);
+        this.progress = total;
+        item._onProgress(progress);
+        this.onProgressItem(item, progress);
+        this.onProgressAll(total);
+        this._render();
+    }
+    _onSuccessItem(item, response, status, headers) {
+        item._onSuccess(response, status, headers);
+        this.onSuccessItem(item, response, status, headers);
+    }
+    _onCancelItem(item, response, status, headers) {
+        item._onCancel(response, status, headers);
+        this.onCancelItem(item, response, status, headers);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-uploader.class.js","sourceRoot":"","sources":["../../../../../libs/ng2-file-upload/file-upload/file-uploader.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,SAAS,MAAM,CAAC,KAAU;IACxB,OAAO,CAAC,IAAI,IAAI,KAAK,YAAY,IAAI,CAAC,CAAC;AACzC,CAAC;AAqCD,MAAM,OAAO,YAAY;IAwBvB,YAAY,OAA4B;QArBxC,gBAAW,GAAG,KAAK,CAAC;QACpB,UAAK,GAAe,EAAE,CAAC;QACvB,aAAQ,GAAG,CAAC,CAAC;QACb,eAAU,GAAG,CAAC,CAAC;QAKf,YAAO,GAAwB;YAC7B,UAAU,EAAE,KAAK;YACjB,OAAO,EAAE,IAAI;YACb,OAAO,EAAE,EAAE;YACX,iBAAiB,EAAE,KAAK;YACxB,gBAAgB,EAAE,KAAK;YACvB,kBAAkB,EAAE,CAAC,IAAc,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK;YAClD,yBAAyB,EAAE,KAAK;YAChC,GAAG,EAAE,EAAE;SACR,CAAC;QAKA,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,IAAI,YAAY,EAAU,CAAC;IAC7C,CAAC;IAED,UAAU,CAAC,OAA4B;QACrC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAEpD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;QACxC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,eAAe,IAAI,eAAe,CAAC;QACvE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;QAC1C,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,IAAI,CAAC,iBAAiB,EAAE,CAAC,CAAC;QAElF,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE;YAC5B,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;SAC/E;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE;YAChC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;SAC/E;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE;YAChC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;SAC/E;QAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC1C,IAAI,CAAC,KAAK,CAAE,CAAC,CAAE,CAAC,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC;SACxC;IACH,CAAC;IAED,UAAU,CAAC,KAAa,EAAE,QAA8B,EAAE,OAAqB;QAC7E,IAAI,OAAO,GAAG,QAAQ,CAAC;QACvB,MAAM,IAAI,GAAW,EAAE,CAAC;QACxB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;YACxB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SACjB;QACD,MAAM,cAAc,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACjD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QAChC,MAAM,cAAc,GAAe,EAAE,CAAC;QACtC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAU,EAAE,EAAE;YACtB,IAAI,CAAC,OAAO,EAAE;gBACZ,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;aACxB;YAED,MAAM,IAAI,GAAG,IAAI,cAAc,CAAC,IAAI,CAAC,CAAC;YACtC,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE;gBACpD,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;gBACnD,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBAC9B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBAC1B,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC;aACnC;iBAAM;gBACL,IAAI,OAAO,IAAI,CAAC,gBAAgB,KAAK,QAAQ,IAAI,IAAI,CAAC,gBAAgB,IAAI,CAAC,EAAE;oBAC3E,MAAM,MAAM,GAAG,cAAc,CAAE,IAAI,CAAC,gBAAgB,CAAE,CAAC;oBACvD,IAAI,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;iBACrD;aACF;QACH,CAAC,CAAC,CAAC;QACH,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,KAAK,EAAE;YAC/B,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC;YACvC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;SAC1C;QACD,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE;YAC3B,IAAI,CAAC,SAAS,EAAE,CAAC;SAClB;IACH,CAAC;IAED,eAAe,CAAC,KAAe;QAC7B,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QACzC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAE,KAAK,CAAE,CAAC;QACjC,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,IAAI,CAAC,MAAM,EAAE,CAAC;SACf;QACD,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAC5B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3C,CAAC;IAED,UAAU;QACR,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;YACxB,IAAI,CAAC,KAAK,CAAE,CAAC,CAAE,CAAC,MAAM,EAAE,CAAC;SAC1B;QACD,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;IACpB,CAAC;IAED,UAAU,CAAC,KAAe;QACxB,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QACzC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAE,KAAK,CAAE,CAAC;QACjC,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,kBAAkB,CAAC;QAC9E,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,OAAO;SACR;QACD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACvB,IAAY,CAAE,SAAS,CAAE,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED,UAAU,CAAC,KAAe;QACxB,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QACzC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAE,KAAK,CAAE,CAAC;QACjC,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;QAC3D,IAAI,IAAI,IAAI,IAAI,CAAC,WAAW,EAAE;YAC5B,IAAI,CAAC,KAAK,EAAE,CAAC;SACd;IACH,CAAC;IAED,SAAS;QACP,MAAM,KAAK,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC,MAAM,CAAC,CAAC,IAAc,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACvF,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;YACjB,OAAO;SACR;QACD,KAAK,CAAC,GAAG,CAAC,CAAC,IAAc,EAAE,EAAE,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC,CAAC;QAC1D,KAAK,CAAE,CAAC,CAAE,CAAC,MAAM,EAAE,CAAC;IACtB,CAAC;IAED,SAAS;QACP,MAAM,KAAK,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QACzC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAc,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED,MAAM,CAAC,KAAU;QACf,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;IAED,gBAAgB,CAAC,KAAU;QACzB,OAAO,KAAK,YAAY,cAAc,CAAC;IACzC,CAAC;IAED,cAAc,CAAC,KAAU;QACvB,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACvE,CAAC;IAED,mBAAmB;QACjB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAc,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACjE,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,KAAK;aACd,MAAM,CAAC,CAAC,IAAc,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;aAC/D,IAAI,CAAC,CAAC,KAAU,EAAE,KAAU,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IACjE,CAAC;IAED,gBAAgB,CAAC,SAAc;QAC7B,OAAO,EAAE,SAAS,EAAE,CAAC;IACvB,CAAC;IAED,eAAe,CAAC,QAAkB,EAAE,IAAS;QAC3C,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IAC5B,CAAC;IAED,iBAAiB,CAAC,QAAkB;QAClC,OAAO,EAAE,QAAQ,EAAE,CAAC;IACtB,CAAC;IAED,sBAAsB,CAAC,IAAoB,EAAE,MAAW,EAAE,OAAY;QACpE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IACnC,CAAC;IAED,kBAAkB,CAAC,QAAkB;QACnC,OAAO,EAAE,QAAQ,EAAE,CAAC;IACtB,CAAC;IAED,cAAc,CAAC,QAAkB,EAAE,QAAa;QAC9C,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;IAChC,CAAC;IAED,aAAa,CAAC,QAAa;QACzB,OAAO,EAAE,QAAQ,EAAE,CAAC;IACtB,CAAC;IAED,aAAa,CAAC,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QAC5F,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IAC7C,CAAC;IAED,WAAW,CAAC,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QAC1F,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IAC7C,CAAC;IAED,YAAY,CAAC,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QAC3F,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IAC7C,CAAC;IAED,cAAc,CAAC,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QAC7F,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IAC7C,CAAC;IAED,aAAa;QACX,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,eAAe,CAAC,IAAoB;QAClC,OAAO,CAAC,CAAC,IAAI,EAAE,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,eAAe,IAAI,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAClH,CAAC;IAED,eAAe,CAAC,IAAoB;QAClC,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,IAAI,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IAC7E,CAAC;IAED,eAAe,CAAC,IAAoB;QAClC,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe;YACnC,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC9E,CAAC;IAED,YAAY,CAAC,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QAC3F,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QACzC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACpD,CAAC;IAED,eAAe,CAAC,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QAC9F,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QAC5C,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QACrD,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,EAAE,CAAE,CAAC,CAAE,CAAC;QAC3C,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,QAAQ,EAAE;YACZ,QAAQ,CAAC,MAAM,EAAE,CAAC;YAElB,OAAO;SACR;QACD,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzC,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAES,cAAc,CAAC,aAAoC;QAC3D,OAAO,CAAC,IAAS,EAAO,EAAE;YACxB,IAAI,IAAI,EAAE;gBACR,OAAO,aAAa,CAAE,IAAI,CAAC,WAAW,EAAE,CAAE,IAAI,SAAS,CAAC;aACzD;YAED,OAAO,aAAa,CAAC;QACvB,CAAC,CAAC;IACJ,CAAC;IAES,aAAa,CAAC,IAAc;QACpC,8CAA8C;QAC9C,4DAA4D;QAC5D,MAAM,IAAI,GAAG,IAAI,CAAC;QAClB,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,GAAG,IAAI,cAAc,EAAE,CAAC;QAC7C,IAAI,QAAa,CAAC;QAClB,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;QAE/B,IAAI,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE;YACvC,MAAM,IAAI,SAAS,CAAC,uCAAuC,CAAC,CAAC;SAC9D;QACD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE;YAClC,QAAQ,GAAG,IAAI,QAAQ,EAAE,CAAC;YAC1B,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;YACtC,MAAM,UAAU,GAAG,GAAG,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACjF,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,qBAAqB,EAAE;gBACvC,UAAU,EAAE,CAAC;aACd;YAED,wDAAwD;YACxD,IAAI,IAAI,CAAC,OAAO,CAAC,mBAAmB,KAAK,SAAS,EAAE;gBAClD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,OAAO,CAAC,CAAC,GAAW,EAAE,EAAE;oBACpE,IAAI,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,mBAAmB,EAAE,CAAE,GAAG,CAAE,CAAC;oBACzD,wDAAwD;oBACxD,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE;wBAC7F,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,eAAe,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;qBAC9D;oBACD,QAAQ,CAAC,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;gBACjC,CAAC,CAAC,CAAC;aACJ;YAED,IAAI,UAAU,IAAI,IAAI,CAAC,OAAO,CAAC,qBAAqB,EAAE;gBACpD,UAAU,EAAE,CAAC;aACd;SACF;aAAM;YACL,IAAI,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE;gBACnC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;aAClD;SACF;QAED,GAAG,CAAC,MAAM,CAAC,UAAU,GAAG,CAAC,KAAU,EAAE,EAAE;YACrC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC3F,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACvC,CAAC,CAAC;QACF,GAAG,CAAC,MAAM,GAAG,GAAG,EAAE;YAChB,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,qBAAqB,EAAE,CAAC,CAAC;YAChE,MAAM,QAAQ,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YAChE,MAAM,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC;YACnE,MAAM,MAAM,GAAG,MAAM,IAAI,MAAM,CAAC;YAC/B,IAAY,CAAE,MAAM,CAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YAC7D,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC5D,CAAC,CAAC;QACF,GAAG,CAAC,OAAO,GAAG,GAAG,EAAE;YACjB,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,qBAAqB,EAAE,CAAC,CAAC;YAChE,MAAM,QAAQ,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YAChE,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YACvD,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC5D,CAAC,CAAC;QACF,GAAG,CAAC,OAAO,GAAG,GAAG,EAAE;YACjB,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,qBAAqB,EAAE,CAAC,CAAC;YAChE,MAAM,QAAQ,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YAChE,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YACxD,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC5D,CAAC,CAAC;QACF,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,GAAG,EAAE;YAC3B,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;SACvC;QACD,GAAG,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;QAC3C,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE;YACxB,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE;gBACzC,GAAG,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;aACjD;SACF;QACD,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;YACvB,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE;gBACjC,GAAG,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;aACjD;SACF;QACD,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,eAAe,EAAE;YAC1C,GAAG,CAAC,gBAAgB,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;SAC5D;QACD,GAAG,CAAC,kBAAkB,GAAG;YACvB,IAAI,GAAG,CAAC,UAAU,IAAI,cAAc,CAAC,IAAI,EAAE;gBACzC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;aACtC;QACH,CAAC,CAAC;QACF,IAAI,IAAI,CAAC,OAAO,CAAC,yBAAyB,EAAE;YAC1C,QAAQ,CAAC,IAAI,CACX,CAAC,MAAW,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAClD,CAAC;SACH;aAAM;YACL,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SACpB;QACD,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAES,iBAAiB,CAAC,KAAK,GAAG,CAAC;QACnC,IAAI,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE;YAClC,OAAO,KAAK,CAAC;SACd;QACD,MAAM,WAAW,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC,MAAM,CAAC;QACtD,MAAM,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QACnF,MAAM,KAAK,GAAG,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QACtC,MAAM,OAAO,GAAG,KAAK,GAAG,KAAK,GAAG,GAAG,CAAC;QACpC,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,KAAK,GAAG,OAAO,CAAC,CAAC;IAChD,CAAC;IAES,WAAW,CAAC,OAAmC;QACvD,IAAI,CAAC,OAAO,EAAE;YACZ,OAAO,IAAI,CAAC,OAAO,EAAE,OAAO,IAAI,EAAE,CAAC;SACpC;QACD,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YAC1B,OAAO,OAAO,CAAC;SAChB;QACD,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;YAC/B,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;YAExC,OAAO,IAAI,CAAC,OAAO,EAAE,OAAO,IAAI,EAAE;iBAC/B,MAAM,CAAC,CAAC,MAAW,EAAE,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SAChE;QAED,OAAO,IAAI,CAAC,OAAO,EAAE,OAAO,IAAI,EAAE,CAAC;IACrC,CAAC;IAES,OAAO;QACf,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAES,iBAAiB;QACzB,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;IAC9F,CAAC;IAES,YAAY,CAAC,IAAoB,EAAE,OAAyB,EAAE,OAA4B;QAClG,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAC;QAE3B,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAsB,EAAE,EAAE;YACvE,IAAI,OAAO,IAAI,CAAC,gBAAgB,KAAK,QAAQ,EAAE;gBAC7C,IAAI,CAAC,gBAAgB,EAAE,CAAC;aACzB;YAED,OAAO,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC;IAES,cAAc,CAAC,MAAc;QACrC,OAAO,CAAC,MAAM,IAAI,GAAG,IAAI,MAAM,GAAG,GAAG,CAAC,IAAI,MAAM,KAAK,GAAG,CAAC;IAC3D,CAAC;IAES,kBAAkB,CAAC,QAAgB,EAAE,OAA8B;QAC3E,OAAO,QAAQ,CAAC;IAClB,CAAC;IAES,aAAa,CAAC,OAAe;QACrC,MAAM,MAAM,GAAQ,EAAE,CAAC;QACvB,IAAI,GAAQ,CAAC;QACb,IAAI,GAAQ,CAAC;QACb,IAAI,CAAM,CAAC;QACX,IAAI,CAAC,OAAO,EAAE;YACZ,OAAO,MAAM,CAAC;SACf;QACD,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,IAAS,EAAE,EAAE;YACpC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YACtB,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YAC5C,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YAC/B,IAAI,GAAG,EAAE;gBACP,MAAM,CAAE,GAAG,CAAE,GAAG,MAAM,CAAE,GAAG,CAAE,CAAC,CAAC,CAAC,MAAM,CAAE,GAAG,CAAE,GAAG,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;aAClE;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC;IAChB,CAAC;IAES,uBAAuB,CAAC,IAAoB,EAAE,MAAW,EAAE,OAAY;QAC/E,IAAI,CAAC,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACrD,CAAC;IAES,kBAAkB,CAAC,IAAc;QACzC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAES,iBAAiB,CAAC,KAAU;QACpC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAES,mBAAmB,CAAC,IAAc;QAC1C,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAES,gBAAgB,CAAC,IAAc,EAAE,IAAS;QAClD,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QACxB,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACnC,CAAC;IAES,eAAe,CAAC,IAAc,EAAE,QAAa;QACrD,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QAC/C,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QAC3B,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACpC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC1B,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAES,cAAc,CAAC,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QACvG,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QAC3C,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACtD,CAAC;IAES,aAAa,CAAC,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QACtG,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QAC1C,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACrD,CAAC;CACF","sourcesContent":["import { EventEmitter } from '@angular/core';\nimport { FileLikeObject } from './file-like-object.class';\nimport { FileItem } from './file-item.class';\nimport { FileType } from './file-type.class';\n\nfunction isFile(value: any): boolean {\n  return (File && value instanceof File);\n}\n\nexport interface Headers {\n  name: string;\n  value: string;\n}\n\nexport interface ParsedResponseHeaders { [ headerFieldName: string ]: string }\n\nexport interface FilterFunction {\n  name: string;\n  fn(item: FileLikeObject, options?: FileUploaderOptions): boolean;\n}\n\nexport interface FileUploaderOptions {\n  allowedMimeType?: string[];\n  allowedFileType?: string[];\n  autoUpload?: boolean;\n  isHTML5?: boolean;\n  filters?: FilterFunction[];\n  headers?: Headers[];\n  method?: string;\n  authToken?: string;\n  maxFileSize?: number;\n  queueLimit?: number;\n  removeAfterUpload?: boolean;\n  url: string;\n  disableMultipart?: boolean;\n  itemAlias?: string;\n  authTokenHeader?: string;\n  additionalParameter?: { [ key: string ]: any };\n  parametersBeforeFiles?: boolean;\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  formatDataFunction?: Function;\n  formatDataFunctionIsAsync?: boolean;\n}\n\nexport class FileUploader {\n\n  authToken?: string;\n  isUploading = false;\n  queue: FileItem[] = [];\n  progress = 0;\n  _nextIndex = 0;\n  autoUpload: any;\n  authTokenHeader?: string;\n  response: EventEmitter<any>;\n\n  options: FileUploaderOptions = {\n    autoUpload: false,\n    isHTML5: true,\n    filters: [],\n    removeAfterUpload: false,\n    disableMultipart: false,\n    formatDataFunction: (item: FileItem) => item._file,\n    formatDataFunctionIsAsync: false,\n    url: ''\n  };\n\n  protected _failFilterIndex?: number;\n\n  constructor(options: FileUploaderOptions) {\n    this.setOptions(options);\n    this.response = new EventEmitter<string>();\n  }\n\n  setOptions(options: FileUploaderOptions): void {\n    this.options = Object.assign(this.options, options);\n\n    this.authToken = this.options.authToken;\n    this.authTokenHeader = this.options.authTokenHeader || 'Authorization';\n    this.autoUpload = this.options.autoUpload;\n    this.options.filters?.unshift({ name: 'queueLimit', fn: this._queueLimitFilter });\n\n    if (this.options.maxFileSize) {\n      this.options.filters?.unshift({ name: 'fileSize', fn: this._fileSizeFilter });\n    }\n\n    if (this.options.allowedFileType) {\n      this.options.filters?.unshift({ name: 'fileType', fn: this._fileTypeFilter });\n    }\n\n    if (this.options.allowedMimeType) {\n      this.options.filters?.unshift({ name: 'mimeType', fn: this._mimeTypeFilter });\n    }\n\n    for (let i = 0; i < this.queue.length; i++) {\n      this.queue[ i ].url = this.options.url;\n    }\n  }\n\n  addToQueue(files: File[], _options?: FileUploaderOptions, filters?: [] | string): void {\n    let options = _options;\n    const list: File[] = [];\n    for (const file of files) {\n      list.push(file);\n    }\n    const arrayOfFilters = this._getFilters(filters);\n    const count = this.queue.length;\n    const addedFileItems: FileItem[] = [];\n    list.map((some: File) => {\n      if (!options) {\n        options = this.options;\n      }\n\n      const temp = new FileLikeObject(some);\n      if (this._isValidFile(temp, arrayOfFilters, options)) {\n        const fileItem = new FileItem(this, some, options);\n        addedFileItems.push(fileItem);\n        this.queue.push(fileItem);\n        this._onAfterAddingFile(fileItem);\n      } else {\n        if (typeof this._failFilterIndex === 'number' && this._failFilterIndex >= 0) {\n          const filter = arrayOfFilters[ this._failFilterIndex ];\n          this._onWhenAddingFileFailed(temp, filter, options);\n        }\n      }\n    });\n    if (this.queue.length !== count) {\n      this._onAfterAddingAll(addedFileItems);\n      this.progress = this._getTotalProgress();\n    }\n    this._render();\n    if (this.options.autoUpload) {\n      this.uploadAll();\n    }\n  }\n\n  removeFromQueue(value: FileItem): void {\n    const index = this.getIndexOfItem(value);\n    const item = this.queue[ index ];\n    if (item.isUploading) {\n      item.cancel();\n    }\n    this.queue.splice(index, 1);\n    this.progress = this._getTotalProgress();\n  }\n\n  clearQueue(): void {\n    while (this.queue.length) {\n      this.queue[ 0 ].remove();\n    }\n    this.progress = 0;\n  }\n\n  uploadItem(value: FileItem): void {\n    const index = this.getIndexOfItem(value);\n    const item = this.queue[ index ];\n    const transport = this.options.isHTML5 ? '_xhrTransport' : '_iframeTransport';\n    item._prepareToUploading();\n    if (this.isUploading) {\n      return;\n    }\n    this.isUploading = true;\n    (this as any)[ transport ](item);\n  }\n\n  cancelItem(value: FileItem): void {\n    const index = this.getIndexOfItem(value);\n    const item = this.queue[ index ];\n    const prop = this.options.isHTML5 ? item._xhr : item._form;\n    if (item && item.isUploading) {\n      prop.abort();\n    }\n  }\n\n  uploadAll(): void {\n    const items = this.getNotUploadedItems().filter((item: FileItem) => !item.isUploading);\n    if (!items.length) {\n      return;\n    }\n    items.map((item: FileItem) => item._prepareToUploading());\n    items[ 0 ].upload();\n  }\n\n  cancelAll(): void {\n    const items = this.getNotUploadedItems();\n    items.map((item: FileItem) => item.cancel());\n  }\n\n  isFile(value: any): boolean {\n    return isFile(value);\n  }\n\n  isFileLikeObject(value: any): boolean {\n    return value instanceof FileLikeObject;\n  }\n\n  getIndexOfItem(value: any): number {\n    return typeof value === 'number' ? value : this.queue.indexOf(value);\n  }\n\n  getNotUploadedItems(): any[] {\n    return this.queue.filter((item: FileItem) => !item.isUploaded);\n  }\n\n  getReadyItems(): any[] {\n    return this.queue\n      .filter((item: FileItem) => (item.isReady && !item.isUploading))\n      .sort((item1: any, item2: any) => item1.index - item2.index);\n  }\n\n  onAfterAddingAll(fileItems: any): any {\n    return { fileItems };\n  }\n\n  onBuildItemForm(fileItem: FileItem, form: any): any {\n    return { fileItem, form };\n  }\n\n  onAfterAddingFile(fileItem: FileItem): any {\n    return { fileItem };\n  }\n\n  onWhenAddingFileFailed(item: FileLikeObject, filter: any, options: any): any {\n    return { item, filter, options };\n  }\n\n  onBeforeUploadItem(fileItem: FileItem): any {\n    return { fileItem };\n  }\n\n  onProgressItem(fileItem: FileItem, progress: any): any {\n    return { fileItem, progress };\n  }\n\n  onProgressAll(progress: any): any {\n    return { progress };\n  }\n\n  onSuccessItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): any {\n    return { item, response, status, headers };\n  }\n\n  onErrorItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): any {\n    return { item, response, status, headers };\n  }\n\n  onCancelItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): any {\n    return { item, response, status, headers };\n  }\n\n  onCompleteItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): any {\n    return { item, response, status, headers };\n  }\n\n  onCompleteAll(): any {\n    return void 0;\n  }\n\n  _mimeTypeFilter(item: FileLikeObject): boolean {\n    return !(item?.type && this.options.allowedMimeType && this.options.allowedMimeType?.indexOf(item.type) === -1);\n  }\n\n  _fileSizeFilter(item: FileLikeObject): boolean {\n    return !(this.options.maxFileSize && item.size > this.options.maxFileSize);\n  }\n\n  _fileTypeFilter(item: FileLikeObject): boolean {\n    return !(this.options.allowedFileType &&\n      this.options.allowedFileType.indexOf(FileType.getMimeClass(item)) === -1);\n  }\n\n  _onErrorItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): void {\n    item._onError(response, status, headers);\n    this.onErrorItem(item, response, status, headers);\n  }\n\n  _onCompleteItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): void {\n    item._onComplete(response, status, headers);\n    this.onCompleteItem(item, response, status, headers);\n    const nextItem = this.getReadyItems()[ 0 ];\n    this.isUploading = false;\n    if (nextItem) {\n      nextItem.upload();\n\n      return;\n    }\n    this.onCompleteAll();\n    this.progress = this._getTotalProgress();\n    this._render();\n  }\n\n  protected _headersGetter(parsedHeaders: ParsedResponseHeaders): any {\n    return (name: any): any => {\n      if (name) {\n        return parsedHeaders[ name.toLowerCase() ] || undefined;\n      }\n\n      return parsedHeaders;\n    };\n  }\n\n  protected _xhrTransport(item: FileItem): any {\n    // tslint:disable-next-line:no-this-assignment\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const that = this;\n    const xhr = item._xhr = new XMLHttpRequest();\n    let sendable: any;\n    this._onBeforeUploadItem(item);\n\n    if (typeof item._file.size !== 'number') {\n      throw new TypeError('The file specified is no longer valid');\n    }\n    if (!this.options.disableMultipart) {\n      sendable = new FormData();\n      this._onBuildItemForm(item, sendable);\n      const appendFile = () => sendable.append(item.alias, item._file, item.file.name);\n      if (!this.options.parametersBeforeFiles) {\n        appendFile();\n      }\n\n      // For AWS, Additional Parameters must come BEFORE Files\n      if (this.options.additionalParameter !== undefined) {\n        Object.keys(this.options.additionalParameter).forEach((key: string) => {\n          let paramVal = this.options.additionalParameter?.[ key ];\n          // Allow an additional parameter to include the filename\n          if (typeof paramVal === 'string' && paramVal.indexOf('{{file_name}}') >= 0 && item.file?.name) {\n            paramVal = paramVal.replace('{{file_name}}', item.file.name);\n          }\n          sendable.append(key, paramVal);\n        });\n      }\n\n      if (appendFile && this.options.parametersBeforeFiles) {\n        appendFile();\n      }\n    } else {\n      if (this.options.formatDataFunction) {\n        sendable = this.options.formatDataFunction(item);\n      }\n    }\n\n    xhr.upload.onprogress = (event: any) => {\n      const progress = Math.round(event.lengthComputable ? event.loaded * 100 / event.total : 0);\n      this._onProgressItem(item, progress);\n    };\n    xhr.onload = () => {\n      const headers = this._parseHeaders(xhr.getAllResponseHeaders());\n      const response = this._transformResponse(xhr.response, headers);\n      const gist = this._isSuccessCode(xhr.status) ? 'Success' : 'Error';\n      const method = `_on${gist}Item`;\n      (this as any)[ method ](item, response, xhr.status, headers);\n      this._onCompleteItem(item, response, xhr.status, headers);\n    };\n    xhr.onerror = () => {\n      const headers = this._parseHeaders(xhr.getAllResponseHeaders());\n      const response = this._transformResponse(xhr.response, headers);\n      this._onErrorItem(item, response, xhr.status, headers);\n      this._onCompleteItem(item, response, xhr.status, headers);\n    };\n    xhr.onabort = () => {\n      const headers = this._parseHeaders(xhr.getAllResponseHeaders());\n      const response = this._transformResponse(xhr.response, headers);\n      this._onCancelItem(item, response, xhr.status, headers);\n      this._onCompleteItem(item, response, xhr.status, headers);\n    };\n    if (item.method && item.url) {\n      xhr.open(item.method, item.url, true);\n    }\n    xhr.withCredentials = item.withCredentials;\n    if (this.options.headers) {\n      for (const header of this.options.headers) {\n        xhr.setRequestHeader(header.name, header.value);\n      }\n    }\n    if (item.headers.length) {\n      for (const header of item.headers) {\n        xhr.setRequestHeader(header.name, header.value);\n      }\n    }\n    if (this.authToken && this.authTokenHeader) {\n      xhr.setRequestHeader(this.authTokenHeader, this.authToken);\n    }\n    xhr.onreadystatechange = function () {\n      if (xhr.readyState == XMLHttpRequest.DONE) {\n        that.response.emit(xhr.responseText);\n      }\n    };\n    if (this.options.formatDataFunctionIsAsync) {\n      sendable.then(\n        (result: any) => xhr.send(JSON.stringify(result))\n      );\n    } else {\n      xhr.send(sendable);\n    }\n    this._render();\n  }\n\n  protected _getTotalProgress(value = 0): number {\n    if (this.options.removeAfterUpload) {\n      return value;\n    }\n    const notUploaded = this.getNotUploadedItems().length;\n    const uploaded = notUploaded ? this.queue.length - notUploaded : this.queue.length;\n    const ratio = 100 / this.queue.length;\n    const current = value * ratio / 100;\n    return Math.round(uploaded * ratio + current);\n  }\n\n  protected _getFilters(filters?: FilterFunction[] | string): FilterFunction[] | [] {\n    if (!filters) {\n      return this.options?.filters || [];\n    }\n    if (Array.isArray(filters)) {\n      return filters;\n    }\n    if (typeof filters === 'string') {\n      const names = filters.match(/[^\\s,]+/g);\n\n      return this.options?.filters || []\n        .filter((filter: any) => names?.indexOf(filter.name) !== -1);\n    }\n\n    return this.options?.filters || [];\n  }\n\n  protected _render(): any {\n    return void 0;\n  }\n\n  protected _queueLimitFilter(): boolean {\n    return this.options.queueLimit === undefined || this.queue.length < this.options.queueLimit;\n  }\n\n  protected _isValidFile(file: FileLikeObject, filters: FilterFunction[], options: FileUploaderOptions): boolean {\n    this._failFilterIndex = -1;\n\n    return !filters.length ? true : filters.every((filter: FilterFunction) => {\n      if (typeof this._failFilterIndex === 'number') {\n        this._failFilterIndex++;\n      }\n\n      return filter.fn.call(this, file, options);\n    });\n  }\n\n  protected _isSuccessCode(status: number): boolean {\n    return (status >= 200 && status < 300) || status === 304;\n  }\n\n  protected _transformResponse(response: string, headers: ParsedResponseHeaders): string {\n    return response;\n  }\n\n  protected _parseHeaders(headers: string): ParsedResponseHeaders {\n    const parsed: any = {};\n    let key: any;\n    let val: any;\n    let i: any;\n    if (!headers) {\n      return parsed;\n    }\n    headers.split('\\n').map((line: any) => {\n      i = line.indexOf(':');\n      key = line.slice(0, i).trim().toLowerCase();\n      val = line.slice(i + 1).trim();\n      if (key) {\n        parsed[ key ] = parsed[ key ] ? parsed[ key ] + ', ' + val : val;\n      }\n    });\n\n    return parsed;\n  }\n\n  protected _onWhenAddingFileFailed(item: FileLikeObject, filter: any, options: any): void {\n    this.onWhenAddingFileFailed(item, filter, options);\n  }\n\n  protected _onAfterAddingFile(item: FileItem): void {\n    this.onAfterAddingFile(item);\n  }\n\n  protected _onAfterAddingAll(items: any): void {\n    this.onAfterAddingAll(items);\n  }\n\n  protected _onBeforeUploadItem(item: FileItem): void {\n    item._onBeforeUpload();\n    this.onBeforeUploadItem(item);\n  }\n\n  protected _onBuildItemForm(item: FileItem, form: any): void {\n    item._onBuildForm(form);\n    this.onBuildItemForm(item, form);\n  }\n\n  protected _onProgressItem(item: FileItem, progress: any): void {\n    const total = this._getTotalProgress(progress);\n    this.progress = total;\n    item._onProgress(progress);\n    this.onProgressItem(item, progress);\n    this.onProgressAll(total);\n    this._render();\n  }\n\n  protected _onSuccessItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): void {\n    item._onSuccess(response, status, headers);\n    this.onSuccessItem(item, response, status, headers);\n  }\n\n  protected _onCancelItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): void {\n    item._onCancel(response, status, headers);\n    this.onCancelItem(item, response, status, headers);\n  }\n}\n"]}

package/esm2020/index.mjs

@@ -0,0 +1,8 @@
+export * from './file-upload/file-drop.directive';
+export * from './file-upload/file-uploader.class';
+export * from './file-upload/file-item.class';
+export * from './file-upload/file-like-object.class';
+export * from './file-upload/file-like-object.class';
+export { FileUploadModule } from './file-upload/file-upload.module';
+export { FileSelectDirective } from './file-upload/file-select.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL25nMi1maWxlLXVwbG9hZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFlLG1DQUFtQyxDQUFDO0FBQ25ELGNBQWUsbUNBQW1DLENBQUM7QUFDbkQsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsc0NBQXNDLENBQUM7QUFFckQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDcEUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0scUNBQXFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICAnLi9maWxlLXVwbG9hZC9maWxlLWRyb3AuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gICcuL2ZpbGUtdXBsb2FkL2ZpbGUtdXBsb2FkZXIuY2xhc3MnO1xuZXhwb3J0ICogZnJvbSAnLi9maWxlLXVwbG9hZC9maWxlLWl0ZW0uY2xhc3MnO1xuZXhwb3J0ICogZnJvbSAnLi9maWxlLXVwbG9hZC9maWxlLWxpa2Utb2JqZWN0LmNsYXNzJztcbmV4cG9ydCAqIGZyb20gJy4vZmlsZS11cGxvYWQvZmlsZS1saWtlLW9iamVjdC5jbGFzcyc7XG5cbmV4cG9ydCB7IEZpbGVVcGxvYWRNb2R1bGUgfSBmcm9tICcuL2ZpbGUtdXBsb2FkL2ZpbGUtdXBsb2FkLm1vZHVsZSc7XG5leHBvcnQgeyBGaWxlU2VsZWN0RGlyZWN0aXZlIH0gZnJvbSAnLi9maWxlLXVwbG9hZC9maWxlLXNlbGVjdC5kaXJlY3RpdmUnO1xuIl19

package/esm2020/ng2-file-upload.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmcyLWZpbGUtdXBsb2FkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbGlicy9uZzItZmlsZS11cGxvYWQvbmcyLWZpbGUtdXBsb2FkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19