@inpageedit/core 0.14.4 → 0.15.0

package/dist/browser-DR-yCqVg.js

@@ -0,0 +1,1160 @@
+function N(s) {
+  if (typeof globalThis.structuredClone == "function")
+    try {
+      return globalThis.structuredClone(s);
+    } catch {
+    }
+  return k(s, /* @__PURE__ */ new WeakMap());
+}
+function k(s, r) {
+  if (typeof s != "object" || s === null) return s;
+  const t = r.get(s);
+  if (t) return t;
+  if (s instanceof Date) return new Date(s.getTime());
+  if (s instanceof RegExp)
+    return new RegExp(s.source, s.flags);
+  if (s instanceof URL) return new URL(s.toString());
+  if (s instanceof URLSearchParams)
+    return new URLSearchParams(s.toString());
+  if (s instanceof ArrayBuffer) return s.slice(0);
+  if (ArrayBuffer.isView(s)) {
+    if (s instanceof DataView)
+      return new DataView(
+        s.buffer.slice(0),
+        s.byteOffset,
+        s.byteLength
+      );
+    const o = s, a = o.constructor;
+    return new a(o.buffer.slice(0), o.byteOffset, o.length);
+  }
+  if (s instanceof Map) {
+    const o = /* @__PURE__ */ new Map();
+    return r.set(s, o), s.forEach((a, c) => {
+      o.set(k(c, r), k(a, r));
+    }), o;
+  }
+  if (s instanceof Set) {
+    const o = /* @__PURE__ */ new Set();
+    return r.set(s, o), s.forEach((a) => o.add(k(a, r))), o;
+  }
+  if (Array.isArray(s)) {
+    const o = new Array(s.length);
+    r.set(s, o);
+    for (let a = 0; a < o.length; a++)
+      o[a] = k(s[a], r);
+    return o;
+  }
+  const e = Object.getPrototypeOf(s), n = Object.create(e);
+  r.set(s, n);
+  const i = Object.getOwnPropertyDescriptors(s);
+  for (const o of Reflect.ownKeys(i)) {
+    const a = i[o];
+    "value" in a && (a.value = k(a.value, r)), Object.defineProperty(n, o, a);
+  }
+  return n;
+}
+function L(s) {
+  if (typeof s != "object" || s === null)
+    return !1;
+  const r = Object.getPrototypeOf(s);
+  return r === Object.prototype || r === null;
+}
+const B = function(s) {
+  const r = this.constructor.prototype, t = Reflect.get(r, s, r);
+  function e(...n) {
+    return Reflect.apply(t, e, n);
+  }
+  Reflect.setPrototypeOf(e, r);
+  for (const n of Reflect.ownKeys(t)) {
+    const i = Reflect.getOwnPropertyDescriptor(t, n);
+    i && Reflect.defineProperty(e, n, i);
+  }
+  return e;
+};
+B.prototype = Object.create(Function.prototype);
+const Y = B;
+function S(s, ...r) {
+  const t = N(s || {});
+  for (const e of r)
+    if (e != null)
+      for (const n of Reflect.ownKeys(e)) {
+        const i = e[n];
+        if (typeof i > "u") continue;
+        if (i === null) {
+          delete t[n];
+          continue;
+        }
+        const o = t[n];
+        L(o) && L(i) ? t[n] = S(o, i) : t[n] = N(i);
+      }
+  return t;
+}
+var b = /* @__PURE__ */ ((s) => (s.BODY_USED = "BODY_USED", s.NO_BODY_READER = "NO_BODY_READER", s.TIMEOUT = "TIMEOUT", s.NETWORK_ERROR = "NETWORK_ERROR", s.BODY_NOT_ALLOWED = "BODY_NOT_ALLOWED", s.HOOK_CONTEXT_CHANGED = "HOOK_CONTEXT_CHANGED", s.ABORTED_BY_HOOK = "ABORTED_BY_HOOK", s.INVALID_HOOK_CALLBACK = "INVALID_HOOK_CALLBACK", s.UNEXPECTED_HOOK_RETURN = "UNEXPECTED_HOOK_RETURN", s.UNSUPPORTED_RESPONSE_TYPE = "UNSUPPORTED_RESPONSE_TYPE", s.BODY_TRANSFORM_ERROR = "BODY_TRANSFORM_ERROR", s))(b || {});
+class E extends Error {
+  constructor(r, t, e, n) {
+    super(t, n), this.code = r, this.context = e;
+  }
+  name = "FexiosError";
+  static is(r, t) {
+    return !(r instanceof E) || r instanceof _ ? !1 : t ? r.code === t : !0;
+  }
+}
+class _ extends E {
+  constructor(r, t, e) {
+    super(t.statusText, r, void 0, e), this.response = t;
+  }
+  name = "FexiosResponseError";
+  static is(r) {
+    return r instanceof _;
+  }
+}
+var D;
+((s) => {
+  s.makeHeaders = (r) => {
+    if (!r) return new Headers();
+    if (r instanceof Headers) return new Headers(r);
+    const t = new Headers();
+    if (r instanceof Map) {
+      for (const [e, n] of r.entries())
+        if (n != null)
+          if (Array.isArray(n))
+            for (const i of n)
+              i != null && t.append(e, String(i));
+          else
+            t.append(e, String(n));
+      return t;
+    }
+    if (L(r)) {
+      for (const [e, n] of Object.entries(r))
+        if (n != null)
+          if (Array.isArray(n))
+            for (const i of n)
+              i != null && t.append(e, String(i));
+          else
+            t.append(e, String(n));
+      return t;
+    }
+    throw new TypeError(
+      "only plain object, Map/ReadonlyMap, or Headers is supported"
+    );
+  }, s.toHeaderRecord = (r) => {
+    if (r instanceof Headers) {
+      const t = {};
+      return r.forEach((e, n) => {
+        t[n] = t[n] ? [...t[n], e] : [e];
+      }), t;
+    }
+    if (r instanceof Map) {
+      const t = {};
+      for (const [e, n] of r.entries())
+        if (n != null)
+          if (Array.isArray(n)) {
+            const i = n.filter((o) => o != null).map((o) => String(o));
+            i.length && (t[e] = (t[e] ?? []).concat(i));
+          } else {
+            const i = String(n);
+            t[e] = t[e] ? [...t[e], i] : [i];
+          }
+      return t;
+    }
+    throw new TypeError(
+      `unsupported type transformation, got: ${Object.prototype.toString.call(
+        r
+      )}`
+    );
+  }, s.mergeHeaders = (...r) => {
+    const t = new Headers(), e = (n) => {
+      for (const [i, o] of Object.entries(n))
+        if (o !== void 0) {
+          if (o === null) {
+            t.delete(i);
+            continue;
+          }
+          if (Array.isArray(o)) {
+            t.delete(i);
+            for (const a of o)
+              a != null && t.append(i, String(a));
+          } else
+            t.set(i, String(o));
+        }
+    };
+    for (const n of r) {
+      if (n == null) continue;
+      if (n instanceof Headers) {
+        n.forEach((o, a) => {
+          t.set(a, o);
+        });
+        continue;
+      }
+      if (L(n)) {
+        e(n);
+        continue;
+      }
+      const i = (0, s.toHeaderRecord)(n);
+      for (const [o, a] of Object.entries(i)) {
+        t.delete(o);
+        for (const c of a) t.append(o, c);
+      }
+    }
+    return t;
+  };
+})(D || (D = {}));
+var O;
+((s) => {
+  s.makeSearchParams = (e) => {
+    if (!e)
+      return new URLSearchParams();
+    if (e instanceof URLSearchParams)
+      return e;
+    if (typeof e != "object" || e?.constructor !== Object)
+      throw new TypeError("only plain object is supported");
+    const n = new URLSearchParams(), i = (c, f) => {
+      f != null && n.append(c, f);
+    }, o = (c, f) => {
+      f != null && n.set(c, f);
+    }, a = (c, f) => {
+      if (f != null) {
+        if (Array.isArray(f)) {
+          for (const u of f) i(c, u?.toString());
+          return;
+        }
+        if (typeof f == "object" && f.constructor === Object) {
+          for (const [u, l] of Object.entries(f)) {
+            if (l == null) continue;
+            const d = u.endsWith("[]"), h = d ? u.slice(0, -2) : u, y = `${c}[${h}]`;
+            if (d) {
+              const w = `${y}[]`;
+              if (Array.isArray(l))
+                for (const p of l) i(w, p?.toString());
+              else typeof l == "object" && l !== null && l.constructor === Object ? a(`${y}[]`, l) : i(w, l?.toString());
+            } else if (Array.isArray(l))
+              for (const w of l) i(y, w?.toString());
+            else typeof l == "object" && l !== null && l.constructor === Object ? a(y, l) : o(y, l?.toString());
+          }
+          return;
+        }
+        o(c, f?.toString());
+      }
+    };
+    for (const [c, f] of Object.entries(e))
+      a(c, f);
+    return n;
+  }, s.makeQueryString = (e) => (0, s.makeSearchParams)(e).toString(), s.makeURL = (e, n, i, o) => {
+    const a = typeof window < "u" && window.location?.origin || "http://localhost", c = typeof e == "string" ? new URL(e, o ?? a) : new URL(e), f = (0, s.toQueryRecord)(c.searchParams), u = (0, s.mergeQueries)(f, n || {}), l = (0, s.makeSearchParams)(u);
+    return c.search = l.toString(), typeof i < "u" && (c.hash = i), c;
+  }, s.toQueryRecord = (e) => {
+    typeof e == "string" && (e = (0, s.fromString)(e));
+    const n = {}, i = (a) => {
+      if (!a.includes("[")) return { path: [a], forceArray: !1 };
+      const c = [a.slice(0, a.indexOf("["))], f = /\[([^\]]*)\]/g;
+      let u, l = !1, d = !1;
+      for (; u = f.exec(a); )
+        u[1] === "" ? (l = !0, d = !0) : (c.push(u[1]), d = !1);
+      return l && d && (c[c.length - 1] = c[c.length - 1] + "[]"), { path: c, forceArray: l };
+    }, o = (a, c, f, u) => {
+      let l = a;
+      for (let d = 0; d < c.length; d++) {
+        const h = c[d];
+        d === c.length - 1 ? u ? l[h] === void 0 ? l[h] = [f] : Array.isArray(l[h]) ? l[h].push(f) : l[h] = [l[h], f] : l[h] === void 0 ? l[h] = f : Array.isArray(l[h]) ? l[h].push(f) : l[h] = [l[h], f] : ((l[h] === void 0 || typeof l[h] != "object" || Array.isArray(l[h])) && (l[h] = {}), l = l[h]);
+      }
+    };
+    for (const [a, c] of e.entries()) {
+      const { path: f, forceArray: u } = i(String(a));
+      o(n, f, c?.toString(), u);
+    }
+    return n;
+  }, s.fromString = (e) => {
+    const n = e.trim();
+    if (!n) return new URLSearchParams();
+    if (n.startsWith("?")) return new URLSearchParams(n.slice(1));
+    const i = n.indexOf("?");
+    if (i >= 0) {
+      const o = n.indexOf("#", i + 1), a = n.slice(i + 1, o >= 0 ? o : void 0);
+      return new URLSearchParams(a);
+    }
+    return new URLSearchParams(n);
+  }, s.mergeQueries = (...e) => {
+    const n = {};
+    for (const i of e)
+      i != null && t(n, r(i));
+    return n;
+  };
+  function r(e) {
+    if (!e) return {};
+    if (e instanceof URLSearchParams || e instanceof FormData || e instanceof Map)
+      return (0, s.toQueryRecord)(e);
+    if (typeof e == "string") return (0, s.toQueryRecord)((0, s.fromString)(e));
+    if (L(e)) return e;
+    throw new TypeError(
+      `unsupported type transformation, got: ${Object.prototype.toString.call(
+        e
+      )}`
+    );
+  }
+  function t(e, n) {
+    for (const [i, o] of Object.entries(n)) {
+      if (o === void 0) continue;
+      if (o === null) {
+        delete e[i];
+        continue;
+      }
+      const a = e[i];
+      L(a) && L(o) ? t(a, o) : e[i] = N(o);
+    }
+  }
+})(O || (O = {}));
+class I {
+  constructor(r, t, e) {
+    this.rawResponse = r, this.data = t, this.responseType = e, ["ok", "status", "statusText", "headers", "url", "redirected"].forEach(
+      (n) => {
+        Reflect.defineProperty(this, n, {
+          get: () => r[n]
+        });
+      }
+    );
+  }
+  ok;
+  status;
+  statusText;
+  headers;
+  url;
+  redirected;
+}
+const P = (s) => {
+  const r = s.reduce((n, i) => n + i.length, 0), t = new Uint8Array(r);
+  let e = 0;
+  for (const n of s)
+    t.set(n, e), e += n.length;
+  return t;
+};
+async function K(s, r, t) {
+  const e = s.getReader();
+  if (!e)
+    throw new E(
+      b.NO_BODY_READER,
+      "Failed to get ReadableStream from response body"
+    );
+  const n = [];
+  let i = 0;
+  try {
+    for (; ; ) {
+      const { done: a, value: c } = await e.read();
+      if (a) break;
+      n.push(c), i += c.length, t && r > 0 && t(i / r, P(n));
+    }
+  } finally {
+    e.releaseLock?.();
+  }
+  const o = P(n);
+  return t?.(1, o), o;
+}
+const $ = (s) => {
+  if (s) {
+    if (s.includes("application/json") || s.endsWith("+json"))
+      return "json";
+    if (s.startsWith("text/")) return "text";
+    if (s.includes("multipart/form-data") || s.includes("application/x-www-form-urlencoded"))
+      return "form";
+    if (/^image\//.test(s) || /^video\//.test(s) || /^audio\//.test(s) || s.includes("application/pdf"))
+      return "blob";
+    if (s.includes("application/octet-stream") || s.includes("application/zip") || s.includes("application/x-tar") || s.includes("application/x-7z-compressed") || s.includes("application/x-gzip"))
+      return "arrayBuffer";
+  }
+};
+async function x(s, r, t, e, n) {
+  const i = s.headers.get("content-type")?.toLowerCase() ?? "", o = s.headers.get("content-length"), a = o ? Number(o) : 0, c = s.headers.get("upgrade")?.toLowerCase(), f = s.headers.get("connection")?.toLowerCase();
+  let u = r ?? $(i) ?? "text";
+  if (r || (c === "websocket" && f === "upgrade" ? u = "ws" : i.includes("text/event-stream") && (u = "stream")), u === "stream") {
+    const p = s.url || s.url || "", g = await Q(
+      p,
+      s,
+      n
+    ), T = e?.(g);
+    if (typeof T == "boolean" ? T : !g.ok)
+      throw new _(g.statusText, g);
+    return g;
+  }
+  if (u === "ws") {
+    const p = s.url || s.url || "", g = await H(
+      p,
+      s,
+      n
+    ), T = e?.(g);
+    if (typeof T == "boolean" ? T : !g.ok)
+      throw new _(g.statusText, g);
+    return g;
+  }
+  const l = /\bcharset=([^;]+)/i.exec(i)?.[1]?.trim() || "utf-8", d = new TextDecoder(l);
+  let h;
+  try {
+    if (u === "form")
+      h = await s.formData();
+    else {
+      const p = await K(s.body, a, t);
+      if (u === "arrayBuffer")
+        h = p.buffer.slice(
+          p.byteOffset,
+          p.byteOffset + p.byteLength
+        );
+      else if (u === "blob")
+        h = new Blob([p], {
+          type: i || "application/octet-stream"
+        });
+      else if (u === "text") {
+        const g = d.decode(p);
+        if (r)
+          h = g;
+        else {
+          const T = g.trim();
+          if (T.startsWith("{") && T.endsWith("}") || T.startsWith("[") && T.endsWith("]"))
+            try {
+              h = JSON.parse(T), u = "json";
+            } catch {
+              h = g;
+            }
+          else
+            h = g;
+        }
+      } else if (u === "json") {
+        const g = d.decode(p);
+        h = g.length ? JSON.parse(g) : null;
+      } else
+        h = p;
+    }
+  } catch (p) {
+    if (!(p instanceof Error)) throw p;
+    try {
+      h = await s.text(), u = "text";
+    } catch {
+      throw new E(
+        b.BODY_TRANSFORM_ERROR,
+        `Failed to transform response body to ${u}`,
+        void 0,
+        { cause: p }
+      );
+    }
+  }
+  const y = new I(
+    s,
+    h,
+    u
+  ), w = e?.(y);
+  if (typeof w == "boolean" ? w : !y.ok)
+    throw new _(y.statusText, y);
+  return y;
+}
+async function H(s, r, t) {
+  const e = new WebSocket(s.toString()), n = t ?? 6e4;
+  return await new Promise((i, o) => {
+    const a = n > 0 ? setTimeout(() => {
+      e.close(), o(
+        new E(
+          b.TIMEOUT,
+          `WebSocket connection timed out after ${n}ms`
+        )
+      );
+    }, n) : void 0;
+    let c = !1;
+    const f = () => {
+      clearTimeout(a), e.removeEventListener("open", u), e.removeEventListener("error", l), e.removeEventListener("close", d);
+    }, u = () => {
+      c || (c = !0, f(), i());
+    }, l = (h) => {
+      c || (c = !0, f(), o(
+        new E(
+          b.NETWORK_ERROR,
+          "WebSocket connection failed",
+          void 0,
+          { cause: h }
+        )
+      ));
+    }, d = (h) => {
+      c || (c = !0, f(), o(
+        new E(
+          b.NETWORK_ERROR,
+          `WebSocket connection closed unexpectedly (code: ${h.code}, reason: ${h.reason})`,
+          void 0,
+          { cause: h }
+        )
+      ));
+    };
+    e.addEventListener("open", u), e.addEventListener("error", l), e.addEventListener("close", d);
+  }), new I(r || new Response(null), e, "ws");
+}
+async function Q(s, r, t) {
+  const e = new EventSource(s.toString()), n = t ?? 6e4;
+  return await new Promise((i, o) => {
+    const a = n > 0 ? setTimeout(() => {
+      e.close(), o(
+        new E(
+          b.TIMEOUT,
+          `EventSource connection timed out after ${n}ms`
+        )
+      );
+    }, n) : void 0;
+    let c = !1;
+    const f = () => {
+      clearTimeout(a), e.removeEventListener("open", u), e.removeEventListener("error", l);
+    }, u = () => {
+      c || (c = !0, f(), i());
+    }, l = (d) => {
+      c || (c = !0, f(), o(
+        new E(
+          b.NETWORK_ERROR,
+          "EventSource connection failed",
+          void 0,
+          { cause: d }
+        )
+      ));
+    };
+    e.addEventListener("open", u), e.addEventListener("error", l);
+  }), new I(
+    r || new Response(null),
+    e,
+    "stream"
+  );
+}
+class m extends Y {
+  static version = "5.0.1";
+  static FINAL_SYMBOL = Symbol("FEXIOS_FINAL_CONTEXT");
+  baseConfigs;
+  // for axios compatibility
+  get defaults() {
+    return this.baseConfigs;
+  }
+  set defaults(r) {
+    this.baseConfigs = r;
+  }
+  static DEFAULT_CONFIGS = {
+    baseURL: "",
+    timeout: 0,
+    credentials: void 0,
+    headers: {},
+    query: {},
+    responseType: void 0,
+    shouldThrow(r) {
+      return !r.ok;
+    },
+    fetch: globalThis.fetch
+  };
+  hooks = [];
+  static ALL_METHODS = [
+    "get",
+    "post",
+    "put",
+    "patch",
+    "delete",
+    "head",
+    "options",
+    "trace"
+  ];
+  static METHODS_WITHOUT_BODY = [
+    "get",
+    "head",
+    "options",
+    "trace"
+  ];
+  constructor(r = {}) {
+    super("request"), this.baseConfigs = S(m.DEFAULT_CONFIGS, r), m.ALL_METHODS.forEach(
+      (t) => this.createMethodShortcut(t.toLowerCase())
+    );
+  }
+  async request(r, t) {
+    let e = t || {};
+    if (typeof r == "string" || r instanceof URL ? e.url = r.toString() : typeof r == "object" && (e = r), e = await this.emit("beforeInit", e), e[m.FINAL_SYMBOL]) return e;
+    if (e = this.applyDefaults(e), m.METHODS_WITHOUT_BODY.includes(
+      e.method?.toLocaleLowerCase()
+    ) && e.body)
+      throw new E(
+        b.BODY_NOT_ALLOWED,
+        `Request method "${e.method}" does not allow body`
+      );
+    if (e = await this.emit("beforeRequest", e), e[m.FINAL_SYMBOL]) return e;
+    let n;
+    const i = {};
+    if (typeof e.body < "u" && e.body !== null && (e.body instanceof Blob || e.body instanceof FormData || e.body instanceof URLSearchParams ? n = e.body : typeof e.body == "object" && e.body !== null ? (n = JSON.stringify(e.body), e.headers = this.mergeHeaders(e.headers, {
+      "Content-Type": "application/json"
+    })) : n = e.body), !D.makeHeaders(e.headers || {}).get("content-type") && n && (n instanceof FormData || n instanceof URLSearchParams ? i["content-type"] = null : typeof n == "string" && typeof e.body == "object" ? i["content-type"] = "application/json" : n instanceof Blob && (i["content-type"] = n.type || "application/octet-stream")), e.body = n, e = await this.emit("afterBodyTransformed", e), e[m.FINAL_SYMBOL]) return e;
+    const o = e.abortController ?? (globalThis.AbortController ? new AbortController() : void 0), a = globalThis.location?.href || "http://localhost", c = new URL(
+      e.baseURL || this.baseConfigs.baseURL || a,
+      a
+    ), f = new URL(e.url, c), u = O.makeURL(
+      f,
+      e.query,
+      f.hash
+      // 保留 hash
+    ).toString(), l = new Request(u, {
+      method: e.method || "GET",
+      credentials: e.credentials,
+      cache: e.cache,
+      mode: e.mode,
+      headers: D.mergeHeaders(
+        this.baseConfigs.headers,
+        e.headers || {},
+        i
+      ),
+      body: e.body,
+      signal: o?.signal
+    });
+    if (e.rawRequest = l, e = await this.emit("beforeActualFetch", e), e[m.FINAL_SYMBOL]) return e;
+    const d = e.timeout ?? this.baseConfigs.timeout ?? 60 * 1e3, h = e.shouldThrow ?? this.baseConfigs.shouldThrow;
+    if (e.url.startsWith("ws") || e.responseType === "ws") {
+      const w = await H(
+        e.url,
+        void 0,
+        d
+      ), p = {
+        ...e,
+        response: w,
+        rawResponse: void 0,
+        data: w.data,
+        headers: w.headers
+      };
+      return this.emit("afterResponse", p);
+    }
+    let y;
+    try {
+      o && (y = d > 0 ? setTimeout(() => {
+        o.abort();
+      }, d) : void 0);
+      const w = await (e.fetch || this.baseConfigs.fetch || globalThis.fetch)(e.rawRequest).catch((p) => {
+        throw y && clearTimeout(y), o?.signal.aborted ? new E(
+          b.TIMEOUT,
+          `Request timed out after ${d}ms`,
+          e
+        ) : new E(b.NETWORK_ERROR, p.message, e);
+      });
+      return y && clearTimeout(y), e.rawResponse = w, e.response = await x(
+        w,
+        e.responseType,
+        (p, g) => {
+          t?.onProgress?.(p, g);
+        },
+        h,
+        d
+      ), Object.defineProperties(e, {
+        url: { get: () => w?.url || u },
+        data: { get: () => e.response.data },
+        headers: { get: () => w.headers },
+        responseType: { get: () => e.response.responseType }
+      }), this.emit("afterResponse", e);
+    } catch (w) {
+      throw y && clearTimeout(y), w;
+    }
+  }
+  mergeQueries = O.mergeQueries;
+  mergeHeaders = D.mergeHeaders;
+  applyDefaults(r) {
+    const t = r;
+    "customEnv" in this.baseConfigs && (t.customEnv = S(
+      {},
+      // ensure we don't mutate baseConfigs
+      this.baseConfigs.customEnv,
+      t.customEnv
+    ));
+    const e = globalThis.location?.href || "http://localhost", n = t.baseURL || this.baseConfigs.baseURL || e, i = new URL(n, e), o = new URL(t.url.toString(), i), a = O.toQueryRecord(i.searchParams), c = O.toQueryRecord(o.searchParams), f = O.mergeQueries(
+      a,
+      c
+    );
+    o.search = O.makeSearchParams(f).toString(), t.url = o.toString();
+    const u = O.mergeQueries(
+      this.baseConfigs.query,
+      t.query
+    );
+    return t.query && this.restoreNulls(u, t.query), t.query = u, t;
+  }
+  restoreNulls(r, t) {
+    if (!(!t || typeof t != "object"))
+      for (const [e, n] of Object.entries(t))
+        n === null ? r[e] = null : L(n) && ((!r[e] || typeof r[e] != "object") && (r[e] = {}), this.restoreNulls(r[e], n));
+  }
+  async emit(r, t, e = {
+    shouldHandleShortCircuitResponse: !0
+  }) {
+    const n = this.hooks.filter((o) => o.event === r);
+    if (n.length === 0) return t;
+    const i = async (o, a) => {
+      const c = { ...o, rawResponse: a }, f = await x(
+        a,
+        o.responseType,
+        (u, l) => o.onProgress?.(u, l),
+        o.shouldThrow ?? this.baseConfigs.shouldThrow,
+        o.timeout ?? this.baseConfigs.timeout ?? 60 * 1e3
+      );
+      if (c.response = f, c.data = f.data, c.headers = f.headers, r !== "afterResponse") {
+        const u = await this.emit("afterResponse", c);
+        return u[m.FINAL_SYMBOL] = !0, u;
+      } else
+        return c[m.FINAL_SYMBOL] = !0, c;
+    };
+    for (let o = 0; o < n.length; o++) {
+      const a = n[o], c = `${String(r)}#${a.action.name || `anonymous#${o}`}`, f = Symbol("FEXIOS_HOOK_CTX_MARK");
+      try {
+        t[f] = f;
+      } catch {
+      }
+      const u = await a.action.call(this, t);
+      try {
+        delete t[f];
+      } catch {
+      }
+      if (u === !1)
+        throw new E(
+          b.ABORTED_BY_HOOK,
+          `Request aborted by hook "${c}"`,
+          t
+        );
+      if (u instanceof Response) {
+        if (e.shouldHandleShortCircuitResponse !== !1)
+          return i(t, u);
+        t.rawResponse = u;
+      } else u && typeof u == "object" && u[f] === f && (t = u);
+    }
+    return t;
+  }
+  on(r, t, e = !1) {
+    if (typeof t != "function")
+      throw new E(
+        b.INVALID_HOOK_CALLBACK,
+        `Hook should be a function, but got "${typeof t}"`
+      );
+    return this.hooks[e ? "unshift" : "push"]({
+      event: r,
+      action: t
+    }), this;
+  }
+  off(r, t) {
+    return r === "*" || !r ? this.hooks = this.hooks.filter((e) => e.action !== t) : this.hooks = this.hooks.filter(
+      (e) => e.event !== r || e.action !== t
+    ), this;
+  }
+  createInterceptor(r) {
+    return {
+      handlers: () => this.hooks.filter((t) => t.event === r).map((t) => t.action),
+      use: (t, e = !1) => this.on(r, t, e),
+      clear: () => {
+        this.hooks = this.hooks.filter((t) => t.event !== r);
+      }
+    };
+  }
+  interceptors = {
+    request: this.createInterceptor("beforeRequest"),
+    response: this.createInterceptor("afterResponse")
+  };
+  createMethodShortcut(r) {
+    return Reflect.defineProperty(this, r, {
+      get: () => (t, e, n) => (m.METHODS_WITHOUT_BODY.includes(
+        r.toLocaleLowerCase()
+      ) ? n = e : (n = n || {}, n.body = e), this.request(t, {
+        ...n,
+        method: r
+      }))
+    }), this;
+  }
+  extends(r) {
+    const t = new m(S(this.baseConfigs, r));
+    return t.hooks = [...this.hooks], t._plugins = new Map(this._plugins), t._plugins.forEach(async (e) => {
+      await t.plugin(e);
+    }), t;
+  }
+  create = m.create;
+  static create(r) {
+    return new m(r);
+  }
+  _plugins = /* @__PURE__ */ new Map();
+  async plugin(r) {
+    if (typeof r?.name == "string" && typeof r?.install == "function") {
+      if (this._plugins.has(r.name))
+        return this;
+      const t = await r.install(this);
+      if (this._plugins.set(r.name, r), t instanceof m)
+        return t;
+    }
+    return this;
+  }
+  // 版本弃子们.jpg
+  /** @deprecated Use `import { checkIsPlainObject } from 'fexios/utils'` instead */
+  checkIsPlainObject = L;
+  /** @deprecated Use `mergeQueries` instead */
+  mergeQuery = this.mergeQueries;
+}
+const X = m.create, j = X();
+typeof globalThis < "u" ? globalThis.fexios = j : typeof window < "u" && (window.fexios = j);
+var C;
+((s) => {
+  function r(e) {
+    return Array.isArray(e) ? e.join("|") : typeof e == "boolean" || e === null ? e ? "1" : void 0 : typeof e == "number" ? "" + e : e;
+  }
+  s.normalizeParamValue = r;
+  function t(e) {
+    const n = (o) => o && (o instanceof URLSearchParams || o instanceof FormData);
+    if (e == null)
+      return;
+    const i = new FormData();
+    if (n(e))
+      return e.forEach((o, a) => {
+        const c = r(o);
+        c != null && i.append(a, c);
+      }), i;
+    if (L(e))
+      return Object.entries(e).forEach(([o, a]) => {
+        const c = r(a);
+        c != null && i.append(o, c);
+      }), i;
+  }
+  s.normalizeBody = t;
+})(C || (C = {}));
+var U = /* @__PURE__ */ ((s) => (s.HTTP_ERROR = "HTTP_ERROR", s.LOGIN_FAILED = "LOGIN_FAILED", s.LOGIN_RETRY_LIMIT_EXCEEDED = "LOGIN_RETRY_LIMIT_EXCEEDED", s.TOKEN_RETRY_LIMIT_EXCEEDED = "TOKEN_RETRY_LIMIT_EXCEEDED", s))(U || {});
+class R extends Error {
+  constructor(r, t = "", e) {
+    super(), this.code = r, this.message = t, this.cause = e, this.name = "WikiSaikouError";
+  }
+  static is(r, t) {
+    return r instanceof this && (t === void 0 || r.code === t);
+  }
+}
+class A extends Error {
+  constructor(r, t) {
+    super(), this.errors = r, this.cause = t, this.name = "MediaWikiApiError", this.errors = A.normalizeErrors(r), this.message = r.map((e) => e.text).filter(Boolean).join(`
+`), this.code = this.isBadTokenError() ? "badtoken" : this.errors[0]?.code || "Unknown Error";
+  }
+  get firstError() {
+    return this.errors[0];
+  }
+  isBadTokenError() {
+    return this.errors.some((r) => r.code === "badtoken") || ["NeedToken", "WrongToken"].includes(this.cause?.data?.login?.result);
+  }
+  toString() {
+    return `[${this.name} ${this.code}]`;
+  }
+  static is(r) {
+    return r instanceof this;
+  }
+  static normalizeErrors(r) {
+    return Array.isArray(r) === !1 ? [] : r.filter((t) => typeof t == "object" && !!t?.code).map((t) => t.text ? t : t.info ? { ...t, text: t.info } : t["*"] ? { ...t, text: t["*"] } : { ...t, text: "" });
+  }
+}
+((s) => {
+  function r(i) {
+    if (i == null) return;
+    if (i?.response?.data !== void 0) return i.response.data;
+    if (i?.data !== void 0) return i.data;
+    const o = i instanceof Error ? i.cause : void 0;
+    return o?.response?.data !== void 0 ? o.response.data : o?.data !== void 0 ? o.data : i || void 0;
+  }
+  function t(i) {
+    return e(i).length > 0;
+  }
+  s.includesMediaWikiApiError = t, s.normalizeMwApiErrors = A.normalizeErrors;
+  function e(i) {
+    let o = r(i);
+    if (typeof o != "object" || o === null)
+      return [];
+    const a = o?.error, c = o?.errors, f = [];
+    return a && f.push(a), Array.isArray(c) && f.push(...c), (0, s.normalizeMwApiErrors)(f);
+  }
+  s.extractMediaWikiApiErrors = e;
+  function n(i) {
+    if (A.is(i))
+      return i.isBadTokenError();
+    {
+      const o = e(i);
+      return new A(o).isBadTokenError();
+    }
+  }
+  s.isBadTokenError = n;
+})(R || (R = {}));
+const M = Symbol.for("__FEXIOS_SAIKOU__");
+function q(s) {
+  const r = s instanceof m ? s : new m({
+    baseURL: s instanceof URL ? s.toString() : String(s),
+    responseType: "json"
+  });
+  return r[M] || (Reflect.defineProperty(r, M, {
+    get: () => !0,
+    enumerable: !1,
+    configurable: !1
+  }), r.on("beforeInit", (t) => {
+    if (t.method?.toLowerCase() !== "post")
+      return t;
+    if (t.body === void 0 || t.body === null)
+      return t.body = void 0, t;
+    const e = t.body = C.normalizeBody(t.body), n = new URLSearchParams(t.query);
+    return e.has("format") && n.delete("format"), e.has("formatversion") && n.delete("formatversion"), e.has("action") && n.delete("action"), e.has("origin") && (n.set("origin", "" + e.get("origin")), e.delete("origin")), t.query = Object.fromEntries(n.entries()), t;
+  }), r.on("beforeInit", (t) => (t.query = O.mergeQueries(
+    {},
+    C.normalizeBody(t.query)
+  ), t)), r.on("beforeRequest", (t) => {
+    const e = new URL(t.url), n = O.mergeQueries(e.searchParams, t.query);
+    if (globalThis.location && (!n.origin && location.origin !== e.origin ? (n.origin = location.origin, r.baseConfigs.credentials = "include", r.baseConfigs.mode = "cors") : location.origin === e.origin && (delete n.origin, r.baseConfigs.credentials = void 0, r.baseConfigs.mode = void 0)), n.origin) {
+      const i = encodeURIComponent(n.origin).replace(/\./g, "%2E");
+      delete n.origin, t.query = n, t.url = `${e.origin}${e.pathname}?origin=${i}`;
+    } else
+      t.query = n;
+    return t;
+  }), r._tokens = /* @__PURE__ */ new Map(), r.on("afterResponse", (t) => {
+    const { data: e } = t, n = t.customEnv?.mwTokenName;
+    n && R.isBadTokenError(e) && r._tokens.delete(n);
+    const i = e?.query?.tokens;
+    i && typeof i == "object" && Object.entries(i).forEach(([a, c]) => {
+      typeof c == "string" && r._tokens.set(a.replace(/token$/i, "").toLowerCase(), c);
+    });
+    const o = e?.login?.token;
+    return typeof o == "string" && r._tokens.set("login", o), t;
+  })), r;
+}
+const W = (s, r, t) => {
+  let e = { ...F.DEFAULT_CONFIGS };
+  if (typeof s == "string" ? e = S(e, {
+    baseURL: s,
+    fexiosConfigs: r || {},
+    defaultParams: t || {},
+    throwOnApiError: !1
+    // Set a default value for throwOnApiError
+  }) : typeof s == "object" && s !== null && (e = S(e, s)), !e.baseURL && typeof window == "object" && window.mediaWiki) {
+    const { wgServer: n, wgScriptPath: i } = window.mediaWiki?.config?.get(["wgServer", "wgScriptPath"]) || {};
+    typeof n == "string" && typeof i == "string" && (e.baseURL = `${n}${i}/api.php`);
+  }
+  if (typeof e.baseURL != "string")
+    throw new Error("baseURL is required");
+  return e;
+}, z = () => {
+}, G = async (s, r) => {
+  let t = 0;
+  const { retry: e = 3, onRetry: n = z, shouldRetry: i = () => !0 } = r;
+  let o;
+  do
+    try {
+      return await s();
+    } catch (a) {
+      if (o = a, i(a, t))
+        n(a, t), t++;
+      else
+        throw a;
+    }
+  while (t < e);
+  throw o || new Error("Retry failed");
+};
+const v = class {
+  constructor(r, t, e) {
+    this.version = "7.3.0", this.token = this.getToken;
+    const n = this.config = W(
+      r,
+      t,
+      e
+    );
+    this.request = q(n.baseURL);
+  }
+  setBaseURL(r) {
+    return this.config.baseURL = r, this.request.baseConfigs.baseURL = r, this;
+  }
+  /** Base methods encapsulation */
+  async get(r, t) {
+    const e = S(
+      {},
+      this.config.fexiosConfigs,
+      {
+        query: O.mergeQueries(
+          this.config.defaultParams,
+          r
+        )
+      },
+      t
+    );
+    return this.runRequestWithApiErrorMapping(
+      () => this.request.get("", e)
+    );
+  }
+  async post(r, t) {
+    return this.runRequestWithApiErrorMapping(
+      () => this.request.post(
+        "",
+        r,
+        S(
+          {},
+          this.config.fexiosConfigs,
+          {
+            query: this.config.defaultParams
+          },
+          t
+        )
+      )
+    );
+  }
+  /**
+   * Wrap a request to map non-2xx responses containing MediaWiki API error bodies
+   * into MediaWikiApiError when throwOnApiError=true, and then pass 2xx responses
+   * through handleApiResponse for unified processing.
+   */
+  async runRequestWithApiErrorMapping(r) {
+    try {
+      const t = await r();
+      return this.handleApiResponse(t);
+    } catch (t) {
+      throw this.config.throwOnApiError && R.includesMediaWikiApiError(t) ? new A(
+        R.extractMediaWikiApiErrors(t),
+        t
+      ) : t;
+    }
+  }
+  throwIfApiError(r) {
+    const t = R.extractMediaWikiApiErrors(r);
+    if (t.length > 0)
+      throw new A(t, r);
+  }
+  handleApiResponse(r) {
+    return this.config.throwOnApiError && this.throwIfApiError(r.data), r;
+  }
+  /** Token Handler */
+  get tokens() {
+    return this.request._tokens;
+  }
+  async fetchTokens(r = ["csrf"]) {
+    return this.config.fexiosConfigs.credentials = "include", await this.get({
+      action: "query",
+      meta: "tokens",
+      type: r
+    }), this.tokens;
+  }
+  async getToken(r = "csrf", t = !1) {
+    return (!this.tokens.get(r) || t) && (this.tokens.delete(r), await this.fetchTokens([r])), this.tokens.get(r);
+  }
+  badToken(r) {
+    return this.tokens.delete(r), this.tokens;
+  }
+  async postWithToken(r, t, e) {
+    const {
+      tokenName: n = "token",
+      retry: i = 3,
+      noCache: o = !1,
+      fexiosOptions: a
+    } = e || {};
+    if (i < 1)
+      throw new R(
+        U.TOKEN_RETRY_LIMIT_EXCEEDED,
+        "The limit of the number of times to automatically re-acquire the token has been exceeded"
+      );
+    let c = 0;
+    return G(
+      async () => {
+        const f = await this.getToken(
+          r,
+          o || c > 0
+        );
+        try {
+          const u = await this.post(
+            {
+              [n]: f,
+              ...t
+            },
+            S(a || {}, {
+              customEnv: {
+                mwTokenName: r
+              }
+            })
+          );
+          if (R.isBadTokenError(u.data))
+            throw u;
+          return u;
+        } catch (u) {
+          throw R.isBadTokenError(u) || u?.ok === !1 || A.is(u) ? u : new R(
+            U.HTTP_ERROR,
+            "Network/transport or SDK-internal error (not a MediaWiki API error)",
+            u
+          );
+        }
+      },
+      {
+        retry: i,
+        onRetry: (f, u) => {
+          c = u + 1;
+        },
+        shouldRetry: (f) => R.isBadTokenError(f) || f?.ok === !1
+      }
+    ).catch((f) => {
+      throw R.isBadTokenError(f) || f?.ok === !1 ? new R(
+        U.TOKEN_RETRY_LIMIT_EXCEEDED,
+        "Retry attempts for acquiring/using token exhausted",
+        f
+      ) : f;
+    });
+  }
+  postWithEditToken(r) {
+    return this.postWithToken("csrf", r);
+  }
+  // for backward compatibility
+  /** @deprecated Use `this.config.baseURL` instead */
+  get baseURL() {
+    return this.config.baseURL;
+  }
+  /** @deprecated Use `this.config.defaultParams` instead */
+  get defaultParams() {
+    return this.config.defaultParams;
+  }
+  /** @deprecated Use `this.config.fexiosConfigs` instead */
+  get defaultOptions() {
+    return this.config.fexiosConfigs;
+  }
+};
+v.INIT_DEFAULT_PARAMS = {
+  action: "query",
+  errorformat: "plaintext",
+  format: "json",
+  formatversion: 2
+}, v.DEFAULT_CONFIGS = {
+  baseURL: void 0,
+  fexiosConfigs: {
+    responseType: "json"
+  },
+  defaultParams: v.INIT_DEFAULT_PARAMS,
+  throwOnApiError: !1
+}, v.createRequestHandler = q;
+let F = v;
+class V extends F {
+  async clientLogin(r, t, e) {
+    e ||= {}, !e.logincontinue && !e.loginreturnurl && (e.loginreturnurl = location?.origin);
+    const n = await this.postWithToken(
+      "login",
+      {
+        action: "clientlogin",
+        username: r,
+        password: t,
+        ...e
+      },
+      {
+        tokenName: "logintoken"
+      }
+    );
+    if (n?.data?.clientlogin?.status === "PASS")
+      return n.data.clientlogin;
+    throw new R(
+      U.LOGIN_FAILED,
+      n.data.clientlogin.message,
+      n
+    );
+  }
+}
+class Z extends V {
+  constructor(r, t, e) {
+    const n = W(
+      r,
+      {
+        credentials: "include",
+        mode: "cors",
+        ...t
+      },
+      {
+        origin: location.origin,
+        ...e
+      }
+    );
+    super(n);
+  }
+}
+export {
+  S as A,
+  V as J,
+  A as S,
+  Z as e
+};
+//# sourceMappingURL=browser-DR-yCqVg.js.map