@ariestools/sdk 7.0.6 → 7.0.8

package/dist/neutral/hex.mjs

@@ -1 +1,390 @@
-export * from '../_pkg/hex/neutral/index.mjs'
+// src/modules/hex/address/address.ts
+import * as z from "zod/mini";
+
+// src/modules/hex/HexRegEx.ts
+var HexRegExMinMax = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
+  return new RegExp(`^[a-f0-9]{${minBytes * 2},${maxBytes * 2}}$`);
+};
+var HexRegExMinMaxMixedCaseWithPrefix = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
+  return new RegExp(`^0x[a-fA-F0-9]{${minBytes * 2},${maxBytes * 2}}$`);
+};
+var HexRegEx = /^[0-9a-f]+$/;
+var HexRegExWithPrefix = /^0x[0-9a-f]+$/;
+
+// src/modules/hex/address/address.ts
+var ZERO_ADDRESS = "0000000000000000000000000000000000000000";
+var ADDRESS_LENGTH = 40;
+var AddressRegEx = HexRegExMinMax(ADDRESS_LENGTH / 2, ADDRESS_LENGTH / 2);
+var AddressZod = z.pipe(
+  z.string().check(z.regex(AddressRegEx)),
+  z.transform((v) => v)
+);
+
+// src/modules/hex/address/AddressTransformZod.ts
+import * as z4 from "zod/mini";
+
+// src/modules/hex/address/AddressValidationZod.ts
+import * as z3 from "zod/mini";
+
+// src/modules/typeof/is.ts
+function isUndefined(value) {
+  return value === void 0;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/modules/error/assert.ts
+var assertError = (value, assert, defaultMessage) => {
+  if (!isUndefined(assert)) {
+    const assertString = typeof assert === "string" ? assert : typeof assert === "boolean" ? defaultMessage : assert(value, defaultMessage);
+    if (isString(assertString) || assertString) {
+      throw new Error(assertString === true ? defaultMessage : assertString);
+    }
+  }
+  return void 0;
+};
+
+// src/modules/hex/hex/nibble.ts
+var bitsToNibbles = (value) => {
+  const nibbles = value >> 2;
+  if (value !== nibbles << 2) throw new Error("Bits for nibbles must multiple of 4");
+  return nibbles;
+};
+var nibblesToBits = (value) => {
+  return value << 2;
+};
+
+// src/modules/hex/hex/is.ts
+var isHex = (value, config) => {
+  if (typeof value !== "string") return false;
+  const valueCharLength = value.length - (config?.prefix === true ? 2 : 0);
+  if (config?.bitLength !== void 0 && valueCharLength !== bitsToNibbles(config?.bitLength)) return false;
+  const regex5 = config?.prefix === true ? HexRegExWithPrefix : HexRegEx;
+  return regex5.test(value);
+};
+
+// src/modules/hex/hex/from/fromHexString.ts
+var hexFromHexString = (value, config = {}) => {
+  const {
+    prefix: isPrefix = false,
+    byteSize = 8,
+    bitLength
+  } = config;
+  const nibbleBoundary = bitsToNibbles(byteSize);
+  const unEvened = (value.startsWith("0x") ? value.slice(2) : value).toLowerCase();
+  if (isHex(unEvened)) {
+    const evenCharacters = unEvened.padStart(Math.ceil(unEvened.length / nibbleBoundary) * nibbleBoundary, "0");
+    const padded = isNumber(bitLength) ? evenCharacters.padStart(bitLength / 4, "0") : evenCharacters;
+    return (isPrefix ? `0x${padded}` : padded).toLowerCase();
+  }
+  throw new Error("Received string is not a value hex");
+};
+
+// src/modules/hex/hex/from/fromArrayBuffer.ts
+var hexFromArrayBuffer = (buffer, config) => {
+  const unPadded = [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, "0")).join("");
+  return hexFromHexString(unPadded, config);
+};
+
+// src/modules/hex/hex/from/fromBigInt.ts
+var hexFromBigInt = (value, config = {}) => {
+  const unPadded = value.toString(16);
+  return hexFromHexString(unPadded, config);
+};
+
+// src/modules/hex/hex/from/fromNumber.ts
+var hexFromNumber = (value, config) => {
+  return hexFromBigInt(BigInt(value), config);
+};
+
+// src/modules/hex/hex/from/from.ts
+var hexFrom = (value, config) => {
+  switch (typeof value) {
+    case "string": {
+      return hexFromHexString(value, config);
+    }
+    case "bigint": {
+      return hexFromBigInt(value, config);
+    }
+    case "number": {
+      return hexFromNumber(value, config);
+    }
+    case "object": {
+      return hexFromArrayBuffer(value, config);
+    }
+    default: {
+      throw new Error(`Invalid type: ${typeof value}`);
+    }
+  }
+};
+
+// src/modules/hex/hex/as.ts
+function asHex(value, assert) {
+  switch (typeof value) {
+    case "string": {
+      const stringValue = hexFromHexString(value);
+      return isHex(stringValue) ? stringValue : assertError(value, assert, `Value is not Hex [${value}]`);
+    }
+    default: {
+      return assertError(value, assert, `Unsupported type [${typeof value}]`);
+    }
+  }
+}
+
+// src/modules/hex/hex/hex.ts
+import * as z2 from "zod/mini";
+var HexZod = z2.pipe(
+  z2.string().check(z2.regex(HexRegEx, { error: "Invalid hex format" })),
+  z2.transform((val) => val)
+);
+
+// src/modules/hex/hex/isHexZero.ts
+var isHexZero = (value) => {
+  return isString(value) ? BigInt(hexFromHexString(value, { prefix: true })) === 0n : void 0;
+};
+
+// src/modules/hex/hex/legacy.ts
+var toHexLegacy = (buffer) => {
+  return [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, "0")).join("");
+};
+
+// src/modules/hex/hex/to.ts
+var toHex = (value, config = {}) => {
+  const { prefix: isPrefix = false } = config;
+  return hexFrom(value, { prefix: isPrefix, ...config });
+};
+
+// src/modules/hex/address/AddressValidationZod.ts
+var AddressValidationZod = z3.pipe(
+  z3.string().check(
+    z3.refine((x) => HexZod.safeParse(x).success),
+    z3.refine((x) => x.length === ADDRESS_LENGTH, { error: (e) => new Error(`Address must have 40 characters [${String(e.input)}]`) })
+  ),
+  z3.transform((v) => v)
+);
+
+// src/modules/hex/address/AddressTransformZod.ts
+var AddressTransformZod = z4.pipe(
+  z4.pipe(
+    z4.union([z4.string(), z4.bigint(), z4.number()]),
+    z4.transform((value) => {
+      if (typeof value === "bigint") {
+        return value.toString(16).padStart(ADDRESS_LENGTH, "0");
+      }
+      if (typeof value === "string") {
+        return value.startsWith("0x") ? value.slice(2) : value;
+      }
+      return BigInt(value).toString(16).padStart(ADDRESS_LENGTH, "0");
+    })
+  ).check(z4.refine((x) => AddressValidationZod.safeParse(x).success)),
+  z4.transform((x) => x)
+);
+
+// src/modules/hex/address/is.ts
+var isAddress = (value, config = {}) => {
+  const { bitLength = 160, prefix: isPrefix = false } = config;
+  return isHex(value, { bitLength, prefix: isPrefix });
+};
+function isAddressV2(value) {
+  return AddressValidationZod.safeParse(value).success;
+}
+
+// src/modules/hex/address/as.ts
+function asAddress(value, assert) {
+  try {
+    let stringValue;
+    switch (typeof value) {
+      case "string": {
+        stringValue = hexFromHexString(value, { prefix: false, byteSize: 4 });
+        break;
+      }
+      default: {
+        return isObject(assert) ? assertError(value, assert, `Unsupported type [${typeof value}]`) : void 0;
+      }
+    }
+    return isAddress(stringValue) ? stringValue : assertError(value, assert, `Value is not an Address [${value}]`);
+  } catch (ex) {
+    const error = ex;
+    return assertError(void 0, assert, error.message);
+  }
+}
+function asAddressV2(value, assert = false) {
+  return assert ? AddressValidationZod.parse(value) : AddressValidationZod.safeParse(value).data;
+}
+
+// src/modules/hex/address/to.ts
+var toAddress = (value, config = {}) => {
+  const { bitLength = 160, prefix: isPrefix = false } = config;
+  return hexFrom(value, {
+    bitLength,
+    prefix: isPrefix,
+    ...config
+  });
+};
+function toAddressV2(value, assert = false) {
+  return assert ? AddressTransformZod.parse(value) : AddressTransformZod.safeParse(value).data;
+}
+
+// src/modules/hex/ethAddress.ts
+import * as z5 from "zod/mini";
+var EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20);
+var EthAddressToStringZod = z5.string().check(z5.regex(EthAddressRegEx));
+var EthAddressToStringSchema = EthAddressToStringZod;
+var EthAddressFromStringZod = z5.pipe(
+  z5.string().check(z5.regex(EthAddressRegEx)),
+  z5.transform((v) => toEthAddress(v))
+);
+var EthAddressFromStringSchema = EthAddressFromStringZod;
+var ETH_ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var toEthAddress = (value, config = {}) => {
+  const { bitLength = 160, prefix: isPrefix = false } = config;
+  return `0x${hexFrom(value, {
+    bitLength,
+    prefix: isPrefix,
+    ...config
+  })}`;
+};
+var isEthAddress = (value, config = {}) => {
+  const { bitLength = 160, prefix: isPrefix = true } = config;
+  const loweredValue = typeof value === "string" ? value.toLowerCase() : value;
+  return isHex(loweredValue, { bitLength, prefix: isPrefix });
+};
+var EthAddressZod = z5.string().check(
+  z5.regex(EthAddressRegEx, { error: "Invalid address format" }),
+  z5.refine(isEthAddress)
+);
+function asEthAddress(value, assert) {
+  try {
+    let stringValue;
+    switch (typeof value) {
+      case "string": {
+        stringValue = hexFromHexString(value, { prefix: true, byteSize: 4 });
+        break;
+      }
+      default: {
+        if (value !== void 0) {
+          return assertError(value, assert, `Unsupported type [${typeof value}]`);
+        }
+      }
+    }
+    return isEthAddress(stringValue) ? stringValue : assertError(value, assert, `Value is not an EthAddress [${value}]`);
+  } catch (ex) {
+    const error = ex;
+    return assertError(void 0, assert, error.message);
+  }
+}
+
+// src/modules/hex/hash/is.ts
+var isHash = (value, bitLength = 256) => {
+  return isHex(value, { bitLength });
+};
+
+// src/modules/hex/hash/as.ts
+function asHash(value, assert) {
+  switch (typeof value) {
+    case "string": {
+      const stringValue = hexFromHexString(value);
+      return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`);
+    }
+    default: {
+      return isUndefined(assert) ? void 0 : assertError(value, assert, `Unsupported type [${typeof value}]`);
+    }
+  }
+}
+
+// src/modules/hex/hash/hash.ts
+import * as z6 from "zod/mini";
+var HASH_LENGTH = 32;
+var HashRegEx = HexRegExMinMax(HASH_LENGTH, HASH_LENGTH);
+var ZERO_HASH = "0000000000000000000000000000000000000000000000000000000000000000";
+var HashBitLength = [32, 64, 128, 256, 512, 1024, 2048, 4096];
+var isHashBitLength = (value) => {
+  return typeof value === "number" && HashBitLength.includes(value);
+};
+var HashZod = z6.pipe(
+  z6.string().check(z6.regex(HashRegEx, { error: "Invalid hex format" })),
+  z6.transform((val) => val)
+);
+
+// src/modules/hex/hash/zod.ts
+import * as z7 from "zod/mini";
+var HashToJsonZod = z7.pipe(HashZod, z7.transform((v) => v));
+var JsonToHashZod = z7.pipe(z7.string(), z7.transform((v) => asHash(v, true)));
+
+// src/modules/hex/hexToBigInt.ts
+function hexToBigInt(hex) {
+  return BigInt(hexFromHexString(hex, { prefix: true }));
+}
+
+// src/modules/hex/zod.ts
+import * as z8 from "zod/mini";
+var BigIntToJsonZod = z8.pipe(
+  z8.bigint().check(z8.nonnegative()),
+  z8.transform((x) => toHex(x))
+);
+var JsonToBigIntZod = z8.pipe(
+  z8.string(),
+  z8.transform((x) => hexToBigInt(toHex(x)))
+);
+export {
+  ADDRESS_LENGTH,
+  AddressRegEx,
+  AddressTransformZod,
+  AddressValidationZod,
+  AddressZod,
+  BigIntToJsonZod,
+  ETH_ZERO_ADDRESS,
+  EthAddressFromStringSchema,
+  EthAddressFromStringZod,
+  EthAddressRegEx,
+  EthAddressToStringSchema,
+  EthAddressToStringZod,
+  EthAddressZod,
+  HASH_LENGTH,
+  HashBitLength,
+  HashRegEx,
+  HashToJsonZod,
+  HashZod,
+  HexRegEx,
+  HexRegExMinMax,
+  HexRegExMinMaxMixedCaseWithPrefix,
+  HexRegExWithPrefix,
+  HexZod,
+  JsonToBigIntZod,
+  JsonToHashZod,
+  ZERO_ADDRESS,
+  ZERO_HASH,
+  asAddress,
+  asAddressV2,
+  asEthAddress,
+  asHash,
+  asHex,
+  bitsToNibbles,
+  hexFrom,
+  hexFromArrayBuffer,
+  hexFromBigInt,
+  hexFromHexString,
+  hexFromNumber,
+  hexToBigInt,
+  isAddress,
+  isAddressV2,
+  isEthAddress,
+  isHash,
+  isHashBitLength,
+  isHex,
+  isHexZero,
+  nibblesToBits,
+  toAddress,
+  toAddressV2,
+  toEthAddress,
+  toHex,
+  toHexLegacy
+};
+//# sourceMappingURL=hex.mjs.map

package/dist/neutral/hex.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/modules/hex/address/address.ts", "../../src/modules/hex/HexRegEx.ts", "../../src/modules/hex/address/AddressTransformZod.ts", "../../src/modules/hex/address/AddressValidationZod.ts", "../../src/modules/typeof/is.ts", "../../src/modules/error/assert.ts", "../../src/modules/hex/hex/nibble.ts", "../../src/modules/hex/hex/is.ts", "../../src/modules/hex/hex/from/fromHexString.ts", "../../src/modules/hex/hex/from/fromArrayBuffer.ts", "../../src/modules/hex/hex/from/fromBigInt.ts", "../../src/modules/hex/hex/from/fromNumber.ts", "../../src/modules/hex/hex/from/from.ts", "../../src/modules/hex/hex/as.ts", "../../src/modules/hex/hex/hex.ts", "../../src/modules/hex/hex/isHexZero.ts", "../../src/modules/hex/hex/legacy.ts", "../../src/modules/hex/hex/to.ts", "../../src/modules/hex/address/is.ts", "../../src/modules/hex/address/as.ts", "../../src/modules/hex/address/to.ts", "../../src/modules/hex/ethAddress.ts", "../../src/modules/hex/hash/is.ts", "../../src/modules/hex/hash/as.ts", "../../src/modules/hex/hash/hash.ts", "../../src/modules/hex/hash/zod.ts", "../../src/modules/hex/hexToBigInt.ts", "../../src/modules/hex/zod.ts"],
+  "sourcesContent": ["import * as z from 'zod/mini'\n\nimport type { Brand } from '#typeof'\n\nimport { type Hex } from '../hex/index.ts'\nimport { HexRegExMinMax } from '../HexRegEx.ts'\n\n/** A 160-bit zero address constant. */\nexport const ZERO_ADDRESS = '0000000000000000000000000000000000000000' as Address\n/** The character length of an address hex string (40 hex characters / 20 bytes). */\nexport const ADDRESS_LENGTH = 40 as const\n\n/** Regular expression matching a 20-byte (40 hex character) address string. */\nexport const AddressRegEx = HexRegExMinMax(ADDRESS_LENGTH / 2, ADDRESS_LENGTH / 2)\n\ntype BrandedAddress = Brand<Hex, { readonly __address: true }>\n\n/** Zod schema that validates and transforms a string into a branded Address type. */\nexport const AddressZod = z.pipe(\n  z.string().check(z.regex(AddressRegEx)),\n  z.transform((v: string): BrandedAddress => v as BrandedAddress),\n)\n\n/** A validated 20-byte address string type, inferred from the AddressZod schema. */\nexport type Address = z.infer<typeof AddressZod>\n", "/**\n * Creates a RegExp matching lowercase hex strings with a byte length in the given range.\n * @param minBytes - Minimum number of bytes (default 0)\n * @param maxBytes - Maximum number of bytes\n * @returns A RegExp for validating hex strings within the byte range\n */\nexport const HexRegExMinMax = (minBytes = 0, maxBytes: number = (Number.MAX_SAFE_INTEGER / 2)) => {\n  return new RegExp(`^[a-f0-9]{${minBytes * 2},${maxBytes * 2}}$`)\n}\n\n/**\n * Creates a RegExp matching mixed-case hex strings with a 0x prefix and a byte length in the given range.\n * @param minBytes - Minimum number of bytes (default 0)\n * @param maxBytes - Maximum number of bytes\n * @returns A RegExp for validating prefixed hex strings within the byte range\n */\nexport const HexRegExMinMaxMixedCaseWithPrefix = (minBytes = 0, maxBytes: number = (Number.MAX_SAFE_INTEGER / 2)) => {\n  return new RegExp(`^0x[a-fA-F0-9]{${minBytes * 2},${maxBytes * 2}}$`)\n}\n\n/** Regular expression matching a lowercase hex string without prefix. */\nexport const HexRegEx = /^[0-9a-f]+$/\n/** Regular expression matching a lowercase hex string with a 0x prefix. */\nexport const HexRegExWithPrefix = /^0x[0-9a-f]+$/\n", "import * as z from 'zod/mini'\n\nimport { type Address, ADDRESS_LENGTH } from './address.ts'\nimport { AddressValidationZod } from './AddressValidationZod.ts'\n\n/** Zod schema that accepts a string, bigint, or number and transforms it into a validated Address. */\nexport const AddressTransformZod = z.pipe(\n  z.pipe(\n    z.union([z.string(), z.bigint(), z.number()]),\n    z.transform((value: string | bigint | number): string => {\n      if (typeof value === 'bigint') {\n        return value.toString(16).padStart(ADDRESS_LENGTH, '0')\n      }\n      if (typeof value === 'string') {\n        return value.startsWith('0x') ? value.slice(2) : value\n      }\n      return BigInt(value).toString(16).padStart(ADDRESS_LENGTH, '0')\n    }),\n  ).check(z.refine((x: string) => AddressValidationZod.safeParse(x).success)),\n  z.transform((x: string): Address => x as Address),\n)\n\n/** The output type of AddressTransformZod after parsing and transformation. */\nexport type AddressTransformZodType = z.infer<typeof AddressTransformZod>\n", "import * as z from 'zod/mini'\n\nimport { HexZod } from '../hex/index.ts'\nimport type { Address } from './address.ts'\nimport { ADDRESS_LENGTH } from './address.ts'\n\n/** Zod schema that validates a string is a properly formatted 40-character hex address. */\nexport const AddressValidationZod = z.pipe(\n  z.string().check(\n    z.refine((x: string) => HexZod.safeParse(x).success),\n    z.refine((x: string) => x.length === ADDRESS_LENGTH, { error: e => new Error(`Address must have 40 characters [${String(e.input)}]`) }),\n  ),\n  z.transform((v: string): Address => v as Address),\n)\n\n/** The output type of AddressValidationZod after parsing. */\nexport type AddressValidationZodType = z.infer<typeof AddressValidationZod>\n", "/// <reference lib=\"dom\" />\n\n/** A function type that accepts any arguments and returns unknown. */\nexport type AnyFunction = (...args: unknown[]) => unknown\n\n/** A union of valid object key types. */\nexport type RecordKey = string | number | symbol\n\n/** Type guard that checks whether a value is undefined. */\nexport function isUndefined(value: unknown): value is undefined\nexport function isUndefined<T>(value: T): value is Extract<T, undefined>\nexport function isUndefined(value: unknown): value is undefined {\n  return value === undefined\n}\n\n/** Type guard that checks whether a value is not undefined. */\nexport function isDefined<T>(value: T): value is Exclude<T, undefined> {\n  return !isUndefined(value)\n}\n\n/** Type guard that checks whether a value is null. */\nexport function isNull(value: unknown): value is null\nexport function isNull<T>(value: T): value is Extract<T, null>\nexport function isNull(value: unknown): value is null {\n  return value === null\n}\n\n/** Type guard that checks whether a value is neither undefined nor null. */\nexport function isDefinedNotNull<T>(value: T): value is Exclude<T, undefined | null> {\n  return !isUndefined(value) && !isNull(value)\n}\n\n/** Type guard that checks whether a value is undefined or null. */\nexport function isUndefinedOrNull(value: unknown): value is undefined | null\nexport function isUndefinedOrNull<T>(value: T): value is Extract<T, undefined | null>\nexport function isUndefinedOrNull(value: unknown): value is undefined | null {\n  return isUndefined(value) || isNull(value)\n}\n\n/** Type guard that checks whether a value is a bigint. */\nexport function isBigInt(value: unknown): value is bigint\nexport function isBigInt<T extends bigint>(value: T): value is Extract<T, bigint>\nexport function isBigInt(value: unknown): value is bigint {\n  return typeof value === 'bigint'\n}\n\n/** Type guard that checks whether a value is a string. */\nexport function isString(value: unknown): value is string\nexport function isString<T extends string>(value: T): value is Extract<T, string>\nexport function isString(value: unknown): value is string {\n  return typeof value === 'string'\n}\n\n/** Type guard that checks whether a value is a number. */\nexport function isNumber(value: unknown): value is number\nexport function isNumber<T extends number>(value: T): value is Extract<T, number>\nexport function isNumber(value: unknown): value is number {\n  return typeof value === 'number'\n}\n\n/** Type guard that checks whether a value is a plain object (not null and not an array). */\nexport function isObject(value: unknown): value is object\nexport function isObject<T extends object>(value: T): value is Extract<T, object>\nexport function isObject(value: unknown): value is object {\n  return (typeof value === 'object') && (value !== null) && !Array.isArray(value)\n}\n\n/** Type guard that checks whether a value is an array. */\nexport function isArray(value: unknown): value is readonly unknown[]\nexport function isArray<T>(value: T): value is Extract<T, readonly unknown[]>\nexport function isArray(value: unknown): value is readonly unknown[] {\n  return Array.isArray(value)\n}\n\n/** Type guard that checks whether a value is a function. */\nexport function isFunction(value: unknown): value is AnyFunction\nexport function isFunction<T extends AnyFunction>(value: T): value is Extract<T, AnyFunction>\nexport function isFunction(value: unknown): value is AnyFunction {\n  return typeof value === 'function'\n}\n\n/** Type guard that checks whether a value is a symbol. */\nexport function isSymbol(value: unknown): value is symbol\nexport function isSymbol<T extends symbol>(value: T): value is Extract<T, symbol>\nexport function isSymbol(value: unknown): value is symbol {\n  return typeof value === 'symbol'\n}\n\n/** Type guard that checks whether a value is an object with no own keys. */\nexport function isEmptyObject(value: unknown): value is {}\nexport function isEmptyObject<K extends RecordKey, V, T extends Record<K, V>>(value: T): value is Extract<T, Record<K, never>>\nexport function isEmptyObject(value: unknown): value is {} {\n  return isObject(value) && Object.keys(value).length === 0\n}\n\n/** Type guard that checks whether a value is an empty string. */\nexport function isEmptyString(value: unknown): value is ''\nexport function isEmptyString<T extends string>(value: T): value is Extract<T, ''>\nexport function isEmptyString(value: unknown): value is '' {\n  return isString(value) && value.length === 0\n}\n\n/** Type guard that checks whether a value is an empty array. */\nexport function isEmptyArray(value: unknown): value is []\nexport function isEmptyArray<T extends unknown[]>(value: T): value is Extract<T, unknown[]>\nexport function isEmptyArray(value: unknown): value is [] {\n  return isArray(value) && value.length === 0\n}\n\n/** Type guard that checks whether a value is a non-empty array. */\nexport function isPopulatedArray(value: unknown): value is readonly unknown[]\nexport function isPopulatedArray<T extends unknown[]>(value: T): value is Extract<T, readonly unknown[]>\nexport function isPopulatedArray(value: unknown): value is readonly unknown[] {\n  return isArray(value) && value.length > 0\n}\n\n/** Type guard that checks whether a value is empty (empty string, empty array, or empty object). */\nexport function isEmpty<T>(value: unknown): value is T\nexport function isEmpty<K extends RecordKey, V, T extends Record<K, V>>(value: T): value is Extract<T, Record<K, never>>\nexport function isEmpty<T extends unknown[]>(value: T): value is Extract<T, never[]>\nexport function isEmpty<T>(value: unknown): value is T {\n  return isEmptyString(value) || isEmptyArray(value) || isEmptyObject(value)\n}\n\n/** Type guard that checks whether a value is falsy (0, null, undefined, false, '', or 0n). */\nexport function isFalsy<T>(value: T): value is Extract<T, 0 | null | undefined | false | '' | 0n>\nexport function isFalsy<T extends boolean>(value: T): value is Extract<T, false>\nexport function isFalsy<T extends number>(value: T): value is Extract<T, 0>\nexport function isFalsy<T extends bigint>(value: T): value is Extract<T, 0n>\nexport function isFalsy<T extends null>(value: T): value is Extract<T, null>\nexport function isFalsy<T extends undefined>(value: T): value is Extract<T, undefined>\nexport function isFalsy<T extends string>(value: T): value is Extract<T, ''>\nexport function isFalsy<T>(value: T): value is T {\n  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- mirrors JavaScript falsy semantics (incl. NaN)\n  return !value\n}\n\n/** Type guard that checks whether a value is truthy (not 0, null, undefined, false, '', or 0n). */\nexport function isTruthy<T>(value: T): value is Exclude<T, 0 | null | undefined | false | '' | 0n>\nexport function isTruthy<T extends boolean>(value: T): value is Extract<T, true>\nexport function isTruthy<T extends number>(value: T): value is Extract<T, number>\nexport function isTruthy<T extends bigint>(value: T): value is Extract<T, bigint>\nexport function isTruthy<T extends null>(value: T): value is Extract<T, null>\nexport function isTruthy<T extends undefined>(value: T): value is Extract<T, undefined>\nexport function isTruthy<T extends string>(value: T): value is Extract<T, string>\nexport function isTruthy<T>(value: T): value is T {\n  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- mirrors JavaScript truthy semantics\n  return !!value\n}\n\n/** Type guard that checks whether a value is a boolean. */\nexport function isBoolean(value: unknown): value is boolean\nexport function isBoolean<T extends boolean>(value: T): value is Extract<T, boolean>\nexport function isBoolean(value: unknown): value is boolean {\n  return typeof value === 'boolean'\n}\n\n/** Type guard that checks whether a value is a string that can be parsed as a valid date. */\nexport function isDateString(value: unknown): value is string\nexport function isDateString<T>(value: T): value is Extract<T, string>\nexport function isDateString(value: unknown): value is string {\n  return isString(value) && !Number.isNaN(Date.parse(value))\n}\n\n/** Type guard that checks whether a value is a Date instance. */\nexport function isDate(value: unknown): value is Date\nexport function isDate<T>(value: T): value is Extract<T, Date>\nexport function isDate(value: unknown): value is Date {\n  return value instanceof Date\n}\n\n/** Type guard that checks whether a value is a RegExp instance. */\nexport function isRegExp(value: unknown): value is RegExp\nexport function isRegExp<T extends RegExp>(value: T): value is Extract<T, RegExp>\nexport function isRegExp(value: unknown): value is RegExp {\n  return value instanceof RegExp\n}\n\n/** Type guard that checks whether a value is an Error instance. */\nexport function isError(value: unknown): value is Error\nexport function isError<T>(value: T): value is Extract<T, Error>\nexport function isError(value: unknown): value is Error {\n  return value instanceof Error\n}\n\n/** Type guard that checks whether a value is a Promise instance. */\nexport function isPromise(value: unknown): value is Promise<unknown>\nexport function isPromise<T>(value: T): value is Extract<T, Promise<unknown>>\nexport function isPromise(value: unknown): value is Promise<unknown> {\n  return value instanceof Promise\n}\n\n/** Type guard that checks whether a value is promise-like (has a `then` method). */\nexport function isPromiseLike(value: unknown): value is Promise<unknown>\nexport function isPromiseLike<T>(value: T): value is Extract<T, Promise<unknown>>\nexport function isPromiseLike(value: unknown): value is Promise<unknown> {\n  return (\n    typeof value === 'object'\n    && value !== null\n    && typeof (value as Record<string, unknown>).then === 'function'\n  )\n}\n\n/** Type guard that checks whether a value is a Map instance. */\nexport function isMap(value: unknown): value is Map<unknown, unknown>\nexport function isMap<K, V, T extends Map<K, V>>(value: T): value is Extract<T, Map<K, V>>\nexport function isMap(value: unknown): value is Map<unknown, unknown> {\n  return value instanceof Map\n}\n\n/** Type guard that checks whether a value is an ArrayBufferView (e.g., TypedArray or DataView). */\nexport function isArrayBufferView(value: unknown): value is ArrayBufferView\nexport function isArrayBufferView<T extends ArrayBufferView>(value: T): value is Extract<T, ArrayBufferView>\nexport function isArrayBufferView(value: unknown): value is ArrayBufferView {\n  return ArrayBuffer.isView(value)\n}\n\n/** Type guard that checks whether a value is a Set instance. */\nexport function isSet(value: unknown): value is Set<unknown>\nexport function isSet<T extends Set<unknown>>(value: T): value is Extract<T, Set<unknown>>\nexport function isSet(value: unknown): value is Set<unknown> {\n  return value instanceof Set\n}\n\n/** Type guard that checks whether a value is a WeakMap instance. */\nexport function isWeakMap(value: unknown): value is WeakMap<WeakKey, unknown>\nexport function isWeakMap<K extends WeakKey, V, T extends WeakMap<K, V>>(value: T): value is Extract<T, WeakMap<K, V>>\nexport function isWeakMap(value: unknown): value is WeakMap<WeakKey, unknown> {\n  return value instanceof WeakMap\n}\n\n/** Type guard that checks whether a value is a WeakSet instance. */\nexport function isWeakSet(value: unknown): value is WeakSet<WeakKey>\nexport function isWeakSet<K extends WeakKey, T extends WeakSet<K>>(value: T): value is Extract<T, WeakSet<K>>\nexport function isWeakSet(value: unknown): value is WeakSet<WeakKey> {\n  return value instanceof WeakSet\n}\n\n/** Type guard that checks whether a value is a DataView instance. */\nexport function isDataView(value: unknown): value is DataView\nexport function isDataView<T>(value: T): value is Extract<T, DataView>\nexport function isDataView(value: unknown): value is DataView {\n  return value instanceof DataView\n}\n\n/** Type guard that checks whether a value is a Blob instance. */\nexport function isBlob(value: unknown): value is Blob\nexport function isBlob<T extends Blob>(value: T): value is Extract<T, Blob>\nexport function isBlob(value: unknown): value is Blob {\n  return typeof Blob !== 'undefined' && value instanceof Blob\n}\n\n/** Type guard that checks whether a value is a File instance. */\nexport function isFile(value: unknown): value is File\nexport function isFile<T extends File>(value: T): value is Extract<T, File>\nexport function isFile(value: unknown): value is File {\n  return typeof File !== 'undefined' && value instanceof File\n}\n", "import { isString, isUndefined } from '#typeof'\n\ntype AssertCallback = (value: unknown, message: string) => string | boolean\n\n/** Configuration for assertion behavior: a static message string, a boolean toggle, or a callback. */\nexport type AssertConfig = string | AssertCallback | boolean\n\n/**\n * Throws an Error based on the assert configuration when a value fails validation.\n * @param value - The value being validated\n * @param assert - Assertion config controlling the error message\n * @param defaultMessage - Fallback message if no custom message is provided\n */\nexport const assertError = (value: unknown, assert: AssertConfig | undefined, defaultMessage: string) => {\n  if (!isUndefined(assert)) {\n    const assertString\n      = typeof assert === 'string'\n        ? assert\n        : typeof assert === 'boolean'\n          ? defaultMessage\n          : assert(value, defaultMessage)\n    if (isString(assertString) || assertString) {\n      throw new Error(assertString === true ? defaultMessage : assertString)\n    }\n  }\n  // eslint-disable-next-line unicorn/no-useless-undefined\n  return undefined\n}\n", "/**\n * Converts a bit count to the equivalent number of hex nibbles (4 bits each).\n * @param value - The number of bits (must be a multiple of 4)\n * @returns The number of nibbles\n */\nexport const bitsToNibbles = (value: number): number => {\n  const nibbles = value >> 2\n  if (value !== nibbles << 2) throw new Error('Bits for nibbles must multiple of 4')\n  return nibbles\n}\n\n/**\n * Converts a nibble count to the equivalent number of bits.\n * @param value - The number of nibbles\n * @returns The number of bits\n */\nexport const nibblesToBits = (value: number): number => {\n  return value << 2\n}\n", "import { HexRegEx, HexRegExWithPrefix } from '../HexRegEx.ts'\nimport type { Hex, HexConfig } from './hex.ts'\nimport { bitsToNibbles } from './nibble.ts'\n\n/**\n * Type guard that checks whether a value is a valid hex string.\n * @param value - The value to check\n * @param config - Optional configuration for prefix and bit length validation\n * @returns True if the value is a valid Hex string\n */\nexport const isHex = (value: unknown, config?: HexConfig): value is Hex => {\n  // Is it a string?\n  if (typeof value !== 'string') return false\n\n  const valueCharLength = value.length - (config?.prefix === true ? 2 : 0)\n\n  // If a bitLength specified, does it conform?\n  if (config?.bitLength !== undefined && valueCharLength !== bitsToNibbles(config?.bitLength)) return false\n\n  // Does it only has hex values?\n  const regex = config?.prefix === true ? HexRegExWithPrefix : HexRegEx\n  return regex.test(value)\n}\n", "import { isNumber } from '#typeof'\n\nimport type { Hex, HexConfig } from '../hex.ts'\nimport { isHex } from '../is.ts'\nimport { bitsToNibbles } from '../nibble.ts'\n\n/**\n * Normalizes a hex string by stripping an optional 0x prefix, lowercasing, and padding to byte/bit boundaries.\n * @param value - The hex string to normalize (with or without 0x prefix)\n * @param config - Configuration for prefix, byteSize, and bitLength padding\n * @returns The normalized Hex string\n */\nexport const hexFromHexString = (value: string, config: HexConfig = {}): Hex => {\n  const {\n    prefix: isPrefix = false, byteSize = 8, bitLength,\n  } = config\n  const nibbleBoundary = bitsToNibbles(byteSize)\n  const unEvened = (value.startsWith('0x') ? value.slice(2) : value).toLowerCase()\n  if (isHex(unEvened)) {\n    const evenCharacters = unEvened.padStart(Math.ceil(unEvened.length / nibbleBoundary) * nibbleBoundary, '0')\n    const padded = isNumber(bitLength) ? evenCharacters.padStart(bitLength / 4, '0') : evenCharacters\n    return (isPrefix ? `0x${padded}` : padded).toLowerCase() as Hex\n  }\n  throw new Error('Received string is not a value hex')\n}\n", "import type { Hex, HexConfig } from '../hex.ts'\nimport { hexFromHexString } from './fromHexString.ts'\n\n/** Convert an ArrayBuffer to a hex string */\nexport const hexFromArrayBuffer = (\n  /** The buffer to be converted */\n  buffer: ArrayBufferLike,\n  /** Configuration of output format and validation */\n  config?: HexConfig,\n): Hex => {\n  const unPadded = [...new Uint8Array(buffer)].map(x => x.toString(16).padStart(2, '0')).join('')\n  return hexFromHexString(unPadded, config)\n}\n", "import type { Hex, HexConfig } from '../hex.ts'\nimport { hexFromHexString } from './fromHexString.ts'\n\n/** Convert a bigint to a hex string */\nexport const hexFromBigInt = (\n  /** The bigint to be converted */\n  value: bigint,\n  /** Configuration of output format and validation */\n  config: HexConfig = {},\n): Hex => {\n  const unPadded = value.toString(16)\n  return hexFromHexString(unPadded, config)\n}\n", "import type { Hex, HexConfig } from '../hex.ts'\nimport { hexFromBigInt } from './fromBigInt.ts'\n\n/**\n * Converts a number to a hex string by converting to BigInt first.\n * @param value - The number to convert\n * @param config - Optional hex output configuration\n * @returns The hex string representation\n */\nexport const hexFromNumber = (value: number, config?: HexConfig): Hex => {\n  return hexFromBigInt(BigInt(value), config)\n}\n", "import type { Hex, HexConfig } from '../hex.ts'\nimport { hexFromArrayBuffer } from './fromArrayBuffer.ts'\nimport { hexFromBigInt } from './fromBigInt.ts'\nimport { hexFromHexString } from './fromHexString.ts'\nimport { hexFromNumber } from './fromNumber.ts'\n\n/** Takes unknown value and tries our best to convert it to a hex string */\nexport const hexFrom = (\n  /** Supported types are string, number, bigint, and ArrayBuffer */\n  value: string | number | bigint | ArrayBufferLike,\n  /** Configuration of output format and validation */\n  config?: HexConfig,\n): Hex => {\n  switch (typeof value) {\n    case 'string': {\n      return hexFromHexString(value, config)\n    }\n    case 'bigint': {\n      return hexFromBigInt(value, config)\n    }\n    case 'number': {\n      return hexFromNumber(value, config)\n    }\n    case 'object': {\n      return hexFromArrayBuffer(value, config)\n    }\n    default: {\n      throw new Error(`Invalid type: ${typeof value}`)\n    }\n  }\n}\n", "import type { AssertConfig } from '#error'\nimport { assertError } from '#error'\n\nimport { hexFromHexString } from './from/index.ts'\nimport type { Hex } from './hex.ts'\nimport { isHex } from './is.ts'\n\n/**\n * Attempts to coerce a value into a Hex type, returning undefined or throwing based on the assert config.\n * @param value - The value to coerce (must be a string)\n * @param assert - If provided, throws on failure instead of returning undefined\n * @returns The value as Hex, or undefined if coercion fails and assert is not set\n */\nexport function asHex(value: unknown): Hex | undefined\nexport function asHex(value: unknown, assert: AssertConfig): Hex\nexport function asHex(value: unknown, assert?: AssertConfig): Hex | undefined {\n  switch (typeof value) {\n    case 'string': {\n      const stringValue = hexFromHexString(value)\n      return isHex(stringValue) ? stringValue : assertError(value, assert, `Value is not Hex [${value}]`)\n    }\n    default: {\n      return assertError(value, assert, `Unsupported type [${typeof value}]`)\n    }\n  }\n}\n", "import * as z from 'zod/mini'\n\nimport type { Brand } from '#typeof'\n\nimport { HexRegEx } from '../HexRegEx.ts'\n\n/** Branded type representing a validated lowercase hex string. */\nexport type BrandedHex = Brand<Lowercase<string>, { readonly __hex: true }>\n\n/** Zod schema that validates and transforms a string into a branded Hex type. */\nexport const HexZod = z.pipe(\n  z.string().check(z.regex(HexRegEx, { error: 'Invalid hex format' })),\n  z.transform((val: string) => val as BrandedHex),\n)\n\n/** Configuration of validation and output format */\nexport interface HexConfig {\n  bitLength?: number\n  byteSize?: number\n  prefix?: boolean\n}\n\n/** A validated hex string type, inferred from the HexZod schema. */\nexport type Hex = z.infer<typeof HexZod>\n", "import { isString } from '#typeof'\n\nimport { hexFromHexString } from './from/index.ts'\n\n/**\n * Checks whether a hex string represents a zero value.\n * @param value - The hex string to check\n * @returns True if zero, false if non-zero, or undefined if the input is not a string\n */\nexport const isHexZero = (value?: string) => {\n  return isString(value) ? BigInt(hexFromHexString(value, { prefix: true })) === 0n : undefined\n}\n", "/**\n * Converts an ArrayBuffer to a hex string without padding or normalization.\n * @param buffer - The ArrayBuffer to convert\n * @returns A lowercase hex string representation of the buffer\n */\nexport const toHexLegacy = (buffer: ArrayBuffer) => {\n  return [...new Uint8Array(buffer)].map(x => x.toString(16).padStart(2, '0')).join('')\n}\n", "import { hexFrom } from './from/index.ts'\nimport type { HexConfig } from './hex.ts'\n\n/** takes any value and tries our best to convert it to a hex string */\nexport const toHex = (\n  /** Supported types are string, number, bigint, and ArrayBuffer */\n  value: string | number | bigint | ArrayBufferLike,\n  /** Configuration of output format and validation */\n  config: HexConfig = {},\n) => {\n  const { prefix: isPrefix = false } = config\n  return hexFrom(value, { prefix: isPrefix, ...config })\n}\n", "import type { HexConfig } from '../hex/index.ts'\nimport { isHex } from '../hex/index.ts'\nimport type { Address } from './address.ts'\nimport { AddressValidationZod } from './AddressValidationZod.ts'\n\n/**\n * Type guard that checks whether a value is a valid 160-bit address.\n * @param value - The value to check\n * @param config - Optional hex config (defaults to 160-bit, no prefix)\n * @returns True if the value is a valid Address\n */\nexport const isAddress = (value?: unknown, config: HexConfig = {}): value is Address => {\n  const { bitLength = 160, prefix: isPrefix = false } = config\n  return isHex(value, { bitLength, prefix: isPrefix })\n}\n\n/** @alpha */\nexport function isAddressV2(value?: unknown): value is Address {\n  return AddressValidationZod.safeParse(value).success\n}\n", "import type { AssertConfig } from '#error'\nimport { assertError } from '#error'\nimport { isObject } from '#typeof'\n\nimport { hexFromHexString } from '../hex/index.ts'\nimport type { Address } from './address.ts'\nimport { AddressValidationZod } from './AddressValidationZod.ts'\nimport { isAddress } from './is.ts'\n\n/**\n * Attempts to coerce a value into an Address type, returning undefined or throwing based on the assert config.\n * @param value - The value to coerce (must be a string)\n * @param assert - If provided, throws on failure instead of returning undefined\n * @returns The value as Address, or undefined if coercion fails and assert is not set\n */\nexport function asAddress(value?: unknown): Address | undefined\nexport function asAddress(value: unknown, assert: AssertConfig): Address\nexport function asAddress(value?: unknown, assert?: AssertConfig): Address | undefined {\n  try {\n    let stringValue: string | undefined\n\n    switch (typeof value) {\n      case 'string': {\n        stringValue = hexFromHexString(value, { prefix: false, byteSize: 4 })\n        break\n      }\n      default: {\n        return isObject(assert) ? assertError(value, assert, `Unsupported type [${typeof value}]`) : undefined\n      }\n    }\n    return isAddress(stringValue) ? stringValue : assertError(value, assert, `Value is not an Address [${value}]`)\n  } catch (ex) {\n    const error = ex as Error\n    return assertError(undefined, assert, error.message)\n  }\n}\n\n/** @alpha */\nexport function asAddressV2(value?: unknown, assert = false): Address | undefined {\n  return assert\n    ? AddressValidationZod.parse(value)\n    : AddressValidationZod.safeParse(value).data\n}\n", "import type { HexConfig } from '../hex/index.ts'\nimport { hexFrom } from '../hex/index.ts'\nimport type { Address } from './address.ts'\nimport { AddressTransformZod } from './AddressTransformZod.ts'\n\n/**\n * Converts a value to a 160-bit Address hex string.\n * @param value - The value to convert (string, number, bigint, or ArrayBuffer)\n * @param config - Optional hex config (defaults to 160-bit, no prefix)\n * @returns The value as an Address\n */\nexport const toAddress = (value: string | number | bigint | ArrayBufferLike, config: HexConfig = {}): Address => {\n  const { bitLength = 160, prefix: isPrefix = false } = config\n  return hexFrom(value, {\n    bitLength, prefix: isPrefix, ...config,\n  }) as unknown as Address\n}\n\n/** @alpha */\nexport function toAddressV2(value: unknown, assert = false): Address | undefined {\n  return assert\n    ? AddressTransformZod.parse(value)\n    : AddressTransformZod.safeParse(value).data\n}\n", "import * as z from 'zod/mini'\n\nimport type { AssertConfig } from '#error'\nimport { assertError } from '#error'\nimport type { Brand } from '#typeof'\n\nimport type { HexConfig } from './hex/index.ts'\nimport {\n  hexFrom, hexFromHexString, isHex,\n} from './hex/index.ts'\nimport { HexRegExMinMaxMixedCaseWithPrefix } from './HexRegEx.ts'\n\n/** Regular expression matching a 20-byte Ethereum address with 0x prefix (mixed case). */\nexport const EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20)\n\n/** Zod schema that validates a string is a properly formatted Ethereum address. */\nexport const EthAddressToStringZod = z.string().check(z.regex(EthAddressRegEx))\n\n/** @deprecated use EthAddressToStringZod */\nexport const EthAddressToStringSchema = EthAddressToStringZod\n\n/** Zod schema that validates and transforms a string into an EthAddress type. */\nexport const EthAddressFromStringZod = z.pipe(\n  z.string().check(z.regex(EthAddressRegEx)),\n  z.transform((v: string) => toEthAddress(v)),\n)\n\n/** @deprecated use EthAddressFromStringZod */\nexport const EthAddressFromStringSchema = EthAddressFromStringZod\n\n/** Branded type representing a validated Ethereum address with 0x prefix. */\n// using true instead of unique symbol to avoid conflicts with other versions of library\nexport type EthAddress = Brand<string, { readonly __eth_address: true }>\n\n/** The zero Ethereum address constant (0x followed by 40 zero characters). */\nexport const ETH_ZERO_ADDRESS = '0x0000000000000000000000000000000000000000' as EthAddress\n\n/**\n * Converts a value to a 0x-prefixed Ethereum address string.\n * @param value - The value to convert (string, number, bigint, or ArrayBuffer)\n * @param config - Optional hex config (defaults to 160-bit, no inner prefix)\n * @returns The value as an EthAddress\n */\nexport const toEthAddress = (value: string | number | bigint | ArrayBufferLike, config: HexConfig = {}): EthAddress => {\n  const { bitLength = 160, prefix: isPrefix = false } = config\n  return `0x${hexFrom(value, {\n    bitLength, prefix: isPrefix, ...config,\n  })}` as EthAddress\n}\n\n/**\n * Type guard that checks whether a value is a valid 0x-prefixed Ethereum address.\n * @param value - The value to check\n * @param config - Optional hex config (defaults to 160-bit with prefix)\n * @returns True if the value is a valid EthAddress\n */\nexport const isEthAddress = (value?: unknown, config: HexConfig = {}): value is EthAddress => {\n  const { bitLength = 160, prefix: isPrefix = true } = config\n  const loweredValue = typeof value === 'string' ? value.toLowerCase() : value\n  return isHex(loweredValue, { bitLength, prefix: isPrefix })\n}\n\n/** Zod schema that validates a string as a properly formatted Ethereum address using regex and type guard. */\nexport const EthAddressZod = z.string().check(\n  z.regex(EthAddressRegEx, { error: 'Invalid address format' }),\n  z.refine(isEthAddress),\n)\n\n/**\n * Attempts to coerce a value into an EthAddress, returning undefined or throwing based on the assert config.\n * @param value - The value to coerce (must be a string)\n * @param assert - If provided, throws on failure instead of returning undefined\n * @returns The value as EthAddress, or undefined if coercion fails and assert is not set\n */\nexport function asEthAddress(value: unknown): EthAddress | undefined\nexport function asEthAddress(value: unknown, assert: AssertConfig): EthAddress\nexport function asEthAddress(value: unknown, assert?: AssertConfig): EthAddress | undefined {\n  try {\n    let stringValue: string | undefined\n\n    switch (typeof value) {\n      case 'string': {\n        stringValue = hexFromHexString(value, { prefix: true, byteSize: 4 })\n        break\n      }\n      default: {\n        if (value !== undefined) {\n          return assertError(value, assert, `Unsupported type [${typeof value}]`)\n        }\n      }\n    }\n    return isEthAddress(stringValue) ? stringValue : assertError(value, assert, `Value is not an EthAddress [${value}]`)\n  } catch (ex) {\n    const error = ex as Error\n    return assertError(undefined, assert, error.message)\n  }\n}\n", "import { isHex } from '../hex/index.ts'\nimport type { Hash, HashBitLength } from './hash.ts'\n\n/**\n * Type guard that checks whether a value is a valid hash of the specified bit length.\n * @param value - The value to check\n * @param bitLength - The expected bit length of the hash (defaults to 256)\n * @returns True if the value is a valid Hash\n */\nexport const isHash = (value: unknown, bitLength: HashBitLength = 256): value is Hash => {\n  return isHex(value, { bitLength })\n}\n", "import type { AssertConfig } from '#error'\nimport { assertError } from '#error'\nimport { isUndefined } from '#typeof'\n\nimport { hexFromHexString } from '../hex/index.ts'\nimport { type Hash } from './hash.ts'\nimport { isHash } from './is.ts'\n\n/**\n * Attempts to coerce a value into a Hash type, returning undefined or throwing based on the assert config.\n * @param value - The value to coerce (must be a string)\n * @param assert - If provided, throws on failure instead of returning undefined\n * @returns The value as Hash, or undefined if coercion fails and assert is not set\n */\nexport function asHash(value: unknown): Hash | undefined\nexport function asHash(value: unknown, assert: AssertConfig): Hash\nexport function asHash(value: unknown, assert?: AssertConfig): Hash | undefined {\n  switch (typeof value) {\n    case 'string': {\n      const stringValue = hexFromHexString(value)\n      return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`)\n    }\n    default: {\n      return isUndefined(assert) ? undefined : assertError(value, assert, `Unsupported type [${typeof value}]`)\n    }\n  }\n}\n", "import * as z from 'zod/mini'\n\nimport type { Brand } from '#typeof'\n\nimport type { Hex } from '../hex/index.ts'\nimport { HexRegExMinMax } from '../HexRegEx.ts'\n\n/** The byte length of a standard hash (32 bytes / 256 bits). */\nexport const HASH_LENGTH = 32 as const\n\n/** Regular expression matching a 32-byte (64 hex character) hash string. */\nexport const HashRegEx = HexRegExMinMax(HASH_LENGTH, HASH_LENGTH)\n\n/** A 256-bit zero hash constant. */\nexport const ZERO_HASH = '0000000000000000000000000000000000000000000000000000000000000000' as Hash\n\n/** Valid bit lengths for hash values. */\nexport type HashBitLength = 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096\n/** Array of all valid hash bit lengths for runtime validation. */\nexport const HashBitLength: HashBitLength[] = [32, 64, 128, 256, 512, 1024, 2048, 4096]\n\n/**\n * Type guard that checks whether a value is a valid hash bit length.\n * @param value - The value to check\n * @returns True if the value is one of the supported HashBitLength values\n */\nexport const isHashBitLength = (value: unknown): value is HashBitLength => {\n  return typeof value === 'number' && HashBitLength.includes(value as HashBitLength)\n}\n\n/** Branded type representing a validated hash hex string. */\nexport type BrandedHash = Brand<Hex, { readonly __hash: true }>\n\n/** Zod schema that validates and transforms a string into a branded Hash type. */\nexport const HashZod = z.pipe(\n  z.string().check(z.regex(HashRegEx, { error: 'Invalid hex format' })),\n  z.transform((val: string) => val as BrandedHash),\n)\n\n/** A validated hash string type, inferred from the HashZod schema. */\nexport type Hash = z.infer<typeof HashZod>\n", "import * as z from 'zod/mini'\n\nimport { asHash } from './as.ts'\nimport type { Hash } from './hash.ts'\nimport { HashZod } from './hash.ts'\n\n/** Zod schema that transforms a Hash to a plain string for JSON serialization. */\nexport const HashToJsonZod = z.pipe(HashZod, z.transform((v: Hash): string => v))\n/** Zod schema that parses a JSON string into a validated Hash, throwing on invalid input. */\nexport const JsonToHashZod = z.pipe(z.string(), z.transform((v: string): Hash => asHash(v, true)))\n", "import { type Hex, hexFromHexString } from './hex/index.ts'\n\n/**\n * Converts a Hex string to a BigInt.\n * @param hex - The hex string to convert\n * @returns The BigInt representation of the hex value\n */\nexport function hexToBigInt(hex: Hex): bigint {\n  return BigInt(hexFromHexString(hex, { prefix: true }))\n}\n", "import * as z from 'zod/mini'\n\nimport { toHex } from './hex/index.ts'\nimport { hexToBigInt } from './hexToBigInt.ts'\n\n/** Zod schema that transforms a non-negative BigInt into a hex string for JSON serialization. */\nexport const BigIntToJsonZod = z.pipe(\n  z.bigint().check(z.nonnegative()),\n  z.transform((x: bigint) => toHex(x)),\n)\n/** Zod schema that parses a JSON hex string into a BigInt. */\nexport const JsonToBigIntZod = z.pipe(\n  z.string(),\n  z.transform((x: string) => hexToBigInt(toHex(x))),\n)\n"],
+  "mappings": "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",
+  "names": ["z", "z", "regex", "z", "z", "z", "z", "z"]
+}

package/dist/neutral/hex.model.d.ts

@@ -1 +1,2 @@
-export type * from '../_pkg/hex/neutral/model.ts'
+export type * from './modules/hex/model.js';
+//# sourceMappingURL=hex.model.d.ts.map

package/dist/neutral/hex.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.model.d.ts","sourceRoot":"","sources":["../../src/hex.model.ts"],"names":[],"mappings":"AAAA,mBAAmB,YAAY,CAAA"}

package/dist/neutral/hex.model.mjs

@@ -1 +1 @@
-export * from '../_pkg/hex/neutral/model.mjs'
+//# sourceMappingURL=hex.model.mjs.map

package/dist/neutral/hex.model.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/neutral/index.d.ts

@@ -0,0 +1,31 @@
+export * from './modules/api/index.js';
+export * from './modules/array/index.js';
+export * from './modules/arraybuffer/index.js';
+export * from './modules/assert/index.js';
+export * from './modules/base/index.js';
+export * from './modules/creatable/index.js';
+export * from './modules/decimal-precision/index.js';
+export * from './modules/delay/index.js';
+export * from './modules/ellipsize/index.js';
+export * from './modules/enum/index.js';
+export * from './modules/error/index.js';
+export * from './modules/events/index.js';
+export * from './modules/exists/index.js';
+export * from './modules/fetch/index.js';
+export * from './modules/forget/index.js';
+export * from './modules/function-name/index.js';
+export * from './modules/hex/index.js';
+export * from './modules/logger/index.js';
+export * from './modules/object/index-un-deprecated.js';
+export * from './modules/profile/index.js';
+export * from './modules/promise/index.js';
+export * from './modules/retry/index.js';
+export * from './modules/set/index.js';
+export * from './modules/static-implements/index.js';
+export * from './modules/storage/index.js';
+export * from './modules/telemetry/index.js';
+export * from './modules/telemetry-exporter/index.js';
+export * from './modules/timer/index.js';
+export * from './modules/typeof/index.js';
+export * from './modules/zod/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,MAAM,CAAA;AACpB,cAAc,QAAQ,CAAA;AACtB,cAAc,cAAc,CAAA;AAC5B,cAAc,SAAS,CAAA;AACvB,cAAc,OAAO,CAAA;AACrB,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,QAAQ,CAAA;AACtB,cAAc,YAAY,CAAA;AAC1B,cAAc,OAAO,CAAA;AACrB,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA;AACvB,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA;AACvB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,MAAM,CAAA;AACpB,cAAc,SAAS,CAAA;AACvB,cAAc,6BAA6B,CAAA;AAC3C,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,QAAQ,CAAA;AACtB,cAAc,MAAM,CAAA;AACpB,cAAc,oBAAoB,CAAA;AAClC,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,qBAAqB,CAAA;AACnC,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA;AACvB,cAAc,MAAM,CAAA"}