@common.js/node-fetch 3.3.2

package/src/index.js

@@ -0,0 +1,602 @@
+/**
+ * Index.js
+ *
+ * a request API compatible with window.fetch
+ *
+ * All spec algorithm step numbers are based on https://fetch.spec.whatwg.org/commit-snapshots/ae716822cb3a61843226cd090eefc6589446c1d2/.
+ */ "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, {
+    FormData: function() {
+        return _esmMinJs.FormData;
+    },
+    Headers: function() {
+        return _headersJs.default;
+    },
+    Request: function() {
+        return _requestJs.default;
+    },
+    Response: function() {
+        return _responseJs.default;
+    },
+    FetchError: function() {
+        return _fetchErrorJs.FetchError;
+    },
+    AbortError: function() {
+        return _abortErrorJs.AbortError;
+    },
+    isRedirect: function() {
+        return _isRedirectJs.isRedirect;
+    },
+    Blob: function() {
+        return _fromJs.Blob;
+    },
+    File: function() {
+        return _fromJs.File;
+    },
+    fileFromSync: function() {
+        return _fromJs.fileFromSync;
+    },
+    fileFrom: function() {
+        return _fromJs.fileFrom;
+    },
+    blobFromSync: function() {
+        return _fromJs.blobFromSync;
+    },
+    blobFrom: function() {
+        return _fromJs.blobFrom;
+    },
+    /**
+ * Fetch function
+ *
+ * @param   {string | URL | import('./request').default} url - Absolute url or Request instance
+ * @param   {*} [options_] - Fetch options
+ * @return  {Promise<import('./response').default>}
+ */ default: function() {
+        return fetch;
+    }
+});
+var _nodeHttp = /*#__PURE__*/ _interopRequireDefault(require("node:http"));
+var _nodeHttps = /*#__PURE__*/ _interopRequireDefault(require("node:https"));
+var _nodeZlib = /*#__PURE__*/ _interopRequireDefault(require("node:zlib"));
+var _nodeStream = /*#__PURE__*/ _interopRequireWildcard(require("node:stream"));
+var _nodeBuffer = require("node:buffer");
+var _dataUriToBuffer = /*#__PURE__*/ _interopRequireDefault(require("data-uri-to-buffer"));
+var _bodyJs = require("./body.js");
+var _responseJs = /*#__PURE__*/ _interopRequireDefault(require("./response.js"));
+var _headersJs = /*#__PURE__*/ _interopRequireWildcard(require("./headers.js"));
+var _requestJs = /*#__PURE__*/ _interopRequireWildcard(require("./request.js"));
+var _fetchErrorJs = require("./errors/fetch-error.js");
+var _abortErrorJs = require("./errors/abort-error.js");
+var _isRedirectJs = require("./utils/is-redirect.js");
+var _esmMinJs = require("formdata-polyfill/esm.min.js");
+var _isJs = require("./utils/is.js");
+var _referrerJs = require("./utils/referrer.js");
+var _fromJs = require("fetch-blob/from.js");
+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 _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;
+}
+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 supportedSchemas = new Set([
+    "data:",
+    "http:",
+    "https:"
+]);
+function fetch(url, options_) {
+    return _fetch.apply(this, arguments);
+}
+function _fetch() {
+    _fetch = _asyncToGenerator(function(url, options_) {
+        return __generator(this, function(_state) {
+            return [
+                2,
+                new Promise(function(resolve, reject) {
+                    // Build request object
+                    var request = new _requestJs.default(url, options_);
+                    var ref = (0, _requestJs.getNodeRequestOptions)(request), parsedURL = ref.parsedURL, options = ref.options;
+                    if (!supportedSchemas.has(parsedURL.protocol)) {
+                        throw new TypeError("node-fetch cannot load ".concat(url, '. URL scheme "').concat(parsedURL.protocol.replace(/:$/, ""), '" is not supported.'));
+                    }
+                    if (parsedURL.protocol === "data:") {
+                        var data = (0, _dataUriToBuffer.default)(request.url);
+                        var response = new _responseJs.default(data, {
+                            headers: {
+                                "Content-Type": data.typeFull
+                            }
+                        });
+                        resolve(response);
+                        return;
+                    }
+                    // Wrap http.request into fetch
+                    var send = (parsedURL.protocol === "https:" ? _nodeHttps.default : _nodeHttp.default).request;
+                    var signal = request.signal;
+                    var response1 = null;
+                    var abort = function() {
+                        var error = new _abortErrorJs.AbortError("The operation was aborted.");
+                        reject(error);
+                        if (request.body && _instanceof(request.body, _nodeStream.default.Readable)) {
+                            request.body.destroy(error);
+                        }
+                        if (!response1 || !response1.body) {
+                            return;
+                        }
+                        response1.body.emit("error", error);
+                    };
+                    if (signal && signal.aborted) {
+                        abort();
+                        return;
+                    }
+                    var abortAndFinalize = function() {
+                        abort();
+                        finalize();
+                    };
+                    // Send request
+                    var request_ = send(parsedURL.toString(), options);
+                    if (signal) {
+                        signal.addEventListener("abort", abortAndFinalize);
+                    }
+                    var finalize = function() {
+                        request_.abort();
+                        if (signal) {
+                            signal.removeEventListener("abort", abortAndFinalize);
+                        }
+                    };
+                    request_.on("error", function(error) {
+                        reject(new _fetchErrorJs.FetchError("request to ".concat(request.url, " failed, reason: ").concat(error.message), "system", error));
+                        finalize();
+                    });
+                    fixResponseChunkedTransferBadEnding(request_, function(error) {
+                        if (response1 && response1.body) {
+                            response1.body.destroy(error);
+                        }
+                    });
+                    /* c8 ignore next 18 */ if (process.version < "v14") {
+                        // Before Node.js 14, pipeline() does not fully support async iterators and does not always
+                        // properly handle when the socket close/end events are out of order.
+                        request_.on("socket", function(s) {
+                            var endedWithEventsCount;
+                            s.prependListener("end", function() {
+                                endedWithEventsCount = s._eventsCount;
+                            });
+                            s.prependListener("close", function(hadError) {
+                                // if end happened before close but the socket didn't emit an error, do it now
+                                if (response1 && endedWithEventsCount < s._eventsCount && !hadError) {
+                                    var error = new Error("Premature close");
+                                    error.code = "ERR_STREAM_PREMATURE_CLOSE";
+                                    response1.body.emit("error", error);
+                                }
+                            });
+                        });
+                    }
+                    request_.on("response", function(response_) {
+                        request_.setTimeout(0);
+                        var headers = (0, _headersJs.fromRawHeaders)(response_.rawHeaders);
+                        // HTTP fetch step 5
+                        if ((0, _isRedirectJs.isRedirect)(response_.statusCode)) {
+                            // HTTP fetch step 5.2
+                            var location = headers.get("Location");
+                            // HTTP fetch step 5.3
+                            var locationURL = null;
+                            try {
+                                locationURL = location === null ? null : new URL(location, request.url);
+                            } catch (e) {
+                                // error here can only be invalid URL in Location: header
+                                // do not throw when options.redirect == manual
+                                // let the user extract the errorneous redirect URL
+                                if (request.redirect !== "manual") {
+                                    reject(new _fetchErrorJs.FetchError("uri requested responds with an invalid redirect URL: ".concat(location), "invalid-redirect"));
+                                    finalize();
+                                    return;
+                                }
+                            }
+                            // HTTP fetch step 5.5
+                            switch(request.redirect){
+                                case "error":
+                                    reject(new _fetchErrorJs.FetchError("uri requested responds with a redirect, redirect mode is set to error: ".concat(request.url), "no-redirect"));
+                                    finalize();
+                                    return;
+                                case "manual":
+                                    break;
+                                case "follow":
+                                    {
+                                        // HTTP-redirect fetch step 2
+                                        if (locationURL === null) {
+                                            break;
+                                        }
+                                        // HTTP-redirect fetch step 5
+                                        if (request.counter >= request.follow) {
+                                            reject(new _fetchErrorJs.FetchError("maximum redirect reached at: ".concat(request.url), "max-redirect"));
+                                            finalize();
+                                            return;
+                                        }
+                                        // HTTP-redirect fetch step 6 (counter increment)
+                                        // Create a new Request object.
+                                        var requestOptions = {
+                                            headers: new _headersJs.default(request.headers),
+                                            follow: request.follow,
+                                            counter: request.counter + 1,
+                                            agent: request.agent,
+                                            compress: request.compress,
+                                            method: request.method,
+                                            body: (0, _bodyJs.clone)(request),
+                                            signal: request.signal,
+                                            size: request.size,
+                                            referrer: request.referrer,
+                                            referrerPolicy: request.referrerPolicy
+                                        };
+                                        // when forwarding sensitive headers like "Authorization",
+                                        // "WWW-Authenticate", and "Cookie" to untrusted targets,
+                                        // headers will be ignored when following a redirect to a domain
+                                        // that is not a subdomain match or exact match of the initial domain.
+                                        // For example, a redirect from "foo.com" to either "foo.com" or "sub.foo.com"
+                                        // will forward the sensitive headers, but a redirect to "bar.com" will not.
+                                        // headers will also be ignored when following a redirect to a domain using
+                                        // a different protocol. For example, a redirect from "https://foo.com" to "http://foo.com"
+                                        // will not forward the sensitive headers
+                                        if (!(0, _isJs.isDomainOrSubdomain)(request.url, locationURL) || !(0, _isJs.isSameProtocol)(request.url, locationURL)) {
+                                            for(var _i = 0, _iter = [
+                                                "authorization",
+                                                "www-authenticate",
+                                                "cookie",
+                                                "cookie2"
+                                            ]; _i < _iter.length; _i++){
+                                                var name = _iter[_i];
+                                                requestOptions.headers.delete(name);
+                                            }
+                                        }
+                                        // HTTP-redirect fetch step 9
+                                        if (response_.statusCode !== 303 && request.body && _instanceof(options_.body, _nodeStream.default.Readable)) {
+                                            reject(new _fetchErrorJs.FetchError("Cannot follow redirect with body being a readable stream", "unsupported-redirect"));
+                                            finalize();
+                                            return;
+                                        }
+                                        // HTTP-redirect fetch step 11
+                                        if (response_.statusCode === 303 || (response_.statusCode === 301 || response_.statusCode === 302) && request.method === "POST") {
+                                            requestOptions.method = "GET";
+                                            requestOptions.body = undefined;
+                                            requestOptions.headers.delete("content-length");
+                                        }
+                                        // HTTP-redirect fetch step 14
+                                        var responseReferrerPolicy = (0, _referrerJs.parseReferrerPolicyFromHeader)(headers);
+                                        if (responseReferrerPolicy) {
+                                            requestOptions.referrerPolicy = responseReferrerPolicy;
+                                        }
+                                        // HTTP-redirect fetch step 15
+                                        resolve(fetch(new _requestJs.default(locationURL, requestOptions)));
+                                        finalize();
+                                        return;
+                                    }
+                                default:
+                                    return reject(new TypeError("Redirect option '".concat(request.redirect, "' is not a valid value of RequestRedirect")));
+                            }
+                        }
+                        // Prepare response
+                        if (signal) {
+                            response_.once("end", function() {
+                                signal.removeEventListener("abort", abortAndFinalize);
+                            });
+                        }
+                        var body = (0, _nodeStream.pipeline)(response_, new _nodeStream.PassThrough(), function(error) {
+                            if (error) {
+                                reject(error);
+                            }
+                        });
+                        // see https://github.com/nodejs/node/pull/29376
+                        /* c8 ignore next 3 */ if (process.version < "v12.10") {
+                            response_.on("aborted", abortAndFinalize);
+                        }
+                        var responseOptions = {
+                            url: request.url,
+                            status: response_.statusCode,
+                            statusText: response_.statusMessage,
+                            headers: headers,
+                            size: request.size,
+                            counter: request.counter,
+                            highWaterMark: request.highWaterMark
+                        };
+                        // HTTP-network fetch step 12.1.1.3
+                        var codings = headers.get("Content-Encoding");
+                        // HTTP-network fetch step 12.1.1.4: handle content codings
+                        // in following scenarios we ignore compression support
+                        // 1. compression support is disabled
+                        // 2. HEAD request
+                        // 3. no Content-Encoding header
+                        // 4. no content response (204)
+                        // 5. content not modified response (304)
+                        if (!request.compress || request.method === "HEAD" || codings === null || response_.statusCode === 204 || response_.statusCode === 304) {
+                            response1 = new _responseJs.default(body, responseOptions);
+                            resolve(response1);
+                            return;
+                        }
+                        // For Node v6+
+                        // Be less strict when decoding compressed responses, since sometimes
+                        // servers send slightly invalid responses that are still accepted
+                        // by common browsers.
+                        // Always using Z_SYNC_FLUSH is what cURL does.
+                        var zlibOptions = {
+                            flush: _nodeZlib.default.Z_SYNC_FLUSH,
+                            finishFlush: _nodeZlib.default.Z_SYNC_FLUSH
+                        };
+                        // For gzip
+                        if (codings === "gzip" || codings === "x-gzip") {
+                            body = (0, _nodeStream.pipeline)(body, _nodeZlib.default.createGunzip(zlibOptions), function(error) {
+                                if (error) {
+                                    reject(error);
+                                }
+                            });
+                            response1 = new _responseJs.default(body, responseOptions);
+                            resolve(response1);
+                            return;
+                        }
+                        // For deflate
+                        if (codings === "deflate" || codings === "x-deflate") {
+                            // Handle the infamous raw deflate response from old servers
+                            // a hack for old IIS and Apache servers
+                            var raw = (0, _nodeStream.pipeline)(response_, new _nodeStream.PassThrough(), function(error) {
+                                if (error) {
+                                    reject(error);
+                                }
+                            });
+                            raw.once("data", function(chunk) {
+                                // See http://stackoverflow.com/questions/37519828
+                                if ((chunk[0] & 0x0F) === 0x08) {
+                                    body = (0, _nodeStream.pipeline)(body, _nodeZlib.default.createInflate(), function(error) {
+                                        if (error) {
+                                            reject(error);
+                                        }
+                                    });
+                                } else {
+                                    body = (0, _nodeStream.pipeline)(body, _nodeZlib.default.createInflateRaw(), function(error) {
+                                        if (error) {
+                                            reject(error);
+                                        }
+                                    });
+                                }
+                                response1 = new _responseJs.default(body, responseOptions);
+                                resolve(response1);
+                            });
+                            raw.once("end", function() {
+                                // Some old IIS servers return zero-length OK deflate responses, so
+                                // 'data' is never emitted. See https://github.com/node-fetch/node-fetch/pull/903
+                                if (!response1) {
+                                    response1 = new _responseJs.default(body, responseOptions);
+                                    resolve(response1);
+                                }
+                            });
+                            return;
+                        }
+                        // For br
+                        if (codings === "br") {
+                            body = (0, _nodeStream.pipeline)(body, _nodeZlib.default.createBrotliDecompress(), function(error) {
+                                if (error) {
+                                    reject(error);
+                                }
+                            });
+                            response1 = new _responseJs.default(body, responseOptions);
+                            resolve(response1);
+                            return;
+                        }
+                        // Otherwise, use response as-is
+                        response1 = new _responseJs.default(body, responseOptions);
+                        resolve(response1);
+                    });
+                    // eslint-disable-next-line promise/prefer-await-to-then
+                    (0, _bodyJs.writeToStream)(request_, request).catch(reject);
+                })
+            ];
+        });
+    });
+    return _fetch.apply(this, arguments);
+}
+function fixResponseChunkedTransferBadEnding(request, errorCallback) {
+    var LAST_CHUNK = _nodeBuffer.Buffer.from("0\r\n\r\n");
+    var isChunkedTransfer = false;
+    var properLastChunkReceived = false;
+    var previousChunk;
+    request.on("response", function(response) {
+        var headers = response.headers;
+        isChunkedTransfer = headers["transfer-encoding"] === "chunked" && !headers["content-length"];
+    });
+    request.on("socket", function(socket) {
+        var onSocketClose = function() {
+            if (isChunkedTransfer && !properLastChunkReceived) {
+                var error = new Error("Premature close");
+                error.code = "ERR_STREAM_PREMATURE_CLOSE";
+                errorCallback(error);
+            }
+        };
+        var onData = function(buf) {
+            properLastChunkReceived = _nodeBuffer.Buffer.compare(buf.slice(-5), LAST_CHUNK) === 0;
+            // Sometimes final 0-length chunk and end of message code are in separate packets
+            if (!properLastChunkReceived && previousChunk) {
+                properLastChunkReceived = _nodeBuffer.Buffer.compare(previousChunk.slice(-3), LAST_CHUNK.slice(0, 3)) === 0 && _nodeBuffer.Buffer.compare(buf.slice(-2), LAST_CHUNK.slice(3)) === 0;
+            }
+            previousChunk = buf;
+        };
+        socket.prependListener("close", onSocketClose);
+        socket.on("data", onData);
+        request.on("close", function() {
+            socket.removeListener("close", onSocketClose);
+            socket.removeListener("data", onData);
+        });
+    });
+}