ox 0.0.1 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# ox
+
+## 0.1.0
+
+### Minor Changes
+
+- [`4297bcf`](https://github.com/wevm/ox/commit/4297bcf0acef7f1f208ba3770d679fefa0c2cb8d) Thanks [@jxom](https://github.com/jxom)! - Initial release.

package/Caches/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/Caches.d.ts",
+  "main": "../_cjs/Caches.js",
+  "module": "../_esm/Caches.js"
+}

package/Caches.ts

@@ -0,0 +1,21 @@
+import type * as Address from './Address.js'
+import { LruMap } from './internal/lru.js'
+
+const caches = {
+  checksum: /*#__PURE__*/ new LruMap<Address.Address>(8192),
+}
+
+export const checksum = caches.checksum
+
+/**
+ * Clears all global caches.
+ *
+ * @example
+ * ```ts
+ * import { Caches } from 'ox'
+ * Caches.clear()
+ * ```
+ */
+export function clear() {
+  for (const cache of Object.values(caches)) cache.clear()
+}

package/ContractAddress/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/ContractAddress.d.ts",
+  "main": "../_cjs/ContractAddress.js",
+  "module": "../_esm/ContractAddress.js"
+}

package/ContractAddress.ts

@@ -0,0 +1,181 @@
+import * as Address from './Address.js'
+import * as Bytes from './Bytes.js'
+import type * as Errors from './Errors.js'
+import * as Hash from './Hash.js'
+import * as Hex from './Hex.js'
+import * as Rlp from './Rlp.js'
+import type { OneOf } from './internal/types.js'
+
+/**
+ * Computes Contract Address generated by the [CREATE](https://ethereum.stackexchange.com/questions/68943/create-opcode-what-does-it-really-do/68945#68945) or [CREATE2](https://eips.ethereum.org/EIPS/eip-1014) opcode.
+ *
+ * @example
+ * ### CREATE
+ *
+ * Computes via the [CREATE](https://ethereum.stackexchange.com/questions/68943/create-opcode-what-does-it-really-do/68945#68945) opcode. Shorthand for {@link ox#ContractAddress.(fromCreate:function)}.
+ *
+ * ```ts twoslash
+ * import { ContractAddress } from 'ox'
+ * ContractAddress.from({
+ *   from: '0x1a1e021a302c237453d3d45c7b82b19ceeb7e2e6',
+ *   nonce: 0n,
+ * })
+ * // @log: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2'
+ * ```
+ *
+ * @example
+ * ### CREATE2
+ *
+ * Computes via the [CREATE2](https://eips.ethereum.org/EIPS/eip-1014) opcode. Shorthand for {@link ox#ContractAddress.(fromCreate2:function)}.
+ *
+ * ```ts twoslash
+ * import { ContractAddress, Hex } from 'ox'
+ * ContractAddress.from({
+ *   from: '0x1a1e021a302c237453d3d45c7b82b19ceeb7e2e6',
+ *   bytecode: '0x6394198df16000526103ff60206004601c335afa6040516060f3',
+ *   salt: Hex.fromString('hello world'),
+ * })
+ * // @log: '0x59fbB593ABe27Cb193b6ee5C5DC7bbde312290aB'
+ * ```
+ *
+ * @param options - Options.
+ * @returns Contract Address.
+ */
+export function from(options: from.Options): Address.Address {
+  if (options.salt) return fromCreate2(options)
+  return fromCreate(options)
+}
+
+export declare namespace from {
+  export type Options = OneOf<fromCreate.Options | fromCreate2.Options>
+
+  type ErrorType =
+    | fromCreate.ErrorType
+    | fromCreate2.ErrorType
+    | Errors.GlobalErrorType
+}
+
+from.parseError = (error: unknown) =>
+  /* v8 ignore next */
+  error as from.ErrorType
+
+/**
+ * Computes contract address via [CREATE](https://ethereum.stackexchange.com/questions/68943/create-opcode-what-does-it-really-do/68945#68945) opcode.
+ *
+ * @example
+ * ```ts twoslash
+ * import { ContractAddress } from 'ox'
+ *
+ * ContractAddress.fromCreate({
+ *   from: '0x1a1e021a302c237453d3d45c7b82b19ceeb7e2e6',
+ *   nonce: 0n,
+ * })
+ * // @log: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2'
+ * ```
+ *
+ * @param options - Options for retrieving address.
+ * @returns Contract Address.
+ */
+export function fromCreate(options: fromCreate.Options): Address.Address {
+  const from = Bytes.fromHex(Address.from(options.from))
+
+  let nonce = Bytes.fromNumber(options.nonce)
+  if (nonce[0] === 0) nonce = new Uint8Array([])
+
+  return Address.from(
+    `0x${Hash.keccak256(Rlp.fromBytes([from, nonce], { as: 'Hex' })).slice(26)}` as Address.Address,
+  )
+}
+
+export declare namespace fromCreate {
+  type Options = {
+    /** The address the contract was deployed from. */
+    from: Address.Address
+    /** The nonce of the transaction which deployed the contract. */
+    nonce: bigint
+  }
+
+  type ErrorType =
+    | Hash.keccak256.ErrorType
+    | Address.from.ErrorType
+    | Bytes.fromHex.ErrorType
+    | Bytes.fromNumber.ErrorType
+    | Rlp.fromBytes.ErrorType
+    | Errors.GlobalErrorType
+}
+
+fromCreate.parseError = (error: unknown) =>
+  /* v8 ignore next */
+  error as fromCreate.ErrorType
+
+/**
+ * Computes contract address via [CREATE2](https://eips.ethereum.org/EIPS/eip-1014) opcode.
+ *
+ * @example
+ * ```ts twoslash
+ * import { ContractAddress, Hex } from 'ox'
+ *
+ * ContractAddress.fromCreate2({
+ *   from: '0x1a1e021a302c237453d3d45c7b82b19ceeb7e2e6',
+ *   bytecode: '0x6394198df16000526103ff60206004601c335afa6040516060f3',
+ *   salt: Hex.fromString('hello world'),
+ * })
+ * // @log: '0x59fbB593ABe27Cb193b6ee5C5DC7bbde312290aB'
+ * ```
+ *
+ * @param options - Options for retrieving address.
+ * @returns Contract Address.
+ */
+export function fromCreate2(options: fromCreate2.Options): Address.Address {
+  const from = Bytes.fromHex(Address.from(options.from))
+  const salt = Bytes.padLeft(
+    Bytes.validate(options.salt) ? options.salt : Bytes.fromHex(options.salt),
+    32,
+  )
+
+  const bytecodeHash = (() => {
+    if ('bytecodeHash' in options) {
+      if (Bytes.validate(options.bytecodeHash)) return options.bytecodeHash
+      return Bytes.fromHex(options.bytecodeHash)
+    }
+    return Hash.keccak256(options.bytecode, { as: 'Bytes' })
+  })()
+
+  return Address.from(
+    Hex.slice(
+      Hash.keccak256(
+        Bytes.concat(Bytes.fromHex('0xff'), from, salt, bytecodeHash),
+        { as: 'Hex' },
+      ),
+      12,
+    ),
+  )
+}
+
+export declare namespace fromCreate2 {
+  type Options =
+    | {
+        bytecode: Bytes.Bytes | Hex.Hex
+        from: Address.Address
+        salt: Bytes.Bytes | Hex.Hex
+      }
+    | {
+        bytecodeHash: Bytes.Bytes | Hex.Hex
+        from: Address.Address
+        salt: Bytes.Bytes | Hex.Hex
+      }
+
+  type ErrorType =
+    | Address.from.ErrorType
+    | Bytes.concat.ErrorType
+    | Bytes.validate.ErrorType
+    | Bytes.padLeft.ErrorType
+    | Hash.keccak256.ErrorType
+    | Hex.slice.ErrorType
+    | Bytes.fromHex.ErrorType
+    | Errors.GlobalErrorType
+}
+
+fromCreate2.parseError = (error: unknown) =>
+  /* v8 ignore next */
+  error as fromCreate2.ErrorType

package/Ens/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/Ens.d.ts",
+  "main": "../_cjs/Ens.js",
+  "module": "../_esm/Ens.js"
+}

package/Ens.ts

@@ -0,0 +1,116 @@
+import { ens_normalize } from '@adraffy/ens-normalize'
+import * as Bytes from './Bytes.js'
+import type * as Errors from './Errors.js'
+import * as Hash from './Hash.js'
+import * as Hex from './Hex.js'
+import * as internal from './internal/ens.js'
+
+/**
+ * Hashes ENS label.
+ *
+ * Since ENS labels prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to [normalize ENS labels](https://docs.ens.domains/contract-api-reference/name-processing#normalising-names) with [UTS-46 normalization](https://unicode.org/reports/tr46) before passing them to `labelhash`. You can use the built-in {@link ox#Ens.(normalize:function)} function for this.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Ens } from 'ox'
+ * Ens.labelhash('eth')
+ * '0x4f5b812789fc606be1b3b16908db13fc7a9adf7ca72641f84d75b47069d3d7f0'
+ * ```
+ *
+ * @param label - ENS label.
+ * @returns ENS labelhash.
+ */
+export function labelhash(label: string) {
+  const result = new Uint8Array(32).fill(0)
+  if (!label) return Hex.fromBytes(result)
+  return (
+    internal.unwrapLabelhash(label) || Hash.keccak256(Hex.fromString(label))
+  )
+}
+
+export declare namespace labelhash {
+  type ErrorType =
+    | Hex.fromBytes.ErrorType
+    | internal.unwrapLabelhash.ErrorType
+    | Hash.keccak256.ErrorType
+    | Hex.fromString.ErrorType
+    | Errors.GlobalErrorType
+}
+
+labelhash.parseError = (error: unknown) =>
+  /* v8 ignore next */
+  error as labelhash.ErrorType
+
+/**
+ * Hashes ENS name.
+ *
+ * Since ENS names prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to [normalize ENS names](https://docs.ens.domains/contract-api-reference/name-processing#normalising-names) with [UTS-46 normalization](https://unicode.org/reports/tr46) before passing them to `namehash`. You can use the built-in {@link ox#Ens.(normalize:function)} function for this.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Ens } from 'ox'
+ * Ens.namehash('wevm.eth')
+ * // @log: '0xf246651c1b9a6b141d19c2604e9a58f567973833990f830d882534a747801359'
+ * ```
+ *
+ * @param name - ENS name.
+ * @returns ENS namehash.
+ */
+export function namehash(name: string) {
+  let result = new Uint8Array(32).fill(0)
+  if (!name) return Hex.fromBytes(result)
+
+  const labels = name.split('.')
+  // Iterate in reverse order building up hash
+  for (let i = labels.length - 1; i >= 0; i -= 1) {
+    const hashFromEncodedLabel = internal.unwrapLabelhash(labels[i]!)
+    const hashed = hashFromEncodedLabel
+      ? Bytes.fromHex(hashFromEncodedLabel)
+      : Hash.keccak256(Bytes.fromString(labels[i]!), { as: 'Bytes' })
+    result = Hash.keccak256(Bytes.concat(result, hashed), { as: 'Bytes' })
+  }
+
+  return Hex.fromBytes(result)
+}
+
+export declare namespace namehash {
+  type ErrorType =
+    | Hex.fromBytes.ErrorType
+    | internal.unwrapLabelhash.ErrorType
+    | Bytes.fromHex.ErrorType
+    | Hash.keccak256.ErrorType
+    | Bytes.fromString.ErrorType
+    | Bytes.concat.ErrorType
+    | Errors.GlobalErrorType
+}
+
+namehash.parseError = (error: unknown) =>
+  /* v8 ignore next */
+  error as namehash.ErrorType
+
+/**
+ * Normalizes ENS name according to [ENSIP-15](https://github.com/ensdomains/docs/blob/9edf9443de4333a0ea7ec658a870672d5d180d53/ens-improvement-proposals/ensip-15-normalization-standard.md).
+ *
+ * For more info see [ENS documentation](https://docs.ens.domains/contract-api-reference/name-processing#normalising-names) on name processing.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Ens } from 'ox'
+ * Ens.normalize('wevm.eth')
+ * // @log: 'wevm.eth'
+ * ```
+ *
+ * @param name - ENS name.
+ * @returns Normalized ENS name.
+ */
+export function normalize(name: string): string {
+  return ens_normalize(name)
+}
+
+export declare namespace normalize {
+  type ErrorType = Errors.GlobalErrorType
+}
+
+normalize.parseError = (error: unknown) =>
+  /* v8 ignore next */
+  error as normalize.ErrorType

package/Errors/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/Errors.d.ts",
+  "main": "../_cjs/Errors.js",
+  "module": "../_esm/Errors.js"
+}

package/Errors.ts

@@ -0,0 +1,95 @@
+import { getVersion } from './internal/errors.js'
+
+export type GlobalErrorType<name extends string = 'Error'> = Error & {
+  name: name
+}
+
+/**
+ * Base error class inherited by all errors thrown by ox.
+ *
+ * @example
+ * ```ts
+ * import { Errors } from 'ox'
+ * throw new Errors.BaseError('An error occurred')
+ * ```
+ */
+export class BaseError<
+  cause extends Error | undefined = undefined,
+> extends Error {
+  details: string
+  docs?: string | undefined
+  docsPath?: string | undefined
+  shortMessage: string
+
+  override cause: cause
+  override name = 'BaseError'
+
+  version = `ox@${getVersion()}`
+
+  constructor(shortMessage: string, options: BaseError.Options<cause> = {}) {
+    const details = (() => {
+      if (options.cause instanceof BaseError) {
+        if (options.cause.details) return options.cause.details
+        if (options.cause.shortMessage) return options.cause.shortMessage
+      }
+      if (options.cause?.message) return options.cause.message
+      return options.details!
+    })()
+    const docsPath = (() => {
+      if (options.cause instanceof BaseError)
+        return options.cause.docsPath || options.docsPath
+      return options.docsPath
+    })()
+
+    const docsBaseUrl = 'https://oxlib.sh'
+    const docs = `${docsBaseUrl}${docsPath ?? ''}`
+
+    const message = [
+      shortMessage || 'An error occurred.',
+      ...(options.metaMessages ? ['', ...options.metaMessages] : []),
+      ...(details || docsPath
+        ? [
+            '',
+            details ? `Details: ${details}` : undefined,
+            docsPath ? `See: ${docs}` : undefined,
+          ]
+        : []),
+    ]
+      .filter((x) => typeof x === 'string')
+      .join('\n')
+
+    super(message, options.cause ? { cause: options.cause } : undefined)
+
+    this.cause = options.cause as any
+    this.details = details
+    this.docs = docs
+    this.docsPath = docsPath
+    this.shortMessage = shortMessage
+  }
+
+  walk(): Error
+  walk(fn: (err: unknown) => boolean): Error | null
+  walk(fn?: any): any {
+    return walk(this, fn)
+  }
+}
+
+export declare namespace BaseError {
+  type Options<cause extends Error | undefined = Error | undefined> = {
+    cause?: cause | undefined
+    details?: string | undefined
+    docsPath?: string | undefined
+    metaMessages?: (string | undefined)[] | undefined
+  }
+}
+
+/** @internal */
+function walk(
+  err: unknown,
+  fn?: ((err: unknown) => boolean) | undefined,
+): unknown {
+  if (fn?.(err)) return err
+  if (err && typeof err === 'object' && 'cause' in err && err.cause)
+    return walk(err.cause, fn)
+  return fn ? null : err
+}

package/Fee/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/Fee.d.ts",
+  "main": "../_cjs/Fee.js",
+  "module": "../_esm/Fee.js"
+}

package/Fee.ts

@@ -0,0 +1,57 @@
+import type * as Hex from './Hex.js'
+import type { Compute, OneOf } from './internal/types.js'
+
+export type FeeHistory<bigintType = bigint> = Compute<{
+  /**
+   * An array of block base fees per gas (in wei). This includes the next block after
+   * the newest of the returned range, because this value can be derived from the newest block.
+   * Zeroes are returned for pre-EIP-1559 blocks. */
+  baseFeePerGas: bigintType[]
+  /** An array of block gas used ratios. These are calculated as the ratio of gasUsed and gasLimit. */
+  gasUsedRatio: number[]
+  /** Lowest number block of the returned range. */
+  oldestBlock: bigintType
+  /** An array of effective priority fees (in wei) per gas data points from a single block. All zeroes are returned if the block is empty. */
+  reward?: bigintType[][] | undefined
+}>
+
+export type FeeHistoryRpc = FeeHistory<Hex.Hex>
+
+export type FeeValuesLegacy<bigintType = bigint> = {
+  /** Base fee per gas. */
+  gasPrice: bigintType
+}
+
+export type FeeValuesLegacyRpc = FeeValuesLegacy<Hex.Hex>
+
+export type FeeValuesEip1559<bigintType = bigint> = {
+  /** Total fee per gas in wei (gasPrice/baseFeePerGas + maxPriorityFeePerGas). */
+  maxFeePerGas: bigintType
+  /** Max priority fee per gas (in wei). */
+  maxPriorityFeePerGas: bigintType
+}
+
+export type FeeValuesEip1559Rpc = FeeValuesEip1559<Hex.Hex>
+
+export type FeeValuesEip4844<bigintType = bigint> = {
+  /** Maximum total fee per gas sender is willing to pay for blob gas (in wei). */
+  maxFeePerBlobGas: bigintType
+  /** Total fee per gas in wei (gasPrice/baseFeePerGas + maxPriorityFeePerGas). */
+  maxFeePerGas: bigintType
+  /** Max priority fee per gas (in wei). */
+  maxPriorityFeePerGas: bigintType
+}
+
+export type FeeValuesEip4844Rpc = FeeValuesEip4844<Hex.Hex>
+
+export type FeeValues<bigintType = bigint> = OneOf<
+  | FeeValuesLegacy<bigintType>
+  | FeeValuesEip1559<bigintType>
+  | FeeValuesEip4844<bigintType>
+>
+
+export type FeeValuesRpc = OneOf<
+  FeeValuesLegacyRpc | FeeValuesEip1559Rpc | FeeValuesEip4844Rpc
+>
+
+export type FeeValuesType = 'legacy' | 'eip1559' | 'eip4844'

package/Filter/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/Filter.d.ts",
+  "main": "../_cjs/Filter.js",
+  "module": "../_esm/Filter.js"
+}

package/Filter.ts

@@ -0,0 +1,144 @@
+import type * as Address from './Address.js'
+import type * as Block from './Block.js'
+import type * as Errors from './Errors.js'
+import * as Hex from './Hex.js'
+import type { Compute } from './internal/types.js'
+
+/** A Filter as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/filter.yaml). */
+export type Filter<bigintType = bigint> = Compute<{
+  /** Address to filter for logs. */
+  address?: Address.Address | readonly Address.Address[] | null | undefined
+  /** Block number or tag to filter logs from. */
+  fromBlock?: Block.Number<bigintType> | Block.Tag | undefined
+  /** Block number or tag to filter logs to. */
+  toBlock?: Block.Number<bigintType> | Block.Tag | undefined
+  /** Topics to filter for logs. */
+  topics?: Topics | undefined
+}>
+
+/** RPC representation of a {@link ox#Filter.Filter}. */
+export type Rpc = Filter<Hex.Hex>
+
+/** Set of Filter topics. */
+export type Topics = readonly Topic[]
+
+/**
+ * A filter topic.
+ *
+ * - `null`: Matches any topic.
+ * - `Hex`: Matches if the topic is equal.
+ * - `Hex[]`: Matches if the topic is in the array.
+ */
+export type Topic = Hex.Hex | readonly Hex.Hex[] | null
+
+/**
+ * Converts a {@link ox#Filter.Rpc} to an {@link ox#Filter.Filter}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Filter } from 'ox'
+ *
+ * const filter = Filter.fromRpc({
+ *   address: '0xd3cda913deb6f67967b99d671a681250403edf27',
+ *   fromBlock: 'latest',
+ *   toBlock: '0x010f2c',
+ *   topics: [
+ *     '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+ *     null,
+ *     '0x0000000000000000000000000c04d9e9278ec5e4d424476d3ebec70cb5d648d1',
+ *   ],
+ * })
+ * // @log: {
+ * // @log:   address: '0xd3cda913deb6f67967b99d671a681250403edf27',
+ * // @log:   fromBlock: 'latest',
+ * // @log:   toBlock: 69420n,
+ * // @log:   topics: [
+ * // @log:     '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+ * // @log:     null,
+ * // @log:     '0x0000000000000000000000000c04d9e9278ec5e4d424476d3ebec70cb5d648d1',
+ * // @log:   ],
+ * // @log: }
+ * ```
+ *
+ * @param filter - The RPC filter to convert.
+ * @returns An instantiated {@link ox#Filter.Filter}.
+ */
+export function fromRpc(filter: Rpc): Filter {
+  const { fromBlock, toBlock } = filter
+  return {
+    ...filter,
+    ...(fromBlock && {
+      fromBlock: Hex.validate(fromBlock, { strict: false })
+        ? BigInt(fromBlock)
+        : fromBlock,
+    }),
+    ...(toBlock && {
+      toBlock: Hex.validate(toBlock, { strict: false })
+        ? BigInt(toBlock)
+        : toBlock,
+    }),
+  } as Filter
+}
+
+export declare namespace fromRpc {
+  type ErrorType = Errors.GlobalErrorType
+}
+
+fromRpc.parseError = (error: unknown) =>
+  /* v8 ignore next */
+  error as fromRpc.ErrorType
+
+/**
+ * Converts a {@link ox#Filter.Filter} to a {@link ox#Filter.Rpc}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AbiEvent, Filter } from 'ox'
+ *
+ * const transfer = AbiEvent.from('event Transfer(address indexed, address indexed, uint256)')
+ * const { topics } = AbiEvent.encode(transfer)
+ *
+ * const filter = Filter.toRpc({
+ *   address: '0xfba3912ca04dd458c843e2ee08967fc04f3579c2',
+ *   topics,
+ * })
+ * // @log: {
+ * // @log:   address: '0xfba3912ca04dd458c843e2ee08967fc04f3579c2',
+ * // @log:   topics: [
+ * // @log:     '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+ * // @log:   ],
+ * // @log: }
+ * ```
+ *
+ * @param filter - The filter to convert.
+ * @returns An RPC filter.
+ */
+export function toRpc(filter: Filter): Rpc {
+  const { address, topics, fromBlock, toBlock } = filter
+  return {
+    ...(address && { address }),
+    ...(topics && { topics }),
+    ...(typeof fromBlock !== 'undefined'
+      ? {
+          fromBlock:
+            typeof fromBlock === 'bigint'
+              ? Hex.fromNumber(fromBlock)
+              : fromBlock,
+        }
+      : {}),
+    ...(typeof toBlock !== 'undefined'
+      ? {
+          toBlock:
+            typeof toBlock === 'bigint' ? Hex.fromNumber(toBlock) : toBlock,
+        }
+      : {}),
+  }
+}
+
+export declare namespace toRpc {
+  type ErrorType = Errors.GlobalErrorType
+}
+
+toRpc.parseError = (error: unknown) =>
+  /* v8 ignore next */
+  error as toRpc.ErrorType

package/Hash/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/Hash.d.ts",
+  "main": "../_cjs/Hash.js",
+  "module": "../_esm/Hash.js"
+}