@seayoo-web/request 3.5.2 → 4.0.1

package/README.md

@@ -11,12 +11,12 @@
 
 ## 特性
 
-1. 默认基于 fetch，请求和响应解析均默认基于 json 或 text
+1. 默认基于 fetch，请求和响应解析默认基于 json
 2. 支持重试配置 maxRetry / retryResolve / retryInterval
 3. 支持响应结果处理策略 responseRule 和通用提示配置
 4. 支持类型守卫 typeGuard
 5. 支持多实例，多端（浏览器，nodejs，微信小程序）
-6. get 请求函数支持并发缓存（默认缓存 500ms）
+6. get 请求支持并发缓存（默认缓存 500ms）
 7. 函数永不抛错，返回固定解析结构 { ok, data, status, headers, code, message }
 8. 提供格式化良好的 sentry 信息用于错误上报
 9. 提供 jsonp / jsonx 函数，支持带上传进度的 upload 函数
@@ -26,17 +26,17 @@
 ```js
 import { get } from "@seayoo-web/request"
 
-interface IUser {
+interface User {
     name: string,
     id:   string
 }
 
-function isUserList(data: unknown): data is IUser[] {
+function isUserList(data: unknown): data is User[] {
     return Array.isArray(data)
     	&& data.every(item => !!item && typeof item === "object" && "name" in item && "id" in item)
 }
 
-export async function getUserList(): Promise<IUser[]> {
+export async function getUserList(): Promise<User[]> {
     const { data } = await get("/api/user", isUserList)
     return data || []
 }
@@ -111,7 +111,7 @@ setConfig({ timeout: 10000 });
 
 类型：string
 
-说明：需要以 / 开头或者是一个完整的 url 地址；此设置会给所有请求的 url 增加 baseURL 作为前缀，但以下情况除外
+说明：需要以 `/` 开头或者是一个完整的 url 地址；此设置会给所有请求的 url 增加 baseURL 作为前缀，但以下情况除外
 
 1. 请求时传入的 url 为完整 url，即以 http:// 或 https:// 开头
 
@@ -129,24 +129,24 @@ setConfig({ timeout: 10000 });
 
 类型：number
 
-说明：请求超时设置，单位 ms，默认 10000，即 10 秒
+说明：请求超时设置，单位 ms，默认 `10000`，即 10 秒
 
 ### cacheTTL
 
 类型：number
 
-说明：用于控制全局请求的缓冲时长，单位 ms，默认 500，设置为 0 则全局禁用缓冲。默认仅仅对 get 请求做缓冲处理。
+说明：用于控制全局请求的缓冲时长，单位 ms，默认 `500`，设置为 `0` 则全局禁用缓冲。默认仅仅对 get 请求做缓冲处理。
 
 ### defaultTypeGuardMessage
 
 类型：string
 
-说明：默认的类型守卫错误提示，仅支持全局配置，默认 “响应数据未能正确识别”，单个 api 可通过传入完整的类型守卫（{ guard, message }）来定制提示消息。
+说明：默认的类型守卫错误提示，仅支持全局配置，默认 `响应数据未能正确识别`，单个 api 可通过传入完整的类型守卫（{ guard, message }）来定制提示消息。
 
 ### message
 
 类型：false | ((
-result: IResponseResult,
+result: ResponseResult,
 method: string,
 url: string,
 defaultMessage: string
@@ -222,21 +222,21 @@ defaultMessage: string
 
 类型：number
 
-说明：当请求发生错误时重试的次数，默认0，即不重试，最大为 10
+说明：当请求发生错误时重试的次数，默认 `1`，最大为 `10`
 
 ### retryResolve
 
-类型："default" | "network" | number[] | ((result: IRequestBaseResponse, count: number) => boolean)
+类型："default" | "network" | number[] | ((result: RequestBaseResponse, count: number) => boolean)
 
-说明：重试判断方法，默认是 default
+说明：重试判断方法，默认是 `default`
 
-default 在 network 基础之上，如果是 Tencent EO 响应的 552/522 错误码，则重试;
+- `default`: 在 `network` 基础之上，如果是 Tencent EO 响应的 552/522 错误码，则重试;
 
-network 表示仅仅当网络错误时才重试，如果请求被取消或超时（aborted/timeout）则不重试；
+- `network`: 表示仅仅当网络错误时（不含 aborted/timeout）才重试；
 
-当设置为 number[] 时，将检查 http 状态码，匹配则重试；
+- `number[]`：当设置为 number[] 时，将检查 http 状态码，匹配则重试；
 
-也可以设置为一个重试检查函数，返回 true 则进行重试；
+- 自定义函数：也可以设置为一个重试检查函数，返回 true 则进行重试；
 
 > 如果需要收集错误的重试信息，可以通过设置 retryResolve 为一个函数来检查或上报请求结果
 
@@ -244,11 +244,11 @@ network 表示仅仅当网络错误时才重试，如果请求被取消或超时
 
 类型：number | "2EB" | ((retryIndex: number, { url, method, status }) => number)
 
-说明：两次重试的间隔策略，设置为数字（单位 ms）表示固定间隔，设置为函数则可以自定义间隔；默认是 100ms；
+说明：两次重试的间隔策略，设置为数字（单位 ms）表示固定间隔，设置为函数则可以自定义间隔；默认是 `200`，即 200ms；
 
 其中 retryIndex 从 1 开始，最大为 10；最小时间间隔为 100ms；
 
-特殊值 2EB 表示以 2 为底的[指数退避策略](https://en.wikipedia.org/wiki/Exponential_backoff)，即首次重试等待 0.1 秒，后续分别是 0.2秒，0.4秒，0.8秒 ...
+特殊值 `2EB` 表示以 2 为底的[指数退避策略](https://en.wikipedia.org/wiki/Exponential_backoff)，即首次重试等待 0.1 秒，后续分别是 0.2秒，0.4秒，0.8秒 ...
 
 ### requestTransformer
 
@@ -257,7 +257,7 @@ headers: Record<string, string>,
 params: Record<string, string>,
 method: string,
 url: string,
-body: IBaseRequestBody
+body: BaseRequestBody
 }) => MaybePromise<void | string>)
 
 说明：可用于发送前修改请求相关数据
@@ -275,7 +275,6 @@ method: string,
 url: string,
 headers: Record<string, string>,
 rawError?: Error | ProgressEvent,
-responseBody: string,
 sentryError: Error,
 sentryTags: Record<string, string | number>,
 sentryExtra: Record<string, unknown>
@@ -285,7 +284,7 @@ sentryExtra: Record<string, unknown>
 
 ### responseHandler
 
-类型：null | ((result: IResponseResult, method: string, url: string) => void)
+类型：null | ((result: ResponseResult, method: string, url: string) => void)
 
 说明：请求完成后用于统一检查响应结果，非网络错误时触发，入参的数据均为副本，仅仅可读
 
@@ -297,13 +296,13 @@ sentryExtra: Record<string, unknown>
 
 ### logHandler
 
-类型：null | ((data: IRequestLog) => void)
+类型：null | ((data: RequestLog) => void)
 
 说明：全局日志打印函数，具体日志信息可参考源码类型声明；
 
 ## 网络请求参数
 
-类型：IRequestOptions
+类型：RequestOptions
 
 说明：网络请求参数，对于每个最终工具函数都提供有可选的请求参数，且每个字段均可选
 
@@ -313,7 +312,7 @@ sentryExtra: Record<string, unknown>
 
 ### params
 
-类型：Record<string, unknown>
+类型：Record<string, string | number | boolean>
 
 ### headers
 
@@ -349,6 +348,10 @@ sentryExtra: Record<string, unknown>
 
 同全局配置，设定的解析规则仅本次请求有效，默认跟随全局设置
 
+### asBuffer
+
+是否将响应内容作为 ArrayBuffer 返回，默认 `false`，当设置为 `true` 时，将会忽略 `responseRule`
+
 ### maxRetry
 
 同全局配置，仅本次请求有效，设置最大重试次数，默认跟随全局设置
@@ -391,17 +394,18 @@ sentryExtra: Record<string, unknown>
 
 类型：string
 
-说明：表示当前请求的状态信息，其可能值有
+说明：表示当前请求的状态信息，其可能值按照优先级从高到低：
+
+- `responseRule` 中自定义的错误码字段所传递的值
+- `RequestInternalError` 网络错误或取消等异常情况
 
-- http statusText 当请求完成且无自定义错误码时，可能为空字符串
-- responseRule 中自定义的错误码字段所传递的值
-- "Aborted" 或 "Unknown" 网络错误或取消等异常情况，详细参见 `RequestInternalError`
+- `Http StatusText` 当请求完成且无自定义错误码时
 
 ### message
 
 类型：string
 
-说明：响应结果的提示消息，不受 IRequestOptions.message 影响
+说明：响应结果的提示消息，不受 RequestOptions.message 影响
 
 ### headers
 
@@ -415,9 +419,10 @@ sentryExtra: Record<string, unknown>
 
 说明：响应的数据内容，其可能值为：
 
-- unknown：如果不提供类型守卫，则返回 unknown
-- null：网络请求错误、类型守卫检查失败、服务器没有返回正确格式的 json 数据，则返回 null
-- T： 如果成功返回并通过类型守卫检查，则返回类型守卫对应的类型
+- `unknown`：如果不提供类型守卫，则返回 unknown
+- `null`：网络请求错误、类型守卫检查失败、服务器没有返回预期的数据，则返回 null
+- `ArrayBuffer`：如果设置请求参数中 `asBuffer` 为 `true` 且没有提供类型守卫函数，在服务器成功响应时返回 arrayBuffer
+- `T`： 如果成功返回并通过类型守卫检查，则返回类型守卫对应的类型
 
 ## 类型守卫
 
@@ -432,54 +437,51 @@ type TypeGuard<T> = {
 type TypeGuardParam<T> = TypeGuard<T> | TypeGuardFn<T>
 ```
 
-## Request函数
+## 请求函数
 
-## request\<T\>(url: string, options?: IRequestOptions)
-
-底层实现的 request 工具函数，未绑定类型守卫处理，返回的数据类型固定为 unknown；同时也未对请求做任何缓存处理；通常情况推荐使用以下的包装函数：get / post / head / del / put / patch
-
-### get\<T\>(url: string, typeGard?: TypeGuardParam\<T\> | null, options?: IRequestOptions)
+### get(url, params?, guard?, options?)
 
 - **url**: 请求的资源路径，如果需要跳过全局 baseURL 设置，可以传递完整 url 地址
-- **typeGuard**: 可选类型守卫，如果设置为 null，则返回的内容为 unkonwn，否则就是经过类型守卫检查后的类型化数据，推荐传递类型守卫
-- **options**: 可选请求配置参数
+- **params**: 请求的 url query 参数，会强制覆盖 options.params
+- **guard**: 可选类型守卫，如果设置为 null，则返回的内容为 unknown，否则就是经过类型守卫检查后的类型化数据，推荐传递类型守卫
+- **options**: 其他可选请求配置参数
 
-> 注意，get 请求默认设置 500ms 缓存，即对同一个请求（url+params）在 500ms 内不再重复发起请求，而是直接返回上一次的结果，其中 params 会从 options.params 以及 url 中查找
+> 注意，get 请求默认设置 500ms 缓存，即对同一个请求（url+params）在 500ms 内不再重复发起请求，而是直接返回上一次的结果，其中 params 会包含 url 中带有的参数
 
-### post(url: string, data: RequstBody, typeGard?: TypeGuardParam\<T\> | null, options?: IRequestOptions)
+### post(url, body, guard?, options?)
 
-- **url**: 请求的资源路径，如果需要跳过全局 baseURL 设置，可以传递完整 url 地址
-- **data**: 请求发送的数据，会覆盖 IRequestOptions.body
-- **typeGuard**: 可选类型守卫，如果设置为 null，则返回的内容为 unkonwn，否则就是经过类型守卫检查后的类型化数据，推荐传递类型守卫，除非对响应内容不关心（比如 httpStatus 为 204 或 202）
-- **options**: 可选请求配置参数
+- **url**: 请求的资源路径，如果需要跳过全局 baseURL 设置，可以传递完整 url 地址，另外可以设置为 `{ url, params }` 对象来传递 url query 参数（当然也可以通过末尾的 options 参数传递 params）
+- **body**: 请求发送的 body 数据，会强制覆盖 options.body
+- **guard**: 可选类型守卫，如果设置为 null，则返回的内容为 unknown，否则就是经过类型守卫检查后的类型化数据，推荐传递类型守卫，除非对响应内容不关心（比如 httpStatus 为 204 或 202）
+- **options**: 其他可选请求配置参数
 
 ### Other
 
-**head(url, options?)** head 方法不支持响应body，也就无需 typeGuard
+**head(url, params?, options?)**
 
-**del(url, typeGard?, options?)**
+**del(url, params?, guard?, options?)**
 
-**put(url, data, typeGard?, options?)**
+**put(url, body, guard?, options?)**
 
-**patch(url, data, typeGard?, options?)**
+**patch(url, body, guard?, options?)**
 
 ## 特殊函数
 
 工具还提供了三个特殊函数以应对不同的场景需求，且限于浏览器环境使用：
 
-### upload(url: string, files: Record<string, Blob>, options?)
+### upload(url, files: Record<string, Blob>, options?)
 
-因为 fetch 不支持上传进度信息，故使用 xhr 函数包装，支持带有上传进度信息的 upload 函数，以满足特定场景下的大文件上传需求；
+因为 `fetch` 不支持上传进度信息，故使用 xhr 实现带有上传进度信息的 upload 函数，以满足特定场景下的大文件上传需求；
 
-其可选 options 不支持重试，其 body 类型限制为 Record<string, unknown>，并且随着 formData 发送；同时新增进度信息配置：
+其可选 options 不支持重试，其 request body 类型限制为 Record<string, unknown>，并且随着 formData 发送；同时新增进度信息配置：
 
 **onUploadProgress?: (progress: { total: number; loaded: number }) => void**
 
-### jsonp\<T\>(url: string, typeGuard: TypeGuardFn\<T\>, params?: Record\<string, string|number|boolean\>)
+### jsonp(url, guard, params?)
 
 以 script 方式加载远程资源，并通过 callback 回调接收远程数据，必须提供类型守卫；
 
-### jsonx\<T\>(url: string, typeGuard: TypeGuardFn\<T\>, params?: Record\<string, string|number|boolean\>)
+### jsonx(url, guard, params?)
 
 以 script 方式加载远程资源，并通过 var（全局变量）接收远程数据，必须提供类型守卫；
 

package/dist/index.js

@@ -1,160 +1,174 @@
-import { h as m, r as q, R as T, c as x, H as R, a as w, v as E, b as C, N as H, X as L } from "./retry-Cxkf8ke1.js";
-import { g as Q } from "./retry-Cxkf8ke1.js";
-import { f as v } from "./request.fetch-Jj3A4PnG.js";
-const j = async function(t, s, e) {
-  return m(await q(y, t, s, e), t, s, e);
+import { h, r as E, G as y, c as q, f as v, a as C, R as w, H as R, b as H, v as x, d as L, N as T, X as k } from "./retry-b0Etywu_.js";
+import { g as W } from "./retry-b0Etywu_.js";
+import { f as S } from "./request.fetch-U2PiTmEn.js";
+const j = async function(n, a, t) {
+  return h(await E(m, n, a, t), n, a, t);
 };
-async function k(t, s, e, n) {
-  const r = e?.body, l = e?.method === "PUT" ? "PUT" : "POST";
-  if (s instanceof Blob) {
-    const i = new T(n), u = await y(t, i, {
-      ...e,
-      method: l,
-      body: s
+async function B(n, a, t, r) {
+  const o = t?.body, u = t?.method === "PUT" ? "PUT" : "POST";
+  if (a instanceof Blob) {
+    const l = new y(r), e = await m(n, l, {
+      ...t,
+      method: u,
+      body: a
     });
-    return m(u, t, i, e);
+    return h(e, n, l, t);
   }
-  const a = new FormData(), d = { ...s };
-  r instanceof Object && Object.entries(r).forEach(([i, u]) => {
-    u instanceof Blob ? d[i] = u : Array.isArray(u) ? u.forEach((o, h) => {
-      a.append(`${i}[${h}]`, String(o));
-    }) : a.append(i, String(u));
+  const c = new FormData(), d = { ...a };
+  o instanceof Object && Object.entries(o).forEach(([l, e]) => {
+    e instanceof Blob ? d[l] = e : Array.isArray(e) ? e.forEach((g, s) => {
+      c.append(`${l}[${s}]`, String(g));
+    }) : c.append(l, String(e));
   });
-  for (const i in d)
-    a.append(i, d[i]);
-  const b = new T(n), g = await y(t, b, {
-    ...e,
-    method: l,
-    body: a
+  for (const l in d)
+    c.append(l, d[l]);
+  const f = new y(r), p = await m(n, f, {
+    ...t,
+    method: u,
+    body: c
   });
-  return m(g, t, b, e);
+  return h(p, n, f, t);
 }
-const y = async function(t, s, e) {
-  const n = await x(t, s, e), r = n.method, l = e?.onUploadProgress, a = R(n.url, n.params);
-  return await new Promise((d) => {
-    let b = null, g = !1;
-    const i = function() {
-      g || (o.abort(), g = !0);
+const m = async function(n, a, t) {
+  const r = await q(n, a, t), o = r.method, u = t?.onUploadProgress;
+  return await new Promise((c) => {
+    let d = null, f = !1;
+    const p = function() {
+      f || (e.abort(), f = !0);
     };
-    function u() {
-      b !== null && clearTimeout(b), n.abort && n.abort.removeEventListener("abort", i);
+    function l() {
+      d !== null && clearTimeout(d), r.abort && r.abort.removeEventListener("abort", p);
     }
-    const o = new XMLHttpRequest();
-    let h = !1;
-    if (o.open(r, a, !0), l) {
-      let f = 1;
-      o.upload.addEventListener("progress", (p) => {
-        f = p.total, l({ total: p.total, loaded: p.loaded });
-      }), o.addEventListener("load", () => {
-        l({ loaded: f, total: f });
+    const e = new XMLHttpRequest();
+    let g = !1;
+    if (e.open(o, r.url, !0), u) {
+      let s = 1;
+      e.upload.addEventListener("progress", (b) => {
+        s = b.total, u({ total: b.total, loaded: b.loaded });
+      }), e.addEventListener("load", () => {
+        u({ loaded: s, total: s });
       });
     }
-    o.addEventListener("load", () => {
-      const f = o.status, p = o.responseType;
-      u(), d({
-        url: a,
-        method: r,
-        status: f,
-        statusText: o.statusText,
-        headers: S(o),
-        body: r === "HEAD" || f === 204 ? "" : p === "" || p === "text" || p === "json" || p === "document" ? o.responseText : ""
-      });
-    }), o.addEventListener(
+    e.addEventListener("load", async () => {
+      l();
+      const s = e.responseType;
+      c(
+        await v(
+          {
+            url: r.url,
+            method: o,
+            status: e.status,
+            statusText: e.statusText,
+            headers: P(e),
+            body: null
+          },
+          {
+            asBuffer: r.asBuffer,
+            text: () => s === "" || s === "text" || s === "json" || s === "document" ? e.responseText : "",
+            buffer: async () => s === "arraybuffer" ? e.response : s === "blob" ? await e.response.arrayBuffer() : await C(e.responseText)
+          }
+        )
+      );
+    }), e.addEventListener(
       "error",
-      (f) => {
-        u(), d({
-          url: a,
-          method: r,
-          status: o.status || -1,
-          statusText: o.statusText || w.NetworkError,
-          body: "",
-          rawError: f
+      (s) => {
+        l(), c({
+          url: r.url,
+          method: o,
+          status: e.status || -1,
+          error: e.status ? void 0 : w.NetworkError,
+          statusText: e.statusText || w.NetworkError,
+          body: null,
+          rawError: s
         });
       },
       !0
-    ), o.addEventListener("abort", () => {
-      u(), d({
-        url: a,
-        method: r,
+    ), e.addEventListener("abort", () => {
+      l();
+      const s = g ? w.Timeout : w.Aborted;
+      c({
+        url: r.url,
+        method: o,
         status: -1,
-        statusText: h ? w.Timeout : w.Aborted,
-        body: ""
+        error: s,
+        statusText: s,
+        body: null
       });
-    }), Object.entries(n.headers).forEach(([f, p]) => {
-      o.setRequestHeader(f, p);
-    }), n.credentials === "include" && (o.withCredentials = !0), o.send(n.body || void 0), n.abort && n.abort.addEventListener("abort", i), n.timeout > 0 && (b = setTimeout(function() {
-      h = !0, i();
-    }, n.timeout));
+    }), Object.entries(r.headers).forEach(([s, b]) => {
+      e.setRequestHeader(s, b);
+    }), r.credentials === "include" && (e.withCredentials = !0), e.send(r.body || void 0), r.abort && r.abort.addEventListener("abort", p), r.timeout > 0 && (d = setTimeout(function() {
+      g = !0, p();
+    }, r.timeout));
   });
 };
-function S(t) {
-  const s = {};
-  if (!t)
-    return s;
-  const e = t.getAllResponseHeaders();
-  return e && e !== "null" && e.replace(/\r/g, "").split(`
-`).forEach((n) => {
-    const r = n.trim();
-    if (!r)
+function P(n) {
+  const a = {};
+  if (!n)
+    return a;
+  const t = n.getAllResponseHeaders();
+  return t && t !== "null" && t.replace(/\r/g, "").split(`
+`).forEach((r) => {
+    const o = r.trim();
+    if (!o)
       return;
-    const l = r.split(":"), a = l[0].trim();
-    a && (s[a] = (l[1] || "").trim());
-  }), s;
+    const u = o.split(":"), c = u[0].trim();
+    c && (a[c] = (u[1] || "").trim());
+  }), a;
 }
-async function P(t, s, e = {}) {
-  const n = window;
-  "callback" in e || (e.callback = "jsonxData" + Math.random().toString(16).slice(2));
-  const r = e.callback + "";
-  if (!t)
+async function O(n, a, t = {}) {
+  const r = window;
+  "callback" in t || (t.callback = "jsonxData" + Math.random().toString(16).slice(2));
+  const o = t.callback + "";
+  if (!n)
     return null;
-  const l = R(t, e, !0);
-  return new Promise((a) => {
-    n[r] = function(d) {
-      if (r in window && delete n[r], s(d))
+  const u = R(n, H(t), !0);
+  return new Promise((c) => {
+    r[o] = function(d) {
+      if (o in window && delete r[o], a(d))
         return d;
-      console.warn("response type check failed", t, d), a(null);
-    }, E(l).catch(function() {
-      a(null), delete n[r];
+      console.warn("response type check failed", n, d), c(null);
+    }, x(u).catch(function() {
+      c(null), delete r[o];
     });
   });
 }
-async function A(t, s, e = {}) {
-  const n = window;
-  return "var" in e || (e.var = "jsonxData" + Math.random().toString(16).slice(2)), t ? await E(R(t, e, !0)).then(() => {
-    const r = n[e.var + ""];
-    return s(r) ? r : (console.warn("response type check failed", t, r), null);
+async function A(n, a, t = {}) {
+  const r = window;
+  return "var" in t || (t.var = "jsonxData" + Math.random().toString(16).slice(2)), n ? await x(R(n, H(t), !0)).then(() => {
+    const o = r[t.var + ""];
+    return a(o) ? o : (console.warn("response type check failed", n, o), null);
   }).catch(() => null) : null;
 }
-const M = async function(t, s, e) {
-  return await k(t, s, e, {
-    baseURL: c.getConfig("baseURL"),
-    logHandler: c.getConfig("logHandler"),
-    errorHandler: c.getConfig("errorHandler"),
-    requestTransformer: c.getConfig("requestTransformer"),
-    messageHandler: c.getConfig("messageHandler"),
-    responseHandler: c.getConfig("responseHandler")
+const M = async function(n, a, t) {
+  return await B(n, a, t, {
+    baseURL: i.getConfig("baseURL"),
+    logHandler: i.getConfig("logHandler"),
+    errorHandler: i.getConfig("errorHandler"),
+    requestTransformer: i.getConfig("requestTransformer"),
+    messageHandler: i.getConfig("messageHandler"),
+    responseHandler: i.getConfig("responseHandler")
   });
 };
 // @__NO_SIDE_EFFECTS__
-function U(t) {
-  if (!C())
+function U(n) {
+  if (!L())
     throw new Error("Default Module Only Support In Browser");
-  return L() ? new H(v, t) : new H(j, t);
+  return k() ? new T(S, n) : new T(j, n);
 }
-const c = /* @__PURE__ */ U(), N = c.setConfig, X = c.request, B = c.head, F = c.get, G = c.post, I = c.del, $ = c.put, z = c.patch;
+const i = /* @__PURE__ */ U(), X = i.setConfig, G = i.request, F = i.head, I = i.get, $ = i.post, z = i.del, J = i.put, K = i.patch;
 export {
   U as NetRequest,
   w as RequestInternalError,
-  I as del,
-  F as get,
-  Q as getResponseRulesDescription,
-  B as head,
-  P as jsonp,
+  z as del,
+  I as get,
+  W as getResponseRulesDescription,
+  F as head,
+  O as jsonp,
   A as jsonx,
-  z as patch,
-  G as post,
-  $ as put,
-  X as request,
-  N as setGlobalConfig,
+  K as patch,
+  $ as post,
+  J as put,
+  G as request,
+  X as setGlobalConfig,
   M as upload
 };