@bynder/compact-view 5.2.0 → 5.2.2

package/index14.js

@@ -0,0 +1,558 @@
+import { g as Se } from "./sdk-DhxX43BH.js";
+import "react/jsx-runtime";
+import H, { createContext as me } from "react";
+var re = { exports: {} }, k = {}, ne = { exports: {} }, V = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var oe;
+function Pe() {
+  if (oe) return V;
+  oe = 1;
+  var e = H;
+  function t(s, c) {
+    return s === c && (s !== 0 || 1 / s === 1 / c) || s !== s && c !== c;
+  }
+  var r = typeof Object.is == "function" ? Object.is : t, n = e.useState, o = e.useEffect, u = e.useLayoutEffect, i = e.useDebugValue;
+  function a(s, c) {
+    var l = c(), b = n({ inst: { value: l, getSnapshot: c } }), f = b[0].inst, P = b[1];
+    return u(
+      function() {
+        f.value = l, f.getSnapshot = c, d(f) && P({ inst: f });
+      },
+      [s, l, c]
+    ), o(
+      function() {
+        return d(f) && P({ inst: f }), s(function() {
+          d(f) && P({ inst: f });
+        });
+      },
+      [s]
+    ), i(l), l;
+  }
+  function d(s) {
+    var c = s.getSnapshot;
+    s = s.value;
+    try {
+      var l = c();
+      return !r(s, l);
+    } catch {
+      return !0;
+    }
+  }
+  function y(s, c) {
+    return c();
+  }
+  var v = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? y : a;
+  return V.useSyncExternalStore = e.useSyncExternalStore !== void 0 ? e.useSyncExternalStore : v, V;
+}
+var ue;
+function ge() {
+  return ue || (ue = 1, ne.exports = Pe()), ne.exports;
+}
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var ie;
+function we() {
+  if (ie) return k;
+  ie = 1;
+  var e = H, t = ge();
+  function r(y, v) {
+    return y === v && (y !== 0 || 1 / y === 1 / v) || y !== y && v !== v;
+  }
+  var n = typeof Object.is == "function" ? Object.is : r, o = t.useSyncExternalStore, u = e.useRef, i = e.useEffect, a = e.useMemo, d = e.useDebugValue;
+  return k.useSyncExternalStoreWithSelector = function(y, v, s, c, l) {
+    var b = u(null);
+    if (b.current === null) {
+      var f = { hasValue: !1, value: null };
+      b.current = f;
+    } else f = b.current;
+    b = a(
+      function() {
+        function Z(S) {
+          if (!$) {
+            if ($ = !0, F = S, S = c(S), l !== void 0 && f.hasValue) {
+              var E = f.value;
+              if (l(E, S))
+                return x = E;
+            }
+            return x = S;
+          }
+          if (E = x, n(F, S)) return E;
+          var te = c(S);
+          return l !== void 0 && l(E, te) ? (F = S, E) : (F = S, x = te);
+        }
+        var $ = !1, F, x, ee = s === void 0 ? null : s;
+        return [
+          function() {
+            return Z(v());
+          },
+          ee === null ? void 0 : function() {
+            return Z(ee());
+          }
+        ];
+      },
+      [v, s, c, l]
+    );
+    var P = o(y, b[0], b[1]);
+    return i(
+      function() {
+        f.hasValue = !0, f.value = P;
+      },
+      [P]
+    ), d(P), P;
+  }, k;
+}
+var ae;
+function Oe() {
+  return ae || (ae = 1, re.exports = we()), re.exports;
+}
+var Ee = Oe();
+const ze = /* @__PURE__ */ Se(Ee), { useDebugValue: We } = H, { useSyncExternalStoreWithSelector: Ke } = ze;
+var _e = Symbol.for("immer-nothing"), se = Symbol.for("immer-draftable"), p = Symbol.for("immer-state");
+function h(e, ...t) {
+  throw new Error(
+    `[Immer] minified error nr: ${e}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var z = Object.getPrototypeOf;
+function D(e) {
+  return !!e && !!e[p];
+}
+function w(e) {
+  var t;
+  return e ? de(e) || Array.isArray(e) || !!e[se] || !!((t = e.constructor) != null && t[se]) || M(e) || R(e) : !1;
+}
+var De = Object.prototype.constructor.toString();
+function de(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const t = z(e);
+  if (t === null)
+    return !0;
+  const r = Object.hasOwnProperty.call(t, "constructor") && t.constructor;
+  return r === Object ? !0 : typeof r == "function" && Function.toString.call(r) === De;
+}
+function C(e, t) {
+  L(e) === 0 ? Reflect.ownKeys(e).forEach((r) => {
+    t(r, e[r], e);
+  }) : e.forEach((r, n) => t(n, r, e));
+}
+function L(e) {
+  const t = e[p];
+  return t ? t.type_ : Array.isArray(e) ? 1 : M(e) ? 2 : R(e) ? 3 : 0;
+}
+function G(e, t) {
+  return L(e) === 2 ? e.has(t) : Object.prototype.hasOwnProperty.call(e, t);
+}
+function ye(e, t, r) {
+  const n = L(e);
+  n === 2 ? e.set(t, r) : n === 3 ? e.add(r) : e[t] = r;
+}
+function Ae(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function M(e) {
+  return e instanceof Map;
+}
+function R(e) {
+  return e instanceof Set;
+}
+function g(e) {
+  return e.copy_ || e.base_;
+}
+function Q(e, t) {
+  if (M(e))
+    return new Map(e);
+  if (R(e))
+    return new Set(e);
+  if (Array.isArray(e))
+    return Array.prototype.slice.call(e);
+  const r = de(e);
+  if (t === !0 || t === "class_only" && !r) {
+    const n = Object.getOwnPropertyDescriptors(e);
+    delete n[p];
+    let o = Reflect.ownKeys(n);
+    for (let u = 0; u < o.length; u++) {
+      const i = o[u], a = n[i];
+      a.writable === !1 && (a.writable = !0, a.configurable = !0), (a.get || a.set) && (n[i] = {
+        configurable: !0,
+        writable: !0,
+        // could live with !!desc.set as well here...
+        enumerable: a.enumerable,
+        value: e[i]
+      });
+    }
+    return Object.create(z(e), n);
+  } else {
+    const n = z(e);
+    if (n !== null && r)
+      return { ...e };
+    const o = Object.create(n);
+    return Object.assign(o, e);
+  }
+}
+function J(e, t = !1) {
+  return I(e) || D(e) || !w(e) || (L(e) > 1 && (e.set = e.add = e.clear = e.delete = je), Object.freeze(e), t && Object.entries(e).forEach(([r, n]) => J(n, !0))), e;
+}
+function je() {
+  h(2);
+}
+function I(e) {
+  return Object.isFrozen(e);
+}
+var Fe = {};
+function O(e) {
+  const t = Fe[e];
+  return t || h(0, e), t;
+}
+var A;
+function he() {
+  return A;
+}
+function xe(e, t) {
+  return {
+    drafts_: [],
+    parent_: e,
+    immer_: t,
+    // Whenever the modified draft contains a draft from another scope, we
+    // need to prevent auto-freezing so the unowned draft can be finalized.
+    canAutoFreeze_: !0,
+    unfinalizedDrafts_: 0
+  };
+}
+function ce(e, t) {
+  t && (O("Patches"), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function T(e) {
+  X(e), e.drafts_.forEach(Ce), e.drafts_ = null;
+}
+function X(e) {
+  e === A && (A = e.parent_);
+}
+function fe(e) {
+  return A = xe(A, e);
+}
+function Ce(e) {
+  const t = e[p];
+  t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function le(e, t) {
+  t.unfinalizedDrafts_ = t.drafts_.length;
+  const r = t.drafts_[0];
+  return e !== void 0 && e !== r ? (r[p].modified_ && (T(t), h(4)), w(e) && (e = U(t, e), t.parent_ || N(t, e)), t.patches_ && O("Patches").generateReplacementPatches_(
+    r[p].base_,
+    e,
+    t.patches_,
+    t.inversePatches_
+  )) : e = U(t, r, []), T(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e !== _e ? e : void 0;
+}
+function U(e, t, r) {
+  if (I(t))
+    return t;
+  const n = t[p];
+  if (!n)
+    return C(
+      t,
+      (o, u) => pe(e, n, t, o, u, r)
+    ), t;
+  if (n.scope_ !== e)
+    return t;
+  if (!n.modified_)
+    return N(e, n.base_, !0), n.base_;
+  if (!n.finalized_) {
+    n.finalized_ = !0, n.scope_.unfinalizedDrafts_--;
+    const o = n.copy_;
+    let u = o, i = !1;
+    n.type_ === 3 && (u = new Set(o), o.clear(), i = !0), C(
+      u,
+      (a, d) => pe(e, n, o, a, d, r, i)
+    ), N(e, o, !1), r && e.patches_ && O("Patches").generatePatches_(
+      n,
+      r,
+      e.patches_,
+      e.inversePatches_
+    );
+  }
+  return n.copy_;
+}
+function pe(e, t, r, n, o, u, i) {
+  if (D(o)) {
+    const a = u && t && t.type_ !== 3 && // Set objects are atomic since they have no keys.
+    !G(t.assigned_, n) ? u.concat(n) : void 0, d = U(e, o, a);
+    if (ye(r, n, d), D(d))
+      e.canAutoFreeze_ = !1;
+    else
+      return;
+  } else i && r.add(o);
+  if (w(o) && !I(o)) {
+    if (!e.immer_.autoFreeze_ && e.unfinalizedDrafts_ < 1)
+      return;
+    U(e, o), (!t || !t.scope_.parent_) && typeof n != "symbol" && Object.prototype.propertyIsEnumerable.call(r, n) && N(e, o);
+  }
+}
+function N(e, t, r = !1) {
+  !e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && J(t, r);
+}
+function Ue(e, t) {
+  const r = Array.isArray(e), n = {
+    type_: r ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: t ? t.scope_ : he(),
+    // True for both shallow and deep changes.
+    modified_: !1,
+    // Used during finalization.
+    finalized_: !1,
+    // Track which properties have been assigned (true) or deleted (false).
+    assigned_: {},
+    // The parent draft state.
+    parent_: t,
+    // The base state.
+    base_: e,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: !1
+  };
+  let o = n, u = Y;
+  r && (o = [n], u = j);
+  const { revoke: i, proxy: a } = Proxy.revocable(o, u);
+  return n.draft_ = a, n.revoke_ = i, a;
+}
+var Y = {
+  get(e, t) {
+    if (t === p)
+      return e;
+    const r = g(e);
+    if (!G(r, t))
+      return Ne(e, r, t);
+    const n = r[t];
+    return e.finalized_ || !w(n) ? n : n === W(e.base_, t) ? (K(e), e.copy_[t] = B(n, e)) : n;
+  },
+  has(e, t) {
+    return t in g(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(g(e));
+  },
+  set(e, t, r) {
+    const n = ve(g(e), t);
+    if (n != null && n.set)
+      return n.set.call(e.draft_, r), !0;
+    if (!e.modified_) {
+      const o = W(g(e), t), u = o?.[p];
+      if (u && u.base_ === r)
+        return e.copy_[t] = r, e.assigned_[t] = !1, !0;
+      if (Ae(r, o) && (r !== void 0 || G(e.base_, t)))
+        return !0;
+      K(e), q(e);
+    }
+    return e.copy_[t] === r && // special case: handle new props with value 'undefined'
+    (r !== void 0 || t in e.copy_) || // special case: NaN
+    Number.isNaN(r) && Number.isNaN(e.copy_[t]) || (e.copy_[t] = r, e.assigned_[t] = !0), !0;
+  },
+  deleteProperty(e, t) {
+    return W(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_[t] = !1, K(e), q(e)) : delete e.assigned_[t], e.copy_ && delete e.copy_[t], !0;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(e, t) {
+    const r = g(e), n = Reflect.getOwnPropertyDescriptor(r, t);
+    return n && {
+      writable: !0,
+      configurable: e.type_ !== 1 || t !== "length",
+      enumerable: n.enumerable,
+      value: r[t]
+    };
+  },
+  defineProperty() {
+    h(11);
+  },
+  getPrototypeOf(e) {
+    return z(e.base_);
+  },
+  setPrototypeOf() {
+    h(12);
+  }
+}, j = {};
+C(Y, (e, t) => {
+  j[e] = function() {
+    return arguments[0] = arguments[0][0], t.apply(this, arguments);
+  };
+});
+j.deleteProperty = function(e, t) {
+  return j.set.call(this, e, t, void 0);
+};
+j.set = function(e, t, r) {
+  return Y.set.call(this, e[0], t, r, e[0]);
+};
+function W(e, t) {
+  const r = e[p];
+  return (r ? g(r) : e)[t];
+}
+function Ne(e, t, r) {
+  var n;
+  const o = ve(t, r);
+  return o ? "value" in o ? o.value : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    (n = o.get) == null ? void 0 : n.call(e.draft_)
+  ) : void 0;
+}
+function ve(e, t) {
+  if (!(t in e))
+    return;
+  let r = z(e);
+  for (; r; ) {
+    const n = Object.getOwnPropertyDescriptor(r, t);
+    if (n)
+      return n;
+    r = z(r);
+  }
+}
+function q(e) {
+  e.modified_ || (e.modified_ = !0, e.parent_ && q(e.parent_));
+}
+function K(e) {
+  e.copy_ || (e.copy_ = Q(
+    e.base_,
+    e.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var Le = class {
+  constructor(e) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.produce = (t, r, n) => {
+      if (typeof t == "function" && typeof r != "function") {
+        const u = r;
+        r = t;
+        const i = this;
+        return function(a = u, ...d) {
+          return i.produce(a, (y) => r.call(this, y, ...d));
+        };
+      }
+      typeof r != "function" && h(6), n !== void 0 && typeof n != "function" && h(7);
+      let o;
+      if (w(t)) {
+        const u = fe(this), i = B(t, void 0);
+        let a = !0;
+        try {
+          o = r(i), a = !1;
+        } finally {
+          a ? T(u) : X(u);
+        }
+        return ce(u, n), le(o, u);
+      } else if (!t || typeof t != "object") {
+        if (o = r(t), o === void 0 && (o = t), o === _e && (o = void 0), this.autoFreeze_ && J(o, !0), n) {
+          const u = [], i = [];
+          O("Patches").generateReplacementPatches_(t, o, u, i), n(u, i);
+        }
+        return o;
+      } else
+        h(1, t);
+    }, this.produceWithPatches = (t, r) => {
+      if (typeof t == "function")
+        return (u, ...i) => this.produceWithPatches(u, (a) => t(a, ...i));
+      let n, o;
+      return [this.produce(t, r, (u, i) => {
+        n = u, o = i;
+      }), n, o];
+    }, typeof e?.autoFreeze == "boolean" && this.setAutoFreeze(e.autoFreeze), typeof e?.useStrictShallowCopy == "boolean" && this.setUseStrictShallowCopy(e.useStrictShallowCopy);
+  }
+  createDraft(e) {
+    w(e) || h(8), D(e) && (e = Me(e));
+    const t = fe(this), r = B(e, void 0);
+    return r[p].isManual_ = !0, X(t), r;
+  }
+  finishDraft(e, t) {
+    const r = e && e[p];
+    (!r || !r.isManual_) && h(9);
+    const { scope_: n } = r;
+    return ce(n, t), le(void 0, n);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(e) {
+    this.autoFreeze_ = e;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(e) {
+    this.useStrictShallowCopy_ = e;
+  }
+  applyPatches(e, t) {
+    let r;
+    for (r = t.length - 1; r >= 0; r--) {
+      const o = t[r];
+      if (o.path.length === 0 && o.op === "replace") {
+        e = o.value;
+        break;
+      }
+    }
+    r > -1 && (t = t.slice(r + 1));
+    const n = O("Patches").applyPatches_;
+    return D(e) ? n(e, t) : this.produce(
+      e,
+      (o) => n(o, t)
+    );
+  }
+};
+function B(e, t) {
+  const r = M(e) ? O("MapSet").proxyMap_(e, t) : R(e) ? O("MapSet").proxySet_(e, t) : Ue(e, t);
+  return (t ? t.scope_ : he()).drafts_.push(r), r;
+}
+function Me(e) {
+  return D(e) || h(10, e), be(e);
+}
+function be(e) {
+  if (!w(e) || I(e))
+    return e;
+  const t = e[p];
+  let r;
+  if (t) {
+    if (!t.modified_)
+      return t.base_;
+    t.finalized_ = !0, r = Q(e, t.scope_.immer_.useStrictShallowCopy_);
+  } else
+    r = Q(e, !0);
+  return C(r, (n, o) => {
+    ye(r, n, be(o));
+  }), t && (t.finalized_ = !1), r;
+}
+var _ = new Le();
+_.produce;
+_.produceWithPatches.bind(
+  _
+);
+_.setAutoFreeze.bind(_);
+_.setUseStrictShallowCopy.bind(_);
+_.applyPatches.bind(_);
+_.createDraft.bind(_);
+_.finishDraft.bind(_);
+var m = /* @__PURE__ */ ((e) => (e.Idle = "IDLE", e.Pending = "PENDING", e.Queued = "QUEUED", e.Uploading = "UPLOADING", e.Uploaded = "UPLOADED", e.Cancelled = "CANCELLED", e.Failed = "FAILED", e.Paused = "PAUSED", e))(m || {});
+m.Pending, m.Uploading;
+m.Idle, m.Paused;
+m.Paused, m.Uploading, m.Queued, m.Pending;
+const Re = me(null), { Provider: Ge } = Re;

package/index15.js

@@ -0,0 +1,58 @@
+import { __exports as n } from "./index16.js";
+var c;
+function f() {
+  if (c) return n;
+  c = 1, Object.defineProperty(n, "__esModule", { value: !0 }), n.jwtDecode = n.InvalidTokenError = void 0;
+  class a extends Error {
+  }
+  n.InvalidTokenError = a, a.prototype.name = "InvalidTokenError";
+  function d(r) {
+    return decodeURIComponent(atob(r).replace(/(.)/g, (e, t) => {
+      let o = t.charCodeAt(0).toString(16).toUpperCase();
+      return o.length < 2 && (o = "0" + o), "%" + o;
+    }));
+  }
+  function l(r) {
+    let e = r.replace(/-/g, "+").replace(/_/g, "/");
+    switch (e.length % 4) {
+      case 0:
+        break;
+      case 2:
+        e += "==";
+        break;
+      case 3:
+        e += "=";
+        break;
+      default:
+        throw new Error("base64 string is not of the correct length");
+    }
+    try {
+      return d(e);
+    } catch {
+      return atob(e);
+    }
+  }
+  function p(r, e) {
+    if (typeof r != "string")
+      throw new a("Invalid token specified: must be a string");
+    e || (e = {});
+    const t = e.header === !0 ? 0 : 1, o = r.split(".")[t];
+    if (typeof o != "string")
+      throw new a(`Invalid token specified: missing part #${t + 1}`);
+    let s;
+    try {
+      s = l(o);
+    } catch (i) {
+      throw new a(`Invalid token specified: invalid base64 for part #${t + 1} (${i.message})`);
+    }
+    try {
+      return JSON.parse(s);
+    } catch (i) {
+      throw new a(`Invalid token specified: invalid json for part #${t + 1} (${i.message})`);
+    }
+  }
+  return n.jwtDecode = p, n;
+}
+export {
+  f as __require
+};

package/index16.js

@@ -0,0 +1,4 @@
+var r = {};
+export {
+  r as __exports
+};

package/index17.js

@@ -0,0 +1,89 @@
+import t from "./utils6.js";
+import p from "./AxiosError.js";
+import u from "./transitional.js";
+import S from "./toFormData.js";
+import h from "./toURLEncodedForm.js";
+import l from "./index18.js";
+import O from "./formDataToJSON.js";
+function y(i, r, e) {
+  if (t.isString(i))
+    try {
+      return (r || JSON.parse)(i), t.trim(i);
+    } catch (n) {
+      if (n.name !== "SyntaxError")
+        throw n;
+    }
+  return (e || JSON.stringify)(i);
+}
+const a = {
+  transitional: u,
+  adapter: ["xhr", "http", "fetch"],
+  transformRequest: [function(r, e) {
+    const n = e.getContentType() || "", s = n.indexOf("application/json") > -1, f = t.isObject(r);
+    if (f && t.isHTMLForm(r) && (r = new FormData(r)), t.isFormData(r))
+      return s ? JSON.stringify(O(r)) : r;
+    if (t.isArrayBuffer(r) || t.isBuffer(r) || t.isStream(r) || t.isFile(r) || t.isBlob(r) || t.isReadableStream(r))
+      return r;
+    if (t.isArrayBufferView(r))
+      return r.buffer;
+    if (t.isURLSearchParams(r))
+      return e.setContentType("application/x-www-form-urlencoded;charset=utf-8", !1), r.toString();
+    let o;
+    if (f) {
+      if (n.indexOf("application/x-www-form-urlencoded") > -1)
+        return h(r, this.formSerializer).toString();
+      if ((o = t.isFileList(r)) || n.indexOf("multipart/form-data") > -1) {
+        const c = this.env && this.env.FormData;
+        return S(
+          o ? { "files[]": r } : r,
+          c && new c(),
+          this.formSerializer
+        );
+      }
+    }
+    return f || s ? (e.setContentType("application/json", !1), y(r)) : r;
+  }],
+  transformResponse: [function(r) {
+    const e = this.transitional || a.transitional, n = e && e.forcedJSONParsing, s = this.responseType === "json";
+    if (t.isResponse(r) || t.isReadableStream(r))
+      return r;
+    if (r && t.isString(r) && (n && !this.responseType || s)) {
+      const m = !(e && e.silentJSONParsing) && s;
+      try {
+        return JSON.parse(r);
+      } catch (o) {
+        if (m)
+          throw o.name === "SyntaxError" ? p.from(o, p.ERR_BAD_RESPONSE, this, null, this.response) : o;
+      }
+    }
+    return r;
+  }],
+  /**
+   * A timeout in milliseconds to abort a request. If set to 0 (default) a
+   * timeout is not created.
+   */
+  timeout: 0,
+  xsrfCookieName: "XSRF-TOKEN",
+  xsrfHeaderName: "X-XSRF-TOKEN",
+  maxContentLength: -1,
+  maxBodyLength: -1,
+  env: {
+    FormData: l.classes.FormData,
+    Blob: l.classes.Blob
+  },
+  validateStatus: function(r) {
+    return r >= 200 && r < 300;
+  },
+  headers: {
+    common: {
+      Accept: "application/json, text/plain, */*",
+      "Content-Type": void 0
+    }
+  }
+};
+t.forEach(["delete", "get", "head", "post", "put", "patch"], (i) => {
+  a.headers[i] = {};
+});
+export {
+  a as default
+};