@xylabs/hex 5.0.57 → 5.0.59

package/dist/neutral/address/AddressTransformZod.d.ts

@@ -1,5 +1,8 @@
-import { z } from 'zod';
-import { type Address } from './address.ts';
-export declare const AddressTransformZod: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodBigInt, z.ZodNumber]>, z.ZodTransform<string, string | number | bigint>>, z.ZodTransform<Address, string>>;
+import * as z from 'zod';
+export declare const AddressTransformZod: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodBigInt, z.ZodNumber]>, z.ZodTransform<string, string | number | bigint>>, z.ZodTransform<Lowercase<string> & {
+    readonly __hex: true;
+} & {
+    readonly __address: true;
+}, string>>;
 export type AddressTransformZodType = z.infer<typeof AddressTransformZod>;
 //# sourceMappingURL=AddressTransformZod.d.ts.map

package/dist/neutral/address/AddressTransformZod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AddressTransformZod.d.ts","sourceRoot":"","sources":["../../../src/address/AddressTransformZod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,KAAK,OAAO,EAAkB,MAAM,cAAc,CAAA;AAG3D,eAAO,MAAM,mBAAmB,uKAkBD,CAAA;AAE/B,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}
+{"version":3,"file":"AddressTransformZod.d.ts","sourceRoot":"","sources":["../../../src/address/AddressTransformZod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAKxB,eAAO,MAAM,mBAAmB;;;;WAkBD,CAAA;AAE/B,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/neutral/address/AddressValidationZod.d.ts

@@ -1,5 +1,8 @@
-import { z } from 'zod';
-import type { Address } from './address.ts';
-export declare const AddressValidationZod: z.ZodPipe<z.ZodString, z.ZodTransform<Address, string>>;
+import * as z from 'zod';
+export declare const AddressValidationZod: z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+    readonly __hex: true;
+} & {
+    readonly __address: true;
+}, string>>;
 export type AddressValidationZodType = z.infer<typeof AddressValidationZod>;
 //# sourceMappingURL=AddressValidationZod.d.ts.map

package/dist/neutral/address/AddressValidationZod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AddressValidationZod.d.ts","sourceRoot":"","sources":["../../../src/address/AddressValidationZod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C,eAAO,MAAM,oBAAoB,yDAGF,CAAA;AAE/B,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}
+{"version":3,"file":"AddressValidationZod.d.ts","sourceRoot":"","sources":["../../../src/address/AddressValidationZod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,oBAAoB;;;;WAGF,CAAA;AAE/B,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/neutral/address/address.d.ts

@@ -1,11 +1,13 @@
 import type { Brand } from '@xylabs/typeof';
+import * as z from 'zod';
 import { type Hex } from '../hex/index.ts';
 export declare const ZERO_ADDRESS: Address;
 export declare const ADDRESS_LENGTH: 40;
 export declare const AddressRegEx: RegExp;
-export type Address = Brand<Hex, {
+type BrandedAddress = Brand<Hex, {
     readonly __address: true;
 }>;
-export declare const UnTypedAddressZod: import("zod").ZodString;
-export declare const AddressZod: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<Address, string>>;
+export declare const AddressZod: z.ZodPipe<z.ZodString, z.ZodTransform<BrandedAddress, string>>;
+export type Address = z.infer<typeof AddressZod>;
+export {};
 //# sourceMappingURL=address.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../../src/address/address.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAE3C,OAAO,EAAE,KAAK,GAAG,EAAiB,MAAM,iBAAiB,CAAA;AAGzD,eAAO,MAAM,YAAY,EAAiD,OAAO,CAAA;AACjF,eAAO,MAAM,cAAc,EAAG,EAAW,CAAA;AAEzC,eAAO,MAAM,YAAY,QAAyD,CAAA;AAElF,MAAM,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAE9D,eAAO,MAAM,iBAAiB,yBAAoC,CAAA;AAClE,eAAO,MAAM,UAAU,6FAA0D,CAAA"}
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../../src/address/address.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,iBAAiB,CAAA;AAG1C,eAAO,MAAM,YAAY,EAAiD,OAAO,CAAA;AACjF,eAAO,MAAM,cAAc,EAAG,EAAW,CAAA;AAEzC,eAAO,MAAM,YAAY,QAAyD,CAAA;AAElF,KAAK,cAAc,GAAG,KAAK,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAE9D,eAAO,MAAM,UAAU,gEAAqF,CAAA;AAE5G,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/dist/neutral/address/addressDeprecated.d.ts

@@ -1,10 +1,18 @@
-import { z } from 'zod';
+import * as z from 'zod';
 /** @deprecated use AddressZod */
 export declare const AddressToStringZod: z.ZodString;
 /** @deprecated use AddressZod */
 export declare const AddressToStringSchema: z.ZodString;
 /** @deprecated use AddressZod */
-export declare const AddressFromStringZod: z.ZodPipe<z.ZodString, z.ZodTransform<import("./address.ts").Address, string>>;
+export declare const AddressFromStringZod: z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+    readonly __hex: true;
+} & {
+    readonly __address: true;
+}, string>>;
 /** @deprecated use AddressZod */
-export declare const AddressFromStringSchema: z.ZodPipe<z.ZodString, z.ZodTransform<import("./address.ts").Address, string>>;
+export declare const AddressFromStringSchema: z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+    readonly __hex: true;
+} & {
+    readonly __address: true;
+}, string>>;
 //# sourceMappingURL=addressDeprecated.d.ts.map

package/dist/neutral/address/addressDeprecated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addressDeprecated.d.ts","sourceRoot":"","sources":["../../../src/address/addressDeprecated.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,iCAAiC;AACjC,eAAO,MAAM,kBAAkB,aAAiC,CAAA;AAEhE,iCAAiC;AAEjC,eAAO,MAAM,qBAAqB,aAAqB,CAAA;AAEvD,iCAAiC;AACjC,eAAO,MAAM,oBAAoB,gFAA4E,CAAA;AAE7G,iCAAiC;AAEjC,eAAO,MAAM,uBAAuB,gFAAuB,CAAA"}
+{"version":3,"file":"addressDeprecated.d.ts","sourceRoot":"","sources":["../../../src/address/addressDeprecated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAKxB,iCAAiC;AACjC,eAAO,MAAM,kBAAkB,aAAiC,CAAA;AAEhE,iCAAiC;AAEjC,eAAO,MAAM,qBAAqB,aAAqB,CAAA;AAEvD,iCAAiC;AACjC,eAAO,MAAM,oBAAoB;;;;WAA4E,CAAA;AAE7G,iCAAiC;AAEjC,eAAO,MAAM,uBAAuB;;;;WAAuB,CAAA"}

package/dist/neutral/ethAddress.d.ts

@@ -1,6 +1,6 @@
 import type { AssertConfig } from '@xylabs/error';
 import type { Brand } from '@xylabs/typeof';
-import { z } from 'zod';
+import * as z from 'zod';
 import type { HexConfig } from './hex/index.ts';
 export declare const EthAddressRegEx: RegExp;
 export declare const EthAddressToStringZod: z.ZodString;

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

@@ -1 +1 @@
-{"version":3,"file":"ethAddress.d.ts","sourceRoot":"","sources":["../../src/ethAddress.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAM/C,eAAO,MAAM,eAAe,QAA4C,CAAA;AAExE,eAAO,MAAM,qBAAqB,aAAoC,CAAA;AAEtE,4CAA4C;AAC5C,eAAO,MAAM,wBAAwB,aAAwB,CAAA;AAE7D,eAAO,MAAM,uBAAuB,4DAAoE,CAAA;AAExG,8CAA8C;AAC9C,eAAO,MAAM,0BAA0B,4DAA0B,CAAA;AAGjE,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAExE,eAAO,MAAM,gBAAgB,EAAmD,UAAU,CAAA;AAE1F,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,eAAe,EAAE,SAAQ,SAAc,KAAG,UAKxG,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,EAAE,SAAQ,SAAc,KAAG,KAAK,IAAI,UAI9E,CAAA;AAED,eAAO,MAAM,aAAa,aAIvB,CAAA;AAEH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAAA;AACpE,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,UAAU,CAAA"}
+{"version":3,"file":"ethAddress.d.ts","sourceRoot":"","sources":["../../src/ethAddress.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAM/C,eAAO,MAAM,eAAe,QAA4C,CAAA;AAExE,eAAO,MAAM,qBAAqB,aAAoC,CAAA;AAEtE,4CAA4C;AAC5C,eAAO,MAAM,wBAAwB,aAAwB,CAAA;AAE7D,eAAO,MAAM,uBAAuB,4DAAoE,CAAA;AAExG,8CAA8C;AAC9C,eAAO,MAAM,0BAA0B,4DAA0B,CAAA;AAGjE,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAExE,eAAO,MAAM,gBAAgB,EAAmD,UAAU,CAAA;AAE1F,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,eAAe,EAAE,SAAQ,SAAc,KAAG,UAKxG,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,EAAE,SAAQ,SAAc,KAAG,KAAK,IAAI,UAI9E,CAAA;AAED,eAAO,MAAM,aAAa,aAIvB,CAAA;AAEH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAAA;AACpE,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,UAAU,CAAA"}

package/dist/neutral/hash/hash.d.ts

@@ -1,5 +1,5 @@
 import type { Brand } from '@xylabs/typeof';
-import { z } from 'zod';
+import * as z from 'zod';
 import type { Hex } from '../hex/index.ts';
 export declare const HASH_LENGTH: 32;
 export declare const HashRegEx: RegExp;
@@ -7,8 +7,9 @@ export declare const ZERO_HASH: Hash;
 export type HashBitLength = 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096;
 export declare const HashBitLength: HashBitLength[];
 export declare const isHashBitLength: (value: unknown) => value is HashBitLength;
-export type Hash = Brand<Hex, {
+export type BrandedHash = Brand<Hex, {
     readonly __hash: true;
 }>;
-export declare const HashZod: z.ZodPipe<z.ZodString, z.ZodTransform<Hash, string>>;
+export declare const HashZod: z.ZodPipe<z.ZodString, z.ZodTransform<BrandedHash, string>>;
+export type Hash = z.infer<typeof HashZod>;
 //# sourceMappingURL=hash.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../src/hash/hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAA;AAG1C,eAAO,MAAM,WAAW,EAAG,EAAW,CAAA;AAEtC,eAAO,MAAM,SAAS,QAA2C,CAAA;AAEjE,eAAO,MAAM,SAAS,EAAyE,IAAI,CAAA;AAEnG,MAAM,MAAM,aAAa,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAC1E,eAAO,MAAM,aAAa,EAAE,aAAa,EAA8C,CAAA;AAEvF,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,aAEzD,CAAA;AAED,MAAM,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAExD,eAAO,MAAM,OAAO,sDACgE,CAAA"}
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../src/hash/hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAA;AAG1C,eAAO,MAAM,WAAW,EAAG,EAAW,CAAA;AAEtC,eAAO,MAAM,SAAS,QAA2C,CAAA;AAEjE,eAAO,MAAM,SAAS,EAAyE,IAAI,CAAA;AAEnG,MAAM,MAAM,aAAa,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAC1E,eAAO,MAAM,aAAa,EAAE,aAAa,EAA8C,CAAA;AAEvF,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,aAEzD,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAE/D,eAAO,MAAM,OAAO,6DACuE,CAAA;AAE3F,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAA"}

package/dist/neutral/hash/zod.d.ts

@@ -1,5 +1,4 @@
-import { z } from 'zod';
-import type { Hash } from './hash.ts';
-export declare const HashToJsonZod: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<Hash, string>>, z.ZodTransform<string, Hash>>;
-export declare const JsonToHashZod: z.ZodPipe<z.ZodString, z.ZodTransform<Hash, string>>;
+import * as z from 'zod';
+export declare const HashToJsonZod: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("./hash.ts").BrandedHash, string>>, z.ZodTransform<string, import("./hash.ts").BrandedHash>>;
+export declare const JsonToHashZod: z.ZodPipe<z.ZodString, z.ZodTransform<import("./hash.ts").BrandedHash, string>>;
 //# sourceMappingURL=zod.d.ts.map

package/dist/neutral/hash/zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../../src/hash/zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAGrC,eAAO,MAAM,aAAa,+FAAoC,CAAA;AAC9D,eAAO,MAAM,aAAa,sDAAmD,CAAA"}
+{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../../src/hash/zod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,aAAa,qJAAoC,CAAA;AAC9D,eAAO,MAAM,aAAa,iFAAmD,CAAA"}

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

@@ -1,14 +1,14 @@
 import type { Brand } from '@xylabs/typeof';
-import { z } from 'zod';
-export type Hex = Brand<Lowercase<string>, {
+import * as z from 'zod';
+export type BrandedHex = Brand<Lowercase<string>, {
     readonly __hex: true;
 }>;
-export declare const UntypedHexZod: z.ZodString;
-export declare const HexZod: z.ZodPipe<z.ZodString, z.ZodTransform<Hex, string>>;
+export declare const HexZod: z.ZodPipe<z.ZodString, z.ZodTransform<BrandedHex, string>>;
 /** Configuration of validation and output format */
 export interface HexConfig {
     bitLength?: number;
     byteSize?: number;
     prefix?: boolean;
 }
+export type Hex = z.infer<typeof HexZod>;
 //# sourceMappingURL=hex.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hex.d.ts","sourceRoot":"","sources":["../../../src/hex/hex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,MAAM,MAAM,GAAG,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAEpE,eAAO,MAAM,aAAa,aAC2B,CAAA;AAErD,eAAO,MAAM,MAAM,qDAA6C,CAAA;AAEhE,oDAAoD;AACpD,MAAM,WAAW,SAAS;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB"}
+{"version":3,"file":"hex.d.ts","sourceRoot":"","sources":["../../../src/hex/hex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAE3E,eAAO,MAAM,MAAM,4DAAoG,CAAA;AAEvH,oDAAoD;AACpD,MAAM,WAAW,SAAS;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAA"}

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

@@ -4,5 +4,5 @@ export declare const toHex: (
 /** Supported types are string, number, bigint, and ArrayBuffer */
 value: string | number | bigint | ArrayBufferLike, 
 /** Configuration of output format and validation */
-config?: HexConfig) => import("./hex.ts").Hex;
+config?: HexConfig) => import("./hex.ts").BrandedHex;
 //# sourceMappingURL=to.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"to.d.ts","sourceRoot":"","sources":["../../../src/hex/to.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC,uEAAuE;AACvE,eAAO,MAAM,KAAK;AAChB,kEAAkE;AAClE,OAAO,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,eAAe;AACjD,oDAAoD;AACpD,SAAQ,SAAc,2BAIvB,CAAA"}
+{"version":3,"file":"to.d.ts","sourceRoot":"","sources":["../../../src/hex/to.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC,uEAAuE;AACvE,eAAO,MAAM,KAAK;AAChB,kEAAkE;AAClE,OAAO,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,eAAe;AACjD,oDAAoD;AACpD,SAAQ,SAAc,kCAIvB,CAAA"}

package/dist/neutral/index.mjs

@@ -1,8 +1,5 @@
-// src/hex/as.ts
-import { assertError } from "@xylabs/error";
-
-// src/hex/from/fromHexString.ts
-import { isNumber } from "@xylabs/typeof";
+// src/address/address.ts
+import * as z from "zod";
 
 // src/HexRegEx.ts
 var HexRegExMinMax = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
@@ -14,6 +11,21 @@ var HexRegExMinMaxMixedCaseWithPrefix = (minBytes = 0, maxBytes = Number.MAX_SAF
 var HexRegEx = /^[0-9a-f]+$/;
 var HexRegExWithPrefix = /^0x[0-9a-f]+$/;
 
+// src/address/address.ts
+var ZERO_ADDRESS = "0000000000000000000000000000000000000000";
+var ADDRESS_LENGTH = 40;
+var AddressRegEx = HexRegExMinMax(ADDRESS_LENGTH / 2, ADDRESS_LENGTH / 2);
+var AddressZod = z.string().regex(AddressRegEx).transform((v) => v);
+
+// src/address/addressDeprecated.ts
+import * as z5 from "zod";
+
+// src/hex/as.ts
+import { assertError } from "@xylabs/error";
+
+// src/hex/from/fromHexString.ts
+import { isNumber } from "@xylabs/typeof";
+
 // src/hex/nibble.ts
 var bitsToNibbles = (value) => {
   const nibbles = value >> 2;
@@ -104,9 +116,8 @@ function asHex(value, assert) {
 }
 
 // src/hex/hex.ts
-import { z } from "zod";
-var UntypedHexZod = z.string().regex(HexRegEx, { message: "Invalid hex format" });
-var HexZod = UntypedHexZod.transform((val) => val);
+import * as z2 from "zod";
+var HexZod = z2.string().regex(HexRegEx, { message: "Invalid hex format" }).transform((val) => val);
 
 // src/hex/isHexZero.ts
 import { isString } from "@xylabs/typeof";
@@ -125,25 +136,15 @@ var toHex = (value, config = {}) => {
   return hexFrom(value, { prefix, ...config });
 };
 
-// src/address/address.ts
-var ZERO_ADDRESS = "0000000000000000000000000000000000000000";
-var ADDRESS_LENGTH = 40;
-var AddressRegEx = HexRegExMinMax(ADDRESS_LENGTH / 2, ADDRESS_LENGTH / 2);
-var UnTypedAddressZod = UntypedHexZod.regex(AddressRegEx);
-var AddressZod = UnTypedAddressZod.transform((v) => v);
-
-// src/address/addressDeprecated.ts
-import { z as z4 } from "zod";
-
 // src/address/AddressTransformZod.ts
-import { z as z3 } from "zod";
+import * as z4 from "zod";
 
 // src/address/AddressValidationZod.ts
-import { z as z2 } from "zod";
-var AddressValidationZod = z2.string().refine((x) => HexZod.safeParse(x)).refine((x) => x.length === ADDRESS_LENGTH, { error: (e) => new Error(`Address must have 40 characters [${e.input}]`) }).transform((v) => v);
+import * as z3 from "zod";
+var AddressValidationZod = z3.string().refine((x) => HexZod.safeParse(x)).refine((x) => x.length === ADDRESS_LENGTH, { error: (e) => new Error(`Address must have 40 characters [${e.input}]`) }).transform((v) => v);
 
 // src/address/AddressTransformZod.ts
-var AddressTransformZod = z3.union([z3.string(), z3.bigint(), z3.number()]).transform((value) => {
+var AddressTransformZod = z4.union([z4.string(), z4.bigint(), z4.number()]).transform((value) => {
   switch (typeof value) {
     case "bigint": {
       return value.toString(16).padStart(ADDRESS_LENGTH, "0");
@@ -174,9 +175,9 @@ function toAddressV2(value, assert = false) {
 }
 
 // src/address/addressDeprecated.ts
-var AddressToStringZod = z4.string().regex(AddressRegEx);
+var AddressToStringZod = z5.string().regex(AddressRegEx);
 var AddressToStringSchema = AddressToStringZod;
-var AddressFromStringZod = z4.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
+var AddressFromStringZod = z5.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
 var AddressFromStringSchema = AddressFromStringZod;
 
 // src/address/as.ts
@@ -217,11 +218,11 @@ function asAddressV2(value, assert = false) {
 
 // src/ethAddress.ts
 import { assertError as assertError3 } from "@xylabs/error";
-import { z as z5 } from "zod";
+import * as z6 from "zod";
 var EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20);
-var EthAddressToStringZod = z5.string().regex(EthAddressRegEx);
+var EthAddressToStringZod = z6.string().regex(EthAddressRegEx);
 var EthAddressToStringSchema = EthAddressToStringZod;
-var EthAddressFromStringZod = z5.string().regex(EthAddressRegEx).transform((v) => toEthAddress(v));
+var EthAddressFromStringZod = z6.string().regex(EthAddressRegEx).transform((v) => toEthAddress(v));
 var EthAddressFromStringSchema = EthAddressFromStringZod;
 var ETH_ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 var toEthAddress = (value, config = {}) => {
@@ -237,7 +238,7 @@ var isEthAddress = (value, config = {}) => {
   const loweredValue = typeof value === "string" ? value.toLowerCase() : value;
   return isHex(loweredValue, { bitLength, prefix });
 };
-var EthAddressZod = z5.string().regex(EthAddressRegEx, { message: "Invalid address format" }).refine(
+var EthAddressZod = z6.string().regex(EthAddressRegEx, { message: "Invalid address format" }).refine(
   isEthAddress
 );
 function asEthAddress(value, assert) {
@@ -286,7 +287,7 @@ function asHash(value, assert) {
 }
 
 // src/hash/hash.ts
-import { z as z6 } from "zod";
+import * as z7 from "zod";
 var HASH_LENGTH = 32;
 var HashRegEx = HexRegExMinMax(HASH_LENGTH, HASH_LENGTH);
 var ZERO_HASH = "0000000000000000000000000000000000000000000000000000000000000000";
@@ -294,12 +295,12 @@ var HashBitLength = [32, 64, 128, 256, 512, 1024, 2048, 4096];
 var isHashBitLength = (value) => {
   return typeof value === "number" && HashBitLength.includes(value);
 };
-var HashZod = z6.string().regex(HashRegEx, { message: "Invalid hex format" }).transform((val) => val);
+var HashZod = z7.string().regex(HashRegEx, { message: "Invalid hex format" }).transform((val) => val);
 
 // src/hash/zod.ts
-import { z as z7 } from "zod";
+import * as z8 from "zod";
 var HashToJsonZod = HashZod.transform((v) => v);
-var JsonToHashZod = z7.string().transform((v) => asHash(v, true));
+var JsonToHashZod = z8.string().transform((v) => asHash(v, true));
 
 // src/hexToBigInt.ts
 function hexToBigInt(hex) {
@@ -307,9 +308,9 @@ function hexToBigInt(hex) {
 }
 
 // src/zod.ts
-import { z as z8 } from "zod";
-var BigIntToJsonZod = z8.bigint().nonnegative().transform((x) => toHex(x));
-var JsonToBigIntZod = z8.string().transform((x) => toHex(x)).transform((x) => hexToBigInt(x));
+import * as z9 from "zod";
+var BigIntToJsonZod = z9.bigint().nonnegative().transform((x) => toHex(x));
+var JsonToBigIntZod = z9.string().transform((x) => toHex(x)).transform((x) => hexToBigInt(x));
 export {
   ADDRESS_LENGTH,
   AddressFromStringSchema,
@@ -340,8 +341,6 @@ export {
   HexZod,
   JsonToBigIntZod,
   JsonToHashZod,
-  UnTypedAddressZod,
-  UntypedHexZod,
   ZERO_ADDRESS,
   ZERO_HASH,
   asAddress,

package/dist/neutral/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/hex/as.ts","../../src/hex/from/fromHexString.ts","../../src/HexRegEx.ts","../../src/hex/nibble.ts","../../src/hex/is.ts","../../src/hex/from/fromArrayBuffer.ts","../../src/hex/from/fromBigInt.ts","../../src/hex/from/fromNumber.ts","../../src/hex/from/from.ts","../../src/hex/hex.ts","../../src/hex/isHexZero.ts","../../src/hex/legacy.ts","../../src/hex/to.ts","../../src/address/address.ts","../../src/address/addressDeprecated.ts","../../src/address/AddressTransformZod.ts","../../src/address/AddressValidationZod.ts","../../src/address/to.ts","../../src/address/as.ts","../../src/address/is.ts","../../src/ethAddress.ts","../../src/hash/as.ts","../../src/hash/is.ts","../../src/hash/hash.ts","../../src/hash/zod.ts","../../src/hexToBigInt.ts","../../src/zod.ts"],"sourcesContent":["import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\n\nimport { hexFromHexString } from './from/index.ts'\nimport type { Hex } from './hex.ts'\nimport { isHex } from './is.ts'\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  let stringValue: string | undefined = undefined\n\n  switch (typeof value) {\n    case 'string': {\n      stringValue = hexFromHexString(value)\n      break\n    }\n    default: {\n      return assertError(value, assert, `Unsupported type [${typeof value}]`)\n    }\n  }\n\n  return isHex(stringValue) ? stringValue : assertError(value, assert, `Value is not Hex [${value}]`)\n}\n","import { isNumber } from '@xylabs/typeof'\n\nimport type { Hex, HexConfig } from '../hex.ts'\nimport { isHex } from '../is.ts'\nimport { bitsToNibbles } from '../nibble.ts'\n\nexport const hexFromHexString = (value: string, config: HexConfig = {}): Hex => {\n  const {\n    prefix = 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(unEvened.length + (unEvened.length % nibbleBoundary), '0')\n    const padded = isNumber(bitLength) ? evenCharacters.padStart(bitLength / 4, '0') : evenCharacters\n    return (prefix ? `0x${padded}` : padded).toLowerCase() as Hex\n  } else {\n    throw new Error('Received string is not a value hex')\n  }\n}\n","export const HexRegExMinMax = (minBytes = 0, maxBytes: number = (Number.MAX_SAFE_INTEGER / 2)) => {\n  return new RegExp(`^[a-f0-9]{${minBytes * 2},${maxBytes * 2}}$`)\n}\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\nexport const HexRegEx = /^[0-9a-f]+$/\nexport const HexRegExWithPrefix = /^0x[0-9a-f]+$/\n","// determine the number of nibbles for a given number of bits\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// determine the number of nibbles for a given number of bits\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\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 = config?.prefix ? value.length - 2 : value.length\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  return config?.prefix ? HexRegExWithPrefix.test(value) : HexRegEx.test(value)\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\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 { Brand } from '@xylabs/typeof'\nimport { z } from 'zod'\n\nimport { HexRegEx } from '../HexRegEx.ts'\n\nexport type Hex = Brand<Lowercase<string>, { readonly __hex: true }>\n\nexport const UntypedHexZod = z.string()\n  .regex(HexRegEx, { message: 'Invalid hex format' })\n\nexport const HexZod = UntypedHexZod.transform(val => val as Hex)\n\n/** Configuration of validation and output format */\nexport interface HexConfig {\n  bitLength?: number\n  byteSize?: number\n  prefix?: boolean\n}\n","import { isString } from '@xylabs/typeof'\n\nimport { hexFromHexString } from './from/index.ts'\n\nexport const isHexZero = (value?: string) => {\n  return isString(value) ? BigInt(hexFromHexString(value, { prefix: true })) === 0n : undefined\n}\n","export 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 = false } = config\n  return hexFrom(value, { prefix, ...config })\n}\n","import type { Brand } from '@xylabs/typeof'\n\nimport { type Hex, UntypedHexZod } from '../hex/index.ts'\nimport { HexRegExMinMax } from '../HexRegEx.ts'\n\nexport const ZERO_ADDRESS = '0000000000000000000000000000000000000000' as Address\nexport const ADDRESS_LENGTH = 40 as const\n\nexport const AddressRegEx = HexRegExMinMax(ADDRESS_LENGTH / 2, ADDRESS_LENGTH / 2)\n\nexport type Address = Brand<Hex, { readonly __address: true }>\n\nexport const UnTypedAddressZod = UntypedHexZod.regex(AddressRegEx)\nexport const AddressZod = UnTypedAddressZod.transform<Address>(v => v as Address)\n","import { z } from 'zod'\n\nimport { AddressRegEx } from './address.ts'\nimport { toAddress } from './to.ts'\n\n/** @deprecated use AddressZod */\nexport const AddressToStringZod = z.string().regex(AddressRegEx)\n\n/** @deprecated use AddressZod */\n// eslint-disable-next-line sonarjs/deprecation\nexport const AddressToStringSchema = AddressToStringZod\n\n/** @deprecated use AddressZod */\nexport const AddressFromStringZod = z.string().toLowerCase().regex(AddressRegEx).transform(v => toAddress(v))\n\n/** @deprecated use AddressZod */\n// eslint-disable-next-line sonarjs/deprecation\nexport const AddressFromStringSchema = AddressFromStringZod\n","import { z } from 'zod'\n\nimport { type Address, ADDRESS_LENGTH } from './address.ts'\nimport { AddressValidationZod } from './AddressValidationZod.ts'\n\nexport const AddressTransformZod = z.union([z.string(), z.bigint(), z.number()])\n  .transform((value) => {\n    switch (typeof value) {\n      case 'bigint': {\n        return value.toString(16).padStart(ADDRESS_LENGTH, '0')\n      }\n      case 'string': {\n        if (value.startsWith('0x')) {\n          return value.slice(2)\n        }\n        return value\n      }\n      case 'number': {\n        return BigInt(value).toString(16).padStart(ADDRESS_LENGTH, '0')\n      }\n    }\n  })\n  .refine(x => AddressValidationZod.safeParse(x).data)\n  .transform(x => x as Address)\n\nexport type AddressTransformZodType = z.infer<typeof AddressTransformZod>\n","import { z } from 'zod'\n\nimport { HexZod } from '../hex/index.ts'\nimport type { Address } from './address.ts'\nimport { ADDRESS_LENGTH } from './address.ts'\n\nexport const AddressValidationZod = z.string()\n  .refine(x => HexZod.safeParse(x))\n  .refine(x => x.length === ADDRESS_LENGTH, { error: e => new Error(`Address must have 40 characters [${e.input}]`) })\n  .transform(v => v as Address)\n\nexport type AddressValidationZodType = z.infer<typeof AddressValidationZod>\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\nexport const toAddress = (value: string | number | bigint | ArrayBufferLike, config: HexConfig = {}): Address => {\n  const { bitLength = 160, prefix = false } = config\n  return hexFrom(value, {\n    bitLength, prefix, ...config,\n  }) as unknown as Address\n}\n\n/** @alpha */\nexport function toAddressV2(value: unknown, assert: boolean = false): Address | undefined {\n  return assert\n    ? AddressTransformZod.parse(value)\n    : AddressTransformZod.safeParse(value).data\n}\n","import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport { isObject } from '@xylabs/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\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 = undefined\n\n    switch (typeof value) {\n      case 'string': {\n        stringValue = hexFromHexString(value, { prefix: false })\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: boolean = 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 { isHex } from '../hex/index.ts'\nimport type { Address } from './address.ts'\nimport { AddressValidationZod } from './AddressValidationZod.ts'\n\nexport const isAddress = (value: unknown, config: HexConfig = {}): value is Address => {\n  const { bitLength = 160, prefix = false } = config\n  return isHex(value, { bitLength, prefix })\n}\n\n/** @alpha */\nexport function isAddressV2(value: unknown): value is Address {\n  return AddressValidationZod.safeParse(value).success\n}\n","import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport type { Brand } from '@xylabs/typeof'\nimport { z } from 'zod'\n\nimport type { HexConfig } from './hex/index.ts'\nimport {\n  hexFrom, hexFromHexString, isHex,\n} from './hex/index.ts'\nimport { HexRegExMinMaxMixedCaseWithPrefix } from './HexRegEx.ts'\n\nexport const EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20)\n\nexport const EthAddressToStringZod = z.string().regex(EthAddressRegEx)\n\n/** @deprecated use EthAddressToStringZod */\nexport const EthAddressToStringSchema = EthAddressToStringZod\n\nexport const EthAddressFromStringZod = z.string().regex(EthAddressRegEx).transform(v => toEthAddress(v))\n\n/** @deprecated use EthAddressFromStringZod */\nexport const EthAddressFromStringSchema = EthAddressFromStringZod\n\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\nexport const ETH_ZERO_ADDRESS = '0x0000000000000000000000000000000000000000' as EthAddress\n\nexport const toEthAddress = (value: string | number | bigint | ArrayBufferLike, config: HexConfig = {}): EthAddress => {\n  const { bitLength = 160, prefix = false } = config\n  return `0x${hexFrom(value, {\n    bitLength, prefix, ...config,\n  })}` as EthAddress\n}\n\nexport const isEthAddress = (value: unknown, config: HexConfig = {}): value is EthAddress => {\n  const { bitLength = 160, prefix = true } = config\n  const loweredValue = typeof value === 'string' ? value.toLowerCase() : value\n  return isHex(loweredValue, { bitLength, prefix })\n}\n\nexport const EthAddressZod = z.string()\n  .regex(EthAddressRegEx, { message: 'Invalid address format' })\n  .refine(\n    isEthAddress,\n  )\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 = 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 type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport { isUndefined } from '@xylabs/typeof'\n\nimport { hexFromHexString } from '../hex/index.ts'\nimport { type Hash } from './hash.ts'\nimport { isHash } from './is.ts'\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  let stringValue: string | undefined = undefined\n\n  switch (typeof value) {\n    case 'string': {\n      stringValue = hexFromHexString(value)\n      break\n    }\n    default: {\n      return isUndefined(assert) ? undefined : assertError(value, assert, `Unsupported type [${typeof value}]`)\n    }\n  }\n  return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`)\n}\n","import { isHex } from '../hex/index.ts'\nimport type { Hash, HashBitLength } from './hash.ts'\n\nexport const isHash = (value: unknown, bitLength: HashBitLength = 256): value is Hash => {\n  return isHex(value, { bitLength })\n}\n","import type { Brand } from '@xylabs/typeof'\nimport { z } from 'zod'\n\nimport type { Hex } from '../hex/index.ts'\nimport { HexRegExMinMax } from '../HexRegEx.ts'\n\nexport const HASH_LENGTH = 32 as const\n\nexport const HashRegEx = HexRegExMinMax(HASH_LENGTH, HASH_LENGTH)\n\nexport const ZERO_HASH = '0000000000000000000000000000000000000000000000000000000000000000' as Hash\n\nexport type HashBitLength = 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096\nexport const HashBitLength: HashBitLength[] = [32, 64, 128, 256, 512, 1024, 2048, 4096]\n\nexport const isHashBitLength = (value: unknown): value is HashBitLength => {\n  return typeof value === 'number' && HashBitLength.includes(value as HashBitLength)\n}\n\nexport type Hash = Brand<Hex, { readonly __hash: true }>\n\nexport const HashZod = z.string()\n  .regex(HashRegEx, { message: 'Invalid hex format' }).transform(val => val as Hash)\n","import { z } from 'zod'\n\nimport { asHash } from './as.ts'\nimport type { Hash } from './hash.ts'\nimport { HashZod } from './hash.ts'\n\nexport const HashToJsonZod = HashZod.transform<string>(v => v)\nexport const JsonToHashZod = z.string().transform<Hash>(v => asHash(v, true))\n","import { type Hex, hexFromHexString } from './hex/index.ts'\n\nexport function hexToBigInt(hex: Hex): bigint {\n  return BigInt(hexFromHexString(hex, { prefix: true }))\n}\n","import { z } from 'zod'\n\nimport { toHex } from './hex/index.ts'\nimport { hexToBigInt } from './hexToBigInt.ts'\n\nexport const BigIntToJsonZod = z.bigint().nonnegative().transform(x => toHex(x))\nexport const JsonToBigIntZod = z.string().transform(x => toHex(x)).transform(x => hexToBigInt(x))\n"],"mappings":"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","names":["z","z","z","z","z","z","assertError","assertError","assertError","z","z","assertError","assertError","assertError","z","z","z","z","z","z"]}
+{"version":3,"sources":["../../src/address/address.ts","../../src/HexRegEx.ts","../../src/address/addressDeprecated.ts","../../src/hex/as.ts","../../src/hex/from/fromHexString.ts","../../src/hex/nibble.ts","../../src/hex/is.ts","../../src/hex/from/fromArrayBuffer.ts","../../src/hex/from/fromBigInt.ts","../../src/hex/from/fromNumber.ts","../../src/hex/from/from.ts","../../src/hex/hex.ts","../../src/hex/isHexZero.ts","../../src/hex/legacy.ts","../../src/hex/to.ts","../../src/address/AddressTransformZod.ts","../../src/address/AddressValidationZod.ts","../../src/address/to.ts","../../src/address/as.ts","../../src/address/is.ts","../../src/ethAddress.ts","../../src/hash/as.ts","../../src/hash/is.ts","../../src/hash/hash.ts","../../src/hash/zod.ts","../../src/hexToBigInt.ts","../../src/zod.ts"],"sourcesContent":["import type { Brand } from '@xylabs/typeof'\nimport * as z from 'zod'\n\nimport { type Hex } from '../hex/index.ts'\nimport { HexRegExMinMax } from '../HexRegEx.ts'\n\nexport const ZERO_ADDRESS = '0000000000000000000000000000000000000000' as Address\nexport const ADDRESS_LENGTH = 40 as const\n\nexport const AddressRegEx = HexRegExMinMax(ADDRESS_LENGTH / 2, ADDRESS_LENGTH / 2)\n\ntype BrandedAddress = Brand<Hex, { readonly __address: true }>\n\nexport const AddressZod = z.string().regex(AddressRegEx).transform<BrandedAddress>(v => v as BrandedAddress)\n\nexport type Address = z.infer<typeof AddressZod>\n","export const HexRegExMinMax = (minBytes = 0, maxBytes: number = (Number.MAX_SAFE_INTEGER / 2)) => {\n  return new RegExp(`^[a-f0-9]{${minBytes * 2},${maxBytes * 2}}$`)\n}\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\nexport const HexRegEx = /^[0-9a-f]+$/\nexport const HexRegExWithPrefix = /^0x[0-9a-f]+$/\n","import * as z from 'zod'\n\nimport { AddressRegEx } from './address.ts'\nimport { toAddress } from './to.ts'\n\n/** @deprecated use AddressZod */\nexport const AddressToStringZod = z.string().regex(AddressRegEx)\n\n/** @deprecated use AddressZod */\n// eslint-disable-next-line sonarjs/deprecation\nexport const AddressToStringSchema = AddressToStringZod\n\n/** @deprecated use AddressZod */\nexport const AddressFromStringZod = z.string().toLowerCase().regex(AddressRegEx).transform(v => toAddress(v))\n\n/** @deprecated use AddressZod */\n// eslint-disable-next-line sonarjs/deprecation\nexport const AddressFromStringSchema = AddressFromStringZod\n","import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\n\nimport { hexFromHexString } from './from/index.ts'\nimport type { Hex } from './hex.ts'\nimport { isHex } from './is.ts'\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  let stringValue: string | undefined = undefined\n\n  switch (typeof value) {\n    case 'string': {\n      stringValue = hexFromHexString(value)\n      break\n    }\n    default: {\n      return assertError(value, assert, `Unsupported type [${typeof value}]`)\n    }\n  }\n\n  return isHex(stringValue) ? stringValue : assertError(value, assert, `Value is not Hex [${value}]`)\n}\n","import { isNumber } from '@xylabs/typeof'\n\nimport type { Hex, HexConfig } from '../hex.ts'\nimport { isHex } from '../is.ts'\nimport { bitsToNibbles } from '../nibble.ts'\n\nexport const hexFromHexString = (value: string, config: HexConfig = {}): Hex => {\n  const {\n    prefix = 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(unEvened.length + (unEvened.length % nibbleBoundary), '0')\n    const padded = isNumber(bitLength) ? evenCharacters.padStart(bitLength / 4, '0') : evenCharacters\n    return (prefix ? `0x${padded}` : padded).toLowerCase() as Hex\n  } else {\n    throw new Error('Received string is not a value hex')\n  }\n}\n","// determine the number of nibbles for a given number of bits\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// determine the number of nibbles for a given number of bits\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\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 = config?.prefix ? value.length - 2 : value.length\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  return config?.prefix ? HexRegExWithPrefix.test(value) : HexRegEx.test(value)\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\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 { Brand } from '@xylabs/typeof'\nimport * as z from 'zod'\n\nimport { HexRegEx } from '../HexRegEx.ts'\n\nexport type BrandedHex = Brand<Lowercase<string>, { readonly __hex: true }>\n\nexport const HexZod = z.string().regex(HexRegEx, { message: 'Invalid hex format' }).transform(val => val as BrandedHex)\n\n/** Configuration of validation and output format */\nexport interface HexConfig {\n  bitLength?: number\n  byteSize?: number\n  prefix?: boolean\n}\n\nexport type Hex = z.infer<typeof HexZod>\n","import { isString } from '@xylabs/typeof'\n\nimport { hexFromHexString } from './from/index.ts'\n\nexport const isHexZero = (value?: string) => {\n  return isString(value) ? BigInt(hexFromHexString(value, { prefix: true })) === 0n : undefined\n}\n","export 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 = false } = config\n  return hexFrom(value, { prefix, ...config })\n}\n","import * as z from 'zod'\n\nimport { type Address, ADDRESS_LENGTH } from './address.ts'\nimport { AddressValidationZod } from './AddressValidationZod.ts'\n\nexport const AddressTransformZod = z.union([z.string(), z.bigint(), z.number()])\n  .transform((value) => {\n    switch (typeof value) {\n      case 'bigint': {\n        return value.toString(16).padStart(ADDRESS_LENGTH, '0')\n      }\n      case 'string': {\n        if (value.startsWith('0x')) {\n          return value.slice(2)\n        }\n        return value\n      }\n      case 'number': {\n        return BigInt(value).toString(16).padStart(ADDRESS_LENGTH, '0')\n      }\n    }\n  })\n  .refine(x => AddressValidationZod.safeParse(x).data)\n  .transform(x => x as Address)\n\nexport type AddressTransformZodType = z.infer<typeof AddressTransformZod>\n","import * as z from 'zod'\n\nimport { HexZod } from '../hex/index.ts'\nimport type { Address } from './address.ts'\nimport { ADDRESS_LENGTH } from './address.ts'\n\nexport const AddressValidationZod = z.string()\n  .refine(x => HexZod.safeParse(x))\n  .refine(x => x.length === ADDRESS_LENGTH, { error: e => new Error(`Address must have 40 characters [${e.input}]`) })\n  .transform(v => v as Address)\n\nexport type AddressValidationZodType = z.infer<typeof AddressValidationZod>\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\nexport const toAddress = (value: string | number | bigint | ArrayBufferLike, config: HexConfig = {}): Address => {\n  const { bitLength = 160, prefix = false } = config\n  return hexFrom(value, {\n    bitLength, prefix, ...config,\n  }) as unknown as Address\n}\n\n/** @alpha */\nexport function toAddressV2(value: unknown, assert: boolean = false): Address | undefined {\n  return assert\n    ? AddressTransformZod.parse(value)\n    : AddressTransformZod.safeParse(value).data\n}\n","import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport { isObject } from '@xylabs/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\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 = undefined\n\n    switch (typeof value) {\n      case 'string': {\n        stringValue = hexFromHexString(value, { prefix: false })\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: boolean = 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 { isHex } from '../hex/index.ts'\nimport type { Address } from './address.ts'\nimport { AddressValidationZod } from './AddressValidationZod.ts'\n\nexport const isAddress = (value: unknown, config: HexConfig = {}): value is Address => {\n  const { bitLength = 160, prefix = false } = config\n  return isHex(value, { bitLength, prefix })\n}\n\n/** @alpha */\nexport function isAddressV2(value: unknown): value is Address {\n  return AddressValidationZod.safeParse(value).success\n}\n","import type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport type { Brand } from '@xylabs/typeof'\nimport * as z from 'zod'\n\nimport type { HexConfig } from './hex/index.ts'\nimport {\n  hexFrom, hexFromHexString, isHex,\n} from './hex/index.ts'\nimport { HexRegExMinMaxMixedCaseWithPrefix } from './HexRegEx.ts'\n\nexport const EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20)\n\nexport const EthAddressToStringZod = z.string().regex(EthAddressRegEx)\n\n/** @deprecated use EthAddressToStringZod */\nexport const EthAddressToStringSchema = EthAddressToStringZod\n\nexport const EthAddressFromStringZod = z.string().regex(EthAddressRegEx).transform(v => toEthAddress(v))\n\n/** @deprecated use EthAddressFromStringZod */\nexport const EthAddressFromStringSchema = EthAddressFromStringZod\n\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\nexport const ETH_ZERO_ADDRESS = '0x0000000000000000000000000000000000000000' as EthAddress\n\nexport const toEthAddress = (value: string | number | bigint | ArrayBufferLike, config: HexConfig = {}): EthAddress => {\n  const { bitLength = 160, prefix = false } = config\n  return `0x${hexFrom(value, {\n    bitLength, prefix, ...config,\n  })}` as EthAddress\n}\n\nexport const isEthAddress = (value: unknown, config: HexConfig = {}): value is EthAddress => {\n  const { bitLength = 160, prefix = true } = config\n  const loweredValue = typeof value === 'string' ? value.toLowerCase() : value\n  return isHex(loweredValue, { bitLength, prefix })\n}\n\nexport const EthAddressZod = z.string()\n  .regex(EthAddressRegEx, { message: 'Invalid address format' })\n  .refine(\n    isEthAddress,\n  )\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 = 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 type { AssertConfig } from '@xylabs/error'\nimport { assertError } from '@xylabs/error'\nimport { isUndefined } from '@xylabs/typeof'\n\nimport { hexFromHexString } from '../hex/index.ts'\nimport { type Hash } from './hash.ts'\nimport { isHash } from './is.ts'\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  let stringValue: string | undefined = undefined\n\n  switch (typeof value) {\n    case 'string': {\n      stringValue = hexFromHexString(value)\n      break\n    }\n    default: {\n      return isUndefined(assert) ? undefined : assertError(value, assert, `Unsupported type [${typeof value}]`)\n    }\n  }\n  return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`)\n}\n","import { isHex } from '../hex/index.ts'\nimport type { Hash, HashBitLength } from './hash.ts'\n\nexport const isHash = (value: unknown, bitLength: HashBitLength = 256): value is Hash => {\n  return isHex(value, { bitLength })\n}\n","import type { Brand } from '@xylabs/typeof'\nimport * as z from 'zod'\n\nimport type { Hex } from '../hex/index.ts'\nimport { HexRegExMinMax } from '../HexRegEx.ts'\n\nexport const HASH_LENGTH = 32 as const\n\nexport const HashRegEx = HexRegExMinMax(HASH_LENGTH, HASH_LENGTH)\n\nexport const ZERO_HASH = '0000000000000000000000000000000000000000000000000000000000000000' as Hash\n\nexport type HashBitLength = 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096\nexport const HashBitLength: HashBitLength[] = [32, 64, 128, 256, 512, 1024, 2048, 4096]\n\nexport const isHashBitLength = (value: unknown): value is HashBitLength => {\n  return typeof value === 'number' && HashBitLength.includes(value as HashBitLength)\n}\n\nexport type BrandedHash = Brand<Hex, { readonly __hash: true }>\n\nexport const HashZod = z.string()\n  .regex(HashRegEx, { message: 'Invalid hex format' }).transform(val => val as BrandedHash)\n\nexport type Hash = z.infer<typeof HashZod>\n","import * as z from 'zod'\n\nimport { asHash } from './as.ts'\nimport type { Hash } from './hash.ts'\nimport { HashZod } from './hash.ts'\n\nexport const HashToJsonZod = HashZod.transform<string>(v => v)\nexport const JsonToHashZod = z.string().transform<Hash>(v => asHash(v, true))\n","import { type Hex, hexFromHexString } from './hex/index.ts'\n\nexport function hexToBigInt(hex: Hex): bigint {\n  return BigInt(hexFromHexString(hex, { prefix: true }))\n}\n","import * as z from 'zod'\n\nimport { toHex } from './hex/index.ts'\nimport { hexToBigInt } from './hexToBigInt.ts'\n\nexport const BigIntToJsonZod = z.bigint().nonnegative().transform(x => toHex(x))\nexport const JsonToBigIntZod = z.string().transform(x => toHex(x)).transform(x => hexToBigInt(x))\n"],"mappings":"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","names":["z","z","z","z","assertError","assertError","assertError","z","assertError","assertError","assertError","z","z","z"]}

package/dist/neutral/zod.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
-export declare const BigIntToJsonZod: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("./hex/hex.ts").Hex, bigint>>;
-export declare const JsonToBigIntZod: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("./hex/hex.ts").Hex, string>>, z.ZodTransform<bigint, import("./hex/hex.ts").Hex>>;
+import * as z from 'zod';
+export declare const BigIntToJsonZod: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("./hex/hex.ts").BrandedHex, bigint>>;
+export declare const JsonToBigIntZod: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("./hex/hex.ts").BrandedHex, string>>, z.ZodTransform<bigint, import("./hex/hex.ts").BrandedHex>>;
 //# sourceMappingURL=zod.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../src/zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,eAAe,4EAAoD,CAAA;AAChF,eAAO,MAAM,eAAe,2IAAqE,CAAA"}
+{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../src/zod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAKxB,eAAO,MAAM,eAAe,mFAAoD,CAAA;AAChF,eAAO,MAAM,eAAe,yJAAqE,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylabs/hex",
-  "version": "5.0.57",
+  "version": "5.0.59",
   "description": "Base functionality used throughout XY Labs TypeScript/JavaScript libraries",
   "keywords": [
     "hex",
@@ -45,13 +45,13 @@
     "!**/*.test.*"
   ],
   "dependencies": {
-    "@xylabs/error": "~5.0.57",
-    "@xylabs/typeof": "~5.0.57"
+    "@xylabs/error": "~5.0.59",
+    "@xylabs/typeof": "~5.0.59"
   },
   "devDependencies": {
     "@xylabs/ts-scripts-yarn3": "~7.2.32",
     "@xylabs/tsconfig": "~7.2.32",
-    "@xylabs/vitest-extended": "~5.0.57",
+    "@xylabs/vitest-extended": "~5.0.59",
     "typescript": "~5.9.3",
     "vitest": "~4.0.16",
     "zod": "^4.2.1"

package/src/address/AddressTransformZod.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod'
+import * as z from 'zod'
 
 import { type Address, ADDRESS_LENGTH } from './address.ts'
 import { AddressValidationZod } from './AddressValidationZod.ts'

package/src/address/AddressValidationZod.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod'
+import * as z from 'zod'
 
 import { HexZod } from '../hex/index.ts'
 import type { Address } from './address.ts'

package/src/address/address.ts

@@ -1,6 +1,7 @@
 import type { Brand } from '@xylabs/typeof'
+import * as z from 'zod'
 
-import { type Hex, UntypedHexZod } from '../hex/index.ts'
+import { type Hex } from '../hex/index.ts'
 import { HexRegExMinMax } from '../HexRegEx.ts'
 
 export const ZERO_ADDRESS = '0000000000000000000000000000000000000000' as Address
@@ -8,7 +9,8 @@ export const ADDRESS_LENGTH = 40 as const
 
 export const AddressRegEx = HexRegExMinMax(ADDRESS_LENGTH / 2, ADDRESS_LENGTH / 2)
 
-export type Address = Brand<Hex, { readonly __address: true }>
+type BrandedAddress = Brand<Hex, { readonly __address: true }>
 
-export const UnTypedAddressZod = UntypedHexZod.regex(AddressRegEx)
-export const AddressZod = UnTypedAddressZod.transform<Address>(v => v as Address)
+export const AddressZod = z.string().regex(AddressRegEx).transform<BrandedAddress>(v => v as BrandedAddress)
+
+export type Address = z.infer<typeof AddressZod>

package/src/address/addressDeprecated.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod'
+import * as z from 'zod'
 
 import { AddressRegEx } from './address.ts'
 import { toAddress } from './to.ts'

package/src/ethAddress.ts

@@ -1,7 +1,7 @@
 import type { AssertConfig } from '@xylabs/error'
 import { assertError } from '@xylabs/error'
 import type { Brand } from '@xylabs/typeof'
-import { z } from 'zod'
+import * as z from 'zod'
 
 import type { HexConfig } from './hex/index.ts'
 import {

package/src/hash/hash.ts

@@ -1,5 +1,5 @@
 import type { Brand } from '@xylabs/typeof'
-import { z } from 'zod'
+import * as z from 'zod'
 
 import type { Hex } from '../hex/index.ts'
 import { HexRegExMinMax } from '../HexRegEx.ts'
@@ -17,7 +17,9 @@ export const isHashBitLength = (value: unknown): value is HashBitLength => {
   return typeof value === 'number' && HashBitLength.includes(value as HashBitLength)
 }
 
-export type Hash = Brand<Hex, { readonly __hash: true }>
+export type BrandedHash = Brand<Hex, { readonly __hash: true }>
 
 export const HashZod = z.string()
-  .regex(HashRegEx, { message: 'Invalid hex format' }).transform(val => val as Hash)
+  .regex(HashRegEx, { message: 'Invalid hex format' }).transform(val => val as BrandedHash)
+
+export type Hash = z.infer<typeof HashZod>

package/src/hash/zod.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod'
+import * as z from 'zod'
 
 import { asHash } from './as.ts'
 import type { Hash } from './hash.ts'

package/src/hex/hex.ts

@@ -1,14 +1,11 @@
 import type { Brand } from '@xylabs/typeof'
-import { z } from 'zod'
+import * as z from 'zod'
 
 import { HexRegEx } from '../HexRegEx.ts'
 
-export type Hex = Brand<Lowercase<string>, { readonly __hex: true }>
+export type BrandedHex = Brand<Lowercase<string>, { readonly __hex: true }>
 
-export const UntypedHexZod = z.string()
-  .regex(HexRegEx, { message: 'Invalid hex format' })
-
-export const HexZod = UntypedHexZod.transform(val => val as Hex)
+export const HexZod = z.string().regex(HexRegEx, { message: 'Invalid hex format' }).transform(val => val as BrandedHex)
 
 /** Configuration of validation and output format */
 export interface HexConfig {
@@ -16,3 +13,5 @@ export interface HexConfig {
   byteSize?: number
   prefix?: boolean
 }
+
+export type Hex = z.infer<typeof HexZod>

package/src/zod.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod'
+import * as z from 'zod'
 
 import { toHex } from './hex/index.ts'
 import { hexToBigInt } from './hexToBigInt.ts'