@zzzeros0/nbsp 0.1.1 → 0.3.0

package/README.md

@@ -27,22 +27,38 @@ interface AckPacket {
 } // domain AckPacket
 
 interface Packet {
-  header: number;
+  header: byte;
   id: string;
   method: string;
   content: string;
 } // domain Packet
 
-const AckPacketStructure = structure<AckPacket>(
+// Transformers
+// Transforms string <-> number[]
+const stringTransform = {
+  input: [(data: string) => toBytes(data)],
+  output: [(data: bytes) => toString(data)],
+};
+
+// Transforms hex string <-> hex number[]
+const hexStringTransform = {
+  input: [(data: string) => toBytes(data, true)],
+  output: [(data: bytes) => toString(data, true)],
+};
+
+const AckPacketStruct = struct<AckPacket, Transformers<AckPacket>>(
   {
     id: charDataType(6),
   },
   {
     packed: true,
+    transform: {
+      id: hexStringTransform,
+    },
   },
-);
+); // AckPacketStruct Constructor (class)
 
-const PacketStructure = structure<Packet>(
+const PacketStruct = struct<Packet, Transformers<Packet>>(
   {
     header: DataType.UINT32LE,
     id: charDataType(6),
@@ -51,170 +67,142 @@ const PacketStructure = structure<Packet>(
   },
   {
     packed: true,
+    transform: {
+      id: hexStringTransform,
+      method: stringTransform,
+      content: stringTransform,
+    },
   },
-);
+); // PacketStruct Constructor (class)
 
-console.log(AckPacketStructure.size); // 6 (Unpacked: 10)
-console.log(PacketStructure.size); // 78 (Unpacked: 128)
+console.log(AckPacketStruct.size); // 6 (Unpacked: 10)
+console.log(PacketStruct.size); // 78 (Unpacked: 128)
 
 mqttClient.on("message", (topic, msg) => {
-  const packet = PacketStructure.from(msg);
-
-  processMessage(
-    topic,
-    toString(packet.id),
-    toString(packet.method),
-    toString(packet.content),
-  ).then(() => {
-    const ackMessage = new AckPacketStructure({
-      id: packet.id,
-    });
+  const packet = PacketStruct.from(msg);
+
+  processMessage(topic, packet.id, packet.method, packet.content).then(() => {
+    const ackMessage = AckPacketStruct.from(msg, sizeof(DataType.UINT32LE)); // Offset the 'header' property
 
     mqttClient.publish("ack", ackMessage.data());
   });
 });
 ```
 
-## Usage
+### Struct Constructor methods
+
+| Method | Description                                                       | Arguments                                    | Returned type |
+| ------ | ----------------------------------------------------------------- | -------------------------------------------- | ------------- |
+| from   | Creates a new instance and copies the buffer content from target. | `(target: Buffer \| Struct, byte: byte = 0)` | `Struct<T>`   |
+| toJson | Creates a plain object, resolving with the data of the buffer.    | `(target: Buffer, offset: byte = 0)`         | T             |
+
+### Struct methods
+
+| Method | Description                            | Arguments                                      | Returned type |
+| ------ | -------------------------------------- | ---------------------------------------------- | ------------- |
+| data   | Returns the internal buffer (no copy). |                                                | `Buffer`      |
+| reset  | Zero the internal buffer content.      |                                                | `void`        |
+| toJson | Returns a plain object.                |                                                | `T`           |
+| copy   | Copies the buffer content from target. | `(target: Buffer \| Struct, offset: byte = 0)` | `void`        |
 
-1. Create a domain interface.
+### Struct Options
 
-- This will represent your data.
+Options argument for the `struct` function.
+
+| Property  | Description                                                                                                                                               | Type              | Default |
+| --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- | ------- |
+| packed    | When false, fields of the `struct` are aligned or padded. This is really important especially for binary communications, improving performance and usage. | `boolean`         | `false` |
+| transform | An object that contains keys from the domain object. Transforms the data obtained/retrieved from the buffer data.                                         | `Transformers<T>` | `{}`    |
+
+## Usage
+
+1. Create a domain interface. This will represent your data.
 
 ```ts
 interface Person {
-  age: number;
+  age: byte;
   name: string;
 } // domain Person
 ```
 
-2. Create a Structure for your domain interface. Calling `structure` will return a new class; it is not intended to be extended.
+2. Create a Struct for your domain interface. Calling `struct` will return a new class; it is not intended to be extended.
 
 ```ts
-const PersonStructure = structure<Person>({
+const PersonStruct = struct<Person>({
   age: DataType.UINT8,
   name: charDataType(4), // strings are arrays of UINT8. charDataType(n) is equivalent to [DataType.UINT8, n]
 });
 ```
 
-3. Now, you can instantiate the structure by using `new` or the `StructureConstructor`'s static method `from`. Instance exposes getters and setters to update and retrieve data directly from the fields of the structure in the buffer as well as some other methods to manage it:
+3. Now, you can instantiate the struct by using `new` or the `StructConstructor`'s static method `from`. Instance exposes getters and setters to update and retrieve data directly from the fields of the struct in the buffer as well as some other methods to manage it:
 
 ```ts
-const person1 = new PersonStructure({
+const person1 = new PersonStruct({
   age: 24,
-  name: toUint8Array("Dave"), // Transform the string to UTF-8 UINT8 array
+  name: toBytes("Dave"), // Transform the string to UTF-8 UINT8 array
 });
 console.log("Name: %s, age: %d", toString(person1.name), person1.age); // Name: Dave, age: 24
 
-const person2 = PersonStructure.from(Buffer.from("526f73655a000000", "hex"));
-
-console.log("Name: %s, age: %d", toString(person2.name), person2.age); // Name: Rose, age: 90
+const person2 = PersonStruct.from(Buffer.from("63000000526f7365", "hex"));
 
-console.log(person2.data()); //  <Buffer 52 6f 73 65 5a 00 00 00>
-```
+console.log("Name: %s, age: %d", toString(person2.name), person2.age); // Name: Rose, age: 99
 
-4. You can create a plain object using `toJson` instance or static methods:
+console.log(person2.data()); //  <Buffer 63 00 00 00 52 6f 73 65>
 
-```ts
-console.log(person2.toJson()); // { name: [ 82, 111, 115, 101 ], age: 90 }
+console.log(person2.toJson()); // { age: 99, name: [ 82, 111, 115, 101 ] }
 
-const person3 = PersonStructure.toJson(Buffer.from("4a616b655a000000", "hex"));
+const person3 = PersonStruct.toJson(Buffer.from("5a0000004a616b65", "hex"));
 
 console.log("Name: %s, age: %d", toString(person3.name), person3.age); // Name: Jake, age: 90
 ```
 
-### Packing
-
-When creating a `Structure`, you can provide the argument `packed` (default is `false`):
+Transformers help to transform data.
+When a property has transformers, its exposed TypeScript type becomes the transformed type instead of the raw BindedType<T>.
+You can have multiple transforms in input/output; each one will receive the last transformed value.
 
 ```ts
-const PacketStructure = structure<Packet>(
+const PersonStruct = struct<Person, { name: PropertyTransform }>(
   {
-    header: DataType.UINT32LE,
-    id: charDataType(6),
-    content: charDataType(64),
+    age: DataType.UINT8,
+    name: charDataType(4),
   },
   {
-    packed: true,
+    transform: {
+      name: {
+        // Executed when data is written to the buffer
+        input: [(data: string) => toBytes(data)],
+        // Executed when data is retrieved from the buffer
+        output: [(data: bytes) => toString(data)],
+      },
+    },
   },
 );
-```
-
-When `packed` is `true`, no padding or alignment will be applied to the fields. This is really important especially for binary communications, improving performance and usage.
-
-```ts
-console.log(PersonStructure.size); // Unpacked: 8 bytes
-console.log(PersonStructure.size); // Packed: 5 bytes
-```
-
-### Strings
-
-NBSP does not store strings dynamically.
-Strings are represented as fixed-length arrays of `UINT8`. You can use `charDataType` as a shorthand:
-
-```ts
-charDataType(6); // returns [DataType.UINT8, 6]
-```
-
-This is intentional and ensures:
-
-- Deterministic payload size
-- Protocol compatibility
-- Zero dynamic allocation
-
-### Working with hex
-
-You can serialize/retrieve hex data:
-
-```ts
-interface User {
-  id: string;
-  role: number;
-} // domain Person
-
-const UserStructure = structure<User>({
-  id: charDataType(4),
-  role: DataType.UINT8,
-});
-
-const instance = new UserStructure({
-  id: toUint8Array("1a2b4c6d", true), // Transform to hex array
-  role: 2,
+const person = new PersonStruct({
+  age: 24,
+  name: "Dave", // Input transformer
 });
-// HEX string length 8 -> HEX array length 4
-
-console.log(instance.name); // Prints [ 26, 43, 76, 109 ]
-console.log(toString(instance.name, true)); // "1a2b4c6d"
+person.name = "Jack"; // Input transformer
+console.log(person.name); // "Jack", output transformer
 ```
 
-### Arrays
+### Arrays & Nesting
 
-`Arrays` are defined with a `type` and a fixed `length` of items:
+`Array` types are defined with a `type` and a fixed `length` of items:
 
 ```ts
-interface Person {
-  name: string;
-} // domain Person
-
-const PersonStructure = structure<Person>({
-  name: charDataType(4), // [ DataType.UINT8, 4 ]
-});
-
-const person = new PersonStructure({
-  name: toUint8Array("Jake"),
+const PersonStruct = struct<Person>({
+  name: [DataType.UINT8, 4], // or charDataType(4)
 });
 ```
 
-This specifies that there will be `4` items in this field, each of them of type `DataType.UINT8` (strings will always be stored as arrays of `DataType.UINT8`).
-
-### Nested Structures
+> Strings are represented as a fixed array of `UINT8` if no transformer was applied for that property. Use the shorthand `charDataType`.
 
-You can nest `Structures`:
+You can nest `Structs`:
 
 ```ts
 interface DeviceConfig {
-  mode: number;
-  factor: number;
+  mode: byte;
+  factor: byte;
 } // domain DeviceConfig
 
 interface Device {
@@ -222,54 +210,54 @@ interface Device {
   config: DeviceConfig; // Provide the domain type
 } // domain Device
 
-const DeviceConfigStructure = structure<DeviceConfig>({
+const DeviceConfigStruct = struct<DeviceConfig>({
   mode: DataType.UINT8,
   factor: DataType.UINT8,
 });
 
-const DeviceStructure = structure<Device>({
+const DeviceStruct = struct<Device>({
   id: charDataType(6),
-  config: DeviceConfigStructure, // Provide the structure as type
+  config: DeviceConfigStruct, // Provide the struct as type
 });
 
-const instance = new DeviceStructure({
+const instance = new DeviceStruct({
   id: Array.from(randomBytes(6)),
   config: {
     // Create a plain object
-    // DO NOT use DeviceConfigStructure constructor
+    // DO NOT use DeviceConfigStruct constructor
     // it will cause unnecessary allocations
     mode: 4,
     factor: 8,
   },
 });
 
-console.log(instance.config.factor); // Prints '8'
+console.log(instance.config.factor); // 8
 ```
 
-You can also store `Structures` or `Arrays` inside of `Arrays`:
+You can also store `Structs` or `Arrays` inside of `Arrays`:
 
 ```ts
 interface Group {
   people: Person[];
 } // domain Group
 
-const GroupStructure = structure<Group>({
-  people: [PersonStructure, 100],
+const GroupStruct = struct<Group>({
+  people: [PersonStruct, 100],
 });
 
-const groupInstance = new GroupStructure({
+const groupInstance = new GroupStruct({
   people: [
     // Create a plain object
-    // DO NOT use PersonStructure constructor
+    // DO NOT use PersonStruct constructor
     // it will cause unnecessary allocations
     {
-      name: toUint8Array("Jack"),
+      name: "Jack",
     },
     {
-      name: toUint8Array("Rose"),
+      name: "Rose",
     },
     {
-      name: toUint8Array("Dave"),
+      name: "Dave",
     },
     ...
   ],
@@ -280,43 +268,11 @@ console.log(groupInstance.people); // Array<100> [ { name: [Getter/Setter] }, ..
 
 > **Important**
 >
-> Structures must be instantiated with plain objects when are nested, `do not` use the `Structure's constructor`; doing so will make unnecessary allocations.
-
-### Buffer and copying
-
-You can access the `buffer` of the `instance` with `data` method:
-
-```ts
-instance.data(); // Returns the internal Buffer (no copy)
-```
-
-You can reset the `buffer` of the `instance` with `reset` method:
-
-```ts
-instance.reset(); // Resets the internal Buffer (0)
-```
-
-You can `copy` the data from other `instance` or `buffer`:
-
-```ts
-instance.copy(instanceOrBuffer);
-```
-
-You can create a `new instance` of the `Structure`, copying the data `from` other `buffer` or `instance`:
-
-```ts
-const copiedInstance = PersonStructure.from(instanceOrBuffer);
-```
-
-> **Important**
->
-> Buffers must be the same size when copying.
->
-> Each instance has its own buffer.
+> Structs must be instantiated with plain objects when are nested, `do not` use the `Struct's constructor`; doing so will make unnecessary allocations.
 
 ### JSON
 
-Instances can be converted to plain JavaScript object with all the resolved properties and nested attributes of your structure using `toJson` method:
+Instances can be converted to plain JavaScript object with all the resolved properties and nested attributes of your struct using `toJson` method:
 
 ```ts
 personInstance.toJson(); // { name: [ 68, 97, 118, 101 ], age: 24 }
@@ -325,16 +281,24 @@ personInstance.toJson(); // { name: [ 68, 97, 118, 101 ], age: 24 }
 You can serialize directly to a plain JavaScript object from a buffer by using the static method `toJson`:
 
 ```ts
-PersonStructure.toJson(Buffer.from("4a616b655a000000", "hex")); // { name: [ 68, 97, 118, 101 ], age: 24 }
+PersonStruct.toJson(Buffer.from("4a616b655a000000", "hex")); // { name: [ 68, 97, 118, 101 ], age: 24 }
 ```
 
 > **Important**
 >
-> Strings are still represented as numeric arrays in JSON output.
+> Transformers will also run when serializing JSON.
+
+> Prefer the static `toJson` method when working with raw buffers; there's no point on doing this:
+>
+> ```ts
+> PersonStruct.toJson(personInstance.data());
+> // Instead
+> personInstance.toJson();
+> ```
 
 ### Endianness
 
-`DataType` difference between `LE` and `BE` types:
+Data types defined in the enum `DataType` difference between `LE` and `BE` types:
 
 ```ts
 structure({
@@ -343,6 +307,16 @@ structure({
 });
 ```
 
+> **Note**
+>
+> You can get the `size` of data types with `sizeof`:
+>
+> ```ts
+> console.log(sizeof(DataType.INT16LE)); // 2
+> console.log(sizeof(charDataType(6))); // 6
+> console.log(sizeof(Structure)); // Or Structure.size
+> ```
+
 ### Floating point (FLOAT32) precision
 
 NBSP uses IEEE-754 floating point representations for FLOAT32 and FLOAT64, exactly like C, C++, Rust, Java, etc.
@@ -352,7 +326,7 @@ This means that some decimal values cannot be represented exactly in binary.
 
 FLOAT32 is a 32-bit single-precision IEEE-754 float.
 
-The decimal number 0.4 cannot be represented exactly using a finite binary fraction, so the closest representable value is stored instead.
+Some decimal numbers, like 0.4, cannot be represented exactly using a finite binary fraction, so the closest representable value is stored instead.
 
 Example:
 
@@ -381,7 +355,9 @@ NBSP intentionally exposes the real binary value, without rounding or post-proce
 
 If you need to compare floating point values, never use strict equality:
 
-a === b // ❌ unsafe for floats
+```ts
+a === b; // ❌ unsafe for floats
+```
 
 Instead, compare with a tolerance:
 

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export { toString, toUint8Array } from "./memory.js";
-export { structure, type Structure, type StructureConstructor, type StructureFields, type StructureMethods, } from "./structure.js";
-export { charDataType, DataType, type BindedType, type DomainObject, type ArrayDataType, type BigIntDataType, type Type, type NumericArrayDataType, type StructureArrayDataType, type StructureDefinitionDataType, type DataVale, } from "./type.js";
+export { toString, toBytes, sizeof } from "./memory.js";
+export { struct, type Struct, type StructConstructor, type StructFields, type StructMethods, type StructReturn, } from "./structure.js";
+export { charDataType, DataType, type ArrayDataType, type BigIntDataType, type BindedType, type DataValue, type DomainObject, type NumericArrayDataType, type StructArrayDataType, type StructDefinitionDataType, type Type, type byte, type bytes, } from "./type.js";
+export { type Transformer, type Transformers, type ApplyTransformers, type PropertyTransformer, } from "./transformer.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EACL,SAAS,EACT,KAAK,SAAS,EACd,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,YAAY,EACZ,QAAQ,EACR,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,IAAI,EACT,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAC3B,KAAK,2BAA2B,EAChC,KAAK,QAAQ,GACd,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EACL,MAAM,EACN,KAAK,MAAM,EACX,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,YAAY,GAClB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,YAAY,EACZ,QAAQ,EACR,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,IAAI,EACT,KAAK,IAAI,EACT,KAAK,KAAK,GACX,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,GACzB,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -1,4 +1,5 @@
-export { toString, toUint8Array } from "./memory.js";
-export { structure, } from "./structure.js";
+export { toString, toBytes, sizeof } from "./memory.js";
+export { struct, } from "./structure.js";
 export { charDataType, DataType, } from "./type.js";
+export {} from "./transformer.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EACL,SAAS,GAKV,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,YAAY,EACZ,QAAQ,GAUT,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EACL,MAAM,GAMP,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,YAAY,EACZ,QAAQ,GAYT,MAAM,WAAW,CAAC;AACnB,OAAO,EAKN,MAAM,kBAAkB,CAAC"}

package/dist/memory.d.ts

@@ -1,7 +1,8 @@
-import { type AlignedData } from "./type.js";
-export declare function alloc(s: number): Buffer<ArrayBuffer>;
-export declare function read(data: AlignedData, buffer: Buffer, offset: number): number | bigint;
-export declare function write(data: AlignedData, buffer: Buffer, value: number, offset: number): void;
-export declare function toUint8Array(s: string, hex?: boolean): number[];
-export declare function toString(n: number[], hex?: boolean): string;
+import { type AlignedData, type byte, type bytes, type Type } from "./type.js";
+export declare function alloc(s: byte): Buffer<ArrayBuffer>;
+export declare function read(data: AlignedData, buffer: Buffer, offset: byte): number | bigint;
+export declare function write(data: AlignedData, buffer: Buffer, value: byte, offset: byte): void;
+export declare function sizeof(type: Type): byte;
+export declare function toBytes(s: string, hex?: boolean): bytes;
+export declare function toString(n: bytes, hex?: boolean): string;
 //# sourceMappingURL=memory.d.ts.map

package/dist/memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../src/memory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AA4BvD,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,uBAG9B;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,mBA2CrE;AAED,wBAAgB,KAAK,CACnB,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,QA0Ff;AAyBD,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,GAAE,OAAe,GAAG,MAAM,EAAE,CAMtE;AACD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,GAAE,OAAe,GAAG,MAAM,CAKlE"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../src/memory.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,WAAW,EAEhB,KAAK,IAAI,EACT,KAAK,KAAK,EACV,KAAK,IAAI,EACV,MAAM,WAAW,CAAC;AA8BnB,wBAAgB,KAAK,CAAC,CAAC,EAAE,IAAI,uBAE5B;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,mBAyCnE;AAED,wBAAgB,KAAK,CACnB,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,IAAI,EACX,MAAM,EAAE,IAAI,GACX,IAAI,CAqFN;AAsCD,wBAAgB,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAQvC;AAsBD,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,GAAE,OAAe,GAAG,KAAK,CAI9D;AACD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,GAAE,OAAe,GAAG,MAAM,CAK/D"}

package/dist/memory.js

@@ -1,4 +1,5 @@
-import { DataType } from "./type.js";
+import { DataType, } from "./type.js";
+let encoder, decoder;
 function assertInteger(value, min, max, type) {
     if (!Number.isInteger(value)) {
         throw new Error(`${type}: value is not an integer`);
@@ -18,12 +19,9 @@ function assertBigIntRange(value, min, max, type) {
     }
 }
 export function alloc(s) {
-    // console.log("Alloc", s);
     return Buffer.alloc(s);
 }
 export function read(data, buffer, offset) {
-    // console.log("read", data, offset + data.offset);
-    // if (typeof data.type === "number") {
     switch (data.type) {
         case DataType.INT8:
             return buffer.readInt8(offset + data.offset);
@@ -66,10 +64,6 @@ export function read(data, buffer, offset) {
     }
 }
 export function write(data, buffer, value, offset) {
-    // console.log("Write", data.offset + offset, value);
-    // if (typeof data.type === "number") {
-    //   if (Array.isArray(value) || typeof value !== "number")
-    //     throw new Error("Invalid value");
     switch (data.type) {
         case DataType.INT8:
             assertInteger(value, -128, 127, "INT8");
@@ -155,7 +149,49 @@ export function write(data, buffer, value, offset) {
             throw new Error("Invalid type");
     }
 }
-let encoder, decoder;
+function getDataTypeSize(type) {
+    switch (type) {
+        case DataType.INT8:
+        case DataType.UINT8:
+            return 1;
+        case DataType.INT16LE:
+        case DataType.INT16BE:
+        case DataType.UINT16LE:
+        case DataType.UINT16BE:
+            return 2;
+        case DataType.INT32BE:
+        case DataType.INT32LE:
+        case DataType.UINT32LE:
+        case DataType.UINT32BE:
+            return 4;
+        case DataType.INT64LE:
+        case DataType.INT64BE:
+        case DataType.UINT64LE:
+        case DataType.UINT64BE:
+            return 8;
+        case DataType.FLOAT32LE:
+        case DataType.FLOAT32BE:
+            return 4;
+        case DataType.FLOAT64LE:
+        case DataType.FLOAT64BE:
+            return 8;
+    }
+}
+function getStructureDataSize(structure) {
+    return structure.size;
+}
+function getArrrayDataSize(type) {
+    return sizeof(type[0]) * type[1];
+}
+export function sizeof(type) {
+    return typeof type === "number"
+        ? getDataTypeSize(type)
+        : typeof type === "string"
+            ? 0
+            : Array.isArray(type)
+                ? getArrrayDataSize(type)
+                : getStructureDataSize(type);
+}
 function hexToBytes(hex) {
     let bytes = [];
     for (let c = 0; c < hex.length; c += 2)
@@ -164,7 +200,7 @@ function hexToBytes(hex) {
     return bytes;
 }
 function bytesToHex(bytes) {
-    let hex = [];
+    const hex = [];
     for (let i = 0; i < bytes.length; i++) {
         const byte = bytes[i];
         if (byte == undefined)
@@ -175,14 +211,12 @@ function bytesToHex(bytes) {
     }
     return hex.join("");
 }
-export function toUint8Array(s, hex = false) {
+export function toBytes(s, hex = false) {
     if (hex)
         return hexToBytes(s);
     if (!encoder)
         encoder = new TextEncoder(); // UTF-8 por defecto
-    const bytes = encoder.encode(s);
-    // console.log("Raw", bytes);
-    return Array.from(bytes);
+    return Array.from(encoder.encode(s));
 }
 export function toString(n, hex = false) {
     // console.log("String", n);