@common.js/node-fetch 3.3.2

package/src/body.js

@@ -0,0 +1,902 @@
+/**
+ * Body.js
+ *
+ * Body interface provides common methods for Request and Response
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return Body;
+    },
+    clone: function() {
+        return clone;
+    },
+    extractContentType: function() {
+        return extractContentType;
+    },
+    getTotalBytes: function() {
+        return getTotalBytes;
+    },
+    writeToStream: function() {
+        return writeToStream;
+    }
+});
+var _nodeStream = /*#__PURE__*/ _interopRequireWildcard(require("node:stream"));
+var _nodeUtil = require("node:util");
+var _nodeBuffer = require("node:buffer");
+var _fetchBlob = /*#__PURE__*/ _interopRequireDefault(require("fetch-blob"));
+var _esmMinJs = require("formdata-polyfill/esm.min.js");
+var _fetchErrorJs = require("./errors/fetch-error.js");
+var _baseJs = require("./errors/base.js");
+var _isJs = require("./utils/is.js");
+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 _asyncIterator(iterable) {
+    var method, async, sync, retry = 2;
+    for("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;){
+        if (async && null != (method = iterable[async])) return method.call(iterable);
+        if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
+        async = "@@asyncIterator", sync = "@@iterator";
+    }
+    throw new TypeError("Object is not async iterable");
+}
+function AsyncFromSyncIterator(s) {
+    function AsyncFromSyncIteratorContinuation(r) {
+        if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
+        var done = r.done;
+        return Promise.resolve(r.value).then(function(value) {
+            return {
+                value: value,
+                done: done
+            };
+        });
+    }
+    return AsyncFromSyncIterator = function(s) {
+        this.s = s, this.n = s.next;
+    }, AsyncFromSyncIterator.prototype = {
+        s: null,
+        n: null,
+        next: function() {
+            return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+        },
+        return: function(value) {
+            var ret = this.s.return;
+            return void 0 === ret ? Promise.resolve({
+                value: value,
+                done: !0
+            }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
+        },
+        throw: function(value) {
+            var thr = this.s.return;
+            return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
+        }
+    }, new AsyncFromSyncIterator(s);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+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 _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+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
+        };
+    }
+};
+var pipeline = (0, _nodeUtil.promisify)(_nodeStream.default.pipeline);
+var INTERNALS = Symbol("Body internals");
+var Body = /*#__PURE__*/ function() {
+    "use strict";
+    function Body(body) {
+        var ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, _size = ref.size, size = _size === void 0 ? 0 : _size;
+        var _this = this;
+        _classCallCheck(this, Body);
+        var boundary = null;
+        if (body === null) {
+            // Body is undefined or null
+            body = null;
+        } else if ((0, _isJs.isURLSearchParameters)(body)) {
+            // Body is a URLSearchParams
+            body = _nodeBuffer.Buffer.from(body.toString());
+        } else if ((0, _isJs.isBlob)(body)) {
+        // Body is blob
+        } else if (_nodeBuffer.Buffer.isBuffer(body)) {
+        // Body is Buffer
+        } else if (_nodeUtil.types.isAnyArrayBuffer(body)) {
+            // Body is ArrayBuffer
+            body = _nodeBuffer.Buffer.from(body);
+        } else if (ArrayBuffer.isView(body)) {
+            // Body is ArrayBufferView
+            body = _nodeBuffer.Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+        } else if (_instanceof(body, _nodeStream.default)) {
+        // Body is stream
+        } else if (_instanceof(body, _esmMinJs.FormData)) {
+            // Body is FormData
+            body = (0, _esmMinJs.formDataToBlob)(body);
+            boundary = body.type.split("=")[1];
+        } else {
+            // None of the above
+            // coerce to string then buffer
+            body = _nodeBuffer.Buffer.from(String(body));
+        }
+        var stream = body;
+        if (_nodeBuffer.Buffer.isBuffer(body)) {
+            stream = _nodeStream.default.Readable.from(body);
+        } else if ((0, _isJs.isBlob)(body)) {
+            stream = _nodeStream.default.Readable.from(body.stream());
+        }
+        this[INTERNALS] = {
+            body: body,
+            stream: stream,
+            boundary: boundary,
+            disturbed: false,
+            error: null
+        };
+        this.size = size;
+        if (_instanceof(body, _nodeStream.default)) {
+            body.on("error", function(error_) {
+                var error = _instanceof(error_, _baseJs.FetchBaseError) ? error_ : new _fetchErrorJs.FetchError("Invalid response body while trying to fetch ".concat(_this.url, ": ").concat(error_.message), "system", error_);
+                _this[INTERNALS].error = error;
+            });
+        }
+    }
+    _createClass(Body, [
+        {
+            key: "body",
+            get: function get() {
+                return this[INTERNALS].stream;
+            }
+        },
+        {
+            key: "bodyUsed",
+            get: function get() {
+                return this[INTERNALS].disturbed;
+            }
+        },
+        {
+            key: "arrayBuffer",
+            value: /**
+	 * Decode response as ArrayBuffer
+	 *
+	 * @return  Promise
+	 */ function arrayBuffer() {
+                var _this = this;
+                return _asyncToGenerator(function() {
+                    var ref, buffer, byteOffset, byteLength;
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    consumeBody(_this)
+                                ];
+                            case 1:
+                                ref = _state.sent(), buffer = ref.buffer, byteOffset = ref.byteOffset, byteLength = ref.byteLength;
+                                return [
+                                    2,
+                                    buffer.slice(byteOffset, byteOffset + byteLength)
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "formData",
+            value: function formData() {
+                var _this = this;
+                return _asyncToGenerator(function() {
+                    var ct, formData, parameters, _, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, name, value, toFormData;
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                ct = _this.headers.get("content-type");
+                                if (!ct.startsWith("application/x-www-form-urlencoded")) return [
+                                    3,
+                                    2
+                                ];
+                                formData = new _esmMinJs.FormData();
+                                _ = URLSearchParams.bind;
+                                return [
+                                    4,
+                                    _this.text()
+                                ];
+                            case 1:
+                                parameters = new (_.apply(URLSearchParams, [
+                                    void 0,
+                                    _state.sent()
+                                ]));
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                try {
+                                    for(_iterator = parameters[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                        _value = _slicedToArray(_step.value, 2), name = _value[0], value = _value[1];
+                                        formData.append(name, value);
+                                    }
+                                } catch (err) {
+                                    _didIteratorError = true;
+                                    _iteratorError = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                            _iterator.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError) {
+                                            throw _iteratorError;
+                                        }
+                                    }
+                                }
+                                return [
+                                    2,
+                                    formData
+                                ];
+                            case 2:
+                                return [
+                                    4,
+                                    Promise.resolve().then(function() {
+                                        return /*#__PURE__*/ _interopRequireWildcard(require("./utils/multipart-parser.js"));
+                                    })
+                                ];
+                            case 3:
+                                toFormData = _state.sent().toFormData;
+                                return [
+                                    2,
+                                    toFormData(_this.body, ct)
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "blob",
+            value: /**
+	 * Return raw response as Blob
+	 *
+	 * @return Promise
+	 */ function blob() {
+                var _this = this;
+                return _asyncToGenerator(function() {
+                    var ct, buf;
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                ct = _this.headers && _this.headers.get("content-type") || _this[INTERNALS].body && _this[INTERNALS].body.type || "";
+                                return [
+                                    4,
+                                    _this.arrayBuffer()
+                                ];
+                            case 1:
+                                buf = _state.sent();
+                                return [
+                                    2,
+                                    new _fetchBlob.default([
+                                        buf
+                                    ], {
+                                        type: ct
+                                    })
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "json",
+            value: /**
+	 * Decode response as json
+	 *
+	 * @return  Promise
+	 */ function json() {
+                var _this = this;
+                return _asyncToGenerator(function() {
+                    var text;
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this.text()
+                                ];
+                            case 1:
+                                text = _state.sent();
+                                return [
+                                    2,
+                                    JSON.parse(text)
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "text",
+            value: /**
+	 * Decode response as text
+	 *
+	 * @return  Promise
+	 */ function text() {
+                var _this = this;
+                return _asyncToGenerator(function() {
+                    var buffer;
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    consumeBody(_this)
+                                ];
+                            case 1:
+                                buffer = _state.sent();
+                                return [
+                                    2,
+                                    new TextDecoder().decode(buffer)
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            /**
+	 * Decode response as buffer (non-spec api)
+	 *
+	 * @return  Promise
+	 */ key: "buffer",
+            value: function buffer() {
+                return consumeBody(this);
+            }
+        }
+    ]);
+    return Body;
+}();
+Body.prototype.buffer = (0, _nodeUtil.deprecate)(Body.prototype.buffer, "Please use 'response.arrayBuffer()' instead of 'response.buffer()'", "node-fetch#buffer");
+// In browsers, all properties are enumerable.
+Object.defineProperties(Body.prototype, {
+    body: {
+        enumerable: true
+    },
+    bodyUsed: {
+        enumerable: true
+    },
+    arrayBuffer: {
+        enumerable: true
+    },
+    blob: {
+        enumerable: true
+    },
+    json: {
+        enumerable: true
+    },
+    text: {
+        enumerable: true
+    },
+    data: {
+        get: (0, _nodeUtil.deprecate)(function() {}, "data doesn't exist, use json(), text(), arrayBuffer(), or body instead", "https://github.com/node-fetch/node-fetch/issues/1000 (response)")
+    }
+});
+function consumeBody(data) {
+    return _consumeBody.apply(this, arguments);
+}
+function _consumeBody() {
+    _consumeBody = /**
+ * Consume and convert an entire Body to a Buffer.
+ *
+ * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body
+ *
+ * @return Promise
+ */ _asyncToGenerator(function(data) {
+        var body, accum, accumBytes, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk, _$error, err, error, error_;
+        return __generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (data[INTERNALS].disturbed) {
+                        throw new TypeError("body used already for: ".concat(data.url));
+                    }
+                    data[INTERNALS].disturbed = true;
+                    if (data[INTERNALS].error) {
+                        throw data[INTERNALS].error;
+                    }
+                    body = data.body;
+                    // Body is null
+                    if (body === null) {
+                        return [
+                            2,
+                            _nodeBuffer.Buffer.alloc(0)
+                        ];
+                    }
+                    /* c8 ignore next 3 */ if (!_instanceof(body, _nodeStream.default)) {
+                        return [
+                            2,
+                            _nodeBuffer.Buffer.alloc(0)
+                        ];
+                    }
+                    accum = [];
+                    accumBytes = 0;
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        14,
+                        ,
+                        15
+                    ]);
+                    _iteratorAbruptCompletion = false, _didIteratorError = false;
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        7,
+                        8,
+                        13
+                    ]);
+                    _iterator = _asyncIterator(body);
+                    _state.label = 3;
+                case 3:
+                    return [
+                        4,
+                        _iterator.next()
+                    ];
+                case 4:
+                    if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done)) return [
+                        3,
+                        6
+                    ];
+                    _value = _step.value;
+                    chunk = _value;
+                    if (data.size > 0 && accumBytes + chunk.length > data.size) {
+                        _$error = new _fetchErrorJs.FetchError("content size at ".concat(data.url, " over limit: ").concat(data.size), "max-size");
+                        body.destroy(_$error);
+                        throw _$error;
+                    }
+                    accumBytes += chunk.length;
+                    accum.push(chunk);
+                    _state.label = 5;
+                case 5:
+                    _iteratorAbruptCompletion = false;
+                    return [
+                        3,
+                        3
+                    ];
+                case 6:
+                    return [
+                        3,
+                        13
+                    ];
+                case 7:
+                    err = _state.sent();
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                    return [
+                        3,
+                        13
+                    ];
+                case 8:
+                    _state.trys.push([
+                        8,
+                        ,
+                        11,
+                        12
+                    ]);
+                    if (!(_iteratorAbruptCompletion && _iterator.return != null)) return [
+                        3,
+                        10
+                    ];
+                    return [
+                        4,
+                        _iterator.return()
+                    ];
+                case 9:
+                    _state.sent();
+                    _state.label = 10;
+                case 10:
+                    return [
+                        3,
+                        12
+                    ];
+                case 11:
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                    return [
+                        7
+                    ];
+                case 12:
+                    return [
+                        7
+                    ];
+                case 13:
+                    return [
+                        3,
+                        15
+                    ];
+                case 14:
+                    error = _state.sent();
+                    error_ = _instanceof(error, _baseJs.FetchBaseError) ? error : new _fetchErrorJs.FetchError("Invalid response body while trying to fetch ".concat(data.url, ": ").concat(error.message), "system", error);
+                    throw error_;
+                case 15:
+                    if (body.readableEnded === true || body._readableState.ended === true) {
+                        try {
+                            if (accum.every(function(c) {
+                                return typeof c === "string";
+                            })) {
+                                return [
+                                    2,
+                                    _nodeBuffer.Buffer.from(accum.join(""))
+                                ];
+                            }
+                            return [
+                                2,
+                                _nodeBuffer.Buffer.concat(accum, accumBytes)
+                            ];
+                        } catch (error1) {
+                            throw new _fetchErrorJs.FetchError("Could not create Buffer from response body for ".concat(data.url, ": ").concat(error1.message), "system", error1);
+                        }
+                    } else {
+                        throw new _fetchErrorJs.FetchError("Premature close of server response while trying to fetch ".concat(data.url));
+                    }
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _consumeBody.apply(this, arguments);
+}
+var clone = function(instance, highWaterMark) {
+    var p1;
+    var p2;
+    var body = instance[INTERNALS].body;
+    // Don't allow cloning a used body
+    if (instance.bodyUsed) {
+        throw new Error("cannot clone body after it is used");
+    }
+    // Check that body is a stream and not form-data object
+    // note: we can't clone the form-data object without having it as a dependency
+    if (_instanceof(body, _nodeStream.default) && typeof body.getBoundary !== "function") {
+        // Tee instance body
+        p1 = new _nodeStream.PassThrough({
+            highWaterMark: highWaterMark
+        });
+        p2 = new _nodeStream.PassThrough({
+            highWaterMark: highWaterMark
+        });
+        body.pipe(p1);
+        body.pipe(p2);
+        // Set instance body to teed body and return the other teed body
+        instance[INTERNALS].stream = p1;
+        body = p2;
+    }
+    return body;
+};
+var getNonSpecFormDataBoundary = (0, _nodeUtil.deprecate)(function(body) {
+    return body.getBoundary();
+}, "form-data doesn't follow the spec and requires special treatment. Use alternative package", "https://github.com/node-fetch/node-fetch/issues/1167");
+var extractContentType = function(body, request) {
+    // Body is null or undefined
+    if (body === null) {
+        return null;
+    }
+    // Body is string
+    if (typeof body === "string") {
+        return "text/plain;charset=UTF-8";
+    }
+    // Body is a URLSearchParams
+    if ((0, _isJs.isURLSearchParameters)(body)) {
+        return "application/x-www-form-urlencoded;charset=UTF-8";
+    }
+    // Body is blob
+    if ((0, _isJs.isBlob)(body)) {
+        return body.type || null;
+    }
+    // Body is a Buffer (Buffer, ArrayBuffer or ArrayBufferView)
+    if (_nodeBuffer.Buffer.isBuffer(body) || _nodeUtil.types.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
+        return null;
+    }
+    if (_instanceof(body, _esmMinJs.FormData)) {
+        return "multipart/form-data; boundary=".concat(request[INTERNALS].boundary);
+    }
+    // Detect form data input from form-data module
+    if (body && typeof body.getBoundary === "function") {
+        return "multipart/form-data;boundary=".concat(getNonSpecFormDataBoundary(body));
+    }
+    // Body is stream - can't really do much about this
+    if (_instanceof(body, _nodeStream.default)) {
+        return null;
+    }
+    // Body constructor defaults other things to string
+    return "text/plain;charset=UTF-8";
+};
+var getTotalBytes = function(request) {
+    var body = request[INTERNALS].body;
+    // Body is null or undefined
+    if (body === null) {
+        return 0;
+    }
+    // Body is Blob
+    if ((0, _isJs.isBlob)(body)) {
+        return body.size;
+    }
+    // Body is Buffer
+    if (_nodeBuffer.Buffer.isBuffer(body)) {
+        return body.length;
+    }
+    // Detect form data input from form-data module
+    if (body && typeof body.getLengthSync === "function") {
+        return body.hasKnownLength && body.hasKnownLength() ? body.getLengthSync() : null;
+    }
+    // Body is stream
+    return null;
+};
+var writeToStream = function() {
+    var _ref = _asyncToGenerator(function(dest, param) {
+        var body;
+        return __generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    body = param.body;
+                    if (!(body === null)) return [
+                        3,
+                        1
+                    ];
+                    // Body is null
+                    dest.end();
+                    return [
+                        3,
+                        3
+                    ];
+                case 1:
+                    // Body is stream
+                    return [
+                        4,
+                        pipeline(body, dest)
+                    ];
+                case 2:
+                    _state.sent();
+                    _state.label = 3;
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function writeToStream(dest, _) {
+        return _ref.apply(this, arguments);
+    };
+}();