@babylonlabs-io/ts-sdk 1.0.0 → 1.2.0

package/dist/onChainBtcPubkey-C1WqyxPM.js

@@ -0,0 +1,159 @@
+import { s as x } from "./sha2-CLpQd0Rd.js";
+import { isAddress as v, keccak256 as m, encodeAbiParameters as E } from "viem";
+function y(r, t) {
+  const e = r.startsWith("0x") ? r.slice(2) : r;
+  if (e.length === 0 || e.length % 2 !== 0)
+    throw new Error(`${t} must be non-empty, even-length hex`);
+  if (!/^[0-9a-fA-F]+$/.test(e))
+    throw new Error(`${t} contains non-hex characters`);
+  const o = new Uint8Array(e.length / 2);
+  for (let s = 0; s < o.length; s++)
+    o[s] = Number.parseInt(e.slice(s * 2, s * 2 + 2), 16);
+  return o;
+}
+function C(r) {
+  return Array.from(r, (t) => t.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+function I(r) {
+  const t = new Uint8Array(
+    r.reduce((o, s) => o + s.length, 0)
+  );
+  let e = 0;
+  for (const o of r)
+    t.set(o, e), e += o.length;
+  return t;
+}
+function B(r) {
+  let t = 0;
+  const e = (n, f) => {
+    if (!Number.isSafeInteger(n) || n < 0)
+      throw new Error(`Invalid ${f} length ${n}`);
+    if (t + n > r.length)
+      throw new Error(`Truncated Bitcoin transaction while reading ${f}`);
+    const c = r.slice(t, t + n);
+    return t += n, c;
+  }, o = (n, f) => {
+    const c = e(n, f);
+    let i = 0n;
+    for (let l = c.length - 1; l >= 0; l--)
+      i = i << 8n | BigInt(c[l]);
+    return i;
+  }, s = (n) => {
+    const f = t, c = e(1, n)[0];
+    let i;
+    if (c < 253)
+      i = BigInt(c);
+    else if (c === 253) {
+      if (i = o(2, n), i < 0xfdn) throw new Error(`Non-canonical ${n}`);
+    } else if (c === 254) {
+      if (i = o(4, n), i <= 0xffffn) throw new Error(`Non-canonical ${n}`);
+    } else if (i = o(8, n), i <= 0xffffffffn) throw new Error(`Non-canonical ${n}`);
+    if (i > BigInt(Number.MAX_SAFE_INTEGER))
+      throw new Error(`${n} exceeds JavaScript's safe integer range`);
+    return {
+      encoded: r.slice(f, t),
+      value: Number(i)
+    };
+  }, a = e(4, "version"), p = r[t] === 0 && r[t + 1] === 1;
+  p && (t += 2);
+  const h = s("input count"), d = [];
+  for (let n = 0; n < h.value; n++) {
+    const f = t;
+    e(32, `input ${n} previous transaction hash`), e(4, `input ${n} previous output index`);
+    const c = s(`input ${n} script length`);
+    e(c.value, `input ${n} script`), e(4, `input ${n} sequence`), d.push(r.slice(f, t));
+  }
+  const w = s("output count"), $ = [];
+  for (let n = 0; n < w.value; n++) {
+    const f = t;
+    e(8, `output ${n} value`);
+    const c = s(`output ${n} script length`);
+    e(c.value, `output ${n} script`), $.push(r.slice(f, t));
+  }
+  if (p) {
+    let n = !1;
+    for (let f = 0; f < h.value; f++) {
+      const c = s(`input ${f} witness item count`);
+      n || (n = c.value > 0);
+      for (let i = 0; i < c.value; i++) {
+        const l = s(
+          `input ${f} witness item ${i} length`
+        );
+        e(l.value, `input ${f} witness item ${i}`);
+      }
+    }
+    if (!n)
+      throw new Error("Bitcoin transaction has superfluous witness marker");
+  }
+  const g = e(4, "locktime");
+  if (t !== r.length)
+    throw new Error(
+      `Bitcoin transaction has ${r.length - t} trailing byte(s)`
+    );
+  return I([
+    a,
+    h.encoded,
+    ...d,
+    w.encoded,
+    ...$,
+    g
+  ]);
+}
+function W(r) {
+  const t = B(
+    y(r, "transactionHex")
+  ), e = x(x(t));
+  return e.reverse(), `0x${C(e)}`;
+}
+function L(r, t) {
+  const e = r.startsWith("0x") ? r : `0x${r}`;
+  if (!/^0x[0-9a-fA-F]{64}$/.test(e))
+    throw new Error("peginTxHash must be a 32-byte hex value");
+  const o = t.startsWith("0x") ? t : `0x${t}`;
+  if (!v(o, { strict: !0 }))
+    throw new Error(`Invalid depositor Ethereum address: ${t}`);
+  return m(
+    E(
+      [{ type: "bytes32" }, { type: "address" }],
+      [e, o]
+    )
+  ).slice(2);
+}
+const u = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn, k = 7n;
+function A(r, t, e) {
+  let o = 1n, s = r % e, a = t;
+  for (; a > 0n; )
+    (a & 1n) === 1n && (o = o * s % e), s = s * s % e, a >>= 1n;
+  return o;
+}
+function S(r) {
+  const t = BigInt(`0x${r}`);
+  if (t >= u) return !1;
+  const o = (t * t % u * t % u + k) % u, s = A(
+    o,
+    u + 1n >> 2n,
+    u
+  );
+  return s * s % u === o;
+}
+function _(r, t) {
+  const e = r.toLowerCase();
+  if (!/^0x[0-9a-f]{64}$/.test(e))
+    throw new Error(
+      `${t} returned an unexpected value (length ${e.length}, prefix "${e.slice(0, 2)}")`
+    );
+  const o = e.slice(2);
+  if (!S(o))
+    throw new Error(
+      `${t} returned a value that is not on the secp256k1 curve`
+    );
+  return o;
+}
+export {
+  _ as a,
+  W as c,
+  L as d
+};
+//# sourceMappingURL=onChainBtcPubkey-C1WqyxPM.js.map

package/dist/onChainBtcPubkey-C1WqyxPM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"onChainBtcPubkey-C1WqyxPM.js","sources":["../src/tbv/core/clients/eth/pegin-transaction.ts","../src/tbv/core/clients/eth/onChainBtcPubkey.ts"],"sourcesContent":["/**\n * Dependency-free Bitcoin txid and vault-ID helpers for Ethereum-only clients.\n * Transaction hex and vault-ID inputs accept an optional `0x` prefix.\n * Depositor addresses use strict EIP-55 validation.\n * Txids use a `0x` prefix. Vault IDs use no prefix. Both use lowercase hex.\n */\n\nimport { sha256 } from \"@noble/hashes/sha2.js\";\nimport {\n  encodeAbiParameters,\n  isAddress,\n  keccak256,\n  type Address,\n  type Hex,\n} from \"viem\";\n\n/** Decode an optional-prefixed, even-length hex string. */\nfunction decodeHex(value: string, label: string): Uint8Array {\n  const clean = value.startsWith(\"0x\") ? value.slice(2) : value;\n  if (clean.length === 0 || clean.length % 2 !== 0) {\n    throw new Error(`${label} must be non-empty, even-length hex`);\n  }\n  if (!/^[0-9a-fA-F]+$/.test(clean)) {\n    throw new Error(`${label} contains non-hex characters`);\n  }\n\n  const bytes = new Uint8Array(clean.length / 2);\n  for (let i = 0; i < bytes.length; i++) {\n    bytes[i] = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);\n  }\n  return bytes;\n}\n\n/** Encode bytes as lowercase hex without a prefix. */\nfunction encodeHex(bytes: Uint8Array): string {\n  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, \"0\")).join(\n    \"\",\n  );\n}\n\n/** Concatenate byte chunks without a buffer dependency. */\nfunction concatBytes(chunks: readonly Uint8Array[]): Uint8Array {\n  const result = new Uint8Array(\n    chunks.reduce((length, chunk) => length + chunk.length, 0),\n  );\n  let offset = 0;\n  for (const chunk of chunks) {\n    result.set(chunk, offset);\n    offset += chunk.length;\n  }\n  return result;\n}\n\n/**\n * Parse enough of Bitcoin's consensus transaction encoding to serialize the\n * no-witness form used for txid calculation. Every length is bounds-checked;\n * malformed/trailing data is rejected rather than hashed as an opaque blob.\n */\nfunction serializeWithoutWitness(transaction: Uint8Array): Uint8Array {\n  let offset = 0;\n\n  const take = (length: number, label: string): Uint8Array => {\n    if (!Number.isSafeInteger(length) || length < 0) {\n      throw new Error(`Invalid ${label} length ${length}`);\n    }\n    if (offset + length > transaction.length) {\n      throw new Error(`Truncated Bitcoin transaction while reading ${label}`);\n    }\n    const value = transaction.slice(offset, offset + length);\n    offset += length;\n    return value;\n  };\n\n  const readLittleEndian = (length: number, label: string): bigint => {\n    const bytes = take(length, label);\n    let value = 0n;\n    for (let i = bytes.length - 1; i >= 0; i--) {\n      value = (value << 8n) | BigInt(bytes[i]);\n    }\n    return value;\n  };\n\n  const readCompactSize = (\n    label: string,\n  ): { encoded: Uint8Array; value: number } => {\n    const start = offset;\n    const prefix = take(1, label)[0];\n    let value: bigint;\n    if (prefix < 0xfd) {\n      value = BigInt(prefix);\n    } else if (prefix === 0xfd) {\n      value = readLittleEndian(2, label);\n      if (value < 0xfdn) throw new Error(`Non-canonical ${label}`);\n    } else if (prefix === 0xfe) {\n      value = readLittleEndian(4, label);\n      if (value <= 0xffffn) throw new Error(`Non-canonical ${label}`);\n    } else {\n      value = readLittleEndian(8, label);\n      if (value <= 0xffffffffn) throw new Error(`Non-canonical ${label}`);\n    }\n    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {\n      throw new Error(`${label} exceeds JavaScript's safe integer range`);\n    }\n    return {\n      encoded: transaction.slice(start, offset),\n      value: Number(value),\n    };\n  };\n\n  const version = take(4, \"version\");\n  const hasWitness =\n    transaction[offset] === 0x00 && transaction[offset + 1] === 0x01;\n  if (hasWitness) offset += 2;\n\n  const inputCount = readCompactSize(\"input count\");\n  const inputs: Uint8Array[] = [];\n  for (let i = 0; i < inputCount.value; i++) {\n    const start = offset;\n    take(32, `input ${i} previous transaction hash`);\n    take(4, `input ${i} previous output index`);\n    const scriptLength = readCompactSize(`input ${i} script length`);\n    take(scriptLength.value, `input ${i} script`);\n    take(4, `input ${i} sequence`);\n    inputs.push(transaction.slice(start, offset));\n  }\n\n  const outputCount = readCompactSize(\"output count\");\n  const outputs: Uint8Array[] = [];\n  for (let i = 0; i < outputCount.value; i++) {\n    const start = offset;\n    take(8, `output ${i} value`);\n    const scriptLength = readCompactSize(`output ${i} script length`);\n    take(scriptLength.value, `output ${i} script`);\n    outputs.push(transaction.slice(start, offset));\n  }\n\n  if (hasWitness) {\n    let hasWitnessData = false;\n    for (let i = 0; i < inputCount.value; i++) {\n      const itemCount = readCompactSize(`input ${i} witness item count`);\n      hasWitnessData ||= itemCount.value > 0;\n      for (let j = 0; j < itemCount.value; j++) {\n        const itemLength = readCompactSize(\n          `input ${i} witness item ${j} length`,\n        );\n        take(itemLength.value, `input ${i} witness item ${j}`);\n      }\n    }\n    if (!hasWitnessData) {\n      throw new Error(\"Bitcoin transaction has superfluous witness marker\");\n    }\n  }\n\n  const locktime = take(4, \"locktime\");\n  if (offset !== transaction.length) {\n    throw new Error(\n      `Bitcoin transaction has ${transaction.length - offset} trailing byte(s)`,\n    );\n  }\n\n  return concatBytes([\n    version,\n    inputCount.encoded,\n    ...inputs,\n    outputCount.encoded,\n    ...outputs,\n    locktime,\n  ]);\n}\n\n/** Calculate a Bitcoin txid without importing bitcoinjs-lib. */\nexport function calculateBtcTxHash(transactionHex: string): Hex {\n  const serialized = serializeWithoutWitness(\n    decodeHex(transactionHex, \"transactionHex\"),\n  );\n  const digest = sha256(sha256(serialized));\n  digest.reverse();\n  return `0x${encodeHex(digest)}`;\n}\n\n/**\n * Derive the Solidity vault ID without loading the Rust/WASM package.\n *\n * Inputs accept an optional `0x` prefix to match the current PeginManager\n * call sites. Address validation stays strict: lowercase and valid EIP-55\n * addresses pass, while uppercase and incorrectly checksummed mixed-case\n * addresses fail. The synchronous result is lowercase hex without a prefix,\n * matching the WASM helper that this function replaces.\n */\nexport function derivePeginVaultId(\n  peginTxHash: string,\n  depositor: string,\n): string {\n  const normalizedPeginTxHash = peginTxHash.startsWith(\"0x\")\n    ? peginTxHash\n    : `0x${peginTxHash}`;\n  if (!/^0x[0-9a-fA-F]{64}$/.test(normalizedPeginTxHash)) {\n    throw new Error(\"peginTxHash must be a 32-byte hex value\");\n  }\n  const normalizedDepositor = depositor.startsWith(\"0x\")\n    ? depositor\n    : `0x${depositor}`;\n  if (!isAddress(normalizedDepositor, { strict: true })) {\n    throw new Error(`Invalid depositor Ethereum address: ${depositor}`);\n  }\n  return keccak256(\n    encodeAbiParameters(\n      [{ type: \"bytes32\" }, { type: \"address\" }],\n      [normalizedPeginTxHash as Hex, normalizedDepositor as Address],\n    ),\n  ).slice(2);\n}\n","/**\n * The single validator that mints {@link OnChainBtcPubkey}.\n *\n * Extracted from `ViemVaultRegistryReader.getVaultProviderGenesisBtcPubKey` so that\n * RFC-006 operation-key resolution can produce branded keys through exactly\n * the same checks, rather than casting past the brand. Every producer of an\n * `OnChainBtcPubkey` must go through here.\n */\n\nimport type { Hex } from \"viem\";\n\nimport type { OnChainBtcPubkey } from \"./types\";\n\n/** secp256k1's base-field prime, `2^256 - 2^32 - 977`. */\nconst SECP256K1_FIELD_PRIME =\n  0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;\n\n/** secp256k1's curve coefficient `b`, from `y^2 = x^3 + b`. */\nconst SECP256K1_CURVE_B = 7n;\n\n/** Modular exponentiation without a crypto-library dependency. */\nfunction modPow(base: bigint, exponent: bigint, modulus: bigint): bigint {\n  let result = 1n;\n  let factor = base % modulus;\n  let remaining = exponent;\n\n  while (remaining > 0n) {\n    if ((remaining & 1n) === 1n) {\n      result = (result * factor) % modulus;\n    }\n    factor = (factor * factor) % modulus;\n    remaining >>= 1n;\n  }\n\n  return result;\n}\n\n/**\n * secp256k1's field prime is congruent to 3 mod 4, so an x-coordinate is on\n * the curve iff `(x^3 + 7)^((p + 1) / 4)` squares back to `x^3 + 7` modulo\n * p. This is the same curve-membership condition used by x-only key parsers;\n * it deliberately does not merely validate length/range.\n * `x^3 + 7` cannot be zero because `-7` is not a cubic residue in this field,\n * so the zero square-root edge case is unreachable.\n */\nfunction isSecp256k1XCoordinate(value: string): boolean {\n  const x = BigInt(`0x${value}`);\n  if (x >= SECP256K1_FIELD_PRIME) return false;\n\n  const xCubed =\n    (((x * x) % SECP256K1_FIELD_PRIME) * x) % SECP256K1_FIELD_PRIME;\n  const curveValue = (xCubed + SECP256K1_CURVE_B) % SECP256K1_FIELD_PRIME;\n  const y = modPow(\n    curveValue,\n    (SECP256K1_FIELD_PRIME + 1n) >> 2n,\n    SECP256K1_FIELD_PRIME,\n  );\n\n  return (y * y) % SECP256K1_FIELD_PRIME === curveValue;\n}\n\n/**\n * Validate a registry-returned `bytes32` as an x-only BTC pubkey and mint the\n * brand. Checks length, hex form, and secp256k1 curve membership. Returns\n * 64-char lowercase hex without the `0x` prefix.\n *\n * `label` identifies the read site in error messages (e.g.\n * `getOperationBtcKeyAtEpoch (vp=0x…, epoch=0)`), so a failure names which\n * participant and which getter produced it.\n *\n * A zero hash fails the curve check, so an unregistered operator or an epoch\n * with no bonded key surfaces as an error rather than a silent all-zero key.\n */\nexport function assertOnChainBtcPubkey(\n  value: Hex,\n  label: string,\n): OnChainBtcPubkey {\n  const lowered = value.toLowerCase();\n  if (!/^0x[0-9a-f]{64}$/.test(lowered)) {\n    throw new Error(\n      `${label} returned an unexpected value (length ${lowered.length}, prefix \"${lowered.slice(0, 2)}\")`,\n    );\n  }\n  const stripped = lowered.slice(2);\n  if (!isSecp256k1XCoordinate(stripped)) {\n    throw new Error(\n      `${label} returned a value that is not on the secp256k1 curve`,\n    );\n  }\n  return stripped as OnChainBtcPubkey;\n}\n"],"names":["decodeHex","value","label","clean","bytes","i","encodeHex","byte","concatBytes","chunks","result","length","chunk","offset","serializeWithoutWitness","transaction","take","readLittleEndian","readCompactSize","start","prefix","version","hasWitness","inputCount","inputs","scriptLength","outputCount","outputs","hasWitnessData","itemCount","j","itemLength","locktime","calculateBtcTxHash","transactionHex","serialized","digest","sha256","derivePeginVaultId","peginTxHash","depositor","normalizedPeginTxHash","normalizedDepositor","isAddress","keccak256","encodeAbiParameters","SECP256K1_FIELD_PRIME","SECP256K1_CURVE_B","modPow","base","exponent","modulus","factor","remaining","isSecp256k1XCoordinate","x","curveValue","y","assertOnChainBtcPubkey","lowered","stripped"],"mappings":"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"}

package/dist/parseFundingOutpoints-C_-PT9BT.cjs

@@ -0,0 +1,2 @@
+"use strict";const o=require("bitcoinjs-lib"),e=require("buffer");function s(r){if(!r)throw new Error("Pre-pegin transaction hex is empty");const i=r.startsWith("0x")?r.slice(2):r,t=o.Transaction.fromHex(i);if(t.ins.length===0)throw new Error("Pre-pegin transaction has no inputs");return t.ins.map(n=>({txid:Uint8Array.from(e.Buffer.from(n.hash).reverse()),vout:n.index}))}exports.parseFundingOutpointsFromTx=s;
+//# sourceMappingURL=parseFundingOutpoints-C_-PT9BT.cjs.map

package/dist/parseFundingOutpoints-C_-PT9BT.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseFundingOutpoints-C_-PT9BT.cjs","sources":["../src/tbv/core/vault-secrets/parseFundingOutpoints.ts"],"sourcesContent":["/**\n * Parse a Pre-PegIn transaction's inputs into the vault-context\n * `fundingOutpoints` shape consumed by `deriveVaultRoot`. Reverses\n * the prev-txid bytes from wire-internal little-endian to display\n * order so the derivation is byte-for-byte identical to the\n * deposit-time computation.\n *\n * @module vault-secrets/parseFundingOutpoints\n */\n\nimport { Transaction } from \"bitcoinjs-lib\";\nimport { Buffer } from \"buffer\";\n\nimport type { FundingOutpoint } from \"./context\";\n\nexport function parseFundingOutpointsFromTx(\n  unsignedTxHex: string,\n): FundingOutpoint[] {\n  if (!unsignedTxHex) {\n    throw new Error(\"Pre-pegin transaction hex is empty\");\n  }\n  const cleanHex = unsignedTxHex.startsWith(\"0x\")\n    ? unsignedTxHex.slice(2)\n    : unsignedTxHex;\n  const tx = Transaction.fromHex(cleanHex);\n  if (tx.ins.length === 0) {\n    throw new Error(\"Pre-pegin transaction has no inputs\");\n  }\n  return tx.ins.map((input) => ({\n    txid: Uint8Array.from(Buffer.from(input.hash).reverse()),\n    vout: input.index,\n  }));\n}\n"],"names":["parseFundingOutpointsFromTx","unsignedTxHex","cleanHex","tx","Transaction","input","Buffer"],"mappings":"kEAeO,SAASA,EACdC,EACmB,CACnB,GAAI,CAACA,EACH,MAAM,IAAI,MAAM,oCAAoC,EAEtD,MAAMC,EAAWD,EAAc,WAAW,IAAI,EAC1CA,EAAc,MAAM,CAAC,EACrBA,EACEE,EAAKC,EAAAA,YAAY,QAAQF,CAAQ,EACvC,GAAIC,EAAG,IAAI,SAAW,EACpB,MAAM,IAAI,MAAM,qCAAqC,EAEvD,OAAOA,EAAG,IAAI,IAAKE,IAAW,CAC5B,KAAM,WAAW,KAAKC,EAAAA,OAAO,KAAKD,EAAM,IAAI,EAAE,SAAS,EACvD,KAAMA,EAAM,KAAA,EACZ,CACJ"}

package/dist/parseFundingOutpoints-GSM-IaaK.js

@@ -0,0 +1,17 @@
+import { Transaction as i } from "bitcoinjs-lib";
+import { Buffer as e } from "buffer";
+function f(r) {
+  if (!r)
+    throw new Error("Pre-pegin transaction hex is empty");
+  const n = r.startsWith("0x") ? r.slice(2) : r, t = i.fromHex(n);
+  if (t.ins.length === 0)
+    throw new Error("Pre-pegin transaction has no inputs");
+  return t.ins.map((o) => ({
+    txid: Uint8Array.from(e.from(o.hash).reverse()),
+    vout: o.index
+  }));
+}
+export {
+  f as p
+};
+//# sourceMappingURL=parseFundingOutpoints-GSM-IaaK.js.map

package/dist/parseFundingOutpoints-GSM-IaaK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseFundingOutpoints-GSM-IaaK.js","sources":["../src/tbv/core/vault-secrets/parseFundingOutpoints.ts"],"sourcesContent":["/**\n * Parse a Pre-PegIn transaction's inputs into the vault-context\n * `fundingOutpoints` shape consumed by `deriveVaultRoot`. Reverses\n * the prev-txid bytes from wire-internal little-endian to display\n * order so the derivation is byte-for-byte identical to the\n * deposit-time computation.\n *\n * @module vault-secrets/parseFundingOutpoints\n */\n\nimport { Transaction } from \"bitcoinjs-lib\";\nimport { Buffer } from \"buffer\";\n\nimport type { FundingOutpoint } from \"./context\";\n\nexport function parseFundingOutpointsFromTx(\n  unsignedTxHex: string,\n): FundingOutpoint[] {\n  if (!unsignedTxHex) {\n    throw new Error(\"Pre-pegin transaction hex is empty\");\n  }\n  const cleanHex = unsignedTxHex.startsWith(\"0x\")\n    ? unsignedTxHex.slice(2)\n    : unsignedTxHex;\n  const tx = Transaction.fromHex(cleanHex);\n  if (tx.ins.length === 0) {\n    throw new Error(\"Pre-pegin transaction has no inputs\");\n  }\n  return tx.ins.map((input) => ({\n    txid: Uint8Array.from(Buffer.from(input.hash).reverse()),\n    vout: input.index,\n  }));\n}\n"],"names":["parseFundingOutpointsFromTx","unsignedTxHex","cleanHex","tx","Transaction","input","Buffer"],"mappings":";;AAeO,SAASA,EACdC,GACmB;AACnB,MAAI,CAACA;AACH,UAAM,IAAI,MAAM,oCAAoC;AAEtD,QAAMC,IAAWD,EAAc,WAAW,IAAI,IAC1CA,EAAc,MAAM,CAAC,IACrBA,GACEE,IAAKC,EAAY,QAAQF,CAAQ;AACvC,MAAIC,EAAG,IAAI,WAAW;AACpB,UAAM,IAAI,MAAM,qCAAqC;AAEvD,SAAOA,EAAG,IAAI,IAAI,CAACE,OAAW;AAAA,IAC5B,MAAM,WAAW,KAAKC,EAAO,KAAKD,EAAM,IAAI,EAAE,SAAS;AAAA,IACvD,MAAMA,EAAM;AAAA,EAAA,EACZ;AACJ;"}