@ethernauta/core - npm Package Compare versions

Comparing version 0.0.44 to 0.0.46

dist/address.d.ts

@@ -1,9 +0,9 @@
-import * as valibot12 from "valibot";
+import * as valibot33 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/address.d.ts
-declare const addressSchema: valibot12.SchemaWithPipe<readonly [valibot12.CustomSchema<`0x${string}`, undefined>, valibot12.BrandAction<`0x${string}`, "Address">]>;
-type Address = InferOutput<typeof addressSchema>;
+declare const AddressSchema: valibot33.SchemaWithPipe<readonly [valibot33.CustomSchema<`0x${string}`, undefined>, valibot33.BrandAction<`0x${string}`, "Address">]>;
+type Address = InferOutput<typeof AddressSchema>;
 //#endregion
-export { Address, addressSchema };
+export { Address, AddressSchema };
 //# sourceMappingURL=address.d.ts.map

dist/address.js

@@ -7,6 +7,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const addressSchema = pipe(custom(isAddress), brand("Address"));
+const AddressSchema = pipe(custom(isAddress), brand("Address"));
 
 //#endregion
-export { addressSchema };
+export { AddressSchema };
 //# sourceMappingURL=address.js.map

dist/address.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"address.js","names":[],"sources":["../src/address.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isAddress(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9,a-f,A-F]{40}$/.test(input)\n  )\n}\nexport const addressSchema = pipe(\n  custom<`0x${string}`>(isAddress),\n  brand(\"Address\"),\n)\nexport type Address = InferOutput<typeof addressSchema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,OACE,OAAO,UAAU,YACjB,wBAAwB,KAAK,KAAK;AAEtC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,SAAS,GAC/B,MAAM,SAAS,CACjB"}
+{"version":3,"file":"address.js","names":[],"sources":["../src/address.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isAddress(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9,a-f,A-F]{40}$/.test(input)\n  )\n}\nexport const AddressSchema = pipe(\n  custom<`0x${string}`>(isAddress),\n  brand(\"Address\"),\n)\nexport type Address = InferOutput<typeof AddressSchema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,OACE,OAAO,UAAU,YACjB,wBAAwB,KAAK,KAAK;AAEtC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,SAAS,GAC/B,MAAM,SAAS,CACjB"}

dist/addresses.d.ts

@@ -1,9 +0,9 @@
-import * as valibot0 from "valibot";
+import * as valibot28 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/addresses.d.ts
-declare const addressesSchema: valibot0.ArraySchema<valibot0.SchemaWithPipe<readonly [valibot0.CustomSchema<`0x${string}`, undefined>, valibot0.BrandAction<`0x${string}`, "Address">]>, undefined>;
-type Addresses = InferOutput<typeof addressesSchema>;
+declare const AddressesSchema: valibot28.ArraySchema<valibot28.SchemaWithPipe<readonly [valibot28.CustomSchema<`0x${string}`, undefined>, valibot28.BrandAction<`0x${string}`, "Address">]>, undefined>;
+type Addresses = InferOutput<typeof AddressesSchema>;
 //#endregion
-export { Addresses, addressesSchema };
+export { Addresses, AddressesSchema };
 //# sourceMappingURL=addresses.d.ts.map

dist/addresses.d.ts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"addresses.d.ts","names":[],"sources":["../src/addresses.ts"],"mappings":";;;;cAIa,iBAAe,QAAA,CAAA,YAAA,QAAA,CAAA,yBAAuB,QAAA,CAAvB,wCAAA,QAAA,CAAA;KAChB,SAAA,GAAY,mBAAmB"}
+{"version":3,"file":"addresses.d.ts","names":[],"sources":["../src/addresses.ts"],"mappings":";;;;cAIa,iBAAe,SAAA,CAAA,YAAA,SAAA,CAAA,yBAAuB,SAAA,CAAvB,wCAAA,SAAA,CAAA;KAChB,SAAA,GAAY,mBAAmB"}

dist/addresses.js

@@ -1,9 +0,9 @@
-import { addressSchema } from "./address.js";
+import { AddressSchema } from "./address.js";
 import { array } from "valibot";
 
 //#region src/addresses.ts
-const addressesSchema = array(addressSchema);
+const AddressesSchema = array(AddressSchema);
 
 //#endregion
-export { addressesSchema };
+export { AddressesSchema };
 //# sourceMappingURL=addresses.js.map

dist/addresses.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"addresses.js","names":[],"sources":["../src/addresses.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { array } from \"valibot\"\nimport { addressSchema } from \"./address\"\n\nexport const addressesSchema = array(addressSchema)\nexport type Addresses = InferOutput<typeof addressesSchema>\n"],"mappings":";;;;AAIA,MAAa,kBAAkB,MAAM,aAAa"}
+{"version":3,"file":"addresses.js","names":[],"sources":["../src/addresses.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { array } from \"valibot\"\nimport { AddressSchema } from \"./address\"\n\nexport const AddressesSchema = array(AddressSchema)\nexport type Addresses = InferOutput<typeof AddressesSchema>\n"],"mappings":";;;;AAIA,MAAa,kBAAkB,MAAM,aAAa"}

dist/byte.d.ts

@@ -1,9 +0,9 @@
-import * as valibot52 from "valibot";
+import * as valibot40 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/byte.d.ts
-declare const byteSchema: valibot52.SchemaWithPipe<readonly [valibot52.CustomSchema<`0x${string}`, undefined>, valibot52.BrandAction<`0x${string}`, "Byte">]>;
-type Byte = InferOutput<typeof byteSchema>;
+declare const ByteSchema: valibot40.SchemaWithPipe<readonly [valibot40.CustomSchema<`0x${string}`, undefined>, valibot40.BrandAction<`0x${string}`, "Byte">]>;
+type Byte = InferOutput<typeof ByteSchema>;
 //#endregion
-export { Byte, byteSchema };
+export { Byte, ByteSchema };
 //# sourceMappingURL=byte.d.ts.map

dist/byte.js

@@ -7,6 +7,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const byteSchema = pipe(custom(isByte), brand("Byte"));
+const ByteSchema = pipe(custom(isByte), brand("Byte"));
 
 //#endregion
-export { byteSchema };
+export { ByteSchema };
 //# sourceMappingURL=byte.js.map

dist/byte.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"byte.js","names":[],"sources":["../src/byte.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isByte(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x([0-9,a-f,A-F]?){1,2}$/.test(input)\n  )\n}\nexport const byteSchema = pipe(\n  custom<`0x${string}`>(isByte),\n  brand(\"Byte\"),\n)\nexport type Byte = InferOutput<typeof byteSchema>\n"],"mappings":";;;AAGA,SAAS,OAAO,OAAyB;CACvC,OACE,OAAO,UAAU,YACjB,4BAA4B,KAAK,KAAK;AAE1C;AACA,MAAa,aAAa,KACxB,OAAsB,MAAM,GAC5B,MAAM,MAAM,CACd"}
+{"version":3,"file":"byte.js","names":[],"sources":["../src/byte.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isByte(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x([0-9,a-f,A-F]?){1,2}$/.test(input)\n  )\n}\nexport const ByteSchema = pipe(\n  custom<`0x${string}`>(isByte),\n  brand(\"Byte\"),\n)\nexport type Byte = InferOutput<typeof ByteSchema>\n"],"mappings":";;;AAGA,SAAS,OAAO,OAAyB;CACvC,OACE,OAAO,UAAU,YACjB,4BAA4B,KAAK,KAAK;AAE1C;AACA,MAAa,aAAa,KACxB,OAAsB,MAAM,GAC5B,MAAM,MAAM,CACd"}

dist/bytes-256.d.ts

@@ -1,9 +0,9 @@
-import * as valibot9 from "valibot";
+import * as valibot16 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/bytes-256.d.ts
-declare const bytes256Schema: valibot9.SchemaWithPipe<readonly [valibot9.CustomSchema<`0x${string}`, undefined>, valibot9.BrandAction<`0x${string}`, "Bytes256">]>;
-type Bytes256 = InferOutput<typeof bytes256Schema>;
+declare const Bytes256Schema: valibot16.SchemaWithPipe<readonly [valibot16.CustomSchema<`0x${string}`, undefined>, valibot16.BrandAction<`0x${string}`, "Bytes256">]>;
+type Bytes256 = InferOutput<typeof Bytes256Schema>;
 //#endregion
-export { Bytes256, bytes256Schema };
+export { Bytes256, Bytes256Schema };
 //# sourceMappingURL=bytes-256.d.ts.map

dist/bytes-256.d.ts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"bytes-256.d.ts","names":[],"sources":["../src/bytes-256.ts"],"mappings":";;;;cASa,gBAAc,QAAA,CAAA,yBAG1B,QAAA,CAH0B,wCAAA,QAAA,CAAA;KAIf,QAAA,GAAW,mBAAmB"}
+{"version":3,"file":"bytes-256.d.ts","names":[],"sources":["../src/bytes-256.ts"],"mappings":";;;;cASa,gBAAc,SAAA,CAAA,yBAG1B,SAAA,CAH0B,wCAAA,SAAA,CAAA;KAIf,QAAA,GAAW,mBAAmB"}

dist/bytes-256.js

@@ -7,6 +7,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const bytes256Schema = pipe(custom(isBytes256), brand("Bytes256"));
+const Bytes256Schema = pipe(custom(isBytes256), brand("Bytes256"));
 
 //#endregion
-export { bytes256Schema };
+export { Bytes256Schema };
 //# sourceMappingURL=bytes-256.js.map

dist/bytes-256.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"bytes-256.js","names":[],"sources":["../src/bytes-256.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes256(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{512}$/.test(input)\n  )\n}\nexport const bytes256Schema = pipe(\n  custom<`0x${string}`>(isBytes256),\n  brand(\"Bytes256\"),\n)\nexport type Bytes256 = InferOutput<typeof bytes256Schema>\n"],"mappings":";;;AAGA,SAAS,WAAW,OAAyB;CAC3C,OACE,OAAO,UAAU,YACjB,oBAAoB,KAAK,KAAK;AAElC;AACA,MAAa,iBAAiB,KAC5B,OAAsB,UAAU,GAChC,MAAM,UAAU,CAClB"}
+{"version":3,"file":"bytes-256.js","names":[],"sources":["../src/bytes-256.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes256(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{512}$/.test(input)\n  )\n}\nexport const Bytes256Schema = pipe(\n  custom<`0x${string}`>(isBytes256),\n  brand(\"Bytes256\"),\n)\nexport type Bytes256 = InferOutput<typeof Bytes256Schema>\n"],"mappings":";;;AAGA,SAAS,WAAW,OAAyB;CAC3C,OACE,OAAO,UAAU,YACjB,oBAAoB,KAAK,KAAK;AAElC;AACA,MAAa,iBAAiB,KAC5B,OAAsB,UAAU,GAChC,MAAM,UAAU,CAClB"}

dist/bytes-32.d.ts

@@ -1,9 +0,9 @@
-import * as valibot55 from "valibot";
+import * as valibot51 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/bytes-32.d.ts
-declare const bytes32Schema: valibot55.SchemaWithPipe<readonly [valibot55.CustomSchema<`0x${string}`, undefined>, valibot55.BrandAction<`0x${string}`, "Bytes32">]>;
-type Bytes32 = InferOutput<typeof bytes32Schema>;
+declare const Bytes32Schema: valibot51.SchemaWithPipe<readonly [valibot51.CustomSchema<`0x${string}`, undefined>, valibot51.BrandAction<`0x${string}`, "Bytes32">]>;
+type Bytes32 = InferOutput<typeof Bytes32Schema>;
 //#endregion
-export { Bytes32, bytes32Schema };
+export { Bytes32, Bytes32Schema };
 //# sourceMappingURL=bytes-32.d.ts.map

dist/bytes-32.js

@@ -7,6 +7,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const bytes32Schema = pipe(custom(isBytes32), brand("Bytes32"));
+const Bytes32Schema = pipe(custom(isBytes32), brand("Bytes32"));
 
 //#endregion
-export { bytes32Schema };
+export { Bytes32Schema };
 //# sourceMappingURL=bytes-32.js.map

dist/bytes-32.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"bytes-32.js","names":[],"sources":["../src/bytes-32.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes32(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{64}$/.test(input)\n  )\n}\nexport const bytes32Schema = pipe(\n  custom<`0x${string}`>(isBytes32),\n  brand(\"Bytes32\"),\n)\nexport type Bytes32 = InferOutput<typeof bytes32Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,OACE,OAAO,UAAU,YACjB,mBAAmB,KAAK,KAAK;AAEjC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,SAAS,GAC/B,MAAM,SAAS,CACjB"}
+{"version":3,"file":"bytes-32.js","names":[],"sources":["../src/bytes-32.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes32(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{64}$/.test(input)\n  )\n}\nexport const Bytes32Schema = pipe(\n  custom<`0x${string}`>(isBytes32),\n  brand(\"Bytes32\"),\n)\nexport type Bytes32 = InferOutput<typeof Bytes32Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,OACE,OAAO,UAAU,YACjB,mBAAmB,KAAK,KAAK;AAEjC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,SAAS,GAC/B,MAAM,SAAS,CACjB"}

dist/bytes-4.d.ts

@@ -1,9 +0,9 @@
-import * as valibot36 from "valibot";
+import * as valibot2 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/bytes-4.d.ts
-declare const bytes4Schema: valibot36.SchemaWithPipe<readonly [valibot36.CustomSchema<`0x${string}`, undefined>, valibot36.BrandAction<`0x${string}`, "Bytes4">]>;
-type Bytes4 = InferOutput<typeof bytes4Schema>;
+declare const Bytes4Schema: valibot2.SchemaWithPipe<readonly [valibot2.CustomSchema<`0x${string}`, undefined>, valibot2.BrandAction<`0x${string}`, "Bytes4">]>;
+type Bytes4 = InferOutput<typeof Bytes4Schema>;
 //#endregion
-export { Bytes4, bytes4Schema };
+export { Bytes4, Bytes4Schema };
 //# sourceMappingURL=bytes-4.d.ts.map

dist/bytes-4.d.ts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"bytes-4.d.ts","names":[],"sources":["../src/bytes-4.ts"],"mappings":";;;;cASa,cAAY,SAAA,CAAA,yBAGxB,SAAA,CAHwB,wCAAA,SAAA,CAAA;KAIb,MAAA,GAAS,mBAAmB"}
+{"version":3,"file":"bytes-4.d.ts","names":[],"sources":["../src/bytes-4.ts"],"mappings":";;;;cASa,cAAY,QAAA,CAAA,yBAGxB,QAAA,CAHwB,wCAAA,QAAA,CAAA;KAIb,MAAA,GAAS,mBAAmB"}

dist/bytes-4.js

@@ -7,6 +7,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const bytes4Schema = pipe(custom(isBytes4), brand("Bytes4"));
+const Bytes4Schema = pipe(custom(isBytes4), brand("Bytes4"));
 
 //#endregion
-export { bytes4Schema };
+export { Bytes4Schema };
 //# sourceMappingURL=bytes-4.js.map

dist/bytes-4.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"bytes-4.js","names":[],"sources":["../src/bytes-4.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes4(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{8}$/.test(input)\n  )\n}\nexport const bytes4Schema = pipe(\n  custom<`0x${string}`>(isBytes4),\n  brand(\"Bytes4\"),\n)\nexport type Bytes4 = InferOutput<typeof bytes4Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,OACE,OAAO,UAAU,YACjB,kBAAkB,KAAK,KAAK;AAEhC;AACA,MAAa,eAAe,KAC1B,OAAsB,QAAQ,GAC9B,MAAM,QAAQ,CAChB"}
+{"version":3,"file":"bytes-4.js","names":[],"sources":["../src/bytes-4.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes4(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{8}$/.test(input)\n  )\n}\nexport const Bytes4Schema = pipe(\n  custom<`0x${string}`>(isBytes4),\n  brand(\"Bytes4\"),\n)\nexport type Bytes4 = InferOutput<typeof Bytes4Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,OACE,OAAO,UAAU,YACjB,kBAAkB,KAAK,KAAK;AAEhC;AACA,MAAa,eAAe,KAC1B,OAAsB,QAAQ,GAC9B,MAAM,QAAQ,CAChB"}

dist/bytes-48.d.ts

@@ -1,9 +0,9 @@
-import * as valibot68 from "valibot";
+import * as valibot25 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/bytes-48.d.ts
-declare const bytes48Schema: valibot68.SchemaWithPipe<readonly [valibot68.CustomSchema<`0x${string}`, undefined>, valibot68.BrandAction<`0x${string}`, "Bytes48">]>;
-type Bytes48 = InferOutput<typeof bytes48Schema>;
+declare const Bytes48Schema: valibot25.SchemaWithPipe<readonly [valibot25.CustomSchema<`0x${string}`, undefined>, valibot25.BrandAction<`0x${string}`, "Bytes48">]>;
+type Bytes48 = InferOutput<typeof Bytes48Schema>;
 //#endregion
-export { Bytes48, bytes48Schema };
+export { Bytes48, Bytes48Schema };
 //# sourceMappingURL=bytes-48.d.ts.map

dist/bytes-48.js

@@ -7,6 +7,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const bytes48Schema = pipe(custom(isBytes48), brand("Bytes48"));
+const Bytes48Schema = pipe(custom(isBytes48), brand("Bytes48"));
 
 //#endregion
-export { bytes48Schema };
+export { Bytes48Schema };
 //# sourceMappingURL=bytes-48.js.map

dist/bytes-48.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"bytes-48.js","names":[],"sources":["../src/bytes-48.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes48(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{96}$/.test(input)\n  )\n}\nexport const bytes48Schema = pipe(\n  custom<`0x${string}`>(isBytes48),\n  brand(\"Bytes48\"),\n)\nexport type Bytes48 = InferOutput<typeof bytes48Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,OACE,OAAO,UAAU,YACjB,mBAAmB,KAAK,KAAK;AAEjC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,SAAS,GAC/B,MAAM,SAAS,CACjB"}
+{"version":3,"file":"bytes-48.js","names":[],"sources":["../src/bytes-48.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes48(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{96}$/.test(input)\n  )\n}\nexport const Bytes48Schema = pipe(\n  custom<`0x${string}`>(isBytes48),\n  brand(\"Bytes48\"),\n)\nexport type Bytes48 = InferOutput<typeof Bytes48Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,OACE,OAAO,UAAU,YACjB,mBAAmB,KAAK,KAAK;AAEjC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,SAAS,GAC/B,MAAM,SAAS,CACjB"}

dist/bytes-64.d.ts

@@ -1,9 +0,9 @@
-import * as valibot23 from "valibot";
+import * as valibot0 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/bytes-64.d.ts
-declare const bytes64Schema: valibot23.SchemaWithPipe<readonly [valibot23.CustomSchema<`0x${string}`, undefined>, valibot23.BrandAction<`0x${string}`, "Bytes64">]>;
-type Bytes64 = InferOutput<typeof bytes64Schema>;
+declare const Bytes64Schema: valibot0.SchemaWithPipe<readonly [valibot0.CustomSchema<`0x${string}`, undefined>, valibot0.BrandAction<`0x${string}`, "Bytes64">]>;
+type Bytes64 = InferOutput<typeof Bytes64Schema>;
 //#endregion
-export { Bytes64, bytes64Schema };
+export { Bytes64, Bytes64Schema };
 //# sourceMappingURL=bytes-64.d.ts.map

dist/bytes-64.d.ts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"bytes-64.d.ts","names":[],"sources":["../src/bytes-64.ts"],"mappings":";;;;cASa,eAAa,SAAA,CAAA,yBAGzB,SAAA,CAHyB,wCAAA,SAAA,CAAA;KAId,OAAA,GAAU,mBAAmB"}
+{"version":3,"file":"bytes-64.d.ts","names":[],"sources":["../src/bytes-64.ts"],"mappings":";;;;cASa,eAAa,QAAA,CAAA,yBAGzB,QAAA,CAHyB,wCAAA,QAAA,CAAA;KAId,OAAA,GAAU,mBAAmB"}

dist/bytes-64.js

@@ -7,6 +7,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const bytes64Schema = pipe(custom(isBytes64), brand("Bytes64"));
+const Bytes64Schema = pipe(custom(isBytes64), brand("Bytes64"));
 
 //#endregion
-export { bytes64Schema };
+export { Bytes64Schema };
 //# sourceMappingURL=bytes-64.js.map

dist/bytes-64.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"bytes-64.js","names":[],"sources":["../src/bytes-64.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes64(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{128}$/.test(input)\n  )\n}\nexport const bytes64Schema = pipe(\n  custom<`0x${string}`>(isBytes64),\n  brand(\"Bytes64\"),\n)\nexport type Bytes64 = InferOutput<typeof bytes64Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,OACE,OAAO,UAAU,YACjB,oBAAoB,KAAK,KAAK;AAElC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,SAAS,GAC/B,MAAM,SAAS,CACjB"}
+{"version":3,"file":"bytes-64.js","names":[],"sources":["../src/bytes-64.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes64(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{128}$/.test(input)\n  )\n}\nexport const Bytes64Schema = pipe(\n  custom<`0x${string}`>(isBytes64),\n  brand(\"Bytes64\"),\n)\nexport type Bytes64 = InferOutput<typeof Bytes64Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,OACE,OAAO,UAAU,YACjB,oBAAoB,KAAK,KAAK;AAElC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,SAAS,GAC/B,MAAM,SAAS,CACjB"}

dist/bytes-65.d.ts

@@ -1,9 +0,9 @@
-import * as valibot6 from "valibot";
+import * as valibot13 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/bytes-65.d.ts
-declare const bytes65Schema: valibot6.SchemaWithPipe<readonly [valibot6.CustomSchema<`0x${string}`, undefined>, valibot6.BrandAction<`0x${string}`, "Bytes65">]>;
-type Bytes65 = InferOutput<typeof bytes65Schema>;
+declare const Bytes65Schema: valibot13.SchemaWithPipe<readonly [valibot13.CustomSchema<`0x${string}`, undefined>, valibot13.BrandAction<`0x${string}`, "Bytes65">]>;
+type Bytes65 = InferOutput<typeof Bytes65Schema>;
 //#endregion
-export { Bytes65, bytes65Schema };
+export { Bytes65, Bytes65Schema };
 //# sourceMappingURL=bytes-65.d.ts.map

dist/bytes-65.d.ts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"bytes-65.d.ts","names":[],"sources":["../src/bytes-65.ts"],"mappings":";;;;cASa,eAAa,QAAA,CAAA,yBAGzB,QAAA,CAHyB,wCAAA,QAAA,CAAA;KAId,OAAA,GAAU,mBAAmB"}
+{"version":3,"file":"bytes-65.d.ts","names":[],"sources":["../src/bytes-65.ts"],"mappings":";;;;cASa,eAAa,SAAA,CAAA,yBAGzB,SAAA,CAHyB,wCAAA,SAAA,CAAA;KAId,OAAA,GAAU,mBAAmB"}

dist/bytes-65.js

@@ -7,6 +7,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const bytes65Schema = pipe(custom(isBytes65), brand("Bytes65"));
+const Bytes65Schema = pipe(custom(isBytes65), brand("Bytes65"));
 
 //#endregion
-export { bytes65Schema };
+export { Bytes65Schema };
 //# sourceMappingURL=bytes-65.js.map

dist/bytes-65.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"bytes-65.js","names":[],"sources":["../src/bytes-65.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes65(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{130}$/.test(input)\n  )\n}\nexport const bytes65Schema = pipe(\n  custom<`0x${string}`>(isBytes65),\n  brand(\"Bytes65\"),\n)\nexport type Bytes65 = InferOutput<typeof bytes65Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,OACE,OAAO,UAAU,YACjB,oBAAoB,KAAK,KAAK;AAElC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,SAAS,GAC/B,MAAM,SAAS,CACjB"}
+{"version":3,"file":"bytes-65.js","names":[],"sources":["../src/bytes-65.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes65(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{130}$/.test(input)\n  )\n}\nexport const Bytes65Schema = pipe(\n  custom<`0x${string}`>(isBytes65),\n  brand(\"Bytes65\"),\n)\nexport type Bytes65 = InferOutput<typeof Bytes65Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,OACE,OAAO,UAAU,YACjB,oBAAoB,KAAK,KAAK;AAElC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,SAAS,GAC/B,MAAM,SAAS,CACjB"}

dist/bytes-8.d.ts

@@ -1,9 +0,9 @@
-import * as valibot39 from "valibot";
+import * as valibot10 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/bytes-8.d.ts
-declare const bytes8Schema: valibot39.SchemaWithPipe<readonly [valibot39.CustomSchema<`0x${string}`, undefined>, valibot39.BrandAction<`0x${string}`, "Bytes8">]>;
-type Bytes8 = InferOutput<typeof bytes8Schema>;
+declare const Bytes8Schema: valibot10.SchemaWithPipe<readonly [valibot10.CustomSchema<`0x${string}`, undefined>, valibot10.BrandAction<`0x${string}`, "Bytes8">]>;
+type Bytes8 = InferOutput<typeof Bytes8Schema>;
 //#endregion
-export { Bytes8, bytes8Schema };
+export { Bytes8, Bytes8Schema };
 //# sourceMappingURL=bytes-8.d.ts.map

dist/bytes-8.js

@@ -7,6 +7,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const bytes8Schema = pipe(custom(isBytes8), brand("Bytes8"));
+const Bytes8Schema = pipe(custom(isBytes8), brand("Bytes8"));
 
 //#endregion
-export { bytes8Schema };
+export { Bytes8Schema };
 //# sourceMappingURL=bytes-8.js.map

dist/bytes-8.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"bytes-8.js","names":[],"sources":["../src/bytes-8.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes8(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{16}$/.test(input)\n  )\n}\nexport const bytes8Schema = pipe(\n  custom<`0x${string}`>(isBytes8),\n  brand(\"Bytes8\"),\n)\nexport type Bytes8 = InferOutput<typeof bytes8Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,OACE,OAAO,UAAU,YACjB,mBAAmB,KAAK,KAAK;AAEjC;AACA,MAAa,eAAe,KAC1B,OAAsB,QAAQ,GAC9B,MAAM,QAAQ,CAChB"}
+{"version":3,"file":"bytes-8.js","names":[],"sources":["../src/bytes-8.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes8(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{16}$/.test(input)\n  )\n}\nexport const Bytes8Schema = pipe(\n  custom<`0x${string}`>(isBytes8),\n  brand(\"Bytes8\"),\n)\nexport type Bytes8 = InferOutput<typeof Bytes8Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,OACE,OAAO,UAAU,YACjB,mBAAmB,KAAK,KAAK;AAEjC;AACA,MAAa,eAAe,KAC1B,OAAsB,QAAQ,GAC9B,MAAM,QAAQ,CAChB"}

dist/bytes-max-32.d.ts

@@ -1,9 +0,9 @@
-import * as valibot15 from "valibot";
+import * as valibot19 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/bytes-max-32.d.ts
-declare const bytesMax32Schema: valibot15.SchemaWithPipe<readonly [valibot15.CustomSchema<`0x${string}`, undefined>, valibot15.BrandAction<`0x${string}`, "BytesMax32">]>;
-type BytesMax32 = InferOutput<typeof bytesMax32Schema>;
+declare const BytesMax32Schema: valibot19.SchemaWithPipe<readonly [valibot19.CustomSchema<`0x${string}`, undefined>, valibot19.BrandAction<`0x${string}`, "BytesMax32">]>;
+type BytesMax32 = InferOutput<typeof BytesMax32Schema>;
 //#endregion
-export { BytesMax32, bytesMax32Schema };
+export { BytesMax32, BytesMax32Schema };
 //# sourceMappingURL=bytes-max-32.d.ts.map

dist/bytes-max-32.js

@@ -7,6 +7,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const bytesMax32Schema = pipe(custom(isBytesMax32), brand("BytesMax32"));
+const BytesMax32Schema = pipe(custom(isBytesMax32), brand("BytesMax32"));
 
 //#endregion
-export { bytesMax32Schema };
+export { BytesMax32Schema };
 //# sourceMappingURL=bytes-max-32.js.map

dist/bytes-max-32.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"bytes-max-32.js","names":[],"sources":["../src/bytes-max-32.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytesMax32(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{0,64}$/.test(input)\n  )\n}\nexport const bytesMax32Schema = pipe(\n  custom<`0x${string}`>(isBytesMax32),\n  brand(\"BytesMax32\"),\n)\nexport type BytesMax32 = InferOutput<\n  typeof bytesMax32Schema\n>\n"],"mappings":";;;AAGA,SAAS,aAAa,OAAyB;CAC7C,OACE,OAAO,UAAU,YACjB,qBAAqB,KAAK,KAAK;AAEnC;AACA,MAAa,mBAAmB,KAC9B,OAAsB,YAAY,GAClC,MAAM,YAAY,CACpB"}
+{"version":3,"file":"bytes-max-32.js","names":[],"sources":["../src/bytes-max-32.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytesMax32(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{0,64}$/.test(input)\n  )\n}\nexport const BytesMax32Schema = pipe(\n  custom<`0x${string}`>(isBytesMax32),\n  brand(\"BytesMax32\"),\n)\nexport type BytesMax32 = InferOutput<\n  typeof BytesMax32Schema\n>\n"],"mappings":";;;AAGA,SAAS,aAAa,OAAyB;CAC7C,OACE,OAAO,UAAU,YACjB,qBAAqB,KAAK,KAAK;AAEnC;AACA,MAAa,mBAAmB,KAC9B,OAAsB,YAAY,GAClC,MAAM,YAAY,CACpB"}

dist/bytes.d.ts

@@ -1,9 +0,9 @@
-import * as valibot81 from "valibot";
+import * as valibot48 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/bytes.d.ts
-declare const bytesSchema: valibot81.SchemaWithPipe<readonly [valibot81.CustomSchema<`0x${string}`, undefined>, valibot81.BrandAction<`0x${string}`, "Bytes">]>;
-type Bytes = InferOutput<typeof bytesSchema>;
+declare const BytesSchema: valibot48.SchemaWithPipe<readonly [valibot48.CustomSchema<`0x${string}`, undefined>, valibot48.BrandAction<`0x${string}`, "Bytes">]>;
+type Bytes = InferOutput<typeof BytesSchema>;
 //#endregion
-export { Bytes, bytesSchema };
+export { Bytes, BytesSchema };
 //# sourceMappingURL=bytes.d.ts.map

dist/bytes.js

@@ -7,6 +7,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const bytesSchema = pipe(custom(isBytes), brand("Bytes"));
+const BytesSchema = pipe(custom(isBytes), brand("Bytes"));
 
 //#endregion
-export { bytesSchema };
+export { BytesSchema };
 //# sourceMappingURL=bytes.js.map

dist/bytes.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"bytes.js","names":[],"sources":["../src/bytes.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes(input: unknown): boolean {\n  return (\n    typeof input === \"string\" && /^0x[0-9a-f]*$/.test(input)\n  )\n}\nexport const bytesSchema = pipe(\n  custom<`0x${string}`>(isBytes),\n  brand(\"Bytes\"),\n)\nexport type Bytes = InferOutput<typeof bytesSchema>\n"],"mappings":";;;AAGA,SAAS,QAAQ,OAAyB;CACxC,OACE,OAAO,UAAU,YAAY,gBAAgB,KAAK,KAAK;AAE3D;AACA,MAAa,cAAc,KACzB,OAAsB,OAAO,GAC7B,MAAM,OAAO,CACf"}
+{"version":3,"file":"bytes.js","names":[],"sources":["../src/bytes.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isBytes(input: unknown): boolean {\n  return (\n    typeof input === \"string\" && /^0x[0-9a-f]*$/.test(input)\n  )\n}\nexport const BytesSchema = pipe(\n  custom<`0x${string}`>(isBytes),\n  brand(\"Bytes\"),\n)\nexport type Bytes = InferOutput<typeof BytesSchema>\n"],"mappings":";;;AAGA,SAAS,QAAQ,OAAyB;CACxC,OACE,OAAO,UAAU,YAAY,gBAAgB,KAAK,KAAK;AAE3D;AACA,MAAa,cAAc,KACzB,OAAsB,OAAO,GAC7B,MAAM,OAAO,CACf"}

dist/hash-32.d.ts

@@ -1,9 +0,9 @@
-import * as valibot3 from "valibot";
+import * as valibot22 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/hash-32.d.ts
-declare const hash32Schema: valibot3.SchemaWithPipe<readonly [valibot3.CustomSchema<`0x${string}`, undefined>, valibot3.BrandAction<`0x${string}`, "Hash32">]>;
-type Hash32 = InferOutput<typeof hash32Schema>;
+declare const Hash32Schema: valibot22.SchemaWithPipe<readonly [valibot22.CustomSchema<`0x${string}`, undefined>, valibot22.BrandAction<`0x${string}`, "Hash32">]>;
+type Hash32 = InferOutput<typeof Hash32Schema>;
 //#endregion
-export { Hash32, hash32Schema };
+export { Hash32, Hash32Schema };
 //# sourceMappingURL=hash-32.d.ts.map

dist/hash-32.d.ts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"hash-32.d.ts","names":[],"sources":["../src/hash-32.ts"],"mappings":";;;;cASa,cAAY,QAAA,CAAA,yBAGxB,QAAA,CAHwB,wCAAA,QAAA,CAAA;KAIb,MAAA,GAAS,mBAAmB"}
+{"version":3,"file":"hash-32.d.ts","names":[],"sources":["../src/hash-32.ts"],"mappings":";;;;cASa,cAAY,SAAA,CAAA,yBAGxB,SAAA,CAHwB,wCAAA,SAAA,CAAA;KAIb,MAAA,GAAS,mBAAmB"}

dist/hash-32.js

@@ -7,6 +7,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const hash32Schema = pipe(custom(isHash32), brand("Hash32"));
+const Hash32Schema = pipe(custom(isHash32), brand("Hash32"));
 
 //#endregion
-export { hash32Schema };
+export { Hash32Schema };
 //# sourceMappingURL=hash-32.js.map

dist/hash-32.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"hash-32.js","names":[],"sources":["../src/hash-32.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isHash32(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{64}$/.test(input)\n  )\n}\nexport const hash32Schema = pipe(\n  custom<`0x${string}`>(isHash32),\n  brand(\"Hash32\"),\n)\nexport type Hash32 = InferOutput<typeof hash32Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,OACE,OAAO,UAAU,YACjB,mBAAmB,KAAK,KAAK;AAEjC;AACA,MAAa,eAAe,KAC1B,OAAsB,QAAQ,GAC9B,MAAM,QAAQ,CAChB"}
+{"version":3,"file":"hash-32.js","names":[],"sources":["../src/hash-32.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isHash32(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{64}$/.test(input)\n  )\n}\nexport const Hash32Schema = pipe(\n  custom<`0x${string}`>(isHash32),\n  brand(\"Hash32\"),\n)\nexport type Hash32 = InferOutput<typeof Hash32Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,OACE,OAAO,UAAU,YACjB,mBAAmB,KAAK,KAAK;AAEjC;AACA,MAAa,eAAe,KAC1B,OAAsB,QAAQ,GAC9B,MAAM,QAAQ,CAChB"}

dist/index.d.ts

@@ -1,31 +0,31 @@
-import { Address, addressSchema } from "./address.js";
-import { Addresses, addressesSchema } from "./addresses.js";
-import { Byte, byteSchema } from "./byte.js";
-import { Bytes, bytesSchema } from "./bytes.js";
-import { Bytes4, bytes4Schema } from "./bytes-4.js";
-import { Bytes8, bytes8Schema } from "./bytes-8.js";
-import { Bytes32, bytes32Schema } from "./bytes-32.js";
-import { Bytes48, bytes48Schema } from "./bytes-48.js";
-import { Bytes64, bytes64Schema } from "./bytes-64.js";
-import { Bytes65, bytes65Schema } from "./bytes-65.js";
-import { Bytes256, bytes256Schema } from "./bytes-256.js";
-import { BytesMax32, bytesMax32Schema } from "./bytes-max-32.js";
-import { Hash32, hash32Schema } from "./hash-32.js";
-import { NotFound, notFoundSchema } from "./not-found.js";
-import { Ratio, ratioSchema } from "./ratio.js";
-import { Uint, uintSchema } from "./uint.js";
-import { Uint8, uint8Schema } from "./uint-8.js";
-import { Uint16, uint16Schema } from "./uint-16.js";
-import { Uint24, uint24Schema } from "./uint-24.js";
-import { Uint32, uint32Schema } from "./uint-32.js";
-import { Uint40, uint40Schema } from "./uint-40.js";
-import { Uint48, uint48Schema } from "./uint-48.js";
-import { Uint56, uint56Schema } from "./uint-56.js";
-import { Uint64, uint64Schema } from "./uint-64.js";
-import { Uint96, uint96Schema } from "./uint-96.js";
-import { Uint128, uint128Schema } from "./uint-128.js";
-import { Uint160, uint160Schema } from "./uint-160.js";
-import { Uint192, uint192Schema } from "./uint-192.js";
-import { Uint224, uint224Schema } from "./uint-224.js";
-import { Uint256, uint256Schema } from "./uint-256.js";
-export { Address, Addresses, Byte, Bytes, Bytes256, Bytes32, Bytes4, Bytes48, Bytes64, Bytes65, Bytes8, BytesMax32, Hash32, NotFound, Ratio, Uint, Uint128, Uint16, Uint160, Uint192, Uint224, Uint24, Uint256, Uint32, Uint40, Uint48, Uint56, Uint64, Uint8, Uint96, addressSchema, addressesSchema, byteSchema, bytes256Schema, bytes32Schema, bytes48Schema, bytes4Schema, bytes64Schema, bytes65Schema, bytes8Schema, bytesMax32Schema, bytesSchema, hash32Schema, notFoundSchema, ratioSchema, uint128Schema, uint160Schema, uint16Schema, uint192Schema, uint224Schema, uint24Schema, uint256Schema, uint32Schema, uint40Schema, uint48Schema, uint56Schema, uint64Schema, uint8Schema, uint96Schema, uintSchema };
+import { Address, AddressSchema } from "./address.js";
+import { Addresses, AddressesSchema } from "./addresses.js";
+import { Byte, ByteSchema } from "./byte.js";
+import { Bytes, BytesSchema } from "./bytes.js";
+import { Bytes4, Bytes4Schema } from "./bytes-4.js";
+import { Bytes8, Bytes8Schema } from "./bytes-8.js";
+import { Bytes32, Bytes32Schema } from "./bytes-32.js";
+import { Bytes48, Bytes48Schema } from "./bytes-48.js";
+import { Bytes64, Bytes64Schema } from "./bytes-64.js";
+import { Bytes65, Bytes65Schema } from "./bytes-65.js";
+import { Bytes256, Bytes256Schema } from "./bytes-256.js";
+import { BytesMax32, BytesMax32Schema } from "./bytes-max-32.js";
+import { Hash32, Hash32Schema } from "./hash-32.js";
+import { NotFound, NotFoundSchema } from "./not-found.js";
+import { Ratio, RatioSchema } from "./ratio.js";
+import { Uint, UintSchema } from "./uint.js";
+import { Uint8, Uint8Schema } from "./uint-8.js";
+import { Uint16, Uint16Schema } from "./uint-16.js";
+import { Uint24, Uint24Schema } from "./uint-24.js";
+import { Uint32, Uint32Schema } from "./uint-32.js";
+import { Uint40, Uint40Schema } from "./uint-40.js";
+import { Uint48, Uint48Schema } from "./uint-48.js";
+import { Uint56, Uint56Schema } from "./uint-56.js";
+import { Uint64, Uint64Schema } from "./uint-64.js";
+import { Uint96, Uint96Schema } from "./uint-96.js";
+import { Uint128, Uint128Schema } from "./uint-128.js";
+import { Uint160, Uint160Schema } from "./uint-160.js";
+import { Uint192, Uint192Schema } from "./uint-192.js";
+import { Uint224, Uint224Schema } from "./uint-224.js";
+import { Uint256, Uint256Schema } from "./uint-256.js";
+export { Address, AddressSchema, Addresses, AddressesSchema, Byte, ByteSchema, Bytes, Bytes256, Bytes256Schema, Bytes32, Bytes32Schema, Bytes4, Bytes48, Bytes48Schema, Bytes4Schema, Bytes64, Bytes64Schema, Bytes65, Bytes65Schema, Bytes8, Bytes8Schema, BytesMax32, BytesMax32Schema, BytesSchema, Hash32, Hash32Schema, NotFound, NotFoundSchema, Ratio, RatioSchema, Uint, Uint128, Uint128Schema, Uint16, Uint160, Uint160Schema, Uint16Schema, Uint192, Uint192Schema, Uint224, Uint224Schema, Uint24, Uint24Schema, Uint256, Uint256Schema, Uint32, Uint32Schema, Uint40, Uint40Schema, Uint48, Uint48Schema, Uint56, Uint56Schema, Uint64, Uint64Schema, Uint8, Uint8Schema, Uint96, Uint96Schema, UintSchema };

dist/index.js

@@ -1,32 +0,32 @@
-import { addressSchema } from "./address.js";
-import { addressesSchema } from "./addresses.js";
-import { byteSchema } from "./byte.js";
-import { bytesSchema } from "./bytes.js";
-import { bytes4Schema } from "./bytes-4.js";
-import { bytes8Schema } from "./bytes-8.js";
-import { bytes32Schema } from "./bytes-32.js";
-import { bytes48Schema } from "./bytes-48.js";
-import { bytes64Schema } from "./bytes-64.js";
-import { bytes65Schema } from "./bytes-65.js";
-import { bytes256Schema } from "./bytes-256.js";
-import { bytesMax32Schema } from "./bytes-max-32.js";
-import { hash32Schema } from "./hash-32.js";
-import { notFoundSchema } from "./not-found.js";
-import { ratioSchema } from "./ratio.js";
-import { uintSchema } from "./uint.js";
-import { uint8Schema } from "./uint-8.js";
-import { uint16Schema } from "./uint-16.js";
-import { uint24Schema } from "./uint-24.js";
-import { uint32Schema } from "./uint-32.js";
-import { uint40Schema } from "./uint-40.js";
-import { uint48Schema } from "./uint-48.js";
-import { uint56Schema } from "./uint-56.js";
-import { uint64Schema } from "./uint-64.js";
-import { uint96Schema } from "./uint-96.js";
-import { uint128Schema } from "./uint-128.js";
-import { uint160Schema } from "./uint-160.js";
-import { uint192Schema } from "./uint-192.js";
-import { uint224Schema } from "./uint-224.js";
-import { uint256Schema } from "./uint-256.js";
+import { AddressSchema } from "./address.js";
+import { AddressesSchema } from "./addresses.js";
+import { ByteSchema } from "./byte.js";
+import { BytesSchema } from "./bytes.js";
+import { Bytes4Schema } from "./bytes-4.js";
+import { Bytes8Schema } from "./bytes-8.js";
+import { Bytes32Schema } from "./bytes-32.js";
+import { Bytes48Schema } from "./bytes-48.js";
+import { Bytes64Schema } from "./bytes-64.js";
+import { Bytes65Schema } from "./bytes-65.js";
+import { Bytes256Schema } from "./bytes-256.js";
+import { BytesMax32Schema } from "./bytes-max-32.js";
+import { Hash32Schema } from "./hash-32.js";
+import { NotFoundSchema } from "./not-found.js";
+import { RatioSchema } from "./ratio.js";
+import { UintSchema } from "./uint.js";
+import { Uint8Schema } from "./uint-8.js";
+import { Uint16Schema } from "./uint-16.js";
+import { Uint24Schema } from "./uint-24.js";
+import { Uint32Schema } from "./uint-32.js";
+import { Uint40Schema } from "./uint-40.js";
+import { Uint48Schema } from "./uint-48.js";
+import { Uint56Schema } from "./uint-56.js";
+import { Uint64Schema } from "./uint-64.js";
+import { Uint96Schema } from "./uint-96.js";
+import { Uint128Schema } from "./uint-128.js";
+import { Uint160Schema } from "./uint-160.js";
+import { Uint192Schema } from "./uint-192.js";
+import { Uint224Schema } from "./uint-224.js";
+import { Uint256Schema } from "./uint-256.js";
 
-export { addressSchema, addressesSchema, byteSchema, bytes256Schema, bytes32Schema, bytes48Schema, bytes4Schema, bytes64Schema, bytes65Schema, bytes8Schema, bytesMax32Schema, bytesSchema, hash32Schema, notFoundSchema, ratioSchema, uint128Schema, uint160Schema, uint16Schema, uint192Schema, uint224Schema, uint24Schema, uint256Schema, uint32Schema, uint40Schema, uint48Schema, uint56Schema, uint64Schema, uint8Schema, uint96Schema, uintSchema };
+export { AddressSchema, AddressesSchema, ByteSchema, Bytes256Schema, Bytes32Schema, Bytes48Schema, Bytes4Schema, Bytes64Schema, Bytes65Schema, Bytes8Schema, BytesMax32Schema, BytesSchema, Hash32Schema, NotFoundSchema, RatioSchema, Uint128Schema, Uint160Schema, Uint16Schema, Uint192Schema, Uint224Schema, Uint24Schema, Uint256Schema, Uint32Schema, Uint40Schema, Uint48Schema, Uint56Schema, Uint64Schema, Uint8Schema, Uint96Schema, UintSchema };

dist/not-found.d.ts

@@ -1,9 +0,9 @@
-import * as valibot22 from "valibot";
+import * as valibot32 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/not-found.d.ts
-declare const notFoundSchema: valibot22.NullSchema<undefined>;
-type NotFound = InferOutput<typeof notFoundSchema>;
+declare const NotFoundSchema: valibot32.NullSchema<undefined>;
+type NotFound = InferOutput<typeof NotFoundSchema>;
 //#endregion
-export { NotFound, notFoundSchema };
+export { NotFound, NotFoundSchema };
 //# sourceMappingURL=not-found.d.ts.map

dist/not-found.js

 import { null_ } from "valibot";
 
 //#region src/not-found.ts
-const notFoundSchema = null_();
+const NotFoundSchema = null_();
 
 //#endregion
-export { notFoundSchema };
+export { NotFoundSchema };
 //# sourceMappingURL=not-found.js.map

dist/not-found.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"not-found.js","names":[],"sources":["../src/not-found.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { null_ } from \"valibot\"\n\nexport const notFoundSchema = null_()\nexport type NotFound = InferOutput<typeof notFoundSchema>\n"],"mappings":";;;AAGA,MAAa,iBAAiB,MAAM"}
+{"version":3,"file":"not-found.js","names":[],"sources":["../src/not-found.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { null_ } from \"valibot\"\n\nexport const NotFoundSchema = null_()\nexport type NotFound = InferOutput<typeof NotFoundSchema>\n"],"mappings":";;;AAGA,MAAa,iBAAiB,MAAM"}

dist/ratio.d.ts

@@ -1,9 +0,9 @@
-import * as valibot18 from "valibot";
+import * as valibot36 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/ratio.d.ts
-declare const ratioSchema: valibot18.SchemaWithPipe<readonly [valibot18.NumberSchema<undefined>, valibot18.MinValueAction<number, 0, undefined>, valibot18.MaxValueAction<number, 1, undefined>]>;
-type Ratio = InferOutput<typeof ratioSchema>;
+declare const RatioSchema: valibot36.SchemaWithPipe<readonly [valibot36.NumberSchema<undefined>, valibot36.MinValueAction<number, 0, undefined>, valibot36.MaxValueAction<number, 1, undefined>]>;
+type Ratio = InferOutput<typeof RatioSchema>;
 //#endregion
-export { Ratio, ratioSchema };
+export { Ratio, RatioSchema };
 //# sourceMappingURL=ratio.d.ts.map

dist/ratio.js

 import { maxValue, minValue, number, pipe } from "valibot";
 
 //#region src/ratio.ts
-const ratioSchema = pipe(number(), minValue(0), maxValue(1));
+const RatioSchema = pipe(number(), minValue(0), maxValue(1));
 
 //#endregion
-export { ratioSchema };
+export { RatioSchema };
 //# sourceMappingURL=ratio.js.map

dist/ratio.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"ratio.js","names":[],"sources":["../src/ratio.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { maxValue, minValue, number, pipe } from \"valibot\"\n\nexport const ratioSchema = pipe(\n  number(),\n  minValue(0),\n  maxValue(1),\n)\nexport type Ratio = InferOutput<typeof ratioSchema>\n"],"mappings":";;;AAGA,MAAa,cAAc,KACzB,OAAO,GACP,SAAS,CAAC,GACV,SAAS,CAAC,CACZ"}
+{"version":3,"file":"ratio.js","names":[],"sources":["../src/ratio.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { maxValue, minValue, number, pipe } from \"valibot\"\n\nexport const RatioSchema = pipe(\n  number(),\n  minValue(0),\n  maxValue(1),\n)\nexport type Ratio = InferOutput<typeof RatioSchema>\n"],"mappings":";;;AAGA,MAAa,cAAc,KACzB,OAAO,GACP,SAAS,CAAC,GACV,SAAS,CAAC,CACZ"}

dist/uint-128.d.ts

@@ -1,9 +0,9 @@
-import * as valibot63 from "valibot";
+import * as valibot84 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/uint-128.d.ts
-declare const uint128Schema: valibot63.SchemaWithPipe<readonly [valibot63.CustomSchema<`0x${string}`, valibot63.ErrorMessage<valibot63.CustomIssue> | undefined>, valibot63.BrandAction<`0x${string}`, "Uint128">]>;
-type Uint128 = InferOutput<typeof uint128Schema>;
+declare const Uint128Schema: valibot84.SchemaWithPipe<readonly [valibot84.CustomSchema<`0x${string}`, valibot84.ErrorMessage<valibot84.CustomIssue> | undefined>, valibot84.BrandAction<`0x${string}`, "Uint128">]>;
+type Uint128 = InferOutput<typeof Uint128Schema>;
 //#endregion
-export { Uint128, uint128Schema };
+export { Uint128, Uint128Schema };
 //# sourceMappingURL=uint-128.d.ts.map

dist/uint-128.js

@@ -9,6 +9,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const uint128Schema = pipe(custom(isUint128, "uint128"), brand("Uint128"));
+const Uint128Schema = pipe(custom(isUint128, "uint128"), brand("Uint128"));
 
 //#endregion
-export { uint128Schema };
+export { Uint128Schema };
 //# sourceMappingURL=uint-128.js.map

dist/uint-128.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-128.js","names":[],"sources":["../src/uint-128.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint128(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 128n) - 1n\n}\nexport const uint128Schema = pipe(\n  custom<`0x${string}`>(isUint128, \"uint128\"),\n  brand(\"Uint128\"),\n)\nexport type Uint128 = InferOutput<typeof uint128Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,QAAQ;AACzC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,WAAW,SAAS,GAC1C,MAAM,SAAS,CACjB"}
+{"version":3,"file":"uint-128.js","names":[],"sources":["../src/uint-128.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint128(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 128n) - 1n\n}\nexport const Uint128Schema = pipe(\n  custom<`0x${string}`>(isUint128, \"uint128\"),\n  brand(\"Uint128\"),\n)\nexport type Uint128 = InferOutput<typeof Uint128Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,QAAQ;AACzC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,WAAW,SAAS,GAC1C,MAAM,SAAS,CACjB"}

dist/uint-16.d.ts

@@ -1,9 +0,9 @@
-import * as valibot94 from "valibot";
+import * as valibot69 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/uint-16.d.ts
-declare const uint16Schema: valibot94.SchemaWithPipe<readonly [valibot94.CustomSchema<`0x${string}`, valibot94.ErrorMessage<valibot94.CustomIssue> | undefined>, valibot94.BrandAction<`0x${string}`, "Uint16">]>;
-type Uint16 = InferOutput<typeof uint16Schema>;
+declare const Uint16Schema: valibot69.SchemaWithPipe<readonly [valibot69.CustomSchema<`0x${string}`, valibot69.ErrorMessage<valibot69.CustomIssue> | undefined>, valibot69.BrandAction<`0x${string}`, "Uint16">]>;
+type Uint16 = InferOutput<typeof Uint16Schema>;
 //#endregion
-export { Uint16, uint16Schema };
+export { Uint16, Uint16Schema };
 //# sourceMappingURL=uint-16.d.ts.map

dist/uint-16.js

@@ -9,6 +9,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const uint16Schema = pipe(custom(isUint16, "uint16"), brand("Uint16"));
+const Uint16Schema = pipe(custom(isUint16, "uint16"), brand("Uint16"));
 
 //#endregion
-export { uint16Schema };
+export { Uint16Schema };
 //# sourceMappingURL=uint-16.js.map

dist/uint-16.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-16.js","names":[],"sources":["../src/uint-16.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint16(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 16n) - 1n\n}\nexport const uint16Schema = pipe(\n  custom<`0x${string}`>(isUint16, \"uint16\"),\n  brand(\"Uint16\"),\n)\nexport type Uint16 = InferOutput<typeof uint16Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}
+{"version":3,"file":"uint-16.js","names":[],"sources":["../src/uint-16.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint16(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 16n) - 1n\n}\nexport const Uint16Schema = pipe(\n  custom<`0x${string}`>(isUint16, \"uint16\"),\n  brand(\"Uint16\"),\n)\nexport type Uint16 = InferOutput<typeof Uint16Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}

dist/uint-160.d.ts

@@ -1,9 +0,9 @@
-import * as valibot109 from "valibot";
+import * as valibot54 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/uint-160.d.ts
-declare const uint160Schema: valibot109.SchemaWithPipe<readonly [valibot109.CustomSchema<`0x${string}`, valibot109.ErrorMessage<valibot109.CustomIssue> | undefined>, valibot109.BrandAction<`0x${string}`, "Uint160">]>;
-type Uint160 = InferOutput<typeof uint160Schema>;
+declare const Uint160Schema: valibot54.SchemaWithPipe<readonly [valibot54.CustomSchema<`0x${string}`, valibot54.ErrorMessage<valibot54.CustomIssue> | undefined>, valibot54.BrandAction<`0x${string}`, "Uint160">]>;
+type Uint160 = InferOutput<typeof Uint160Schema>;
 //#endregion
-export { Uint160, uint160Schema };
+export { Uint160, Uint160Schema };
 //# sourceMappingURL=uint-160.d.ts.map

dist/uint-160.d.ts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-160.d.ts","names":[],"sources":["../src/uint-160.ts"],"mappings":";;;;cAQa,eAAa,UAAA,CAAA,yBAAA,UAAA,CAAA,4BAAA,UAAA,CAAA,aAGzB,UAAA,CAHyB,WAAA,gBAAA,UAAA,CAAA;KAId,OAAA,GAAU,mBAAmB"}
+{"version":3,"file":"uint-160.d.ts","names":[],"sources":["../src/uint-160.ts"],"mappings":";;;;cAQa,eAAa,SAAA,CAAA,yBAAA,SAAA,CAAA,4BAAA,SAAA,CAAA,aAGzB,SAAA,CAHyB,WAAA,gBAAA,SAAA,CAAA;KAId,OAAA,GAAU,mBAAmB"}

dist/uint-160.js

@@ -9,6 +9,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const uint160Schema = pipe(custom(isUint160, "uint160"), brand("Uint160"));
+const Uint160Schema = pipe(custom(isUint160, "uint160"), brand("Uint160"));
 
 //#endregion
-export { uint160Schema };
+export { Uint160Schema };
 //# sourceMappingURL=uint-160.js.map

dist/uint-160.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-160.js","names":[],"sources":["../src/uint-160.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint160(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 160n) - 1n\n}\nexport const uint160Schema = pipe(\n  custom<`0x${string}`>(isUint160, \"uint160\"),\n  brand(\"Uint160\"),\n)\nexport type Uint160 = InferOutput<typeof uint160Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,QAAQ;AACzC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,WAAW,SAAS,GAC1C,MAAM,SAAS,CACjB"}
+{"version":3,"file":"uint-160.js","names":[],"sources":["../src/uint-160.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint160(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 160n) - 1n\n}\nexport const Uint160Schema = pipe(\n  custom<`0x${string}`>(isUint160, \"uint160\"),\n  brand(\"Uint160\"),\n)\nexport type Uint160 = InferOutput<typeof Uint160Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,QAAQ;AACzC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,WAAW,SAAS,GAC1C,MAAM,SAAS,CACjB"}

dist/uint-192.d.ts

@@ -1,9 +0,9 @@
-import * as valibot114 from "valibot";
+import * as valibot79 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/uint-192.d.ts
-declare const uint192Schema: valibot114.SchemaWithPipe<readonly [valibot114.CustomSchema<`0x${string}`, valibot114.ErrorMessage<valibot114.CustomIssue> | undefined>, valibot114.BrandAction<`0x${string}`, "Uint192">]>;
-type Uint192 = InferOutput<typeof uint192Schema>;
+declare const Uint192Schema: valibot79.SchemaWithPipe<readonly [valibot79.CustomSchema<`0x${string}`, valibot79.ErrorMessage<valibot79.CustomIssue> | undefined>, valibot79.BrandAction<`0x${string}`, "Uint192">]>;
+type Uint192 = InferOutput<typeof Uint192Schema>;
 //#endregion
-export { Uint192, uint192Schema };
+export { Uint192, Uint192Schema };
 //# sourceMappingURL=uint-192.d.ts.map

dist/uint-192.d.ts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-192.d.ts","names":[],"sources":["../src/uint-192.ts"],"mappings":";;;;cAQa,eAAa,UAAA,CAAA,yBAAA,UAAA,CAAA,4BAAA,UAAA,CAAA,aAGzB,UAAA,CAHyB,WAAA,gBAAA,UAAA,CAAA;KAId,OAAA,GAAU,mBAAmB"}
+{"version":3,"file":"uint-192.d.ts","names":[],"sources":["../src/uint-192.ts"],"mappings":";;;;cAQa,eAAa,SAAA,CAAA,yBAAA,SAAA,CAAA,4BAAA,SAAA,CAAA,aAGzB,SAAA,CAHyB,WAAA,gBAAA,SAAA,CAAA;KAId,OAAA,GAAU,mBAAmB"}

dist/uint-192.js

@@ -9,6 +9,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const uint192Schema = pipe(custom(isUint192, "uint192"), brand("Uint192"));
+const Uint192Schema = pipe(custom(isUint192, "uint192"), brand("Uint192"));
 
 //#endregion
-export { uint192Schema };
+export { Uint192Schema };
 //# sourceMappingURL=uint-192.js.map

dist/uint-192.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-192.js","names":[],"sources":["../src/uint-192.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint192(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 192n) - 1n\n}\nexport const uint192Schema = pipe(\n  custom<`0x${string}`>(isUint192, \"uint192\"),\n  brand(\"Uint192\"),\n)\nexport type Uint192 = InferOutput<typeof uint192Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,QAAQ;AACzC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,WAAW,SAAS,GAC1C,MAAM,SAAS,CACjB"}
+{"version":3,"file":"uint-192.js","names":[],"sources":["../src/uint-192.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint192(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 192n) - 1n\n}\nexport const Uint192Schema = pipe(\n  custom<`0x${string}`>(isUint192, \"uint192\"),\n  brand(\"Uint192\"),\n)\nexport type Uint192 = InferOutput<typeof Uint192Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,QAAQ;AACzC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,WAAW,SAAS,GAC1C,MAAM,SAAS,CACjB"}

dist/uint-224.d.ts

@@ -1,9 +0,9 @@
-import * as valibot104 from "valibot";
+import * as valibot89 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/uint-224.d.ts
-declare const uint224Schema: valibot104.SchemaWithPipe<readonly [valibot104.CustomSchema<`0x${string}`, valibot104.ErrorMessage<valibot104.CustomIssue> | undefined>, valibot104.BrandAction<`0x${string}`, "Uint224">]>;
-type Uint224 = InferOutput<typeof uint224Schema>;
+declare const Uint224Schema: valibot89.SchemaWithPipe<readonly [valibot89.CustomSchema<`0x${string}`, valibot89.ErrorMessage<valibot89.CustomIssue> | undefined>, valibot89.BrandAction<`0x${string}`, "Uint224">]>;
+type Uint224 = InferOutput<typeof Uint224Schema>;
 //#endregion
-export { Uint224, uint224Schema };
+export { Uint224, Uint224Schema };
 //# sourceMappingURL=uint-224.d.ts.map

dist/uint-224.d.ts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-224.d.ts","names":[],"sources":["../src/uint-224.ts"],"mappings":";;;;cAQa,eAAa,UAAA,CAAA,yBAAA,UAAA,CAAA,4BAAA,UAAA,CAAA,aAGzB,UAAA,CAHyB,WAAA,gBAAA,UAAA,CAAA;KAId,OAAA,GAAU,mBAAmB"}
+{"version":3,"file":"uint-224.d.ts","names":[],"sources":["../src/uint-224.ts"],"mappings":";;;;cAQa,eAAa,SAAA,CAAA,yBAAA,SAAA,CAAA,4BAAA,SAAA,CAAA,aAGzB,SAAA,CAHyB,WAAA,gBAAA,SAAA,CAAA;KAId,OAAA,GAAU,mBAAmB"}

dist/uint-224.js

@@ -9,6 +9,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const uint224Schema = pipe(custom(isUint224, "uint224"), brand("Uint224"));
+const Uint224Schema = pipe(custom(isUint224, "uint224"), brand("Uint224"));
 
 //#endregion
-export { uint224Schema };
+export { Uint224Schema };
 //# sourceMappingURL=uint-224.js.map

dist/uint-224.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-224.js","names":[],"sources":["../src/uint-224.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint224(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 224n) - 1n\n}\nexport const uint224Schema = pipe(\n  custom<`0x${string}`>(isUint224, \"uint224\"),\n  brand(\"Uint224\"),\n)\nexport type Uint224 = InferOutput<typeof uint224Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,QAAQ;AACzC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,WAAW,SAAS,GAC1C,MAAM,SAAS,CACjB"}
+{"version":3,"file":"uint-224.js","names":[],"sources":["../src/uint-224.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint224(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 224n) - 1n\n}\nexport const Uint224Schema = pipe(\n  custom<`0x${string}`>(isUint224, \"uint224\"),\n  brand(\"Uint224\"),\n)\nexport type Uint224 = InferOutput<typeof Uint224Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,QAAQ;AACzC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,WAAW,SAAS,GAC1C,MAAM,SAAS,CACjB"}

dist/uint-24.d.ts

@@ -1,9 +0,9 @@
-import * as valibot47 from "valibot";
+import * as valibot94 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/uint-24.d.ts
-declare const uint24Schema: valibot47.SchemaWithPipe<readonly [valibot47.CustomSchema<`0x${string}`, valibot47.ErrorMessage<valibot47.CustomIssue> | undefined>, valibot47.BrandAction<`0x${string}`, "Uint24">]>;
-type Uint24 = InferOutput<typeof uint24Schema>;
+declare const Uint24Schema: valibot94.SchemaWithPipe<readonly [valibot94.CustomSchema<`0x${string}`, valibot94.ErrorMessage<valibot94.CustomIssue> | undefined>, valibot94.BrandAction<`0x${string}`, "Uint24">]>;
+type Uint24 = InferOutput<typeof Uint24Schema>;
 //#endregion
-export { Uint24, uint24Schema };
+export { Uint24, Uint24Schema };
 //# sourceMappingURL=uint-24.d.ts.map

dist/uint-24.js

@@ -9,6 +9,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const uint24Schema = pipe(custom(isUint24, "uint24"), brand("Uint24"));
+const Uint24Schema = pipe(custom(isUint24, "uint24"), brand("Uint24"));
 
 //#endregion
-export { uint24Schema };
+export { Uint24Schema };
 //# sourceMappingURL=uint-24.js.map

dist/uint-24.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-24.js","names":[],"sources":["../src/uint-24.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint24(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 24n) - 1n\n}\nexport const uint24Schema = pipe(\n  custom<`0x${string}`>(isUint24, \"uint24\"),\n  brand(\"Uint24\"),\n)\nexport type Uint24 = InferOutput<typeof uint24Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}
+{"version":3,"file":"uint-24.js","names":[],"sources":["../src/uint-24.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint24(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 24n) - 1n\n}\nexport const Uint24Schema = pipe(\n  custom<`0x${string}`>(isUint24, \"uint24\"),\n  brand(\"Uint24\"),\n)\nexport type Uint24 = InferOutput<typeof Uint24Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}

dist/uint-256.d.ts

@@ -1,9 +0,9 @@
-import * as valibot99 from "valibot";
+import * as valibot5 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/uint-256.d.ts
-declare const uint256Schema: valibot99.SchemaWithPipe<readonly [valibot99.CustomSchema<`0x${string}`, valibot99.ErrorMessage<valibot99.CustomIssue> | undefined>, valibot99.BrandAction<`0x${string}`, "Uint256">]>;
-type Uint256 = InferOutput<typeof uint256Schema>;
+declare const Uint256Schema: valibot5.SchemaWithPipe<readonly [valibot5.CustomSchema<`0x${string}`, valibot5.ErrorMessage<valibot5.CustomIssue> | undefined>, valibot5.BrandAction<`0x${string}`, "Uint256">]>;
+type Uint256 = InferOutput<typeof Uint256Schema>;
 //#endregion
-export { Uint256, uint256Schema };
+export { Uint256, Uint256Schema };
 //# sourceMappingURL=uint-256.d.ts.map

dist/uint-256.d.ts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-256.d.ts","names":[],"sources":["../src/uint-256.ts"],"mappings":";;;;cASa,eAAa,SAAA,CAAA,yBAAA,SAAA,CAAA,4BAAA,SAAA,CAAA,aAGzB,SAAA,CAHyB,WAAA,gBAAA,SAAA,CAAA;KAId,OAAA,GAAU,mBAAmB"}
+{"version":3,"file":"uint-256.d.ts","names":[],"sources":["../src/uint-256.ts"],"mappings":";;;;cASa,eAAa,QAAA,CAAA,yBAAA,QAAA,CAAA,4BAAA,QAAA,CAAA,aAGzB,QAAA,CAHyB,WAAA,gBAAA,QAAA,CAAA;KAId,OAAA,GAAU,mBAAmB"}

dist/uint-256.js

@@ -7,6 +7,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const uint256Schema = pipe(custom(isUint256, "uint256"), brand("Uint256"));
+const Uint256Schema = pipe(custom(isUint256, "uint256"), brand("Uint256"));
 
 //#endregion
-export { uint256Schema };
+export { Uint256Schema };
 //# sourceMappingURL=uint-256.js.map

dist/uint-256.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-256.js","names":[],"sources":["../src/uint-256.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint256(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{1,64}$/.test(input)\n  )\n}\nexport const uint256Schema = pipe(\n  custom<`0x${string}`>(isUint256, \"uint256\"),\n  brand(\"Uint256\"),\n)\nexport type Uint256 = InferOutput<typeof uint256Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,OACE,OAAO,UAAU,YACjB,qBAAqB,KAAK,KAAK;AAEnC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,WAAW,SAAS,GAC1C,MAAM,SAAS,CACjB"}
+{"version":3,"file":"uint-256.js","names":[],"sources":["../src/uint-256.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint256(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x[0-9a-f]{1,64}$/.test(input)\n  )\n}\nexport const Uint256Schema = pipe(\n  custom<`0x${string}`>(isUint256, \"uint256\"),\n  brand(\"Uint256\"),\n)\nexport type Uint256 = InferOutput<typeof Uint256Schema>\n"],"mappings":";;;AAGA,SAAS,UAAU,OAAyB;CAC1C,OACE,OAAO,UAAU,YACjB,qBAAqB,KAAK,KAAK;AAEnC;AACA,MAAa,gBAAgB,KAC3B,OAAsB,WAAW,SAAS,GAC1C,MAAM,SAAS,CACjB"}

dist/uint-32.d.ts

@@ -1,9 +0,9 @@
-import * as valibot31 from "valibot";
+import * as valibot114 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/uint-32.d.ts
-declare const uint32Schema: valibot31.SchemaWithPipe<readonly [valibot31.CustomSchema<`0x${string}`, valibot31.ErrorMessage<valibot31.CustomIssue> | undefined>, valibot31.BrandAction<`0x${string}`, "Uint32">]>;
-type Uint32 = InferOutput<typeof uint32Schema>;
+declare const Uint32Schema: valibot114.SchemaWithPipe<readonly [valibot114.CustomSchema<`0x${string}`, valibot114.ErrorMessage<valibot114.CustomIssue> | undefined>, valibot114.BrandAction<`0x${string}`, "Uint32">]>;
+type Uint32 = InferOutput<typeof Uint32Schema>;
 //#endregion
-export { Uint32, uint32Schema };
+export { Uint32, Uint32Schema };
 //# sourceMappingURL=uint-32.d.ts.map

dist/uint-32.d.ts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-32.d.ts","names":[],"sources":["../src/uint-32.ts"],"mappings":";;;;cAQa,cAAY,SAAA,CAAA,yBAAA,SAAA,CAAA,4BAAA,SAAA,CAAA,aAGxB,SAAA,CAHwB,WAAA,gBAAA,SAAA,CAAA;KAIb,MAAA,GAAS,mBAAmB"}
+{"version":3,"file":"uint-32.d.ts","names":[],"sources":["../src/uint-32.ts"],"mappings":";;;;cAQa,cAAY,UAAA,CAAA,yBAAA,UAAA,CAAA,4BAAA,UAAA,CAAA,aAGxB,UAAA,CAHwB,WAAA,gBAAA,UAAA,CAAA;KAIb,MAAA,GAAS,mBAAmB"}

dist/uint-32.js

@@ -9,6 +9,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const uint32Schema = pipe(custom(isUint32, "uint32"), brand("Uint32"));
+const Uint32Schema = pipe(custom(isUint32, "uint32"), brand("Uint32"));
 
 //#endregion
-export { uint32Schema };
+export { Uint32Schema };
 //# sourceMappingURL=uint-32.js.map

dist/uint-32.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-32.js","names":[],"sources":["../src/uint-32.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint32(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 32n) - 1n\n}\nexport const uint32Schema = pipe(\n  custom<`0x${string}`>(isUint32, \"uint32\"),\n  brand(\"Uint32\"),\n)\nexport type Uint32 = InferOutput<typeof uint32Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}
+{"version":3,"file":"uint-32.js","names":[],"sources":["../src/uint-32.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint32(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 32n) - 1n\n}\nexport const Uint32Schema = pipe(\n  custom<`0x${string}`>(isUint32, \"uint32\"),\n  brand(\"Uint32\"),\n)\nexport type Uint32 = InferOutput<typeof Uint32Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}

dist/uint-40.d.ts

@@ -1,9 +0,9 @@
-import * as valibot71 from "valibot";
+import * as valibot99 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/uint-40.d.ts
-declare const uint40Schema: valibot71.SchemaWithPipe<readonly [valibot71.CustomSchema<`0x${string}`, valibot71.ErrorMessage<valibot71.CustomIssue> | undefined>, valibot71.BrandAction<`0x${string}`, "Uint40">]>;
-type Uint40 = InferOutput<typeof uint40Schema>;
+declare const Uint40Schema: valibot99.SchemaWithPipe<readonly [valibot99.CustomSchema<`0x${string}`, valibot99.ErrorMessage<valibot99.CustomIssue> | undefined>, valibot99.BrandAction<`0x${string}`, "Uint40">]>;
+type Uint40 = InferOutput<typeof Uint40Schema>;
 //#endregion
-export { Uint40, uint40Schema };
+export { Uint40, Uint40Schema };
 //# sourceMappingURL=uint-40.d.ts.map

dist/uint-40.js

@@ -9,6 +9,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const uint40Schema = pipe(custom(isUint40, "uint40"), brand("Uint40"));
+const Uint40Schema = pipe(custom(isUint40, "uint40"), brand("Uint40"));
 
 //#endregion
-export { uint40Schema };
+export { Uint40Schema };
 //# sourceMappingURL=uint-40.js.map

dist/uint-40.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-40.js","names":[],"sources":["../src/uint-40.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint40(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 40n) - 1n\n}\nexport const uint40Schema = pipe(\n  custom<`0x${string}`>(isUint40, \"uint40\"),\n  brand(\"Uint40\"),\n)\nexport type Uint40 = InferOutput<typeof uint40Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}
+{"version":3,"file":"uint-40.js","names":[],"sources":["../src/uint-40.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint40(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 40n) - 1n\n}\nexport const Uint40Schema = pipe(\n  custom<`0x${string}`>(isUint40, \"uint40\"),\n  brand(\"Uint40\"),\n)\nexport type Uint40 = InferOutput<typeof Uint40Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}

dist/uint-48.d.ts

@@ -1,9 +0,9 @@
-import * as valibot84 from "valibot";
+import * as valibot109 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/uint-48.d.ts
-declare const uint48Schema: valibot84.SchemaWithPipe<readonly [valibot84.CustomSchema<`0x${string}`, valibot84.ErrorMessage<valibot84.CustomIssue> | undefined>, valibot84.BrandAction<`0x${string}`, "Uint48">]>;
-type Uint48 = InferOutput<typeof uint48Schema>;
+declare const Uint48Schema: valibot109.SchemaWithPipe<readonly [valibot109.CustomSchema<`0x${string}`, valibot109.ErrorMessage<valibot109.CustomIssue> | undefined>, valibot109.BrandAction<`0x${string}`, "Uint48">]>;
+type Uint48 = InferOutput<typeof Uint48Schema>;
 //#endregion
-export { Uint48, uint48Schema };
+export { Uint48, Uint48Schema };
 //# sourceMappingURL=uint-48.d.ts.map

dist/uint-48.d.ts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-48.d.ts","names":[],"sources":["../src/uint-48.ts"],"mappings":";;;;cAQa,cAAY,SAAA,CAAA,yBAAA,SAAA,CAAA,4BAAA,SAAA,CAAA,aAGxB,SAAA,CAHwB,WAAA,gBAAA,SAAA,CAAA;KAIb,MAAA,GAAS,mBAAmB"}
+{"version":3,"file":"uint-48.d.ts","names":[],"sources":["../src/uint-48.ts"],"mappings":";;;;cAQa,cAAY,UAAA,CAAA,yBAAA,UAAA,CAAA,4BAAA,UAAA,CAAA,aAGxB,UAAA,CAHwB,WAAA,gBAAA,UAAA,CAAA;KAIb,MAAA,GAAS,mBAAmB"}

dist/uint-48.js

@@ -9,6 +9,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const uint48Schema = pipe(custom(isUint48, "uint48"), brand("Uint48"));
+const Uint48Schema = pipe(custom(isUint48, "uint48"), brand("Uint48"));
 
 //#endregion
-export { uint48Schema };
+export { Uint48Schema };
 //# sourceMappingURL=uint-48.js.map

dist/uint-48.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-48.js","names":[],"sources":["../src/uint-48.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint48(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 48n) - 1n\n}\nexport const uint48Schema = pipe(\n  custom<`0x${string}`>(isUint48, \"uint48\"),\n  brand(\"Uint48\"),\n)\nexport type Uint48 = InferOutput<typeof uint48Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}
+{"version":3,"file":"uint-48.js","names":[],"sources":["../src/uint-48.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint48(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 48n) - 1n\n}\nexport const Uint48Schema = pipe(\n  custom<`0x${string}`>(isUint48, \"uint48\"),\n  brand(\"Uint48\"),\n)\nexport type Uint48 = InferOutput<typeof Uint48Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}

dist/uint-56.d.ts

@@ -1,9 +0,9 @@
-import * as valibot89 from "valibot";
+import * as valibot59 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/uint-56.d.ts
-declare const uint56Schema: valibot89.SchemaWithPipe<readonly [valibot89.CustomSchema<`0x${string}`, valibot89.ErrorMessage<valibot89.CustomIssue> | undefined>, valibot89.BrandAction<`0x${string}`, "Uint56">]>;
-type Uint56 = InferOutput<typeof uint56Schema>;
+declare const Uint56Schema: valibot59.SchemaWithPipe<readonly [valibot59.CustomSchema<`0x${string}`, valibot59.ErrorMessage<valibot59.CustomIssue> | undefined>, valibot59.BrandAction<`0x${string}`, "Uint56">]>;
+type Uint56 = InferOutput<typeof Uint56Schema>;
 //#endregion
-export { Uint56, uint56Schema };
+export { Uint56, Uint56Schema };
 //# sourceMappingURL=uint-56.d.ts.map

dist/uint-56.js

@@ -9,6 +9,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const uint56Schema = pipe(custom(isUint56, "uint56"), brand("Uint56"));
+const Uint56Schema = pipe(custom(isUint56, "uint56"), brand("Uint56"));
 
 //#endregion
-export { uint56Schema };
+export { Uint56Schema };
 //# sourceMappingURL=uint-56.js.map

dist/uint-56.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-56.js","names":[],"sources":["../src/uint-56.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint56(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 56n) - 1n\n}\nexport const uint56Schema = pipe(\n  custom<`0x${string}`>(isUint56, \"uint56\"),\n  brand(\"Uint56\"),\n)\nexport type Uint56 = InferOutput<typeof uint56Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}
+{"version":3,"file":"uint-56.js","names":[],"sources":["../src/uint-56.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint56(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 56n) - 1n\n}\nexport const Uint56Schema = pipe(\n  custom<`0x${string}`>(isUint56, \"uint56\"),\n  brand(\"Uint56\"),\n)\nexport type Uint56 = InferOutput<typeof Uint56Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}

dist/uint-64.d.ts

@@ -1,9 +0,9 @@
-import * as valibot58 from "valibot";
+import * as valibot104 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/uint-64.d.ts
-declare const uint64Schema: valibot58.SchemaWithPipe<readonly [valibot58.CustomSchema<`0x${string}`, valibot58.ErrorMessage<valibot58.CustomIssue> | undefined>, valibot58.BrandAction<`0x${string}`, "Uint64">]>;
-type Uint64 = InferOutput<typeof uint64Schema>;
+declare const Uint64Schema: valibot104.SchemaWithPipe<readonly [valibot104.CustomSchema<`0x${string}`, valibot104.ErrorMessage<valibot104.CustomIssue> | undefined>, valibot104.BrandAction<`0x${string}`, "Uint64">]>;
+type Uint64 = InferOutput<typeof Uint64Schema>;
 //#endregion
-export { Uint64, uint64Schema };
+export { Uint64, Uint64Schema };
 //# sourceMappingURL=uint-64.d.ts.map

dist/uint-64.d.ts.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-64.d.ts","names":[],"sources":["../src/uint-64.ts"],"mappings":";;;;cAQa,cAAY,SAAA,CAAA,yBAAA,SAAA,CAAA,4BAAA,SAAA,CAAA,aAGxB,SAAA,CAHwB,WAAA,gBAAA,SAAA,CAAA;KAIb,MAAA,GAAS,mBAAmB"}
+{"version":3,"file":"uint-64.d.ts","names":[],"sources":["../src/uint-64.ts"],"mappings":";;;;cAQa,cAAY,UAAA,CAAA,yBAAA,UAAA,CAAA,4BAAA,UAAA,CAAA,aAGxB,UAAA,CAHwB,WAAA,gBAAA,UAAA,CAAA;KAIb,MAAA,GAAS,mBAAmB"}

dist/uint-64.js

@@ -9,6 +9,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const uint64Schema = pipe(custom(isUint64, "uint64"), brand("Uint64"));
+const Uint64Schema = pipe(custom(isUint64, "uint64"), brand("Uint64"));
 
 //#endregion
-export { uint64Schema };
+export { Uint64Schema };
 //# sourceMappingURL=uint-64.js.map

dist/uint-64.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-64.js","names":[],"sources":["../src/uint-64.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint64(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 64n) - 1n\n}\nexport const uint64Schema = pipe(\n  custom<`0x${string}`>(isUint64, \"uint64\"),\n  brand(\"Uint64\"),\n)\nexport type Uint64 = InferOutput<typeof uint64Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}
+{"version":3,"file":"uint-64.js","names":[],"sources":["../src/uint-64.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint64(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 64n) - 1n\n}\nexport const Uint64Schema = pipe(\n  custom<`0x${string}`>(isUint64, \"uint64\"),\n  brand(\"Uint64\"),\n)\nexport type Uint64 = InferOutput<typeof Uint64Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}

dist/uint-8.d.ts

@@ -1,9 +0,9 @@
-import * as valibot26 from "valibot";
+import * as valibot64 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/uint-8.d.ts
-declare const uint8Schema: valibot26.SchemaWithPipe<readonly [valibot26.CustomSchema<`0x${string}`, valibot26.ErrorMessage<valibot26.CustomIssue> | undefined>, valibot26.BrandAction<`0x${string}`, "Uint8">]>;
-type Uint8 = InferOutput<typeof uint8Schema>;
+declare const Uint8Schema: valibot64.SchemaWithPipe<readonly [valibot64.CustomSchema<`0x${string}`, valibot64.ErrorMessage<valibot64.CustomIssue> | undefined>, valibot64.BrandAction<`0x${string}`, "Uint8">]>;
+type Uint8 = InferOutput<typeof Uint8Schema>;
 //#endregion
-export { Uint8, uint8Schema };
+export { Uint8, Uint8Schema };
 //# sourceMappingURL=uint-8.d.ts.map

dist/uint-8.js

@@ -9,6 +9,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const uint8Schema = pipe(custom(isUint8, "uint8"), brand("Uint8"));
+const Uint8Schema = pipe(custom(isUint8, "uint8"), brand("Uint8"));
 
 //#endregion
-export { uint8Schema };
+export { Uint8Schema };
 //# sourceMappingURL=uint-8.js.map

dist/uint-8.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-8.js","names":[],"sources":["../src/uint-8.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint8(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 8n) - 1n\n}\nexport const uint8Schema = pipe(\n  custom<`0x${string}`>(isUint8, \"uint8\"),\n  brand(\"Uint8\"),\n)\nexport type Uint8 = InferOutput<typeof uint8Schema>\n"],"mappings":";;;AAGA,SAAS,QAAQ,OAAyB;CACxC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,MAAM;AACvC;AACA,MAAa,cAAc,KACzB,OAAsB,SAAS,OAAO,GACtC,MAAM,OAAO,CACf"}
+{"version":3,"file":"uint-8.js","names":[],"sources":["../src/uint-8.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint8(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 8n) - 1n\n}\nexport const Uint8Schema = pipe(\n  custom<`0x${string}`>(isUint8, \"uint8\"),\n  brand(\"Uint8\"),\n)\nexport type Uint8 = InferOutput<typeof Uint8Schema>\n"],"mappings":";;;AAGA,SAAS,QAAQ,OAAyB;CACxC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,MAAM;AACvC;AACA,MAAa,cAAc,KACzB,OAAsB,SAAS,OAAO,GACtC,MAAM,OAAO,CACf"}

dist/uint-96.d.ts

@@ -1,9 +0,9 @@
-import * as valibot76 from "valibot";
+import * as valibot74 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/uint-96.d.ts
-declare const uint96Schema: valibot76.SchemaWithPipe<readonly [valibot76.CustomSchema<`0x${string}`, valibot76.ErrorMessage<valibot76.CustomIssue> | undefined>, valibot76.BrandAction<`0x${string}`, "Uint96">]>;
-type Uint96 = InferOutput<typeof uint96Schema>;
+declare const Uint96Schema: valibot74.SchemaWithPipe<readonly [valibot74.CustomSchema<`0x${string}`, valibot74.ErrorMessage<valibot74.CustomIssue> | undefined>, valibot74.BrandAction<`0x${string}`, "Uint96">]>;
+type Uint96 = InferOutput<typeof Uint96Schema>;
 //#endregion
-export { Uint96, uint96Schema };
+export { Uint96, Uint96Schema };
 //# sourceMappingURL=uint-96.d.ts.map

dist/uint-96.js

@@ -9,6 +9,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const uint96Schema = pipe(custom(isUint96, "uint96"), brand("Uint96"));
+const Uint96Schema = pipe(custom(isUint96, "uint96"), brand("Uint96"));
 
 //#endregion
-export { uint96Schema };
+export { Uint96Schema };
 //# sourceMappingURL=uint-96.js.map

dist/uint-96.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint-96.js","names":[],"sources":["../src/uint-96.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint96(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 96n) - 1n\n}\nexport const uint96Schema = pipe(\n  custom<`0x${string}`>(isUint96, \"uint96\"),\n  brand(\"Uint96\"),\n)\nexport type Uint96 = InferOutput<typeof uint96Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}
+{"version":3,"file":"uint-96.js","names":[],"sources":["../src/uint-96.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint96(input: unknown): boolean {\n  if (typeof input !== \"string\") return false\n  if (!/^0x[0-9a-f]{1,64}$/.test(input)) return false\n  return BigInt(input) <= (1n << 96n) - 1n\n}\nexport const Uint96Schema = pipe(\n  custom<`0x${string}`>(isUint96, \"uint96\"),\n  brand(\"Uint96\"),\n)\nexport type Uint96 = InferOutput<typeof Uint96Schema>\n"],"mappings":";;;AAGA,SAAS,SAAS,OAAyB;CACzC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC9C,OAAO,OAAO,KAAK,MAAM,MAAM,OAAO;AACxC;AACA,MAAa,eAAe,KAC1B,OAAsB,UAAU,QAAQ,GACxC,MAAM,QAAQ,CAChB"}

dist/uint.d.ts

@@ -1,9 +0,9 @@
-import * as valibot42 from "valibot";
+import * as valibot43 from "valibot";
 import { InferOutput } from "valibot";
 
 //#region src/uint.d.ts
-declare const uintSchema: valibot42.SchemaWithPipe<readonly [valibot42.CustomSchema<`0x${string}`, valibot42.ErrorMessage<valibot42.CustomIssue> | undefined>, valibot42.BrandAction<`0x${string}`, "Uint">]>;
-type Uint = InferOutput<typeof uintSchema>;
+declare const UintSchema: valibot43.SchemaWithPipe<readonly [valibot43.CustomSchema<`0x${string}`, valibot43.ErrorMessage<valibot43.CustomIssue> | undefined>, valibot43.BrandAction<`0x${string}`, "Uint">]>;
+type Uint = InferOutput<typeof UintSchema>;
 //#endregion
-export { Uint, uintSchema };
+export { Uint, UintSchema };
 //# sourceMappingURL=uint.d.ts.map

dist/uint.js

@@ -7,6 +7,6 @@ import { brand, custom, pipe } from "valibot";
 }
-const uintSchema = pipe(custom(isUint, "uint"), brand("Uint"));
+const UintSchema = pipe(custom(isUint, "uint"), brand("Uint"));
 
 //#endregion
-export { uintSchema };
+export { UintSchema };
 //# sourceMappingURL=uint.js.map

dist/uint.js.map

@@ -1,1 +0,1 @@
-{"version":3,"file":"uint.js","names":[],"sources":["../src/uint.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x([1-9a-f]+[0-9a-f]*|0)$/.test(input)\n  )\n}\nexport const uintSchema = pipe(\n  custom<`0x${string}`>(isUint, \"uint\"),\n  brand(\"Uint\"),\n)\nexport type Uint = InferOutput<typeof uintSchema>\n"],"mappings":";;;AAGA,SAAS,OAAO,OAAyB;CACvC,OACE,OAAO,UAAU,YACjB,6BAA6B,KAAK,KAAK;AAE3C;AACA,MAAa,aAAa,KACxB,OAAsB,QAAQ,MAAM,GACpC,MAAM,MAAM,CACd"}
+{"version":3,"file":"uint.js","names":[],"sources":["../src/uint.ts"],"sourcesContent":["import type { InferOutput } from \"valibot\"\nimport { brand, custom, pipe } from \"valibot\"\n\nfunction isUint(input: unknown): boolean {\n  return (\n    typeof input === \"string\" &&\n    /^0x([1-9a-f]+[0-9a-f]*|0)$/.test(input)\n  )\n}\nexport const UintSchema = pipe(\n  custom<`0x${string}`>(isUint, \"uint\"),\n  brand(\"Uint\"),\n)\nexport type Uint = InferOutput<typeof UintSchema>\n"],"mappings":";;;AAGA,SAAS,OAAO,OAAyB;CACvC,OACE,OAAO,UAAU,YACjB,6BAA6B,KAAK,KAAK;AAE3C;AACA,MAAa,aAAa,KACxB,OAAsB,QAAQ,MAAM,GACpC,MAAM,MAAM,CACd"}

package.json

@@ -5,3 +5,3 @@ {
   "type": "module",
-  "version": "0.0.44",
+  "version": "0.0.46",
   "publishConfig": {
@@ -34,4 +34,5 @@ "access": "public"
     "typecheck": "tsc --noEmit",
-    "test:unit": "vitest"
+    "test:unit": "vitest",
+    "test:integration": "echo no integration tests"
   }
 }

README.md

@@ -32,6 +32,6 @@ [![bundlejs](https://deno.bundlejs.com/badge?q=@ethernauta/core&treeshake=[*])](https://deno.bundlejs.com/?q=@ethernauta/core&treeshake=[*])
 import { parse } from "valibot"
-import { addressSchema } from "@ethernauta/core"
+import { AddressSchema } from "@ethernauta/core"
 
 function transfer(_to: string) {
-  const to = parse(addressSchema, _to) // validated `Address`
+  const to = parse(AddressSchema, _to) // validated `Address`
   // …
@@ -44,6 +44,6 @@ }
 ```ts
-import { type Address, addressSchema, addressesSchema } from "@ethernauta/core"
+import { type Address, AddressSchema, AddressesSchema } from "@ethernauta/core"
 
-// `addressSchema`     — single 0x-prefixed 20-byte address
-// `addressesSchema`   — array of addresses
+// `AddressSchema`     — single 0x-prefixed 20-byte address
+// `AddressesSchema`   — array of addresses
 ```
@@ -54,5 +54,5 @@
 ```ts
-import { type Hash32, hash32Schema } from "@ethernauta/core"
+import { type Hash32, Hash32Schema } from "@ethernauta/core"
 
-// `hash32Schema` — 0x-prefixed 32-byte hash (transaction / block / topic)
+// `Hash32Schema` — 0x-prefixed 32-byte hash (transaction / block / topic)
 ```
@@ -64,17 +64,17 @@
 import {
-  type Byte, byteSchema,
-  type Bytes, bytesSchema,
-  type BytesMax32, bytesMax32Schema,
-  type Bytes4, bytes4Schema,
-  type Bytes8, bytes8Schema,
-  type Bytes32, bytes32Schema,
-  type Bytes48, bytes48Schema,
-  type Bytes64, bytes64Schema,
-  type Bytes65, bytes65Schema,
-  type Bytes256, bytes256Schema,
+  type Byte, ByteSchema,
+  type Bytes, BytesSchema,
+  type BytesMax32, BytesMax32Schema,
+  type Bytes4, Bytes4Schema,
+  type Bytes8, Bytes8Schema,
+  type Bytes32, Bytes32Schema,
+  type Bytes48, Bytes48Schema,
+  type Bytes64, Bytes64Schema,
+  type Bytes65, Bytes65Schema,
+  type Bytes256, Bytes256Schema,
 } from "@ethernauta/core"
 
-// `byteSchema`       — single 0x-prefixed byte
-// `bytesSchema`      — arbitrary 0x-prefixed byte string
-// `bytesMax32Schema` — 0x-prefixed byte string ≤ 32 bytes
+// `ByteSchema`       — single 0x-prefixed byte
+// `BytesSchema`      — arbitrary 0x-prefixed byte string
+// `BytesMax32Schema` — 0x-prefixed byte string ≤ 32 bytes
 // `bytesNSchema`     — fixed-width N-byte string (4, 8, 32, 48, 64, 65, 256)
@@ -87,17 +87,17 @@ ```
 import {
-  type Uint, uintSchema,
-  type Uint8, uint8Schema,
-  type Uint16, uint16Schema,
-  type Uint24, uint24Schema,
-  type Uint32, uint32Schema,
-  type Uint40, uint40Schema,
-  type Uint48, uint48Schema,
-  type Uint56, uint56Schema,
-  type Uint64, uint64Schema,
-  type Uint96, uint96Schema,
-  type Uint128, uint128Schema,
-  type Uint160, uint160Schema,
-  type Uint192, uint192Schema,
-  type Uint224, uint224Schema,
-  type Uint256, uint256Schema,
+  type Uint, UintSchema,
+  type Uint8, Uint8Schema,
+  type Uint16, Uint16Schema,
+  type Uint24, Uint24Schema,
+  type Uint32, Uint32Schema,
+  type Uint40, Uint40Schema,
+  type Uint48, Uint48Schema,
+  type Uint56, Uint56Schema,
+  type Uint64, Uint64Schema,
+  type Uint96, Uint96Schema,
+  type Uint128, Uint128Schema,
+  type Uint160, Uint160Schema,
+  type Uint192, Uint192Schema,
+  type Uint224, Uint224Schema,
+  type Uint256, Uint256Schema,
 } from "@ethernauta/core"
@@ -112,3 +112,3 @@
 ```ts
-import { type Ratio, ratioSchema } from "@ethernauta/core"
+import { type Ratio, RatioSchema } from "@ethernauta/core"
 
@@ -121,7 +121,7 @@ // A 0x-prefixed fraction in [0, 1] (used by tip / cap ratios).
 ```ts
-import { type NotFound, notFoundSchema } from "@ethernauta/core"
+import { type NotFound, NotFoundSchema } from "@ethernauta/core"
 
 // The protocol's "absent" sentinel — `null` wrapped as a schema
 // so JSON-RPC responses that may resolve to `null` (missing
-// block, missing receipt) can be composed with `union([…, notFoundSchema])`.
+// block, missing receipt) can be composed with `union([…, NotFoundSchema])`.
 ```

src/address.ts

@@ -10,6 +10,6 @@ import type { InferOutput } from "valibot"
 }
-export const addressSchema = pipe(
+export const AddressSchema = pipe(
   custom<`0x${string}`>(isAddress),
   brand("Address"),
 )
-export type Address = InferOutput<typeof addressSchema>
+export type Address = InferOutput<typeof AddressSchema>

src/addresses.ts

 import type { InferOutput } from "valibot"
 import { array } from "valibot"
-import { addressSchema } from "./address"
+import { AddressSchema } from "./address"
 
-export const addressesSchema = array(addressSchema)
-export type Addresses = InferOutput<typeof addressesSchema>
+export const AddressesSchema = array(AddressSchema)
+export type Addresses = InferOutput<typeof AddressesSchema>

src/byte.ts

@@ -10,6 +10,6 @@ import type { InferOutput } from "valibot"
 }
-export const byteSchema = pipe(
+export const ByteSchema = pipe(
   custom<`0x${string}`>(isByte),
   brand("Byte"),
 )
-export type Byte = InferOutput<typeof byteSchema>
+export type Byte = InferOutput<typeof ByteSchema>

src/bytes-256.ts

@@ -10,6 +10,6 @@ import type { InferOutput } from "valibot"
 }
-export const bytes256Schema = pipe(
+export const Bytes256Schema = pipe(
   custom<`0x${string}`>(isBytes256),
   brand("Bytes256"),
 )
-export type Bytes256 = InferOutput<typeof bytes256Schema>
+export type Bytes256 = InferOutput<typeof Bytes256Schema>

src/bytes-32.ts

@@ -10,6 +10,6 @@ import type { InferOutput } from "valibot"
 }
-export const bytes32Schema = pipe(
+export const Bytes32Schema = pipe(
   custom<`0x${string}`>(isBytes32),
   brand("Bytes32"),
 )
-export type Bytes32 = InferOutput<typeof bytes32Schema>
+export type Bytes32 = InferOutput<typeof Bytes32Schema>

src/bytes-4.ts

@@ -10,6 +10,6 @@ import type { InferOutput } from "valibot"
 }
-export const bytes4Schema = pipe(
+export const Bytes4Schema = pipe(
   custom<`0x${string}`>(isBytes4),
   brand("Bytes4"),
 )
-export type Bytes4 = InferOutput<typeof bytes4Schema>
+export type Bytes4 = InferOutput<typeof Bytes4Schema>

src/bytes-48.ts

@@ -10,6 +10,6 @@ import type { InferOutput } from "valibot"
 }
-export const bytes48Schema = pipe(
+export const Bytes48Schema = pipe(
   custom<`0x${string}`>(isBytes48),
   brand("Bytes48"),
 )
-export type Bytes48 = InferOutput<typeof bytes48Schema>
+export type Bytes48 = InferOutput<typeof Bytes48Schema>

src/bytes-64.ts

@@ -10,6 +10,6 @@ import type { InferOutput } from "valibot"
 }
-export const bytes64Schema = pipe(
+export const Bytes64Schema = pipe(
   custom<`0x${string}`>(isBytes64),
   brand("Bytes64"),
 )
-export type Bytes64 = InferOutput<typeof bytes64Schema>
+export type Bytes64 = InferOutput<typeof Bytes64Schema>

src/bytes-65.ts

@@ -10,6 +10,6 @@ import type { InferOutput } from "valibot"
 }
-export const bytes65Schema = pipe(
+export const Bytes65Schema = pipe(
   custom<`0x${string}`>(isBytes65),
   brand("Bytes65"),
 )
-export type Bytes65 = InferOutput<typeof bytes65Schema>
+export type Bytes65 = InferOutput<typeof Bytes65Schema>

src/bytes-8.ts

@@ -10,6 +10,6 @@ import type { InferOutput } from "valibot"
 }
-export const bytes8Schema = pipe(
+export const Bytes8Schema = pipe(
   custom<`0x${string}`>(isBytes8),
   brand("Bytes8"),
 )
-export type Bytes8 = InferOutput<typeof bytes8Schema>
+export type Bytes8 = InferOutput<typeof Bytes8Schema>

src/bytes-max-32.ts

@@ -10,3 +10,3 @@ import type { InferOutput } from "valibot"
 }
-export const bytesMax32Schema = pipe(
+export const BytesMax32Schema = pipe(
   custom<`0x${string}`>(isBytesMax32),
@@ -16,3 +16,3 @@ brand("BytesMax32"),
 export type BytesMax32 = InferOutput<
-  typeof bytesMax32Schema
+  typeof BytesMax32Schema
 >

src/bytes.ts

@@ -9,6 +9,6 @@ import type { InferOutput } from "valibot"
 }
-export const bytesSchema = pipe(
+export const BytesSchema = pipe(
   custom<`0x${string}`>(isBytes),
   brand("Bytes"),
 )
-export type Bytes = InferOutput<typeof bytesSchema>
+export type Bytes = InferOutput<typeof BytesSchema>

src/hash-32.ts

@@ -10,6 +10,6 @@ import type { InferOutput } from "valibot"
 }
-export const hash32Schema = pipe(
+export const Hash32Schema = pipe(
   custom<`0x${string}`>(isHash32),
   brand("Hash32"),
 )
-export type Hash32 = InferOutput<typeof hash32Schema>
+export type Hash32 = InferOutput<typeof Hash32Schema>

src/not-found.ts

 import type { InferOutput } from "valibot"
 import { null_ } from "valibot"
 
-export const notFoundSchema = null_()
-export type NotFound = InferOutput<typeof notFoundSchema>
+export const NotFoundSchema = null_()
+export type NotFound = InferOutput<typeof NotFoundSchema>

src/ratio.ts

 import type { InferOutput } from "valibot"
 import { maxValue, minValue, number, pipe } from "valibot"
 
-export const ratioSchema = pipe(
+export const RatioSchema = pipe(
   number(),
@@ -9,2 +9,2 @@ minValue(0),
 )
-export type Ratio = InferOutput<typeof ratioSchema>
+export type Ratio = InferOutput<typeof RatioSchema>

src/uint-128.ts

@@ -9,6 +9,6 @@ import type { InferOutput } from "valibot"
 }
-export const uint128Schema = pipe(
+export const Uint128Schema = pipe(
   custom<`0x${string}`>(isUint128, "uint128"),
   brand("Uint128"),
 )
-export type Uint128 = InferOutput<typeof uint128Schema>
+export type Uint128 = InferOutput<typeof Uint128Schema>

src/uint-16.ts

@@ -9,6 +9,6 @@ import type { InferOutput } from "valibot"
 }
-export const uint16Schema = pipe(
+export const Uint16Schema = pipe(
   custom<`0x${string}`>(isUint16, "uint16"),
   brand("Uint16"),
 )
-export type Uint16 = InferOutput<typeof uint16Schema>
+export type Uint16 = InferOutput<typeof Uint16Schema>

src/uint-160.ts

@@ -9,6 +9,6 @@ import type { InferOutput } from "valibot"
 }
-export const uint160Schema = pipe(
+export const Uint160Schema = pipe(
   custom<`0x${string}`>(isUint160, "uint160"),
   brand("Uint160"),
 )
-export type Uint160 = InferOutput<typeof uint160Schema>
+export type Uint160 = InferOutput<typeof Uint160Schema>

src/uint-192.ts

@@ -9,6 +9,6 @@ import type { InferOutput } from "valibot"
 }
-export const uint192Schema = pipe(
+export const Uint192Schema = pipe(
   custom<`0x${string}`>(isUint192, "uint192"),
   brand("Uint192"),
 )
-export type Uint192 = InferOutput<typeof uint192Schema>
+export type Uint192 = InferOutput<typeof Uint192Schema>

src/uint-224.ts

@@ -9,6 +9,6 @@ import type { InferOutput } from "valibot"
 }
-export const uint224Schema = pipe(
+export const Uint224Schema = pipe(
   custom<`0x${string}`>(isUint224, "uint224"),
   brand("Uint224"),
 )
-export type Uint224 = InferOutput<typeof uint224Schema>
+export type Uint224 = InferOutput<typeof Uint224Schema>

src/uint-24.ts

@@ -9,6 +9,6 @@ import type { InferOutput } from "valibot"
 }
-export const uint24Schema = pipe(
+export const Uint24Schema = pipe(
   custom<`0x${string}`>(isUint24, "uint24"),
   brand("Uint24"),
 )
-export type Uint24 = InferOutput<typeof uint24Schema>
+export type Uint24 = InferOutput<typeof Uint24Schema>

src/uint-256.test.ts

 import { safeParse } from "valibot"
 import { describe, expect, it } from "vitest"
-import { uint256Schema } from "./uint-256"
+import { Uint256Schema } from "./uint-256"
 
-describe("uint256Schema", () => {
+describe("Uint256Schema", () => {
   it("accepts 32-byte padded hex returned by decode_function_result", () => {
     const padded =
       "0x0000000000000000000000000000000000000000000000000000000000000002"
-    expect(safeParse(uint256Schema, padded).success).toBe(
+    expect(safeParse(Uint256Schema, padded).success).toBe(
       true,
@@ -17,3 +17,3 @@ )
       "0x0000000000000000000000000000000000000000000000000000000000000000"
-    expect(safeParse(uint256Schema, zero).success).toBe(
+    expect(safeParse(Uint256Schema, zero).success).toBe(
       true,
@@ -24,10 +24,10 @@ )
   it("accepts canonical short hex (no leading zeros)", () => {
-    expect(safeParse(uint256Schema, "0x2").success).toBe(
+    expect(safeParse(Uint256Schema, "0x2").success).toBe(
       true,
     )
-    expect(safeParse(uint256Schema, "0x0").success).toBe(
+    expect(safeParse(Uint256Schema, "0x0").success).toBe(
       true,
     )
     expect(
-      safeParse(uint256Schema, "0x1bc16d674ec80000")
+      safeParse(Uint256Schema, "0x1bc16d674ec80000")
         .success,
@@ -39,7 +39,7 @@ ).toBe(true)
     const max = `0x${"f".repeat(64)}` as const
-    expect(safeParse(uint256Schema, max).success).toBe(true)
+    expect(safeParse(Uint256Schema, max).success).toBe(true)
   })
 
   it("rejects values without 0x prefix", () => {
-    expect(safeParse(uint256Schema, "2").success).toBe(
+    expect(safeParse(Uint256Schema, "2").success).toBe(
       false,
@@ -50,3 +50,3 @@ )
   it("rejects empty 0x", () => {
-    expect(safeParse(uint256Schema, "0x").success).toBe(
+    expect(safeParse(Uint256Schema, "0x").success).toBe(
       false,
@@ -57,3 +57,3 @@ )
   it("rejects non-hex characters", () => {
-    expect(safeParse(uint256Schema, "0xzz").success).toBe(
+    expect(safeParse(Uint256Schema, "0xzz").success).toBe(
       false,
@@ -65,3 +65,3 @@ )
     const overflow = `0x1${"0".repeat(64)}`
-    expect(safeParse(uint256Schema, overflow).success).toBe(
+    expect(safeParse(Uint256Schema, overflow).success).toBe(
       false,
@@ -72,5 +72,5 @@ )
   it("rejects non-string inputs", () => {
-    expect(safeParse(uint256Schema, 2).success).toBe(false)
-    expect(safeParse(uint256Schema, 2n).success).toBe(false)
-    expect(safeParse(uint256Schema, null).success).toBe(
+    expect(safeParse(Uint256Schema, 2).success).toBe(false)
+    expect(safeParse(Uint256Schema, 2n).success).toBe(false)
+    expect(safeParse(Uint256Schema, null).success).toBe(
       false,
@@ -77,0 +77,0 @@ )

src/uint-256.ts

@@ -10,6 +10,6 @@ import type { InferOutput } from "valibot"
 }
-export const uint256Schema = pipe(
+export const Uint256Schema = pipe(
   custom<`0x${string}`>(isUint256, "uint256"),
   brand("Uint256"),
 )
-export type Uint256 = InferOutput<typeof uint256Schema>
+export type Uint256 = InferOutput<typeof Uint256Schema>

src/uint-32.ts

@@ -9,6 +9,6 @@ import type { InferOutput } from "valibot"
 }
-export const uint32Schema = pipe(
+export const Uint32Schema = pipe(
   custom<`0x${string}`>(isUint32, "uint32"),
   brand("Uint32"),
 )
-export type Uint32 = InferOutput<typeof uint32Schema>
+export type Uint32 = InferOutput<typeof Uint32Schema>

src/uint-40.ts

@@ -9,6 +9,6 @@ import type { InferOutput } from "valibot"
 }
-export const uint40Schema = pipe(
+export const Uint40Schema = pipe(
   custom<`0x${string}`>(isUint40, "uint40"),
   brand("Uint40"),
 )
-export type Uint40 = InferOutput<typeof uint40Schema>
+export type Uint40 = InferOutput<typeof Uint40Schema>

src/uint-48.ts

@@ -9,6 +9,6 @@ import type { InferOutput } from "valibot"
 }
-export const uint48Schema = pipe(
+export const Uint48Schema = pipe(
   custom<`0x${string}`>(isUint48, "uint48"),
   brand("Uint48"),
 )
-export type Uint48 = InferOutput<typeof uint48Schema>
+export type Uint48 = InferOutput<typeof Uint48Schema>

src/uint-56.ts

@@ -9,6 +9,6 @@ import type { InferOutput } from "valibot"
 }
-export const uint56Schema = pipe(
+export const Uint56Schema = pipe(
   custom<`0x${string}`>(isUint56, "uint56"),
   brand("Uint56"),
 )
-export type Uint56 = InferOutput<typeof uint56Schema>
+export type Uint56 = InferOutput<typeof Uint56Schema>

src/uint-64.ts

@@ -9,6 +9,6 @@ import type { InferOutput } from "valibot"
 }
-export const uint64Schema = pipe(
+export const Uint64Schema = pipe(
   custom<`0x${string}`>(isUint64, "uint64"),
   brand("Uint64"),
 )
-export type Uint64 = InferOutput<typeof uint64Schema>
+export type Uint64 = InferOutput<typeof Uint64Schema>

src/uint-8.ts

@@ -9,6 +9,6 @@ import type { InferOutput } from "valibot"
 }
-export const uint8Schema = pipe(
+export const Uint8Schema = pipe(
   custom<`0x${string}`>(isUint8, "uint8"),
   brand("Uint8"),
 )
-export type Uint8 = InferOutput<typeof uint8Schema>
+export type Uint8 = InferOutput<typeof Uint8Schema>

src/uint-96.ts

@@ -9,6 +9,6 @@ import type { InferOutput } from "valibot"
 }
-export const uint96Schema = pipe(
+export const Uint96Schema = pipe(
   custom<`0x${string}`>(isUint96, "uint96"),
   brand("Uint96"),
 )
-export type Uint96 = InferOutput<typeof uint96Schema>
+export type Uint96 = InferOutput<typeof Uint96Schema>

src/uint.ts

@@ -10,6 +10,6 @@ import type { InferOutput } from "valibot"
 }
-export const uintSchema = pipe(
+export const UintSchema = pipe(
   custom<`0x${string}`>(isUint, "uint"),
   brand("Uint"),
 )
-export type Uint = InferOutput<typeof uintSchema>
+export type Uint = InferOutput<typeof UintSchema>

No alert changes

Improved metrics

Total package byte prevSize

72772

0.08%

No dependency changes