@gearbox-protocol/sdk 14.10.7 → 14.11.0-next.1

package/dist/cjs/preview/prerequisites/Prerequisite.js

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Prerequisite_exports = {};
+__export(Prerequisite_exports, {
+  Prerequisite: () => Prerequisite,
+  toPrerequisiteError: () => toPrerequisiteError
+});
+module.exports = __toCommonJS(Prerequisite_exports);
+var import_viem = require("viem");
+function toPrerequisiteError(cause) {
+  if (cause instanceof import_viem.BaseError) {
+    const reverted = cause.walk(
+      (e) => e instanceof import_viem.ContractFunctionRevertedError
+    );
+    if (reverted instanceof import_viem.ContractFunctionRevertedError) {
+      return {
+        reason: reverted.data?.errorName ?? reverted.shortMessage ?? "reverted",
+        cause
+      };
+    }
+    return { reason: cause.shortMessage ?? cause.name, cause };
+  }
+  if (cause instanceof Error) {
+    return { reason: cause.message, cause };
+  }
+  return { reason: "unknown error", cause };
+}
+class Prerequisite {
+  /**
+   * Verifies this prerequisite on its own using an `allowFailure` multicall.
+   * Prefer `verifyPrerequisites` to batch several checks into one round-trip.
+   */
+  async verify(ctx) {
+    const calls = this.calls(ctx);
+    const results = await ctx.sdk.client.multicall({
+      allowFailure: true,
+      contracts: calls,
+      // `undefined` lets viem read at `latest`; `blockNumber` is only set for
+      // testnet forks pinned to a specific block.
+      blockNumber: ctx.blockNumber
+    });
+    return this.resolve(results);
+  }
+  /** Builds a successful result; `detail` carries the on-chain `actual`. */
+  satisfiedResult(satisfied, detail) {
+    return {
+      id: this.id,
+      kind: this.kind,
+      title: this.title,
+      detail,
+      satisfied
+    };
+  }
+  /** Builds a failed result from a decoded read error. */
+  errorResult(error) {
+    return {
+      id: this.id,
+      kind: this.kind,
+      title: this.title,
+      detail: this.detail,
+      error
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Prerequisite,
+  toPrerequisiteError
+});

package/dist/cjs/preview/prerequisites/buildPrerequisites.js

@@ -0,0 +1,141 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var buildPrerequisites_exports = {};
+__export(buildPrerequisites_exports, {
+  buildPrerequisites: () => buildPrerequisites
+});
+module.exports = __toCommonJS(buildPrerequisites_exports);
+var import_viem = require("viem");
+var import_AllowancePrerequisite = require("./AllowancePrerequisite.js");
+var import_BalancePrerequisite = require("./BalancePrerequisite.js");
+function buildPrerequisites(tx, ctx) {
+  const { wallet } = ctx;
+  switch (tx.operation) {
+    case "Deposit":
+      return [
+        new import_AllowancePrerequisite.AllowancePrerequisite({
+          token: tx.underlying,
+          owner: wallet,
+          spender: tx.pool,
+          required: tx.assets,
+          title: "Token approved to pool"
+        }),
+        new import_BalancePrerequisite.BalancePrerequisite({
+          token: tx.underlying,
+          owner: wallet,
+          required: tx.assets,
+          title: "Sufficient token balance"
+        })
+      ];
+    case "Redeem": {
+      const prereqs = [
+        new import_BalancePrerequisite.BalancePrerequisite({
+          token: tx.pool,
+          owner: tx.owner,
+          required: tx.shares,
+          title: "Sufficient LP token balance"
+        })
+      ];
+      if (!(0, import_viem.isAddressEqual)(tx.owner, wallet)) {
+        prereqs.push(
+          new import_AllowancePrerequisite.AllowancePrerequisite({
+            token: tx.pool,
+            owner: tx.owner,
+            spender: wallet,
+            required: tx.shares,
+            title: "LP token approved to caller"
+          })
+        );
+      }
+      return prereqs;
+    }
+    case "MultiCall":
+    case "BotMulticall":
+    case "OpenCreditAccount":
+    case "CloseCreditAccount":
+    case "LiquidateCreditAccount":
+      return collateralPrerequisites(tx.multicall, tx.creditManager, wallet);
+    case "PartiallyLiquidateCreditAccount": {
+      const underlying = underlyingOf(ctx.sdk, tx.creditManager);
+      if (!underlying || tx.repaidAmount === 0n) {
+        return [];
+      }
+      return [
+        new import_AllowancePrerequisite.AllowancePrerequisite({
+          token: underlying,
+          owner: wallet,
+          spender: tx.creditManager,
+          required: tx.repaidAmount,
+          title: "Underlying approved to credit manager"
+        }),
+        new import_BalancePrerequisite.BalancePrerequisite({
+          token: underlying,
+          owner: wallet,
+          required: tx.repaidAmount,
+          title: "Sufficient underlying balance"
+        })
+      ];
+    }
+    default:
+      return [];
+  }
+}
+function collateralPrerequisites(multicall, creditManager, wallet) {
+  const required = /* @__PURE__ */ new Map();
+  for (const op of multicall) {
+    if (op.operation !== "AddCollateral" || op.amount === 0n) {
+      continue;
+    }
+    const key = op.token.toLowerCase();
+    const existing = required.get(key);
+    required.set(key, {
+      token: op.token,
+      amount: (existing?.amount ?? 0n) + op.amount
+    });
+  }
+  const prereqs = [];
+  for (const { token, amount } of required.values()) {
+    prereqs.push(
+      new import_AllowancePrerequisite.AllowancePrerequisite({
+        token,
+        owner: wallet,
+        spender: creditManager,
+        required: amount,
+        title: "Collateral approved to credit manager"
+      }),
+      new import_BalancePrerequisite.BalancePrerequisite({
+        token,
+        owner: wallet,
+        required: amount,
+        title: "Sufficient collateral balance"
+      })
+    );
+  }
+  return prereqs;
+}
+function underlyingOf(sdk, creditManager) {
+  const suite = sdk.marketRegister.creditManagers.find(
+    (cm) => (0, import_viem.isAddressEqual)(cm.creditManager.address, creditManager)
+  );
+  return suite?.underlying;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildPrerequisites
+});

package/dist/cjs/preview/prerequisites/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var prerequisites_exports = {};
+module.exports = __toCommonJS(prerequisites_exports);
+__reExport(prerequisites_exports, require("./AllowancePrerequisite.js"), module.exports);
+__reExport(prerequisites_exports, require("./BalancePrerequisite.js"), module.exports);
+__reExport(prerequisites_exports, require("./buildPrerequisites.js"), module.exports);
+__reExport(prerequisites_exports, require("./Prerequisite.js"), module.exports);
+__reExport(prerequisites_exports, require("./runPrerequisites.js"), module.exports);
+__reExport(prerequisites_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./AllowancePrerequisite.js"),
+  ...require("./BalancePrerequisite.js"),
+  ...require("./buildPrerequisites.js"),
+  ...require("./Prerequisite.js"),
+  ...require("./runPrerequisites.js"),
+  ...require("./types.js")
+});

package/dist/cjs/preview/prerequisites/runPrerequisites.js

@@ -0,0 +1,71 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runPrerequisites_exports = {};
+__export(runPrerequisites_exports, {
+  verifyPrerequisites: () => verifyPrerequisites
+});
+module.exports = __toCommonJS(runPrerequisites_exports);
+async function verifyPrerequisites(prereqs, ctx) {
+  if (prereqs.length === 0) {
+    return [];
+  }
+  const ranges = [];
+  const calls = [];
+  for (const prereq of prereqs) {
+    const start = calls.length;
+    calls.push(...prereq.calls(ctx));
+    ranges.push({ start, end: calls.length });
+  }
+  let results;
+  try {
+    results = await ctx.sdk.client.multicall({
+      allowFailure: true,
+      contracts: calls,
+      // `undefined` lets viem read at `latest`; `blockNumber` is only set for
+      // testnet forks pinned to a specific block.
+      blockNumber: ctx.blockNumber
+    });
+  } catch (cause) {
+    const error = cause instanceof Error ? cause : new Error(String(cause));
+    return prereqs.map(
+      (prereq, i) => (
+        // Each prereq pairs its own kind with its detail, so the widened
+        // `resolve` return is safe to narrow back to the discriminated union.
+        prereq.resolve(
+          failureSlice(ranges[i].end - ranges[i].start, error)
+        )
+      )
+    );
+  }
+  return prereqs.map(
+    (prereq, i) => prereq.resolve(
+      results.slice(ranges[i].start, ranges[i].end)
+    )
+  );
+}
+function failureSlice(n, error) {
+  return Array.from({ length: n }, () => ({
+    status: "failure",
+    error
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  verifyPrerequisites
+});

package/dist/cjs/preview/prerequisites/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/preview/simulate/decodeSimulationError.js

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var decodeSimulationError_exports = {};
+__export(decodeSimulationError_exports, {
+  decodeSimulationError: () => decodeSimulationError
+});
+module.exports = __toCommonJS(decodeSimulationError_exports);
+var import_viem = require("viem");
+var import_errors = require("../../abi/errors.js");
+function decodeSimulationError(revert) {
+  const { error, data } = revert;
+  if (data && data !== "0x") {
+    try {
+      const decoded = (0, import_viem.decodeErrorResult)({ abi: import_errors.errorAbis, data });
+      return {
+        reason: formatDecodedError(decoded.errorName, decoded.args),
+        cause: error
+      };
+    } catch {
+    }
+  }
+  if (error instanceof import_viem.BaseError) {
+    const reverted = error.walk(
+      (e) => e instanceof import_viem.ContractFunctionRevertedError
+    );
+    if (reverted instanceof import_viem.ContractFunctionRevertedError) {
+      return {
+        reason: reverted.data?.errorName ?? reverted.reason ?? reverted.shortMessage ?? "reverted",
+        cause: error
+      };
+    }
+    return { reason: error.shortMessage ?? error.name, cause: error };
+  }
+  if (error instanceof Error) {
+    return { reason: error.message, cause: error };
+  }
+  return { reason: "reverted", cause: error };
+}
+function formatDecodedError(errorName, args) {
+  if (!args || args.length === 0) {
+    return errorName;
+  }
+  return `${errorName}(${args.map((arg) => String(arg)).join(", ")})`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decodeSimulationError
+});

package/dist/cjs/preview/simulate/extractERC20Transfers.js

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var extractERC20Transfers_exports = {};
+__export(extractERC20Transfers_exports, {
+  extractERC20Transfers: () => extractERC20Transfers
+});
+module.exports = __toCommonJS(extractERC20Transfers_exports);
+var import_viem = require("viem");
+var import_iERC20 = require("../../abi/iERC20.js");
+function extractERC20Transfers(logs, watch) {
+  const parsed = (0, import_viem.parseEventLogs)({
+    abi: import_iERC20.ierc20Abi,
+    eventName: "Transfer",
+    logs
+  });
+  const transfers = [];
+  for (const log of parsed) {
+    const { from, to, value } = log.args;
+    const involved = watch.some(
+      (address) => (0, import_viem.isAddressEqual)(from, address) || (0, import_viem.isAddressEqual)(to, address)
+    );
+    if (involved) {
+      transfers.push({ token: log.address, amount: value, from, to });
+    }
+  }
+  return transfers;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractERC20Transfers
+});

package/dist/cjs/preview/simulate/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var simulate_exports = {};
+module.exports = __toCommonJS(simulate_exports);
+__reExport(simulate_exports, require("./decodeSimulationError.js"), module.exports);
+__reExport(simulate_exports, require("./extractERC20Transfers.js"), module.exports);
+__reExport(simulate_exports, require("./simulatePoolOperation.js"), module.exports);
+__reExport(simulate_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./decodeSimulationError.js"),
+  ...require("./extractERC20Transfers.js"),
+  ...require("./simulatePoolOperation.js"),
+  ...require("./types.js")
+});

package/dist/cjs/preview/simulate/simulatePoolOperation.js

@@ -0,0 +1,94 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var simulatePoolOperation_exports = {};
+__export(simulatePoolOperation_exports, {
+  simulatePoolOperation: () => simulatePoolOperation
+});
+module.exports = __toCommonJS(simulatePoolOperation_exports);
+var import_viem = require("viem");
+var import_actions = require("viem/actions");
+var import_iERC20 = require("../../abi/iERC20.js");
+var import_decodeSimulationError = require("./decodeSimulationError.js");
+var import_extractERC20Transfers = require("./extractERC20Transfers.js");
+async function simulatePoolOperation(input) {
+  const { sdk, operation, to, calldata, wallet, blockNumber } = input;
+  const { underlying, pool } = operation;
+  const receiverIsWallet = (0, import_viem.isAddressEqual)(operation.receiver, wallet);
+  const holders = receiverIsWallet ? [wallet] : [wallet, operation.receiver];
+  const tokens = [underlying, pool];
+  const balanceOf = (token, holder) => ({
+    to: token,
+    abi: import_iERC20.ierc20Abi,
+    functionName: "balanceOf",
+    args: [holder]
+  });
+  const balanceCalls = holders.flatMap(
+    (holder) => tokens.map((token) => balanceOf(token, holder))
+  );
+  const { results } = await (0, import_actions.simulateCalls)(sdk.client, {
+    account: wallet,
+    // `undefined` lets viem simulate at `latest`; `blockNumber` is only set for
+    // testnet forks pinned to a specific block.
+    blockNumber,
+    calls: [...balanceCalls, { to, data: calldata }, ...balanceCalls]
+  });
+  const sim = results;
+  const txIndex = balanceCalls.length;
+  const afterOffset = txIndex + 1;
+  const txResult = sim[txIndex];
+  if (!txResult || txResult.status === "failure") {
+    return {
+      status: "failure",
+      error: (0, import_decodeSimulationError.decodeSimulationError)({
+        error: txResult?.error,
+        data: txResult?.data
+      })
+    };
+  }
+  const balanceChanges = [];
+  for (const [holderIndex, address] of holders.entries()) {
+    const changes = [];
+    for (const [tokenIndex, token] of tokens.entries()) {
+      const slot = holderIndex * tokens.length + tokenIndex;
+      const before = readBalance(sim[slot]);
+      const after = readBalance(sim[afterOffset + slot]);
+      const delta = after - before;
+      const magnitude = delta >= 0n ? delta : -delta;
+      if (magnitude > 1n) {
+        changes.push({ token, before, after, delta });
+      }
+    }
+    if (changes.length > 0) {
+      balanceChanges.push({ address, changes });
+    }
+  }
+  return {
+    status: "success",
+    transfers: (0, import_extractERC20Transfers.extractERC20Transfers)(txResult.logs ?? [], holders),
+    balanceChanges,
+    gasUsed: txResult.gasUsed
+  };
+}
+function readBalance(result) {
+  return result?.status === "success" ? result.result : 0n;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  simulatePoolOperation
+});

package/dist/cjs/preview/simulate/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/esm/preview/index.js

@@ -0,0 +1,3 @@
+export * from "./parse/index.js";
+export * from "./prerequisites/index.js";
+export * from "./simulate/index.js";

package/dist/esm/preview/package.json

@@ -0,0 +1 @@
+{"type": "module","sideEffects":false}