{"mappings":"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","names":["BaseError","narrow","value","execTyped","tupleRegex","formatAbiParameter","abiParameter","type","length","i","component","result","formatAbiParameters","abiParameters","params","length","i","abiParameter","formatAbiParameter","formatAbiItem","abiItem","formatAbiParameters","formatAbi","abi","signatures","length","i","abiItem","signature","formatAbiItem","isStructSignature","execTyped","isTupleRegex","UnknownTypeError","InvalidAbiTypeParameterError","InvalidSignatureError","InvalidStructSignatureError","BaseError","CircularReferenceError","type","execStructSignature","isStructSignature","isSolidityType","parseAbiParameter","parseStructs","signatures","shallowStructs","signaturesLength","i","signature","match","InvalidSignatureError","properties","components","propertiesLength","k","trimmed","abiParameter","InvalidStructSignatureError","resolvedStructs","entries","entriesLength","name","parameters","resolveStructs","typeWithoutTupleRegex","abiParameters","structs","ancestors","length","isTupleRegex","execTyped","InvalidAbiTypeParameterError","array","type","CircularReferenceError","UnknownTypeError","parseSignature","parseAbi","signatures","structs","parseStructs","abi","length","i","signature","isStructSignature","InvalidAbiItemError","isStructSignature","parseSignature","parseAbiItem","signature","abiItem","structs","parseStructs","length","i","signature_","isStructSignature","InvalidAbiItemError","InvalidAbiParameterError","isStructSignature","modifiers","parseAbiParameter_","parseAbiParameter","param","abiParameter","modifiers","structs","parseStructs","length","i","signature","isStructSignature","InvalidAbiParameterError","InvalidAbiParametersError","isStructSignature","modifiers","splitParameters","parseAbiParameter_","parseAbiParameters","params","abiParameters","parameters","length","i","modifiers","structs","parseStructs","signature","isStructSignature","k","InvalidAbiParametersError","UnknownTypeError","InvalidAbiItemError","UnknownSolidityTypeError","InvalidAbiTypeParameterError","InvalidFunctionModifierError","InvalidModifierError","SolidityProtectedKeywordError","InvalidParameterError","InvalidAbiParametersError","InvalidAbiParameterError","InvalidStructSignatureError","InvalidSignatureError","UnknownSignatureError","InvalidParenthesisError"],"sources":["../esm/npm/abitype@1.2.3/node_modules/abitype/src/exports/index.ts","../esm/npm/abitype@1.2.3/node_modules/abitype/src/narrow.ts","../esm/npm/abitype@1.2.3/node_modules/abitype/src/human-readable/formatAbiParameter.ts","../esm/npm/abitype@1.2.3/node_modules/abitype/src/human-readable/formatAbiParameters.ts","../esm/npm/abitype@1.2.3/node_modules/abitype/src/human-readable/formatAbiItem.ts","../esm/npm/abitype@1.2.3/node_modules/abitype/src/human-readable/formatAbi.ts","../esm/npm/abitype@1.2.3/node_modules/abitype/src/human-readable/parseAbi.ts","../esm/npm/abitype@1.2.3/node_modules/abitype/src/human-readable/runtime/structs.ts","../esm/npm/abitype@1.2.3/node_modules/abitype/src/human-readable/errors/struct.ts","../esm/npm/abitype@1.2.3/node_modules/abitype/src/human-readable/parseAbiItem.ts","../esm/npm/abitype@1.2.3/node_modules/abitype/src/human-readable/parseAbiParameter.ts","../esm/npm/abitype@1.2.3/node_modules/abitype/src/human-readable/parseAbiParameters.ts"],"sourcesContent":["export type {\n  Abi,\n  AbiConstructor,\n  AbiError,\n  AbiEvent,\n  AbiEventParameter,\n  AbiFallback,\n  AbiFunction,\n  AbiInternalType,\n  AbiItemType,\n  AbiParameter,\n  AbiParameterKind,\n  AbiReceive,\n  AbiStateMutability,\n  AbiType,\n  Address,\n  SolidityAddress,\n  SolidityArray,\n  SolidityArrayWithoutTuple,\n  SolidityArrayWithTuple,\n  SolidityBool,\n  SolidityBytes,\n  SolidityFixedArrayRange,\n  SolidityFixedArraySizeLookup,\n  SolidityFunction,\n  SolidityInt,\n  SolidityString,\n  SolidityTuple,\n  TypedData,\n  TypedDataDomain,\n  TypedDataParameter,\n  TypedDataType,\n} from '../abi.js'\n\n// biome-ignore lint/performance/noBarrelFile: \u003cexplanation\u003e\nexport { BaseError } from '../errors.js'\n\nexport type { Narrow } from '../narrow.js'\nexport { narrow } from '../narrow.js'\n\nexport type {\n  Register,\n  DefaultRegister,\n  ResolvedRegister,\n} from '../register.js'\n\nexport type {\n  AbiParameterToPrimitiveType,\n  AbiParametersToPrimitiveTypes,\n  AbiTypeToPrimitiveType,\n  ExtractAbiError,\n  ExtractAbiErrorNames,\n  ExtractAbiErrors,\n  ExtractAbiEvent,\n  ExtractAbiEventNames,\n  ExtractAbiEvents,\n  ExtractAbiFunction,\n  ExtractAbiFunctionNames,\n  ExtractAbiFunctions,\n  IsAbi,\n  IsTypedData,\n  TypedDataToPrimitiveTypes,\n} from '../utils.js'\n\n////////////////////////////////////////////////////////////////////////////////////////////////////\n// Human-Readable\n\nexport {\n  formatAbi,\n  type FormatAbi,\n} from '../human-readable/formatAbi.js'\n\nexport {\n  formatAbiItem,\n  type FormatAbiItem,\n} from '../human-readable/formatAbiItem.js'\n\nexport {\n  formatAbiParameter,\n  type FormatAbiParameter,\n} from '../human-readable/formatAbiParameter.js'\n\nexport {\n  formatAbiParameters,\n  type FormatAbiParameters,\n} from '../human-readable/formatAbiParameters.js'\n\nexport { parseAbi, type ParseAbi } from '../human-readable/parseAbi.js'\n\nexport {\n  parseAbiItem,\n  type ParseAbiItem,\n} from '../human-readable/parseAbiItem.js'\n\nexport {\n  parseAbiParameter,\n  type ParseAbiParameter,\n} from '../human-readable/parseAbiParameter.js'\n\nexport {\n  parseAbiParameters,\n  type ParseAbiParameters,\n} from '../human-readable/parseAbiParameters.js'\n\nexport {\n  UnknownTypeError,\n  InvalidAbiItemError,\n  UnknownSolidityTypeError,\n} from '../human-readable/errors/abiItem.js'\n\nexport {\n  InvalidAbiTypeParameterError,\n  InvalidFunctionModifierError,\n  InvalidModifierError,\n  SolidityProtectedKeywordError,\n  InvalidParameterError,\n  InvalidAbiParametersError,\n  InvalidAbiParameterError,\n} from '../human-readable/errors/abiParameter.js'\n\nexport {\n  InvalidStructSignatureError,\n  InvalidSignatureError,\n  UnknownSignatureError,\n} from '../human-readable/errors/signature.js'\n\nexport { InvalidParenthesisError } from '../human-readable/errors/splitParameters.js'\n\nexport { CircularReferenceError } from '../human-readable/errors/struct.js'\n","/**\n * Infers embedded primitive type of any type\n *\n * @param T - Type to infer\n * @returns Embedded type of {@link type}\n *\n * @example\n * type Result = Narrow\u003c['foo', 'bar', 1]\u003e\n */\n// s/o https://twitter.com/hd_nvim/status/1578567206190780417\nexport type Narrow\u003ctype\u003e =\n  | (unknown extends type ? unknown : never)\n  | (type extends Function ? type : never)\n  | (type extends bigint | boolean | number | string ? type : never)\n  | (type extends [] ? [] : never)\n  | { [K in keyof type]: Narrow\u003ctype[K]\u003e }\n\n/**\n * Infers embedded primitive type of any type\n * Same as `as const` but without setting the object as readonly and without needing the user to use it.\n *\n * @param value - Value to infer\n * @returns Value with embedded type inferred\n *\n * @example\n * const result = narrow(['foo', 'bar', 1])\n */\nexport function narrow\u003ctype\u003e(value: Narrow\u003ctype\u003e) {\n  return value\n}\n","import type { AbiEventParameter, AbiParameter } from '../abi.js'\nimport { execTyped } from '../regex.js'\nimport type { IsNarrowable, Join } from '../types.js'\nimport type { AssertName } from './types/signatures.js'\n\n/**\n * Formats {@link AbiParameter} to human-readable ABI parameter.\n *\n * @param abiParameter - ABI parameter\n * @returns Human-readable ABI parameter\n *\n * @example\n * type Result = FormatAbiParameter\u003c{ type: 'address'; name: 'from'; }\u003e\n * //   ^? type Result = 'address from'\n */\nexport type FormatAbiParameter\u003c\n  abiParameter extends AbiParameter | AbiEventParameter,\n\u003e = abiParameter extends {\n  name?: infer name extends string\n  type: `tuple${infer array}`\n  components: infer components extends readonly AbiParameter[]\n  indexed?: infer indexed extends boolean\n}\n  ? FormatAbiParameter\u003c\n      {\n        type: `(${Join\u003c\n          {\n            [key in keyof components]: FormatAbiParameter\u003c\n              {\n                type: components[key]['type']\n              } \u0026 (IsNarrowable\u003ccomponents[key]['name'], string\u003e extends true\n                ? { name: components[key]['name'] }\n                : unknown) \u0026\n                (components[key] extends { components: readonly AbiParameter[] }\n                  ? { components: components[key]['components'] }\n                  : unknown)\n            \u003e\n          },\n          ', '\n        \u003e})${array}`\n      } \u0026 (IsNarrowable\u003cname, string\u003e extends true ? { name: name } : unknown) \u0026\n        (IsNarrowable\u003cindexed, boolean\u003e extends true\n          ? { indexed: indexed }\n          : unknown)\n    \u003e\n  : `${abiParameter['type']}${abiParameter extends { indexed: true }\n      ? ' indexed'\n      : ''}${abiParameter['name'] extends infer name extends string\n      ? name extends ''\n        ? ''\n        : ` ${AssertName\u003cname\u003e}`\n      : ''}`\n\n// https://regexr.com/7f7rv\nconst tupleRegex = /^tuple(?\u003carray\u003e(\\[(\\d*)\\])*)$/\n\n/**\n * Formats {@link AbiParameter} to human-readable ABI parameter.\n *\n * @param abiParameter - ABI parameter\n * @returns Human-readable ABI parameter\n *\n * @example\n * const result = formatAbiParameter({ type: 'address', name: 'from' })\n * //    ^? const result: 'address from'\n */\nexport function formatAbiParameter\u003c\n  const abiParameter extends AbiParameter | AbiEventParameter,\n\u003e(abiParameter: abiParameter): FormatAbiParameter\u003cabiParameter\u003e {\n  type Result = FormatAbiParameter\u003cabiParameter\u003e\n\n  let type = abiParameter.type\n  if (tupleRegex.test(abiParameter.type) \u0026\u0026 'components' in abiParameter) {\n    type = '('\n    const length = abiParameter.components.length as number\n    for (let i = 0; i \u003c length; i++) {\n      const component = abiParameter.components[i]!\n      type += formatAbiParameter(component)\n      if (i \u003c length - 1) type += ', '\n    }\n    const result = execTyped\u003c{ array?: string }\u003e(tupleRegex, abiParameter.type)\n    type += `)${result?.array || ''}`\n    return formatAbiParameter({\n      ...abiParameter,\n      type,\n    }) as Result\n  }\n  // Add `indexed` to type if in `abiParameter`\n  if ('indexed' in abiParameter \u0026\u0026 abiParameter.indexed)\n    type = `${type} indexed`\n  // Return human-readable ABI parameter\n  if (abiParameter.name) return `${type} ${abiParameter.name}` as Result\n  return type as Result\n}\n","import type { AbiEventParameter, AbiParameter } from '../abi.js'\nimport type { Join } from '../types.js'\nimport {\n  type FormatAbiParameter,\n  formatAbiParameter,\n} from './formatAbiParameter.js'\n\n/**\n * Formats {@link AbiParameter}s to human-readable ABI parameter.\n *\n * @param abiParameters - ABI parameters\n * @returns Human-readable ABI parameters\n *\n * @example\n * type Result = FormatAbiParameters\u003c[\n *   // ^? type Result = 'address from, uint256 tokenId'\n *   { type: 'address'; name: 'from'; },\n *   { type: 'uint256'; name: 'tokenId'; },\n * ]\u003e\n */\nexport type FormatAbiParameters\u003c\n  abiParameters extends readonly [\n    AbiParameter | AbiEventParameter,\n    ...(readonly (AbiParameter | AbiEventParameter)[]),\n  ],\n\u003e = Join\u003c\n  {\n    [key in keyof abiParameters]: FormatAbiParameter\u003cabiParameters[key]\u003e\n  },\n  ', '\n\u003e\n\n/**\n * Formats {@link AbiParameter}s to human-readable ABI parameters.\n *\n * @param abiParameters - ABI parameters\n * @returns Human-readable ABI parameters\n *\n * @example\n * const result = formatAbiParameters([\n *   //  ^? const result: 'address from, uint256 tokenId'\n *   { type: 'address', name: 'from' },\n *   { type: 'uint256', name: 'tokenId' },\n * ])\n */\nexport function formatAbiParameters\u003c\n  const abiParameters extends readonly [\n    AbiParameter | AbiEventParameter,\n    ...(readonly (AbiParameter | AbiEventParameter)[]),\n  ],\n\u003e(abiParameters: abiParameters): FormatAbiParameters\u003cabiParameters\u003e {\n  let params = ''\n  const length = abiParameters.length\n  for (let i = 0; i \u003c length; i++) {\n    const abiParameter = abiParameters[i]!\n    params += formatAbiParameter(abiParameter)\n    if (i !== length - 1) params += ', '\n  }\n  return params as FormatAbiParameters\u003cabiParameters\u003e\n}\n","import type {\n  Abi,\n  AbiConstructor,\n  AbiError,\n  AbiEvent,\n  AbiEventParameter,\n  AbiFallback,\n  AbiFunction,\n  AbiParameter,\n  AbiReceive,\n  AbiStateMutability,\n} from '../abi.js'\nimport {\n  type FormatAbiParameters as FormatAbiParameters_,\n  formatAbiParameters,\n} from './formatAbiParameters.js'\nimport type { AssertName } from './types/signatures.js'\n\n/**\n * Formats ABI item (e.g. error, event, function) into human-readable ABI item\n *\n * @param abiItem - ABI item\n * @returns Human-readable ABI item\n */\nexport type FormatAbiItem\u003cabiItem extends Abi[number]\u003e =\n  Abi[number] extends abiItem\n    ? string\n    :\n        | (abiItem extends AbiFunction\n            ? AbiFunction extends abiItem\n              ? string\n              : `function ${AssertName\u003cabiItem['name']\u003e}(${FormatAbiParameters\u003c\n                  abiItem['inputs']\n                \u003e})${abiItem['stateMutability'] extends Exclude\u003c\n                  AbiStateMutability,\n                  'nonpayable'\n                \u003e\n                  ? ` ${abiItem['stateMutability']}`\n                  : ''}${abiItem['outputs']['length'] extends 0\n                  ? ''\n                  : ` returns (${FormatAbiParameters\u003cabiItem['outputs']\u003e})`}`\n            : never)\n        | (abiItem extends AbiEvent\n            ? AbiEvent extends abiItem\n              ? string\n              : `event ${AssertName\u003cabiItem['name']\u003e}(${FormatAbiParameters\u003c\n                  abiItem['inputs']\n                \u003e})`\n            : never)\n        | (abiItem extends AbiError\n            ? AbiError extends abiItem\n              ? string\n              : `error ${AssertName\u003cabiItem['name']\u003e}(${FormatAbiParameters\u003c\n                  abiItem['inputs']\n                \u003e})`\n            : never)\n        | (abiItem extends AbiConstructor\n            ? AbiConstructor extends abiItem\n              ? string\n              : `constructor(${FormatAbiParameters\u003c\n                  abiItem['inputs']\n                \u003e})${abiItem['stateMutability'] extends 'payable'\n                  ? ' payable'\n                  : ''}`\n            : never)\n        | (abiItem extends AbiFallback\n            ? AbiFallback extends abiItem\n              ? string\n              : `fallback() external${abiItem['stateMutability'] extends 'payable'\n                  ? ' payable'\n                  : ''}`\n            : never)\n        | (abiItem extends AbiReceive\n            ? AbiReceive extends abiItem\n              ? string\n              : 'receive() external payable'\n            : never)\n\ntype FormatAbiParameters\u003c\n  abiParameters extends readonly (AbiParameter | AbiEventParameter)[],\n\u003e = abiParameters['length'] extends 0\n  ? ''\n  : FormatAbiParameters_\u003c\n      abiParameters extends readonly [\n        AbiParameter | AbiEventParameter,\n        ...(readonly (AbiParameter | AbiEventParameter)[]),\n      ]\n        ? abiParameters\n        : never\n    \u003e\n\n/**\n * Formats ABI item (e.g. error, event, function) into human-readable ABI item\n *\n * @param abiItem - ABI item\n * @returns Human-readable ABI item\n */\nexport function formatAbiItem\u003cconst abiItem extends Abi[number]\u003e(\n  abiItem: abiItem,\n): FormatAbiItem\u003cabiItem\u003e {\n  type Result = FormatAbiItem\u003cabiItem\u003e\n  type Params = readonly [\n    AbiParameter | AbiEventParameter,\n    ...(readonly (AbiParameter | AbiEventParameter)[]),\n  ]\n\n  if (abiItem.type === 'function')\n    return `function ${abiItem.name}(${formatAbiParameters(\n      abiItem.inputs as Params,\n    )})${\n      abiItem.stateMutability \u0026\u0026 abiItem.stateMutability !== 'nonpayable'\n        ? ` ${abiItem.stateMutability}`\n        : ''\n    }${\n      abiItem.outputs?.length\n        ? ` returns (${formatAbiParameters(abiItem.outputs as Params)})`\n        : ''\n    }`\n  if (abiItem.type === 'event')\n    return `event ${abiItem.name}(${formatAbiParameters(\n      abiItem.inputs as Params,\n    )})`\n  if (abiItem.type === 'error')\n    return `error ${abiItem.name}(${formatAbiParameters(\n      abiItem.inputs as Params,\n    )})`\n  if (abiItem.type === 'constructor')\n    return `constructor(${formatAbiParameters(abiItem.inputs as Params)})${\n      abiItem.stateMutability === 'payable' ? ' payable' : ''\n    }`\n  if (abiItem.type === 'fallback')\n    return `fallback() external${\n      abiItem.stateMutability === 'payable' ? ' payable' : ''\n    }` as Result\n  return 'receive() external payable' as Result\n}\n","import type { Abi } from '../abi.js'\nimport { type FormatAbiItem, formatAbiItem } from './formatAbiItem.js'\n\n/**\n * Parses JSON ABI into human-readable ABI\n *\n * @param abi - ABI\n * @returns Human-readable ABI\n */\nexport type FormatAbi\u003cabi extends Abi | readonly unknown[]\u003e = Abi extends abi\n  ? readonly string[]\n  : abi extends readonly []\n    ? never\n    : abi extends Abi\n      ? {\n          [key in keyof abi]: FormatAbiItem\u003cabi[key]\u003e\n        }\n      : readonly string[]\n\n/**\n * Parses JSON ABI into human-readable ABI\n *\n * @param abi - ABI\n * @returns Human-readable ABI\n */\nexport function formatAbi\u003cconst abi extends Abi | readonly unknown[]\u003e(\n  abi: abi,\n): FormatAbi\u003cabi\u003e {\n  const signatures = []\n  const length = abi.length\n  for (let i = 0; i \u003c length; i++) {\n    const abiItem = abi[i]!\n    const signature = formatAbiItem(abiItem as Abi[number])\n    signatures.push(signature)\n  }\n  return signatures as unknown as FormatAbi\u003cabi\u003e\n}\n","import type { Abi } from '../abi.js'\nimport type { Error, Filter } from '../types.js'\nimport { isStructSignature } from './runtime/signatures.js'\nimport { parseStructs } from './runtime/structs.js'\nimport { parseSignature } from './runtime/utils.js'\nimport type { Signatures } from './types/signatures.js'\nimport type { ParseStructs } from './types/structs.js'\nimport type { ParseSignature } from './types/utils.js'\n\n/**\n * Parses human-readable ABI into JSON {@link Abi}\n *\n * @param signatures - Human-readable ABI\n * @returns Parsed {@link Abi}\n *\n * @example\n * type Result = ParseAbi\u003c\n *   // ^? type Result = readonly [{ name: \"balanceOf\"; type: \"function\"; stateMutability:...\n *   [\n *     'function balanceOf(address owner) view returns (uint256)',\n *     'event Transfer(address indexed from, address indexed to, uint256 amount)',\n *   ]\n * \u003e\n */\nexport type ParseAbi\u003csignatures extends readonly string[]\u003e =\n  string[] extends signatures\n    ? Abi // If `T` was not able to be inferred (e.g. just `string[]`), return `Abi`\n    : signatures extends readonly string[]\n      ? signatures extends Signatures\u003csignatures\u003e // Validate signatures\n        ? ParseStructs\u003csignatures\u003e extends infer structs\n          ? {\n              [key in keyof signatures]: signatures[key] extends string\n                ? ParseSignature\u003csignatures[key], structs\u003e\n                : never\n            } extends infer mapped extends readonly unknown[]\n            ? Filter\u003cmapped, never\u003e extends infer result\n              ? result extends readonly []\n                ? never\n                : result\n              : never\n            : never\n          : never\n        : never\n      : never\n\n/**\n * Parses human-readable ABI into JSON {@link Abi}\n *\n * @param signatures - Human-Readable ABI\n * @returns Parsed {@link Abi}\n *\n * @example\n * const abi = parseAbi([\n *   //  ^? const abi: readonly [{ name: \"balanceOf\"; type: \"function\"; stateMutability:...\n *   'function balanceOf(address owner) view returns (uint256)',\n *   'event Transfer(address indexed from, address indexed to, uint256 amount)',\n * ])\n */\nexport function parseAbi\u003cconst signatures extends readonly string[]\u003e(\n  signatures: signatures['length'] extends 0\n    ? Error\u003c'At least one signature required'\u003e\n    : Signatures\u003csignatures\u003e extends signatures\n      ? signatures\n      : Signatures\u003csignatures\u003e,\n): ParseAbi\u003csignatures\u003e {\n  const structs = parseStructs(signatures as readonly string[])\n  const abi = []\n  const length = signatures.length as number\n  for (let i = 0; i \u003c length; i++) {\n    const signature = (signatures as readonly string[])[i]!\n    if (isStructSignature(signature)) continue\n    abi.push(parseSignature(signature, structs))\n  }\n  return abi as unknown as ParseAbi\u003csignatures\u003e\n}\n","import type { AbiParameter } from '../../abi.js'\nimport { execTyped, isTupleRegex } from '../../regex.js'\nimport { UnknownTypeError } from '../errors/abiItem.js'\nimport { InvalidAbiTypeParameterError } from '../errors/abiParameter.js'\nimport {\n  InvalidSignatureError,\n  InvalidStructSignatureError,\n} from '../errors/signature.js'\nimport { CircularReferenceError } from '../errors/struct.js'\nimport type { StructLookup } from '../types/structs.js'\nimport { execStructSignature, isStructSignature } from './signatures.js'\nimport { isSolidityType, parseAbiParameter } from './utils.js'\n\nexport function parseStructs(signatures: readonly string[]) {\n  // Create \"shallow\" version of each struct (and filter out non-structs or invalid structs)\n  const shallowStructs: StructLookup = {}\n  const signaturesLength = signatures.length\n  for (let i = 0; i \u003c signaturesLength; i++) {\n    const signature = signatures[i]!\n    if (!isStructSignature(signature)) continue\n\n    const match = execStructSignature(signature)\n    if (!match) throw new InvalidSignatureError({ signature, type: 'struct' })\n\n    const properties = match.properties.split(';')\n\n    const components: AbiParameter[] = []\n    const propertiesLength = properties.length\n    for (let k = 0; k \u003c propertiesLength; k++) {\n      const property = properties[k]!\n      const trimmed = property.trim()\n      if (!trimmed) continue\n      const abiParameter = parseAbiParameter(trimmed, {\n        type: 'struct',\n      })\n      components.push(abiParameter)\n    }\n\n    if (!components.length) throw new InvalidStructSignatureError({ signature })\n    shallowStructs[match.name] = components\n  }\n\n  // Resolve nested structs inside each parameter\n  const resolvedStructs: StructLookup = {}\n  const entries = Object.entries(shallowStructs)\n  const entriesLength = entries.length\n  for (let i = 0; i \u003c entriesLength; i++) {\n    const [name, parameters] = entries[i]!\n    resolvedStructs[name] = resolveStructs(parameters, shallowStructs)\n  }\n\n  return resolvedStructs\n}\n\nconst typeWithoutTupleRegex =\n  /^(?\u003ctype\u003e[a-zA-Z$_][a-zA-Z0-9$_]*)(?\u003carray\u003e(?:\\[\\d*?\\])+?)?$/\n\nfunction resolveStructs(\n  abiParameters: readonly (AbiParameter \u0026 { indexed?: true })[] = [],\n  structs: StructLookup = {},\n  ancestors = new Set\u003cstring\u003e(),\n) {\n  const components: AbiParameter[] = []\n  const length = abiParameters.length\n  for (let i = 0; i \u003c length; i++) {\n    const abiParameter = abiParameters[i]!\n    const isTuple = isTupleRegex.test(abiParameter.type)\n    if (isTuple) components.push(abiParameter)\n    else {\n      const match = execTyped\u003c{ array?: string; type: string }\u003e(\n        typeWithoutTupleRegex,\n        abiParameter.type,\n      )\n      if (!match?.type) throw new InvalidAbiTypeParameterError({ abiParameter })\n\n      const { array, type } = match\n      if (type in structs) {\n        if (ancestors.has(type)) throw new CircularReferenceError({ type })\n\n        components.push({\n          ...abiParameter,\n          type: `tuple${array ?? ''}`,\n          components: resolveStructs(\n            structs[type],\n            structs,\n            new Set([...ancestors, type]),\n          ),\n        })\n      } else {\n        if (isSolidityType(type)) components.push(abiParameter)\n        else throw new UnknownTypeError({ type })\n      }\n    }\n  }\n\n  return components\n}\n","import { BaseError } from '../../errors.js'\n\nexport class CircularReferenceError extends BaseError {\n  override name = 'CircularReferenceError'\n\n  constructor({ type }: { type: string }) {\n    super('Circular reference detected.', {\n      metaMessages: [`Struct \"${type}\" is a circular reference.`],\n    })\n  }\n}\n","import type { Abi } from '../abi.js'\nimport type { Narrow } from '../narrow.js'\nimport type { Error, Filter } from '../types.js'\nimport { InvalidAbiItemError } from './errors/abiItem.js'\nimport { isStructSignature } from './runtime/signatures.js'\nimport { parseStructs } from './runtime/structs.js'\nimport { parseSignature } from './runtime/utils.js'\nimport type { Signature, Signatures } from './types/signatures.js'\nimport type { ParseStructs } from './types/structs.js'\nimport type { ParseSignature } from './types/utils.js'\n\n/**\n * Parses human-readable ABI item (e.g. error, event, function) into {@link Abi} item\n *\n * @param signature - Human-readable ABI item\n * @returns Parsed {@link Abi} item\n *\n * @example\n * type Result = ParseAbiItem\u003c'function balanceOf(address owner) view returns (uint256)'\u003e\n * //   ^? type Result = { name: \"balanceOf\"; type: \"function\"; stateMutability: \"view\";...\n *\n * @example\n * type Result = ParseAbiItem\u003c\n *   // ^? type Result = { name: \"foo\"; type: \"function\"; stateMutability: \"view\"; inputs:...\n *   ['function foo(Baz bar) view returns (string)', 'struct Baz { string name; }']\n * \u003e\n */\nexport type ParseAbiItem\u003c\n  signature extends string | readonly string[] | readonly unknown[],\n\u003e =\n  | (signature extends string\n      ? string extends signature\n        ? Abi[number]\n        : signature extends Signature\u003csignature\u003e // Validate signature\n          ? ParseSignature\u003csignature\u003e\n          : never\n      : never)\n  | (signature extends readonly string[]\n      ? string[] extends signature\n        ? Abi[number] // Return generic Abi item since type was no inferrable\n        : signature extends Signatures\u003csignature\u003e // Validate signature\n          ? ParseStructs\u003csignature\u003e extends infer structs\n            ? {\n                [key in keyof signature]: ParseSignature\u003c\n                  signature[key] extends string ? signature[key] : never,\n                  structs\n                \u003e\n              } extends infer mapped extends readonly unknown[]\n              ? // Filter out `never` since those are structs\n                Filter\u003cmapped, never\u003e[0] extends infer result\n                ? result extends undefined // convert `undefined` to `never` (e.g. `ParseAbiItem\u003c['struct Foo { string name; }']\u003e`)\n                  ? never\n                  : result\n                : never\n              : never\n            : never\n          : never\n      : never)\n\n/**\n * Parses human-readable ABI item (e.g. error, event, function) into {@link Abi} item\n *\n * @param signature - Human-readable ABI item\n * @returns Parsed {@link Abi} item\n *\n * @example\n * const abiItem = parseAbiItem('function balanceOf(address owner) view returns (uint256)')\n * //    ^? const abiItem: { name: \"balanceOf\"; type: \"function\"; stateMutability: \"view\";...\n *\n * @example\n * const abiItem = parseAbiItem([\n *   //  ^? const abiItem: { name: \"foo\"; type: \"function\"; stateMutability: \"view\"; inputs:...\n *   'function foo(Baz bar) view returns (string)',\n *   'struct Baz { string name; }',\n * ])\n */\nexport function parseAbiItem\u003c\n  signature extends string | readonly string[] | readonly unknown[],\n\u003e(\n  signature: Narrow\u003csignature\u003e \u0026\n    (\n      | (signature extends string\n          ? string extends signature\n            ? unknown\n            : Signature\u003csignature\u003e\n          : never)\n      | (signature extends readonly string[]\n          ? signature extends readonly [] // empty array\n            ? Error\u003c'At least one signature required.'\u003e\n            : string[] extends signature\n              ? unknown\n              : Signatures\u003csignature\u003e\n          : never)\n    ),\n): ParseAbiItem\u003csignature\u003e {\n  let abiItem: ParseAbiItem\u003csignature\u003e | undefined\n  if (typeof signature === 'string')\n    abiItem = parseSignature(signature) as ParseAbiItem\u003csignature\u003e\n  else {\n    const structs = parseStructs(signature as readonly string[])\n    const length = signature.length as number\n    for (let i = 0; i \u003c length; i++) {\n      const signature_ = (signature as readonly string[])[i]!\n      if (isStructSignature(signature_)) continue\n      abiItem = parseSignature(signature_, structs) as ParseAbiItem\u003csignature\u003e\n      break\n    }\n  }\n\n  if (!abiItem) throw new InvalidAbiItemError({ signature })\n  return abiItem as ParseAbiItem\u003csignature\u003e\n}\n","import type { AbiParameter } from '../abi.js'\nimport type { Narrow } from '../narrow.js'\nimport type { Error, Filter } from '../types.js'\nimport { InvalidAbiParameterError } from './errors/abiParameter.js'\nimport { isStructSignature, modifiers } from './runtime/signatures.js'\nimport { parseStructs } from './runtime/structs.js'\nimport { parseAbiParameter as parseAbiParameter_ } from './runtime/utils.js'\nimport type { IsStructSignature, Modifier } from './types/signatures.js'\nimport type { ParseStructs } from './types/structs.js'\nimport type { ParseAbiParameter as ParseAbiParameter_ } from './types/utils.js'\n\n/**\n * Parses human-readable ABI parameter into {@link AbiParameter}\n *\n * @param param - Human-readable ABI parameter\n * @returns Parsed {@link AbiParameter}\n *\n * @example\n * type Result = ParseAbiParameter\u003c'address from'\u003e\n * //   ^? type Result = { type: \"address\"; name: \"from\"; }\n *\n * @example\n * type Result = ParseAbiParameter\u003c\n *   // ^? type Result = { type: \"tuple\"; components: [{ type: \"string\"; name:...\n *   ['Baz bar', 'struct Baz { string name; }']\n * \u003e\n */\nexport type ParseAbiParameter\u003c\n  param extends string | readonly string[] | readonly unknown[],\n\u003e =\n  | (param extends string\n      ? param extends ''\n        ? never\n        : string extends param\n          ? AbiParameter\n          : ParseAbiParameter_\u003cparam, { modifier: Modifier }\u003e\n      : never)\n  | (param extends readonly string[]\n      ? string[] extends param\n        ? AbiParameter // Return generic AbiParameter item since type was no inferrable\n        : ParseStructs\u003cparam\u003e extends infer structs\n          ? {\n              [key in keyof param]: param[key] extends string\n                ? IsStructSignature\u003cparam[key]\u003e extends true\n                  ? never\n                  : ParseAbiParameter_\u003c\n                      param[key],\n                      { modifier: Modifier; structs: structs }\n                    \u003e\n                : never\n            } extends infer mapped extends readonly unknown[]\n            ? Filter\u003cmapped, never\u003e[0] extends infer result\n              ? result extends undefined\n                ? never\n                : result\n              : never\n            : never\n          : never\n      : never)\n\n/**\n * Parses human-readable ABI parameter into {@link AbiParameter}\n *\n * @param param - Human-readable ABI parameter\n * @returns Parsed {@link AbiParameter}\n *\n * @example\n * const abiParameter = parseAbiParameter('address from')\n * //    ^? const abiParameter: { type: \"address\"; name: \"from\"; }\n *\n * @example\n * const abiParameter = parseAbiParameter([\n *   //  ^? const abiParameter: { type: \"tuple\"; components: [{ type: \"string\"; name:...\n *   'Baz bar',\n *   'struct Baz { string name; }',\n * ])\n */\nexport function parseAbiParameter\u003c\n  param extends string | readonly string[] | readonly unknown[],\n\u003e(\n  param: Narrow\u003cparam\u003e \u0026\n    (\n      | (param extends string\n          ? param extends ''\n            ? Error\u003c'Empty string is not allowed.'\u003e\n            : unknown\n          : never)\n      | (param extends readonly string[]\n          ? param extends readonly [] // empty array\n            ? Error\u003c'At least one parameter required.'\u003e\n            : string[] extends param\n              ? unknown\n              : unknown // TODO: Validate param string\n          : never)\n    ),\n): ParseAbiParameter\u003cparam\u003e {\n  let abiParameter: AbiParameter | undefined\n  if (typeof param === 'string')\n    abiParameter = parseAbiParameter_(param, {\n      modifiers,\n    }) as ParseAbiParameter\u003cparam\u003e\n  else {\n    const structs = parseStructs(param as readonly string[])\n    const length = param.length as number\n    for (let i = 0; i \u003c length; i++) {\n      const signature = (param as readonly string[])[i]!\n      if (isStructSignature(signature)) continue\n      abiParameter = parseAbiParameter_(signature, { modifiers, structs })\n      break\n    }\n  }\n\n  if (!abiParameter) throw new InvalidAbiParameterError({ param })\n\n  return abiParameter as ParseAbiParameter\u003cparam\u003e\n}\n","import type { AbiParameter } from '../abi.js'\nimport type { Narrow } from '../narrow.js'\nimport type { Error, Filter } from '../types.js'\nimport { InvalidAbiParametersError } from './errors/abiParameter.js'\nimport { isStructSignature, modifiers } from './runtime/signatures.js'\nimport { parseStructs } from './runtime/structs.js'\nimport { splitParameters } from './runtime/utils.js'\nimport { parseAbiParameter as parseAbiParameter_ } from './runtime/utils.js'\nimport type { IsStructSignature, Modifier } from './types/signatures.js'\nimport type { ParseStructs } from './types/structs.js'\nimport type { SplitParameters } from './types/utils.js'\nimport type { ParseAbiParameters as ParseAbiParameters_ } from './types/utils.js'\n\n/**\n * Parses human-readable ABI parameters into {@link AbiParameter}s\n *\n * @param params - Human-readable ABI parameters\n * @returns Parsed {@link AbiParameter}s\n *\n * @example\n * type Result = ParseAbiParameters('address from, address to, uint256 amount')\n * //   ^? type Result: [{ type: \"address\"; name: \"from\"; }, { type: \"address\";...\n *\n * @example\n * type Result = ParseAbiParameters\u003c\n *   // ^? type Result: [{ type: \"tuple\"; components: [{ type: \"string\"; name:...\n *   ['Baz bar', 'struct Baz { string name; }']\n * \u003e\n */\nexport type ParseAbiParameters\u003c\n  params extends string | readonly string[] | readonly unknown[],\n\u003e =\n  | (params extends string\n      ? params extends ''\n        ? never\n        : string extends params\n          ? readonly AbiParameter[]\n          : ParseAbiParameters_\u003cSplitParameters\u003cparams\u003e, { modifier: Modifier }\u003e\n      : never)\n  | (params extends readonly string[]\n      ? string[] extends params\n        ? AbiParameter // Return generic AbiParameter item since type was no inferrable\n        : ParseStructs\u003cparams\u003e extends infer structs\n          ? {\n              [key in keyof params]: params[key] extends string\n                ? IsStructSignature\u003cparams[key]\u003e extends true\n                  ? never\n                  : ParseAbiParameters_\u003c\n                      SplitParameters\u003cparams[key]\u003e,\n                      { modifier: Modifier; structs: structs }\n                    \u003e\n                : never\n            } extends infer mapped extends readonly unknown[]\n            ? Filter\u003cmapped, never\u003e extends readonly [...infer content]\n              ? content['length'] extends 0\n                ? never\n                : DeepFlatten\u003ccontent\u003e\n              : never\n            : never\n          : never\n      : never)\n\n/**\n * Flatten all members of {@link T}\n *\n * @param T - List of items to flatten\n * @param Acc - The accumulator used while recursing\n * @returns The flattened array\n *\n * @example\n * type Result = DeepFlatten\u003c[['a', 'b'], [['c']]]\u003e\n * //   ^? type Result = ['a', 'b', 'c']\n */\ntype DeepFlatten\u003c\n  T extends readonly unknown[],\n  Acc extends readonly unknown[] = readonly [],\n\u003e = T extends readonly [infer head, ...infer tail]\n  ? tail extends undefined\n    ? never\n    : head extends readonly unknown[]\n      ? DeepFlatten\u003ctail, readonly [...Acc, ...DeepFlatten\u003chead\u003e]\u003e\n      : DeepFlatten\u003ctail, readonly [...Acc, head]\u003e\n  : Acc\n\n/**\n * Parses human-readable ABI parameters into {@link AbiParameter}s\n *\n * @param params - Human-readable ABI parameters\n * @returns Parsed {@link AbiParameter}s\n *\n * @example\n * const abiParameters = parseAbiParameters('address from, address to, uint256 amount')\n * //    ^? const abiParameters: [{ type: \"address\"; name: \"from\"; }, { type: \"address\";...\n *\n * @example\n * const abiParameters = parseAbiParameters([\n *   //  ^? const abiParameters: [{ type: \"tuple\"; components: [{ type: \"string\"; name:...\n *   'Baz bar',\n *   'struct Baz { string name; }',\n * ])\n */\nexport function parseAbiParameters\u003c\n  params extends string | readonly string[] | readonly unknown[],\n\u003e(\n  params: Narrow\u003cparams\u003e \u0026\n    (\n      | (params extends string\n          ? params extends ''\n            ? Error\u003c'Empty string is not allowed.'\u003e\n            : unknown\n          : never)\n      | (params extends readonly string[]\n          ? params extends readonly [] // empty array\n            ? Error\u003c'At least one parameter required.'\u003e\n            : string[] extends params\n              ? unknown\n              : unknown // TODO: Validate param string\n          : never)\n    ),\n): ParseAbiParameters\u003cparams\u003e {\n  const abiParameters: AbiParameter[] = []\n  if (typeof params === 'string') {\n    const parameters = splitParameters(params)\n    const length = parameters.length\n    for (let i = 0; i \u003c length; i++) {\n      abiParameters.push(parseAbiParameter_(parameters[i]!, { modifiers }))\n    }\n  } else {\n    const structs = parseStructs(params as readonly string[])\n    const length = params.length as number\n    for (let i = 0; i \u003c length; i++) {\n      const signature = (params as readonly string[])[i]!\n      if (isStructSignature(signature)) continue\n      const parameters = splitParameters(signature)\n      const length = parameters.length\n      for (let k = 0; k \u003c length; k++) {\n        abiParameters.push(\n          parseAbiParameter_(parameters[k]!, { modifiers, structs }),\n        )\n      }\n    }\n  }\n\n  if (abiParameters.length === 0)\n    throw new InvalidAbiParametersError({ params })\n\n  return abiParameters as ParseAbiParameters\u003cparams\u003e\n}\n"],"version":3}