724 lines
19 KiB
JavaScript
724 lines
19 KiB
JavaScript
Object.defineProperty(exports, "__esModule", {
|
|
value: !0
|
|
});
|
|
|
|
var e = require("node:stream");
|
|
|
|
var t = require("node:https");
|
|
|
|
var n = require("node:http");
|
|
|
|
var o = require("node:url");
|
|
|
|
var r = require("node:stream/consumers");
|
|
|
|
var s = require("node:util/types");
|
|
|
|
var a = require("node:crypto");
|
|
|
|
var i = require("node:buffer");
|
|
|
|
var c = require("node:zlib");
|
|
|
|
var l = require("node:net");
|
|
|
|
function _interopNamespaceDefault(e) {
|
|
var t = Object.create(null);
|
|
if (e) {
|
|
Object.keys(e).forEach((function(n) {
|
|
if ("default" !== n) {
|
|
var o = Object.getOwnPropertyDescriptor(e, n);
|
|
Object.defineProperty(t, n, o.get ? o : {
|
|
enumerable: !0,
|
|
get: function() {
|
|
return e[n];
|
|
}
|
|
});
|
|
}
|
|
}));
|
|
}
|
|
t.default = e;
|
|
return t;
|
|
}
|
|
|
|
var f = _interopNamespaceDefault(t);
|
|
|
|
var u = _interopNamespaceDefault(n);
|
|
|
|
var p = _interopNamespaceDefault(o);
|
|
|
|
var d = _interopNamespaceDefault(i);
|
|
|
|
var y = _interopNamespaceDefault(c);
|
|
|
|
var h = _interopNamespaceDefault(l);
|
|
|
|
const m = globalThis.File || d.File;
|
|
|
|
if (void 0 === globalThis.File) {
|
|
globalThis.File = m;
|
|
}
|
|
|
|
const b = Blob;
|
|
|
|
const g = URLSearchParams;
|
|
|
|
const w = URL;
|
|
|
|
exports.Request = void 0;
|
|
|
|
exports.Response = void 0;
|
|
|
|
exports.Headers = void 0;
|
|
|
|
exports.FormData = void 0;
|
|
|
|
if ("undefined" != typeof Request) {
|
|
exports.Request = Request;
|
|
}
|
|
|
|
if ("undefined" != typeof Response) {
|
|
exports.Response = Response;
|
|
}
|
|
|
|
if ("undefined" != typeof Headers) {
|
|
exports.Headers = Headers;
|
|
}
|
|
|
|
if ("undefined" != typeof FormData) {
|
|
exports.FormData = FormData;
|
|
}
|
|
|
|
const T = "\r\n";
|
|
|
|
const v = "-".repeat(2);
|
|
|
|
const isReadable = t => e.Readable.isReadable(t);
|
|
|
|
const isReadableStream = e => "object" == typeof e && "function" == typeof e.getReader && "function" == typeof e.cancel && "function" == typeof e.tee;
|
|
|
|
const isBlob = e => {
|
|
if ("object" == typeof e && "function" == typeof e.arrayBuffer && "string" == typeof e.type && "function" == typeof e.stream && "function" == typeof e.constructor) {
|
|
const t = e[Symbol.toStringTag];
|
|
return !!t && (t.startsWith("Blob") || t.startsWith("File"));
|
|
} else {
|
|
return !1;
|
|
}
|
|
};
|
|
|
|
const getFormHeader = (e, t, n) => {
|
|
let o = `${v}${e}${T}`;
|
|
o += `Content-Disposition: form-data; name="${t}"`;
|
|
if (isBlob(n)) {
|
|
o += `; filename="${n.name ?? "blob"}"${T}`;
|
|
o += `Content-Type: ${n.type || "application/octet-stream"}`;
|
|
}
|
|
return `${o}${T}${T}`;
|
|
};
|
|
|
|
const getFormFooter = e => `${v}${e}${v}${T}${T}`;
|
|
|
|
const _ = new TextEncoder;
|
|
|
|
const extractBody = t => {
|
|
let n = null;
|
|
let o;
|
|
let r = null;
|
|
if (null == t) {
|
|
o = null;
|
|
r = 0;
|
|
} else if ("string" == typeof t) {
|
|
const e = _.encode(`${t}`);
|
|
n = "text/plain;charset=UTF-8";
|
|
r = e.byteLength;
|
|
o = e;
|
|
} else if ((e => "object" == typeof e && "function" == typeof e.append && "function" == typeof e.delete && "function" == typeof e.get && "function" == typeof e.getAll && "function" == typeof e.has && "function" == typeof e.set && "function" == typeof e.sort && "URLSearchParams" === e[Symbol.toStringTag])(t)) {
|
|
const e = _.encode(t.toString());
|
|
o = e;
|
|
r = e.byteLength;
|
|
n = "application/x-www-form-urlencoded;charset=UTF-8";
|
|
} else if (isBlob(t)) {
|
|
r = t.size;
|
|
n = t.type || null;
|
|
o = t.stream();
|
|
} else if (t instanceof Uint8Array) {
|
|
o = t;
|
|
r = t.byteLength;
|
|
} else if (s.isAnyArrayBuffer(t)) {
|
|
const e = new Uint8Array(t);
|
|
o = e;
|
|
r = e.byteLength;
|
|
} else if (ArrayBuffer.isView(t)) {
|
|
const e = new Uint8Array(t.buffer, t.byteOffset, t.byteLength);
|
|
o = e;
|
|
r = e.byteLength;
|
|
} else if (isReadableStream(t)) {
|
|
o = t;
|
|
} else if ((e => "object" == typeof e && "function" == typeof e.append && "function" == typeof e.set && "function" == typeof e.get && "function" == typeof e.getAll && "function" == typeof e.delete && "function" == typeof e.keys && "function" == typeof e.values && "function" == typeof e.entries && "function" == typeof e.constructor && "FormData" === e[Symbol.toStringTag])(t)) {
|
|
const s = `formdata-${a.randomBytes(8).toString("hex")}`;
|
|
n = `multipart/form-data; boundary=${s}`;
|
|
r = ((e, t) => {
|
|
let n = Buffer.byteLength(getFormFooter(t));
|
|
for (const [o, r] of e) {
|
|
n += Buffer.byteLength(getFormHeader(t, o, r)) + (isBlob(r) ? r.size : Buffer.byteLength(`${r}`)) + 2;
|
|
}
|
|
return n;
|
|
})(t, s);
|
|
o = e.Readable.from(async function* generatorOfFormData(e, t) {
|
|
const n = new TextEncoder;
|
|
for (const [o, r] of e) {
|
|
if (isBlob(r)) {
|
|
yield n.encode(getFormHeader(t, o, r));
|
|
yield* r.stream();
|
|
yield n.encode(T);
|
|
} else {
|
|
yield n.encode(getFormHeader(t, o, r) + r + T);
|
|
}
|
|
}
|
|
yield n.encode(getFormFooter(t));
|
|
}(t, s));
|
|
} else if ((t => "function" == typeof t.getBoundary && "function" == typeof t.hasKnownLength && "function" == typeof t.getLengthSync && e.Readable.isReadable(t))(t)) {
|
|
n = `multipart/form-data; boundary=${t.getBoundary()}`;
|
|
r = t.hasKnownLength() ? t.getLengthSync() : null;
|
|
o = t;
|
|
} else if (isReadable(t)) {
|
|
o = t;
|
|
} else if ((e => "function" == typeof e[Symbol.asyncIterator] || "function" == typeof e[Symbol.iterator])(t)) {
|
|
o = e.Readable.from(t);
|
|
} else {
|
|
const e = _.encode(`${t}`);
|
|
n = "text/plain;charset=UTF-8";
|
|
o = e;
|
|
r = e.byteLength;
|
|
}
|
|
return {
|
|
contentLength: r,
|
|
contentType: n,
|
|
body: o
|
|
};
|
|
};
|
|
|
|
const x = Symbol("kBodyInternals");
|
|
|
|
class InflateStream extends e.Transform {
|
|
constructor(e) {
|
|
super();
|
|
this._opts = e;
|
|
}
|
|
_transform(e, t, n) {
|
|
if (!this._inflate) {
|
|
if (0 === e.length) {
|
|
n();
|
|
return;
|
|
}
|
|
this._inflate = 8 == (15 & e[0]) ? y.createInflate(this._opts) : y.createInflateRaw(this._opts);
|
|
this._inflate.on("data", this.push.bind(this));
|
|
this._inflate.on("end", (() => this.push(null)));
|
|
this._inflate.on("error", (e => this.destroy(e)));
|
|
}
|
|
this._inflate.write(e, t, n);
|
|
}
|
|
_final(e) {
|
|
if (this._inflate) {
|
|
this._inflate.once("finish", e);
|
|
this._inflate.end();
|
|
this._inflate = void 0;
|
|
} else {
|
|
e();
|
|
}
|
|
}
|
|
}
|
|
|
|
const getHttpProxyUrl = () => process.env.HTTP_PROXY ?? process.env.http_proxy;
|
|
|
|
const createProxyPattern = e => {
|
|
if (!(e = e.trim()).startsWith(".")) {
|
|
e = `^${e}`;
|
|
}
|
|
if (!e.endsWith(".") || e.includes(":")) {
|
|
e += "$";
|
|
}
|
|
return (e = e.replace(/\./g, "\\.").replace(/\*/g, "[\\w.]+")) ? new RegExp(e, "i") : null;
|
|
};
|
|
|
|
const matchesNoProxy = e => {
|
|
const t = process.env.NO_PROXY ?? process.env.no_proxy;
|
|
if ("*" === t || "1" === t || "true" === t) {
|
|
return !0;
|
|
} else if (t) {
|
|
for (const n of t.split(",")) {
|
|
const t = createProxyPattern(n);
|
|
if (t) {
|
|
const n = e.hostname || e.host;
|
|
const o = n && `${n}:${e.port || e.defaultPort || 80}`;
|
|
if (n && t.test(n) || o && t.test(o)) {
|
|
return !0;
|
|
}
|
|
}
|
|
}
|
|
return !1;
|
|
} else {
|
|
return !1;
|
|
}
|
|
};
|
|
|
|
const L = {
|
|
keepAlive: !0,
|
|
keepAliveMsecs: 1e3
|
|
};
|
|
|
|
let R;
|
|
|
|
let A;
|
|
|
|
let P;
|
|
|
|
let E;
|
|
|
|
const createRequestOptions = (e, t, n) => {
|
|
const o = {
|
|
host: `${n.host}:${n.port}`,
|
|
connection: t ? "keep-alive" : "close"
|
|
};
|
|
if (e.username || e.password) {
|
|
const t = decodeURIComponent(e.username || "");
|
|
const n = decodeURIComponent(e.password || "");
|
|
const r = Buffer.from(`${t}:${n}`).toString("base64");
|
|
o["proxy-authorization"] = `Basic ${r}`;
|
|
}
|
|
return {
|
|
method: "CONNECT",
|
|
host: e.hostname,
|
|
port: e.port,
|
|
path: `${n.host}:${n.port}`,
|
|
setHost: !1,
|
|
agent: !1,
|
|
proxyEnv: {},
|
|
timeout: 5e3,
|
|
headers: o,
|
|
servername: "https:" === e.protocol ? e.hostname : void 0
|
|
};
|
|
};
|
|
|
|
class HttpProxyAgent extends u.Agent {
|
|
constructor(e, t) {
|
|
super(t);
|
|
this._proxy = e;
|
|
this._keepAlive = !!t.keepAlive;
|
|
}
|
|
createConnection(e, t) {
|
|
const n = ("http:" === this._proxy.protocol ? u : f).request(createRequestOptions(this._proxy, this._keepAlive, e));
|
|
n.once("connect", ((e, o, r) => {
|
|
n.removeAllListeners();
|
|
o.removeAllListeners();
|
|
if (200 === e.statusCode) {
|
|
t(null, o);
|
|
} else {
|
|
o.destroy();
|
|
t(new Error(`HTTP Proxy Network Error: ${e.statusMessage || e.statusCode}`), null);
|
|
}
|
|
}));
|
|
n.once("timeout", (() => {
|
|
n.destroy(new Error("HTTP Proxy timed out"));
|
|
}));
|
|
n.once("error", (e => {
|
|
n.removeAllListeners();
|
|
t(e, null);
|
|
}));
|
|
n.end();
|
|
}
|
|
}
|
|
|
|
class HttpsProxyAgent extends f.Agent {
|
|
constructor(e, t) {
|
|
super(t);
|
|
this._proxy = e;
|
|
this._keepAlive = !!t.keepAlive;
|
|
}
|
|
createConnection(e, t) {
|
|
const n = ("http:" === this._proxy.protocol ? u : f).request(createRequestOptions(this._proxy, this._keepAlive, e));
|
|
n.once("connect", ((o, r, s) => {
|
|
n.removeAllListeners();
|
|
r.removeAllListeners();
|
|
if (200 === o.statusCode) {
|
|
const n = {
|
|
...e,
|
|
socket: r
|
|
};
|
|
h._normalizeArgs(n);
|
|
const o = super.createConnection(n);
|
|
t?.(null, o);
|
|
} else {
|
|
r.destroy();
|
|
t?.(new Error(`HTTP Proxy Network Error: ${o.statusMessage || o.statusCode}`), null);
|
|
}
|
|
}));
|
|
n.once("timeout", (() => {
|
|
n.destroy(new Error("HTTP Proxy timed out"));
|
|
}));
|
|
n.once("error", (e => {
|
|
n.removeAllListeners();
|
|
t?.(e, null);
|
|
}));
|
|
n.end();
|
|
return n.socket;
|
|
}
|
|
}
|
|
|
|
const headersOfRawHeaders = e => {
|
|
const t = new Headers;
|
|
for (let n = 0; n < e.length; n += 2) {
|
|
t.append(e[n], e[n + 1]);
|
|
}
|
|
return t;
|
|
};
|
|
|
|
const methodToHttpOption = e => {
|
|
const t = e?.toUpperCase();
|
|
switch (t) {
|
|
case "CONNECT":
|
|
case "TRACE":
|
|
case "TRACK":
|
|
throw new TypeError(`Failed to construct 'Request': '${e}' HTTP method is unsupported.`);
|
|
|
|
case "DELETE":
|
|
case "GET":
|
|
case "HEAD":
|
|
case "OPTIONS":
|
|
case "POST":
|
|
case "PUT":
|
|
return t;
|
|
|
|
default:
|
|
return e ?? "GET";
|
|
}
|
|
};
|
|
|
|
const urlToHttpOptions = e => {
|
|
const t = new w(e);
|
|
switch (t.protocol) {
|
|
case "http:":
|
|
case "https:":
|
|
return p.urlToHttpOptions(t);
|
|
|
|
default:
|
|
throw new TypeError(`URL scheme "${t.protocol}" is not supported.`);
|
|
}
|
|
};
|
|
|
|
async function _fetch(t, n) {
|
|
const o = (e => null != e && "object" == typeof e && "body" in e)(t);
|
|
const r = o ? t.url : t;
|
|
const s = n?.body ?? (o ? t.body : null);
|
|
const a = n?.signal ?? (o ? t.signal : void 0);
|
|
const i = (e => {
|
|
switch (e) {
|
|
case "follow":
|
|
case "manual":
|
|
case "error":
|
|
return e;
|
|
|
|
case void 0:
|
|
return "follow";
|
|
|
|
default:
|
|
throw new TypeError(`Request constructor: ${e} is not an accepted type. Expected one of follow, manual, error.`);
|
|
}
|
|
})(n?.redirect ?? (o ? t.redirect : void 0));
|
|
let c = new w(r);
|
|
let l = extractBody(s);
|
|
let p = 0;
|
|
const d = new Headers(n?.headers ?? (o ? t.headers : void 0));
|
|
const h = {
|
|
...urlToHttpOptions(c),
|
|
timeout: 5e3,
|
|
method: methodToHttpOption(o ? t.method : n?.method),
|
|
signal: a
|
|
};
|
|
return await new Promise((function _call(t, n) {
|
|
h.agent = "https:" === h.protocol ? (e => {
|
|
const t = process.env.HTTPS_PROXY ?? process.env.https_proxy ?? getHttpProxyUrl();
|
|
if (!t) {
|
|
E = void 0;
|
|
return;
|
|
} else if (matchesNoProxy(e)) {
|
|
return;
|
|
} else if (!P || P !== t) {
|
|
E = void 0;
|
|
try {
|
|
P = t;
|
|
E = new HttpsProxyAgent(new URL(t), L);
|
|
} catch (e) {
|
|
const n = new Error(`Invalid HTTPS_PROXY URL: "${t}".\n` + e?.message || e);
|
|
n.cause = e;
|
|
throw n;
|
|
}
|
|
return E;
|
|
} else {
|
|
return E;
|
|
}
|
|
})(h) : (e => {
|
|
const t = getHttpProxyUrl();
|
|
if (!t) {
|
|
A = void 0;
|
|
return;
|
|
} else if (matchesNoProxy(e)) {
|
|
return;
|
|
} else if (!R || R !== t) {
|
|
A = void 0;
|
|
try {
|
|
R = t;
|
|
A = new HttpProxyAgent(new URL(t), L);
|
|
} catch (e) {
|
|
const n = new Error(`Invalid HTTP_PROXY URL: "${t}".\n` + e?.message || e);
|
|
n.cause = e;
|
|
throw n;
|
|
}
|
|
return A;
|
|
} else {
|
|
return A;
|
|
}
|
|
})(h);
|
|
const o = h.method;
|
|
const r = ("https:" === h.protocol ? f : u).request(h);
|
|
let m;
|
|
const destroy = e => {
|
|
if (e) {
|
|
r?.destroy(a?.aborted ? a.reason : e);
|
|
m?.destroy(a?.aborted ? a.reason : e);
|
|
n(a?.aborted ? a.reason : e);
|
|
}
|
|
a?.removeEventListener("abort", destroy);
|
|
};
|
|
a?.addEventListener("abort", destroy);
|
|
r.on("timeout", (() => {
|
|
if (!m) {
|
|
const e = new Error("Request timed out");
|
|
e.code = "ETIMEDOUT";
|
|
destroy(e);
|
|
}
|
|
}));
|
|
r.on("response", (f => {
|
|
if (a?.aborted) {
|
|
return;
|
|
}
|
|
m = f;
|
|
m.setTimeout(0);
|
|
m.socket.unref();
|
|
m.on("error", destroy);
|
|
const u = {
|
|
status: m.statusCode,
|
|
statusText: m.statusMessage,
|
|
headers: headersOfRawHeaders(m.rawHeaders)
|
|
};
|
|
if (301 === (b = u.status) || 302 === b || 303 === b || 307 === b || 308 === b) {
|
|
const e = u.headers.get("Location");
|
|
const r = null != e ? ((e, t) => {
|
|
try {
|
|
return new w(e, t);
|
|
} catch {
|
|
return null;
|
|
}
|
|
})(e, c) : null;
|
|
if ("error" === i) {
|
|
n(new Error("URI requested responds with a redirect, redirect mode is set to error"));
|
|
return;
|
|
} else if ("manual" === i && e) {
|
|
u.headers.set("Location", r?.href ?? e);
|
|
} else if ("follow" === i) {
|
|
if (null === r) {
|
|
n(new Error("URI requested responds with an invalid redirect URL"));
|
|
return;
|
|
} else if (++p > 20) {
|
|
n(new Error(`maximum redirect reached at: ${c}`));
|
|
return;
|
|
} else if ("http:" !== r.protocol && "https:" !== r.protocol) {
|
|
n(new Error("URL scheme must be a HTTP(S) scheme"));
|
|
return;
|
|
}
|
|
if (303 === u.status || (301 === u.status || 302 === u.status) && "POST" === o) {
|
|
l = extractBody(null);
|
|
h.method = "GET";
|
|
d.delete("Content-Length");
|
|
} else if (null != l.body && null == l.contentLength) {
|
|
n(new Error("Cannot follow redirect with a streamed body"));
|
|
return;
|
|
} else {
|
|
l = extractBody(s);
|
|
}
|
|
Object.assign(h, urlToHttpOptions(c = r));
|
|
return _call(t, n);
|
|
}
|
|
}
|
|
var b;
|
|
let g = m;
|
|
const T = u.headers.get("Content-Encoding")?.toLowerCase();
|
|
if ("HEAD" === o || 204 === u.status || 304 === u.status) {
|
|
g = null;
|
|
} else if (null != T) {
|
|
u.headers.set("Content-Encoding", T);
|
|
g = e.pipeline(g, (t => {
|
|
switch (t) {
|
|
case "br":
|
|
return y.createBrotliDecompress({
|
|
flush: y.constants.BROTLI_OPERATION_FLUSH,
|
|
finishFlush: y.constants.BROTLI_OPERATION_FLUSH
|
|
});
|
|
|
|
case "gzip":
|
|
case "x-gzip":
|
|
return y.createGunzip({
|
|
flush: y.constants.Z_SYNC_FLUSH,
|
|
finishFlush: y.constants.Z_SYNC_FLUSH
|
|
});
|
|
|
|
case "deflate":
|
|
case "x-deflate":
|
|
return new InflateStream({
|
|
flush: y.constants.Z_SYNC_FLUSH,
|
|
finishFlush: y.constants.Z_SYNC_FLUSH
|
|
});
|
|
|
|
default:
|
|
return new e.PassThrough;
|
|
}
|
|
})(T), destroy);
|
|
r.on("error", destroy);
|
|
}
|
|
if (null != g) {
|
|
!function attachRefLifetime(e, t) {
|
|
const {_read: n} = e;
|
|
e.on("close", (() => {
|
|
t.unref();
|
|
}));
|
|
e._read = function _readRef(...o) {
|
|
e._read = n;
|
|
t.ref();
|
|
return n.apply(this, o);
|
|
};
|
|
}(g, m.socket);
|
|
}
|
|
t(function createResponse(e, t, n) {
|
|
const o = new exports.Response(e, t);
|
|
Object.defineProperty(o, "url", {
|
|
value: n.url
|
|
});
|
|
if ("default" !== n.type) {
|
|
Object.defineProperty(o, "type", {
|
|
value: n.type
|
|
});
|
|
}
|
|
if (n.redirected) {
|
|
Object.defineProperty(o, "redirected", {
|
|
value: n.redirected
|
|
});
|
|
}
|
|
return o;
|
|
}(g, u, {
|
|
type: "default",
|
|
url: c.toString(),
|
|
redirected: p > 0
|
|
}));
|
|
}));
|
|
r.on("error", destroy);
|
|
if (!d.has("Accept")) {
|
|
d.set("Accept", "*/*");
|
|
}
|
|
if (!d.has("Content-Type") && l.contentType) {
|
|
d.set("Content-Type", l.contentType);
|
|
}
|
|
if (null == l.body && ("POST" === o || "PUT" === o || "PATCH" === o)) {
|
|
d.set("Content-Length", "0");
|
|
} else if (null != l.body && null != l.contentLength) {
|
|
d.set("Content-Length", `${l.contentLength}`);
|
|
}
|
|
((e, t) => {
|
|
const n = {};
|
|
for (const [e, o] of t) {
|
|
if (Array.isArray(n[e])) {
|
|
n[e].push(o);
|
|
} else if (null != n[e]) {
|
|
n[e] = [ n[e], o ];
|
|
} else {
|
|
n[e] = o;
|
|
}
|
|
}
|
|
for (const t in n) {
|
|
e.setHeader(t, n[t]);
|
|
}
|
|
})(r, d);
|
|
if (null == l.body) {
|
|
r.end();
|
|
} else if (l.body instanceof Uint8Array) {
|
|
r.write(l.body);
|
|
r.end();
|
|
} else {
|
|
const t = l.body instanceof e.Stream ? l.body : e.Readable.fromWeb(l.body);
|
|
e.pipeline(t, r, destroy);
|
|
}
|
|
}));
|
|
}
|
|
|
|
exports.Blob = b;
|
|
|
|
exports.Body = class Body {
|
|
constructor(e) {
|
|
this[x] = extractBody(e);
|
|
}
|
|
get body() {
|
|
return this[x].body;
|
|
}
|
|
get bodyUsed() {
|
|
const {body: t} = this[x];
|
|
if (isReadable(t)) {
|
|
return e.Readable.isDisturbed(t);
|
|
} else if (isReadableStream(t)) {
|
|
return t.locked;
|
|
} else {
|
|
return !1;
|
|
}
|
|
}
|
|
async arrayBuffer() {
|
|
const {body: e} = this[x];
|
|
return null != e && !s.isAnyArrayBuffer(e) ? r.arrayBuffer(e) : e;
|
|
}
|
|
async formData() {
|
|
const {body: e, contentLength: t, contentType: n} = this[x];
|
|
const o = {};
|
|
if (t) {
|
|
o["Content-Length"] = t;
|
|
}
|
|
if (n) {
|
|
o["Content-Type"] = n;
|
|
}
|
|
return new exports.Response(e, {
|
|
headers: o
|
|
}).formData();
|
|
}
|
|
async blob() {
|
|
const {body: e, contentType: t} = this[x];
|
|
const n = null !== e ? [ !s.isAnyArrayBuffer(e) ? await r.blob(e) : e ] : [];
|
|
return new b(n, {
|
|
type: t ?? void 0
|
|
});
|
|
}
|
|
async json() {
|
|
return JSON.parse(await this.text());
|
|
}
|
|
async text() {
|
|
const {body: e} = this[x];
|
|
return null == e || s.isAnyArrayBuffer(e) ? (new TextDecoder).decode(await this.arrayBuffer()) : r.text(e);
|
|
}
|
|
};
|
|
|
|
exports.File = m;
|
|
|
|
exports.URL = w;
|
|
|
|
exports.URLSearchParams = g;
|
|
|
|
exports.default = _fetch;
|
|
|
|
exports.fetch = _fetch;
|
|
//# sourceMappingURL=minifetch.js.map
|