@nnilky/structo 1.0.5 → 1.0.8

package/README.md

@@ -21,9 +21,9 @@ const Entity = st.object({
 ```
 
 - Lightweight, base size is <1KB and each datatype is a few hundred bytes
-- Fast, from [benchmarks](./benchmark) only 2-
-- Supports Web/Node.js compatible
-- Easily implemented
+- Fast![benchmarks](./benchmark) show only 1.5-5x slower than ideal implementaiton
+- Designed for both Web/Node.js compatible
+- Easily implement your own serializers
 
 Each serializer is completely seperate from the base library, meaning you only pay for what you use.
 

package/dist/datatypes/containers/array.js

@@ -7,6 +7,7 @@
  *
  */
 export function array(size, type) {
+    const SHOW_ERRORS = size < 4096;
     const { read: readType, write: writeType, size: typeSize } = type;
     return {
         size: type.size ? size * type.size : undefined,
@@ -16,13 +17,21 @@ export function array(size, type) {
             if (typeSize)
                 ctx.alloc(size * typeSize);
             for (let i = 0; i < size; i++) {
+                if (SHOW_ERRORS)
+                    ctx.stack.push(`[${i}]`);
                 writeType(ctx, value[i]);
+                if (SHOW_ERRORS)
+                    ctx.stack.pop();
             }
         },
         read: (ctx) => {
             const arr = new Array(size);
             for (let i = 0; i < size; i++) {
+                if (SHOW_ERRORS)
+                    ctx.stack.push(`[${i}]`);
                 arr[i] = readType(ctx);
+                if (SHOW_ERRORS)
+                    ctx.stack.pop();
             }
             return arr;
         },

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

@@ -1,22 +1,18 @@
 import { describe, it } from "bun:test";
-import { expectEncode, expectError } from "../utils.test";
+import { encodeTest, encodeFailTest } from "../../utils.test";
 import * as st from "../../index";
 describe("st.array", () => {
     it("encode correctly", () => {
-        const spec = st.array(4, st.u16());
-        expectEncode(spec, [1, 2, 3, 4]);
+        encodeTest(st.array(4, st.u16()), [1, 2, 3, 4]);
     });
     it("works on empty lists", () => {
-        const spec = st.array(0, st.u16());
-        expectEncode(spec, []);
+        encodeTest(st.array(0, st.u16()), []);
     });
     it("throws error on invalid size", () => {
-        const spec = st.array(2, st.u16());
-        expectError(() => st.write(spec, [1]));
+        encodeFailTest(st.array(2, st.u16()), [1]);
     });
     it("throws error on invalid value", () => {
-        const spec = st.array(2, st.u16());
-        expectError(() => st.write(spec, [1, -1]));
-        expectError(() => st.write(spec, [2 ** 16 + 1, 0]));
+        encodeFailTest(st.array(2, st.u16()), [1, -1]);
+        encodeFailTest(st.array(2, st.u16()), [2 ** 16 + 1, 0]);
     });
 });

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

@@ -1,9 +1,9 @@
-import * as st from "../..";
+import * as st from "../../index";
 /**
  * exhuastiveArray is read until the end of the data
  *
  * ```py
- * exhuastiveArray(st.u32())
+ * exhuastiveArray(st.string(st.u8()))
  * ```
  */
 export declare function exhuastiveArray<T>(type: st.Serializer<T>): st.Serializer<T[]>;

package/dist/datatypes/containers/exhuastiveArray.js

@@ -1,23 +1,34 @@
-import * as st from "../..";
+import * as st from "../../index";
 /**
  * exhuastiveArray is read until the end of the data
  *
  * ```py
- * exhuastiveArray(st.u32())
+ * exhuastiveArray(st.string(st.u8()))
  * ```
  */
 export function exhuastiveArray(type) {
     return {
         read(ctx) {
             let arr = [];
+            let i = 0;
             while (ctx.offset < ctx.view.byteLength) {
+                const TRACK_STACK = i++ < 4096;
+                if (TRACK_STACK)
+                    ctx.stack.push(`[${arr.length - 1}]`);
                 arr.push(type.read(ctx));
+                if (TRACK_STACK)
+                    ctx.stack.pop();
             }
             return arr;
         },
         write(ctx, value) {
+            const TRACK_STACK = value.length < 4096;
             for (let i = 0; i < value.length; i++) {
+                if (TRACK_STACK)
+                    ctx.stack.push(`[${i}]`);
                 type.write(ctx, value[i]);
+                if (TRACK_STACK)
+                    ctx.stack.pop();
             }
         },
     };

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

@@ -1,18 +1,18 @@
 import { describe, it } from "bun:test";
-import { expectEncode, expectEncodeSnapshot, expectError } from "../utils.test";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../../utils.test";
 import * as st from "../../index";
 describe("st.exhuastiveArray", () => {
     it("encode correctly", () => {
         const spec = st.exhuastiveArray(st.u32());
-        expectEncode(spec, [1, 2, 3, 4]);
+        encodeTest(spec, [1, 2, 3, 4]);
     });
     it("works on empty arrays", () => {
         const spec = st.exhuastiveArray(st.u32());
-        expectEncode(spec, []);
+        encodeTest(spec, []);
     });
     it("accepts large array", () => {
         const spec = st.exhuastiveArray(st.u32());
-        expectEncode(spec, Array.from({ length: 10000 }, (_, i) => i));
+        encodeTest(spec, Array.from({ length: 10000 }, (_, i) => i));
     });
     it("works composed", () => {
         const spec = st.object({
@@ -20,22 +20,19 @@ describe("st.exhuastiveArray", () => {
             b: st.u8(),
             c: st.exhuastiveArray(st.u32()),
         });
-        expectEncode(spec, { a: 1, b: 2, c: [3, 4, 5, 6, 7] });
+        encodeTest(spec, { a: 1, b: 2, c: [3, 4, 5, 6, 7] });
     });
     it("throws error on invalid value", () => {
-        const spec = st.exhuastiveArray(st.u16());
-        expectError(() => {
-            st.write(spec, [-1]);
-        });
+        encodeFailTest(st.exhuastiveArray(st.u16()), [-1]);
     });
     it("nested arrays encode correctly", () => {
-        expectEncode(st.exhuastiveArray(st.exhuastiveArray(st.u16())), //
+        encodeTest(st.exhuastiveArray(st.exhuastiveArray(st.u16())), //
         [[1, 2]]);
     });
     it(`matches snapshots`, () => {
-        expectEncodeSnapshot(st.exhuastiveArray(st.string(st.u16())), //
+        encodeSnapshotTest(st.exhuastiveArray(st.string(st.u16())), //
         ["foo", "bar", "baz"]);
-        expectEncodeSnapshot(st.exhuastiveArray(st.u8()), //
+        encodeSnapshotTest(st.exhuastiveArray(st.u8()), //
         [0, 1, 2, 3]);
     });
 });

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

@@ -3,7 +3,7 @@ type InferObject<T> = T extends Record<string, Serializer<any>> ? {
     [Key in keyof T]: InferInput<T[Key]>;
 } : never;
 /**
- * `fastObject` is equivelent to object but it uses eval to improve performance
+ * `fastObject` is equivelent to object but it uses eval to improve performance, additionally it omits error reporting
  *
  * This means that is should be avoided in scenarios where CSP is required (so can't be the default), but should be fine for all other cases
  *
@@ -14,6 +14,8 @@ type InferObject<T> = T extends Record<string, Serializer<any>> ? {
  *     createdAt: st.f64(),
  * })
  * ```
+ *
+ * Note: Using `st.lazy` affects the performance of fastObject as it prevents discovery of subobjects, avoid when performance is a requirement
  */
 export declare function fastObject<T extends Record<string, Serializer<any>>>(definition: T): Serializer<InferObject<T>>;
 export {};

package/dist/datatypes/containers/fastObject.js

@@ -1,6 +1,6 @@
 const definitionSymbol = Symbol();
 /**
- * `fastObject` is equivelent to object but it uses eval to improve performance
+ * `fastObject` is equivelent to object but it uses eval to improve performance, additionally it omits error reporting
  *
  * This means that is should be avoided in scenarios where CSP is required (so can't be the default), but should be fine for all other cases
  *
@@ -11,6 +11,8 @@ const definitionSymbol = Symbol();
  *     createdAt: st.f64(),
  * })
  * ```
+ *
+ * Note: Using `st.lazy` affects the performance of fastObject as it prevents discovery of subobjects, avoid when performance is a requirement
  */
 export function fastObject(definition) {
     let serializers = [];

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

@@ -1,26 +1,38 @@
 //@ts-ignore TODO
 import { describe, it, expect } from "bun:test";
-import { bytes, expectEncode, expectEncodeSnapshot } from "../utils.test";
+import { bytes, encodeTest, encodeSnapshotTest } from "../../utils.test";
 import * as st from "../../index";
 describe("st.fastObject", () => {
-    const test = st.fastObject({
+    const spec = st.fastObject({
         a: st.u8(),
         b: st.u8(),
     });
     it("encodes correctly", () => {
-        st.write(test, { b: 2, a: 1 });
+        st.write(spec, { b: 2, a: 1 });
+    });
+    it("encodes nest correctly", () => {
+        st.write(st.fastObject({
+            a: st.fastObject({
+                cat: st.u8(),
+                puppy: st.string(st.u8()),
+            }),
+            b: st.u8(),
+        }), {
+            a: { cat: 1, puppy: "woof" },
+            b: 3,
+        });
     });
     it("encode in correct order", () => {
-        const data = st.write(test, { b: 2, a: 1 });
+        const data = st.write(spec, { b: 2, a: 1 });
         const arr = new Uint8Array(data);
         expect(arr[0]).toBe(1);
         expect(arr[1]).toBe(2);
     });
     it("encodes empty", () => {
-        expectEncode(st.fastObject({}), {});
+        encodeTest(st.fastObject({}), {});
     });
     it(`matches snapshots`, () => {
-        expectEncodeSnapshot(st.fastObject({
+        encodeSnapshotTest(st.fastObject({
             number: st.u32(),
             puppy: st.string(st.s32()),
             buffer: st.bytes(4),

package/dist/datatypes/containers/list.js

@@ -12,17 +12,29 @@ export function list(length, type) {
     return {
         write: (ctx, value) => {
             length.write(ctx, value.length);
-            if (type.size)
+            const TRACK_STACK = value.length < 4096;
+            if (type.size) {
                 ctx.alloc(value.length * type.size);
-            for (const v of value) {
+            }
+            for (let i = 0; i < value.length; i++) {
+                if (TRACK_STACK)
+                    ctx.stack.push(`[${i}]`);
+                const v = value[i];
                 type.write(ctx, v);
+                if (TRACK_STACK)
+                    ctx.stack.pop();
             }
         },
         read: (ctx) => {
             const size = length.read(ctx);
+            const TRACK_STACK = size < 4096;
             const arr = new Array(size);
             for (let i = 0; i < size; i++) {
+                if (TRACK_STACK)
+                    ctx.stack.push(`[${i}]`);
                 arr[i] = type.read(ctx);
+                if (TRACK_STACK)
+                    ctx.stack.pop();
             }
             return arr;
         },

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

@@ -1,29 +1,23 @@
 import { describe, it } from "bun:test";
-import { expectEncode, expectEncodeSnapshot, expectError } from "../utils.test";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../../utils.test";
 import * as st from "../../index";
 describe("st.list", () => {
     it("encode correctly", () => {
         const spec = st.list(st.u8(), st.u32());
-        expectEncode(spec, [1, 2, 3, 4]);
+        encodeTest(spec, [1, 2, 3, 4]);
     });
     it("works on empty lists", () => {
         const spec = st.list(st.u8(), st.u32());
-        expectEncode(spec, []);
+        encodeTest(spec, []);
     });
     it("throws error on too large array", () => {
-        const spec = st.list(st.u8(), st.u32());
-        expectError(() => {
-            st.write(spec, Array.from({ length: 10000 }, () => 0));
-        });
+        encodeFailTest(st.list(st.u8(), st.u32()), Array.from({ length: 10000 }, () => 0));
     });
     it("throws error on invalid value", () => {
-        const spec = st.list(st.u8(), st.u16());
-        expectError(() => {
-            st.write(spec, [-1]);
-        });
+        encodeFailTest(st.list(st.u8(), st.u16()), [-1]);
     });
     it(`matches snapshots`, () => {
-        expectEncodeSnapshot(st.list(st.s32(), st.string(st.u16())), //
+        encodeSnapshotTest(st.list(st.s32(), st.string(st.u16())), //
         ["foo", "bar", "baz"]);
     });
 });

package/dist/datatypes/containers/object.js

@@ -21,13 +21,19 @@ export function object(definition) {
             if (size)
                 ctx.alloc(size);
             for (let i = 0; i < entires.length; i++) {
-                entires[i][1].write(ctx, value[entires[i][0]]);
+                const [key, serializer] = entires[i];
+                ctx.stack.push(`.${key}`);
+                serializer.write(ctx, value[key]);
+                ctx.stack.pop();
             }
         },
         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)];
+                const [key, serializer] = entires[i];
+                ctx.stack.push(`.${key}`);
+                output[i] = [key, serializer.read(ctx)];
+                ctx.stack.pop();
             }
             return Object.fromEntries(output);
         },

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

@@ -1,26 +1,33 @@
 //@ts-ignore TODO
-import { describe, it, expect } from "bun:test";
-import { bytes, expectEncode, expectEncodeSnapshot } from "../utils.test";
+import { describe, it, expect, expectTypeOf } from "bun:test";
+import { bytes, encodeTest, encodeSnapshotTest } from "../../utils.test";
 import * as st from "../../index";
 describe("st.object", () => {
-    const test = st.object({
-        a: st.u8(),
-        b: st.u8(),
-    });
     it("encodes correctly", () => {
-        st.write(test, { b: 2, a: 1 });
+        encodeTest(st.object({ a: st.u8(), b: st.u8() }), //
+        { b: 2, a: 1 });
+    });
+    it("encodes nested correctly", () => {
+        encodeTest(st.object({
+            a: st.object({ a: st.u8() }),
+            b: st.u8(),
+        }), //
+        { a: { a: 2 }, b: 1 });
     });
     it("encode in correct order", () => {
-        const data = st.write(test, { b: 2, a: 1 });
+        const data = st.write(st.object({
+            a: st.u8(),
+            b: st.u8(),
+        }), { b: 2, a: 1 });
         const arr = new Uint8Array(data);
         expect(arr[0]).toBe(1);
         expect(arr[1]).toBe(2);
     });
     it("encodes empty", () => {
-        expectEncode(st.object({}), {});
+        encodeTest(st.object({}), {});
     });
     it(`matches snapshots`, () => {
-        expectEncodeSnapshot(st.object({
+        encodeSnapshotTest(st.object({
             number: st.u32(),
             puppy: st.string(st.s32()),
             buffer: st.bytes(4),
@@ -30,4 +37,9 @@ describe("st.object", () => {
             buffer: bytes([19, 87, 19, 83]),
         });
     });
+    // Type Tests
+    expectTypeOf(st.object({
+        number: st.u32(),
+        string: st.string(st.u32()),
+    })).toEqualTypeOf();
 });

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

@@ -11,12 +11,16 @@ import type { InferInput, InferOutput, Serializer } from "../../types";
  *     2: MouseMovePacket,
  * })
  * ```
- *
  */
-export declare function taggedUnion<TTag extends string | number, TType extends Serializer<any>>(tag: Serializer<TTag>, variants: Record<TTag, TType>): Serializer<{
-    type: TTag;
-    value: InferInput<TType>;
-}, {
-    type: TTag;
-    value: InferOutput<TType>;
-}>;
+export declare function taggedUnion<Tag extends PropertyKey, //
+Variants extends Record<Tag, Serializer<any>>>(tag: Serializer<Tag>, variants: Variants & Record<Exclude<keyof Variants, Tag>, never>): Serializer<{
+    [K in keyof Variants]: {
+        type: K;
+        value: InferInput<Variants[K]>;
+    };
+}[keyof Variants], {
+    [K in keyof Variants]: {
+        type: K;
+        value: InferOutput<Variants[K]>;
+    };
+}[keyof Variants]>;

package/dist/datatypes/containers/taggedUnion.js

@@ -10,15 +10,16 @@
  *     2: MouseMovePacket,
  * })
  * ```
- *
  */
 export function taggedUnion(tag, variants) {
     return {
         write: (ctx, value) => {
             if (!(value.type in variants))
-                throw new Error(`Unknown type ${value.type}`);
+                throw new Error(`Unknown type ${String(value.type)}`);
+            //@ts-expect-error
             tag.write(ctx, value.type);
             const variant = variants[value.type];
+            //@ts-expect-error
             variant.write(ctx, value.value);
         },
         read: (ctx) => {
@@ -26,6 +27,7 @@ export function taggedUnion(tag, variants) {
             if (!(type in variants))
                 throw new Error(`Unknown type ${tag}`);
             const variant = variants[type];
+            //@ts-expect-error
             const value = variant.read(ctx);
             return { type, value };
         },

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

@@ -1,5 +1,5 @@
-import { describe, it } from "bun:test";
-import { expectEncode, expectEncodeSize, expectEncodeSnapshot, expectError } from "../utils.test";
+import { describe, expectTypeOf, it } from "bun:test";
+import { encodeTest, expectEncodeSize, encodeSnapshotTest, encodeFailTest } from "../../utils.test";
 import * as st from "../../index";
 describe("st.taggedUnion", () => {
     it("encode correctly", () => {
@@ -7,57 +7,61 @@ describe("st.taggedUnion", () => {
             1: st.string(st.u8()),
             2: st.u8(),
         });
-        expectEncode(spec, { type: 1, value: "s" });
-        expectEncode(spec, { type: 2, value: 52 });
+        encodeTest(spec, { type: 1, value: "s" });
+        encodeTest(spec, { type: 2, value: 52 });
     });
     it("encode with string tag", () => {
         const spec = st.taggedUnion(st.string(st.u8()), {
             foo: st.string(st.u8()),
             bar: st.u8(),
         });
-        expectEncode(spec, { type: "foo", value: "woof" });
-        expectEncode(spec, { type: "bar", value: 52 });
+        encodeTest(spec, { type: "foo", value: "woof" });
+        encodeTest(spec, { type: "bar", value: 52 });
     });
     it("throws error on invalid tag", () => {
         const spec = st.taggedUnion(st.string(st.u8()), {
             foo: st.string(st.u8()),
             bar: st.u8(),
         });
-        expectError(() => {
-            st.write(spec, { type: "unknown", value: "woof" });
-        });
+        //@ts-expect-error, intended
+        encodeFailTest(spec, { type: "unknown", value: "woof" });
     });
     it("throws error on invalid type", () => {
         const spec = st.taggedUnion(st.string(st.u8()), {
             foo: st.string(st.u8()),
             bar: st.u8(),
         });
-        expectError(() => {
-            st.write(spec, { type: "unknown", value: "woof" });
-        });
+        //@ts-expect-error, intended
+        encodeFailTest(spec, { type: "unknown", value: "woof" });
     });
     it("throws error on invalid value", () => {
         const spec = st.taggedUnion(st.string(st.u8()), {
             foo: st.string(st.u8()),
         });
-        expectError(() => {
-            //@ts-expect-error
-            st.write(spec, { type: "foo", value: 0 });
-        });
+        //@ts-expect-error, intended
+        encodeFailTest(spec, { type: "foo", value: 0 });
     });
     it("encodes varying sizes", () => {
         const spec = st.taggedUnion(st.u8(), {
             1: st.string(st.u8()),
             2: st.u8(),
         });
-        expectEncode(spec, { type: 1, value: "s" });
+        encodeTest(spec, { type: 1, value: "s" });
         expectEncodeSize(spec, 5, { type: 1, value: "foo" });
         expectEncodeSize(spec, 2, { type: 2, value: 52 });
     });
     it("encodes snapshots", () => {
-        expectEncodeSnapshot(st.taggedUnion(st.u32(), {
+        encodeSnapshotTest(st.taggedUnion(st.u32(), {
             0: st.list(st.u8(), st.f64()),
             3: st.u32(),
         }), { type: 0, value: [1] });
     });
+    expectTypeOf(st.taggedUnion(st.u32(), {
+        0: st.u8(),
+        1: st.string(st.u32()),
+    })).toEqualTypeOf();
+    () => {
+        //@ts-expect-error, must be same type as tags
+        st.taggedUnion(st.string(st.u8()), { 0: st.u8(), 1: st.string(st.u32()) });
+    };
 });

package/dist/datatypes/index.d.ts

@@ -6,15 +6,8 @@ export { array } from "./containers/array";
 export { fastObject } from "./containers/fastObject";
 export { object } from "./containers/object";
 export { list } from "./containers/list";
-export { sizedBytes } from "./containers/sizedbytes";
 export { taggedUnion } from "./containers/taggedUnion";
 export { exhuastiveArray } from "./containers/exhuastiveArray";
-export { string } from "./containers/string";
 export { bytes } from "./values/bytes";
-export { bytesLiteral } from "./values/byteliteral";
-export { type Transform as Pipeline, pipe } from "./transforms/pipe";
-export { fixedOffset } from "./transforms/fixedOffset";
-export { modify } from "./transforms/modify";
-export { encode } from "./transforms/encode";
-export { noAdvance } from "./transforms/noAdvance";
-export { createRememberedValue } from "./utilities/remember";
+export { sizedBytes } from "./values/sizedbytes";
+export { string } from "./values/string";

package/dist/datatypes/index.js

@@ -6,15 +6,8 @@ export { array } from "./containers/array";
 export { fastObject } from "./containers/fastObject";
 export { object } from "./containers/object";
 export { list } from "./containers/list";
-export { sizedBytes } from "./containers/sizedbytes";
 export { taggedUnion } from "./containers/taggedUnion";
 export { exhuastiveArray } from "./containers/exhuastiveArray";
-export { string } from "./containers/string";
 export { bytes } from "./values/bytes";
-export { bytesLiteral } from "./values/byteliteral";
-export { pipe } from "./transforms/pipe";
-export { fixedOffset } from "./transforms/fixedOffset";
-export { modify } from "./transforms/modify";
-export { encode } from "./transforms/encode";
-export { noAdvance } from "./transforms/noAdvance";
-export { createRememberedValue } from "./utilities/remember";
+export { sizedBytes } from "./values/sizedbytes";
+export { string } from "./values/string";

package/dist/datatypes/numbers/bigints.test.js

@@ -1,19 +1,19 @@
 import { describe, it, expect } from "bun:test";
-import { expectEncode, expectEncodeSnapshot, expectError, randbigint } from "../utils.test";
+import { encodeTest, encodeSnapshotTest, randbigint, encodeFailTest } from "../../utils.test";
 import * as st from "../../index";
 function test_bigint(options) {
     const { name, range: [start, end], serializer, size, } = options;
     describe(name, () => {
         it("works in bounds", () => {
-            expectEncode(serializer, start);
+            encodeTest(serializer, start);
             for (let i = 0; i < 100; i++) {
-                expectEncode(serializer, randbigint(start, end));
+                encodeTest(serializer, randbigint(start, end));
             }
-            expectEncode(serializer, end);
+            encodeTest(serializer, end);
         });
         it("outside bounds", () => {
-            expectError(() => st.write(serializer, start - 1n));
-            expectError(() => st.write(serializer, end + 1n));
+            encodeFailTest(serializer, start - 1n);
+            encodeFailTest(serializer, end + 1n);
         });
         it(`is right size`, () => {
             const expectValueSize = (value) => {
@@ -27,11 +27,11 @@ function test_bigint(options) {
             expectValueSize(end);
         });
         it(`matches snapshots`, () => {
-            expectEncodeSnapshot(serializer, 0n);
-            expectEncodeSnapshot(serializer, start);
-            expectEncodeSnapshot(serializer, start + 10n);
-            expectEncodeSnapshot(serializer, end - 10n);
-            expectEncodeSnapshot(serializer, end);
+            encodeSnapshotTest(serializer, 0n);
+            encodeSnapshotTest(serializer, start);
+            encodeSnapshotTest(serializer, start + 10n);
+            encodeSnapshotTest(serializer, end - 10n);
+            encodeSnapshotTest(serializer, end);
         });
     });
 }

package/dist/datatypes/numbers/floats.test.js

@@ -1,6 +1,6 @@
 //@ts-ignore TODO
 import { describe, it, expect } from "bun:test";
-import { expectEncode, expectEncodeSize, } from "../utils.test";
+import { encodeTest, expectEncodeSize } from "../../utils.test";
 import * as st from "../../index";
 function test_float(options) {
     const { name, serializer, size } = options;
@@ -22,17 +22,17 @@ function test_float(options) {
             }
         });
         it(`works on Infinty`, () => {
-            expectEncode(serializer, Infinity);
-            expectEncode(serializer, -Infinity);
+            encodeTest(serializer, Infinity);
+            encodeTest(serializer, -Infinity);
         });
         it(`works on NaN`, () => {
-            expectEncode(serializer, NaN);
+            encodeTest(serializer, NaN);
         });
         it(`works on 0`, () => {
-            expectEncode(serializer, 0);
+            encodeTest(serializer, 0);
         });
         it(`works on -0`, () => {
-            expectEncode(serializer, -0);
+            encodeTest(serializer, -0);
         });
         it(`is right size`, () => {
             for (let i = 0; i < 100; i++) {