@nnilky/structo 1.0.0 → 1.0.2

package/dist/structo/datatypes/containers/array.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from "../../types";
+export declare function array<T>(size: number, type: Serializer<T>): Serializer<T[]>;

package/{structo/datatypes/containers/array.ts → dist/structo/datatypes/containers/array.js}

@@ -1,14 +1,12 @@
-import type { Serializer } from "../../types";
-
-export function array<T>(size: number, type: Serializer<T>): Serializer<T[]> {
+export function array(size, type) {
     const { read: readType, write: writeType, size: typeSize } = type;
-
     return {
         size: type.size ? size * type.size : undefined,
         write: (ctx, value) => {
-            if (value.length !== size) throw new Error("Invalid Size");
-
-            if (typeSize) ctx.alloc(size * typeSize);
+            if (value.length !== size)
+                throw new Error("Invalid Size");
+            if (typeSize)
+                ctx.alloc(size * typeSize);
             for (let i = 0; i < size; i++) {
                 writeType(ctx, value[i]);
             }

package/dist/structo/datatypes/containers/fastObject.d.ts

@@ -0,0 +1,6 @@
+import type { InferInput, Serializer } from "../../types";
+type InferObject<T> = T extends Record<string, Serializer<any>> ? {
+    [Key in keyof T]: InferInput<T[Key]>;
+} : never;
+export declare function fastObject<T extends Record<string, Serializer<any>>>(definition: T): Serializer<InferObject<T>>;
+export {};

package/{structo/datatypes/containers/fastObject.ts → dist/structo/datatypes/containers/fastObject.js}

@@ -1,61 +1,41 @@
-import type { InferInput, Serializer } from "../../types";
-
-type InferObject<T> =
-    T extends Record<string, Serializer<any>> ? { [Key in keyof T]: InferInput<T[Key]> } : never;
-
 const definitionSymbol = Symbol();
-
-export function fastObject<T extends Record<string, Serializer<any>>>(
-    definition: T,
-): Serializer<InferObject<T>> {
-    let serializers: [string, Serializer<any>][] = [];
-
+export function fastObject(definition) {
+    let serializers = [];
     let writeBody = "";
     let readBody = "";
-
-    function generateSerializers(serializer: Serializer<any>, keys: string[]) {
+    function generateSerializers(serializer, keys) {
         if (definitionSymbol in serializer) {
-            const definition = serializer[definitionSymbol] as any;
+            const definition = serializer[definitionSymbol];
             readBody += `${keys[keys.length - 1]}: {`;
-            for (const key of Object.keys(definition as any)) {
+            for (const key of Object.keys(definition)) {
                 generateSerializers(definition[key], [...keys, key]);
             }
             readBody += `},`;
-        } else {
+        }
+        else {
             let path = "";
             for (const key of keys) {
                 if (key.match(/[a-zA-Z_][a-zA-Z0-9_]*/)) {
                     path += `.${key}`;
-                } else {
+                }
+                else {
                     path += `[${JSON.stringify(key)}]`;
                 }
             }
-
             let name = `s${Object.keys(serializers).length}`;
             serializers.push([name, serializer]);
             writeBody += `${name}(c, v${path});`;
             readBody += `${keys[keys.length - 1]}: ${name}(c),`;
         }
     }
-
     for (const key of Object.keys(definition)) {
         generateSerializers(definition[key], [key]);
     }
-
-    const writeFactory = new Function(
-        ...serializers.map((v) => v[0]),
-        `return (c, v) => {${writeBody}}`,
-    );
-    const readFactory = new Function(
-        ...serializers.map((v) => v[0]),
-        `return (c, v) => ({${readBody}})`,
-    );
-
+    const writeFactory = new Function(...serializers.map((v) => v[0]), `return (c, v) => {${writeBody}}`);
+    const readFactory = new Function(...serializers.map((v) => v[0]), `return (c, v) => ({${readBody}})`);
     const write = writeFactory(...serializers.map((v) => v[1].write));
     const read = readFactory(...serializers.map((v) => v[1].read));
-
-    let size = Object.values(definition).reduce((total, v) => total + (v.size as number), 0);
-
+    let size = Object.values(definition).reduce((total, v) => total + v.size, 0);
     return {
         //@ts-ignore
         [definitionSymbol]: definition,

package/dist/structo/datatypes/containers/list.d.ts

@@ -0,0 +1,5 @@
+import type { Serializer } from "../../types";
+export declare function list<T>(options: {
+    type: Serializer<T>;
+    length: Serializer<number>;
+}): Serializer<T[]>;

package/{structo/datatypes/containers/list.ts → dist/structo/datatypes/containers/list.js}

@@ -1,24 +1,17 @@
-import type { Serializer } from "../../types";
-
-export function list<T>(options: {
-    type: Serializer<T>;
-    length: Serializer<number>;
-}): Serializer<T[]> {
+export function list(options) {
     const { read: readLength, write: writeLength } = options.length;
     const { read: readType, write: writeType, size: sizeType } = options.type;
-
     return {
         write: (ctx, value) => {
             writeLength(ctx, value.length);
-
-            if (sizeType) ctx.alloc(value.length * sizeType);
+            if (sizeType)
+                ctx.alloc(value.length * sizeType);
             for (const v of value) {
                 writeType(ctx, v);
             }
         },
         read: (ctx) => {
             const size = readLength(ctx);
-
             const arr = new Array(size);
             for (let i = 0; i < size; i++) {
                 arr[i] = readType(ctx);

package/dist/structo/datatypes/containers/object.d.ts

@@ -0,0 +1,9 @@
+import type { InferInput, InferOutput, Serializer } from "../../types";
+type InferObjectInfer<T> = T extends Record<string, Serializer<any>> ? {
+    [Key in keyof T]: InferInput<T[Key]>;
+} : never;
+type InferObjectOutput<T> = T extends Record<string, Serializer<any>> ? {
+    [Key in keyof T]: InferOutput<T[Key]>;
+} : never;
+export declare function object<T extends Record<string, Serializer<any>>>(definition: T): Serializer<InferObjectInfer<T>, InferObjectOutput<T>>;
+export {};

package/dist/structo/datatypes/containers/object.js

@@ -0,0 +1,24 @@
+export function object(definition) {
+    const entires = Object.entries(definition);
+    // Use the fact: number + undefined = NaN
+    // Check for NaN afterwards
+    let computedSize = Object.values(definition).reduce((total, v) => total + v.size, 0);
+    const size = isNaN(computedSize) ? undefined : computedSize;
+    return {
+        size,
+        write: (ctx, value) => {
+            if (size)
+                ctx.alloc(size);
+            for (let i = 0; i < entires.length; i++) {
+                entires[i][1].write(ctx, value[entires[i][0]]);
+            }
+        },
+        read: (ctx) => {
+            const output = new Array(entires.length);
+            for (let i = 0; i < entires.length; i++) {
+                output[i] = [entires[i][0], entires[i][1].read(ctx)];
+            }
+            return Object.fromEntries(output);
+        },
+    };
+}

package/dist/structo/datatypes/containers/sizedbuffer.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from "../../types";
+export declare function sizedBuffer(length: Serializer<number>): Serializer<ArrayBuffer>;

package/{structo/datatypes/containers/sizedbuffer.ts → dist/structo/datatypes/containers/sizedbuffer.js}

@@ -1,10 +1,7 @@
-import type { Serializer } from "../../types";
-
-export function sizedBuffer(length: Serializer<number>): Serializer<ArrayBuffer> {
+export function sizedBuffer(length) {
     return {
         write: (ctx, value) => {
             length.write(ctx, value.byteLength);
-
             const bytes = new Uint8Array(value);
             ctx.alloc(value.byteLength);
             new Uint8Array(ctx.view.buffer).set(bytes, ctx.offset);

package/{structo/datatypes/index.ts → dist/structo/datatypes/index.d.ts}

@@ -2,17 +2,14 @@ export { u64Bigint, s64Bigint } from "./numbers/bigints";
 export { f32, f64 } from "./numbers/floats";
 export { s8, s16, s32, s64 } from "./numbers/sints";
 export { u8, u16, u32, u64 } from "./numbers/uints";
-
 export { array } from "./containers/array";
 export { fastObject } from "./containers/fastObject";
 export { object } from "./containers/object";
 export { list } from "./containers/list";
 export { sizedBuffer } from "./containers/sizedbuffer";
-
 export { string } from "./values/string";
 export { buffer } from "./values/buffer";
 export { byteLiteral } from "./values/byteliteral";
-
 export { type Transform as Pipeline, pipe } from "./transforms/pipe";
 export { positionOffset } from "./transforms/readOffset";
 export { transform } from "./transforms/transform";

package/dist/structo/datatypes/index.js

@@ -0,0 +1,15 @@
+export { u64Bigint, s64Bigint } from "./numbers/bigints";
+export { f32, f64 } from "./numbers/floats";
+export { s8, s16, s32, s64 } from "./numbers/sints";
+export { u8, u16, u32, u64 } from "./numbers/uints";
+export { array } from "./containers/array";
+export { fastObject } from "./containers/fastObject";
+export { object } from "./containers/object";
+export { list } from "./containers/list";
+export { sizedBuffer } from "./containers/sizedbuffer";
+export { string } from "./values/string";
+export { buffer } from "./values/buffer";
+export { byteLiteral } from "./values/byteliteral";
+export { pipe } from "./transforms/pipe";
+export { positionOffset } from "./transforms/readOffset";
+export { transform } from "./transforms/transform";

package/dist/structo/datatypes/numbers/bigints.d.ts

@@ -0,0 +1,3 @@
+import type { Serializer } from "../../types";
+export declare function u64Bigint(endian?: "little" | "big"): Serializer<number | bigint, bigint>;
+export declare function s64Bigint(endian?: "little" | "big"): Serializer<number | bigint, bigint>;

package/{structo/datatypes/numbers/bigints.ts → dist/structo/datatypes/numbers/bigints.js}

@@ -1,20 +1,13 @@
-//@ts-ignore TODO
-import type { Serializer } from "../../types";
-
-const checkValue = (value: number | bigint, start: bigint, end: bigint) => {
+const checkValue = (value, start, end) => {
     if (value < start || value >= end) {
         throw new Error("Out of Range");
     }
 };
-
-export function u64Bigint(
-    endian: "little" | "big" = "little",
-): Serializer<number | bigint, bigint> {
+export function u64Bigint(endian = "little") {
     return {
         size: 8,
         write: (ctx, value) => {
             checkValue(value, 0n, 2n ** 64n);
-
             ctx.alloc(8);
             ctx.view.setBigUint64(ctx.offset, BigInt(value), endian === "little");
             ctx.offset += 8;
@@ -26,15 +19,11 @@ export function u64Bigint(
         },
     };
 }
-
-export function s64Bigint(
-    endian: "little" | "big" = "little",
-): Serializer<number | bigint, bigint> {
+export function s64Bigint(endian = "little") {
     return {
         size: 8,
         write: (ctx, value) => {
             checkValue(value, -(2n ** 63n), 2n ** 63n);
-
             ctx.alloc(8);
             ctx.view.setBigInt64(ctx.offset, BigInt(value), endian === "little");
             ctx.offset += 8;

package/dist/structo/datatypes/numbers/floats.d.ts

@@ -0,0 +1,3 @@
+import type { Serializer } from "../../types";
+export declare function f32(endian?: "little" | "big"): Serializer<number>;
+export declare function f64(endian?: "little" | "big"): Serializer<number>;

package/{structo/datatypes/numbers/floats.ts → dist/structo/datatypes/numbers/floats.js}

@@ -1,6 +1,4 @@
-import type { Serializer } from "../../types";
-
-export function f32(endian: "little" | "big" = "little"): Serializer<number> {
+export function f32(endian = "little") {
     return {
         size: 4,
         write: (ctx, value) => {
@@ -15,8 +13,7 @@ export function f32(endian: "little" | "big" = "little"): Serializer<number> {
         },
     };
 }
-
-export function f64(endian: "little" | "big" = "little"): Serializer<number> {
+export function f64(endian = "little") {
     return {
         size: 8,
         write: (ctx, value) => {

package/dist/structo/datatypes/numbers/sints.d.ts

@@ -0,0 +1,5 @@
+import type { Serializer } from "../../types";
+export declare function s8(): Serializer<number>;
+export declare function s16(endian?: "little" | "big"): Serializer<number>;
+export declare function s32(endian?: "little" | "big"): Serializer<number>;
+export declare function s64(endian?: "little" | "big"): Serializer<number>;

package/{structo/datatypes/numbers/sints.ts → dist/structo/datatypes/numbers/sints.js}

@@ -1,21 +1,16 @@
-import type { Serializer } from "../../types";
-
-const checkValue = (value: number, start: number, end: number) => {
+const checkValue = (value, start, end) => {
     if (!Number.isInteger(value)) {
         throw new Error("Not Integer");
     }
-
     if (value < start || value >= end) {
         throw new Error("Out of Range");
     }
 };
-
-export function s8(): Serializer<number> {
+export function s8() {
     return {
         size: 1,
         write: (ctx, value) => {
             checkValue(value, -(2 ** 7), 2 ** 7);
-
             ctx.alloc(1);
             ctx.view.setInt8(ctx.offset, value);
             ctx.offset += 1;
@@ -27,13 +22,11 @@ export function s8(): Serializer<number> {
         },
     };
 }
-
-export function s16(endian: "little" | "big" = "little"): Serializer<number> {
+export function s16(endian = "little") {
     return {
         size: 2,
         write: (ctx, value) => {
             checkValue(value, -(2 ** 15), 2 ** 15);
-
             ctx.alloc(2);
             ctx.view.setInt16(ctx.offset, value, endian === "little");
             ctx.offset += 2;
@@ -45,13 +38,11 @@ export function s16(endian: "little" | "big" = "little"): Serializer<number> {
         },
     };
 }
-
-export function s32(endian: "little" | "big" = "little"): Serializer<number> {
+export function s32(endian = "little") {
     return {
         size: 4,
         write: (ctx, value) => {
             checkValue(value, -(2 ** 31), 2 ** 31);
-
             ctx.alloc(4);
             ctx.view.setInt32(ctx.offset, value, endian === "little");
             ctx.offset += 4;
@@ -63,13 +54,11 @@ export function s32(endian: "little" | "big" = "little"): Serializer<number> {
         },
     };
 }
-
-export function s64(endian: "little" | "big" = "little"): Serializer<number> {
+export function s64(endian = "little") {
     return {
         size: 8,
         write: (ctx, value) => {
             checkValue(value, -(2 ** 63), 2 ** 63);
-
             ctx.alloc(8);
             ctx.view.setBigInt64(ctx.offset, BigInt(value), endian === "little");
             ctx.offset += 8;

package/dist/structo/datatypes/numbers/uints.d.ts

@@ -0,0 +1,5 @@
+import type { Serializer } from "../../types";
+export declare function u8(): Serializer<number>;
+export declare function u16(endian?: "little" | "big"): Serializer<number>;
+export declare function u32(endian?: "little" | "big"): Serializer<number>;
+export declare function u64(endian?: "little" | "big"): Serializer<number>;

package/{structo/datatypes/numbers/uints.ts → dist/structo/datatypes/numbers/uints.js}

@@ -1,17 +1,11 @@
-import type { Serializer } from "../../types";
-
-const checkValue = (value: number, start: number, end: number) => {
-    if (!Number.isInteger(value)) throw new Error("Not Integer");
-    if (value < start || value >= end) throw new Error("Out of Range");
-};
-
-export function u8(): Serializer<number> {
+export function u8() {
     return {
         size: 1,
         write: (ctx, value) => {
-            if (!Number.isInteger(value)) throw new Error("Not Integer");
-            if (value < 0 || value >= 2 ** 8) throw new Error("Out of Range");
-
+            if (!Number.isInteger(value))
+                throw new Error("Not Integer");
+            if (value < 0 || value >= 2 ** 8)
+                throw new Error("Out of Range");
             ctx.alloc(1);
             ctx.view.setUint8(ctx.offset, value);
             ctx.offset += 1;
@@ -23,14 +17,14 @@ export function u8(): Serializer<number> {
         },
     };
 }
-
-export function u16(endian: "little" | "big" = "little"): Serializer<number> {
+export function u16(endian = "little") {
     return {
         size: 2,
         write: (ctx, value) => {
-            if (!Number.isInteger(value)) throw new Error("Not Integer");
-            if (value < 0 || value >= 2 ** 16) throw new Error("Out of Range");
-
+            if (!Number.isInteger(value))
+                throw new Error("Not Integer");
+            if (value < 0 || value >= 2 ** 16)
+                throw new Error("Out of Range");
             ctx.alloc(2);
             ctx.view.setUint16(ctx.offset, value, endian === "little");
             ctx.offset += 2;
@@ -42,14 +36,14 @@ export function u16(endian: "little" | "big" = "little"): Serializer<number> {
         },
     };
 }
-
-export function u32(endian: "little" | "big" = "little"): Serializer<number> {
+export function u32(endian = "little") {
     return {
         size: 4,
         write: (ctx, value) => {
-            if (!Number.isInteger(value)) throw new Error("Not Integer");
-            if (value < 0 || value >= 2 ** 32) throw new Error("Out of Range");
-
+            if (!Number.isInteger(value))
+                throw new Error("Not Integer");
+            if (value < 0 || value >= 2 ** 32)
+                throw new Error("Out of Range");
             ctx.alloc(4);
             ctx.view.setUint32(ctx.offset, value, endian === "little");
             ctx.offset += 4;
@@ -61,14 +55,14 @@ export function u32(endian: "little" | "big" = "little"): Serializer<number> {
         },
     };
 }
-
-export function u64(endian: "little" | "big" = "little"): Serializer<number> {
+export function u64(endian = "little") {
     return {
         size: 8,
         write: (ctx, value) => {
-            if (!Number.isInteger(value)) throw new Error("Not Integer");
-            if (value < 0 || value >= 2 ** 64) throw new Error("Out of Range");
-
+            if (!Number.isInteger(value))
+                throw new Error("Not Integer");
+            if (value < 0 || value >= 2 ** 64)
+                throw new Error("Out of Range");
             ctx.alloc(8);
             ctx.view.setBigUint64(ctx.offset, BigInt(value), endian === "little");
             ctx.offset += 8;

package/dist/structo/datatypes/transforms/pipe.d.ts

@@ -0,0 +1,11 @@
+import type { Serializer } from "../../types";
+export type Transform<T = any, TNext = T> = (type: Serializer<TNext>) => Serializer<T>;
+export declare function pipe<TStart, T1>(type: Serializer<TStart>, p1: Transform<T1, TStart>): Serializer<T1>;
+export declare function pipe<TStart, T1, T2>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>): Serializer<T2>;
+export declare function pipe<TStart, T1, T2, T3>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>): Serializer<T3>;
+export declare function pipe<TStart, T1, T2, T3, T4>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>): Serializer<T4>;
+export declare function pipe<TStart, T1, T2, T3, T4, T5>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>, p5: Transform<T5, T4>): Serializer<T5>;
+export declare function pipe<TStart, T1, T2, T3, T4, T5, T6>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>, p5: Transform<T5, T6>): Serializer<T6>;
+export declare function pipe<TStart, T1, T2, T3, T4, T5, T6, T7>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>, p5: Transform<T5, T6>, p6: Transform<T6, T7>): Serializer<T7>;
+export declare function pipe<TStart, T1, T2, T3, T4, T5, T6, T7, T8>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>, p5: Transform<T5, T6>, p6: Transform<T6, T7>, p7: Transform<T7, T8>): Serializer<T8>;
+export declare function pipe<TStart, T1, T2, T3, T4, T5, T6, T7, T8, T9>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>, p5: Transform<T5, T6>, p6: Transform<T6, T7>, p7: Transform<T7, T8>, p8: Transform<T8, T9>): Serializer<T9>;

package/dist/structo/datatypes/transforms/pipe.js

@@ -0,0 +1,4 @@
+export function pipe(type, ...pipeline) {
+    //@ts-ignore
+    return pipeline.reduce((v, func) => func(v), type);
+}

package/dist/structo/datatypes/transforms/readOffset.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from "../../types";
+export declare function positionOffset<T>(delta: number): (type: Serializer<T>) => Serializer<T>;

package/{structo/datatypes/transforms/readOffset.ts → dist/structo/datatypes/transforms/readOffset.js}

@@ -1,7 +1,5 @@
-import type { Serializer } from "../../types";
-
-export function positionOffset<T>(delta: number) {
-    return (type: Serializer<T>): Serializer<T> => ({
+export function positionOffset(delta) {
+    return (type) => ({
         size: type.size,
         read: (ctx) => {
             let start = ctx.offset;

package/dist/structo/datatypes/transforms/transform.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from "../../types";
+export declare function transform<T>(callback: (value: T) => T): (type: Serializer<T>) => Serializer<T>;

package/{structo/datatypes/transforms/transform.ts → dist/structo/datatypes/transforms/transform.js}

@@ -1,7 +1,5 @@
-import type { Serializer } from "../../types";
-
-export function transform<T>(callback: (value: T) => T) {
-    return (type: Serializer<T>): Serializer<T> => ({
+export function transform(callback) {
+    return (type) => ({
         size: type.size,
         read: (ctx) => {
             const value = type.read(ctx);

package/dist/structo/datatypes/values/buffer.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from "../../types";
+export declare function buffer(size: number): Serializer<ArrayBuffer>;

package/{structo/datatypes/values/buffer.ts → dist/structo/datatypes/values/buffer.js}

@@ -1,12 +1,10 @@
-import type { Serializer } from "../../types";
-
-export function buffer(size: number): Serializer<ArrayBuffer> {
+export function buffer(size) {
     return {
         size,
         write: (ctx, value) => {
             const bytes = new Uint8Array(value);
-            if (bytes.length !== size) throw new Error("Invalid Length");
-
+            if (bytes.length !== size)
+                throw new Error("Invalid Length");
             ctx.alloc(size);
             new Uint8Array(ctx.buffer).set(bytes, ctx.offset);
             ctx.offset += size;

package/dist/structo/datatypes/values/byteliteral.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from "../../types";
+export declare function byteLiteral(bytes: number[]): Serializer<number[]>;

package/{structo/datatypes/values/byteliteral.ts → dist/structo/datatypes/values/byteliteral.js}

@@ -1,13 +1,9 @@
-import type { Serializer } from "../../types";
-
-export function byteLiteral(bytes: number[]): Serializer<number[]> {
+export function byteLiteral(bytes) {
     const length = bytes.length;
-
     return {
         size: bytes.length,
         read: (ctx) => {
             const arr = new Uint8Array(ctx.view.buffer);
-
             for (let i = 0; i < length; i++) {
                 if (arr[ctx.offset + i] !== bytes[i]) {
                     throw new Error("Invalid Value");

package/dist/structo/datatypes/values/string.d.ts

@@ -0,0 +1,2 @@
+import type { Serializer } from "../../types";
+export declare function string(length: Serializer<number>): Serializer<string>;

package/{structo/datatypes/values/string.ts → dist/structo/datatypes/values/string.js}

@@ -1,21 +1,14 @@
-import type { Serializer } from "../../types";
-
-export function string(length: Serializer<number>): Serializer<string> {
+export function string(length) {
     const { read: readLength, write: writeLength } = length;
     const encoder = new TextEncoder();
     const decoder = new TextDecoder();
-
     return {
         write: (ctx, value) => {
             const bytes = encoder.encode(value);
-
             writeLength(ctx, bytes.byteLength);
-
             ctx.alloc(bytes.byteLength);
-
             const arr = new Uint8Array(ctx.view.buffer);
             arr.set(bytes, ctx.offset);
-
             ctx.offset += bytes.byteLength;
         },
         read: (ctx) => {

package/dist/structo/index.d.ts

@@ -0,0 +1,4 @@
+export type { InferInput as Infer, InferInput, InferOutput, ReaderContext, WriterContext, Serializer, } from "./types";
+export * from "./datatypes";
+export { write, createdWriterContext } from "./write";
+export { read, createReaderContext } from "./read";

package/dist/structo/index.js

@@ -0,0 +1,3 @@
+export * from "./datatypes";
+export { write, createdWriterContext } from "./write";
+export { read, createReaderContext } from "./read";

package/dist/structo/read.d.ts

@@ -0,0 +1,7 @@
+import type { Serializer } from "./types";
+export declare function read<T>(serializer: Serializer<T>, buffer: ArrayBuffer): T;
+export declare function createReaderContext(buffer: ArrayBuffer): {
+    offset: number;
+    buffer: ArrayBuffer;
+    view: DataView<ArrayBuffer>;
+};

package/dist/structo/read.js

@@ -0,0 +1,10 @@
+export function read(serializer, buffer) {
+    return serializer.read(createReaderContext(buffer));
+}
+export function createReaderContext(buffer) {
+    return {
+        offset: 0,
+        buffer,
+        view: new DataView(buffer),
+    };
+}

package/{structo/types.ts → dist/structo/types.d.ts}

@@ -3,19 +3,16 @@ export type Serializer<TIn, TOut = TIn> = {
     write: (ctx: WriterContext, value: TIn) => void;
     read: (ctx: ReaderContext) => TOut;
 };
-
 export interface WriterContext {
     buffer: ArrayBuffer;
     view: DataView;
     offset: number;
     alloc: (length: number) => void;
 }
-
 export interface ReaderContext {
     buffer: ArrayBuffer;
     view: DataView;
     offset: number;
 }
-
 export type InferInput<T> = T extends Serializer<infer V> ? V : never;
 export type InferOutput<T> = T extends Serializer<any, infer V> ? V : never;

package/dist/structo/types.js

@@ -0,0 +1 @@
+export {};