@etcswapv2/sdk-legacy 1.0.0

package/dist/index.mjs

@@ -0,0 +1,570 @@
+// src/index.ts
+var ChainId = /* @__PURE__ */ ((ChainId2) => {
+  ChainId2[ChainId2["MAINNET"] = 1] = "MAINNET";
+  ChainId2[ChainId2["ROPSTEN"] = 3] = "ROPSTEN";
+  ChainId2[ChainId2["RINKEBY"] = 4] = "RINKEBY";
+  ChainId2[ChainId2["G\xD6RLI"] = 5] = "G\xD6RLI";
+  ChainId2[ChainId2["KOVAN"] = 42] = "KOVAN";
+  ChainId2[ChainId2["CLASSIC"] = 61] = "CLASSIC";
+  ChainId2[ChainId2["MORDOR"] = 63] = "MORDOR";
+  return ChainId2;
+})(ChainId || {});
+var SUPPORTED_CHAINS = [61 /* CLASSIC */, 63 /* MORDOR */];
+var Ether = class _Ether {
+  constructor() {
+    this.decimals = 18;
+    this.symbol = "ETC";
+    this.name = "Ether";
+  }
+  static get Instance() {
+    return this._instance || (this._instance = new _Ether());
+  }
+};
+var ETHER = Ether.Instance;
+var Token = class {
+  constructor(chainId, address, decimals, symbol, name) {
+    this.chainId = chainId;
+    this.address = address.toLowerCase();
+    this.decimals = decimals;
+    this.symbol = symbol;
+    this.name = name;
+  }
+  equals(other) {
+    return this.chainId === other.chainId && this.address === other.address;
+  }
+  sortsBefore(other) {
+    return this.address.toLowerCase() < other.address.toLowerCase();
+  }
+};
+var WETC = {
+  [61 /* CLASSIC */]: new Token(
+    61 /* CLASSIC */,
+    "0x1953cab0E5bFa6D4a9BaD6E05fD46C1CC6527a5a",
+    18,
+    "WETC",
+    "Wrapped Ether"
+  ),
+  [63 /* MORDOR */]: new Token(
+    63 /* MORDOR */,
+    "0x1953cab0E5bFa6D4a9BaD6E05fD46C1CC6527a5a",
+    18,
+    "WETC",
+    "Wrapped Ether"
+  )
+};
+var WETH = WETC;
+var Fraction = class _Fraction {
+  constructor(numerator, denominator = 1n) {
+    this.numerator = BigInt(numerator);
+    this.denominator = BigInt(denominator);
+  }
+  get quotient() {
+    return this.numerator / this.denominator;
+  }
+  invert() {
+    return new _Fraction(this.denominator, this.numerator);
+  }
+  add(other) {
+    const otherFraction = other instanceof _Fraction ? other : new _Fraction(other);
+    if (this.denominator === otherFraction.denominator) {
+      return new _Fraction(this.numerator + otherFraction.numerator, this.denominator);
+    }
+    return new _Fraction(
+      this.numerator * otherFraction.denominator + otherFraction.numerator * this.denominator,
+      this.denominator * otherFraction.denominator
+    );
+  }
+  subtract(other) {
+    const otherFraction = other instanceof _Fraction ? other : new _Fraction(other);
+    if (this.denominator === otherFraction.denominator) {
+      return new _Fraction(this.numerator - otherFraction.numerator, this.denominator);
+    }
+    return new _Fraction(
+      this.numerator * otherFraction.denominator - otherFraction.numerator * this.denominator,
+      this.denominator * otherFraction.denominator
+    );
+  }
+  multiply(other) {
+    const otherFraction = other instanceof _Fraction ? other : new _Fraction(other);
+    return new _Fraction(
+      this.numerator * otherFraction.numerator,
+      this.denominator * otherFraction.denominator
+    );
+  }
+  divide(other) {
+    const otherFraction = other instanceof _Fraction ? other : new _Fraction(other);
+    return new _Fraction(
+      this.numerator * otherFraction.denominator,
+      this.denominator * otherFraction.numerator
+    );
+  }
+  lessThan(other) {
+    const otherFraction = other instanceof _Fraction ? other : new _Fraction(other);
+    return this.numerator * otherFraction.denominator < otherFraction.numerator * this.denominator;
+  }
+  greaterThan(other) {
+    const otherFraction = other instanceof _Fraction ? other : new _Fraction(other);
+    return this.numerator * otherFraction.denominator > otherFraction.numerator * this.denominator;
+  }
+  equalTo(other) {
+    const otherFraction = other instanceof _Fraction ? other : new _Fraction(other);
+    return this.numerator * otherFraction.denominator === otherFraction.numerator * this.denominator;
+  }
+  toSignificant(significantDigits = 6) {
+    const value = Number(this.numerator) / Number(this.denominator);
+    return value.toPrecision(significantDigits);
+  }
+  toFixed(decimalPlaces = 4) {
+    const value = Number(this.numerator) / Number(this.denominator);
+    return value.toFixed(decimalPlaces);
+  }
+};
+var Percent = class _Percent extends Fraction {
+  constructor(numerator, denominator = 100n) {
+    super(numerator, denominator);
+  }
+  toFixed(decimalPlaces = 2) {
+    return (Number(this.numerator) / Number(this.denominator) * 100).toFixed(decimalPlaces);
+  }
+  toSignificant(significantDigits = 3) {
+    return (Number(this.numerator) / Number(this.denominator) * 100).toPrecision(significantDigits);
+  }
+  add(other) {
+    const result = super.add(other);
+    return new _Percent(result.numerator, result.denominator);
+  }
+  subtract(other) {
+    const result = super.subtract(other);
+    return new _Percent(result.numerator, result.denominator);
+  }
+  multiply(other) {
+    const result = super.multiply(other);
+    return new _Percent(result.numerator, result.denominator);
+  }
+};
+var TokenAmount = class _TokenAmount extends Fraction {
+  constructor(token, amount) {
+    const rawAmount = BigInt(amount);
+    super(rawAmount, BigInt(10 ** token.decimals));
+    this.token = token;
+    this.raw = rawAmount;
+  }
+  get currency() {
+    return this.token;
+  }
+  toExact() {
+    const divisor = BigInt(10 ** this.token.decimals);
+    const quotient = this.raw / divisor;
+    const remainder = this.raw % divisor;
+    if (remainder === 0n) {
+      return quotient.toString();
+    }
+    const remainderStr = remainder.toString().padStart(this.token.decimals, "0");
+    return `${quotient}.${remainderStr}`.replace(/\.?0+$/, "");
+  }
+  toSignificant(significantDigits = 6) {
+    return parseFloat(this.toExact()).toPrecision(significantDigits);
+  }
+  add(other) {
+    if (!this.token.equals(other.token)) throw new Error("TOKEN");
+    return new _TokenAmount(this.token, this.raw + other.raw);
+  }
+  subtract(other) {
+    if (other instanceof _TokenAmount) {
+      if (!this.token.equals(other.token)) throw new Error("TOKEN");
+      return new _TokenAmount(this.token, this.raw - other.raw);
+    }
+    const otherFraction = other instanceof Fraction ? other : new Fraction(other);
+    return new _TokenAmount(this.token, this.raw - otherFraction.numerator);
+  }
+  greaterThan(other) {
+    if (other instanceof _TokenAmount) {
+      return this.raw > other.raw;
+    }
+    return super.greaterThan(other);
+  }
+  lessThan(other) {
+    if (other instanceof _TokenAmount) {
+      return this.raw < other.raw;
+    }
+    return super.lessThan(other);
+  }
+  equalTo(other) {
+    if (other instanceof _TokenAmount) {
+      return this.raw === other.raw;
+    }
+    return super.equalTo(other);
+  }
+};
+var CurrencyAmount = class _CurrencyAmount extends Fraction {
+  constructor(currency, amount) {
+    const decimals = currency instanceof Token ? currency.decimals : 18;
+    const rawAmount = BigInt(amount);
+    super(rawAmount, BigInt(10 ** decimals));
+    this.currency = currency;
+    this.raw = rawAmount;
+  }
+  static ether(amount) {
+    return new _CurrencyAmount(ETHER, amount);
+  }
+  toExact() {
+    const decimals = this.currency instanceof Token ? this.currency.decimals : 18;
+    const divisor = BigInt(10 ** decimals);
+    const quotient = this.raw / divisor;
+    const remainder = this.raw % divisor;
+    if (remainder === 0n) {
+      return quotient.toString();
+    }
+    const remainderStr = remainder.toString().padStart(decimals, "0");
+    return `${quotient}.${remainderStr}`.replace(/\.?0+$/, "");
+  }
+  toSignificant(significantDigits = 6) {
+    return parseFloat(this.toExact()).toPrecision(significantDigits);
+  }
+  add(other) {
+    return new _CurrencyAmount(this.currency, this.raw + other.raw);
+  }
+  subtract(other) {
+    if (other instanceof _CurrencyAmount) {
+      return new _CurrencyAmount(this.currency, this.raw - other.raw);
+    }
+    const otherFraction = other instanceof Fraction ? other : new Fraction(other);
+    return new _CurrencyAmount(this.currency, this.raw - otherFraction.numerator);
+  }
+  greaterThan(other) {
+    if (other instanceof _CurrencyAmount) {
+      return this.raw > other.raw;
+    }
+    return super.greaterThan(other);
+  }
+};
+var Price = class _Price extends Fraction {
+  constructor(baseCurrency, quoteCurrency, denominator, numerator) {
+    super(numerator, denominator);
+    this.baseCurrency = baseCurrency;
+    this.quoteCurrency = quoteCurrency;
+    const baseDecimals = baseCurrency instanceof Token ? baseCurrency.decimals : 18;
+    const quoteDecimals = quoteCurrency instanceof Token ? quoteCurrency.decimals : 18;
+    this.scalar = new Fraction(
+      BigInt(10 ** baseDecimals),
+      BigInt(10 ** quoteDecimals)
+    );
+  }
+  get raw() {
+    return new Fraction(this.numerator, this.denominator);
+  }
+  get adjusted() {
+    return this.raw.multiply(this.scalar);
+  }
+  invert() {
+    return new _Price(this.quoteCurrency, this.baseCurrency, this.numerator, this.denominator);
+  }
+  multiply(other) {
+    return new _Price(
+      this.baseCurrency,
+      other.quoteCurrency,
+      this.denominator * other.denominator,
+      this.numerator * other.numerator
+    );
+  }
+  quote(currencyAmount) {
+    return new CurrencyAmount(
+      this.quoteCurrency,
+      this.adjusted.numerator * currencyAmount.raw / this.adjusted.denominator
+    );
+  }
+  toSignificant(significantDigits = 6) {
+    return this.adjusted.toSignificant(significantDigits);
+  }
+  toFixed(decimalPlaces = 4) {
+    return this.adjusted.toFixed(decimalPlaces);
+  }
+};
+var Pair = class _Pair {
+  constructor(tokenAmountA, tokenAmountB) {
+    const [token0Amount, token1Amount] = tokenAmountA.token.sortsBefore(tokenAmountB.token) ? [tokenAmountA, tokenAmountB] : [tokenAmountB, tokenAmountA];
+    this.token0 = token0Amount.token;
+    this.token1 = token1Amount.token;
+    this.reserve0 = token0Amount;
+    this.reserve1 = token1Amount;
+    const pairAddress = _Pair.getAddress(this.token0, this.token1);
+    this.liquidityToken = new Token(
+      this.token0.chainId,
+      pairAddress,
+      18,
+      "ETC-V2",
+      "ETCswap V2"
+    );
+  }
+  static getAddress(tokenA, tokenB) {
+    const [token0, token1] = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA];
+    const factoryAddress = FACTORY_ADDRESS[token0.chainId] ?? "0x0000000000000000000000000000000000000000";
+    return `0x${factoryAddress.slice(2, 42)}${token0.address.slice(2, 6)}${token1.address.slice(2, 6)}`.toLowerCase();
+  }
+  get token0Price() {
+    return new Price(this.token0, this.token1, this.reserve0.raw, this.reserve1.raw);
+  }
+  get token1Price() {
+    return new Price(this.token1, this.token0, this.reserve1.raw, this.reserve0.raw);
+  }
+  priceOf(token) {
+    return token.equals(this.token0) ? this.token0Price : this.token1Price;
+  }
+  reserveOf(token) {
+    return token.equals(this.token0) ? this.reserve0 : this.reserve1;
+  }
+  involvesToken(token) {
+    return token.equals(this.token0) || token.equals(this.token1);
+  }
+  getLiquidityValue(token, totalSupply, liquidity, _feeOn) {
+    if (!totalSupply.token.equals(this.liquidityToken)) throw new Error("TOTAL_SUPPLY");
+    if (!liquidity.token.equals(this.liquidityToken)) throw new Error("LIQUIDITY");
+    if (liquidity.raw > totalSupply.raw) throw new Error("LIQUIDITY");
+    const reserve = this.reserveOf(token);
+    return new TokenAmount(token, liquidity.raw * reserve.raw / totalSupply.raw);
+  }
+  /**
+   * Returns the amount of liquidity tokens that would be minted given the deposited amounts
+   */
+  getLiquidityMinted(totalSupply, tokenAmountA, tokenAmountB) {
+    if (!totalSupply.token.equals(this.liquidityToken)) throw new Error("LIQUIDITY");
+    const tokenAmounts = tokenAmountA.token.sortsBefore(tokenAmountB.token) ? [tokenAmountA, tokenAmountB] : [tokenAmountB, tokenAmountA];
+    const amount0 = tokenAmounts[0].raw;
+    const amount1 = tokenAmounts[1].raw;
+    if (totalSupply.raw === 0n) {
+      const sqrt = (n) => {
+        if (n < 0n) throw new Error("NEGATIVE");
+        if (n < 2n) return n;
+        let x = n;
+        let y = (x + 1n) / 2n;
+        while (y < x) {
+          x = y;
+          y = (x + n / x) / 2n;
+        }
+        return x;
+      };
+      const liquidity = sqrt(amount0 * amount1) - MINIMUM_LIQUIDITY;
+      return new TokenAmount(this.liquidityToken, liquidity);
+    } else {
+      const liquidity0 = amount0 * totalSupply.raw / this.reserve0.raw;
+      const liquidity1 = amount1 * totalSupply.raw / this.reserve1.raw;
+      const liquidity = liquidity0 < liquidity1 ? liquidity0 : liquidity1;
+      return new TokenAmount(this.liquidityToken, liquidity);
+    }
+  }
+};
+var TradeType = /* @__PURE__ */ ((TradeType2) => {
+  TradeType2[TradeType2["EXACT_INPUT"] = 0] = "EXACT_INPUT";
+  TradeType2[TradeType2["EXACT_OUTPUT"] = 1] = "EXACT_OUTPUT";
+  return TradeType2;
+})(TradeType || {});
+var Route = class {
+  constructor(pairs, input, output) {
+    this.pairs = pairs;
+    this.path = pairs.reduce((path, pair) => {
+      const inputToken = path[path.length - 1];
+      const outputToken = pair.token0.equals(inputToken) ? pair.token1 : pair.token0;
+      return [...path, outputToken];
+    }, [input instanceof Token ? input : WETC[pairs[0].token0.chainId]]);
+    this.input = input;
+    this.output = output ?? this.path[this.path.length - 1];
+  }
+  get midPrice() {
+    const prices = this.pairs.map((pair, i) => pair.priceOf(this.path[i]));
+    return prices.reduce((acc, price) => {
+      return new Price(
+        acc.baseCurrency,
+        price.quoteCurrency,
+        acc.denominator * price.denominator,
+        acc.numerator * price.numerator
+      );
+    });
+  }
+};
+var Trade = class _Trade {
+  constructor(route, amount, tradeType) {
+    this.route = route;
+    this.tradeType = tradeType;
+    if (tradeType === 0 /* EXACT_INPUT */) {
+      this.inputAmount = amount;
+      this.outputAmount = new CurrencyAmount(route.output, 0n);
+    } else {
+      this.outputAmount = amount;
+      this.inputAmount = new CurrencyAmount(route.input, 0n);
+    }
+    this.priceImpact = new Percent(0n, 10000n);
+  }
+  get executionPrice() {
+    return new Price(
+      this.inputAmount.currency,
+      this.outputAmount.currency,
+      this.inputAmount.raw,
+      this.outputAmount.raw
+    );
+  }
+  minimumAmountOut(slippageTolerance) {
+    if (this.tradeType === 1 /* EXACT_OUTPUT */) {
+      return this.outputAmount;
+    }
+    const slippageAdjustedAmountOut = new Fraction(1n).add(slippageTolerance).invert().multiply(new Fraction(this.outputAmount.raw)).quotient;
+    return new CurrencyAmount(this.outputAmount.currency, slippageAdjustedAmountOut);
+  }
+  maximumAmountIn(slippageTolerance) {
+    if (this.tradeType === 0 /* EXACT_INPUT */) {
+      return this.inputAmount;
+    }
+    const slippageAdjustedAmountIn = new Fraction(1n).add(slippageTolerance).multiply(new Fraction(this.inputAmount.raw)).quotient;
+    return new CurrencyAmount(this.inputAmount.currency, slippageAdjustedAmountIn);
+  }
+  static exactIn(route, amountIn) {
+    return new _Trade(route, amountIn, 0 /* EXACT_INPUT */);
+  }
+  static exactOut(route, amountOut) {
+    return new _Trade(route, amountOut, 1 /* EXACT_OUTPUT */);
+  }
+  static bestTradeExactIn(pairs, currencyAmountIn, currencyOut, _options = {}) {
+    const inputToken = currencyAmountIn.currency instanceof Token ? currencyAmountIn.currency : WETC[pairs[0]?.token0.chainId];
+    if (!inputToken) return [];
+    for (const pair of pairs) {
+      if (pair.involvesToken(inputToken)) {
+        const outputToken = pair.token0.equals(inputToken) ? pair.token1 : pair.token0;
+        const outputCurrency = currencyOut instanceof Token ? currencyOut : WETC[outputToken.chainId];
+        if (outputCurrency && outputToken.equals(outputCurrency)) {
+          const route = new Route([pair], currencyAmountIn.currency, currencyOut);
+          return [new _Trade(route, currencyAmountIn, 0 /* EXACT_INPUT */)];
+        }
+      }
+    }
+    return [];
+  }
+  static bestTradeExactOut(pairs, currencyIn, currencyAmountOut, _options = {}) {
+    const outputToken = currencyAmountOut.currency instanceof Token ? currencyAmountOut.currency : WETC[pairs[0]?.token0.chainId];
+    if (!outputToken) return [];
+    for (const pair of pairs) {
+      if (pair.involvesToken(outputToken)) {
+        const inputToken = pair.token0.equals(outputToken) ? pair.token1 : pair.token0;
+        const inputCurrency = currencyIn instanceof Token ? currencyIn : WETC[inputToken.chainId];
+        if (inputCurrency && inputToken.equals(inputCurrency)) {
+          const route = new Route([pair], currencyIn, currencyAmountOut.currency);
+          return [new _Trade(route, currencyAmountOut, 1 /* EXACT_OUTPUT */)];
+        }
+      }
+    }
+    return [];
+  }
+};
+var JSBI = {
+  BigInt: (value) => BigInt(value),
+  add: (a, b) => a + b,
+  subtract: (a, b) => a - b,
+  multiply: (a, b) => a * b,
+  divide: (a, b) => a / b,
+  remainder: (a, b) => a % b,
+  exponentiate: (a, b) => a ** b,
+  greaterThan: (a, b) => a > b,
+  greaterThanOrEqual: (a, b) => a >= b,
+  lessThan: (a, b) => a < b,
+  lessThanOrEqual: (a, b) => a <= b,
+  equal: (a, b) => a === b,
+  notEqual: (a, b) => a !== b
+};
+var Rounding = /* @__PURE__ */ ((Rounding2) => {
+  Rounding2[Rounding2["ROUND_DOWN"] = 0] = "ROUND_DOWN";
+  Rounding2[Rounding2["ROUND_HALF_UP"] = 1] = "ROUND_HALF_UP";
+  Rounding2[Rounding2["ROUND_UP"] = 2] = "ROUND_UP";
+  return Rounding2;
+})(Rounding || {});
+function currencyEquals(a, b) {
+  if (a === ETHER && b === ETHER) return true;
+  if (a instanceof Token && b instanceof Token) return a.equals(b);
+  return false;
+}
+var FACTORY_ADDRESS = {
+  [61 /* CLASSIC */]: "0x0307cd3D7DA98A29e6Ed0D2137be386Ec1e4Bc9C",
+  [63 /* MORDOR */]: "0x212eE1B5c8C26ff5B2c4c14CD1C54486Fe23ce70"
+};
+var ROUTER_ADDRESS = {
+  [61 /* CLASSIC */]: "0x79Bf07555C34e68C4Ae93642d1007D7f908d60F5",
+  [63 /* MORDOR */]: "0x6d194227a9A1C11f144B35F96E6289c5602Da493"
+};
+var INIT_CODE_HASH = {
+  [61 /* CLASSIC */]: "0xb5e58237f3a44220ffc3dfb989e53735df8fcd9df82c94b13105be8380344e52",
+  [63 /* MORDOR */]: "0x4d8a51f257ed377a6ac3f829cd4226c892edbbbcb87622bcc232807b885b1303"
+};
+var MINIMUM_LIQUIDITY = 1000n;
+var Router = class {
+  static swapCallParameters(trade, options) {
+    const etherIn = !(trade.inputAmount.currency instanceof Token);
+    const etherOut = !(trade.outputAmount.currency instanceof Token);
+    let methodName;
+    if (trade.tradeType === 0 /* EXACT_INPUT */) {
+      if (etherIn) {
+        methodName = options.feeOnTransfer ? "swapExactETCForTokensSupportingFeeOnTransferTokens" : "swapExactETCForTokens";
+      } else if (etherOut) {
+        methodName = options.feeOnTransfer ? "swapExactTokensForETCSupportingFeeOnTransferTokens" : "swapExactTokensForETC";
+      } else {
+        methodName = options.feeOnTransfer ? "swapExactTokensForTokensSupportingFeeOnTransferTokens" : "swapExactTokensForTokens";
+      }
+    } else {
+      if (etherIn) {
+        methodName = "swapETCForExactTokens";
+      } else if (etherOut) {
+        methodName = "swapTokensForExactETC";
+      } else {
+        methodName = "swapTokensForExactTokens";
+      }
+    }
+    const path = trade.route.path.map((token) => token.address);
+    const amountIn = trade.maximumAmountIn(options.allowedSlippage).raw.toString();
+    const amountOut = trade.minimumAmountOut(options.allowedSlippage).raw.toString();
+    const deadline = options.deadline.toString();
+    let args;
+    let value = "0";
+    if (trade.tradeType === 0 /* EXACT_INPUT */) {
+      if (etherIn) {
+        args = [amountOut, path, options.recipient, deadline];
+        value = amountIn;
+      } else if (etherOut) {
+        args = [amountIn, amountOut, path, options.recipient, deadline];
+      } else {
+        args = [amountIn, amountOut, path, options.recipient, deadline];
+      }
+    } else {
+      if (etherIn) {
+        args = [amountOut, path, options.recipient, deadline];
+        value = amountIn;
+      } else if (etherOut) {
+        args = [amountOut, amountIn, path, options.recipient, deadline];
+      } else {
+        args = [amountOut, amountIn, path, options.recipient, deadline];
+      }
+    }
+    return { methodName, args, value };
+  }
+};
+export {
+  ChainId,
+  CurrencyAmount,
+  ETHER,
+  Ether,
+  FACTORY_ADDRESS,
+  Fraction,
+  INIT_CODE_HASH,
+  JSBI,
+  MINIMUM_LIQUIDITY,
+  Pair,
+  Percent,
+  Price,
+  ROUTER_ADDRESS,
+  Rounding,
+  Route,
+  Router,
+  SUPPORTED_CHAINS,
+  Token,
+  TokenAmount,
+  Trade,
+  TradeType,
+  WETC,
+  WETH,
+  currencyEquals
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@etcswapv2/sdk-legacy",
+  "version": "1.0.0",
+  "description": "Legacy V2 SDK for ETCswap - non-generic API compatible with Uniswap V2 interface",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/etcswap/sdks.git",
+    "directory": "sdks/v2-sdk-legacy"
+  },
+  "keywords": [
+    "etcswap",
+    "ethereum-classic",
+    "etc",
+    "dex",
+    "amm",
+    "v2",
+    "legacy",
+    "uniswap-v2-compatible"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "clean": "rimraf dist",
+    "lint": "eslint src --ext .ts",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "pnpm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "rimraf": "^5.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^3.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}