@dhedge/trading-widget 6.0.6 → 6.1.1

package/dytm-CWhBYz0P.js

@@ -0,0 +1,784 @@
+import { mainnet as f, hyperEvm as $, polygon as Y, optimism as k, base as q, arbitrum as G } from "wagmi/chains";
+import { ar as V, ap as K, aq as H, a as _, q as w, as as z, at as Q, a5 as Z, al as j, a3 as X, b as J, ae as tt, ak as et, aj as at, Z as nt, au as x, e as st, d as ot, M as rt, R as it, P as ut, av as ct, aw as dt, Q as pt, N as mt, ah as S, _ as lt, W as yt, X as At, U as Tt, ax as P, ay as gt, az as Dt, aA as St, aB as ft, aC as _t, ad as wt } from "./gmx-c42QlKyJ.js";
+import c from "bignumber.js";
+import { zeroHash as Et, bytesToHex as bt, pad as ht, stringToHex as E, encodeAbiParameters as g, encodeFunctionData as A, erc20Abi as U, maxUint256 as b } from "viem";
+const se = typeof window < "u", oe = [
+  {
+    inputs: [
+      { internalType: "address", name: "_pool", type: "address" },
+      { internalType: "address", name: "_asset", type: "address" },
+      { internalType: "uint256", name: "_poolTokenAmount", type: "uint256" }
+    ],
+    name: "previewGmTokenAmount",
+    outputs: [
+      { internalType: "uint256", name: "gmTokenAmount", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "ondoGMSwap",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "usdc",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  }
+], It = [
+  {
+    type: "tuple",
+    components: [
+      { name: "attestationSignature", type: "bytes" },
+      {
+        name: "quote",
+        type: "tuple",
+        components: [
+          { name: "chainId", type: "uint256" },
+          { name: "attestationId", type: "uint256" },
+          { name: "userId", type: "bytes32" },
+          { name: "asset", type: "address" },
+          { name: "price", type: "uint256" },
+          { name: "quantity", type: "uint256" },
+          { name: "expiration", type: "uint256" },
+          { name: "side", type: "uint8" },
+          { name: "additionalData", type: "bytes32" }
+        ]
+      },
+      { name: "amountOutMinimum", type: "uint256" }
+    ]
+  }
+], Nt = [
+  { name: "asset", type: "address" },
+  { name: "amount", type: "uint256" },
+  { name: "assetType", type: "uint16" },
+  { name: "isPool", type: "bool" },
+  { name: "isDebt", type: "bool" },
+  { name: "marketId", type: "uint88" },
+  { name: "accountId", type: "uint256" },
+  { name: "tokenId", type: "uint256" },
+  { name: "debtKey", type: "uint248" },
+  { name: "shares", type: "uint256" }
+], re = [
+  {
+    inputs: [
+      { internalType: "address", name: "_pool", type: "address" },
+      { internalType: "uint256", name: "_poolTokenAmount", type: "uint256" }
+    ],
+    name: "previewWithdrawal",
+    outputs: [
+      {
+        name: "assetData",
+        type: "tuple[]",
+        components: Nt
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "dytmWithdrawProcessor",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  }
+], F = [
+  {
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "account", type: "uint256" },
+          { name: "tokenId", type: "uint256" },
+          { name: "receiver", type: "address" },
+          { name: "assets", type: "uint256" },
+          { name: "shares", type: "uint256" },
+          { name: "extraData", type: "bytes" }
+        ]
+      }
+    ],
+    name: "withdraw",
+    outputs: [{ name: "assets", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "account", type: "uint256" },
+          { name: "key", type: "uint248" },
+          // DytmParamStructs.TokenType enum — 0 = NONE.
+          { name: "withCollateralType", type: "uint8" },
+          { name: "assets", type: "uint256" },
+          { name: "shares", type: "uint256" },
+          { name: "extraData", type: "bytes" }
+        ]
+      }
+    ],
+    name: "repay",
+    outputs: [{ name: "assetsRepaid", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+], Ot = [
+  {
+    inputs: [
+      { name: "tokenIn", type: "address" },
+      { name: "amountIn", type: "uint256" },
+      { name: "tokenOut", type: "address" },
+      { name: "amountOutMinimum", type: "uint256" },
+      { name: "attestationSignature", type: "bytes" },
+      {
+        name: "quote",
+        type: "tuple",
+        components: [
+          { name: "chainId", type: "uint256" },
+          { name: "attestationId", type: "uint256" },
+          { name: "userId", type: "bytes32" },
+          { name: "asset", type: "address" },
+          { name: "price", type: "uint256" },
+          { name: "quantity", type: "uint256" },
+          { name: "expiration", type: "uint256" },
+          { name: "side", type: "uint8" },
+          { name: "additionalData", type: "bytes32" }
+        ]
+      }
+    ],
+    name: "swapExactInWithAttestation",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+], Rt = [
+  {
+    type: "tuple",
+    components: [
+      {
+        name: "actions",
+        type: "tuple[]",
+        components: [
+          { name: "to", type: "address" },
+          { name: "data", type: "bytes" }
+        ]
+      },
+      { name: "outputAsset", type: "address" },
+      { name: "minOutputAmount", type: "uint256" }
+    ]
+  }
+], Ct = () => typeof window < "u";
+function Mt() {
+  return Ct() && typeof window.ethereum < "u";
+}
+async function ie(t) {
+  try {
+    if (Mt())
+      return window.ethereum.request({
+        method: "wallet_watchAsset",
+        params: {
+          type: "ERC20",
+          options: t
+        }
+      });
+  } catch {
+    return !1;
+  }
+  return !1;
+}
+const m = (t, e) => t?.toLowerCase() === e?.toLowerCase(), ue = (t) => m(t, V), T = (t) => {
+  if (!t) throw new Error("Cannot prefix an empty hex value");
+  return t.startsWith("0x") ? t : `0x${t}`;
+}, p = (t, e) => {
+  try {
+    return BigInt(t);
+  } catch {
+    throw new Error(`Cannot convert "${e}" value "${t}" to bigint`);
+  }
+}, h = (t) => t ? ht(T(t), { size: 32 }) : Et, Bt = (t) => {
+  if (!t) throw new Error("Cannot decode an empty base64 string");
+  return bt(Uint8Array.from(atob(t), (e) => e.charCodeAt(0)));
+}, Lt = (t, e) => H[e]?.[t] ?? _, ce = (t) => K[t], de = (t) => t && `${t.substring(0, 6)}...${t.substring(
+  t.length - 4,
+  t.length
+)}`, pe = ({
+  address: t,
+  chainId: e
+}) => {
+  const a = Lt(
+    "aaveLendingPoolV3",
+    e
+  );
+  return m(t, a);
+}, xt = ({
+  sourceAddress: t,
+  amount: e
+}) => `${t}_${e}`, me = (t, e) => {
+  const a = t.slice(0, e), n = t.slice(e);
+  return { firstPart: a, secondPart: n };
+}, Pt = (t, e) => t / e * 100, le = (t) => t < 1 ? 4 : t < 10 ? 3 : 2, ye = (t, e = w) => new c(t.toString()).shiftedBy(e).toFixed(0), Ae = (t, e, a, n) => new c(e).dividedBy(a).multipliedBy(t).shiftedBy(-(n || w)).toNumber(), Te = (t) => BigInt(
+  new c(t || "0").shiftedBy(w).toFixed(0, c.ROUND_DOWN)
+), Ut = (t) => {
+  const e = new c(0.01), a = new c(t), n = !a.isZero() && a.lt(e) ? e : a;
+  return BigInt(n.multipliedBy(100).toFixed(0));
+}, ge = ({
+  vaultAddress: t,
+  swapData: e,
+  sendTokenAddress: a,
+  sendTokenAmount: n,
+  vaultDepositTokenAddress: s,
+  minVaultTokensReceivedAmount: o,
+  routerKey: r = "ONE_INCH",
+  swapDestinationAmount: u,
+  swapSlippage: i
+}) => {
+  const d = new c(u).multipliedBy(1 - i / 100).toFixed(0), l = [E(r, { size: 32 }), e];
+  return [t, [[a, n, l], [s, d]], o];
+}, De = ({
+  receiveAssetAddress: t,
+  assets: e,
+  swapData: a,
+  slippage: n
+}) => {
+  const s = {
+    srcData: [],
+    destAmount: new c("0")
+  }, { srcData: o, destAmount: r } = e?.reduce((u, i) => {
+    const d = a?.[i.address];
+    if (!d)
+      return u;
+    const l = [
+      E(d.routerKey, { size: 32 }),
+      d.rawTransaction.data
+    ], y = [i.address, i.rawBalance, l];
+    return {
+      srcData: [...u.srcData, y],
+      destAmount: u.destAmount.plus(d.destinationAmount)
+    };
+  }, s) ?? s;
+  return [
+    o,
+    [
+      t,
+      r.times(1 - n / 100).toFixed(0, c.ROUND_DOWN)
+    ]
+  ];
+}, Ft = ({
+  assetAddress: t,
+  swapQuotes: e,
+  swapParams: a,
+  slippageToleranceForContractTransaction: n,
+  routerKey: s
+}) => {
+  if (!a)
+    return {
+      supportedAsset: t,
+      withdrawData: "",
+      slippageTolerance: BigInt(0)
+    };
+  const { srcData: o, dstData: r } = a, u = o.map(({ asset: l, amount: y }) => {
+    const D = e?.[xt({
+      sourceAddress: l,
+      amount: y.toString()
+    })]?.find((W) => W.routerKey === s);
+    return {
+      asset: l,
+      amount: y,
+      swapData: {
+        routerKey: E(D?.routerKey ?? "", { size: 32 }),
+        txData: D?.rawTransaction.data ?? "0x"
+      }
+    };
+  }), i = g(
+    z,
+    [u]
+  ), d = g(Q, [
+    {
+      encodedSrcData: i,
+      dstData: {
+        dstAddress: r.asset,
+        dstAmount: r.amount
+      },
+      slippage: n
+    }
+  ]);
+  return {
+    supportedAsset: t,
+    withdrawData: d,
+    slippageTolerance: n
+  };
+}, Se = ({
+  chainId: t,
+  txHash: e,
+  error: a
+}) => {
+  if (t !== f.id || !e || !a)
+    return !1;
+  const n = a instanceof Error ? a.message : String(a);
+  return /\bNo Result\b/i.test(n);
+}, fe = ({
+  chainId: t,
+  action: e,
+  isRabbyWallet: a
+}) => e === "update_ondo_prices" && t === f.id && a ? Z : t ? j[t] ?? 0 : 0, _e = (t, e) => J[e]?.nativeTokenSymbol === t, we = ({
+  nativeTokenBalance: t,
+  tokenDecimals: e,
+  gasPrice: a
+}) => {
+  const n = new c(a).multipliedBy(X).shiftedBy(-e), s = new c(t).minus(
+    n
+  );
+  return s.gt("0") ? s : new c("0");
+}, Ee = (t) => tt.includes(t), be = (t) => {
+  const e = Object.values(t).reduce(
+    (a, { type: n }) => (a[n] = a[n] + 1, a),
+    { string: 0, number: 0 }
+  );
+  if (e.string > 10)
+    throw new Error("logger params must contain up to 10 string values");
+  if (e.number > 40)
+    throw new Error("logger params must contain up to 40 numeric values");
+  return !0;
+}, vt = (t, e = 150) => t.length > e ? t.substring(0, e) : t, I = (t, e = et) => {
+  const a = t.toLowerCase();
+  return e.sort((n, s) => s.length - n.length).find((n) => a.includes(n.toLowerCase()));
+}, N = (t) => at[t] ?? nt[t], he = ({
+  errorMessage: t,
+  abiErrors: e
+}) => {
+  if (!t || t.includes("User rejected"))
+    return null;
+  const a = e.find((o) => t.includes(o));
+  if (a && I(a))
+    return N(a);
+  const n = I(t);
+  if (n)
+    return N(n);
+  const [s] = t.split(a ? "." : "Contract").map((o) => o.trim());
+  return {
+    title: "Transaction failed",
+    hint: `${vt(s ?? "")} ${a ? `: ${a}` : ""}`
+  };
+}, Ie = (t) => typeof t == "number" && Number.isFinite(t), Ne = (t) => typeof t == "bigint" && t !== BigInt(0), Wt = (t, e = x) => new c(t).shiftedBy(-e).toNumber(), $t = (t) => !isNaN(parseFloat(t)) && !isNaN(t), Yt = ({
+  value: t,
+  minimumFractionDigits: e = 2,
+  maximumFractionDigits: a = 2,
+  compact: n = !1,
+  normalize: s = !1
+}) => new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  notation: n ? "compact" : void 0,
+  minimumFractionDigits: e,
+  maximumFractionDigits: a
+}).format(s ? Wt(t) : Number(t)), O = (t) => $t(t) ? new c(t).toFixed() : "", R = ["₀", "₁", "₂", "₃", "₄", "₅", "₆", "₇", "₈", "₉"], kt = ({
+  value: t,
+  decimals: e = 4
+}) => {
+  const a = new c(t);
+  if (a.isGreaterThan(1) || a.isZero())
+    return O(a.toFixed(e));
+  const s = (/e/i.test(t.toString()) ? parseFloat(t.toString()).toFixed(x) : t.toString()).match(/^0\.(0+)(\d+)$/);
+  if (s) {
+    const [, o, r] = s;
+    if (o.length >= e && o.length < R.length)
+      return `0.0${R[o.length]}${r.slice(0, 3)}`;
+  }
+  return O(a.toFixed(e));
+}, qt = (t, e = 0) => `${t.toLocaleString("en-US", { maximumFractionDigits: e })}%`, Oe = (t) => t.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ","), Re = (t, e, a = 0) => {
+  const n = Pt(+t, e);
+  return qt(n, a);
+}, Ce = ({
+  currency: t,
+  value: e
+}) => t === "USD" ? Yt({ value: e }) : `${st[t]} ${kt({
+  value: e,
+  decimals: ot[t]
+})}`, Gt = (t, e) => new c(
+  new c(t).toFixed(e, c.ROUND_DOWN)
+).toString(), Vt = (t, e = 3, a = 2) => {
+  if (t.length <= 5)
+    return t;
+  const n = "...";
+  return t.length <= e + a + n.length ? t : `${t.slice(0, e)}${n}${t.slice(-a)}`;
+}, Me = ({
+  balance: t,
+  symbol: e,
+  precision: a,
+  truncateSymbol: n
+}) => `${Gt(t, a)} ${n ? Vt(e) : e}`, Be = (t) => {
+  if (!t)
+    return;
+  const e = t.match(/0x[a-fA-F0-9]{64}/);
+  if (!e)
+    return;
+  const a = e[0];
+  return `${a.slice(0, 4)}...${a.slice(-3)}`;
+}, Le = (t) => m(ct, t) || m(dt, t), xe = (t) => mt.some(
+  (e) => m(e, t)
+), Pe = (t) => rt[t.toLowerCase()] ?? {
+  symbol: "",
+  decimals: 18,
+  address: _
+}, Ue = (t) => m(t, pt) ? it : ut, Kt = (t) => `eth_${t}`, Fe = ({
+  action: t,
+  log: e,
+  symbol: a,
+  vaultAddress: n,
+  chainId: s
+}) => {
+  const o = {
+    [S.SYMBOL.NAME]: a,
+    [S.CHAIN_ID.NAME]: s,
+    [S.ADDRESS.NAME]: Kt(n)
+  };
+  lt[t].forEach((r) => {
+    e?.(r, o);
+  });
+}, ve = (t) => Tt.some((e) => m(e, t)), We = (t) => yt[t.toLowerCase()] ?? {
+  symbol: "",
+  decimals: 18,
+  address: _
+}, $e = (t) => At[t.toLowerCase()], Ht = "0x3333333333333333333333333333333333333333";
+G.id + "", _t.address, q.id + "", ft.address, k.id + "", St.address, Y.id + "", Dt.address, f.id + "", gt.address, $.id + "", P.address;
+const Ye = (t) => m(t, Ht), ke = () => P, qe = /* @__PURE__ */ new Map(), v = (t, e) => !e || e.size === 0 ? t : t.map((a) => {
+  const n = e.get(
+    a.supportedAsset.toLowerCase()
+  );
+  return n ? {
+    ...a,
+    withdrawData: n.withdrawData,
+    slippageTolerance: n.slippageTolerance
+  } : a;
+}), zt = (t) => {
+  const e = t.find(
+    ({ swapQuotes: a }) => a
+  );
+  return e?.swapQuotes ? Object.values(e.swapQuotes)[0]?.map(
+    ({ routerKey: a }) => a
+  ) ?? [] : [];
+}, Qt = (t, e, a) => t.map(({ asset: n, swapParams: s, swapQuotes: o }) => !s || !o ? {
+  supportedAsset: n,
+  withdrawData: "",
+  slippageTolerance: a
+} : Ft({
+  assetAddress: n,
+  swapQuotes: o,
+  swapParams: s,
+  slippageToleranceForContractTransaction: a,
+  routerKey: e
+})), Zt = async (t, e, a, n, s, o) => {
+  for (const r of t) {
+    const u = v(
+      Qt(
+        e,
+        r,
+        a
+      ),
+      o
+    ), { error: i } = await n(...s, u);
+    if (!i)
+      return u;
+  }
+  return null;
+}, Ge = (t, e, a) => {
+  const n = (t ?? []).map((s) => ({
+    supportedAsset: s,
+    withdrawData: "",
+    slippageTolerance: e
+  }));
+  return v(n, a);
+}, Ve = async (t, e, a, n, s) => {
+  for (const o of t) {
+    const r = Ut(o);
+    try {
+      const u = await e(o), i = zt(
+        u
+      ), d = await Zt(
+        i,
+        u,
+        r,
+        a,
+        n,
+        s
+      );
+      if (d)
+        return console.debug(
+          `[Init Withdraw] Auto slippage simulation succeeded: slippage=${o}%`
+        ), console.debug("[Init Withdraw] Complex asset data:", d), d;
+    } catch (u) {
+      console.error(
+        `[Init Withdraw] Failed to fetch quotes for slippage=${o}%:`,
+        u
+      );
+    }
+  }
+  return null;
+}, Ke = async (t, e, {
+  fetchAaveSwapParams: a,
+  fetchAaveSwapQuotes: n,
+  withdrawAmountD18: s,
+  slippage: o
+}) => Promise.all(
+  (t ?? []).map(async (r) => {
+    if (!m(r, e))
+      return { asset: r };
+    try {
+      const i = await a({
+        withdrawAmountD18: s,
+        slippage: o
+      });
+      if (i?.srcData.length) {
+        const d = await n({
+          swapParams: i,
+          slippage: o
+        });
+        return { asset: r, swapParams: i, swapQuotes: d };
+      }
+      return { asset: r };
+    } catch (i) {
+      return console.error(i), { asset: r };
+    }
+  })
+), C = (t) => Math.round(t * 100) / 100, He = ({
+  maxSlippage: t,
+  candidates: e = wt
+}) => {
+  if (!Number.isFinite(t) || t <= 0)
+    return [];
+  const a = C(Math.min(t, 100)), n = e.filter((o) => o > 0 && o <= a).map(C), s = new Set(n);
+  return s.add(a), s.add(t), Array.from(s).sort((o, r) => o - r);
+}, M = 1000000000000000000n, jt = 1000000n, B = 10000n, L = 100n, ze = (t) => ({
+  quotes: t.quotes.map(
+    (e) => ({
+      chainId: p(e.chainId, "chainId"),
+      attestationId: p(e.attestationId, "attestationId"),
+      userId: T(e.userId),
+      asset: e.asset,
+      price: p(e.price, "price"),
+      quantity: p(e.quantity, "quantity"),
+      expiration: p(e.expiration, "expiration"),
+      side: Number(e.side),
+      additionalData: T(e.additionalData)
+    })
+  ),
+  signatures: t.signatures.map(T)
+}), Xt = (t, e, a) => {
+  const n = BigInt(Math.max(0, Math.round(a * 100))), s = n > L ? L : n, o = B - s, u = t * e / M * o * jt, i = B * M;
+  return (u + i - 1n) / i;
+}, Jt = (t, e) => ({
+  chainId: e,
+  attestationId: p(t.attestationId, "attestationId"),
+  userId: h(t.userId),
+  asset: t.assetAddress,
+  price: p(t.price, "price"),
+  quantity: p(t.tokenAmount, "tokenAmount"),
+  expiration: p(t.expiration, "expiration"),
+  side: Number(t.side),
+  additionalData: h(t.additionalData)
+}), Qe = ({
+  attestation: t,
+  chainId: e,
+  slippagePercent: a
+}) => {
+  const n = Jt(t, e);
+  return g(It, [
+    {
+      attestationSignature: Bt(t.signature),
+      quote: n,
+      amountOutMinimum: Xt(
+        n.quantity,
+        n.price,
+        a
+      )
+    }
+  ]);
+}, Ze = (t) => [...t.reduce(
+  (a, n) => a.has(n.accountId) ? a : a.set(n.accountId, n),
+  /* @__PURE__ */ new Map()
+).values()].map(({ accountId: a, marketId: n }) => ({
+  accountId: a,
+  marketId: n,
+  collaterals: t.filter(
+    (s) => s.accountId === a && !s.isDebt
+  ),
+  debt: t.find(
+    (s) => s.accountId === a && s.isDebt
+  )
+})), je = ({
+  collateral: t,
+  dytmOffice: e,
+  processor: a,
+  gmToken: n,
+  ondoGMSwap: s,
+  usdc: o,
+  gmAmount: r,
+  amountOutMinimum: u,
+  signature: i,
+  quote: d
+}) => [
+  {
+    // 1 · pull GM collateral out of the split account -> processor
+    to: e,
+    data: A({
+      abi: F,
+      functionName: "withdraw",
+      args: [
+        {
+          account: t.accountId,
+          tokenId: t.tokenId,
+          receiver: a,
+          assets: r,
+          shares: 0n,
+          extraData: "0x"
+        }
+      ]
+    })
+  },
+  {
+    // 2 · approve the GM token to Ondo's swap contract
+    to: n,
+    data: A({
+      abi: U,
+      functionName: "approve",
+      args: [s, r]
+    })
+  },
+  {
+    // 3 · redeem GM -> USDC with the signed attestation
+    to: s,
+    data: A({
+      abi: Ot,
+      functionName: "swapExactInWithAttestation",
+      args: [n, r, o, u, i, d]
+    })
+  }
+], Xe = ({
+  accountId: t,
+  debtKey: e,
+  dytmOffice: a,
+  usdc: n
+}) => [
+  {
+    // approve USDC to the DYTM Office for the repay
+    to: n,
+    data: A({
+      abi: U,
+      functionName: "approve",
+      args: [a, b]
+    })
+  },
+  {
+    // repay the slice's whole USDC debt
+    to: a,
+    data: A({
+      abi: F,
+      functionName: "repay",
+      args: [
+        {
+          account: t,
+          key: e,
+          withCollateralType: 0,
+          // DytmParamStructs.TokenType.NONE
+          assets: b,
+          // repay all
+          shares: 0n,
+          extraData: "0x"
+        }
+      ]
+    })
+  }
+], Je = ({
+  actions: t,
+  outputAsset: e,
+  minOutputAmount: a
+}) => g(Rt, [
+  { actions: t, outputAsset: e, minOutputAmount: a }
+]);
+export {
+  Se as $,
+  Ue as A,
+  We as B,
+  $e as C,
+  ke as D,
+  qe as E,
+  we as F,
+  Pt as G,
+  Ae as H,
+  fe as I,
+  Ut as J,
+  Be as K,
+  Ze as L,
+  pe as M,
+  xe as N,
+  Le as O,
+  ve as P,
+  Ye as Q,
+  _e as R,
+  Ee as S,
+  Fe as T,
+  Jt as U,
+  ze as V,
+  v as W,
+  Te as X,
+  he as Y,
+  ye as Z,
+  de as _,
+  Ft as a,
+  me as a0,
+  p as a1,
+  h as a2,
+  Kt as a3,
+  Vt as a4,
+  Zt as a5,
+  Ve as a6,
+  be as a7,
+  ue as a8,
+  Ie as a9,
+  m as aa,
+  Yt as ab,
+  Ne as ac,
+  Wt as ad,
+  re as ae,
+  oe as af,
+  Ht as ag,
+  kt as ah,
+  ie as ai,
+  qt as aj,
+  $t as ak,
+  Oe as al,
+  O as am,
+  Bt as b,
+  Qt as c,
+  je as d,
+  Xe as e,
+  xt as f,
+  De as g,
+  ge as h,
+  se as i,
+  Xt as j,
+  Ge as k,
+  Qe as l,
+  Je as m,
+  Ke as n,
+  T as o,
+  zt as p,
+  Gt as q,
+  Ce as r,
+  Re as s,
+  Me as t,
+  He as u,
+  ce as v,
+  Lt as w,
+  le as x,
+  I as y,
+  Pe as z
+};