@common.js/formdata-polyfill 4.0.10

package/formdata-to-blob.js

@@ -0,0 +1,93 @@
+/*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "formDataToBlob", {
+    enumerable: true,
+    get: function() {
+        return formDataToBlob;
+    }
+});
+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 _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 escape = function(str, filename) {
+    return (filename ? str : str.replace(/\r?\n|\r/g, "\r\n")).replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
+};
+function formDataToBlob(formData) {
+    var BlobClass = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Blob;
+    var boundary = "----formdata-polyfill-" + Math.random();
+    var chunks = [];
+    var prefix = "--".concat(boundary, '\r\nContent-Disposition: form-data; name="');
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = formData[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _value = _slicedToArray(_step.value, 2), name = _value[0], value = _value[1];
+            if (typeof value === "string") {
+                chunks.push(prefix + escape(name) + '"\r\n\r\n'.concat(value.replace(RegExp("\\r(?!\\n)|(?<!\\r)\\n", "g"), "\r\n"), "\r\n"));
+            } else {
+                chunks.push(prefix + escape(name) + '"; filename="'.concat(escape(value.name, 1), '"\r\n') + "Content-Type: ".concat(value.type || "application/octet-stream", "\r\n\r\n"), value, "\r\n");
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    chunks.push("--".concat(boundary, "--"));
+    return new BlobClass(chunks, {
+        type: "multipart/form-data; boundary=" + boundary
+    });
+}

package/formdata.min.js

@@ -0,0 +1,507 @@
+"use strict";
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+;
+(function() {
+    var l = function l(a) {
+        var b = 0;
+        return function() {
+            return b < a.length ? {
+                done: !1,
+                value: a[b++]
+            } : {
+                done: !0
+            };
+        };
+    };
+    var n = function n(a) {
+        a = [
+            "object" == typeof globalThis && globalThis,
+            a,
+            "object" == typeof window && window,
+            "object" == typeof self && self,
+            "object" == typeof global && global
+        ];
+        for(var b = 0; b < a.length; ++b){
+            var c = a[b];
+            if (c && c.Math == Math) return c;
+        }
+        throw Error("Cannot find global object");
+    };
+    var r = function r(a, b) {
+        if (b) a: {
+            var c = q;
+            a = a.split(".");
+            for(var d = 0; d < a.length - 1; d++){
+                var e = a[d];
+                if (!(e in c)) break a;
+                c = c[e];
+            }
+            a = a[a.length - 1];
+            d = c[a];
+            b = b(d);
+            b != d && null != b && m(c, a, {
+                configurable: !0,
+                writable: !0,
+                value: b
+            });
+        }
+    };
+    var u = function u(a) {
+        a = {
+            next: a
+        };
+        a[Symbol.iterator] = function() {
+            return this;
+        };
+        return a;
+    };
+    var v = function v(a) {
+        var b = "undefined" != typeof Symbol && Symbol.iterator && a[Symbol.iterator];
+        return b ? b.call(a) : {
+            next: l(a)
+        };
+    };
+    var C = function C() {
+        this.m = !1;
+        this.j = null;
+        this.v = void 0;
+        this.h = 1;
+        this.u = this.C = 0;
+        this.l = null;
+    };
+    var D = function D(a) {
+        if (a.m) throw new TypeError("Generator is already running");
+        a.m = !0;
+    };
+    var E = function E(a, b) {
+        a.h = 3;
+        return {
+            value: b
+        };
+    };
+    var F = function F(a) {
+        this.g = new C;
+        this.G = a;
+    };
+    var I = function I(a, b) {
+        D(a.g);
+        var c = a.g.j;
+        if (c) return G(a, "return" in c ? c["return"] : function(d) {
+            return {
+                value: d,
+                done: !0
+            };
+        }, b, a.g.return);
+        a.g.return(b);
+        return H(a);
+    };
+    var G = function G(a, b, c, d) {
+        try {
+            var e = b.call(a.g.j, c);
+            if (!_instanceof(e, Object)) throw new TypeError("Iterator result " + e + " is not an object");
+            if (!e.done) return a.g.m = !1, e;
+            var f = e.value;
+        } catch (g) {
+            return a.g.j = null, a.g.s(g), H(a);
+        }
+        a.g.j = null;
+        d.call(a.g, f);
+        return H(a);
+    };
+    var H = function H(a) {
+        for(; a.g.h;)try {
+            var b = a.G(a.g);
+            if (b) return a.g.m = !1, {
+                value: b.value,
+                done: !1
+            };
+        } catch (c) {
+            a.g.v = void 0, a.g.s(c);
+        }
+        a.g.m = !1;
+        if (a.g.l) {
+            b = a.g.l;
+            a.g.l = null;
+            if (b.F) throw b.D;
+            return {
+                value: b.return,
+                done: !0
+            };
+        }
+        return {
+            value: void 0,
+            done: !0
+        };
+    };
+    var J = function J(a) {
+        this.next = function(b) {
+            return a.o(b);
+        };
+        this.throw = function(b) {
+            return a.s(b);
+        };
+        this.return = function(b) {
+            return I(a, b);
+        };
+        this[Symbol.iterator] = function() {
+            return this;
+        };
+    };
+    var K = function K(a, b) {
+        b = new J(new F(b));
+        B && a.prototype && B(b, a.prototype);
+        return b;
+    };
+    var L = function L(a, b) {
+        _instanceof(a, String) && (a += "");
+        var c = 0, d = !1, e = {
+            next: function next() {
+                if (!d && c < a.length) {
+                    var f = c++;
+                    return {
+                        value: b(f, a[f]),
+                        done: !1
+                    };
+                }
+                d = !0;
+                return {
+                    done: !0,
+                    value: void 0
+                };
+            }
+        };
+        e[Symbol.iterator] = function() {
+            return e;
+        };
+        return e;
+    };
+    var h;
+    var m = "function" == typeof Object.defineProperties ? Object.defineProperty : function m(a, b, c) {
+        if (a == Array.prototype || a == Object.prototype) return a;
+        a[b] = c.value;
+        return a;
+    };
+    var q = n(this);
+    r("Symbol", function(a) {
+        var c = function c(f, g) {
+            this.A = f;
+            m(this, "description", {
+                configurable: !0,
+                writable: !0,
+                value: g
+            });
+        };
+        function b(f) {
+            if (_instanceof(this, b)) throw new TypeError("Symbol is not a constructor");
+            return new c(d + (f || "") + "_" + e++, f);
+        }
+        if (a) return a;
+        c.prototype.toString = function() {
+            return this.A;
+        };
+        var d = "jscomp_symbol_" + (1E9 * Math.random() >>> 0) + "_", e = 0;
+        return b;
+    });
+    r("Symbol.iterator", function(a) {
+        if (a) return a;
+        a = Symbol("Symbol.iterator");
+        for(var b = "Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array".split(" "), c = 0; c < b.length; c++){
+            var d = q[b[c]];
+            "function" === typeof d && "function" != typeof d.prototype[a] && m(d.prototype, a, {
+                configurable: !0,
+                writable: !0,
+                value: function value() {
+                    return u(l(this));
+                }
+            });
+        }
+        return a;
+    });
+    var w;
+    if ("function" == typeof Object.setPrototypeOf) w = Object.setPrototypeOf;
+    else {
+        var y;
+        a: {
+            var z = {
+                a: !0
+            }, A = {};
+            try {
+                A.__proto__ = z;
+                y = A.a;
+                break a;
+            } catch (a) {}
+            y = !1;
+        }
+        w = y ? function w(a, b) {
+            a.__proto__ = b;
+            if (a.__proto__ !== b) throw new TypeError(a + " is not extensible");
+            return a;
+        } : null;
+    }
+    var B = w;
+    C.prototype.o = function(a) {
+        this.v = a;
+    };
+    C.prototype.s = function(a) {
+        this.l = {
+            D: a,
+            F: !0
+        };
+        this.h = this.C || this.u;
+    };
+    C.prototype.return = function(a) {
+        this.l = {
+            return: a
+        };
+        this.h = this.u;
+    };
+    F.prototype.o = function(a) {
+        D(this.g);
+        if (this.g.j) return G(this, this.g.j.next, a, this.g.o);
+        this.g.o(a);
+        return H(this);
+    };
+    F.prototype.s = function(a) {
+        D(this.g);
+        if (this.g.j) return G(this, this.g.j["throw"], a, this.g.o);
+        this.g.s(a);
+        return H(this);
+    };
+    r("Array.prototype.entries", function(a) {
+        return a ? a : function() {
+            return L(this, function(b, c) {
+                return [
+                    b,
+                    c
+                ];
+            });
+        };
+    });
+    if ("undefined" !== typeof Blob && ("undefined" === typeof FormData || !FormData.prototype.keys)) {
+        var M = function M(a, b) {
+            for(var c = 0; c < a.length; c++)b(a[c]);
+        }, N = function N(a) {
+            return a.replace(/\r?\n|\r/g, "\r\n");
+        }, O = function O(a, b, c) {
+            if (_instanceof(b, Blob)) {
+                c = void 0 !== c ? String(c + "") : "string" === typeof b.name ? b.name : "blob";
+                if (b.name !== c || "[object Blob]" === Object.prototype.toString.call(b)) b = new File([
+                    b
+                ], c);
+                return [
+                    String(a),
+                    b
+                ];
+            }
+            return [
+                String(a),
+                String(b)
+            ];
+        }, P = function P(a, b) {
+            if (a.length < b) throw new TypeError(b + " argument required, but only " + a.length + " present.");
+        }, Q = "object" === typeof globalThis ? globalThis : "object" === typeof window ? window : "object" === typeof self ? self : this, R = Q.FormData, S = Q.XMLHttpRequest && Q.XMLHttpRequest.prototype.send, T = Q.Request && Q.fetch, U = Q.navigator && Q.navigator.sendBeacon, V = Q.Element && Q.Element.prototype, W = Q.Symbol && Symbol.toStringTag;
+        W && (Blob.prototype[W] || (Blob.prototype[W] = "Blob"), "File" in Q && !File.prototype[W] && (File.prototype[W] = "File"));
+        try {
+            new File([], "");
+        } catch (a1) {
+            Q.File = function(b, c, d) {
+                b = new Blob(b, d || {});
+                Object.defineProperties(b, {
+                    name: {
+                        value: c
+                    },
+                    lastModified: {
+                        value: +(d && void 0 !== d.lastModified ? new Date(d.lastModified) : new Date)
+                    },
+                    toString: {
+                        value: function value() {
+                            return "[object File]";
+                        }
+                    }
+                });
+                W && Object.defineProperty(b, W, {
+                    value: "File"
+                });
+                return b;
+            };
+        }
+        var escape = function escape(a) {
+            return a.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
+        }, X = function X(a) {
+            this.i = [];
+            var b = this;
+            a && M(a.elements, function(c) {
+                if (c.name && !c.disabled && "submit" !== c.type && "button" !== c.type && !c.matches("form fieldset[disabled] *")) if ("file" === c.type) {
+                    var d = c.files && c.files.length ? c.files : [
+                        new File([], "", {
+                            type: "application/octet-stream"
+                        })
+                    ];
+                    M(d, function(e) {
+                        b.append(c.name, e);
+                    });
+                } else "select-multiple" === c.type || "select-one" === c.type ? M(c.options, function(e) {
+                    !e.disabled && e.selected && b.append(c.name, e.value);
+                }) : "checkbox" === c.type || "radio" === c.type ? c.checked && b.append(c.name, c.value) : (d = "textarea" === c.type ? N(c.value) : c.value, b.append(c.name, d));
+            });
+        };
+        h = X.prototype;
+        h.append = function(a, b, c) {
+            P(arguments, 2);
+            this.i.push(O(a, b, c));
+        };
+        h.delete = function(a) {
+            P(arguments, 1);
+            var b = [];
+            a = String(a);
+            M(this.i, function(c) {
+                c[0] !== a && b.push(c);
+            });
+            this.i = b;
+        };
+        h.entries = function b() {
+            var c, d = this;
+            return K(b, function(e) {
+                1 == e.h && (c = 0);
+                if (3 != e.h) return c < d.i.length ? e = E(e, d.i[c]) : (e.h = 0, e = void 0), e;
+                c++;
+                e.h = 2;
+            });
+        };
+        h.forEach = function(b, c) {
+            P(arguments, 1);
+            for(var d = v(this), e = d.next(); !e.done; e = d.next()){
+                var f = v(e.value);
+                e = f.next().value;
+                f = f.next().value;
+                b.call(c, f, e, this);
+            }
+        };
+        h.get = function(b) {
+            P(arguments, 1);
+            var c = this.i;
+            b = String(b);
+            for(var d = 0; d < c.length; d++)if (c[d][0] === b) return c[d][1];
+            return null;
+        };
+        h.getAll = function(b) {
+            P(arguments, 1);
+            var c = [];
+            b = String(b);
+            M(this.i, function(d) {
+                d[0] === b && c.push(d[1]);
+            });
+            return c;
+        };
+        h.has = function(b) {
+            P(arguments, 1);
+            b = String(b);
+            for(var c = 0; c < this.i.length; c++)if (this.i[c][0] === b) return !0;
+            return !1;
+        };
+        h.keys = function c() {
+            var d = this, e, f, g, k, p;
+            return K(c, function(t) {
+                1 == t.h && (e = v(d), f = e.next());
+                if (3 != t.h) {
+                    if (f.done) {
+                        t.h = 0;
+                        return;
+                    }
+                    g = f.value;
+                    k = v(g);
+                    p = k.next().value;
+                    return E(t, p);
+                }
+                f = e.next();
+                t.h = 2;
+            });
+        };
+        h.set = function(c, d, e) {
+            P(arguments, 2);
+            c = String(c);
+            var f = [], g = O(c, d, e), k = !0;
+            M(this.i, function(p) {
+                p[0] === c ? k && (k = !f.push(g)) : f.push(p);
+            });
+            k && f.push(g);
+            this.i = f;
+        };
+        h.values = function d() {
+            var e = this, f, g, k, p, t;
+            return K(d, function(x) {
+                1 == x.h && (f = v(e), g = f.next());
+                if (3 != x.h) {
+                    if (g.done) {
+                        x.h = 0;
+                        return;
+                    }
+                    k = g.value;
+                    p = v(k);
+                    p.next();
+                    t = p.next().value;
+                    return E(x, t);
+                }
+                g = f.next();
+                x.h = 2;
+            });
+        };
+        X.prototype._asNative = function() {
+            for(var d = new R, e = v(this), f = e.next(); !f.done; f = e.next()){
+                var g = v(f.value);
+                f = g.next().value;
+                g = g.next().value;
+                d.append(f, g);
+            }
+            return d;
+        };
+        X.prototype._blob = function() {
+            var d = "----formdata-polyfill-" + Math.random(), e = [], f = "--" + d + '\r\nContent-Disposition: form-data; name="';
+            this.forEach(function(g, k) {
+                return "string" == typeof g ? e.push(f + escape(N(k)) + ('"\r\n\r\n' + N(g) + "\r\n")) : e.push(f + escape(N(k)) + ('"; filename="' + escape(g.name) + '"\r\nContent-Type: ' + (g.type || "application/octet-stream") + "\r\n\r\n"), g, "\r\n");
+            });
+            e.push("--" + d + "--");
+            return new Blob(e, {
+                type: "multipart/form-data; boundary=" + d
+            });
+        };
+        X.prototype[Symbol.iterator] = function() {
+            return this.entries();
+        };
+        X.prototype.toString = function() {
+            return "[object FormData]";
+        };
+        V && !V.matches && (V.matches = V.matchesSelector || V.mozMatchesSelector || V.msMatchesSelector || V.oMatchesSelector || V.webkitMatchesSelector || function(d) {
+            d = (this.document || this.ownerDocument).querySelectorAll(d);
+            for(var e = d.length; 0 <= --e && d.item(e) !== this;);
+            return -1 < e;
+        });
+        W && (X.prototype[W] = "FormData");
+        if (S) {
+            var Y = Q.XMLHttpRequest.prototype.setRequestHeader;
+            Q.XMLHttpRequest.prototype.setRequestHeader = function(d, e) {
+                Y.call(this, d, e);
+                "content-type" === d.toLowerCase() && (this.B = !0);
+            };
+            Q.XMLHttpRequest.prototype.send = function(d) {
+                _instanceof(d, X) ? (d = d._blob(), this.B || this.setRequestHeader("Content-Type", d.type), S.call(this, d)) : S.call(this, d);
+            };
+        }
+        T && (Q.fetch = function(d, e) {
+            e && e.body && _instanceof(e.body, X) && (e.body = e.body._blob());
+            return T.call(this, d, e);
+        });
+        U && (Q.navigator.sendBeacon = function(d, e) {
+            _instanceof(e, X) && (e = e._asNative());
+            return U.call(this, d, e);
+        });
+        Q.FormData = X;
+    }
+    ;
+})();

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@common.js/formdata-polyfill",
+  "version": "4.0.10",
+  "description": "formdata-polyfill package exported as CommonJS modules",
+  "type": "commonjs",
+  "main": "formdata.min.js",
+  "scripts": {
+    "build": "node build.js",
+    "test": "node test/test-esm.js",
+    "test-wpt": "node --experimental-loader ./test/http-loader.js ./test/test-wpt-in-node.js",
+    "test-polyfill": "php -S localhost:4445 & open http://localhost:4445/test/test-polyfill.html"
+  },
+  "repository": "etienne-martin/common.js",
+  "files": [
+    "esm.min.js",
+    "esm.min.d.ts",
+    "FormData.js",
+    "formdata-to-blob.js",
+    "formdata.min.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=12.20.0"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/jimmywarting/FormData/issues"
+  },
+  "homepage": "https://github.com/etienne-martin/common.js#readme",
+  "dependencies": {
+    "@common.js/fetch-blob": "^3.1.2"
+  },
+  "devDependencies": {
+    "@types/google-closure-compiler": "^0.0.19",
+    "@types/node": "^16.7.10",
+    "google-closure-compiler": "^20210808.0.0"
+  }
+}