@nnilky/structo 1.0.8 → 1.1.0

package/dist/utilities/index.js

@@ -1,3 +1,3 @@
-export { lazy } from "./lazy";
-export { createReference } from "./reference";
-export { createRememberedValue } from "./remember";
+export { lazy } from "./lazy.js";
+export { createReference } from "./reference.js";
+export { createRememberedValue } from "./remember.js";

package/dist/utilities/lazy.d.ts

@@ -1,2 +1,2 @@
-import type { Serializer } from "../types";
+import type { Serializer } from "../types.js";
 export declare function lazy<TIn, TOut = TIn>(type: () => Serializer<TIn, TOut>): Serializer<TIn, TOut>;

package/dist/utilities/lazy.test.js

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
-import { encodeTest } from "../utils.test";
-import * as st from "../index";
+import { encodeTest } from "../utils.test.js";
+import * as st from "../index.js";
 describe("st.lazy", () => {
     it("encodes correctly", () => {
         const spec = st.lazy(() => st.object({

package/dist/utilities/reference.d.ts

@@ -1,4 +1,4 @@
-import type { Serializer } from "../types";
+import type { Serializer } from "../types.js";
 /**
  * createReference lets you defer writing a value until later, useful for lengths and sizes
  *

package/dist/utilities/reference.test.js

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
-import { encodeTest, encodeSnapshotTest, expectError } from "../utils.test";
-import * as st from "../index";
+import { encodeTest, encodeSnapshotTest, expectError } from "../utils.test.js";
+import * as st from "../index.js";
 describe("st.createReference", () => {
     it("encodes correctly", () => {
         const length = st.createReference();

package/dist/utilities/remember.d.ts

@@ -1,11 +1,11 @@
-import type { Serializer } from "../types";
+import type { Serializer } from "../types.js";
 /**
  * createRememberedValue lets you save and recall a value when serializing
  *
  * This is useful for checksums and other values calculated from a writen value
  *
  * ```
- * const data = st.createRememberedValue<ArrayBuffer>()
+ * const data = st.createRememberedValue<Uint8Array>()
  * st.object({
  *   data: data.save(st.bytes(1024))
  *   checksum: crc32(data.load())

package/dist/utilities/remember.js

@@ -4,7 +4,7 @@
  * This is useful for checksums and other values calculated from a writen value
  *
  * ```
- * const data = st.createRememberedValue<ArrayBuffer>()
+ * const data = st.createRememberedValue<Uint8Array>()
  * st.object({
  *   data: data.save(st.bytes(1024))
  *   checksum: crc32(data.load())
@@ -18,7 +18,7 @@ export function createRememberedValue() {
      *
      * ---
      * ```
-     * const data = st.createRememberedValue<ArrayBuffer>()
+     * const data = st.createRememberedValue<Uint8Array>()
      * st.object({
      *   data: data.save(st.bytes(1024))
      *   checksum: crc32(data.load())
@@ -50,7 +50,7 @@ export function createRememberedValue() {
      *
      * ---
      * ```
-     * const data = st.createRememberedValue<ArrayBuffer>()
+     * const data = st.createRememberedValue<Uint8Array>()
      * st.object({
      *   data: data.save(st.bytes(1024))
      *   checksum: crc32(data.load())

package/dist/utilities/remember.test.js

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
-import { encodeTest, encodeSnapshotTest } from "../utils.test";
-import * as st from "../index";
+import { encodeTest, encodeSnapshotTest } from "../utils.test.js";
+import * as st from "../index.js";
 describe("st.remember", () => {
     it("encodes correctly", () => {
         const v = st.createRememberedValue();

package/dist/utils.test.d.ts

@@ -1,4 +1,4 @@
-import * as st from "./index";
+import * as st from "./index.js";
 export declare const randint: (start: number, end: number) => number;
 export declare const randbigint: (start: bigint, end: bigint) => bigint;
 export declare const encodeTest: <TIn, TOut>(serializer: st.Serializer<TIn, TOut>, value: TIn, expected?: TOut) => void;
@@ -6,4 +6,4 @@ export declare const encodeFailTest: <TIn, TOut>(serializer: st.Serializer<TIn,
 export declare const expectEncodeSize: <TIn, TOut>(serializer: st.Serializer<TIn, TOut>, size: number, value: TIn) => void;
 export declare const encodeSnapshotTest: <T>(serializer: st.Serializer<T>, value: T) => void;
 export declare const expectError: (callback: () => void) => void;
-export declare const bytes: (bytes: number[]) => ArrayBuffer;
+export declare const bytes: (bytes: number[]) => Uint8Array<ArrayBuffer>;

package/dist/utils.test.js

@@ -1,6 +1,6 @@
 //@ts-ignore TODO
 import { describe, it, expect } from "bun:test";
-import * as st from "./index";
+import * as st from "./index.js";
 export const randint = (start, end) => {
     const range = end - start;
     return Math.floor(start + range * Math.random());
@@ -37,6 +37,4 @@ export const expectError = (callback) => {
     }
     throw new Error("Expected Error");
 };
-export const bytes = (bytes) => {
-    return new Uint8Array(bytes).buffer;
-};
+export const bytes = (bytes) => new Uint8Array(bytes);

package/dist/write.d.ts

@@ -1,3 +1,3 @@
-import type { WriterContext, Serializer } from "./types";
+import type { Serializer } from "./types.js";
 export declare function write<TIn, TOut>(serializer: Serializer<TIn, TOut>, value: TIn): ArrayBuffer;
-export declare function createdWriterContext(type: Serializer<any>): WriterContext;
+export declare function writeInto<TIn, TOut, TBuffer extends ArrayBuffer | SharedArrayBuffer>(buffer: TBuffer, offset: number, serializer: Serializer<TIn, TOut>, value: TIn): void;

package/dist/write.js

@@ -1,49 +1,62 @@
 export function write(serializer, value) {
-    const ctx = createdWriterContext(serializer);
+    let byteLength = serializer.size ?? 4096;
+    let buffer_ = new ArrayBuffer(byteLength);
+    let ctx = {
+        path: [],
+        offset: 0,
+        buffer: buffer_,
+        bytes: new Uint8Array(buffer_),
+        view: new DataView(buffer_),
+        reserve: (length) => {
+            if (length <= 0)
+                return;
+            while (ctx.offset + length > byteLength) {
+                byteLength *= 2;
+                ctx.buffer = ctx.buffer.transfer(byteLength);
+                ctx.view = new DataView(ctx.buffer);
+                ctx.bytes = new Uint8Array(ctx.buffer);
+            }
+        },
+    };
+    if (serializer.size) {
+        ctx.reserve = (length) => {
+            if (ctx.offset + length > byteLength) {
+                throw new Error("Attempted to allocate space when writing into buffer");
+            }
+        };
+    }
     try {
         serializer.write(ctx, value);
     }
     catch (e) {
-        const path = ctx.stack.join("") ?? "root";
-        throw new Error(`Serialization error at value${path}`, { cause: e });
+        const path = ctx.path.length === 0 ? "root" : "value" + ctx.path.join("");
+        throw new Error(`Serialization error at ${path}`, { cause: e });
     }
     if (ctx.buffer.byteLength === ctx.offset) {
         return ctx.buffer;
     }
     else {
-        return ctx.buffer.transfer(ctx.offset);
+        return ctx.buffer.transferToFixedLength(ctx.offset);
     }
 }
-export function createdWriterContext(type) {
-    if (type.size) {
-        let buffer = new ArrayBuffer(type.size);
-        const view = new DataView(buffer);
-        return {
-            stack: [],
-            offset: 0,
-            buffer,
-            view,
-            alloc: Function.prototype,
-        };
+export function writeInto(buffer, offset, serializer, value) {
+    let ctx = {
+        path: [],
+        offset: offset,
+        buffer: buffer,
+        bytes: new Uint8Array(buffer),
+        view: new DataView(buffer),
+        reserve(length) {
+            if (ctx.offset + length > ctx.buffer.byteLength) {
+                throw new Error("Attempted to allocate space when writing into buffer");
+            }
+        },
+    };
+    try {
+        serializer.write(ctx, value);
     }
-    else {
-        let bufferLength = 64;
-        let buffer = new ArrayBuffer(bufferLength);
-        const view = new DataView(buffer);
-        return {
-            stack: [],
-            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);
-                }
-            },
-        };
+    catch (e) {
+        const path = ctx.path.join("") ?? "root";
+        throw new Error(`Serialization error at value${path}`, { cause: e });
     }
 }

package/package.json

@@ -9,7 +9,7 @@
     "node"
   ],
   "license": "ISC",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "author": "Ben Brady",
   "private": false,
   "publishConfig": {
@@ -49,13 +49,18 @@
     "@types/node": "^25.9.2",
     "bun-types": "^1.3.14",
     "jest": "^30.4.2",
+    "tsx": "^4.22.4",
     "typescript": "^6.0.3"
   },
+  "dependencies": {
+    "@mitata/counters": "^0.0.8",
+    "mitata": "^1.0.34"
+  },
   "scripts": {
     "build": "tsc",
     "prepublish": "tsc",
     "check": "tsc --noEmit",
-    "test": "bun test src --only-failures",
+    "test": "bun test src ",
     "test:coverage": "bun test src --only-failures --coverage"
   }
 }

package/dist/datatypes/containers/sizedbytes.d.ts

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

package/dist/datatypes/containers/sizedbytes.js

@@ -1,17 +0,0 @@
-export function sizedBytes(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/datatypes/containers/sizedbytes.test.d.ts

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

package/dist/datatypes/containers/sizedbytes.test.js

@@ -1,27 +0,0 @@
-import { describe, it } from "bun:test";
-import { bytes, expectEncode, expectError } from "../utils.test";
-import * as st from "../../index";
-describe("st.sizedBytes", () => {
-    it("encode correctly", () => {
-        const buffer = st.sizedBytes(st.u8());
-        expectEncode(buffer, bytes([1, 2]));
-    });
-    it("encodes empty correctly", () => {
-        const spec = st.sizedBytes(st.u8());
-        expectEncode(spec, bytes([]));
-    });
-    it("holds large data", () => {
-        const size = 1024 * 1024 * 8; // 8MB
-        const spec = st.sizedBytes(st.u32());
-        const data = new Uint8Array(size);
-        data.set([3, 4], 1000);
-        data.set([3, 4], 2000);
-        expectEncode(spec, data.buffer);
-    });
-    it("errors on invalid length", () => {
-        const spec = st.sizedBytes(st.u8());
-        expectError(() => {
-            st.write(spec, bytes(Array.from({ length: 256 }, () => 0)));
-        });
-    });
-});

package/dist/datatypes/containers/string.d.ts

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

package/dist/datatypes/containers/string.js

@@ -1,24 +0,0 @@
-export function string(length) {
-    const encoder = new TextEncoder();
-    const decoder = new TextDecoder();
-    const lengthSize = length.size ?? 0;
-    return {
-        write: (ctx, value) => {
-            if (typeof value !== "string")
-                throw new Error("Expected String to encoder");
-            const bytes = encoder.encode(value);
-            const size = bytes.byteLength;
-            ctx.alloc(size + lengthSize);
-            length.write(ctx, size);
-            const arr = new Uint8Array(ctx.buffer, ctx.offset);
-            arr.set(bytes);
-            ctx.offset += size;
-        },
-        read: (ctx) => {
-            const size = length.read(ctx);
-            const section = ctx.buffer.slice(ctx.offset, ctx.offset + size);
-            ctx.offset += size;
-            return decoder.decode(section);
-        },
-    };
-}

package/dist/datatypes/containers/string.test.d.ts

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

package/dist/datatypes/containers/string.test.js

@@ -1,24 +0,0 @@
-import { describe, it } from "bun:test";
-import { expectEncode, expectError } from "../utils.test";
-import * as st from "../../index";
-describe("st.string", () => {
-    const string_u8 = st.string(st.u8());
-    const string_u32 = st.string(st.u32());
-    it("encode correctly", () => {
-        expectEncode(string_u8, "foo");
-    });
-    it("works on empty strings", () => {
-        expectEncode(string_u32, "");
-    });
-    it("errors on numbers", () => {
-        expectError(() => {
-            //@ts-expect-error, intentional mistake
-            st.write(st.string(st.u8()), 8);
-        });
-    });
-    it("errors on too long strings", () => {
-        expectError(() => {
-            st.write(string_u8, "A".repeat(256));
-        });
-    });
-});

package/dist/datatypes/transforms/encode.d.ts

@@ -1,2 +0,0 @@
-import type { Transform } from "./pipe";
-export declare function encode<TIn, TOut>(encodeTo: (value: TIn) => TOut, encodeFrom: (value: TOut) => TIn): Transform<TOut, TIn>;

package/dist/datatypes/transforms/encode.js

@@ -1,7 +0,0 @@
-export function encode(encodeTo, encodeFrom) {
-    return (type) => ({
-        size: type.size,
-        read: (ctx) => encodeTo(type.read(ctx)),
-        write: (ctx, value) => type.write(ctx, encodeFrom(value)),
-    });
-}

package/dist/datatypes/transforms/fixedOffset.d.ts

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

package/dist/datatypes/transforms/fixedOffset.js

@@ -1,18 +0,0 @@
-export function fixedOffset(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/datatypes/transforms/modify.d.ts

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

package/dist/datatypes/transforms/modify.js

@@ -1,7 +0,0 @@
-export function modify(callback) {
-    return (type) => ({
-        size: type.size,
-        read: (ctx) => callback(type.read(ctx)),
-        write: (ctx, value) => type.write(ctx, callback(value)),
-    });
-}

package/dist/datatypes/transforms/noAdvance.d.ts

@@ -1,16 +0,0 @@
-import type { Serializer } from "../../types";
-/**
- * Whilst reading this type, don't advance the offset after reading
- *
- * This can be useful for taggedUnions where they key is the first value in all the variants
- *
- * ```
- * st.object({
- *     stringLength: st.pipe(
- *         st.u16(),
- *         st.noAdvance(),
- *     ),
- *     text: st.string(st.u16()),
- * })
- */
-export declare function noAdvance<T>(): (type: Serializer<T>) => Serializer<T>;

package/dist/datatypes/transforms/noAdvance.js

@@ -1,30 +0,0 @@
-/**
- * Whilst reading this type, don't advance the offset after reading
- *
- * This can be useful for taggedUnions where they key is the first value in all the variants
- *
- * ```
- * st.object({
- *     stringLength: st.pipe(
- *         st.u16(),
- *         st.noAdvance(),
- *     ),
- *     text: st.string(st.u16()),
- * })
- */
-export function noAdvance() {
-    return (type) => ({
-        size: type.size,
-        read: (ctx) => {
-            let start = ctx.offset;
-            const value = type.read(ctx);
-            ctx.offset = start;
-            return value;
-        },
-        write: (ctx, value) => {
-            let start = ctx.offset;
-            type.write(ctx, value);
-            ctx.offset = start;
-        },
-    });
-}

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

@@ -1,11 +0,0 @@
-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/datatypes/transforms/pipe.js

@@ -1,16 +0,0 @@
-/**
- * Pipe lets you chain modification functions together
- * ```
- * st.object({
- *   age: st.u32(),
- *   ageInMonths: st.pipe(
- *     st.u32(),
- *     st.modify(v => v * 12),
- *     st.offset(-8),
- *   )})
- * ```
- */
-export function pipe(type, ...pipeline) {
-    //@ts-ignore
-    return pipeline.reduce((v, func) => func(v), type);
-}

package/dist/datatypes/utilities/remember.d.ts

@@ -1,15 +0,0 @@
-import type { Serializer } from "../../types";
-/**
- * ```
- * const length = st.createRememberedValue<number>()
- * st.object({
- *   length: length.save(st.u32()),
- *   type: st.u8(),
- *   data: st.sizedBytes(length.load())
- * })
- * ```
- */
-export declare function createRememberedValue<T>(): {
-    save: (serializer: Serializer<T>) => Serializer<T>;
-    load: (serializer?: Serializer<T>) => Serializer<T>;
-};

package/dist/datatypes/utilities/remember.js

@@ -1,36 +0,0 @@
-/**
- * ```
- * const length = st.createRememberedValue<number>()
- * st.object({
- *   length: length.save(st.u32()),
- *   type: st.u8(),
- *   data: st.sizedBytes(length.load())
- * })
- * ```
- */
-export function createRememberedValue() {
-    const stack = [];
-    function save(serializer) {
-        return {
-            size: serializer.size,
-            read: (ctx) => {
-                const value = serializer.read(ctx);
-                stack.push(value);
-                return value;
-            },
-            write: (ctx, value) => {
-                serializer.write(ctx, value);
-                stack.push(value);
-                return value;
-            },
-        };
-    }
-    function load(serializer) {
-        return {
-            size: serializer?.size ?? 0,
-            read: () => stack.pop(),
-            write: (ctx) => serializer && serializer.write(ctx, stack.pop()),
-        };
-    }
-    return { save: save, load: load };
-}

package/dist/datatypes/utilities/remember.test.d.ts

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

package/dist/datatypes/utilities/remember.test.js

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { expectEncode, expectEncodeSnapshot } from "../utils.test";
-import * as st from "../../index";
-describe("st.remember", () => {
-    const v = st.createRememberedValue();
-    it("encodes correctly", () => {
-        const spec = st.object({
-            a: v.save(st.u32()),
-            b: st.list(v.load(), st.u8()),
-        });
-        expectEncode(spec, {
-            a: 3,
-            b: [1, 3, 4],
-        });
-    });
-    it("omitted serializer doesn't write data ", () => {
-        const spec = st.object({
-            a: v.save(st.u32()),
-            b: v.load(),
-        });
-        const output = st.write(spec, { a: 3, b: 0 });
-        expect(output.byteLength).toBe(4);
-    });
-    it("serializer is used write data ", () => {
-        const spec = st.object({
-            a: v.save(st.u32()),
-            b: v.load(st.u8()),
-        });
-        expectEncode(spec, { a: 3, b: 0 }, { a: 3, b: 3 });
-    });
-    it("snapshots are correct", () => {
-        expectEncodeSnapshot(st.object({
-            a: v.save(st.u32()),
-            b: st.list(v.load(), st.u8()),
-        }), {
-            a: 3,
-            b: [1, 3, 4],
-        });
-        expectEncodeSnapshot(st.object({
-            a: v.save(st.u32()),
-            b: v.load(st.u8()),
-        }), { a: 3, b: 0 });
-    });
-});

package/dist/datatypes/utils.test.d.ts

@@ -1,8 +0,0 @@
-import * as st from "../index";
-export declare const randint: (start: number, end: number) => number;
-export declare const randbigint: (start: bigint, end: bigint) => bigint;
-export declare const expectEncode: <TIn, TOut>(serializer: st.Serializer<TIn, TOut>, value: TIn, expected?: TOut) => void;
-export declare const expectEncodeSize: <TIn, TOut>(serializer: st.Serializer<TIn, TOut>, size: number, value: TIn) => void;
-export declare const expectEncodeSnapshot: <T>(serializer: st.Serializer<T>, value: T) => void;
-export declare const expectError: (callback: () => void) => void;
-export declare const bytes: (bytes: number[]) => ArrayBuffer;

package/dist/datatypes/utils.test.js

@@ -1,37 +0,0 @@
-//@ts-ignore TODO
-import { describe, it, expect } from "bun:test";
-import * as st from "../index";
-export const randint = (start, end) => {
-    const range = end - start;
-    return Math.floor(start + range * Math.random());
-};
-export const randbigint = (start, end) => {
-    const range = end - start;
-    const offset = BigInt(Math.floor(Number(range) * Math.random()));
-    return start + offset;
-};
-export const expectEncode = (serializer, value, expected) => {
-    const data = st.write(serializer, value);
-    const newValue = st.read(serializer, data);
-    expect(newValue).toEqual((expected ?? value));
-};
-export const expectEncodeSize = (serializer, size, value) => {
-    const data = st.write(serializer, value);
-    expect(data.byteLength).toEqual(size);
-};
-export const expectEncodeSnapshot = (serializer, value) => {
-    const data = st.write(serializer, value);
-    expect(data).toMatchSnapshot();
-};
-export const expectError = (callback) => {
-    try {
-        callback();
-    }
-    catch {
-        return;
-    }
-    throw new Error("Expected Error");
-};
-export const bytes = (bytes) => {
-    return new Uint8Array(bytes).buffer;
-};

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

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