@common.js/formdata-polyfill 4.0.10

package/FormData.js

@@ -0,0 +1,752 @@
+/* formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */ /* global FormData self Blob File */ /* eslint-disable no-inner-declarations */ "use strict";
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+if (typeof Blob !== "undefined" && (typeof FormData === "undefined" || !FormData.prototype.keys)) {
+    var ensureArgs = function ensureArgs(args, expected) {
+        if (args.length < expected) {
+            throw new TypeError("".concat(expected, " argument required, but only ").concat(args.length, " present."));
+        }
+    };
+    var normalizeArgs = /**
+   * @param {string} name
+   * @param {string | undefined} filename
+   * @returns {[string, File|string]}
+   */ function normalizeArgs(name, value, filename) {
+        if (_instanceof(value, Blob)) {
+            filename = filename !== undefined ? String(filename + "") : typeof value.name === "string" ? value.name : "blob";
+            if (value.name !== filename || Object.prototype.toString.call(value) === "[object Blob]") {
+                value = new File([
+                    value
+                ], filename);
+            }
+            return [
+                String(name),
+                value
+            ];
+        }
+        return [
+            String(name),
+            String(value)
+        ];
+    };
+    var normalizeLinefeeds = // normalize line feeds for textarea
+    // https://html.spec.whatwg.org/multipage/form-elements.html#textarea-line-break-normalisation-transformation
+    function normalizeLinefeeds(value) {
+        return value.replace(/\r?\n|\r/g, "\r\n");
+    };
+    var each = /**
+   * @template T
+   * @param {ArrayLike<T>} arr
+   * @param {{ (elm: T): void; }} cb
+   */ function each(arr, cb) {
+        for(var i = 0; i < arr.length; i++){
+            cb(arr[i]);
+        }
+    };
+    var global = typeof globalThis === "object" ? globalThis : typeof window === "object" ? window : typeof self === "object" ? self : void 0;
+    // keep a reference to native implementation
+    var _FormData = global.FormData;
+    // To be monkey patched
+    var _send = global.XMLHttpRequest && global.XMLHttpRequest.prototype.send;
+    var _fetch = global.Request && global.fetch;
+    var _sendBeacon = global.navigator && global.navigator.sendBeacon;
+    // Might be a worker thread...
+    var _match = global.Element && global.Element.prototype;
+    // Unable to patch Request/Response constructor correctly #109
+    // only way is to use ES6 class extend
+    // https://github.com/babel/babel/issues/1966
+    var stringTag = global.Symbol && Symbol.toStringTag;
+    // Add missing stringTags to blob and files
+    if (stringTag) {
+        if (!Blob.prototype[stringTag]) {
+            Blob.prototype[stringTag] = "Blob";
+        }
+        if ("File" in global && !File.prototype[stringTag]) {
+            File.prototype[stringTag] = "File";
+        }
+    }
+    // Fix so you can construct your own File
+    try {
+        new File([], "") // eslint-disable-line
+        ;
+    } catch (a) {
+        global.File = function File1(b, d, c) {
+            var blob = new Blob(b, c || {});
+            var t = c && void 0 !== c.lastModified ? new Date(c.lastModified) : new Date();
+            Object.defineProperties(blob, {
+                name: {
+                    value: d
+                },
+                lastModified: {
+                    value: +t
+                },
+                toString: {
+                    value: function value() {
+                        return "[object File]";
+                    }
+                }
+            });
+            if (stringTag) {
+                Object.defineProperty(blob, stringTag, {
+                    value: "File"
+                });
+            }
+            return blob;
+        };
+    }
+    var escape = function(str) {
+        return str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
+    };
+    /**
+   * @implements {Iterable}
+   */ var FormDataPolyfill = /*#__PURE__*/ function() {
+        "use strict";
+        function FormDataPolyfill(form) {
+            _classCallCheck(this, FormDataPolyfill);
+            /** @type {[string, string|File][]} */ this._data = [];
+            var _$self = this;
+            form && each(form.elements, function(/** @type {HTMLInputElement} */ elm) {
+                if (!elm.name || elm.disabled || elm.type === "submit" || elm.type === "button" || elm.matches("form fieldset[disabled] *")) return;
+                if (elm.type === "file") {
+                    var files = elm.files && elm.files.length ? elm.files : [
+                        new File([], "", {
+                            type: "application/octet-stream"
+                        })
+                    ] // #78
+                    ;
+                    each(files, function(file) {
+                        _$self.append(elm.name, file);
+                    });
+                } else if (elm.type === "select-multiple" || elm.type === "select-one") {
+                    each(elm.options, function(opt) {
+                        !opt.disabled && opt.selected && _$self.append(elm.name, opt.value);
+                    });
+                } else if (elm.type === "checkbox" || elm.type === "radio") {
+                    if (elm.checked) _$self.append(elm.name, elm.value);
+                } else {
+                    var value = elm.type === "textarea" ? normalizeLinefeeds(elm.value) : elm.value;
+                    _$self.append(elm.name, value);
+                }
+            });
+        }
+        _createClass(FormDataPolyfill, [
+            {
+                /**
+     * Append a field
+     *
+     * @param   {string}           name      field name
+     * @param   {string|Blob|File} value     string / blob / file
+     * @param   {string=}          filename  filename to use with blob
+     * @return  {undefined}
+     */ key: "append",
+                value: function append(name, value, filename) {
+                    ensureArgs(arguments, 2);
+                    this._data.push(normalizeArgs(name, value, filename));
+                }
+            },
+            {
+                /**
+     * Delete all fields values given name
+     *
+     * @param   {string}  name  Field name
+     * @return  {undefined}
+     */ key: "delete",
+                value: function _delete(name) {
+                    ensureArgs(arguments, 1);
+                    var result = [];
+                    name = String(name);
+                    each(this._data, function(entry) {
+                        entry[0] !== name && result.push(entry);
+                    });
+                    this._data = result;
+                }
+            },
+            {
+                key: "entries",
+                value: /**
+     * Iterate over all fields as [name, value]
+     *
+     * @return {Iterator}
+     */ function entries() {
+                    var i;
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                i = 0;
+                                _state.label = 1;
+                            case 1:
+                                if (!(i < this._data.length)) return [
+                                    3,
+                                    4
+                                ];
+                                return [
+                                    4,
+                                    this._data[i]
+                                ];
+                            case 2:
+                                _state.sent();
+                                _state.label = 3;
+                            case 3:
+                                i++;
+                                return [
+                                    3,
+                                    1
+                                ];
+                            case 4:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }
+            },
+            {
+                /**
+     * Iterate over all fields
+     *
+     * @param   {Function}  callback  Executed for each item with parameters (value, name, thisArg)
+     * @param   {Object=}   thisArg   `this` context for callback function
+     */ key: "forEach",
+                value: function forEach(callback, thisArg) {
+                    ensureArgs(arguments, 1);
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = this[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var _value = _slicedToArray(_step.value, 2), name = _value[0], value = _value[1];
+                            callback.call(thisArg, value, name, this);
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                }
+            },
+            {
+                /**
+     * Return first field value given name
+     * or null if non existent
+     *
+     * @param   {string}  name      Field name
+     * @return  {string|File|null}  value Fields value
+     */ key: "get",
+                value: function get(name) {
+                    ensureArgs(arguments, 1);
+                    var entries = this._data;
+                    name = String(name);
+                    for(var i = 0; i < entries.length; i++){
+                        if (entries[i][0] === name) {
+                            return entries[i][1];
+                        }
+                    }
+                    return null;
+                }
+            },
+            {
+                /**
+     * Return all fields values given name
+     *
+     * @param   {string}  name  Fields name
+     * @return  {Array}         [{String|File}]
+     */ key: "getAll",
+                value: function getAll(name) {
+                    ensureArgs(arguments, 1);
+                    var result = [];
+                    name = String(name);
+                    each(this._data, function(data) {
+                        data[0] === name && result.push(data[1]);
+                    });
+                    return result;
+                }
+            },
+            {
+                /**
+     * Check for field name existence
+     *
+     * @param   {string}   name  Field name
+     * @return  {boolean}
+     */ key: "has",
+                value: function has(name) {
+                    ensureArgs(arguments, 1);
+                    name = String(name);
+                    for(var i = 0; i < this._data.length; i++){
+                        if (this._data[i][0] === name) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+            },
+            {
+                key: "keys",
+                value: /**
+     * Iterate over all fields name
+     *
+     * @return {Iterator}
+     */ function keys() {
+                    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, name, err;
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    6,
+                                    7,
+                                    8
+                                ]);
+                                _iterator = this[Symbol.iterator]();
+                                _state.label = 2;
+                            case 2:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    5
+                                ];
+                                _value = _slicedToArray(_step.value, 1), name = _value[0];
+                                return [
+                                    4,
+                                    name
+                                ];
+                            case 3:
+                                _state.sent();
+                                _state.label = 4;
+                            case 4:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    2
+                                ];
+                            case 5:
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 6:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 7:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 8:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }
+            },
+            {
+                /**
+     * Overwrite all values given name
+     *
+     * @param   {string}    name      Filed name
+     * @param   {string}    value     Field value
+     * @param   {string=}   filename  Filename (optional)
+     */ key: "set",
+                value: function set(name, value, filename) {
+                    ensureArgs(arguments, 2);
+                    name = String(name);
+                    /** @type {[string, string|File][]} */ var result = [];
+                    var args = normalizeArgs(name, value, filename);
+                    var replace = true;
+                    // - replace the first occurrence with same name
+                    // - discards the remaining with same name
+                    // - while keeping the same order items where added
+                    each(this._data, function(data) {
+                        data[0] === name ? replace && (replace = !result.push(args)) : result.push(data);
+                    });
+                    replace && result.push(args);
+                    this._data = result;
+                }
+            },
+            {
+                key: "values",
+                value: /**
+     * Iterate over all fields
+     *
+     * @return {Iterator}
+     */ function values() {
+                    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value, err;
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    6,
+                                    7,
+                                    8
+                                ]);
+                                _iterator = this[Symbol.iterator]();
+                                _state.label = 2;
+                            case 2:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    5
+                                ];
+                                _value = _slicedToArray(_step.value, 2), value = _value[1];
+                                return [
+                                    4,
+                                    value
+                                ];
+                            case 3:
+                                _state.sent();
+                                _state.label = 4;
+                            case 4:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    2
+                                ];
+                            case 5:
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 6:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 7:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 8:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }
+            },
+            {
+                /**
+     * Return a native (perhaps degraded) FormData with only a `append` method
+     * Can throw if it's not supported
+     *
+     * @return {FormData}
+     */ key: "_asNative",
+                value: function value() {
+                    var fd = new _FormData();
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = this[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var _value = _slicedToArray(_step.value, 2), name = _value[0], value1 = _value[1];
+                            fd.append(name, value1);
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    return fd;
+                }
+            },
+            {
+                /**
+     * [_blob description]
+     *
+     * @return {Blob} [description]
+     */ key: "_blob",
+                value: function value() {
+                    var boundary = "----formdata-polyfill-" + Math.random(), chunks = [], p = "--".concat(boundary, '\r\nContent-Disposition: form-data; name="');
+                    this.forEach(function(value, name) {
+                        return typeof value == "string" ? chunks.push(p + escape(normalizeLinefeeds(name)) + '"\r\n\r\n'.concat(normalizeLinefeeds(value), "\r\n")) : chunks.push(p + escape(normalizeLinefeeds(name)) + '"; filename="'.concat(escape(value.name), '"\r\nContent-Type: ').concat(value.type || "application/octet-stream", "\r\n\r\n"), value, "\r\n");
+                    });
+                    chunks.push("--".concat(boundary, "--"));
+                    return new Blob(chunks, {
+                        type: "multipart/form-data; boundary=" + boundary
+                    });
+                }
+            },
+            {
+                /**
+     * The class itself is iterable
+     * alias for formdata.entries()
+     *
+     * @return {Iterator}
+     */ key: Symbol.iterator,
+                value: function value() {
+                    return this.entries();
+                }
+            },
+            {
+                /**
+     * Create the default string description.
+     *
+     * @return  {string} [object FormData]
+     */ key: "toString",
+                value: function toString() {
+                    return "[object FormData]";
+                }
+            }
+        ]);
+        return FormDataPolyfill;
+    }();
+    if (_match && !_match.matches) {
+        _match.matches = _match.matchesSelector || _match.mozMatchesSelector || _match.msMatchesSelector || _match.oMatchesSelector || _match.webkitMatchesSelector || function(s) {
+            var matches = (this.document || this.ownerDocument).querySelectorAll(s);
+            var i = matches.length;
+            while(--i >= 0 && matches.item(i) !== this){}
+            return i > -1;
+        };
+    }
+    if (stringTag) {
+        /**
+     * Create the default string description.
+     * It is accessed internally by the Object.prototype.toString().
+     */ FormDataPolyfill.prototype[stringTag] = "FormData";
+    }
+    // Patch xhr's send method to call _blob transparently
+    if (_send) {
+        var setRequestHeader = global.XMLHttpRequest.prototype.setRequestHeader;
+        global.XMLHttpRequest.prototype.setRequestHeader = function(name, value) {
+            setRequestHeader.call(this, name, value);
+            if (name.toLowerCase() === "content-type") this._hasContentType = true;
+        };
+        global.XMLHttpRequest.prototype.send = function(data) {
+            // need to patch send b/c old IE don't send blob's type (#44)
+            if (_instanceof(data, FormDataPolyfill)) {
+                var blob = data["_blob"]();
+                if (!this._hasContentType) this.setRequestHeader("Content-Type", blob.type);
+                _send.call(this, blob);
+            } else {
+                _send.call(this, data);
+            }
+        };
+    }
+    // Patch fetch's function to call _blob transparently
+    if (_fetch) {
+        global.fetch = function(input, init) {
+            if (init && init.body && _instanceof(init.body, FormDataPolyfill)) {
+                init.body = init.body["_blob"]();
+            }
+            return _fetch.call(this, input, init);
+        };
+    }
+    // Patch navigator.sendBeacon to use native FormData
+    if (_sendBeacon) {
+        global.navigator.sendBeacon = function(url, data) {
+            if (_instanceof(data, FormDataPolyfill)) {
+                data = data["_asNative"]();
+            }
+            return _sendBeacon.call(this, url, data);
+        };
+    }
+    global["FormData"] = FormDataPolyfill;
+}