@pancakeswap/swap-sdk-core 0.0.1 → 1.0.0

package/dist/index.js

@@ -1,63 +1,18 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
+
+var invariant6 = require('tiny-invariant');
+var _Decimal = require('decimal.js-light');
+var _Big = require('big.js');
+var toFormat = require('toformat');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  BaseCurrency: () => BaseCurrency,
-  CurrencyAmount: () => CurrencyAmount,
-  FIVE: () => FIVE,
-  Fraction: () => Fraction,
-  InsufficientInputAmountError: () => InsufficientInputAmountError,
-  InsufficientReservesError: () => InsufficientReservesError,
-  JSBI: () => import_jsbi7.default,
-  MINIMUM_LIQUIDITY: () => MINIMUM_LIQUIDITY,
-  MaxUint256: () => MaxUint256,
-  NativeCurrency: () => NativeCurrency,
-  ONE: () => ONE,
-  Percent: () => Percent,
-  Price: () => Price,
-  Rounding: () => Rounding,
-  TEN: () => TEN,
-  THREE: () => THREE,
-  TWO: () => TWO,
-  Token: () => Token,
-  TradeType: () => TradeType,
-  VMType: () => VMType,
-  VM_TYPE_MAXIMA: () => VM_TYPE_MAXIMA,
-  ZERO: () => ZERO,
-  _100: () => _100,
-  _10000: () => _10000,
-  _9975: () => _9975,
-  computePriceImpact: () => computePriceImpact,
-  sortedInsert: () => sortedInsert,
-  sqrt: () => sqrt,
-  validateVMTypeInstance: () => validateVMTypeInstance
-});
-module.exports = __toCommonJS(src_exports);
-var import_jsbi7 = __toESM(require("jsbi"));
+var invariant6__default = /*#__PURE__*/_interopDefault(invariant6);
+var _Decimal__default = /*#__PURE__*/_interopDefault(_Decimal);
+var _Big__default = /*#__PURE__*/_interopDefault(_Big);
+var toFormat__default = /*#__PURE__*/_interopDefault(toFormat);
 
 // src/constants.ts
-var import_jsbi = __toESM(require("jsbi"));
 var TradeType = /* @__PURE__ */ ((TradeType2) => {
   TradeType2[TradeType2["EXACT_INPUT"] = 0] = "EXACT_INPUT";
   TradeType2[TradeType2["EXACT_OUTPUT"] = 1] = "EXACT_OUTPUT";
@@ -69,48 +24,45 @@ var Rounding = /* @__PURE__ */ ((Rounding2) => {
   Rounding2[Rounding2["ROUND_UP"] = 2] = "ROUND_UP";
   return Rounding2;
 })(Rounding || {});
-var MINIMUM_LIQUIDITY = import_jsbi.default.BigInt(1e3);
-var ZERO = import_jsbi.default.BigInt(0);
-var ONE = import_jsbi.default.BigInt(1);
-var TWO = import_jsbi.default.BigInt(2);
-var THREE = import_jsbi.default.BigInt(3);
-var FIVE = import_jsbi.default.BigInt(5);
-var TEN = import_jsbi.default.BigInt(10);
-var _100 = import_jsbi.default.BigInt(100);
-var _9975 = import_jsbi.default.BigInt(9975);
-var _10000 = import_jsbi.default.BigInt(1e4);
-var MaxUint256 = import_jsbi.default.BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-var VMType = /* @__PURE__ */ ((VMType2) => {
-  VMType2["uint8"] = "uint8";
-  VMType2["uint256"] = "uint256";
-  return VMType2;
+var MINIMUM_LIQUIDITY = 1000n;
+var ZERO = 0n;
+var ONE = 1n;
+var TWO = 2n;
+var THREE = 3n;
+var FIVE = 5n;
+var TEN = 10n;
+var _100 = 100n;
+var _9975 = 9975n;
+var _10000 = 10000n;
+var MaxUint256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+var VMType = /* @__PURE__ */ ((VMType3) => {
+  VMType3["uint8"] = "uint8";
+  VMType3["uint256"] = "uint256";
+  return VMType3;
 })(VMType || {});
 var VM_TYPE_MAXIMA = {
-  ["uint8" /* uint8 */]: import_jsbi.default.BigInt("0xff"),
-  ["uint256" /* uint256 */]: import_jsbi.default.BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
+  ["uint8" /* uint8 */]: BigInt("0xff"),
+  ["uint256" /* uint256 */]: BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
 };
-
-// src/baseCurrency.ts
-var import_tiny_invariant = __toESM(require("tiny-invariant"));
 var BaseCurrency = class {
+  /**
+   * Constructs an instance of the base class `BaseCurrency`.
+   * @param chainId the chain ID on which this currency resides
+   * @param decimals decimals of the currency
+   * @param symbol symbol of the currency
+   * @param name of the currency
+   */
   constructor(chainId, decimals, symbol, name) {
-    (0, import_tiny_invariant.default)(Number.isSafeInteger(chainId), "CHAIN_ID");
-    (0, import_tiny_invariant.default)(decimals >= 0 && decimals < 255 && Number.isInteger(decimals), "DECIMALS");
+    invariant6__default.default(Number.isSafeInteger(chainId), "CHAIN_ID");
+    invariant6__default.default(decimals >= 0 && decimals < 255 && Number.isInteger(decimals), "DECIMALS");
     this.chainId = chainId;
     this.decimals = decimals;
     this.symbol = symbol;
     this.name = name;
   }
 };
-
-// src/fractions/fraction.ts
-var import_jsbi2 = __toESM(require("jsbi"));
-var import_tiny_invariant2 = __toESM(require("tiny-invariant"));
-var import_decimal = __toESM(require("decimal.js-light"));
-var import_big = __toESM(require("big.js"));
-var import_toformat = __toESM(require("toformat"));
-var Decimal = (0, import_toformat.default)(import_decimal.default);
-var Big = (0, import_toformat.default)(import_big.default);
+var Decimal = toFormat__default.default(_Decimal__default.default);
+var Big = toFormat__default.default(_Big__default.default);
 var toSignificantRounding = {
   [0 /* ROUND_DOWN */]: Decimal.ROUND_DOWN,
   [1 /* ROUND_HALF_UP */]: Decimal.ROUND_HALF_UP,
@@ -122,88 +74,101 @@ var toFixedRounding = {
   [2 /* ROUND_UP */]: 3 /* RoundUp */
 };
 var Fraction = class {
-  constructor(numerator, denominator = import_jsbi2.default.BigInt(1)) {
-    this.numerator = import_jsbi2.default.BigInt(numerator);
-    this.denominator = import_jsbi2.default.BigInt(denominator);
+  constructor(numerator, denominator = 1n) {
+    this.numerator = BigInt(numerator);
+    this.denominator = BigInt(denominator);
   }
   static tryParseFraction(fractionish) {
-    if (fractionish instanceof import_jsbi2.default || typeof fractionish === "number" || typeof fractionish === "string")
+    if (typeof fractionish === "bigint" || typeof fractionish === "number" || typeof fractionish === "string")
       return new Fraction(fractionish);
     if ("numerator" in fractionish && "denominator" in fractionish)
       return fractionish;
     throw new Error("Could not parse fraction");
   }
+  // performs floor division
   get quotient() {
-    return import_jsbi2.default.divide(this.numerator, this.denominator);
+    return this.numerator / this.denominator;
   }
+  // remainder after floor division
   get remainder() {
-    return new Fraction(import_jsbi2.default.remainder(this.numerator, this.denominator), this.denominator);
+    return new Fraction(this.numerator % this.denominator, this.denominator);
   }
   invert() {
     return new Fraction(this.denominator, this.numerator);
   }
   add(other) {
     const otherParsed = Fraction.tryParseFraction(other);
-    if (import_jsbi2.default.equal(this.denominator, otherParsed.denominator)) {
-      return new Fraction(import_jsbi2.default.add(this.numerator, otherParsed.numerator), this.denominator);
+    if (this.denominator === otherParsed.denominator) {
+      return new Fraction(this.numerator + otherParsed.numerator, this.denominator);
     }
-    return new Fraction(import_jsbi2.default.add(import_jsbi2.default.multiply(this.numerator, otherParsed.denominator), import_jsbi2.default.multiply(otherParsed.numerator, this.denominator)), import_jsbi2.default.multiply(this.denominator, otherParsed.denominator));
+    return new Fraction(
+      this.numerator * otherParsed.denominator + otherParsed.numerator * this.denominator,
+      this.denominator * otherParsed.denominator
+    );
   }
   subtract(other) {
     const otherParsed = Fraction.tryParseFraction(other);
-    if (import_jsbi2.default.equal(this.denominator, otherParsed.denominator)) {
-      return new Fraction(import_jsbi2.default.subtract(this.numerator, otherParsed.numerator), this.denominator);
+    if (this.denominator === otherParsed.denominator) {
+      return new Fraction(this.numerator - otherParsed.numerator, this.denominator);
     }
-    return new Fraction(import_jsbi2.default.subtract(import_jsbi2.default.multiply(this.numerator, otherParsed.denominator), import_jsbi2.default.multiply(otherParsed.numerator, this.denominator)), import_jsbi2.default.multiply(this.denominator, otherParsed.denominator));
+    return new Fraction(
+      this.numerator * otherParsed.denominator - otherParsed.numerator * this.denominator,
+      this.denominator * otherParsed.denominator
+    );
   }
   lessThan(other) {
     const otherParsed = Fraction.tryParseFraction(other);
-    return import_jsbi2.default.lessThan(import_jsbi2.default.multiply(this.numerator, otherParsed.denominator), import_jsbi2.default.multiply(otherParsed.numerator, this.denominator));
+    return this.numerator * otherParsed.denominator < otherParsed.numerator * this.denominator;
   }
   equalTo(other) {
     const otherParsed = Fraction.tryParseFraction(other);
-    return import_jsbi2.default.equal(import_jsbi2.default.multiply(this.numerator, otherParsed.denominator), import_jsbi2.default.multiply(otherParsed.numerator, this.denominator));
+    return this.numerator * otherParsed.denominator === otherParsed.numerator * this.denominator;
   }
   greaterThan(other) {
     const otherParsed = Fraction.tryParseFraction(other);
-    return import_jsbi2.default.greaterThan(import_jsbi2.default.multiply(this.numerator, otherParsed.denominator), import_jsbi2.default.multiply(otherParsed.numerator, this.denominator));
+    return this.numerator * otherParsed.denominator > otherParsed.numerator * this.denominator;
   }
   multiply(other) {
     const otherParsed = Fraction.tryParseFraction(other);
-    return new Fraction(import_jsbi2.default.multiply(this.numerator, otherParsed.numerator), import_jsbi2.default.multiply(this.denominator, otherParsed.denominator));
+    return new Fraction(this.numerator * otherParsed.numerator, this.denominator * otherParsed.denominator);
   }
   divide(other) {
     const otherParsed = Fraction.tryParseFraction(other);
-    return new Fraction(import_jsbi2.default.multiply(this.numerator, otherParsed.denominator), import_jsbi2.default.multiply(this.denominator, otherParsed.numerator));
+    return new Fraction(this.numerator * otherParsed.denominator, this.denominator * otherParsed.numerator);
   }
   toSignificant(significantDigits, format = { groupSeparator: "" }, rounding = 1 /* ROUND_HALF_UP */) {
-    (0, import_tiny_invariant2.default)(Number.isInteger(significantDigits), `${significantDigits} is not an integer.`);
-    (0, import_tiny_invariant2.default)(significantDigits > 0, `${significantDigits} is not positive.`);
+    invariant6__default.default(Number.isInteger(significantDigits), `${significantDigits} is not an integer.`);
+    invariant6__default.default(significantDigits > 0, `${significantDigits} is not positive.`);
     Decimal.set({ precision: significantDigits + 1, rounding: toSignificantRounding[rounding] });
     const quotient = new Decimal(this.numerator.toString()).div(this.denominator.toString()).toSignificantDigits(significantDigits);
     return quotient.toFormat(quotient.decimalPlaces(), format);
   }
   toFixed(decimalPlaces, format = { groupSeparator: "" }, rounding = 1 /* ROUND_HALF_UP */) {
-    (0, import_tiny_invariant2.default)(Number.isInteger(decimalPlaces), `${decimalPlaces} is not an integer.`);
-    (0, import_tiny_invariant2.default)(decimalPlaces >= 0, `${decimalPlaces} is negative.`);
+    invariant6__default.default(Number.isInteger(decimalPlaces), `${decimalPlaces} is not an integer.`);
+    invariant6__default.default(decimalPlaces >= 0, `${decimalPlaces} is negative.`);
     Big.DP = decimalPlaces;
     Big.RM = toFixedRounding[rounding];
     return new Big(this.numerator.toString()).div(this.denominator.toString()).toFormat(decimalPlaces, format);
   }
+  /**
+   * Helper method for converting any super class back to a fraction
+   */
   get asFraction() {
     return new Fraction(this.numerator, this.denominator);
   }
 };
 
 // src/fractions/percent.ts
-var import_jsbi3 = __toESM(require("jsbi"));
-var ONE_HUNDRED = new Fraction(import_jsbi3.default.BigInt(100));
+var ONE_HUNDRED = new Fraction(100n);
 function toPercent(fraction) {
   return new Percent(fraction.numerator, fraction.denominator);
 }
 var Percent = class extends Fraction {
   constructor() {
     super(...arguments);
+    /**
+     * This boolean prevents a fraction from being interpreted as a Percent
+     */
     this.isPercent = true;
   }
   add(other) {
@@ -225,33 +190,38 @@ var Percent = class extends Fraction {
     return super.multiply(ONE_HUNDRED).toFixed(decimalPlaces, format, rounding);
   }
 };
-
-// src/fractions/currencyAmount.ts
-var import_tiny_invariant3 = __toESM(require("tiny-invariant"));
-var import_jsbi4 = __toESM(require("jsbi"));
-var import_big2 = __toESM(require("big.js"));
-var import_toformat2 = __toESM(require("toformat"));
-var Big2 = (0, import_toformat2.default)(import_big2.default);
+var Big2 = toFormat__default.default(_Big__default.default);
 var CurrencyAmount = class extends Fraction {
   constructor(currency, numerator, denominator) {
     super(numerator, denominator);
-    (0, import_tiny_invariant3.default)(import_jsbi4.default.lessThanOrEqual(this.quotient, MaxUint256), "AMOUNT");
+    invariant6__default.default(this.quotient <= MaxUint256, "AMOUNT");
     this.currency = currency;
-    this.decimalScale = import_jsbi4.default.exponentiate(import_jsbi4.default.BigInt(10), import_jsbi4.default.BigInt(currency.decimals));
+    this.decimalScale = 10n ** BigInt(currency.decimals);
   }
+  /**
+   * Returns a new currency amount instance from the unitless amount of token, i.e. the raw amount
+   * @param currency the currency in the amount
+   * @param rawAmount the raw token or ether amount
+   */
   static fromRawAmount(currency, rawAmount) {
     return new CurrencyAmount(currency, rawAmount);
   }
+  /**
+   * Construct a currency amount with a denominator that is not equal to 1
+   * @param currency the currency
+   * @param numerator the numerator of the fractional token amount
+   * @param denominator the denominator of the fractional token amount
+   */
   static fromFractionalAmount(currency, numerator, denominator) {
     return new CurrencyAmount(currency, numerator, denominator);
   }
   add(other) {
-    (0, import_tiny_invariant3.default)(this.currency.equals(other.currency), "CURRENCY");
+    invariant6__default.default(this.currency.equals(other.currency), "CURRENCY");
     const added = super.add(other);
     return CurrencyAmount.fromFractionalAmount(this.currency, added.numerator, added.denominator);
   }
   subtract(other) {
-    (0, import_tiny_invariant3.default)(this.currency.equals(other.currency), "CURRENCY");
+    invariant6__default.default(this.currency.equals(other.currency), "CURRENCY");
     const subtracted = super.subtract(other);
     return CurrencyAmount.fromFractionalAmount(this.currency, subtracted.numerator, subtracted.denominator);
   }
@@ -267,7 +237,7 @@ var CurrencyAmount = class extends Fraction {
     return super.divide(this.decimalScale).toSignificant(significantDigits, format, rounding);
   }
   toFixed(decimalPlaces = this.currency.decimals, format, rounding = 0 /* ROUND_DOWN */) {
-    (0, import_tiny_invariant3.default)(decimalPlaces <= this.currency.decimals, "DECIMALS");
+    invariant6__default.default(decimalPlaces <= this.currency.decimals, "DECIMALS");
     return super.divide(this.decimalScale).toFixed(decimalPlaces, format, rounding);
   }
   toExact(format = { groupSeparator: "" }) {
@@ -280,18 +250,18 @@ var CurrencyAmount = class extends Fraction {
     return CurrencyAmount.fromFractionalAmount(this.currency.wrapped, this.numerator, this.denominator);
   }
 };
-
-// src/fractions/price.ts
-var import_jsbi5 = __toESM(require("jsbi"));
-var import_tiny_invariant4 = __toESM(require("tiny-invariant"));
 var Price = class extends Fraction {
+  // used to adjust the raw fraction w/r/t the decimals of the {base,quote}Token
+  /**
+   * Construct a price, either with the base and quote currency amount, or the
+   * @param args
+   */
   constructor(...args) {
     let baseCurrency;
     let quoteCurrency;
     let denominator;
     let numerator;
     if (args.length === 4) {
-      ;
       [baseCurrency, quoteCurrency, denominator, numerator] = args;
     } else {
       const result = args[0].quoteAmount.divide(args[0].baseAmount);
@@ -305,21 +275,36 @@ var Price = class extends Fraction {
     super(numerator, denominator);
     this.baseCurrency = baseCurrency;
     this.quoteCurrency = quoteCurrency;
-    this.scalar = new Fraction(import_jsbi5.default.exponentiate(import_jsbi5.default.BigInt(10), import_jsbi5.default.BigInt(baseCurrency.decimals)), import_jsbi5.default.exponentiate(import_jsbi5.default.BigInt(10), import_jsbi5.default.BigInt(quoteCurrency.decimals)));
+    this.scalar = new Fraction(10n ** BigInt(baseCurrency.decimals), 10n ** BigInt(quoteCurrency.decimals));
   }
+  /**
+   * Flip the price, switching the base and quote currency
+   */
   invert() {
     return new Price(this.quoteCurrency, this.baseCurrency, this.numerator, this.denominator);
   }
+  /**
+   * Multiply the price by another price, returning a new price. The other price must have the same base currency as this price's quote currency
+   * @param other the other price
+   */
   multiply(other) {
-    (0, import_tiny_invariant4.default)(this.quoteCurrency.equals(other.baseCurrency), "TOKEN");
+    invariant6__default.default(this.quoteCurrency.equals(other.baseCurrency), "TOKEN");
     const fraction = super.multiply(other);
     return new Price(this.baseCurrency, other.quoteCurrency, fraction.denominator, fraction.numerator);
   }
+  /**
+   * Return the amount of quote currency corresponding to a given amount of the base currency
+   * @param currencyAmount the amount of base currency to quote against the price
+   */
   quote(currencyAmount) {
-    (0, import_tiny_invariant4.default)(currencyAmount.currency.equals(this.baseCurrency), "TOKEN");
+    invariant6__default.default(currencyAmount.currency.equals(this.baseCurrency), "TOKEN");
     const result = super.multiply(currencyAmount);
     return CurrencyAmount.fromFractionalAmount(this.quoteCurrency, result.numerator, result.denominator);
   }
+  /**
+   * Get the value scaled by decimals for formatting
+   * @private
+   */
   get adjustedForDecimals() {
     return super.multiply(this.scalar);
   }
@@ -339,9 +324,6 @@ var NativeCurrency = class extends BaseCurrency {
     this.isToken = false;
   }
 };
-
-// src/token.ts
-var import_tiny_invariant5 = __toESM(require("tiny-invariant"));
 var Token = class extends BaseCurrency {
   constructor(chainId, address, decimals, symbol, name, projectLink) {
     super(chainId, decimals, symbol, name);
@@ -350,14 +332,27 @@ var Token = class extends BaseCurrency {
     this.address = address;
     this.projectLink = projectLink;
   }
+  /**
+   * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
+   * @param other other token to compare
+   */
   equals(other) {
     return other.isToken && this.chainId === other.chainId && this.address === other.address;
   }
+  /**
+   * Returns true if the address of this token sorts before the address of the other token
+   * @param other other token to compare
+   * @throws if the tokens have the same address
+   * @throws if the tokens are on different chains
+   */
   sortsBefore(other) {
-    (0, import_tiny_invariant5.default)(this.chainId === other.chainId, "CHAIN_IDS");
-    (0, import_tiny_invariant5.default)(this.address !== other.address, "ADDRESSES");
+    invariant6__default.default(this.chainId === other.chainId, "CHAIN_IDS");
+    invariant6__default.default(this.address !== other.address, "ADDRESSES");
     return this.address.toLowerCase() < other.address.toLowerCase();
   }
+  /**
+   * Return this token, which does not need to be wrapped
+   */
   get wrapped() {
     return this;
   }
@@ -393,33 +388,29 @@ var InsufficientInputAmountError = class extends Error {
       Object.setPrototypeOf(this, new.target.prototype);
   }
 };
-
-// src/utils.ts
-var import_jsbi6 = __toESM(require("jsbi"));
-var import_tiny_invariant6 = __toESM(require("tiny-invariant"));
 function validateVMTypeInstance(value, vmType) {
-  (0, import_tiny_invariant6.default)(import_jsbi6.default.greaterThanOrEqual(value, ZERO), `${value} is not a ${vmType}.`);
-  (0, import_tiny_invariant6.default)(import_jsbi6.default.lessThanOrEqual(value, VM_TYPE_MAXIMA[vmType]), `${value} is not a ${vmType}.`);
+  invariant6__default.default(value >= ZERO, `${value} is not a ${vmType}.`);
+  invariant6__default.default(value <= VM_TYPE_MAXIMA[vmType], `${value} is not a ${vmType}.`);
 }
 function sqrt(y) {
-  validateVMTypeInstance(y, "uint256" /* uint256 */);
+  invariant6__default.default(y >= ZERO, "NEGATIVE");
   let z = ZERO;
   let x;
-  if (import_jsbi6.default.greaterThan(y, THREE)) {
+  if (y > THREE) {
     z = y;
-    x = import_jsbi6.default.add(import_jsbi6.default.divide(y, TWO), ONE);
-    while (import_jsbi6.default.lessThan(x, z)) {
+    x = y / TWO + ONE;
+    while (x < z) {
       z = x;
-      x = import_jsbi6.default.divide(import_jsbi6.default.add(import_jsbi6.default.divide(y, x), x), TWO);
+      x = (y / x + x) / TWO;
     }
-  } else if (import_jsbi6.default.notEqual(y, ZERO)) {
+  } else if (y !== ZERO) {
     z = ONE;
   }
   return z;
 }
 function sortedInsert(items, add, maxSize, comparator) {
-  (0, import_tiny_invariant6.default)(maxSize > 0, "MAX_SIZE_ZERO");
-  (0, import_tiny_invariant6.default)(items.length <= maxSize, "ITEMS_SIZE");
+  invariant6__default.default(maxSize > 0, "MAX_SIZE_ZERO");
+  invariant6__default.default(items.length <= maxSize, "ITEMS_SIZE");
   if (items.length === 0) {
     items.push(add);
     return null;
@@ -446,35 +437,58 @@ function computePriceImpact(midPrice, inputAmount, outputAmount) {
   const priceImpact = quotedOutputAmount.subtract(outputAmount).divide(quotedOutputAmount);
   return new Percent(priceImpact.numerator, priceImpact.denominator);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BaseCurrency,
-  CurrencyAmount,
-  FIVE,
-  Fraction,
-  InsufficientInputAmountError,
-  InsufficientReservesError,
-  JSBI,
-  MINIMUM_LIQUIDITY,
-  MaxUint256,
-  NativeCurrency,
-  ONE,
-  Percent,
-  Price,
-  Rounding,
-  TEN,
-  THREE,
-  TWO,
-  Token,
-  TradeType,
-  VMType,
-  VM_TYPE_MAXIMA,
-  ZERO,
-  _100,
-  _10000,
-  _9975,
-  computePriceImpact,
-  sortedInsert,
-  sqrt,
-  validateVMTypeInstance
-});
+function balanceComparator(balanceA, balanceB) {
+  if (balanceA && balanceB) {
+    return balanceA.greaterThan(balanceB) ? -1 : balanceA.equalTo(balanceB) ? 0 : 1;
+  }
+  if (balanceA && balanceA.greaterThan("0")) {
+    return -1;
+  }
+  if (balanceB && balanceB.greaterThan("0")) {
+    return 1;
+  }
+  return 0;
+}
+function getTokenComparator(balances) {
+  return function sortTokens(tokenA, tokenB) {
+    const balanceA = balances[tokenA.address];
+    const balanceB = balances[tokenB.address];
+    const balanceComp = balanceComparator(balanceA, balanceB);
+    if (balanceComp !== 0)
+      return balanceComp;
+    if (tokenA.symbol && tokenB.symbol) {
+      return tokenA.symbol.toLowerCase() < tokenB.symbol.toLowerCase() ? -1 : 1;
+    }
+    return tokenA.symbol ? -1 : tokenB.symbol ? -1 : 0;
+  };
+}
+
+exports.BaseCurrency = BaseCurrency;
+exports.CurrencyAmount = CurrencyAmount;
+exports.FIVE = FIVE;
+exports.Fraction = Fraction;
+exports.InsufficientInputAmountError = InsufficientInputAmountError;
+exports.InsufficientReservesError = InsufficientReservesError;
+exports.MINIMUM_LIQUIDITY = MINIMUM_LIQUIDITY;
+exports.MaxUint256 = MaxUint256;
+exports.NativeCurrency = NativeCurrency;
+exports.ONE = ONE;
+exports.Percent = Percent;
+exports.Price = Price;
+exports.Rounding = Rounding;
+exports.TEN = TEN;
+exports.THREE = THREE;
+exports.TWO = TWO;
+exports.Token = Token;
+exports.TradeType = TradeType;
+exports.VMType = VMType;
+exports.VM_TYPE_MAXIMA = VM_TYPE_MAXIMA;
+exports.ZERO = ZERO;
+exports._100 = _100;
+exports._10000 = _10000;
+exports._9975 = _9975;
+exports.computePriceImpact = computePriceImpact;
+exports.getTokenComparator = getTokenComparator;
+exports.sortedInsert = sortedInsert;
+exports.sqrt = sqrt;
+exports.validateVMTypeInstance = validateVMTypeInstance;