@sundaeswap/math 0.5.0 → 0.6.0

package/dist/types/PoolMath/ConcentratedLiquidityPool.d.ts

@@ -1,9 +1,9 @@
 import { AssetAmount, IAssetAmountMetadata } from "@sundaeswap/asset";
-import { Fraction, type TFractionLike } from "@sundaeswap/fraction";
+import { Fraction } from "@sundaeswap/fraction";
 /**
- * Holds the calculated outcome of a concentrated-liquidity swap. Mirrors
- * {@link ConstantProductPool.TSwapOutcome} so it flows through the same generic
- * swap-outcome consumers.
+ * Holds the calculated outcome of a concentrated-liquidity swap. It has the
+ * same shape as `ConstantProductPool.TSwapOutcome`, so the generic
+ * swap-outcome consumers accept it.
  */
 export type TSwapOutcome = {
     input: bigint;
@@ -13,48 +13,234 @@ export type TSwapOutcome = {
     nextOutputReserve: bigint;
     priceImpact: Fraction;
 };
-/** A sqrt-price bound from the CL config, as an exact rational `[num, den]`. */
-export type TSqrtPrice = [bigint, bigint];
 /**
- * Calculate the swap outcome for a concentrated-liquidity pool.
+ * Concentrated liquidity: Sundae v4's ladder invariant.
  *
- * @param inputMetadata Metadata for the supplied (input) asset — used for the fee AssetAmount.
- * @param input The pre-fee amount of the input asset being swapped.
- * @param aReserve The pool's raw reserve of asset A.
- * @param bReserve The pool's raw reserve of asset B.
- * @param totalLp The pool's total LP supply (the virtual liquidity `L`).
- * @param sqrtPriceA The lower sqrt-price bound `[num, den]` from the CL config.
- * @param sqrtPriceB The upper sqrt-price bound `[num, den]` from the CL config.
- * @param fee The liquidity-provider fee (plus protocol fee) as a fraction.
- * @param isAInput True when asset A is the supplied asset (A→B swap).
- * @returns The swap details in the shared {@link TSwapOutcome} shape.
- */
-export declare const getSwapOutput: (inputMetadata: IAssetAmountMetadata, input: bigint, aReserve: bigint, bReserve: bigint, totalLp: bigint, sqrtPriceA: TSqrtPrice, sqrtPriceB: TSqrtPrice, fee: TFractionLike, isAInput: boolean) => TSwapOutcome;
-/**
- * Calculate the minimal input required to receive a given output — the inverse
- * of {@link getSwapOutput}. The forward swap is linear-fractional in the
- * effective input, so it inverts in closed form; a short correction loop
- * absorbs the fee floor and integer rounding so the result is the exact minimal
- * input whose forward swap yields at least `output`.
- */
-export declare const getSwapInput: (inputMetadata: IAssetAmountMetadata, output: bigint, aReserve: bigint, bReserve: bigint, totalLp: bigint, sqrtPriceA: TSqrtPrice, sqrtPriceB: TSqrtPrice, fee: TFractionLike, isAInput: boolean) => TSwapOutcome;
-/**
- * Deposit LP estimate for a concentrated-liquidity pool. CL deposits reuse the
- * constant-product *proportional* pinning: minting by the scarcest offered
- * asset and ceil-pinning the reserve deltas gives, per asset,
- * `a1·L0 ≥ a0·L1` and `b1·L0 ≥ b0·L1` — and those two bounds multiply to
- * exactly the on-chain CL non-swap invariant `va1·vb1·L0² ≥ va0·vb0·L1²`
- * (`cl_check.ak`). So the proportional deposit is always chain-valid; excess of
- * either asset is refunded via aChange/bChange. This mirrors the scooper's
- * `resolve_cl_deposit` (which likewise reuses the CP pinning).
- */
-export declare const calculateLiquidity: (a: bigint, b: bigint, aReserve: bigint, bReserve: bigint, totalLp: bigint) => {
-    nextTotalLp: bigint;
-    generatedLp: bigint;
-    shareAfterDeposit: Fraction;
-    bChange: bigint;
-    aChange: bigint;
-    actualDepositedA: bigint;
-    actualDepositedB: bigint;
+ * A pool is a ladder of bands in ascending sqrt-price order. Each band is a
+ * concentrated-liquidity arc (`curve` 0) or a constant-sum bin (`curve` 1)
+ * with its own share of the pool's liquidity (`weight / weightTotal`) and
+ * its own two fees. LP is one fungible token for the whole ladder; a
+ * deposit or withdrawal scales every band.
+ *
+ * The chain never stores the price. It stores reserves, and the state is a
+ * WITNESS `(X, k)`: the ladder counter `X` (the pool's `total_lp`, spec V12)
+ * and the active band `k`, which the reserves must prove. Everything here
+ * mirrors `lib/modules/cl_check.ak` and the scooper's ladder
+ * math, rounding included; where they disagree the chain wins
+ * and the transaction fails. The rounding is not negotiable:
+ *
+ *   - `L_k` floors; saturation ceils, in ONE division;
+ *   - the band fee ceils, per step, on the step's real input;
+ *   - the prefix sums come from the LADDER INDEX (cumulative coefficients
+ *     in fixed point at 2^64, spec §2.3), multiplied by the counter and
+ *     ceiled ONCE. A per-band sum of ceilings is a different number and the
+ *     chain rejects it.
+ */
+/** An exact rational `num / den`. */
+export type TFrac = {
+    num: bigint;
+    den: bigint;
+};
+/** One band of the ladder. */
+export type TBand = {
+    /** The band's LOWER sqrt-price edge. The next band's `start` is its upper edge. */
+    start: TFrac;
+    /** The band's share of the ladder's liquidity counter. */
+    weight: bigint;
+    /** 0 = concentrated-liquidity arc, 1 = constant-sum bin. */
+    curve: 0 | 1;
+    /** Fee on swaps that buy the pool's first asset (B in). */
+    feeBuy: TFrac;
+    /** Fee on swaps that sell the pool's first asset (A in). */
+    feeSell: TFrac;
+};
+/** A ladder: bands, the top edge, and the sum of the weights. */
+export type TLadder = {
+    bands: TBand[];
+    /** The last band's UPPER sqrt-price edge. */
+    closing: TFrac;
+    weightTotal: bigint;
+};
+/** The witness the chain checks: the ladder counter and the active band. */
+export type TWitness = {
+    x: bigint;
+    k: number;
 };
+/** 2^64, the fixed-point scale of the ladder index. */
+export declare const FIXED_ONE: bigint;
+/**
+ * The least counter per unit of weight a ladder may be created with.
+ * Mirrors `cl_check.min_counter_per_weight` (sundae-v4 #229, SV4-007):
+ * Create requires `total_lp >= MIN_COUNTER_PER_WEIGHT * weightTotal`.
+ */
+export declare const MIN_COUNTER_PER_WEIGHT = 1000n;
+/** The least counter (initial `total_lp`) the chain accepts at Create for `ladder`. */
+export declare const minCreateCounter: (ladder: TLadder) => bigint;
+/** Band i's upper sqrt-price edge. */
+export declare const upperEdge: (l: TLadder, i: number) => TFrac;
+/** `D_i = hi.num·lo.den − lo.num·hi.den`: positive exactly when the edges increase. */
+export declare const delta: (lo: TFrac, hi: TFrac) => bigint;
+/** `a_sat_i = ceil(w_i·X·D_i / (W·lo.num·hi.num))`: the A a band above the price holds. */
+export declare const aSat: (l: TLadder, x: bigint, i: number) => bigint;
+/** `b_sat_i = ceil(w_i·X·D_i / (W·lo.den·hi.den))`: the B a band below the price holds. */
+export declare const bSat: (l: TLadder, x: bigint, i: number) => bigint;
+/** `L_k = floor(w_k·X / W)`. */
+export declare const liquidityOf: (l: TLadder, x: bigint, k: number) => bigint;
+/** Band i's A-side saturation coefficient: the part of `a_sat_i` independent of X, rounded up. */
+export declare const coeffA: (l: TLadder, i: number) => bigint;
+/** The same on the B side. */
+export declare const coeffB: (l: TLadder, i: number) => bigint;
+/** One index entry: the cumulative coefficients above and below band k. */
+export type TIndexEntry = {
+    ca: bigint;
+    cb: bigint;
+};
+/**
+ * The ladder index `Create` pins and every spend reads: entry k is the pair
+ * of cumulative coefficients for the bands strictly above and strictly
+ * below band k. `cl_check.build_index`, to the digit.
+ */
+export declare const buildIndex: (l: TLadder) => TIndexEntry[];
+/**
+ * A ladder with its index built once. Every probe of the witness search
+ * reads the index for every band, and rebuilding it per probe is most of
+ * the cost of a quote.
+ */
+export type TIndexedLadder = TLadder & {
+    index: TIndexEntry[];
+};
+export declare const indexLadder: (l: TLadder) => TIndexedLadder;
+/** `C_A`, `C_B` at (X, k) from the index: one ceiling after the multiply by X. */
+export declare const prefixes: (l: TIndexedLadder, x: bigint, k: number) => {
+    ca: bigint;
+    cb: bigint;
+};
+/** The band proof, P1 through P7. The chain runs exactly this. */
+export declare const bandProof: (l: TIndexedLadder, A: bigint, B: bigint, x: bigint, k: number) => boolean;
+/**
+ * The witness in band k, seeded at `hint` when given: the counter only
+ * grows along a swap, so the doubling search starts from the previous
+ * witness. `lo` is the largest x with non-negative residuals and G ≥ 0,
+ * and a witness is such an x whose successor fails G, so the scan walks
+ * DOWN from `lo` first. Mirrors the scooper's `find_witness_in_band_from`.
+ */
+export declare const findWitnessInBand: (l: TIndexedLadder, A: bigint, B: bigint, k: number, hint?: bigint) => TWitness | null;
+/**
+ * The witness `(X, k)` for a pool's reserves. A hint (the indexed
+ * `bandCounter` / `activeBand`) is checked first and seeds the search in
+ * its band; a stale hint falls back to every band. Null when the reserves
+ * sit on no point of the ladder — the chain would reject them too.
+ */
+export declare const findWitness: (ladder: TLadder, A: bigint, B: bigint, hint?: TWitness) => TWitness | null;
+/** The active band's view at a witness: its residual reserves and liquidity. */
+export type TBandView = {
+    ra: bigint;
+    rb: bigint;
+    l: bigint;
+    lo: TFrac;
+    hi: TFrac;
+    curve: 0 | 1;
+    feeBuy: TFrac;
+    feeSell: TFrac;
+};
+export declare const bandView: (l: TIndexedLadder, A: bigint, B: bigint, w: TWitness) => TBandView;
+/** The band's fee for a direction: `feeSell` when A is sold, `feeBuy` when A is bought. */
+export declare const feeFor: (v: TBandView, isAInput: boolean) => TFrac;
+/**
+ * The band fee on a step's real input `dx`: `ceil(dx * num / den)`.
+ * Mirrors `cl_check.band_fee` (sundae-v4 #228, SV4-006). The chain charges
+ * it per transcript step and rounds it UP, so a step below `den / num`
+ * units still pays one unit. A zero rate charges nothing.
+ */
+export declare const bandFee: (dx: bigint, fee: TFrac) => bigint;
+/** The output one band pays for `dx` within itself. Mirrors the scooper's `band_output`. */
+export declare const bandOutput: (v: TBandView, isAInput: boolean, dx: bigint) => bigint;
+/** What the band can pay out in a direction: its residual of the output asset. */
+export declare const bandCapacity: (v: TBandView, isAInput: boolean) => bigint;
+/** The largest input whose output stays within the band. */
+export declare const maxDxInBand: (v: TBandView, isAInput: boolean) => bigint;
+/** The next band a fill enters: selling A walks down the ladder, buying A walks up. */
+export declare const nextBand: (k: number, isAInput: boolean, n: number) => number | null;
+/** One band of a fill: what it paid, and the state it left. */
+export type TFillStep = {
+    band: number;
+    input: bigint;
+    output: bigint;
+    after: TWitness;
+};
+/**
+ * Price `dx` across as many bands as it takes, as the scooper's
+ * `swap_steps` does: fill the active band, cross to the next, repeat.
+ * Returns the steps, or null when the ladder cannot absorb `dx` (the
+ * direction is exhausted, or the remainder pays nothing).
+ */
+export declare const swapSteps: (ladder: TLadder, A: bigint, B: bigint, isAInput: boolean, dx: bigint, hint?: TWitness) => TFillStep[] | null;
+/**
+ * The swap output of a concentrated-liquidity pool for `input` of one asset, crossing
+ * bands as needed. `aReserve`/`bReserve` are the pool's reserves in
+ * canonical order; `hint` is the indexed `bandCounter` / `activeBand`,
+ * which seeds the witness search and may be stale.
+ *
+ * The `lpFee` is the fee the bands kept of the input, summed across the
+ * steps. `priceImpact` is against the active band's opening marginal
+ * price. Throws when the ladder cannot absorb the input.
+ */
+export declare const getSwapOutput: (inputMetadata: IAssetAmountMetadata, input: bigint, aReserve: bigint, bReserve: bigint, ladder: TLadder, isAInput: boolean, hint?: TWitness) => TSwapOutcome & {
+    steps: TFillStep[];
+};
+/** What each band holds at the pool's reserves. */
+export type TBandState = {
+    /** The band's reserves in canonical order. The bands sum to the pool's reserves. */
+    quantities: [bigint, bigint];
+    liquidity: bigint;
+    active: boolean;
+};
+/**
+ * Every band's state at the pool's reserves: a band below the price holds
+ * only B, a band above it only A, the active band some of both. Null when
+ * the reserves sit on no point of the ladder.
+ */
+export declare const bandStates: (ladder: TLadder, aReserve: bigint, bReserve: bigint, hint?: TWitness) => TBandState[] | null;
+/** Which band holds a sqrt-price. */
+export declare const bandOf: (l: TLadder, s: TFrac) => number;
+/**
+ * The exact reserves a ladder holds at counter `x` with the price at
+ * sqrt-price `s`, which must lie in band `k`: what a pool creator deposits
+ * for a chosen shape, scale and launch price. The result is floored, so
+ * `findWitness` must still be run on it to learn the counter the chain
+ * derives — usually `x`, but rounding can move it.
+ */
+export declare const reservesAt: (l: TLadder, x: bigint, k: number, s: TFrac) => {
+    A: bigint;
+    B: bigint;
+};
+/**
+ * An equal-weight ladder of `n` bands from `lo` to `hi`, every band a CL
+ * arc at `fee` unless named in `curves`. The edges are built over a common
+ * denominator and reduced: every rational component of a concentrated-liquidity config
+ * must stay below 2^64 (spec V9).
+ */
+export declare const uniformLadder: (n: number, lo: TFrac, hi: TFrac, fee: TFrac, curves?: (0 | 1)[]) => TLadder;
+/** Band weight profiles. Every weight is at least 1, as `Create` demands. */
+export type TWeightShape = "flat" | "concentrated" | "skewed-low" | "skewed-high" | "bimodal";
+export declare const bandWeights: (n: number, shape?: TWeightShape, opts?: {
+    centre?: number;
+    peak?: bigint;
+    tail?: bigint;
+}) => bigint[];
+/**
+ * A ladder of `n` bands from `lo` to `hi` with a weight shape, optional
+ * constant-sum bins and an optional per-band fee. The edges are
+ * `uniformLadder`'s exactly; only the weights, curves and fees differ.
+ */
+export declare const shapedLadder: (n: number, lo: TFrac, hi: TFrac, fee: TFrac, opts?: {
+    shape?: TWeightShape;
+    centre?: number;
+    peak?: bigint;
+    tail?: bigint;
+    /** Zero-based band indices to price as constant-sum bins. */
+    csBands?: number[];
+    /** Overrides `fee` per band. */
+    feeAt?: (i: number) => TFrac;
+}) => TLadder;
 //# sourceMappingURL=ConcentratedLiquidityPool.d.ts.map

package/dist/types/PoolMath/ConcentratedLiquidityPool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConcentratedLiquidityPool.d.ts","sourceRoot":"","sources":["../../../src/PoolMath/ConcentratedLiquidityPool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAIpE;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,WAAW,CAAC,oBAAoB,CAAC,CAAC;IACzC,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,WAAW,EAAE,QAAQ,CAAC;CACvB,CAAC;AAEF,gFAAgF;AAChF,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AA2D1C;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa,kBACT,oBAAoB,SAC5B,MAAM,YACH,MAAM,YACN,MAAM,WACP,MAAM,cACH,UAAU,cACV,UAAU,OACjB,aAAa,YACR,OAAO,KAChB,YAuDF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,kBACR,oBAAoB,UAC3B,MAAM,YACJ,MAAM,YACN,MAAM,WACP,MAAM,cACH,UAAU,cACV,UAAU,OACjB,aAAa,YACR,OAAO,KAChB,YA+EF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,MAC1B,MAAM,KACN,MAAM,YACC,MAAM,YACN,MAAM,WACP,MAAM;;;;;;;;CAC6D,CAAC"}
+{"version":3,"file":"ConcentratedLiquidityPool.d.ts","sourceRoot":"","sources":["../../../src/PoolMath/ConcentratedLiquidityPool.ts"],"names":[],"mappings":"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"}

package/dist/types/PoolMath/StableSwapsPool.d.ts

@@ -180,17 +180,18 @@ export type TSwapOutcome = {
  */
 export declare const getSwapOutput: (outputMetadata: IAssetAmountMetadata, input: bigint, inputReserve: bigint, outputReserve: bigint, fee: TFractionLike, protocolFee: TFractionLike, laf: bigint, roundOutputUp?: boolean) => TSwapOutcome;
 /**
- * Calculates the current price (exchange rate) of asset A in terms of asset B for a Stableswaps pool.
- * The price is derived from the Stableswaps curve equation and takes into account the amplification factor.
+ * The pool's marginal price as raw units of asset A per raw unit of asset B,
+ * |dx/dy| at the current reserves. This is the "ideal" price that swap price
+ * impact is measured against.
  *
- * The calculation uses the formula:
+ * Derived from the Stableswaps invariant 4A(x + y) + D = 4AD + D^3 / (4xy):
  * price = (xpA + (dR * aReserve) / bReserve) / (xpA + dR)
- * where xpA = (Ann * aReserve) / A_PRECISION and dR is derived from the sum invariant
+ * where xpA = 4 * laf * aReserve and dR = D^3 / (4 * aReserve * bReserve)
  *
  * @param {bigint} aReserve - The current reserve amount of asset A in the pool.
  * @param {bigint} bReserve - The current reserve amount of asset B in the pool.
  * @param {bigint} laf - The linear amplification factor of the pool.
- * @returns {Fraction} The price of asset A in terms of asset B as a Fraction.
+ * @returns {Fraction} Raw A per raw B at the current reserves.
  */
 export declare function getPrice(aReserve: bigint, bReserve: bigint, laf: bigint): Fraction;
 /**

package/dist/types/PoolMath/StableSwapsPool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StableSwapsPool.d.ts","sourceRoot":"","sources":["../../../src/PoolMath/StableSwapsPool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAEpE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,mBAAmB,EAAE,MAAM,EAC3B,eAAe,EAAE,MAAM,WAsBxB;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,MAAa,CAAC;AAExC;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAA2B,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,MAAgB,CAAC;AAE7C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAyCvE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CACrB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,GACnB,MAAM,CAkCR;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,MAAO,MAAM,KAAK,MAAM,OAAO,MAAM,WACZ,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,kBAAkB,MAC1B,MAAM,KACN,MAAM,YACC,MAAM,YACN,MAAM,WACP,MAAM,OACV,MAAM;;;;;;;;CA4BZ,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,OACrB,MAAM,YACA,MAAM,YACN,MAAM,WACP,MAAM,KACd,cAAc,CAAC,KAGjB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,KAAK,EAAE,WAAW,CAAC,oBAAoB,CAAC,CAAC;IACzC,oDAAoD;IACpD,WAAW,EAAE,WAAW,CAAC,oBAAoB,CAAC,CAAC;IAC/C,oDAAoD;IACpD,gBAAgB,EAAE,MAAM,CAAC;IACzB,+EAA+E;IAC/E,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kDAAkD;IAClD,gBAAgB,EAAE,MAAM,CAAC;IACzB,6FAA6F;IAC7F,WAAW,EAAE,QAAQ,CAAC;CACvB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,aAAa,mBACR,oBAAoB,SAC7B,MAAM,gBACC,MAAM,iBACL,MAAM,OAChB,aAAa,eACL,aAAa,OACrB,MAAM,kBACK,OAAO,KACtB,YAuDF,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,GACV,QAAQ,CAYV;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,YAAY,mBACP,oBAAoB,UAC5B,MAAM,gBACA,MAAM,iBACL,MAAM,OAChB,aAAa,eACL,aAAa,OACrB,MAAM,KACV,YAoEF,CAAC"}
+{"version":3,"file":"StableSwapsPool.d.ts","sourceRoot":"","sources":["../../../src/PoolMath/StableSwapsPool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAEpE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,mBAAmB,EAAE,MAAM,EAC3B,eAAe,EAAE,MAAM,WAsBxB;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,MAAa,CAAC;AAExC;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAA2B,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,MAAgB,CAAC;AAE7C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAyCvE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CACrB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,GACnB,MAAM,CAkCR;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,MAAO,MAAM,KAAK,MAAM,OAAO,MAAM,WACZ,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,kBAAkB,MAC1B,MAAM,KACN,MAAM,YACC,MAAM,YACN,MAAM,WACP,MAAM,OACV,MAAM;;;;;;;;CA4BZ,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,OACrB,MAAM,YACA,MAAM,YACN,MAAM,WACP,MAAM,KACd,cAAc,CAAC,KAGjB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,KAAK,EAAE,WAAW,CAAC,oBAAoB,CAAC,CAAC;IACzC,oDAAoD;IACpD,WAAW,EAAE,WAAW,CAAC,oBAAoB,CAAC,CAAC;IAC/C,oDAAoD;IACpD,gBAAgB,EAAE,MAAM,CAAC;IACzB,+EAA+E;IAC/E,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kDAAkD;IAClD,gBAAgB,EAAE,MAAM,CAAC;IACzB,6FAA6F;IAC7F,WAAW,EAAE,QAAQ,CAAC;CACvB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,aAAa,mBACR,oBAAoB,SAC7B,MAAM,gBACC,MAAM,iBACL,MAAM,OAChB,aAAa,eACL,aAAa,OACrB,MAAM,kBACK,OAAO,KACtB,YAuDF,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,GACV,QAAQ,CAWV;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,YAAY,mBACP,oBAAoB,UAC5B,MAAM,gBACA,MAAM,iBACL,MAAM,OAChB,aAAa,eACL,aAAa,OACrB,MAAM,KACV,YAoEF,CAAC"}