@blockrun/llm 0.3.0 → 1.1.0

package/dist/index.js

@@ -1,4 +1,9 @@
-import "./chunk-2ESYSVXG.js";
+import {
+  __require,
+  __toCommonJS,
+  index_esm_exports,
+  init_index_esm
+} from "./chunk-KRDGCX7W.js";
 
 // src/client.ts
 import { privateKeyToAccount } from "viem/accounts";
@@ -27,10 +32,17 @@ var APIError = class extends BlockrunError {
   }
 };
 
+// src/client.ts
+import { route, DEFAULT_ROUTING_CONFIG } from "@blockrun/clawrouter";
+
 // src/x402.ts
 import { signTypedData } from "viem/accounts";
 var BASE_CHAIN_ID = 8453;
 var USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var SOLANA_NETWORK = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+var USDC_SOLANA = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+var DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS = 1;
+var DEFAULT_COMPUTE_UNIT_LIMIT = 8e3;
 var USDC_DOMAIN = {
   name: "USD Coin",
   version: "2",
@@ -103,6 +115,66 @@ async function createPaymentPayload(privateKey, fromAddress, recipient, amount,
   };
   return btoa(JSON.stringify(paymentData));
 }
+async function createSolanaPaymentPayload(secretKey, fromAddress, recipient, amount, feePayer, options = {}) {
+  const { Connection, PublicKey, TransactionMessage, VersionedTransaction, ComputeBudgetProgram } = await import("./index.esm-SXKIFLA7.js");
+  const { getAssociatedTokenAddress, createTransferCheckedInstruction, getMint } = await import("./esm-PTFDM6PE.js");
+  const { Keypair } = await import("./index.esm-SXKIFLA7.js");
+  const rpcUrl = options.rpcUrl || "https://api.mainnet-beta.solana.com";
+  const connection = new Connection(rpcUrl);
+  const keypair = Keypair.fromSecretKey(secretKey);
+  const feePayerPubkey = new PublicKey(feePayer);
+  const ownerPubkey = keypair.publicKey;
+  const tokenMint = new PublicKey(USDC_SOLANA);
+  const payToPubkey = new PublicKey(recipient);
+  const mintInfo = await getMint(connection, tokenMint);
+  const sourceATA = await getAssociatedTokenAddress(tokenMint, ownerPubkey, false);
+  const destinationATA = await getAssociatedTokenAddress(tokenMint, payToPubkey, false);
+  const { blockhash } = await connection.getLatestBlockhash();
+  const setComputeUnitPriceIx = ComputeBudgetProgram.setComputeUnitPrice({
+    microLamports: DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS
+  });
+  const setComputeUnitLimitIx = ComputeBudgetProgram.setComputeUnitLimit({
+    units: DEFAULT_COMPUTE_UNIT_LIMIT
+  });
+  const transferIx = createTransferCheckedInstruction(
+    sourceATA,
+    tokenMint,
+    destinationATA,
+    ownerPubkey,
+    BigInt(amount),
+    mintInfo.decimals
+  );
+  const messageV0 = new TransactionMessage({
+    payerKey: feePayerPubkey,
+    recentBlockhash: blockhash,
+    instructions: [setComputeUnitLimitIx, setComputeUnitPriceIx, transferIx]
+  }).compileToV0Message();
+  const transaction = new VersionedTransaction(messageV0);
+  transaction.sign([keypair]);
+  const serializedTx = Buffer.from(transaction.serialize()).toString("base64");
+  const paymentData = {
+    x402Version: 2,
+    resource: {
+      url: options.resourceUrl || "https://blockrun.ai/api/v1/chat/completions",
+      description: options.resourceDescription || "BlockRun AI API call",
+      mimeType: "application/json"
+    },
+    accepted: {
+      scheme: "exact",
+      network: SOLANA_NETWORK,
+      amount,
+      asset: USDC_SOLANA,
+      payTo: recipient,
+      maxTimeoutSeconds: options.maxTimeoutSeconds || 300,
+      extra: options.extra || { feePayer }
+    },
+    payload: {
+      transaction: serializedTx
+    },
+    extensions: options.extensions || {}
+  };
+  return btoa(JSON.stringify(paymentData));
+}
 function parsePaymentRequired(headerValue) {
   try {
     const decoded = atob(headerValue);
@@ -237,6 +309,8 @@ var LLMClient = class {
   timeout;
   sessionTotalUsd = 0;
   sessionCalls = 0;
+  modelPricingCache = null;
+  modelPricingPromise = null;
   /**
    * Initialize the BlockRun LLM client.
    *
@@ -285,6 +359,91 @@ var LLMClient = class {
     });
     return result.choices[0].message.content || "";
   }
+  /**
+   * Smart chat with automatic model routing.
+   *
+   * Uses ClawRouter's 14-dimension rule-based scoring algorithm (<1ms, 100% local)
+   * to select the cheapest model that can handle your request.
+   *
+   * @param prompt - User message
+   * @param options - Optional chat and routing parameters
+   * @returns SmartChatResponse with response text, selected model, and routing metadata
+   *
+   * @example Simple usage (auto profile)
+   * ```ts
+   * const result = await client.smartChat('What is 2+2?');
+   * console.log(result.response); // '4'
+   * console.log(result.model); // 'google/gemini-2.5-flash-lite'
+   * console.log(result.routing.savings); // 0.78 (78% savings)
+   * ```
+   *
+   * @example With routing profile
+   * ```ts
+   * // Free tier only (zero cost)
+   * const result = await client.smartChat('Hello!', { routingProfile: 'free' });
+   *
+   * // Eco mode (budget optimized)
+   * const result = await client.smartChat('Explain quantum computing', { routingProfile: 'eco' });
+   *
+   * // Premium mode (best quality)
+   * const result = await client.smartChat('Write a business plan', { routingProfile: 'premium' });
+   * ```
+   */
+  async smartChat(prompt, options) {
+    const modelPricing = await this.getModelPricing();
+    const maxOutputTokens = options?.maxOutputTokens || options?.maxTokens || 1024;
+    const decision = route(prompt, options?.system, maxOutputTokens, {
+      config: DEFAULT_ROUTING_CONFIG,
+      modelPricing,
+      routingProfile: options?.routingProfile
+    });
+    const response = await this.chat(decision.model, prompt, {
+      system: options?.system,
+      maxTokens: options?.maxTokens,
+      temperature: options?.temperature,
+      topP: options?.topP,
+      search: options?.search,
+      searchParameters: options?.searchParameters
+    });
+    return {
+      response,
+      model: decision.model,
+      routing: decision
+    };
+  }
+  /**
+   * Get model pricing map (cached).
+   * Fetches from API on first call, then returns cached result.
+   */
+  async getModelPricing() {
+    if (this.modelPricingCache) {
+      return this.modelPricingCache;
+    }
+    if (this.modelPricingPromise) {
+      return this.modelPricingPromise;
+    }
+    this.modelPricingPromise = this.fetchModelPricing();
+    try {
+      this.modelPricingCache = await this.modelPricingPromise;
+      return this.modelPricingCache;
+    } finally {
+      this.modelPricingPromise = null;
+    }
+  }
+  /**
+   * Fetch model pricing from API.
+   */
+  async fetchModelPricing() {
+    const models = await this.listModels();
+    const pricing = /* @__PURE__ */ new Map();
+    for (const model of models) {
+      pricing.set(model.id, {
+        inputPrice: model.inputPrice,
+        outputPrice: model.outputPrice
+      });
+    }
+    return pricing;
+  }
   /**
    * Full chat completion interface (OpenAI-compatible).
    *
@@ -857,6 +1016,255 @@ Check my balance: ${links.basescan}`;
 var WALLET_FILE_PATH = WALLET_FILE;
 var WALLET_DIR_PATH = WALLET_DIR;
 
+// src/solana-wallet.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+var WALLET_DIR2 = path2.join(os2.homedir(), ".blockrun");
+var SOLANA_WALLET_FILE = path2.join(WALLET_DIR2, ".solana-session");
+function createSolanaWallet() {
+  const { Keypair } = (init_index_esm(), __toCommonJS(index_esm_exports));
+  const bs58 = __require("bs58");
+  const keypair = Keypair.generate();
+  return {
+    address: keypair.publicKey.toBase58(),
+    privateKey: bs58.default?.encode(keypair.secretKey) ?? bs58.encode(keypair.secretKey)
+  };
+}
+async function solanaKeyToBytes(privateKey) {
+  try {
+    const bs58 = await import("bs58");
+    const bytes = (bs58.default ?? bs58).decode(privateKey);
+    if (bytes.length !== 64) {
+      throw new Error(`Invalid Solana key length: expected 64 bytes, got ${bytes.length}`);
+    }
+    return bytes;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid Solana private key: ${msg}`);
+  }
+}
+async function solanaPublicKey(privateKey) {
+  const { Keypair } = await import("./index.esm-SXKIFLA7.js");
+  const bytes = await solanaKeyToBytes(privateKey);
+  return Keypair.fromSecretKey(bytes).publicKey.toBase58();
+}
+function saveSolanaWallet(privateKey) {
+  if (!fs2.existsSync(WALLET_DIR2)) fs2.mkdirSync(WALLET_DIR2, { recursive: true });
+  fs2.writeFileSync(SOLANA_WALLET_FILE, privateKey, { mode: 384 });
+  return SOLANA_WALLET_FILE;
+}
+function loadSolanaWallet() {
+  if (fs2.existsSync(SOLANA_WALLET_FILE)) {
+    const key = fs2.readFileSync(SOLANA_WALLET_FILE, "utf-8").trim();
+    if (key) return key;
+  }
+  return null;
+}
+async function getOrCreateSolanaWallet() {
+  const envKey = typeof process !== "undefined" && process.env ? process.env.SOLANA_WALLET_KEY : void 0;
+  if (envKey) {
+    const address2 = await solanaPublicKey(envKey);
+    return { privateKey: envKey, address: address2, isNew: false };
+  }
+  const fileKey = loadSolanaWallet();
+  if (fileKey) {
+    const address2 = await solanaPublicKey(fileKey);
+    return { privateKey: fileKey, address: address2, isNew: false };
+  }
+  const { address, privateKey } = createSolanaWallet();
+  saveSolanaWallet(privateKey);
+  return { address, privateKey, isNew: true };
+}
+
+// src/solana-client.ts
+var SOLANA_API_URL = "https://sol.blockrun.ai/api";
+var DEFAULT_MAX_TOKENS2 = 1024;
+var DEFAULT_TIMEOUT3 = 6e4;
+var SDK_VERSION2 = "0.3.0";
+var USER_AGENT2 = `blockrun-ts/${SDK_VERSION2}`;
+var SolanaLLMClient = class {
+  static SOLANA_API_URL = SOLANA_API_URL;
+  privateKey;
+  apiUrl;
+  rpcUrl;
+  timeout;
+  sessionTotalUsd = 0;
+  sessionCalls = 0;
+  addressCache = null;
+  constructor(options = {}) {
+    const envKey = typeof process !== "undefined" && process.env ? process.env.SOLANA_WALLET_KEY : void 0;
+    const privateKey = options.privateKey || envKey;
+    if (!privateKey) {
+      throw new Error(
+        "Private key required. Pass privateKey in options or set SOLANA_WALLET_KEY environment variable."
+      );
+    }
+    this.privateKey = privateKey;
+    const apiUrl = options.apiUrl || SOLANA_API_URL;
+    validateApiUrl(apiUrl);
+    this.apiUrl = apiUrl.replace(/\/$/, "");
+    this.rpcUrl = options.rpcUrl || "https://api.mainnet-beta.solana.com";
+    this.timeout = options.timeout || DEFAULT_TIMEOUT3;
+  }
+  /** Get Solana wallet address (public key in base58). */
+  async getWalletAddress() {
+    if (!this.addressCache) {
+      this.addressCache = await solanaPublicKey(this.privateKey);
+    }
+    return this.addressCache;
+  }
+  /** Simple 1-line chat. */
+  async chat(model, prompt, options) {
+    const messages = [];
+    if (options?.system) messages.push({ role: "system", content: options.system });
+    messages.push({ role: "user", content: prompt });
+    const result = await this.chatCompletion(model, messages, {
+      maxTokens: options?.maxTokens,
+      temperature: options?.temperature,
+      topP: options?.topP,
+      search: options?.search,
+      searchParameters: options?.searchParameters
+    });
+    return result.choices[0].message.content || "";
+  }
+  /** Full chat completion (OpenAI-compatible). */
+  async chatCompletion(model, messages, options) {
+    const body = {
+      model,
+      messages,
+      max_tokens: options?.maxTokens || DEFAULT_MAX_TOKENS2
+    };
+    if (options?.temperature !== void 0) body.temperature = options.temperature;
+    if (options?.topP !== void 0) body.top_p = options.topP;
+    if (options?.searchParameters !== void 0) body.search_parameters = options.searchParameters;
+    else if (options?.search === true) body.search_parameters = { mode: "on" };
+    if (options?.tools !== void 0) body.tools = options.tools;
+    if (options?.toolChoice !== void 0) body.tool_choice = options.toolChoice;
+    return this.requestWithPayment("/v1/chat/completions", body);
+  }
+  /** List available models. */
+  async listModels() {
+    const response = await this.fetchWithTimeout(`${this.apiUrl}/v1/models`, { method: "GET" });
+    if (!response.ok) {
+      throw new APIError(`Failed to list models: ${response.status}`, response.status);
+    }
+    const data = await response.json();
+    return data.data || [];
+  }
+  /** Get session spending. */
+  getSpending() {
+    return { totalUsd: this.sessionTotalUsd, calls: this.sessionCalls };
+  }
+  /** True if using sol.blockrun.ai. */
+  isSolana() {
+    return this.apiUrl.includes("sol.blockrun.ai");
+  }
+  async requestWithPayment(endpoint, body) {
+    const url = `${this.apiUrl}${endpoint}`;
+    const response = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT2 },
+      body: JSON.stringify(body)
+    });
+    if (response.status === 402) {
+      return this.handlePaymentAndRetry(url, body, response);
+    }
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {
+        errorBody = { error: "Request failed" };
+      }
+      throw new APIError(`API error: ${response.status}`, response.status, sanitizeErrorResponse(errorBody));
+    }
+    return response.json();
+  }
+  async handlePaymentAndRetry(url, body, response) {
+    let paymentHeader = response.headers.get("payment-required");
+    if (!paymentHeader) {
+      try {
+        const respBody = await response.json();
+        if (respBody.accepts || respBody.x402Version) {
+          paymentHeader = btoa(JSON.stringify(respBody));
+        }
+      } catch {
+      }
+    }
+    if (!paymentHeader) {
+      throw new PaymentError("402 response but no payment requirements found");
+    }
+    const paymentRequired = parsePaymentRequired(paymentHeader);
+    const details = extractPaymentDetails(paymentRequired, SOLANA_NETWORK);
+    if (!details.network?.startsWith("solana:")) {
+      throw new PaymentError(
+        `Expected Solana payment network, got: ${details.network}. Use LLMClient for Base payments.`
+      );
+    }
+    const feePayer = details.extra?.feePayer;
+    if (!feePayer) throw new PaymentError("Missing feePayer in 402 extra field");
+    const fromAddress = await this.getWalletAddress();
+    const secretKey = await solanaKeyToBytes(this.privateKey);
+    const extensions = paymentRequired.extensions;
+    const paymentPayload = await createSolanaPaymentPayload(
+      secretKey,
+      fromAddress,
+      details.recipient,
+      details.amount,
+      feePayer,
+      {
+        resourceUrl: validateResourceUrl(
+          details.resource?.url || `${this.apiUrl}/v1/chat/completions`,
+          this.apiUrl
+        ),
+        resourceDescription: details.resource?.description || "BlockRun Solana AI API call",
+        maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+        extra: details.extra,
+        extensions,
+        rpcUrl: this.rpcUrl
+      }
+    );
+    const retryResponse = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT2,
+        "PAYMENT-SIGNATURE": paymentPayload
+      },
+      body: JSON.stringify(body)
+    });
+    if (retryResponse.status === 402) {
+      throw new PaymentError("Payment was rejected. Check your Solana USDC balance.");
+    }
+    if (!retryResponse.ok) {
+      let errorBody;
+      try {
+        errorBody = await retryResponse.json();
+      } catch {
+        errorBody = { error: "Request failed" };
+      }
+      throw new APIError(`API error after payment: ${retryResponse.status}`, retryResponse.status, sanitizeErrorResponse(errorBody));
+    }
+    const costUsd = parseFloat(details.amount) / 1e6;
+    this.sessionCalls += 1;
+    this.sessionTotalUsd += costUsd;
+    return retryResponse.json();
+  }
+  async fetchWithTimeout(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      return await fetch(url, { ...options, signal: controller.signal });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+function solanaClient(options = {}) {
+  return new SolanaLLMClient({ ...options, apiUrl: SOLANA_API_URL });
+}
+
 // src/openai-compat.ts
 var StreamingResponse = class {
   reader;
@@ -1034,20 +1442,32 @@ export {
   LLMClient,
   OpenAI,
   PaymentError,
+  SOLANA_NETWORK,
+  SOLANA_WALLET_FILE as SOLANA_WALLET_FILE_PATH,
+  SolanaLLMClient,
   USDC_BASE,
   USDC_BASE_CONTRACT,
+  USDC_SOLANA,
   WALLET_DIR_PATH,
   WALLET_FILE_PATH,
+  createSolanaPaymentPayload,
+  createSolanaWallet,
   createWallet,
   client_default as default,
   formatFundingMessageCompact,
   formatNeedsFundingMessage,
   formatWalletCreatedMessage,
   getEip681Uri,
+  getOrCreateSolanaWallet,
   getOrCreateWallet,
   getPaymentLinks,
   getWalletAddress,
+  loadSolanaWallet,
   loadWallet,
+  saveSolanaWallet,
   saveWallet,
+  solanaClient,
+  solanaKeyToBytes,
+  solanaPublicKey,
   testnetClient
 };

package/package.json

@@ -1,70 +1,71 @@
-{
-  "name": "@blockrun/llm",
-  "version": "0.3.0",
-  "type": "module",
-  "description": "BlockRun LLM Gateway SDK - Pay-per-request AI via x402 on Base",
-  "main": "dist/index.cjs",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
-    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
-    "test": "vitest",
-    "lint": "eslint src/",
-    "typecheck": "tsc --noEmit"
-  },
-  "keywords": [
-    "llm",
-    "ai",
-    "x402",
-    "base",
-    "solana",
-    "usdc",
-    "micropayments",
-    "openai",
-    "claude",
-    "gemini",
-    "blockchain"
-  ],
-  "author": "BlockRun <hello@blockrun.ai>",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/BlockRunAI/blockrun-llm-ts"
-  },
-  "homepage": "https://blockrun.ai",
-  "bugs": {
-    "url": "https://github.com/BlockRunAI/blockrun-llm-ts/issues"
-  },
-  "dependencies": {
-    "viem": "^2.21.0"
-  },
-  "optionalDependencies": {
-    "@solana/web3.js": "^1.98.0",
-    "@solana/spl-token": "^0.4.0"
-  },
-  "devDependencies": {
-    "@eslint/js": "^9.0.0",
-    "@types/node": "^20.0.0",
-    "eslint": "^9.0.0",
-    "tsup": "^8.0.0",
-    "typescript": "^5.0.0",
-    "typescript-eslint": "^8.0.0",
-    "vitest": "^1.0.0"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "packageManager": "pnpm@9.15.4"
-}
+{
+  "name": "@blockrun/llm",
+  "version": "1.1.0",
+  "type": "module",
+  "description": "BlockRun LLM Gateway SDK - Pay-per-request AI via x402 on Base",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "llm",
+    "ai",
+    "x402",
+    "base",
+    "solana",
+    "usdc",
+    "micropayments",
+    "openai",
+    "claude",
+    "gemini",
+    "blockchain"
+  ],
+  "author": "BlockRun <hello@blockrun.ai>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BlockRunAI/blockrun-llm-ts"
+  },
+  "homepage": "https://blockrun.ai",
+  "bugs": {
+    "url": "https://github.com/BlockRunAI/blockrun-llm-ts/issues"
+  },
+  "dependencies": {
+    "@blockrun/clawrouter": "^0.10.18",
+    "bs58": "^6.0.0",
+    "viem": "^2.21.0"
+  },
+  "optionalDependencies": {
+    "@solana/spl-token": "^0.4.0",
+    "@solana/web3.js": "^1.98.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "@types/node": "^20.0.0",
+    "eslint": "^9.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/dist/chunk-2ESYSVXG.js

@@ -1,48 +0,0 @@
-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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-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(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-export {
-  __require,
-  __esm,
-  __commonJS,
-  __export,
-  __toESM,
-  __toCommonJS
-};