eth-compress 0.3.0 → 0.3.1

package/_cjs/jit-compressor.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/jit-compressor.ts", "../../src/compiler/constants.ts", "../../src/compiler/opcodes.ts", "../../src/compiler/utils.ts", "../../src/compiler/jit.ts", "../../src/contracts.ts"],
-  "sourcesContent": ["import { LibZip } from 'solady';\nimport { _jitDecompressor } from './compiler';\nimport { _normHex } from './compiler/utils';\nimport { flzFwdBytecode, rleFwdBytecode } from './contracts';\nimport { MIN_BODY_SIZE } from './index';\n/**\n * Compresses eth_call payload using JIT, FastLZ (FLZ), or calldata RLE (CD) compression.\n * Auto-selects best algorithm if not specified. Only compresses if >800 bytes and beneficial.\n *\n * Only applies compression to calls that:\n * - have no state overrides\n * - have a target address and calldata\n * - have no other properties (nonce, gas, etc.)\n *\n * @param payload - eth_call RPC payload\n * @param alg - 'jit' | 'flz' | 'cd' | undefined (auto)\n * @returns (un)compressed eth_call payload\n * @pure\n */\n//! @__PURE__\nexport const compress_call = function (payload: any, alg?: string): any {\n  const { method, params } = payload;\n  if (method && method !== 'eth_call') return payload;\n  const txObj = params?.[0] || payload;\n  const blockParam = params?.[1];\n  const overrides = params?.[2];\n\n  // Validation\n  if (\n    (overrides && Object.keys(overrides).length > 0) ||\n    !txObj?.to ||\n    !txObj?.data ||\n    Object.keys(txObj).some((k) => !['to', 'data', 'from'].includes(k))\n  ) {\n    return payload;\n  }\n\n  const originalSize = txObj.data.length;\n  if (originalSize < MIN_BODY_SIZE) return payload;\n\n  const inputData = '0x' + _normHex(txObj.data);\n  const to = txObj.to;\n  const from = txObj.from;\n\n  let bytecode: string;\n  let calldata: string;\n  let decompressorAddress: string;\n  let fromAddr: string | undefined;\n  let balanceHex: string;\n\n  if (alg === 'jit' || (!alg && (originalSize < 3000 || originalSize >= 8000))) {\n    const result = _jitDecompressor(inputData, to, from);\n    bytecode = result.bytecode;\n    calldata = result.calldata;\n    decompressorAddress = result.to;\n    fromAddr = result.from;\n    balanceHex = result.balance;\n  } else {\n    const jit = !alg ? _jitDecompressor(inputData, to, from) : null;\n    const flzData = alg === 'flz' || !alg ? LibZip.flzCompress(inputData) : null;\n    const cdData = alg === 'cd' || (!alg && flzData) ? LibZip.cdCompress(inputData) : null;\n    const useFlz =\n      alg === 'flz' || (!alg && flzData && (!cdData || flzData.length < cdData.length));\n\n    if (useFlz) {\n      calldata = flzData!;\n      bytecode = flzFwdBytecode(to);\n    } else {\n      calldata = cdData!;\n      bytecode = rleFwdBytecode(to);\n    }\n\n    decompressorAddress = '0x' + 224n.toString(16).padStart(40, '0');\n    fromAddr = from ? _normHex(from).padStart(16, '0') : undefined;\n    balanceHex = '0';\n    if (\n      !alg &&\n      jit &&\n      jit.bytecode.length + jit.calldata.length < bytecode.length + calldata.length\n    ) {\n      bytecode = jit.bytecode;\n      calldata = jit.calldata;\n      decompressorAddress = jit.to;\n      fromAddr = jit.from;\n      balanceHex = jit.balance;\n    }\n  }\n\n  // Skip if not beneficial\n  if (bytecode.length + calldata.length >= originalSize) return payload;\n\n  const stateOverride: any = {\n    code: bytecode,\n    balance: '0x' + balanceHex,\n  };\n  const compressedTxObj: any = { to: decompressorAddress, data: calldata };\n  if (fromAddr) {\n    compressedTxObj.from = '0x' + fromAddr;\n  }\n\n  return {\n    ...payload,\n    params: [compressedTxObj, blockParam, { ...overrides, [decompressorAddress]: stateOverride }],\n  };\n};\n", "export const MAX_128_BIT = (1n << 128n) - 1n;\nexport const MAX_256_BIT = (1n << 256n) - 1n;\n", "import { MAX_256_BIT } from './constants';\n\nexport const not = (a: bigint): bigint => ~a & MAX_256_BIT;\nexport const eq = (a: bigint, b: bigint): bigint => (a === b ? 1n : 0n);\nexport const and = (a: bigint, b: bigint): bigint => a & b & MAX_256_BIT;\nexport const or = (a: bigint, b: bigint): bigint => (a | b) & MAX_256_BIT;\nexport const xor = (a: bigint, b: bigint): bigint => (a ^ b) & MAX_256_BIT;\n\nexport const add = (a: bigint, b: bigint): bigint => (a + b) & MAX_256_BIT;\nexport const sub = (a: bigint, b: bigint): bigint => (a - b) & MAX_256_BIT;\n\nexport const shl = (shift: bigint, value: bigint): bigint => (value << shift) & MAX_256_BIT;\nexport const shr = (shift: bigint, value: bigint): bigint => (value >> shift) & MAX_256_BIT;\n\nexport const sigext = (byteSize: bigint, value: bigint): bigint => {\n  const numBytes = Number(byteSize) + 1;\n  const mask = (1n << BigInt(numBytes * 8)) - 1n;\n  const signBit = 1n << BigInt(numBytes * 8 - 1);\n  const maskedVal = value & mask;\n  const extended = (maskedVal & signBit) !== 0n ? maskedVal | (~mask & MAX_256_BIT) : maskedVal;\n  return extended & MAX_256_BIT;\n};\n\nexport const clz = (value: bigint): bigint => {\n  if (value === 0n) return 256n;\n  let count = 0n;\n  let mask = 1n << 255n;\n  while ((value & mask) === 0n && count < 256n) {\n    count++;\n    mask >>= 1n;\n  }\n  return count;\n};\n\nexport const ctz = (value: bigint): bigint => {\n  if (value === 0n) return 256n;\n  let count = 0n;\n  while (count < 256n && (value & (1n << count)) === 0n) {\n    count++;\n  }\n  return count;\n};\n", "export const _normHex = (hex: string): string => hex.replace(/^0x/, '').toLowerCase();\n\nexport const _hexToUint8Array = (hex: string): Uint8Array => {\n  const normalized = _normHex(hex);\n  const len = normalized.length;\n  const bytes = new Uint8Array(len / 2);\n  for (let i = 0; i < len; i += 2) {\n    bytes[i / 2] = Number.parseInt(normalized.slice(i, i + 2), 16);\n  }\n  return bytes;\n};\n\nexport const _uint8ArrayToHex = (bytes: Uint8Array): string => {\n  let hex = '';\n  for (let i = 0; i < bytes.length; i++) {\n    hex += bytes[i].toString(16).padStart(2, '0');\n  }\n  return hex;\n};\n\nexport type MemorySegment = { s: number; e: number };\n\nexport interface WordStats {\n  /** Total number of times this 32-byte word appears in the view. */\n  freq: number;\n  normFreq: number;\n  /** First 32-byte word index at which this word appears. */\n  firstWordIndex: number;\n  /** Last 32-byte word index at which this word appears. */\n  lastWordIndex: number;\n  /** Starting byte offset in memory of the first occurrence (same as MLOAD offset). */\n  firstOffset: number;\n  /** Starting byte offset in memory of the last occurrence (same as MLOAD offset). */\n  lastOffset: number;\n  reuseCost: number;\n}\n\nexport interface MemoryView {\n  /** Normalized hex string (without 0x) of the original payload. */\n  readonly hex: string;\n  /** Backing buffer containing `padding` zero bytes followed by the payload. */\n  readonly buffer: Uint8Array;\n  /** Total length of the backing buffer (padding + payload length), rounded up to full words. */\n  readonly roundedLength: number;\n  /** Number of zero bytes prefixed before the payload. */\n  readonly padding: number;\n  /** Length of the original (unpadded) payload in bytes. */\n  readonly dataLength: number;\n  /** Number of 32-byte words in this view. */\n  readonly wordCount: number;\n  /** Frequency of each 32-byte word (by hex representation) across the memory view. */\n  readonly wordFreq: ReadonlyMap<string, number>;\n  readonly wordStats: ReadonlyMap<string, WordStats>;\n  /** Return the nth 32-byte word (zero-padded on the right if incomplete). */\n  getWord(wordIndex: number): Uint8Array;\n  /**\n   * Return all non-zero byte segments within the nth 32-byte word.\n   * Each segment is an inclusive [s, e] range in the word.\n   */\n  getSegments(wordIndex: number): MemorySegment[];\n  mload(offset: number): Uint8Array;\n  /**\n   * Read an arbitrary slice starting at `offset` for `size` bytes,\n   * padding with zeros when reading past `length`.\n   */\n  slice(offset: number, size: number): Uint8Array;\n}\n\nexport const initMemoryView = (calldata: string, padding: number): MemoryView => {\n  const hex = _normHex(calldata);\n  const originalBuf = _hexToUint8Array(hex);\n  const buffer = new Uint8Array(padding + originalBuf.length);\n  buffer.set(originalBuf, padding);\n  const rawLength = buffer.length;\n  const wordCount = Math.ceil(rawLength / 32);\n  const roundedLength = wordCount * 32;\n\n  const words: Uint8Array[] = new Array(wordCount);\n  const segments: MemorySegment[][] = new Array(wordCount);\n  const wordFreq = new Map<string, number>();\n  const wordStats = new Map<string, WordStats>();\n\n  let prevWordHex: string | null = null;\n\n  for (let wordIndex = 0; wordIndex < wordCount; wordIndex++) {\n    const base = wordIndex * 32;\n    const word = new Uint8Array(32);\n    if (base < rawLength) {\n      const end = Math.min(base + 32, rawLength);\n      word.set(buffer.subarray(base, end), 0);\n    }\n    words[wordIndex] = word;\n\n    const wordHex = _uint8ArrayToHex(word);\n    const existing = wordStats.get(wordHex);\n    const isRunContinuation = prevWordHex === wordHex;\n    if (!existing) {\n      const stats: WordStats = {\n        freq: 1,\n        normFreq: 1,\n        firstWordIndex: wordIndex,\n        lastWordIndex: wordIndex,\n        firstOffset: base,\n        lastOffset: base,\n        reuseCost: -1,\n      };\n      wordStats.set(wordHex, stats);\n      wordFreq.set(wordHex, 1);\n    } else {\n      existing.freq += 1;\n      if (!isRunContinuation) {\n        existing.normFreq += 1;\n      }\n      existing.lastWordIndex = wordIndex;\n      existing.lastOffset = base;\n      wordFreq.set(wordHex, existing.freq);\n    }\n    prevWordHex = wordHex;\n\n    const seg: MemorySegment[] = [];\n    for (let i = 0; i < 32; ) {\n      while (i < 32 && word[i] === 0) ++i;\n      if (i >= 32) break;\n      const s = i;\n      while (i < 32 && word[i] !== 0) ++i;\n      seg.push({ s, e: i - 1 });\n    }\n    segments[wordIndex] = seg;\n  }\n\n  for (const stats of wordStats.values()) {\n    const baseBytes = stats.firstOffset === 0 ? 0 : Math.ceil(Math.log2(stats.firstOffset + 1) / 8);\n    const reuseCost = baseBytes + 3;\n    const totalLiteralBytes = stats.normFreq * 32;\n    const totalReuseBytes = stats.normFreq * reuseCost;\n    stats.reuseCost = totalLiteralBytes > totalReuseBytes ? reuseCost : -1;\n  }\n\n  const zeroWord = new Uint8Array(32);\n\n  const getWord = (wordIndex: number): Uint8Array => {\n    if (wordIndex < 0 || wordIndex >= wordCount) return zeroWord;\n    return words[wordIndex];\n  };\n\n  const getSegments = (wordIndex: number): MemorySegment[] => {\n    if (wordIndex < 0 || wordIndex >= wordCount) return [];\n    return segments[wordIndex];\n  };\n\n  const mload = (offset: number): Uint8Array => {\n    const out = new Uint8Array(32);\n    if (offset < 0 || offset >= rawLength) return out;\n    const end = Math.min(offset + 32, rawLength);\n    out.set(buffer.slice(offset, end), 0);\n    return out;\n  };\n\n  const slice = (offset: number, size: number): Uint8Array => {\n    if (size <= 0) return new Uint8Array(0);\n    const out = new Uint8Array(size);\n    if (offset < 0 || offset >= rawLength) return out;\n    const end = Math.min(offset + size, rawLength);\n    out.set(buffer.slice(offset, end), 0);\n    return out;\n  };\n\n  return {\n    hex,\n    buffer,\n    roundedLength,\n    padding,\n    dataLength: originalBuf.length,\n    wordCount,\n    wordFreq,\n    wordStats,\n    getWord,\n    getSegments,\n    mload,\n    slice,\n  };\n};\n", "import { MAX_128_BIT, MAX_256_BIT } from './constants';\nimport { add, and, not, or, shl, shr, sigext, sub, xor } from './opcodes';\nimport { _normHex, _uint8ArrayToHex, initMemoryView, MemorySegment } from './utils';\n\nexport const _jitDecompressor = function (\n  calldata: string,\n  to: string,\n  from?: string,\n): { bytecode: string; calldata: string; to: string; from?: string; balance: string } {\n  let padding = 28;\n  const view = initMemoryView(calldata, padding);\n  let decAddr = 224n;\n  let originalTo = _normHex(to).padStart(16, '0');\n  let fromAddr = from ? BigInt('0x' + _normHex(from)) : 96n;\n  const excluded = new Set([0n, 32n, decAddr, fromAddr, BigInt('0x' + originalTo)]);\n  let selfbalance = 2n;\n  const filtered = Array.from(view.wordFreq.entries())\n    .map(([word, freq]) => [BigInt('0x' + word), freq] as [bigint, number])\n    .filter(([val]) => !excluded.has(val));\n  if (filtered.length > 0) {\n    selfbalance = filtered.reduce((max, curr) => (curr[1] > max[1] ? curr : max))[0];\n  }\n  const { wordCount } = view;\n  let ops: number[] = [];\n  let data: (number[] | null)[] = [];\n  let stack: bigint[] = [];\n  let trackedMemSize = 0;\n  let mem = new Map<number, bigint>();\n  let firstPass = true;\n\n  const roundUp32 = (x: number) => (x + 31) & ~31;\n  const getStackIdx = (val: bigint): number => {\n    let idx = stack.lastIndexOf(val);\n    idx = idx === -1 ? -1 : stack.length - 1 - idx;\n    return idx > 15 ? -1 : idx;\n  };\n  const stackFreq = new Map<bigint, number>();\n  const stackLastUse = new Map<bigint, number>();\n  let pushCounter = 0;\n  const ctr = <K>(m: Map<K, number>, k: K, delta: number) => m.set(k, (m.get(k) || 0) + delta);\n  const pushOp = (op: number, d?: number[] | null) => {\n    ops.push(op);\n    data.push(d ?? null);\n  };\n  const pushS = (v: bigint, freqDelta: number = 1) => {\n    stack.push(v);\n    if (freqDelta !== 0) ctr(stackFreq, v, freqDelta);\n    ++pushCounter;\n    stackLastUse.set(v, pushCounter);\n  };\n  const pop2 = (): [bigint, bigint] => [stack.pop()!, stack.pop()!];\n  const trackMem = (offset: number, size: number) => {\n    trackedMemSize = roundUp32(offset + size);\n  };\n\n  const addOp = (op: number, imm?: number[]) => {\n    if (op == 0x80) {\n      // DUP1\n      const val = stack[stack.length - 1]!;\n      pushS(val, firstPass ? 0 : 1);\n    }\n    if (op == 0x50) stack.pop();\n    if (op == 0x47) pushS(selfbalance, 0);\n    if (op == 0x30) pushS(decAddr, 0);\n    if (op == 0x33) pushS(fromAddr, 0);\n    if (op == 0x36) pushS(32n, 0);\n    if (op == 0x59) pushS(BigInt(trackedMemSize), 0);\n    if (op === 0x0b) {\n      // SIGNEXTEND\n      const [byteSize, val] = pop2();\n      pushS(sigext(byteSize, val), 1);\n    }\n    if (op == 0x19) {\n      // NOT\n      const val = stack.pop()!;\n      pushS(not(val), 0);\n    }\n    if (op === 0x18) {\n      // XOR\n      const [a, b] = pop2();\n      pushS(xor(a, b), 1);\n    }\n    if (op == 0x16) {\n      // AND\n      const [a, b] = pop2();\n      pushS(and(a, b), 1);\n    }\n    if (op == 0x17) {\n      // OR\n      const [a, b] = pop2();\n      pushS(or(a, b), 1);\n    }\n    if (op == 0x01) {\n      // ADD\n      const [a, b] = pop2();\n      pushS(add(a, b), 1);\n    }\n    if (op === 0x03) {\n      // SUB\n      const [a, b] = pop2();\n      pushS(sub(b, a), 1);\n    }\n    if (op == 0x1b) {\n      // SHL\n      const [shift, val] = pop2();\n      pushS(shl(shift, val), 1);\n    }\n    if (op == 0x1c) {\n      // SHR\n      const [shift, val] = pop2();\n      pushS(shr(shift, val), 1);\n    }\n    if ((op >= 0x60 && op <= 0x7f) || op === 0x5f) {\n      let v = 0n; // PUSH* and PUSH0\n      for (const b of imm || []) v = (v << 8n) | BigInt(b);\n      if (v == selfbalance) {\n        pushS(v, 0);\n        pushOp(0x47);\n        return;\n      }\n      if (v == decAddr) {\n        pushS(v, 0);\n        pushOp(0x30);\n        return;\n      }\n      if (v == fromAddr) {\n        pushS(v, 0);\n        pushOp(0x33); // FROM ADDRESS\n        return;\n      }\n      if (v == 32n) {\n        pushS(v, 0);\n        pushOp(0x36); // CALLDATASIZE\n        return;\n      }\n      if (v === BigInt(trackedMemSize) && v !== 0n) {\n        pushS(v, 0);\n        pushOp(0x59);\n        return;\n      }\n      const idx = getStackIdx(v);\n      if (idx !== -1 && op !== 0x5f) {\n        const freqDelta = firstPass ? 1 : 0;\n        pushS(v, freqDelta);\n        pushOp(0x80 + idx);\n        return;\n      }\n      if (v === MAX_256_BIT) {\n        pushS(v, 0);\n        pushOp(0x5f); // PUSH0\n        pushOp(0x19); // NOT\n        return;\n      }\n      pushS(v, 1);\n      pushOp(op, imm || null);\n      return;\n    }\n    if (op === 0x51) {\n      // MLOAD\n      const k = Number(stack.pop()!);\n      pushS(mem.has(k) ? mem.get(k)! : 0n, 0);\n    }\n    if (op === 0x52) {\n      // MSTORE\n      const [offset, value] = pop2();\n      const k = Number(offset);\n      mem.set(k, value & MAX_256_BIT);\n      trackMem(k, 32);\n    }\n    if (op === 0x53) {\n      // MSTORE8\n      const [offset, _] = pop2();\n      trackMem(Number(offset), 1);\n    }\n    pushOp(op, imm || null);\n  };\n\n  const op = (opcode: number) => addOp(opcode);\n\n  const bytesLen = (v: bigint): number => {\n    if (v === 0n) return 0;\n    let n = 0;\n    let t = v < 0n ? -v : v;\n    while (t > 0n) {\n      ++n;\n      t >>= 8n;\n    }\n    return n;\n  };\n\n  const pushCost = (v: bigint): number => (v === 0n ? 1 : 1 + bytesLen(v));\n\n  const pushN = (value: number | bigint) => {\n    const v = typeof value === 'bigint' ? value : BigInt(value);\n    if (v > 0n && v === BigInt(trackedMemSize)) return addOp(0x59);\n    if (v === 32n) return addOp(0x36);\n    if (v === 0n) return addOp(0x5f);\n\n    let tmp = v;\n    const bytes: number[] = [];\n    while (tmp !== 0n) {\n      bytes.unshift(Number(tmp & 0xffn));\n      tmp >>= 8n;\n    }\n    return addOp(0x5f + bytes.length, bytes);\n  };\n\n  const pushB = (buf: Uint8Array) => addOp(0x5f + buf.length, Array.from(buf));\n\n  type PlanStep =\n    | { t: 'num'; v: number | bigint }\n    | { t: 'bytes'; b: Uint8Array }\n    | { t: 'op'; o: number };\n\n  const plan: PlanStep[] = [];\n\n  const emitPushN = (v: number | bigint) => {\n    plan.push({ t: 'num', v });\n    pushN(v);\n  };\n  const emitPushB = (b: Uint8Array) => {\n    plan.push({ t: 'bytes', b });\n    pushB(b);\n  };\n  const emitOp = (o: number) => {\n    plan.push({ t: 'op', o });\n    op(o);\n  };\n\n  const estShlCost = (seg: MemorySegment[]) => {\n    let cost = 0;\n    let first = true;\n    for (const { s, e } of seg) {\n      cost += 1 + (e - s + 1); // PUSH<n> immediate bytes\n      if (31 - e > 0) cost += 1 + 1 + 1; // PUSH1 shift + SHL\n      if (!first) cost += 1; // OR\n      first = false;\n    }\n    return cost;\n  };\n\n  const emitBestValueForWord = (word: Uint8Array, seg: MemorySegment[]) => {\n    const literal = word.slice(seg[0].s);\n    let literalVal = 0n;\n    for (const b of literal) literalVal = (literalVal << 8n) | BigInt(b);\n    const literalCost = 1 + literal.length;\n    const shlCost = estShlCost(seg);\n    let bestCost = literalCost;\n    let bestEmit: () => void = () => emitPushB(literal);\n    // Try NOT: PUSH(~x) NOT\n    const notVal = not(literalVal);\n    const notCost = pushCost(notVal) + 1;\n    if (notCost < bestCost) {\n      bestCost = notCost;\n      bestEmit = () => {\n        emitPushN(notVal);\n        emitOp(0x19);\n      };\n    }\n    // Try SUB: PUSH0, PUSH(x), SUB\n    const subVal = sub(0n, literalVal);\n    const subCost = 1 + pushCost(subVal) + 1;\n    if (subCost < bestCost) {\n      bestCost = subCost;\n      bestEmit = () => {\n        emitPushN(0);\n        emitPushN(subVal);\n        emitOp(0x03);\n      };\n    }\n    // Try SIGNEXTEND\n    for (let numBytes = 1; numBytes < literal.length; numBytes++) {\n      const mask = (1n << BigInt(numBytes * 8)) - 1n;\n      const truncated = literalVal & mask;\n      const extended = sigext(BigInt(numBytes - 1), truncated);\n      if (\n        extended === literalVal &&\n        (truncated & (1n << BigInt(numBytes * 8 - 1))) !== 0n // must be negative in that width\n      ) {\n        const signCost = pushCost(truncated) + 2 + 1; // PUSH + PUSH1 + SIGNEXTEND\n        if (signCost < bestCost) {\n          bestCost = signCost;\n          bestEmit = () => {\n            emitPushN(truncated);\n            emitPushN(numBytes - 1);\n            emitOp(0x0b);\n          };\n        }\n        break;\n      }\n    }\n    // Try SHIFT+NOT\n    for (let shiftBits = 8; shiftBits <= 248; shiftBits += 8) {\n      const shifted = shr(BigInt(shiftBits), literalVal);\n      if (shifted === 0n) break;\n\n      const notShifted = not(shifted);\n      const reconstructed = shl(BigInt(shiftBits), notShifted);\n      if (reconstructed === literalVal) {\n        const shiftNotCost = pushCost(notShifted) + pushCost(BigInt(shiftBits)) + 2; // PUSH + PUSH + SHL + NOT\n        if (shiftNotCost < bestCost) {\n          bestCost = shiftNotCost;\n          bestEmit = () => {\n            emitPushN(notShifted);\n            emitPushN(shiftBits);\n            emitOp(0x1b);\n            emitOp(0x19);\n          };\n        }\n      }\n    }\n    // Try SHL/OR\n    if (shlCost < bestCost) {\n      bestCost = shlCost;\n      bestEmit = () => {\n        let first = true;\n        for (const { s, e } of seg) {\n          const suffix0s = 31 - e;\n          emitPushB(word.slice(s, e + 1));\n          if (suffix0s > 0) {\n            emitPushN(suffix0s * 8);\n            emitOp(0x1b); // SHL\n          }\n          if (!first) emitOp(0x17); // OR\n          first = false;\n        }\n      };\n    }\n    return { literal, literalVal, bestCost, bestEmit, literalCost, shlCost };\n  };\n\n  let wordIndex = 0;\n  while (wordIndex < wordCount) {\n    const base = wordIndex * 32;\n    const word = view.getWord(wordIndex);\n    const seg = view.getSegments(wordIndex);\n    if (!seg.length) {\n      ++wordIndex;\n      continue;\n    }\n\n    const wordHex = _uint8ArrayToHex(word);\n    // Encode Run?\n    let runLen = 1;\n    while (wordIndex + runLen < wordCount) {\n      const w2 = view.getWord(wordIndex + runLen);\n      const s2 = view.getSegments(wordIndex + runLen);\n      if (!s2.length) break;\n      if (_uint8ArrayToHex(w2) !== wordHex) break;\n      ++runLen;\n    }\n\n    if (runLen >= 2) {\n      const { bestEmit } = emitBestValueForWord(word, seg);\n      // First store: keep word value on stack.\n      bestEmit(); // push value\n      emitOp(0x80); // DUP1 (keep value)\n      emitPushN(base); // offset (MSIZE if aligned)\n      emitOp(0x52); // MSTORE\n\n      for (let j = 1; j < runLen; j++) {\n        emitOp(0x80); // DUP1\n        emitOp(0x59); // MSIZE\n        emitOp(0x52); // MSTORE\n      }\n      const stats = view.wordStats.get(wordHex);\n      if (stats && stats.lastWordIndex <= wordIndex + runLen - 1) {\n        emitOp(0x50); // POP\n      }\n      wordIndex += runLen;\n      continue;\n    }\n\n    const { literalCost, shlCost, bestCost, bestEmit } = emitBestValueForWord(word, seg);\n    // Try MLOAD/MSTORE reuse\n    if (literalCost > 8) {\n      const stats = view.wordStats.get(wordHex);\n      if (stats && stats.reuseCost !== -1 && wordIndex > stats.firstWordIndex) {\n        const baseBytes =\n          stats.firstOffset === 0 ? 0 : Math.ceil(Math.log2(stats.firstOffset + 1) / 8);\n        if (literalCost > stats.reuseCost + baseBytes) {\n          emitPushN(stats.firstOffset);\n          emitOp(0x51); // MLOAD\n          emitPushN(base);\n          emitOp(0x52); // MSTORE\n          ++wordIndex;\n          continue;\n        }\n      }\n    }\n    const byte8s = seg.every(({ s, e }) => s === e);\n    const byte8sCost = seg.length * 3; // PUSH1(value), PUSH1(offset), MSTORE8\n    if (byte8s && byte8sCost < bestCost && byte8sCost <= shlCost) {\n      for (const { s } of seg) {\n        emitPushN(word[s]);\n        emitPushN(base + s);\n        emitOp(0x53); // MSTORE8\n      }\n      ++wordIndex;\n      continue;\n    }\n    // Default\n    bestEmit();\n    emitPushN(base);\n    emitOp(0x52); // MSTORE\n    ++wordIndex;\n  }\n\n  //2nd pass: preseed dictionary + emit final ops\n  const planOut = plan.slice();\n  ops = [];\n  data = [];\n  stack = [];\n  trackedMemSize = 0;\n  mem = new Map();\n  firstPass = false;\n\n  const reserved = new Set<bigint>([0n, 32n, selfbalance, decAddr, fromAddr]);\n  Array.from(stackFreq.entries())\n    .filter(([val, uses]) => uses > 1 && !reserved.has(val))\n    .map(([val, uses]) => {\n      const p = pushCost(val);\n      const net = uses * (p - 1) - p;\n      return { val, uses, net, p };\n    })\n    .sort((a, b) => {\n      if (b.net !== a.net) return b.net - a.net;\n      if (b.uses !== a.uses) return b.uses - a.uses;\n      return a.p - b.p;\n    })\n    .filter((x) => x.net > 0 && x.val <= MAX_128_BIT)\n    .slice(0, 15)\n    .forEach(({ val }) => {\n      pushN(val);\n    });\n\n  for (const step of planOut) {\n    if (step.t === 'num') pushN(step.v);\n    else if (step.t === 'bytes') pushB(step.b);\n    else if (step.t === 'op') op(step.o);\n  }\n\n  // CALL stack layout (top to bottom): gas, address, value, argsOffset, argsSize, retOffset, retSize\n  //\n  // - 0x5f5f: PUSH0 PUSH0 (retSize=0, retOffset=0)\n  // - pushN(view.dataLength): argsSize\n  // - pushN(padding): argsOffset (skip leading alignment bytes)\n  // - 0x34: CALLVALUE (value)\n  // - 0x5f35: PUSH0 CALLDATALOAD (address from calldata[0])\n  // - 0x5a: GAS (remaining gas)\n  // - 0xf1: CALL\n  //\n  // RETURNDATACOPY(destOffset=0, offset=0, length=RETURNDATASIZE):\n  // - 0x3d5f5f3e: RETURNDATASIZE PUSH0 PUSH0 RETURNDATACOPY\n  //\n  // RETURN(offset=0, size=RETURNDATASIZE):\n  // - 0x3d5ff3: RETURNDATASIZE PUSH0 RETURN\n\n  op(0x5f); // PUSH0 (retSize)\n  op(0x5f); // PUSH0 (retOffset)\n  pushN(view.dataLength); // argsSize = actual data length\n  pushN(padding); // argsOffset = padding\n\n  const out: number[] = [];\n  for (let i = 0; i < ops.length; ++i) {\n    out.push(ops[i]);\n    if (ops[i] >= 0x60 && ops[i] <= 0x7f && data[i]) out.push(...data[i]!);\n  }\n\n  // - CALLVALUE, load target address from calldata[0], GAS, CALL\n  // - RETURNDATACOPY(0, 0, RETURNDATASIZE)\n  // - RETURN(0, RETURNDATASIZE)\n  const bytecode = '0x' + _uint8ArrayToHex(new Uint8Array(out)) + '345f355af13d5f5f3e3d5ff3';\n  const calldataOut = '0x' + _normHex(originalTo).padStart(64, '0');\n\n  return {\n    bytecode,\n    calldata: calldataOut,\n    to: '0x' + decAddr.toString(16).padStart(40, '0'),\n    from: _normHex(fromAddr.toString(16)).padStart(40, '0'),\n    balance: selfbalance.toString(16),\n  };\n};\n", "import { _normHex } from './compiler/utils';\n\n/**\n * Generates FastLZ (LZ77) decompressor bytecode. The generated code decompresses incoming calldata and forwards it to the target address.\n * @param address - Target contract address\n * @see {@link https://github.com/Vectorized/solady/blob/main/src/utils/LibZip.sol}\n * @pure\n */\n//! @__PURE__\nexport const flzFwdBytecode = (address: string): string =>\n  `0x365f73${_normHex(address)}815b838110602f575f80848134865af1503d5f803e3d5ff35b803590815f1a8060051c908115609857600190600783149285831a6007018118840218600201948383011a90601f1660081b0101808603906020811860208211021890815f5b80830151818a015201858110609257505050600201019201916018565b82906075565b6001929350829150019101925f5b82811060b3575001916018565b85851060c1575b60010160a6565b936001818192355f1a878501530194905060ba56`;\n\n/**\n * Generates RLE (run-length encoded) decompressor bytecode. The generated code decompresses incoming calldata and forwards it to the target address.\n * @param address - Target contract address\n * @see {@link https://github.com/Vectorized/solady/blob/main/src/utils/LibZip.sol}\n * @pure\n */\n//! @__PURE__\nexport const rleFwdBytecode = (address: string): string =>\n  `0x5f5f5b368110602d575f8083813473${_normHex(address)}5af1503d5f803e3d5ff35b600180820192909160031981019035185f1a8015604c57815301906002565b505f19815282820192607f9060031981019035185f1a818111156072575b160101906002565b838101368437606a56`;\n"],
-  "mappings": "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",
-  "names": ["jit_compressor_exports", "__export", "compress_call", "__toCommonJS", "import_solady", "MAX_128_BIT", "MAX_256_BIT", "not", "a", "MAX_256_BIT", "and", "a", "b", "MAX_256_BIT", "or", "xor", "add", "sub", "shl", "shift", "value", "shr", "sigext", "byteSize", "numBytes", "mask", "signBit", "maskedVal", "_normHex", "hex", "_hexToUint8Array", "normalized", "len", "bytes", "i", "_uint8ArrayToHex", "initMemoryView", "calldata", "padding", "originalBuf", "buffer", "rawLength", "wordCount", "roundedLength", "words", "segments", "wordFreq", "wordStats", "prevWordHex", "wordIndex", "base", "word", "end", "wordHex", "existing", "isRunContinuation", "stats", "seg", "s", "reuseCost", "totalLiteralBytes", "totalReuseBytes", "zeroWord", "getWord", "getSegments", "mload", "offset", "out", "slice", "size", "_jitDecompressor", "calldata", "to", "from", "padding", "view", "initMemoryView", "decAddr", "originalTo", "_normHex", "fromAddr", "excluded", "selfbalance", "filtered", "word", "freq", "val", "max", "curr", "wordCount", "ops", "data", "stack", "trackedMemSize", "mem", "firstPass", "roundUp32", "x", "getStackIdx", "idx", "stackFreq", "stackLastUse", "pushCounter", "ctr", "m", "k", "delta", "pushOp", "op", "d", "pushS", "v", "freqDelta", "pop2", "trackMem", "offset", "size", "addOp", "imm", "byteSize", "sigext", "not", "a", "b", "xor", "and", "or", "add", "sub", "shift", "shl", "shr", "MAX_256_BIT", "value", "_", "opcode", "bytesLen", "n", "t", "pushCost", "pushN", "tmp", "bytes", "pushB", "buf", "plan", "emitPushN", "emitPushB", "emitOp", "o", "estShlCost", "seg", "cost", "first", "s", "e", "emitBestValueForWord", "literal", "literalVal", "literalCost", "shlCost", "bestCost", "bestEmit", "notVal", "notCost", "subVal", "subCost", "numBytes", "mask", "truncated", "signCost", "shiftBits", "shifted", "notShifted", "shiftNotCost", "suffix0s", "wordIndex", "base", "wordHex", "_uint8ArrayToHex", "runLen", "w2", "j", "stats", "baseBytes", "byte8s", "byte8sCost", "planOut", "reserved", "uses", "p", "net", "MAX_128_BIT", "step", "out", "i", "bytecode", "calldataOut", "flzFwdBytecode", "address", "_normHex", "rleFwdBytecode", "compress_call", "payload", "alg", "method", "params", "txObj", "blockParam", "overrides", "k", "originalSize", "inputData", "_normHex", "to", "from", "bytecode", "calldata", "decompressorAddress", "fromAddr", "balanceHex", "result", "_jitDecompressor", "jit", "flzData", "cdData", "flzFwdBytecode", "rleFwdBytecode", "stateOverride", "compressedTxObj"]
+  "sourcesContent": ["import { LibZip } from 'solady';\nimport { _jitDecompressor, DEC_ADDR } from './compiler';\nimport { _normHex } from './compiler/utils';\nimport { flzFwdBytecode, rleFwdBytecode } from './contracts';\nimport { MIN_BODY_SIZE } from './index';\n/**\n * Compresses eth_call payload using JIT, FastLZ (FLZ), or calldata RLE (CD) compression.\n * Auto-selects best algorithm if not specified. Only compresses if >800 bytes and beneficial.\n *\n * Only applies compression to calls that:\n * - have no state overrides\n * - have a target address and calldata\n * - have no other properties (nonce, gas, etc.)\n *\n * @param payload - eth_call RPC payload\n * @param alg - 'jit' | 'flz' | 'cd' | undefined (auto)\n * @returns (un)compressed eth_call payload\n * @pure\n */\n//! @__PURE__\nexport const compress_call = function (payload: any, alg?: string): any {\n  const { method, params } = payload;\n  if (method && method !== 'eth_call') return payload;\n  const txObj = params?.[0] || payload;\n  const blockParam = params?.[1];\n  const overrides = params?.[2];\n\n  // Validation\n  if (\n    !txObj?.to ||\n    !txObj?.data ||\n    (() => {\n      if (overrides) for (const _ in overrides) return true;\n      for (const k in txObj) if (k !== 'to' && k !== 'data' && k !== 'from') return true;\n      return false;\n    })()\n  ) {\n    return payload;\n  }\n\n  const originalSize = txObj.data.length;\n  if (originalSize < MIN_BODY_SIZE) return payload;\n\n  const inputData = txObj.data;\n  const to = txObj.to;\n  const from = txObj.from;\n\n  let bytecode: string;\n  let calldata: string;\n  let decompressorAddress: string;\n  let fromAddr: string | undefined;\n  let balanceHex: string;\n\n  if (alg === 'jit' || (!alg && (originalSize < 3000 || originalSize >= 8000))) {\n    const result = _jitDecompressor(inputData, to, from);\n    bytecode = result.bytecode;\n    calldata = result.calldata;\n    decompressorAddress = result.to;\n    fromAddr = result.from;\n    balanceHex = result.balance;\n  } else {\n    const jit = !alg ? _jitDecompressor(inputData, to, from) : null;\n    const flzData = alg === 'flz' || !alg ? LibZip.flzCompress(inputData) : null;\n    const cdData = alg === 'cd' || (!alg && flzData) ? LibZip.cdCompress(inputData) : null;\n    const useFlz =\n      alg === 'flz' || (!alg && flzData && (!cdData || flzData.length < cdData.length));\n\n    if (useFlz) {\n      calldata = flzData!;\n      bytecode = flzFwdBytecode(to);\n    } else {\n      calldata = cdData!;\n      bytecode = rleFwdBytecode(to);\n    }\n\n    decompressorAddress = DEC_ADDR;\n    fromAddr = from ? _normHex(from).padStart(16, '0') : undefined;\n    balanceHex = '0';\n    if (\n      !alg &&\n      jit &&\n      jit.bytecode.length + jit.calldata.length < bytecode.length + calldata.length\n    ) {\n      bytecode = jit.bytecode;\n      calldata = jit.calldata;\n      decompressorAddress = jit.to;\n      fromAddr = jit.from;\n      balanceHex = jit.balance;\n    }\n  }\n\n  // Skip if not beneficial\n  if (bytecode.length + calldata.length >= originalSize) return payload;\n\n  const stateOverride: any = {\n    code: bytecode,\n    balance: '0x' + balanceHex,\n  };\n\n  const compressedTxObj: any = { to: decompressorAddress, data: calldata };\n\n  if (fromAddr) compressedTxObj.from = '0x' + fromAddr;\n\n  return {\n    ...payload,\n    params: [compressedTxObj, blockParam, { ...overrides, [decompressorAddress]: stateOverride }],\n  };\n};\n", "export const MAX_128_BIT = (1n << 128n) - 1n;\nexport const MAX_256_BIT = (1n << 256n) - 1n;\n", "import { MAX_256_BIT } from './constants';\n\nexport const not = (a: bigint): bigint => ~a & MAX_256_BIT;\nexport const eq = (a: bigint, b: bigint): bigint => (a === b ? 1n : 0n);\nexport const and = (a: bigint, b: bigint): bigint => a & b & MAX_256_BIT;\nexport const or = (a: bigint, b: bigint): bigint => (a | b) & MAX_256_BIT;\nexport const xor = (a: bigint, b: bigint): bigint => (a ^ b) & MAX_256_BIT;\n\nexport const add = (a: bigint, b: bigint): bigint => (a + b) & MAX_256_BIT;\nexport const sub = (a: bigint, b: bigint): bigint => (a - b) & MAX_256_BIT;\n\nexport const shl = (shift: bigint, value: bigint): bigint => (value << shift) & MAX_256_BIT;\nexport const shr = (shift: bigint, value: bigint): bigint => (value >> shift) & MAX_256_BIT;\n\nexport const sigext = (byteSize: bigint, value: bigint): bigint => {\n  if (byteSize >= 31n) return value & MAX_256_BIT;\n  const bits = Number((byteSize + 1n) * 8n);\n  return BigInt.asUintN(256, BigInt.asIntN(bits, value));\n};\n\nexport const clz = (value: bigint): bigint => {\n  if (value === 0n) return 256n;\n  let count = 0n;\n  let mask = 1n << 255n;\n  while ((value & mask) === 0n && count < 256n) {\n    count++;\n    mask >>= 1n;\n  }\n  return count;\n};\n", "export const _normHex = (hex: string): string =>\n  (hex.charCodeAt(0) === 48 && (hex.charCodeAt(1) | 32) === 120 ? hex.slice(2) : hex).toLowerCase();\n\nconst _hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0')),\n  _nibbles = (() => {\n    const t = new Int8Array(103).fill(-1);\n    for (let i = 0; i < 10; i++) t[48 + i] = i;\n    for (let i = 0; i < 6; i++) t[97 + i] = 10 + i;\n    return t;\n  })();\n\nexport const _hexToUint8Array = (hex: string): Uint8Array => {\n  const normalized = _normHex(hex);\n  const len = normalized.length;\n  const bytes = new Uint8Array(len / 2);\n  for (let i = 0, j = 0; i < len; i += 2) {\n    bytes[j++] = (_nibbles[normalized.charCodeAt(i)] << 4) | _nibbles[normalized.charCodeAt(i + 1)];\n  }\n  return bytes;\n};\n\nexport const _uint8ArrayToHex = (bytes: Uint8Array): string => {\n  let hex = '';\n  for (let i = 0; i < bytes.length; i++) hex += _hexes[bytes[i]]!;\n  return hex;\n};\n\nexport type MemorySegment = number; // (s << 8) | e, both in [0..31]\nconst _zeroWord = new Uint8Array(32);\nconst _emptySegments: MemorySegment[] = [];\n\nexport type WordStats = [\n  freq: number,\n  normFreq: number,\n  firstWordIndex: number,\n  lastWordIndex: number,\n  firstOffset: number,\n  lastOffset: number,\n  reuseCost: number,\n];\n\nexport interface MemoryView {\n  /** Normalized hex string (without 0x) of the original payload. */\n  readonly hex: string;\n  /** Backing buffer containing `padding` zero bytes followed by the payload. */\n  readonly buffer: Uint8Array;\n  /** Total length of the backing buffer (padding + payload length), rounded up to full words. */\n  readonly roundedLength: number;\n  /** Number of zero bytes prefixed before the payload. */\n  readonly padding: number;\n  /** Length of the original (unpadded) payload in bytes. */\n  readonly dataLength: number;\n  /** Number of 32-byte words in this view. */\n  readonly wordCount: number;\n  /** Hex string (without 0x) for each 32-byte word in the view. */\n  readonly wordHexes: readonly string[];\n  readonly wordStats: ReadonlyMap<string, WordStats>;\n  /** Return the nth 32-byte word (zero-padded on the right if incomplete). */\n  getWord(wordIndex: number): Uint8Array;\n  /** Return all non-zero byte segments (packed as (s<<8)|e) within the nth 32-byte word. */\n  getSegments(wordIndex: number): MemorySegment[];\n  mload(offset: number): Uint8Array;\n  /**\n   * Read an arbitrary slice starting at `offset` for `size` bytes,\n   * padding with zeros when reading past `length`.\n   */\n  slice(offset: number, size: number): Uint8Array;\n}\n\nexport const initMemoryView = (calldata: string, padding: number): MemoryView => {\n  const hex = _normHex(calldata);\n  const originalBuf = _hexToUint8Array(hex);\n  let buffer = new Uint8Array(padding + originalBuf.length);\n  buffer.set(originalBuf, padding);\n  const rawLength = buffer.length;\n  const wordCount = Math.ceil(rawLength / 32);\n  const roundedLength = wordCount * 32;\n  if (rawLength !== roundedLength) {\n    const rounded = new Uint8Array(roundedLength);\n    rounded.set(buffer, 0);\n    buffer = rounded;\n  }\n\n  const segments: MemorySegment[][] = new Array(wordCount);\n  const wordHexes: string[] = new Array(wordCount);\n  const wordStats = new Map<string, WordStats>();\n\n  let prevWordHex: string | null = null;\n  const wordAt = (wordIndex: number) => {\n    const base = wordIndex << 5;\n    return buffer.subarray(base, base + 32);\n  };\n\n  for (let wordIndex = 0; wordIndex < wordCount; wordIndex++) {\n    const base = wordIndex << 5;\n    const word = wordAt(wordIndex);\n\n    const wordHex = _uint8ArrayToHex(word);\n    wordHexes[wordIndex] = wordHex;\n    const existing = wordStats.get(wordHex);\n    const isRunContinuation = prevWordHex === wordHex;\n    if (!existing) {\n      const stats: WordStats = [1, 1, wordIndex, wordIndex, base, base, -1];\n      wordStats.set(wordHex, stats);\n    } else {\n      existing[0] += 1;\n      if (!isRunContinuation) existing[1] += 1;\n      existing[3] = wordIndex;\n      existing[5] = base;\n    }\n    prevWordHex = wordHex;\n\n    const seg: MemorySegment[] = [];\n    for (let i = 0; i < 32; ) {\n      while (i < 32 && word[i] === 0) ++i;\n      if (i >= 32) break;\n      const s = i;\n      while (i < 32 && word[i] !== 0) ++i;\n      seg.push((s << 8) | (i - 1));\n    }\n    segments[wordIndex] = seg;\n  }\n\n  for (const stats of wordStats.values()) {\n    const baseBytes = stats[4] === 0 ? 0 : (32 - Math.clz32(stats[4]) + 7) >> 3;\n    const reuseCost = baseBytes + 3;\n    stats[6] = 32 > reuseCost ? reuseCost : -1;\n  }\n\n  const getWord = (wordIndex: number): Uint8Array => {\n    return wordIndex < 0 || wordIndex >= wordCount ? _zeroWord : wordAt(wordIndex);\n  };\n\n  const getSegments = (wordIndex: number): MemorySegment[] => {\n    return wordIndex < 0 || wordIndex >= wordCount ? _emptySegments : segments[wordIndex];\n  };\n\n  const slice = (offset: number, size: number): Uint8Array => {\n    if (size <= 0) return new Uint8Array(0);\n    const out = new Uint8Array(size);\n    if (offset < 0 || offset >= rawLength) return out;\n    const end = Math.min(offset + size, rawLength);\n    out.set(buffer.subarray(offset, end), 0);\n    return out;\n  };\n\n  const mload = (offset: number): Uint8Array => slice(offset, 32);\n\n  return {\n    hex,\n    buffer,\n    roundedLength,\n    padding,\n    dataLength: originalBuf.length,\n    wordCount,\n    wordHexes,\n    wordStats,\n    getWord,\n    getSegments,\n    mload,\n    slice,\n  };\n};\n", "import { MAX_128_BIT, MAX_256_BIT } from './constants';\nimport { add, and, not, or, shl, shr, sigext, sub, xor } from './opcodes';\nimport { _normHex, _uint8ArrayToHex, initMemoryView, MemorySegment } from './utils';\nexport const DEC_ADDR = '0x00000000000000000000000000000000000000e0';\n\nconst _pad64 = (s: string) => s.padStart(64, '0'),\n  _zeroW = _pad64('0'),\n  _cdsizeW = _pad64('20'),\n  _decW = _pad64('e0'),\n  _retSuffix = '345f355af13d5f5f3e3d5ff3';\n\nexport const _jitDecompressor = function (\n  calldata: string,\n  to: string,\n  from?: string,\n): { bytecode: string; calldata: string; to: string; from?: string; balance: string } {\n  const fromHex = from ? _normHex(from) : null;\n\n  let padding = 28,\n    bestW: string | null = null,\n    bestF = 0,\n    originalTo = _normHex(to).padStart(16, '0'),\n    fromAddr = fromHex ? BigInt('0x' + fromHex) : 96n,\n    selfbalance = 2n,\n    ops: number[] = [],\n    data: (Uint8Array | null)[] = [],\n    stack: bigint[] = [],\n    trackedMemSize = 0,\n    mem: bigint[] = [],\n    firstPass = true;\n\n  const view = initMemoryView(calldata, padding);\n  const { wordCount } = view;\n\n  const decAddr = 224n,\n    stackFreq = new Map<bigint, number>(),\n    decW = _decW,\n    fromW = _pad64(fromHex ?? fromAddr.toString(16)),\n    toW = _pad64(originalTo);\n\n  for (const [w, st] of view.wordStats) {\n    const f = st[0];\n    if (w === _zeroW || w === _cdsizeW || w === decW || w === fromW || w === toW) continue;\n    if (f > bestF) (bestF = f), (bestW = w);\n  }\n  if (bestW) selfbalance = BigInt('0x' + bestW);\n\n  const roundUp32 = (x: number) => (x + 31) & ~31;\n\n  const getStackIdx = (val: bigint): number => {\n    for (let i = stack.length - 1, d = 0; d < 16 && i >= 0; --i, ++d) {\n      if (stack[i] === val) return d;\n    }\n    return -1;\n  };\n\n  const ctr = <K>(m: Map<K, number>, k: K, delta: number) => m.set(k, (m.get(k) || 0) + delta);\n\n  const pushOp = (op: number, d?: Uint8Array | null) => {\n    ops.push(op);\n    data.push(d ?? null);\n  };\n\n  const pushS = (v: bigint, freqDelta: number = 1) => {\n    stack.push(v);\n    if (freqDelta !== 0) ctr(stackFreq, v, freqDelta);\n  };\n\n  const pop2 = (): [bigint, bigint] => [stack.pop()!, stack.pop()!];\n\n  const trackMem = (offset: number, size: number) => {\n    trackedMemSize = roundUp32(offset + size);\n  };\n\n  const addOp = (op: number, imm?: Uint8Array) => {\n    if (op === 0x80) {\n      // DUP1\n      pushS(stack[stack.length - 1]!, firstPass ? 0 : 1);\n    }\n    if (op === 0x50) stack.pop();\n    if (op === 0x47) pushS(selfbalance, 0);\n    if (op === 0x30) pushS(decAddr, 0);\n    if (op === 0x33) pushS(fromAddr, 0);\n    if (op === 0x36) pushS(32n, 0);\n    if (op === 0x59) pushS(BigInt(trackedMemSize), 0);\n    if (op === 0x0b) {\n      // SIGNEXTEND\n      const [byteSize, val] = pop2();\n      pushS(sigext(byteSize, val), 1);\n    }\n    if (op === 0x19) {\n      // NOT\n      pushS(not(stack.pop()!), 0);\n    }\n    if (op === 0x18) {\n      // XOR\n      const [a, b] = pop2();\n      pushS(xor(a, b), 1);\n    }\n    if (op === 0x16) {\n      // AND\n      const [a, b] = pop2();\n      pushS(and(a, b), 1);\n    }\n    if (op === 0x17) {\n      // OR\n      const [a, b] = pop2();\n      pushS(or(a, b), 1);\n    }\n    if (op === 0x01) {\n      // ADD\n      const [a, b] = pop2();\n      pushS(add(a, b), 1);\n    }\n    if (op === 0x03) {\n      // SUB\n      const [a, b] = pop2();\n      pushS(sub(b, a), 1);\n    }\n    if (op === 0x1b) {\n      // SHL\n      const [shift, val] = pop2();\n      pushS(shl(shift, val), 1);\n    }\n    if (op === 0x1c) {\n      // SHR\n      const [shift, val] = pop2();\n      pushS(shr(shift, val), 1);\n    }\n    if ((op >= 0x60 && op <= 0x7f) || op === 0x5f) {\n      let v = 0n; // PUSH* and PUSH0\n      for (const b of imm || []) v = (v << 8n) | BigInt(b);\n      if (v === selfbalance) {\n        pushS(v, 0);\n        pushOp(0x47);\n        return;\n      }\n      if (v === decAddr) {\n        pushS(v, 0);\n        pushOp(0x30);\n        return;\n      }\n      if (v === fromAddr) {\n        pushS(v, 0);\n        pushOp(0x33); // FROM ADDRESS\n        return;\n      }\n      if (v === 32n) {\n        pushS(v, 0);\n        pushOp(0x36); // CALLDATASIZE\n        return;\n      }\n      if (v === BigInt(trackedMemSize) && v != 0n) {\n        pushS(v, 0);\n        pushOp(0x59);\n        return;\n      }\n      const idx = getStackIdx(v);\n      if (idx != -1 && op != 0x5f) {\n        const freqDelta = firstPass ? 1 : 0;\n        pushS(v, freqDelta);\n        pushOp(0x80 + idx);\n        return;\n      }\n      if (v === MAX_256_BIT) {\n        pushS(v, 0);\n        pushOp(0x5f); // PUSH0\n        pushOp(0x19); // NOT\n        return;\n      }\n      pushS(v, 1);\n      pushOp(op, imm || null);\n      return;\n    }\n    if (op === 0x51) {\n      // MLOAD\n      pushS(mem[Number(stack.pop()!) >>> 5] ?? 0n, 0);\n    }\n    if (op === 0x52) {\n      // MSTORE\n      const [offset, value] = pop2();\n      const k = Number(offset);\n      mem[k >>> 5] = value & MAX_256_BIT;\n      trackMem(k, 32);\n    }\n    if (op === 0x53) {\n      // MSTORE8\n      const [offset, _] = pop2();\n      trackMem(Number(offset), 1);\n    }\n    pushOp(op, imm || null);\n  };\n\n  const op = (opcode: number) => addOp(opcode);\n\n  const bytesLen = (v: bigint): number => {\n    if (v === 0n) return 0;\n    let n = 0;\n    let t = v < 0n ? -v : v;\n    while (t > 0n) {\n      ++n;\n      t >>= 8n;\n    }\n    return n;\n  };\n\n  const pushCost = (v: bigint): number => (v === 0n ? 1 : 1 + bytesLen(v));\n\n  const pushN = (value: number | bigint) => {\n    const v = typeof value === 'bigint' ? value : BigInt(value);\n    if (v > 0n && v === BigInt(trackedMemSize)) return addOp(0x59);\n    if (v === 32n) return addOp(0x36);\n    if (v === 0n) return addOp(0x5f);\n\n    let tmp = v;\n    const len = bytesLen(tmp);\n    const bytes = new Uint8Array(len);\n    for (let i = len - 1; i >= 0; --i) {\n      bytes[i] = Number(tmp & 0xffn);\n      tmp >>= 8n;\n    }\n    return addOp(0x5f + len, bytes);\n  };\n\n  const pushB = (buf: Uint8Array) => addOp(0x5f + buf.length, buf);\n\n  type PlanStep =\n    | { t: 'num'; v: number | bigint }\n    | { t: 'bytes'; b: Uint8Array }\n    | { t: 'op'; o: number };\n\n  const plan: PlanStep[] = [];\n\n  const emitPushN = (v: number | bigint) => {\n    plan.push({ t: 'num', v });\n    pushN(v);\n  };\n  const emitPushB = (b: Uint8Array) => {\n    plan.push({ t: 'bytes', b });\n    pushB(b);\n  };\n  const emitOp = (o: number) => {\n    plan.push({ t: 'op', o });\n    op(o);\n  };\n\n  const estShlCost = (seg: MemorySegment[]) => {\n    let cost = 0;\n    let first = true;\n    for (let i = 0; i < seg.length; i++) {\n      const se = seg[i]!;\n      const s = se >>> 8,\n        e = se & 0xff;\n      cost += 1 + (e - s + 1); // PUSH<n> immediate bytes\n      if (31 - e > 0) cost += 3; // PUSH1 shift + SHL\n      if (!first) cost += 1; // OR\n      first = false;\n    }\n    return cost;\n  };\n\n  const emitBestValueForWord = (word: Uint8Array, seg: MemorySegment[]) => {\n    const literal = word.subarray(seg[0]! >>> 8);\n    let literalVal = 0n;\n    for (let i = 0; i < literal.length; i++) literalVal = (literalVal << 8n) | BigInt(literal[i]!);\n    const literalCost = literal.length + 1;\n    const shlCost = estShlCost(seg);\n    let bestCost = literalCost;\n    let bestEmit: () => void = () => emitPushB(literal);\n    // Try NOT: PUSH(~x) NOT\n    const notVal = not(literalVal);\n    const notCost = pushCost(notVal) + 1;\n    if (notCost < bestCost) {\n      bestCost = notCost;\n      bestEmit = () => {\n        emitPushN(notVal);\n        emitOp(0x19);\n      };\n    }\n\n    // Try SUB: PUSH0, PUSH(x), SUB\n    const subVal = sub(0n, literalVal);\n    const subCost = pushCost(subVal) + 2;\n    if (subCost < bestCost) {\n      bestCost = subCost;\n      bestEmit = () => {\n        emitPushN(0);\n        emitPushN(subVal);\n        emitOp(0x03);\n      };\n    }\n\n    // Try SIGNEXTEND\n    for (let numBytes = 1; numBytes < literal.length; numBytes++) {\n      const mask = (1n << BigInt(numBytes * 8)) - 1n;\n      const truncated = literalVal & mask;\n      const extended = sigext(BigInt(numBytes - 1), truncated);\n      if (\n        extended === literalVal &&\n        (truncated & (1n << BigInt(numBytes * 8 - 1))) !== 0n // must be negative in that width\n      ) {\n        const signCost = pushCost(truncated) + 3; // PUSH + PUSH1 + SIGNEXTEND\n        if (signCost < bestCost) {\n          bestCost = signCost;\n          bestEmit = () => {\n            emitPushN(truncated);\n            emitPushN(numBytes - 1);\n            emitOp(0x0b);\n          };\n        }\n        break;\n      }\n    }\n\n    // Try SHIFT+NOT\n    for (let shiftBits = 8; shiftBits <= 248; shiftBits += 8) {\n      const shifted = shr(BigInt(shiftBits), literalVal);\n      if (shifted === 0n) break;\n\n      const notShifted = not(shifted);\n      const reconstructed = shl(BigInt(shiftBits), notShifted);\n      if (reconstructed === literalVal) {\n        const shiftNotCost = pushCost(notShifted) + pushCost(BigInt(shiftBits)) + 2; // PUSH + PUSH + SHL + NOT\n        if (shiftNotCost < bestCost) {\n          bestCost = shiftNotCost;\n          bestEmit = () => {\n            emitPushN(notShifted);\n            emitPushN(shiftBits);\n            emitOp(0x1b);\n            emitOp(0x19);\n          };\n        }\n      }\n    }\n    // Try SHL/OR\n    if (shlCost < bestCost) {\n      bestCost = shlCost;\n      bestEmit = () => {\n        let first = true;\n        for (let i = 0; i < seg.length; i++) {\n          const se = seg[i]!;\n          const s = se >>> 8,\n            e = se & 0xff;\n          const suffix0s = 31 - e;\n          emitPushB(word.subarray(s, e + 1));\n          if (suffix0s > 0) {\n            emitPushN(suffix0s * 8);\n            emitOp(0x1b); // SHL\n          }\n          if (!first) emitOp(0x17); // OR\n          first = false;\n        }\n      };\n    }\n    return { literal, literalVal, bestCost, bestEmit, literalCost, shlCost };\n  };\n\n  let wordIndex = 0;\n  while (wordIndex < wordCount) {\n    const base = wordIndex * 32;\n    const word = view.getWord(wordIndex);\n    const seg = view.getSegments(wordIndex);\n    if (!seg.length) {\n      ++wordIndex;\n      continue;\n    }\n\n    const wordHex = view.wordHexes[wordIndex]!;\n    // Encode Run?\n    let nextIndex = wordIndex + 1;\n    while (nextIndex < wordCount) {\n      const s2 = view.getSegments(nextIndex);\n      if (!s2.length) break;\n      if (view.wordHexes[nextIndex] !== wordHex) break;\n      ++nextIndex;\n    }\n    const runLen = nextIndex - wordIndex;\n\n    if (runLen >= 2) {\n      const lastIndex = nextIndex - 1;\n      const { bestEmit } = emitBestValueForWord(word, seg);\n      // First store: keep word value on stack.\n      bestEmit(); // push value\n      emitOp(0x80); // DUP1 (keep value)\n      emitPushN(base); // offset (MSIZE if aligned)\n      emitOp(0x52); // MSTORE\n\n      for (let j = 1; j < runLen; j++) {\n        emitOp(0x80); // DUP1\n        emitOp(0x59); // MSIZE\n        emitOp(0x52); // MSTORE\n      }\n      const stats = view.wordStats.get(wordHex);\n      if (stats && stats[3] <= lastIndex) {\n        emitOp(0x50); // POP\n      }\n      wordIndex = nextIndex;\n      continue;\n    }\n\n    const { literalCost, shlCost, bestCost, bestEmit } = emitBestValueForWord(word, seg);\n    // Try MLOAD/MSTORE reuse\n    if (literalCost > 8) {\n      const stats = view.wordStats.get(wordHex);\n      if (stats && stats[6] !== -1 && wordIndex > stats[2]) {\n        const baseBytes = stats[4] === 0 ? 0 : (32 - Math.clz32(stats[4]) + 7) >> 3;\n        if (literalCost > stats[6] + baseBytes) {\n          emitPushN(stats[4]);\n          emitOp(0x51); // MLOAD\n          emitPushN(base);\n          emitOp(0x52); // MSTORE\n          ++wordIndex;\n          continue;\n        }\n      }\n    }\n    let byte8s = true;\n    for (let i = 0; i < seg.length; i++) {\n      const se = seg[i]!;\n      if (se >>> 8 !== (se & 0xff)) {\n        byte8s = false;\n        break;\n      }\n    }\n    const byte8sCost = seg.length * 3; // PUSH1(value), PUSH1(offset), MSTORE8\n    if (byte8s && byte8sCost < bestCost && byte8sCost <= shlCost) {\n      for (let i = 0; i < seg.length; i++) {\n        const s = seg[i]! >>> 8;\n        emitPushN(word[s]);\n        emitPushN(base + s);\n        emitOp(0x53); // MSTORE8\n      }\n      ++wordIndex;\n      continue;\n    }\n    // Default\n    bestEmit();\n    emitPushN(base);\n    emitOp(0x52); // MSTORE\n    ++wordIndex;\n  }\n\n  //2nd pass: preseed dictionary + emit final ops\n  ops = [];\n  data = [];\n  stack = [];\n  trackedMemSize = 0;\n  mem = [];\n  firstPass = false;\n\n  const pre: { val: bigint; uses: number; net: number; p: number }[] = [];\n  for (const [val, uses] of stackFreq) {\n    if (\n      uses > 1 &&\n      val !== 0n &&\n      val !== 32n &&\n      val !== selfbalance &&\n      val !== decAddr &&\n      val !== fromAddr &&\n      val <= MAX_128_BIT\n    ) {\n      const p = pushCost(val);\n      const net = uses * (p - 1) - p;\n      if (net > 0) pre.push({ val, uses, net, p });\n    }\n  }\n\n  pre.sort((a, b) => b.net - a.net || b.uses - a.uses || a.p - b.p);\n  for (let i = 0; i < 15 && i < pre.length; ++i) pushN(pre[i]!.val);\n\n  for (const step of plan) {\n    if (step.t === 'num') pushN(step.v);\n    else if (step.t === 'bytes') pushB(step.b);\n    else if (step.t === 'op') op(step.o);\n  }\n\n  // CALL stack layout (top to bottom): gas, address, value, argsOffset, argsSize, retOffset, retSize\n  //\n  // - 0x5f5f: PUSH0 PUSH0 (retSize=0, retOffset=0)\n  // - pushN(view.dataLength): argsSize\n  // - pushN(padding): argsOffset (skip leading alignment bytes)\n  // - 0x34: CALLVALUE (value)\n  // - 0x5f35: PUSH0 CALLDATALOAD (address from calldata[0])\n  // - 0x5a: GAS (remaining gas)\n  // - 0xf1: CALL\n  //\n  // RETURNDATACOPY(destOffset=0, offset=0, length=RETURNDATASIZE):\n  // - 0x3d5f5f3e: RETURNDATASIZE PUSH0 PUSH0 RETURNDATACOPY\n  //\n  // RETURN(offset=0, size=RETURNDATASIZE):\n  // - 0x3d5ff3: RETURNDATASIZE PUSH0 RETURN\n\n  op(0x5f); // PUSH0 (retSize)\n  op(0x5f); // PUSH0 (retOffset)\n  pushN(view.dataLength); // argsSize = actual data length\n  pushN(padding); // argsOffset = padding\n\n  // - CALLVALUE, load target address from calldata[0], GAS, CALL\n  // - RETURNDATACOPY(0, 0, RETURNDATASIZE)\n  // - RETURN(0, RETURNDATASIZE)\n  let outLen = ops.length;\n\n  for (let i = 0; i < ops.length; ++i)\n    if (ops[i] >= 0x60 && ops[i] <= 0x7f && data[i]) outLen += data[i]!.length;\n\n  const out = new Uint8Array(outLen);\n\n  for (let i = 0, o = 0; i < ops.length; ++i) {\n    out[o++] = ops[i]!;\n    if (ops[i] >= 0x60 && ops[i] <= 0x7f && data[i]) out.set(data[i]!, o), (o += data[i]!.length);\n  }\n\n  const bytecode = '0x' + _uint8ArrayToHex(out) + _retSuffix;\n  const calldataOut = '0x' + _pad64(originalTo);\n\n  return {\n    bytecode,\n    calldata: calldataOut,\n    to: DEC_ADDR,\n    from: fromAddr.toString(16).padStart(40, '0'),\n    balance: selfbalance.toString(16),\n  };\n};\n", "import { _normHex } from './compiler/utils';\n\n/**\n * Generates FastLZ (LZ77) decompressor bytecode. The generated code decompresses incoming calldata and forwards it to the target address.\n * @param address - Target contract address\n * @see {@link https://github.com/Vectorized/solady/blob/main/src/utils/LibZip.sol}\n * @pure\n */\n//! @__PURE__\nexport const flzFwdBytecode = (address: string): string =>\n  `0x365f73${_normHex(address)}815b838110602f575f80848134865af1503d5f803e3d5ff35b803590815f1a8060051c908115609857600190600783149285831a6007018118840218600201948383011a90601f1660081b0101808603906020811860208211021890815f5b80830151818a015201858110609257505050600201019201916018565b82906075565b6001929350829150019101925f5b82811060b3575001916018565b85851060c1575b60010160a6565b936001818192355f1a878501530194905060ba56`;\n\n/**\n * Generates RLE (run-length encoded) decompressor bytecode. The generated code decompresses incoming calldata and forwards it to the target address.\n * @param address - Target contract address\n * @see {@link https://github.com/Vectorized/solady/blob/main/src/utils/LibZip.sol}\n * @pure\n */\n//! @__PURE__\nexport const rleFwdBytecode = (address: string): string =>\n  `0x5f5f5b368110602d575f8083813473${_normHex(address)}5af1503d5f803e3d5ff35b600180820192909160031981019035185f1a8015604c57815301906002565b505f19815282820192607f9060031981019035185f1a818111156072575b160101906002565b838101368437606a56`;\n"],
+  "mappings": "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",
+  "names": ["jit_compressor_exports", "__export", "compress_call", "__toCommonJS", "import_solady", "MAX_128_BIT", "MAX_256_BIT", "not", "a", "MAX_256_BIT", "and", "a", "b", "MAX_256_BIT", "or", "xor", "add", "sub", "shl", "shift", "value", "shr", "sigext", "byteSize", "bits", "_normHex", "hex", "_hexes", "_", "i", "_nibbles", "t", "_hexToUint8Array", "normalized", "len", "bytes", "j", "_uint8ArrayToHex", "_zeroWord", "_emptySegments", "initMemoryView", "calldata", "padding", "originalBuf", "buffer", "rawLength", "wordCount", "roundedLength", "rounded", "segments", "wordHexes", "wordStats", "prevWordHex", "wordAt", "wordIndex", "base", "word", "wordHex", "existing", "isRunContinuation", "stats", "seg", "s", "reuseCost", "getWord", "getSegments", "slice", "offset", "size", "out", "end", "mload", "DEC_ADDR", "_pad64", "s", "_zeroW", "_cdsizeW", "_decW", "_retSuffix", "_jitDecompressor", "calldata", "to", "from", "fromHex", "_normHex", "padding", "bestW", "bestF", "originalTo", "fromAddr", "selfbalance", "ops", "data", "stack", "trackedMemSize", "mem", "firstPass", "view", "initMemoryView", "wordCount", "decAddr", "stackFreq", "decW", "fromW", "toW", "w", "st", "f", "roundUp32", "x", "getStackIdx", "val", "i", "d", "ctr", "m", "k", "delta", "pushOp", "op", "pushS", "v", "freqDelta", "pop2", "trackMem", "offset", "size", "addOp", "imm", "byteSize", "sigext", "not", "a", "b", "xor", "and", "or", "add", "sub", "shift", "shl", "shr", "idx", "MAX_256_BIT", "value", "_", "opcode", "bytesLen", "n", "t", "pushCost", "pushN", "tmp", "len", "bytes", "pushB", "buf", "plan", "emitPushN", "emitPushB", "emitOp", "o", "estShlCost", "seg", "cost", "first", "se", "e", "emitBestValueForWord", "word", "literal", "literalVal", "literalCost", "shlCost", "bestCost", "bestEmit", "notVal", "notCost", "subVal", "subCost", "numBytes", "mask", "truncated", "signCost", "shiftBits", "shifted", "notShifted", "shiftNotCost", "suffix0s", "wordIndex", "base", "wordHex", "nextIndex", "runLen", "lastIndex", "j", "stats", "baseBytes", "byte8s", "byte8sCost", "pre", "uses", "MAX_128_BIT", "p", "net", "step", "outLen", "out", "bytecode", "_uint8ArrayToHex", "calldataOut", "flzFwdBytecode", "address", "_normHex", "rleFwdBytecode", "compress_call", "payload", "alg", "method", "params", "txObj", "blockParam", "overrides", "_", "k", "originalSize", "inputData", "to", "from", "bytecode", "calldata", "decompressorAddress", "fromAddr", "balanceHex", "result", "_jitDecompressor", "jit", "flzData", "cdData", "flzFwdBytecode", "rleFwdBytecode", "DEC_ADDR", "_normHex", "stateOverride", "compressedTxObj"]
 }

package/_esm/index.js

@@ -1,2 +1,2 @@
-var b=1150,h=new Map,m=["gzip","deflate"];async function w(o,e,s){let p=o instanceof Request?o:null,a=typeof o=="string"?o:o instanceof Request?o.url:o.toString(),t=typeof(e==null?void 0:e.body)=="string"?e.body:null;if(typeof s=="function"){if(p&&!e)return fetch(p);let n=e==null?void 0:e.body;if(t)try{let c=s(JSON.parse(t));c!==void 0&&(n=JSON.stringify(c))}catch{}return fetch(p??a,{...e,body:n})}let r=h.get(a),S=typeof CompressionStream<"u",u=s==="gzip"||s==="deflate",d=S?u?s:s==="proactive"?r===-1?null:r??"gzip":typeof r=="string"?r:null:null,g=!!d&&!!t&&t.length>=1150,f={...e,priority:"high"},y=new Headers(f.headers);g&&(f.body=await new Response(new Blob([t]).stream().pipeThrough(new CompressionStream(d))).blob(),y.set("Content-Encoding",d)),f.headers=y;let i=await fetch(p??a,f);if(!u&&r===void 0){let n=i.headers.get("Accept-Encoding"),c=(n==null?void 0:n.split(",").map(l=>l.trim()).find(l=>m.includes(l)))??-1;h.set(a,s==="proactive"&&g&&i.ok?d:c)}return i}export{b as MIN_BODY_SIZE,w as compressModule};
+var b=1150,S=typeof CompressionStream<"u",h=new Map,m=["gzip","deflate"];async function w(o,e,s){let p=o instanceof Request?o:null,a=typeof o=="string"?o:o instanceof Request?o.url:o.toString(),t=typeof(e==null?void 0:e.body)=="string"?e.body:null;if(typeof s=="function"){if(p&&!e)return fetch(p);let n=e==null?void 0:e.body;if(t)try{let c=s(JSON.parse(t));c!==void 0&&(n=JSON.stringify(c))}catch{}return fetch(p??a,{...e,body:n})}let r=h.get(a),u=s==="gzip"||s==="deflate",d=S?u?s:s==="proactive"?r===-1?null:r??"gzip":typeof r=="string"?r:null:null,g=!!d&&!!t&&t.length>=1150,f={...e,priority:"high"},y=new Headers(f.headers);g&&(f.body=await new Response(new Blob([t]).stream().pipeThrough(new CompressionStream(d))).blob(),y.set("Content-Encoding",d)),f.headers=y;let i=await fetch(p??a,f);if(!u&&r===void 0){let n=i.headers.get("Accept-Encoding"),c=(n==null?void 0:n.split(",").map(l=>l.trim()).find(l=>m.includes(l)))??-1;h.set(a,s==="proactive"&&g&&i.ok?d:c)}return i}export{b as MIN_BODY_SIZE,w as compressModule};
 //# sourceMappingURL=index.js.map

package/_esm/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/index.ts"],
-  "sourcesContent": ["export const MIN_BODY_SIZE = 1150;\n\nconst _cache = new Map<string, string | -1>();\nconst _enc = ['gzip', 'deflate'] as const;\ntype SupportedEncoding = (typeof _enc)[number];\n\nexport type PayloadTransform = (payload: unknown) => unknown;\nexport type CompressionMode = 'passive' | 'proactive' | 'gzip' | 'deflate' | PayloadTransform;\n\n/**\n * @param input - URL or Request\n * @param init - Request options\n * @param mode - Compression mode:\n *   - 'passive' (default): discover support via Accept-Encoding header first\n *   - 'proactive': compress with gzip first, adjust if server rejects\n *   - 'gzip' | 'deflate': use specified encoding directly (known support)\n *   - PayloadTransform function: transform payload, skip HTTP compression\n */\nexport async function compressModule(\n  input: string | URL | Request,\n  init?: RequestInit,\n  mode?: CompressionMode,\n): Promise<Response> {\n  const req = input instanceof Request ? input : null;\n  const url =\n    typeof input === 'string' ? input : input instanceof Request ? input.url : input.toString();\n  const bodyStr = typeof init?.body === 'string' ? init.body : null;\n\n  // Custom transform: apply and skip HTTP compression\n  if (typeof mode === 'function') {\n    if (req && !init) return fetch(req);\n    let body = init?.body;\n    if (bodyStr)\n      try {\n        const next = mode(JSON.parse(bodyStr));\n        if (next !== undefined) body = JSON.stringify(next);\n      } catch {}\n    return fetch(req ?? url, { ...init, body });\n  }\n\n  const cached = _cache.get(url);\n  const hasCS = typeof CompressionStream !== 'undefined';\n  const known = mode === 'gzip' || mode === 'deflate';\n  const encoding = !hasCS\n    ? null\n    : known\n      ? (mode as SupportedEncoding)\n      : mode === 'proactive'\n        ? cached === -1\n          ? null\n          : (cached ?? 'gzip')\n        : typeof cached === 'string'\n          ? cached\n          : null;\n\n  const shouldCompress = !!encoding && !!bodyStr && bodyStr.length >= MIN_BODY_SIZE;\n  const opts: RequestInit = { ...init, priority: 'high' as RequestPriority };\n  const headers = new Headers(opts.headers);\n  if (shouldCompress) {\n    opts.body = await new Response(\n      new Blob([bodyStr!])\n        .stream()\n        .pipeThrough(new CompressionStream(encoding as CompressionFormat)),\n    ).blob();\n    headers.set('Content-Encoding', encoding);\n  }\n  opts.headers = headers;\n\n  const response = await fetch(req ?? url, opts);\n\n  // Cache discovery for passive/proactive (not known modes)\n  if (!known && cached === undefined) {\n    const header = response.headers.get('Accept-Encoding');\n    const discovered =\n      header\n        ?.split(',')\n        .map((e) => e.trim())\n        .find((e): e is SupportedEncoding => _enc.includes(e as SupportedEncoding)) ?? -1;\n    _cache.set(\n      url,\n      mode === 'proactive' && shouldCompress ? (response.ok ? encoding! : discovered) : discovered,\n    );\n  }\n\n  return response;\n}\n"],
-  "mappings": "AAAO,IAAMA,EAAgB,KAEvBC,EAAS,IAAI,IACbC,EAAO,CAAC,OAAQ,SAAS,EAe/B,eAAsBC,EACpBC,EACAC,EACAC,EACmB,CACnB,IAAMC,EAAMH,aAAiB,QAAUA,EAAQ,KACzCI,EACJ,OAAOJ,GAAU,SAAWA,EAAQA,aAAiB,QAAUA,EAAM,IAAMA,EAAM,SAAS,EACtFK,EAAU,OAAOJ,GAAA,YAAAA,EAAM,OAAS,SAAWA,EAAK,KAAO,KAG7D,GAAI,OAAOC,GAAS,WAAY,CAC9B,GAAIC,GAAO,CAACF,EAAM,OAAO,MAAME,CAAG,EAClC,IAAIG,EAAOL,GAAA,YAAAA,EAAM,KACjB,GAAII,EACF,GAAI,CACF,IAAME,EAAOL,EAAK,KAAK,MAAMG,CAAO,CAAC,EACjCE,IAAS,SAAWD,EAAO,KAAK,UAAUC,CAAI,EACpD,MAAQ,CAAC,CACX,OAAO,MAAMJ,GAAOC,EAAK,CAAE,GAAGH,EAAM,KAAAK,CAAK,CAAC,CAC5C,CAEA,IAAME,EAASX,EAAO,IAAIO,CAAG,EACvBK,EAAQ,OAAO,kBAAsB,IACrCC,EAAQR,IAAS,QAAUA,IAAS,UACpCS,EAAYF,EAEdC,EACGR,EACDA,IAAS,YACPM,IAAW,GACT,KACCA,GAAU,OACb,OAAOA,GAAW,SAChBA,EACA,KATN,KAWEI,EAAiB,CAAC,CAACD,GAAY,CAAC,CAACN,GAAWA,EAAQ,QAAU,KAC9DQ,EAAoB,CAAE,GAAGZ,EAAM,SAAU,MAA0B,EACnEa,EAAU,IAAI,QAAQD,EAAK,OAAO,EACpCD,IACFC,EAAK,KAAO,MAAM,IAAI,SACpB,IAAI,KAAK,CAACR,CAAQ,CAAC,EAChB,OAAO,EACP,YAAY,IAAI,kBAAkBM,CAA6B,CAAC,CACrE,EAAE,KAAK,EACPG,EAAQ,IAAI,mBAAoBH,CAAQ,GAE1CE,EAAK,QAAUC,EAEf,IAAMC,EAAW,MAAM,MAAMZ,GAAOC,EAAKS,CAAI,EAG7C,GAAI,CAACH,GAASF,IAAW,OAAW,CAClC,IAAMQ,EAASD,EAAS,QAAQ,IAAI,iBAAiB,EAC/CE,GACJD,GAAA,YAAAA,EACI,MAAM,KACP,IAAKE,GAAMA,EAAE,KAAK,GAClB,KAAMA,GAA8BpB,EAAK,SAASoB,CAAsB,KAAM,GACnFrB,EAAO,IACLO,EACAF,IAAS,aAAeU,GAAkBG,EAAS,GAAKJ,EAA0BM,CACpF,CACF,CAEA,OAAOF,CACT",
-  "names": ["MIN_BODY_SIZE", "_cache", "_enc", "compressModule", "input", "init", "mode", "req", "url", "bodyStr", "body", "next", "cached", "hasCS", "known", "encoding", "shouldCompress", "opts", "headers", "response", "header", "discovered", "e"]
+  "sourcesContent": ["export const MIN_BODY_SIZE = 1150;\n\nconst _hasCS = typeof CompressionStream !== 'undefined';\nconst _cache = new Map<string, string | -1>();\nconst _enc = ['gzip', 'deflate'] as const;\ntype SupportedEncoding = (typeof _enc)[number];\n\nexport type PayloadTransform = (payload: unknown) => unknown;\nexport type CompressionMode = 'passive' | 'proactive' | 'gzip' | 'deflate' | PayloadTransform;\n\n/**\n * @param input - URL or Request\n * @param init - Request options\n * @param mode - Compression mode:\n *   - 'passive' (default): discover support via Accept-Encoding header first\n *   - 'proactive': compress with gzip first, adjust if server rejects\n *   - 'gzip' | 'deflate': use specified encoding directly (known support)\n *   - PayloadTransform function: transform payload, skip HTTP compression\n */\nexport async function compressModule(\n  input: string | URL | Request,\n  init?: RequestInit,\n  mode?: CompressionMode,\n): Promise<Response> {\n  const req = input instanceof Request ? input : null;\n  const url =\n    typeof input === 'string' ? input : input instanceof Request ? input.url : input.toString();\n  const bodyStr = typeof init?.body === 'string' ? init.body : null;\n\n  // Custom transform: apply and skip HTTP compression\n  if (typeof mode === 'function') {\n    if (req && !init) return fetch(req);\n    let body = init?.body;\n    if (bodyStr)\n      try {\n        const next = mode(JSON.parse(bodyStr));\n        if (next !== undefined) body = JSON.stringify(next);\n      } catch {}\n    return fetch(req ?? url, { ...init, body });\n  }\n\n  const cached = _cache.get(url);\n  const known = mode === 'gzip' || mode === 'deflate';\n  const encoding = !_hasCS\n    ? null\n    : known\n      ? (mode as SupportedEncoding)\n      : mode === 'proactive'\n        ? cached === -1\n          ? null\n          : (cached ?? 'gzip')\n        : typeof cached === 'string'\n          ? cached\n          : null;\n\n  const shouldCompress = !!encoding && !!bodyStr && bodyStr.length >= MIN_BODY_SIZE;\n  const opts: RequestInit = { ...init, priority: 'high' as RequestPriority };\n  const headers = new Headers(opts.headers);\n  if (shouldCompress) {\n    opts.body = await new Response(\n      new Blob([bodyStr!])\n        .stream()\n        .pipeThrough(new CompressionStream(encoding as CompressionFormat)),\n    ).blob();\n    headers.set('Content-Encoding', encoding);\n  }\n  opts.headers = headers;\n\n  const response = await fetch(req ?? url, opts);\n\n  // Cache discovery for passive/proactive (not known modes)\n  if (!known && cached === undefined) {\n    const header = response.headers.get('Accept-Encoding');\n    const discovered =\n      header\n        ?.split(',')\n        .map((e) => e.trim())\n        .find((e): e is SupportedEncoding => _enc.includes(e as SupportedEncoding)) ?? -1;\n    _cache.set(\n      url,\n      mode === 'proactive' && shouldCompress ? (response.ok ? encoding! : discovered) : discovered,\n    );\n  }\n\n  return response;\n}\n"],
+  "mappings": "AAAO,IAAMA,EAAgB,KAEvBC,EAAS,OAAO,kBAAsB,IACtCC,EAAS,IAAI,IACbC,EAAO,CAAC,OAAQ,SAAS,EAe/B,eAAsBC,EACpBC,EACAC,EACAC,EACmB,CACnB,IAAMC,EAAMH,aAAiB,QAAUA,EAAQ,KACzCI,EACJ,OAAOJ,GAAU,SAAWA,EAAQA,aAAiB,QAAUA,EAAM,IAAMA,EAAM,SAAS,EACtFK,EAAU,OAAOJ,GAAA,YAAAA,EAAM,OAAS,SAAWA,EAAK,KAAO,KAG7D,GAAI,OAAOC,GAAS,WAAY,CAC9B,GAAIC,GAAO,CAACF,EAAM,OAAO,MAAME,CAAG,EAClC,IAAIG,EAAOL,GAAA,YAAAA,EAAM,KACjB,GAAII,EACF,GAAI,CACF,IAAME,EAAOL,EAAK,KAAK,MAAMG,CAAO,CAAC,EACjCE,IAAS,SAAWD,EAAO,KAAK,UAAUC,CAAI,EACpD,MAAQ,CAAC,CACX,OAAO,MAAMJ,GAAOC,EAAK,CAAE,GAAGH,EAAM,KAAAK,CAAK,CAAC,CAC5C,CAEA,IAAME,EAASX,EAAO,IAAIO,CAAG,EACvBK,EAAQP,IAAS,QAAUA,IAAS,UACpCQ,EAAYd,EAEda,EACGP,EACDA,IAAS,YACPM,IAAW,GACT,KACCA,GAAU,OACb,OAAOA,GAAW,SAChBA,EACA,KATN,KAWEG,EAAiB,CAAC,CAACD,GAAY,CAAC,CAACL,GAAWA,EAAQ,QAAU,KAC9DO,EAAoB,CAAE,GAAGX,EAAM,SAAU,MAA0B,EACnEY,EAAU,IAAI,QAAQD,EAAK,OAAO,EACpCD,IACFC,EAAK,KAAO,MAAM,IAAI,SACpB,IAAI,KAAK,CAACP,CAAQ,CAAC,EAChB,OAAO,EACP,YAAY,IAAI,kBAAkBK,CAA6B,CAAC,CACrE,EAAE,KAAK,EACPG,EAAQ,IAAI,mBAAoBH,CAAQ,GAE1CE,EAAK,QAAUC,EAEf,IAAMC,EAAW,MAAM,MAAMX,GAAOC,EAAKQ,CAAI,EAG7C,GAAI,CAACH,GAASD,IAAW,OAAW,CAClC,IAAMO,EAASD,EAAS,QAAQ,IAAI,iBAAiB,EAC/CE,GACJD,GAAA,YAAAA,EACI,MAAM,KACP,IAAKE,GAAMA,EAAE,KAAK,GAClB,KAAMA,GAA8BnB,EAAK,SAASmB,CAAsB,KAAM,GACnFpB,EAAO,IACLO,EACAF,IAAS,aAAeS,GAAkBG,EAAS,GAAKJ,EAA0BM,CACpF,CACF,CAEA,OAAOF,CACT",
+  "names": ["MIN_BODY_SIZE", "_hasCS", "_cache", "_enc", "compressModule", "input", "init", "mode", "req", "url", "bodyStr", "body", "next", "cached", "known", "encoding", "shouldCompress", "opts", "headers", "response", "header", "discovered", "e"]
 }

package/_esm/index.node.js

@@ -1,2 +1,2 @@
-import o from"node:zlib";var C=1150,h=new Map,w=["gzip","deflate"];async function R(t,s,e){let n=t instanceof Request?t:null,c=typeof t=="string"?t:t instanceof Request?t.url:t.toString(),r=typeof s?.body=="string"?s.body:null;if(typeof e=="function"){if(n&&!s)return fetch(n);let f=s?.body;if(r)try{let i=e(JSON.parse(r));i!==void 0&&(f=JSON.stringify(i))}catch{}return fetch(n??c,{...s,body:f})}let a=h.get(c),S=typeof CompressionStream<"u",u=e==="gzip"||e==="deflate",l=S?u?e:e==="proactive"?a===-1?null:a??"gzip":typeof a=="string"?a:null:null,y=!!l&&!!r&&r.length>=1150,p={...s,priority:"high"},m=new Headers(p.headers);y&&(p.body=await new Response(new Blob([r]).stream().pipeThrough(new CompressionStream(l))).blob(),m.set("Content-Encoding",l)),p.headers=m;let d=await fetch(n??c,p);if(!u&&a===void 0){let i=d.headers.get("Accept-Encoding")?.split(",").map(g=>g.trim()).find(g=>w.includes(g))??-1;h.set(c,e==="proactive"&&y&&d.ok?l:i)}return d}var b=(t,s)=>Object.assign(t,{writable:new WritableStream({write(e){return s.write(e),Promise.resolve()},close(){return s.end(),Promise.resolve()}}),readable:new ReadableStream({type:"bytes",start(e){s.on("data",n=>e.enqueue(n)),s.once("end",()=>e.close())}})});globalThis.CompressionStream||(globalThis.CompressionStream=class{constructor(s){let e;s==="deflate"?e=o.createDeflate():s==="gzip"?e=o.createGzip():s==="br"?e=o.createBrotliCompress():e=o.createDeflateRaw(),b(this,e)}});globalThis.DecompressionStream||(globalThis.DecompressionStream=class{constructor(s){let e;s==="deflate"?e=o.createInflate():s==="gzip"?e=o.createGunzip():s==="br"?e=o.createBrotliDecompress():e=o.createInflateRaw(),b(this,e)}});export{C as MIN_BODY_SIZE,R as compressModule};
+import o from"node:zlib";var C=1150,S=typeof CompressionStream<"u",h=new Map,w=["gzip","deflate"];async function R(t,s,e){let n=t instanceof Request?t:null,c=typeof t=="string"?t:t instanceof Request?t.url:t.toString(),r=typeof s?.body=="string"?s.body:null;if(typeof e=="function"){if(n&&!s)return fetch(n);let f=s?.body;if(r)try{let i=e(JSON.parse(r));i!==void 0&&(f=JSON.stringify(i))}catch{}return fetch(n??c,{...s,body:f})}let a=h.get(c),u=e==="gzip"||e==="deflate",l=S?u?e:e==="proactive"?a===-1?null:a??"gzip":typeof a=="string"?a:null:null,y=!!l&&!!r&&r.length>=1150,p={...s,priority:"high"},m=new Headers(p.headers);y&&(p.body=await new Response(new Blob([r]).stream().pipeThrough(new CompressionStream(l))).blob(),m.set("Content-Encoding",l)),p.headers=m;let d=await fetch(n??c,p);if(!u&&a===void 0){let i=d.headers.get("Accept-Encoding")?.split(",").map(g=>g.trim()).find(g=>w.includes(g))??-1;h.set(c,e==="proactive"&&y&&d.ok?l:i)}return d}var b=(t,s)=>Object.assign(t,{writable:new WritableStream({write(e){return s.write(e),Promise.resolve()},close(){return s.end(),Promise.resolve()}}),readable:new ReadableStream({type:"bytes",start(e){s.on("data",n=>e.enqueue(n)),s.once("end",()=>e.close())}})});globalThis.CompressionStream||(globalThis.CompressionStream=class{constructor(s){let e;s==="deflate"?e=o.createDeflate():s==="gzip"?e=o.createGzip():s==="br"?e=o.createBrotliCompress():e=o.createDeflateRaw(),b(this,e)}});globalThis.DecompressionStream||(globalThis.DecompressionStream=class{constructor(s){let e;s==="deflate"?e=o.createInflate():s==="gzip"?e=o.createGunzip():s==="br"?e=o.createBrotliDecompress():e=o.createInflateRaw(),b(this,e)}});export{C as MIN_BODY_SIZE,R as compressModule};
 //# sourceMappingURL=index.node.js.map

package/_esm/index.node.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/index.node.ts", "../../src/index.ts"],
-  "sourcesContent": ["import zlib from 'node:zlib';\n\n// Polyfill for CompressionStream/DecompressionStream in older versions of Node.js & Bun\nconst make = (ctx: any, handle: any) =>\n  Object.assign(ctx, {\n    writable: new WritableStream({\n      write(chunk) {\n        handle.write(chunk);\n        return Promise.resolve();\n      },\n      close() {\n        handle.end();\n        return Promise.resolve();\n      },\n    }),\n    readable: new ReadableStream({\n      type: 'bytes',\n      start(ctrl) {\n        handle.on('data', (chunk: any) => ctrl.enqueue(chunk));\n        handle.once('end', () => ctrl.close());\n      },\n    }),\n  });\n\nif (!globalThis.CompressionStream) {\n  globalThis.CompressionStream = class CompressionStream {\n    constructor(format: string) {\n      let handle;\n      if (format === 'deflate') {\n        handle = zlib.createDeflate();\n      } else if (format === 'gzip') {\n        handle = zlib.createGzip();\n      } else if (format === 'br') {\n        handle = zlib.createBrotliCompress();\n      } else {\n        handle = zlib.createDeflateRaw();\n      }\n      make(this, handle);\n    }\n  } as any;\n}\n\nif (!globalThis.DecompressionStream) {\n  globalThis.DecompressionStream = class DecompressionStream {\n    constructor(format: string) {\n      let handle;\n      if (format === 'deflate') {\n        handle = zlib.createInflate();\n      } else if (format === 'gzip') {\n        handle = zlib.createGunzip();\n      } else if (format === 'br') {\n        handle = zlib.createBrotliDecompress();\n      } else {\n        handle = zlib.createInflateRaw();\n      }\n      make(this, handle);\n    }\n  } as any;\n}\n\nexport * from './index';\n", "export const MIN_BODY_SIZE = 1150;\n\nconst _cache = new Map<string, string | -1>();\nconst _enc = ['gzip', 'deflate'] as const;\ntype SupportedEncoding = (typeof _enc)[number];\n\nexport type PayloadTransform = (payload: unknown) => unknown;\nexport type CompressionMode = 'passive' | 'proactive' | 'gzip' | 'deflate' | PayloadTransform;\n\n/**\n * @param input - URL or Request\n * @param init - Request options\n * @param mode - Compression mode:\n *   - 'passive' (default): discover support via Accept-Encoding header first\n *   - 'proactive': compress with gzip first, adjust if server rejects\n *   - 'gzip' | 'deflate': use specified encoding directly (known support)\n *   - PayloadTransform function: transform payload, skip HTTP compression\n */\nexport async function compressModule(\n  input: string | URL | Request,\n  init?: RequestInit,\n  mode?: CompressionMode,\n): Promise<Response> {\n  const req = input instanceof Request ? input : null;\n  const url =\n    typeof input === 'string' ? input : input instanceof Request ? input.url : input.toString();\n  const bodyStr = typeof init?.body === 'string' ? init.body : null;\n\n  // Custom transform: apply and skip HTTP compression\n  if (typeof mode === 'function') {\n    if (req && !init) return fetch(req);\n    let body = init?.body;\n    if (bodyStr)\n      try {\n        const next = mode(JSON.parse(bodyStr));\n        if (next !== undefined) body = JSON.stringify(next);\n      } catch {}\n    return fetch(req ?? url, { ...init, body });\n  }\n\n  const cached = _cache.get(url);\n  const hasCS = typeof CompressionStream !== 'undefined';\n  const known = mode === 'gzip' || mode === 'deflate';\n  const encoding = !hasCS\n    ? null\n    : known\n      ? (mode as SupportedEncoding)\n      : mode === 'proactive'\n        ? cached === -1\n          ? null\n          : (cached ?? 'gzip')\n        : typeof cached === 'string'\n          ? cached\n          : null;\n\n  const shouldCompress = !!encoding && !!bodyStr && bodyStr.length >= MIN_BODY_SIZE;\n  const opts: RequestInit = { ...init, priority: 'high' as RequestPriority };\n  const headers = new Headers(opts.headers);\n  if (shouldCompress) {\n    opts.body = await new Response(\n      new Blob([bodyStr!])\n        .stream()\n        .pipeThrough(new CompressionStream(encoding as CompressionFormat)),\n    ).blob();\n    headers.set('Content-Encoding', encoding);\n  }\n  opts.headers = headers;\n\n  const response = await fetch(req ?? url, opts);\n\n  // Cache discovery for passive/proactive (not known modes)\n  if (!known && cached === undefined) {\n    const header = response.headers.get('Accept-Encoding');\n    const discovered =\n      header\n        ?.split(',')\n        .map((e) => e.trim())\n        .find((e): e is SupportedEncoding => _enc.includes(e as SupportedEncoding)) ?? -1;\n    _cache.set(\n      url,\n      mode === 'proactive' && shouldCompress ? (response.ok ? encoding! : discovered) : discovered,\n    );\n  }\n\n  return response;\n}\n"],
-  "mappings": "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",
-  "names": ["zlib", "MIN_BODY_SIZE", "_cache", "_enc", "compressModule", "input", "init", "mode", "req", "url", "bodyStr", "body", "next", "cached", "hasCS", "known", "encoding", "shouldCompress", "opts", "headers", "response", "discovered", "e", "make", "ctx", "handle", "chunk", "ctrl", "format", "zlib"]
+  "sourcesContent": ["import zlib from 'node:zlib';\n\n// Polyfill for CompressionStream/DecompressionStream in older versions of Node.js & Bun\nconst make = (ctx: any, handle: any) =>\n  Object.assign(ctx, {\n    writable: new WritableStream({\n      write(chunk) {\n        handle.write(chunk);\n        return Promise.resolve();\n      },\n      close() {\n        handle.end();\n        return Promise.resolve();\n      },\n    }),\n    readable: new ReadableStream({\n      type: 'bytes',\n      start(ctrl) {\n        handle.on('data', (chunk: any) => ctrl.enqueue(chunk));\n        handle.once('end', () => ctrl.close());\n      },\n    }),\n  });\n\nif (!globalThis.CompressionStream) {\n  globalThis.CompressionStream = class CompressionStream {\n    constructor(format: string) {\n      let handle;\n      if (format === 'deflate') {\n        handle = zlib.createDeflate();\n      } else if (format === 'gzip') {\n        handle = zlib.createGzip();\n      } else if (format === 'br') {\n        handle = zlib.createBrotliCompress();\n      } else {\n        handle = zlib.createDeflateRaw();\n      }\n      make(this, handle);\n    }\n  } as any;\n}\n\nif (!globalThis.DecompressionStream) {\n  globalThis.DecompressionStream = class DecompressionStream {\n    constructor(format: string) {\n      let handle;\n      if (format === 'deflate') {\n        handle = zlib.createInflate();\n      } else if (format === 'gzip') {\n        handle = zlib.createGunzip();\n      } else if (format === 'br') {\n        handle = zlib.createBrotliDecompress();\n      } else {\n        handle = zlib.createInflateRaw();\n      }\n      make(this, handle);\n    }\n  } as any;\n}\n\nexport * from './index';\n", "export const MIN_BODY_SIZE = 1150;\n\nconst _hasCS = typeof CompressionStream !== 'undefined';\nconst _cache = new Map<string, string | -1>();\nconst _enc = ['gzip', 'deflate'] as const;\ntype SupportedEncoding = (typeof _enc)[number];\n\nexport type PayloadTransform = (payload: unknown) => unknown;\nexport type CompressionMode = 'passive' | 'proactive' | 'gzip' | 'deflate' | PayloadTransform;\n\n/**\n * @param input - URL or Request\n * @param init - Request options\n * @param mode - Compression mode:\n *   - 'passive' (default): discover support via Accept-Encoding header first\n *   - 'proactive': compress with gzip first, adjust if server rejects\n *   - 'gzip' | 'deflate': use specified encoding directly (known support)\n *   - PayloadTransform function: transform payload, skip HTTP compression\n */\nexport async function compressModule(\n  input: string | URL | Request,\n  init?: RequestInit,\n  mode?: CompressionMode,\n): Promise<Response> {\n  const req = input instanceof Request ? input : null;\n  const url =\n    typeof input === 'string' ? input : input instanceof Request ? input.url : input.toString();\n  const bodyStr = typeof init?.body === 'string' ? init.body : null;\n\n  // Custom transform: apply and skip HTTP compression\n  if (typeof mode === 'function') {\n    if (req && !init) return fetch(req);\n    let body = init?.body;\n    if (bodyStr)\n      try {\n        const next = mode(JSON.parse(bodyStr));\n        if (next !== undefined) body = JSON.stringify(next);\n      } catch {}\n    return fetch(req ?? url, { ...init, body });\n  }\n\n  const cached = _cache.get(url);\n  const known = mode === 'gzip' || mode === 'deflate';\n  const encoding = !_hasCS\n    ? null\n    : known\n      ? (mode as SupportedEncoding)\n      : mode === 'proactive'\n        ? cached === -1\n          ? null\n          : (cached ?? 'gzip')\n        : typeof cached === 'string'\n          ? cached\n          : null;\n\n  const shouldCompress = !!encoding && !!bodyStr && bodyStr.length >= MIN_BODY_SIZE;\n  const opts: RequestInit = { ...init, priority: 'high' as RequestPriority };\n  const headers = new Headers(opts.headers);\n  if (shouldCompress) {\n    opts.body = await new Response(\n      new Blob([bodyStr!])\n        .stream()\n        .pipeThrough(new CompressionStream(encoding as CompressionFormat)),\n    ).blob();\n    headers.set('Content-Encoding', encoding);\n  }\n  opts.headers = headers;\n\n  const response = await fetch(req ?? url, opts);\n\n  // Cache discovery for passive/proactive (not known modes)\n  if (!known && cached === undefined) {\n    const header = response.headers.get('Accept-Encoding');\n    const discovered =\n      header\n        ?.split(',')\n        .map((e) => e.trim())\n        .find((e): e is SupportedEncoding => _enc.includes(e as SupportedEncoding)) ?? -1;\n    _cache.set(\n      url,\n      mode === 'proactive' && shouldCompress ? (response.ok ? encoding! : discovered) : discovered,\n    );\n  }\n\n  return response;\n}\n"],
+  "mappings": "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",
+  "names": ["zlib", "MIN_BODY_SIZE", "_hasCS", "_cache", "_enc", "compressModule", "input", "init", "mode", "req", "url", "bodyStr", "body", "next", "cached", "known", "encoding", "shouldCompress", "opts", "headers", "response", "discovered", "e", "make", "ctx", "handle", "chunk", "ctrl", "format", "zlib"]
 }

package/_esm/jit-compressor.js

@@ -1,3 +1,3 @@
-import{LibZip as wt}from"solady";var bt=(1n<<128n)-1n,M=(1n<<256n)-1n;var tt=o=>~o&M;var gt=(o,c)=>o&c&M,mt=(o,c)=>(o|c)&M,dt=(o,c)=>(o^c)&M,xt=(o,c)=>o+c&M,rt=(o,c)=>o-c&M,st=(o,c)=>c<<o&M,ot=(o,c)=>c>>o&M,it=(o,c)=>{let x=Number(o)+1,y=(1n<<BigInt(x*8))-1n,f=1n<<BigInt(x*8-1),g=c&y;return((g&f)!==0n?g|~y&M:g)&M};var O=o=>o.replace(/^0x/,"").toLowerCase(),Ut=o=>{let c=O(o),x=c.length,y=new Uint8Array(x/2);for(let f=0;f<x;f+=2)y[f/2]=Number.parseInt(c.slice(f,f+2),16);return y},Z=o=>{let c="";for(let x=0;x<o.length;x++)c+=o[x].toString(16).padStart(2,"0");return c},ht=(o,c)=>{let x=O(o),y=Ut(x),f=new Uint8Array(c+y.length);f.set(y,c);let g=f.length,w=Math.ceil(g/32),k=w*32,N=new Array(w),I=new Array(w),z=new Map,S=new Map,h=null;for(let r=0;r<w;r++){let l=r*32,u=new Uint8Array(32);if(l<g){let i=Math.min(l+32,g);u.set(f.subarray(l,i),0)}N[r]=u;let C=Z(u),L=S.get(C),nt=h===C;if(L)L.freq+=1,nt||(L.normFreq+=1),L.lastWordIndex=r,L.lastOffset=l,z.set(C,L.freq);else{let i={freq:1,normFreq:1,firstWordIndex:r,lastWordIndex:r,firstOffset:l,lastOffset:l,reuseCost:-1};S.set(C,i),z.set(C,1)}h=C;let U=[];for(let i=0;i<32;){for(;i<32&&u[i]===0;)++i;if(i>=32)break;let q=i;for(;i<32&&u[i]!==0;)++i;U.push({s:q,e:i-1})}I[r]=U}for(let r of S.values()){let u=(r.firstOffset===0?0:Math.ceil(Math.log2(r.firstOffset+1)/8))+3,C=r.normFreq*32,L=r.normFreq*u;r.reuseCost=C>L?u:-1}let W=new Uint8Array(32),m=r=>r<0||r>=w?W:N[r],F=r=>r<0||r>=w?[]:I[r],j=r=>{let l=new Uint8Array(32);if(r<0||r>=g)return l;let u=Math.min(r+32,g);return l.set(f.slice(r,u),0),l},V=(r,l)=>{if(l<=0)return new Uint8Array(0);let u=new Uint8Array(l);if(r<0||r>=g)return u;let C=Math.min(r+l,g);return u.set(f.slice(r,C),0),u};return{hex:x,buffer:f,roundedLength:k,padding:c,dataLength:y.length,wordCount:w,wordFreq:z,wordStats:S,getWord:m,getSegments:F,mload:j,slice:V}};var ct=function(o,c,x){let y=28,f=ht(o,y),g=224n,w=O(c).padStart(16,"0"),k=x?BigInt("0x"+O(x)):96n,N=new Set([0n,32n,g,k,BigInt("0x"+w)]),I=2n,z=Array.from(f.wordFreq.entries()).map(([t,e])=>[BigInt("0x"+t),e]).filter(([t])=>!N.has(t));z.length>0&&(I=z.reduce((t,e)=>e[1]>t[1]?e:t)[0]);let{wordCount:S}=f,h=[],W=[],m=[],F=0,j=new Map,V=!0,r=t=>t+31&-32,l=t=>{let e=m.lastIndexOf(t);return e=e===-1?-1:m.length-1-e,e>15?-1:e},u=new Map,C=new Map,L=0,nt=(t,e,n)=>t.set(e,(t.get(e)||0)+n),U=(t,e)=>{h.push(t),W.push(e??null)},i=(t,e=1)=>{m.push(t),e!==0&&nt(u,t,e),++L,C.set(t,L)},q=()=>[m.pop(),m.pop()],ft=(t,e)=>{F=r(t+e)},D=(t,e)=>{if(t==128){let n=m[m.length-1];i(n,V?0:1)}if(t==80&&m.pop(),t==71&&i(I,0),t==48&&i(g,0),t==51&&i(k,0),t==54&&i(32n,0),t==89&&i(BigInt(F),0),t===11){let[n,s]=q();i(it(n,s),1)}if(t==25){let n=m.pop();i(tt(n),0)}if(t===24){let[n,s]=q();i(dt(n,s),1)}if(t==22){let[n,s]=q();i(gt(n,s),1)}if(t==23){let[n,s]=q();i(mt(n,s),1)}if(t==1){let[n,s]=q();i(xt(n,s),1)}if(t===3){let[n,s]=q();i(rt(s,n),1)}if(t==27){let[n,s]=q();i(st(n,s),1)}if(t==28){let[n,s]=q();i(ot(n,s),1)}if(t>=96&&t<=127||t===95){let n=0n;for(let b of e||[])n=n<<8n|BigInt(b);if(n==I){i(n,0),U(71);return}if(n==g){i(n,0),U(48);return}if(n==k){i(n,0),U(51);return}if(n==32n){i(n,0),U(54);return}if(n===BigInt(F)&&n!==0n){i(n,0),U(89);return}let s=l(n);if(s!==-1&&t!==95){i(n,V?1:0),U(128+s);return}if(n===M){i(n,0),U(95),U(25);return}i(n,1),U(t,e||null);return}if(t===81){let n=Number(m.pop());i(j.has(n)?j.get(n):0n,0)}if(t===82){let[n,s]=q(),b=Number(n);j.set(b,s&M),ft(b,32)}if(t===83){let[n,s]=q();ft(Number(n),1)}U(t,e||null)},$=t=>D(t),St=t=>{if(t===0n)return 0;let e=0,n=t<0n?-t:t;for(;n>0n;)++e,n>>=8n;return e},P=t=>t===0n?1:1+St(t),X=t=>{let e=typeof t=="bigint"?t:BigInt(t);if(e>0n&&e===BigInt(F))return D(89);if(e===32n)return D(54);if(e===0n)return D(95);let n=e,s=[];for(;n!==0n;)s.unshift(Number(n&0xffn)),n>>=8n;return D(95+s.length,s)},at=t=>D(95+t.length,Array.from(t)),Y=[],B=t=>{Y.push({t:"num",v:t}),X(t)},lt=t=>{Y.push({t:"bytes",b:t}),at(t)},p=t=>{Y.push({t:"op",o:t}),$(t)},Bt=t=>{let e=0,n=!0;for(let{s,e:b}of t)e+=1+(b-s+1),31-b>0&&(e+=3),n||(e+=1),n=!1;return e},ut=(t,e)=>{let n=t.slice(e[0].s),s=0n;for(let a of n)s=s<<8n|BigInt(a);let b=1+n.length,E=Bt(e),_=b,v=()=>lt(n),G=tt(s),J=P(G)+1;J<_&&(_=J,v=()=>{B(G),p(25)});let R=rt(0n,s),d=1+P(R)+1;d<_&&(_=d,v=()=>{B(0),B(R),p(3)});for(let a=1;a<n.length;a++){let T=(1n<<BigInt(a*8))-1n,H=s&T;if(it(BigInt(a-1),H)===s&&(H&1n<<BigInt(a*8-1))!==0n){let K=P(H)+2+1;K<_&&(_=K,v=()=>{B(H),B(a-1),p(11)});break}}for(let a=8;a<=248;a+=8){let T=ot(BigInt(a),s);if(T===0n)break;let H=tt(T);if(st(BigInt(a),H)===s){let K=P(H)+P(BigInt(a))+2;K<_&&(_=K,v=()=>{B(H),B(a),p(27),p(25)})}}return E<_&&(_=E,v=()=>{let a=!0;for(let{s:T,e:H}of e){let Q=31-H;lt(t.slice(T,H+1)),Q>0&&(B(Q*8),p(27)),a||p(23),a=!1}}),{literal:n,literalVal:s,bestCost:_,bestEmit:v,literalCost:b,shlCost:E}},A=0;for(;A<S;){let t=A*32,e=f.getWord(A),n=f.getSegments(A);if(!n.length){++A;continue}let s=Z(e),b=1;for(;A+b<S;){let d=f.getWord(A+b);if(!f.getSegments(A+b).length||Z(d)!==s)break;++b}if(b>=2){let{bestEmit:d}=ut(e,n);d(),p(128),B(t),p(82);for(let T=1;T<b;T++)p(128),p(89),p(82);let a=f.wordStats.get(s);a&&a.lastWordIndex<=A+b-1&&p(80),A+=b;continue}let{literalCost:E,shlCost:_,bestCost:v,bestEmit:G}=ut(e,n);if(E>8){let d=f.wordStats.get(s);if(d&&d.reuseCost!==-1&&A>d.firstWordIndex){let a=d.firstOffset===0?0:Math.ceil(Math.log2(d.firstOffset+1)/8);if(E>d.reuseCost+a){B(d.firstOffset),p(81),B(t),p(82),++A;continue}}}let J=n.every(({s:d,e:a})=>d===a),R=n.length*3;if(J&&R<v&&R<=_){for(let{s:d}of n)B(e[d]),B(t+d),p(83);++A;continue}G(),B(t),p(82),++A}let At=Y.slice();h=[],W=[],m=[],F=0,j=new Map,V=!1;let Mt=new Set([0n,32n,I,g,k]);Array.from(u.entries()).filter(([t,e])=>e>1&&!Mt.has(t)).map(([t,e])=>{let n=P(t),s=e*(n-1)-n;return{val:t,uses:e,net:s,p:n}}).sort((t,e)=>e.net!==t.net?e.net-t.net:e.uses!==t.uses?e.uses-t.uses:t.p-e.p).filter(t=>t.net>0&&t.val<=bt).slice(0,15).forEach(({val:t})=>{X(t)});for(let t of At)t.t==="num"?X(t.v):t.t==="bytes"?at(t.b):t.t==="op"&&$(t.o);$(95),$(95),X(f.dataLength),X(y);let et=[];for(let t=0;t<h.length;++t)et.push(h[t]),h[t]>=96&&h[t]<=127&&W[t]&&et.push(...W[t]);let It="0x"+Z(new Uint8Array(et))+"345f355af13d5f5f3e3d5ff3",Ct="0x"+O(w).padStart(64,"0");return{bytecode:It,calldata:Ct,to:"0x"+g.toString(16).padStart(40,"0"),from:O(k.toString(16)).padStart(40,"0"),balance:I.toString(16)}};var pt=o=>`0x365f73${O(o)}815b838110602f575f80848134865af1503d5f803e3d5ff35b803590815f1a8060051c908115609857600190600783149285831a6007018118840218600201948383011a90601f1660081b0101808603906020811860208211021890815f5b80830151818a015201858110609257505050600201019201916018565b82906075565b6001929350829150019101925f5b82811060b3575001916018565b85851060c1575b60010160a6565b936001818192355f1a878501530194905060ba56`;var yt=o=>`0x5f5f5b368110602d575f8083813473${O(o)}5af1503d5f803e3d5ff35b600180820192909160031981019035185f1a8015604c57815301906002565b505f19815282820192607f9060031981019035185f1a818111156072575b160101906002565b838101368437606a56`;var Et=function(o,c){let{method:x,params:y}=o;if(x&&x!=="eth_call")return o;let f=y?.[0]||o,g=y?.[1],w=y?.[2];if(w&&Object.keys(w).length>0||!f?.to||!f?.data||Object.keys(f).some(r=>!["to","data","from"].includes(r)))return o;let k=f.data.length;if(k<1150)return o;let N="0x"+O(f.data),I=f.to,z=f.from,S,h,W,m,F;if(c==="jit"||!c&&(k<3e3||k>=8e3)){let r=ct(N,I,z);S=r.bytecode,h=r.calldata,W=r.to,m=r.from,F=r.balance}else{let r=c?null:ct(N,I,z),l=c==="flz"||!c?wt.flzCompress(N):null,u=c==="cd"||!c&&l?wt.cdCompress(N):null;c==="flz"||!c&&l&&(!u||l.length<u.length)?(h=l,S=pt(I)):(h=u,S=yt(I)),W="0x"+224n.toString(16).padStart(40,"0"),m=z?O(z).padStart(16,"0"):void 0,F="0",!c&&r&&r.bytecode.length+r.calldata.length<S.length+h.length&&(S=r.bytecode,h=r.calldata,W=r.to,m=r.from,F=r.balance)}if(S.length+h.length>=k)return o;let j={code:S,balance:"0x"+F},V={to:W,data:h};return m&&(V.from="0x"+m),{...o,params:[V,g,{...w,[W]:j}]}};export{Et as compress_call};
+import{LibZip as Wt}from"solady";var wt=(1n<<128n)-1n,k=(1n<<256n)-1n;var et=o=>~o&k;var At=(o,r)=>o&r&k,St=(o,r)=>(o|r)&k,_t=(o,r)=>(o^r)&k,Bt=(o,r)=>o+r&k,it=(o,r)=>o-r&k,ct=(o,r)=>r<<o&k,ft=(o,r)=>r>>o&k,at=(o,r)=>{if(o>=31n)return r&k;let h=Number((o+1n)*8n);return BigInt.asUintN(256,BigInt.asIntN(h,r))};var j=o=>(o.charCodeAt(0)===48&&(o.charCodeAt(1)|32)===120?o.slice(2):o).toLowerCase(),Dt=Array.from({length:256},(o,r)=>r.toString(16).padStart(2,"0")),It=(()=>{let o=new Int8Array(103).fill(-1);for(let r=0;r<10;r++)o[48+r]=r;for(let r=0;r<6;r++)o[97+r]=10+r;return o})(),Lt=o=>{let r=j(o),h=r.length,w=new Uint8Array(h/2);for(let l=0,H=0;l<h;l+=2)w[H++]=It[r.charCodeAt(l)]<<4|It[r.charCodeAt(l+1)];return w},lt=o=>{let r="";for(let h=0;h<o.length;h++)r+=Dt[o[h]];return r},Nt=new Uint8Array(32),Ft=[],Mt=(o,r)=>{let h=j(o),w=Lt(h),l=new Uint8Array(r+w.length);l.set(w,r);let H=l.length,A=Math.ceil(H/32),L=A*32;if(H!==L){let i=new Uint8Array(L);i.set(l,0),l=i}let M=new Array(A),C=new Array(A),g=new Map,m=null,u=i=>{let f=i<<5;return l.subarray(f,f+32)};for(let i=0;i<A;i++){let f=i<<5,d=u(i),W=lt(d);C[i]=W;let V=g.get(W),rt=m===W;if(V)V[0]+=1,rt||(V[1]+=1),V[3]=i,V[5]=f;else{let _=[1,1,i,i,f,f,-1];g.set(W,_)}m=W;let Y=[];for(let _=0;_<32;){for(;_<32&&d[_]===0;)++_;if(_>=32)break;let ot=_;for(;_<32&&d[_]!==0;)++_;Y.push(ot<<8|_-1)}M[i]=Y}for(let i of g.values()){let d=(i[4]===0?0:32-Math.clz32(i[4])+7>>3)+3;i[6]=32>d?d:-1}let U=i=>i<0||i>=A?Nt:u(i),N=i=>i<0||i>=A?Ft:M[i],F=(i,f)=>{if(f<=0)return new Uint8Array(0);let d=new Uint8Array(f);if(i<0||i>=H)return d;let W=Math.min(i+f,H);return d.set(l.subarray(i,W),0),d},S=i=>F(i,32);return{hex:h,buffer:l,roundedLength:L,padding:r,dataLength:w.length,wordCount:A,wordHexes:C,wordStats:g,getWord:U,getSegments:N,mload:S,slice:F}};var ut="0x00000000000000000000000000000000000000e0",R=o=>o.padStart(64,"0"),Ot=R("0"),Tt=R("20"),jt=R("e0"),Vt="345f355af13d5f5f3e3d5ff3",bt=function(o,r,h){let w=h?j(h):null,l=28,H=null,A=0,L=j(r).padStart(16,"0"),M=w?BigInt("0x"+w):96n,C=2n,g=[],m=[],u=[],U=0,N=[],F=!0,S=Mt(o,l),{wordCount:i}=S,f=224n,d=new Map,W=jt,V=R(w??M.toString(16)),rt=R(L);for(let[t,e]of S.wordStats){let n=e[0];t===Ot||t===Tt||t===W||t===V||t===rt||n>A&&(A=n,H=t)}H&&(C=BigInt("0x"+H));let Y=t=>t+31&-32,_=t=>{for(let e=u.length-1,n=0;n<16&&e>=0;--e,++n)if(u[e]===t)return n;return-1},ot=(t,e,n)=>t.set(e,(t.get(e)||0)+n),O=(t,e)=>{g.push(t),m.push(e??null)},a=(t,e=1)=>{u.push(t),e!==0&&ot(d,t,e)},T=()=>[u.pop(),u.pop()],gt=(t,e)=>{U=Y(t+e)},P=(t,e)=>{if(t===128&&a(u[u.length-1],F?0:1),t===80&&u.pop(),t===71&&a(C,0),t===48&&a(f,0),t===51&&a(M,0),t===54&&a(32n,0),t===89&&a(BigInt(U),0),t===11){let[n,s]=T();a(at(n,s),1)}if(t===25&&a(et(u.pop()),0),t===24){let[n,s]=T();a(_t(n,s),1)}if(t===22){let[n,s]=T();a(At(n,s),1)}if(t===23){let[n,s]=T();a(St(n,s),1)}if(t===1){let[n,s]=T();a(Bt(n,s),1)}if(t===3){let[n,s]=T();a(it(s,n),1)}if(t===27){let[n,s]=T();a(ct(n,s),1)}if(t===28){let[n,s]=T();a(ft(n,s),1)}if(t>=96&&t<=127||t===95){let n=0n;for(let b of e||[])n=n<<8n|BigInt(b);if(n===C){a(n,0),O(71);return}if(n===f){a(n,0),O(48);return}if(n===M){a(n,0),O(51);return}if(n===32n){a(n,0),O(54);return}if(n===BigInt(U)&&n!=0n){a(n,0),O(89);return}let s=_(n);if(s!=-1&&t!=95){a(n,F?1:0),O(128+s);return}if(n===k){a(n,0),O(95),O(25);return}a(n,1),O(t,e||null);return}if(t===81&&a(N[Number(u.pop())>>>5]??0n,0),t===82){let[n,s]=T(),b=Number(n);N[b>>>5]=s&k,gt(b,32)}if(t===83){let[n,s]=T();gt(Number(n),1)}O(t,e||null)},G=t=>P(t),mt=t=>{if(t===0n)return 0;let e=0,n=t<0n?-t:t;for(;n>0n;)++e,n>>=8n;return e},q=t=>t===0n?1:1+mt(t),K=t=>{let e=typeof t=="bigint"?t:BigInt(t);if(e>0n&&e===BigInt(U))return P(89);if(e===32n)return P(54);if(e===0n)return P(95);let n=e,s=mt(n),b=new Uint8Array(s);for(let D=s-1;D>=0;--D)b[D]=Number(n&0xffn),n>>=8n;return P(95+s,b)},dt=t=>P(95+t.length,t),J=[],B=t=>{J.push({t:"num",v:t}),K(t)},xt=t=>{J.push({t:"bytes",b:t}),dt(t)},y=t=>{J.push({t:"op",o:t}),G(t)},zt=t=>{let e=0,n=!0;for(let s=0;s<t.length;s++){let b=t[s],D=b>>>8,p=b&255;e+=1+(p-D+1),31-p>0&&(e+=3),n||(e+=1),n=!1}return e},ht=(t,e)=>{let n=t.subarray(e[0]>>>8),s=0n;for(let c=0;c<n.length;c++)s=s<<8n|BigInt(n[c]);let b=n.length+1,D=zt(e),p=b,v=()=>xt(n),tt=et(s),nt=q(tt)+1;nt<p&&(p=nt,v=()=>{B(tt),y(25)});let Z=it(0n,s),$=q(Z)+2;$<p&&(p=$,v=()=>{B(0),B(Z),y(3)});for(let c=1;c<n.length;c++){let x=(1n<<BigInt(c*8))-1n,I=s&x;if(at(BigInt(c-1),I)===s&&(I&1n<<BigInt(c*8-1))!==0n){let E=q(I)+3;E<p&&(p=E,v=()=>{B(I),B(c-1),y(11)});break}}for(let c=8;c<=248;c+=8){let x=ft(BigInt(c),s);if(x===0n)break;let I=et(x);if(ct(BigInt(c),I)===s){let E=q(I)+q(BigInt(c))+2;E<p&&(p=E,v=()=>{B(I),B(c),y(27),y(25)})}}return D<p&&(p=D,v=()=>{let c=!0;for(let x=0;x<e.length;x++){let I=e[x],X=I>>>8,E=I&255,pt=31-E;xt(t.subarray(X,E+1)),pt>0&&(B(pt*8),y(27)),c||y(23),c=!1}}),{literal:n,literalVal:s,bestCost:p,bestEmit:v,literalCost:b,shlCost:D}},z=0;for(;z<i;){let t=z*32,e=S.getWord(z),n=S.getSegments(z);if(!n.length){++z;continue}let s=S.wordHexes[z],b=z+1;for(;b<i&&!(!S.getSegments(b).length||S.wordHexes[b]!==s);)++b;let D=b-z;if(D>=2){let c=b-1,{bestEmit:x}=ht(e,n);x(),y(128),B(t),y(82);for(let X=1;X<D;X++)y(128),y(89),y(82);let I=S.wordStats.get(s);I&&I[3]<=c&&y(80),z=b;continue}let{literalCost:p,shlCost:v,bestCost:tt,bestEmit:nt}=ht(e,n);if(p>8){let c=S.wordStats.get(s);if(c&&c[6]!==-1&&z>c[2]){let x=c[4]===0?0:32-Math.clz32(c[4])+7>>3;if(p>c[6]+x){B(c[4]),y(81),B(t),y(82),++z;continue}}}let Z=!0;for(let c=0;c<n.length;c++){let x=n[c];if(x>>>8!==(x&255)){Z=!1;break}}let $=n.length*3;if(Z&&$<tt&&$<=v){for(let c=0;c<n.length;c++){let x=n[c]>>>8;B(e[x]),B(t+x),y(83)}++z;continue}nt(),B(t),y(82),++z}g=[],m=[],u=[],U=0,N=[],F=!1;let Q=[];for(let[t,e]of d)if(e>1&&t!==0n&&t!==32n&&t!==C&&t!==f&&t!==M&&t<=wt){let n=q(t),s=e*(n-1)-n;s>0&&Q.push({val:t,uses:e,net:s,p:n})}Q.sort((t,e)=>e.net-t.net||e.uses-t.uses||t.p-e.p);for(let t=0;t<15&&t<Q.length;++t)K(Q[t].val);for(let t of J)t.t==="num"?K(t.v):t.t==="bytes"?dt(t.b):t.t==="op"&&G(t.o);G(95),G(95),K(S.dataLength),K(l);let yt=g.length;for(let t=0;t<g.length;++t)g[t]>=96&&g[t]<=127&&m[t]&&(yt+=m[t].length);let st=new Uint8Array(yt);for(let t=0,e=0;t<g.length;++t)st[e++]=g[t],g[t]>=96&&g[t]<=127&&m[t]&&(st.set(m[t],e),e+=m[t].length);let kt="0x"+lt(st)+Vt,Ht="0x"+R(L);return{bytecode:kt,calldata:Ht,to:ut,from:M.toString(16).padStart(40,"0"),balance:C.toString(16)}};var Ct=o=>`0x365f73${j(o)}815b838110602f575f80848134865af1503d5f803e3d5ff35b803590815f1a8060051c908115609857600190600783149285831a6007018118840218600201948383011a90601f1660081b0101808603906020811860208211021890815f5b80830151818a015201858110609257505050600201019201916018565b82906075565b6001929350829150019101925f5b82811060b3575001916018565b85851060c1575b60010160a6565b936001818192355f1a878501530194905060ba56`;var Ut=o=>`0x5f5f5b368110602d575f8083813473${j(o)}5af1503d5f803e3d5ff35b600180820192909160031981019035185f1a8015604c57815301906002565b505f19815282820192607f9060031981019035185f1a818111156072575b160101906002565b838101368437606a56`;var rn=function(o,r){let{method:h,params:w}=o;if(h&&h!=="eth_call")return o;let l=w?.[0]||o,H=w?.[1],A=w?.[2];if(!l?.to||!l?.data||(()=>{if(A)for(let f in A)return!0;for(let f in l)if(f!=="to"&&f!=="data"&&f!=="from")return!0;return!1})())return o;let L=l.data.length;if(L<1150)return o;let M=l.data,C=l.to,g=l.from,m,u,U,N,F;if(r==="jit"||!r&&(L<3e3||L>=8e3)){let f=bt(M,C,g);m=f.bytecode,u=f.calldata,U=f.to,N=f.from,F=f.balance}else{let f=r?null:bt(M,C,g),d=r==="flz"||!r?Wt.flzCompress(M):null,W=r==="cd"||!r&&d?Wt.cdCompress(M):null;r==="flz"||!r&&d&&(!W||d.length<W.length)?(u=d,m=Ct(C)):(u=W,m=Ut(C)),U=ut,N=g?j(g).padStart(16,"0"):void 0,F="0",!r&&f&&f.bytecode.length+f.calldata.length<m.length+u.length&&(m=f.bytecode,u=f.calldata,U=f.to,N=f.from,F=f.balance)}if(m.length+u.length>=L)return o;let S={code:m,balance:"0x"+F},i={to:U,data:u};return N&&(i.from="0x"+N),{...o,params:[i,H,{...A,[U]:S}]}};export{rn as compress_call};
 //! @__PURE__
 //# sourceMappingURL=jit-compressor.js.map