@nnilky/structo 1.0.1 → 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/dist/structo/datatypes/containers/array.js

@@ -0,0 +1,22 @@
+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);
+            for (let i = 0; i < size; i++) {
+                writeType(ctx, value[i]);
+            }
+        },
+        read: (ctx) => {
+            const arr = new Array(size);
+            for (let i = 0; i < size; i++) {
+                arr[i] = readType(ctx);
+            }
+            return arr;
+        },
+    };
+}

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/dist/structo/datatypes/containers/fastObject.js

@@ -0,0 +1,46 @@
+const definitionSymbol = Symbol();
+export function fastObject(definition) {
+    let serializers = [];
+    let writeBody = "";
+    let readBody = "";
+    function generateSerializers(serializer, keys) {
+        if (definitionSymbol in serializer) {
+            const definition = serializer[definitionSymbol];
+            readBody += `${keys[keys.length - 1]}: {`;
+            for (const key of Object.keys(definition)) {
+                generateSerializers(definition[key], [...keys, key]);
+            }
+            readBody += `},`;
+        }
+        else {
+            let path = "";
+            for (const key of keys) {
+                if (key.match(/[a-zA-Z_][a-zA-Z0-9_]*/)) {
+                    path += `.${key}`;
+                }
+                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 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, 0);
+    return {
+        //@ts-ignore
+        [definitionSymbol]: definition,
+        size: isNaN(size) ? undefined : size,
+        write,
+        read,
+    };
+}

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/dist/structo/datatypes/containers/list.js

@@ -0,0 +1,22 @@
+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);
+            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);
+            }
+            return arr;
+        },
+    };
+}

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/dist/structo/datatypes/containers/sizedbuffer.js

@@ -0,0 +1,17 @@
+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);
+            ctx.offset += value.byteLength;
+        },
+        read: (ctx) => {
+            const size = length.read(ctx);
+            const slice = ctx.buffer.slice(ctx.offset, ctx.offset + size);
+            ctx.offset += size;
+            return slice;
+        },
+    };
+}

package/dist/structo/datatypes/index.d.ts

@@ -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 { 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/dist/structo/datatypes/numbers/bigints.js

@@ -0,0 +1,37 @@
+const checkValue = (value, start, end) => {
+    if (value < start || value >= end) {
+        throw new Error("Out of Range");
+    }
+};
+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;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getBigUint64(ctx.offset, endian === "little");
+            ctx.offset += 8;
+            return value;
+        },
+    };
+}
+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;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getBigInt64(ctx.offset, endian === "little");
+            ctx.offset += 8;
+            return value;
+        },
+    };
+}

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/dist/structo/datatypes/numbers/floats.js

@@ -0,0 +1,30 @@
+export function f32(endian = "little") {
+    return {
+        size: 4,
+        write: (ctx, value) => {
+            ctx.alloc(4);
+            ctx.view.setFloat32(ctx.offset, value, endian === "little");
+            ctx.offset += 4;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getFloat32(ctx.offset, endian === "little");
+            ctx.offset += 4;
+            return value;
+        },
+    };
+}
+export function f64(endian = "little") {
+    return {
+        size: 8,
+        write: (ctx, value) => {
+            ctx.alloc(8);
+            ctx.view.setFloat64(ctx.offset, value, endian === "little");
+            ctx.offset += 8;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getFloat64(ctx.offset, endian === "little");
+            ctx.offset += 8;
+            return 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/dist/structo/datatypes/numbers/sints.js

@@ -0,0 +1,72 @@
+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() {
+    return {
+        size: 1,
+        write: (ctx, value) => {
+            checkValue(value, -(2 ** 7), 2 ** 7);
+            ctx.alloc(1);
+            ctx.view.setInt8(ctx.offset, value);
+            ctx.offset += 1;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getInt8(ctx.offset);
+            ctx.offset += 1;
+            return value;
+        },
+    };
+}
+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;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getInt16(ctx.offset, endian === "little");
+            ctx.offset += 2;
+            return value;
+        },
+    };
+}
+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;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getInt32(ctx.offset, endian === "little");
+            ctx.offset += 4;
+            return value;
+        },
+    };
+}
+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;
+        },
+        read: (ctx) => {
+            const value = Number(ctx.view.getBigInt64(ctx.offset, endian === "little"));
+            ctx.offset += 8;
+            return value;
+        },
+    };
+}

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/dist/structo/datatypes/numbers/uints.js

@@ -0,0 +1,76 @@
+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");
+            ctx.alloc(1);
+            ctx.view.setUint8(ctx.offset, value);
+            ctx.offset += 1;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getUint8(ctx.offset);
+            ctx.offset += 1;
+            return value;
+        },
+    };
+}
+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");
+            ctx.alloc(2);
+            ctx.view.setUint16(ctx.offset, value, endian === "little");
+            ctx.offset += 2;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getUint16(ctx.offset, endian === "little");
+            ctx.offset += 2;
+            return value;
+        },
+    };
+}
+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");
+            ctx.alloc(4);
+            ctx.view.setUint32(ctx.offset, value, endian === "little");
+            ctx.offset += 4;
+        },
+        read: (ctx) => {
+            const value = ctx.view.getUint32(ctx.offset, endian === "little");
+            ctx.offset += 4;
+            return value;
+        },
+    };
+}
+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");
+            ctx.alloc(8);
+            ctx.view.setBigUint64(ctx.offset, BigInt(value), endian === "little");
+            ctx.offset += 8;
+        },
+        read: (ctx) => {
+            const value = Number(ctx.view.getBigUint64(ctx.offset, endian === "little"));
+            ctx.offset += 8;
+            return value;
+        },
+    };
+}

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/dist/structo/datatypes/transforms/readOffset.js

@@ -0,0 +1,18 @@
+export function positionOffset(delta) {
+    return (type) => ({
+        size: type.size,
+        read: (ctx) => {
+            let start = ctx.offset;
+            ctx.offset += delta;
+            const value = type.read(ctx);
+            ctx.offset = start;
+            return value;
+        },
+        write: (ctx, value) => {
+            let start = ctx.offset;
+            ctx.offset += delta;
+            type.write(ctx, value);
+            ctx.offset = start;
+        },
+    });
+}

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/dist/structo/datatypes/transforms/transform.js

@@ -0,0 +1,13 @@
+export function transform(callback) {
+    return (type) => ({
+        size: type.size,
+        read: (ctx) => {
+            const value = type.read(ctx);
+            return callback(value);
+        },
+        write: (ctx, value) => {
+            let outValue = callback(value);
+            type.write(ctx, outValue);
+        },
+    });
+}

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/dist/structo/datatypes/values/buffer.js

@@ -0,0 +1,18 @@
+export function buffer(size) {
+    return {
+        size,
+        write: (ctx, value) => {
+            const bytes = new Uint8Array(value);
+            if (bytes.length !== size)
+                throw new Error("Invalid Length");
+            ctx.alloc(size);
+            new Uint8Array(ctx.buffer).set(bytes, ctx.offset);
+            ctx.offset += size;
+        },
+        read: (ctx) => {
+            const slice = ctx.buffer.slice(ctx.offset, ctx.offset + size);
+            ctx.offset += size;
+            return slice;
+        },
+    };
+}

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/dist/structo/datatypes/values/byteliteral.js

@@ -0,0 +1,20 @@
+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");
+                }
+            }
+            ctx.offset += length;
+            return bytes;
+        },
+        write(ctx) {
+            new Uint8Array(ctx.view.buffer).set(bytes, ctx.offset);
+            ctx.offset += length;
+        },
+    };
+}

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/dist/structo/datatypes/values/string.js

@@ -0,0 +1,21 @@
+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) => {
+            const length = readLength(ctx);
+            const section = ctx.buffer.slice(ctx.offset, ctx.offset + length);
+            ctx.offset += length;
+            return decoder.decode(section);
+        },
+    };
+}

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/dist/structo/types.d.ts

@@ -0,0 +1,18 @@
+export type Serializer<TIn, TOut = TIn> = {
+    size?: number | undefined;
+    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 {};

package/dist/structo/write.d.ts

@@ -0,0 +1,3 @@
+import type { WriterContext, Serializer } from "./types";
+export declare function write<T>(serializer: Serializer<T>, value: T): ArrayBuffer;
+export declare function createdWriterContext(type: Serializer<any>): WriterContext;

package/dist/structo/write.js

@@ -0,0 +1,41 @@
+export function write(serializer, value) {
+    const ctx = createdWriterContext(serializer);
+    serializer.write(ctx, value);
+    if (ctx.buffer.byteLength === ctx.offset) {
+        return ctx.buffer;
+    }
+    else {
+        return ctx.buffer.transfer(ctx.offset);
+    }
+}
+export function createdWriterContext(type) {
+    if (type.size) {
+        let buffer = new ArrayBuffer(type.size);
+        const view = new DataView(buffer);
+        return {
+            offset: 0,
+            buffer,
+            view,
+            alloc: Function.prototype,
+        };
+    }
+    else {
+        let bufferLength = 64;
+        let buffer = new ArrayBuffer(bufferLength);
+        const view = new DataView(buffer);
+        return {
+            offset: 0,
+            buffer,
+            view,
+            alloc(length) {
+                if (length < 0)
+                    return;
+                while (this.offset + length >= bufferLength) {
+                    bufferLength = this.buffer.byteLength * 2;
+                    this.buffer = this.buffer.transfer(bufferLength);
+                    this.view = new DataView(this.buffer);
+                }
+            },
+        };
+    }
+}

package/package.json

@@ -3,7 +3,7 @@
   "description": "A library for serializing and deserializing binary content",
   "keywords": ["binary", "library", "utility", "web", "node"],
   "license": "ISC",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "author": "Ben Brady",
   "private": false,
   "publishConfig": {"access": "public"},
@@ -34,9 +34,9 @@
   "files": [
     "LICENSE",
     "README.md",
-    "./dist/*.d.ts",
-    "./dist/*.js.map",
-    "./dist/*.js"
+    "./dist/**/*.d.ts",
+    "./dist/**/*.js.map",
+    "./dist/**/*.js"
   ],
 
   "scripts": {