@nnilky/structo 1.0.8 → 1.1.0

package/README.md

@@ -20,14 +20,14 @@ const Entity = st.object({
 
 ```
 
+- Extremely Fast! [benchmarks](./benchmark) show equivelent performance to hand written serializers
+- Designed to be both Web & Node.js compatible
 - Lightweight, base size is <1KB and each datatype is a few hundred bytes
-- Fast![benchmarks](./benchmark) show only 1.5-5x slower than ideal implementaiton
-- Designed for both Web/Node.js compatible
-- Easily implement your own serializers
+- Easily extendable with your own datatypes
 
 Each serializer is completely seperate from the base library, meaning you only pay for what you use.
 
-## Implementing your own Serializer
+## Implementing your datatype
 
 Implementing your own serializer is incredibly simple, heres the `f64` serializer for example
 

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

@@ -1,4 +1,4 @@
-import type { Serializer } from "../../types";
+import type { Serializer } from "../../types.js";
 /**
  * `st.array` is a fixed length array, akin to a C array.
  *

package/dist/datatypes/containers/array.js

@@ -7,31 +7,28 @@
  *
  */
 export function array(size, type) {
-    const SHOW_ERRORS = size < 4096;
-    const { read: readType, write: writeType, size: typeSize } = type;
+    const SHOW_ERRORS = false;
     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 (type.size)
+                ctx.reserve(size * type.size);
             for (let i = 0; i < size; i++) {
-                if (SHOW_ERRORS)
-                    ctx.stack.push(`[${i}]`);
-                writeType(ctx, value[i]);
-                if (SHOW_ERRORS)
-                    ctx.stack.pop();
+                // if (SHOW_ERRORS) ctx.path.push(`[${i}]`);
+                type.write(ctx, value[i]);
+                // if (SHOW_ERRORS) ctx.path.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);
+                    ctx.path.push(`[${i}]`);
+                arr[i] = type.read(ctx);
                 if (SHOW_ERRORS)
-                    ctx.stack.pop();
+                    ctx.path.pop();
             }
             return arr;
         },

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

@@ -1,6 +1,6 @@
 import { describe, it } from "bun:test";
-import { encodeTest, encodeFailTest } from "../../utils.test";
-import * as st from "../../index";
+import { encodeTest, encodeFailTest } from "../../utils.test.js";
+import * as st from "../../index.js";
 describe("st.array", () => {
     it("encode correctly", () => {
         encodeTest(st.array(4, st.u16()), [1, 2, 3, 4]);

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

@@ -1,4 +1,4 @@
-import * as st from "../../index";
+import * as st from "../../index.js";
 /**
  * exhuastiveArray is read until the end of the data
  *

package/dist/datatypes/containers/exhuastiveArray.js

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

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

@@ -1,6 +1,6 @@
 import { describe, it } from "bun:test";
-import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../../utils.test";
-import * as st from "../../index";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../../utils.test.js";
+import * as st from "../../index.js";
 describe("st.exhuastiveArray", () => {
     it("encode correctly", () => {
         const spec = st.exhuastiveArray(st.u32());

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

@@ -1,4 +1,4 @@
-import type { InferInput, Serializer } from "../../types";
+import type { InferInput, Serializer } from "../../types.js";
 type InferObject<T> = T extends Record<string, Serializer<any>> ? {
     [Key in keyof T]: InferInput<T[Key]>;
 } : never;

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

@@ -1,7 +1,7 @@
 //@ts-ignore TODO
 import { describe, it, expect } from "bun:test";
-import { bytes, encodeTest, encodeSnapshotTest } from "../../utils.test";
-import * as st from "../../index";
+import { bytes, encodeTest, encodeSnapshotTest } from "../../utils.test.js";
+import * as st from "../../index.js";
 describe("st.fastObject", () => {
     const spec = st.fastObject({
         a: st.u8(),

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

@@ -1,4 +1,4 @@
-import type { Serializer } from "../../types";
+import type { Serializer } from "../../types.js";
 /**
  * `st.list` is a dynamically sized array
  *

package/dist/datatypes/containers/list.js

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

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

@@ -1,6 +1,6 @@
 import { describe, it } from "bun:test";
-import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../../utils.test";
-import * as st from "../../index";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../../utils.test.js";
+import * as st from "../../index.js";
 describe("st.list", () => {
     it("encode correctly", () => {
         const spec = st.list(st.u8(), st.u32());

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

@@ -1,4 +1,4 @@
-import type { InferInput, InferOutput, Serializer } from "../../types";
+import type { InferInput, InferOutput, Serializer } from "../../types.js";
 type InferObjectInfer<T> = T extends Record<string, Serializer<any>> ? {
     [Key in keyof T]: InferInput<T[Key]>;
 } : never;

package/dist/datatypes/containers/object.js

@@ -19,23 +19,24 @@ export function object(definition) {
         size,
         write: (ctx, value) => {
             if (size)
-                ctx.alloc(size);
+                ctx.reserve(size);
             for (let i = 0; i < entires.length; i++) {
                 const [key, serializer] = entires[i];
-                ctx.stack.push(`.${key}`);
+                // ctx.path.push(`.${key}`);
                 serializer.write(ctx, value[key]);
-                ctx.stack.pop();
+                // ctx.path.pop();
             }
         },
         read: (ctx) => {
-            const output = new Array(entires.length);
+            const output = {};
             for (let i = 0; i < entires.length; i++) {
                 const [key, serializer] = entires[i];
-                ctx.stack.push(`.${key}`);
-                output[i] = [key, serializer.read(ctx)];
-                ctx.stack.pop();
+                // ctx.path.push(`.${key}`);
+                //@ts-expect-error
+                output[key] = serializer.read(ctx);
+                // ctx.path.pop();
             }
-            return Object.fromEntries(output);
+            return output;
         },
     };
 }

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

@@ -1,7 +1,7 @@
 //@ts-ignore TODO
 import { describe, it, expect, expectTypeOf } from "bun:test";
-import { bytes, encodeTest, encodeSnapshotTest } from "../../utils.test";
-import * as st from "../../index";
+import { bytes, encodeTest, encodeSnapshotTest } from "../../utils.test.js";
+import * as st from "../../index.js";
 describe("st.object", () => {
     it("encodes correctly", () => {
         encodeTest(st.object({ a: st.u8(), b: st.u8() }), //

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

@@ -1,4 +1,4 @@
-import type { InferInput, InferOutput, Serializer } from "../../types";
+import type { InferInput, InferOutput, Serializer } from "../../types.js";
 /**
  * `st.taggedUnion` is a union type with a kind
  *

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

@@ -1,6 +1,6 @@
 import { describe, expectTypeOf, it } from "bun:test";
-import { encodeTest, expectEncodeSize, encodeSnapshotTest, encodeFailTest } from "../../utils.test";
-import * as st from "../../index";
+import { encodeTest, expectEncodeSize, encodeSnapshotTest, encodeFailTest, } from "../../utils.test.js";
+import * as st from "../../index.js";
 describe("st.taggedUnion", () => {
     it("encode correctly", () => {
         const spec = st.taggedUnion(st.u8(), {

package/dist/datatypes/index.d.ts

@@ -1,13 +1,13 @@
-export { u64Bigint, s64Bigint } from "./numbers/bigints";
-export { f16, 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 { taggedUnion } from "./containers/taggedUnion";
-export { exhuastiveArray } from "./containers/exhuastiveArray";
-export { bytes } from "./values/bytes";
-export { sizedBytes } from "./values/sizedbytes";
-export { string } from "./values/string";
+export { u64Bigint, s64Bigint } from "./numbers/bigints.js";
+export { f16, f32, f64 } from "./numbers/floats.js";
+export { s8, s16, s32, s64 } from "./numbers/sints.js";
+export { u8, u16, u32, u64 } from "./numbers/uints.js";
+export { array } from "./containers/array.js";
+export { fastObject } from "./containers/fastObject.js";
+export { object } from "./containers/object.js";
+export { list } from "./containers/list.js";
+export { taggedUnion } from "./containers/taggedUnion.js";
+export { exhuastiveArray } from "./containers/exhuastiveArray.js";
+export { bytes } from "./values/bytes.js";
+export { sizedBytes } from "./values/sizedbytes.js";
+export { string } from "./values/string.js";

package/dist/datatypes/index.js

@@ -1,13 +1,13 @@
-export { u64Bigint, s64Bigint } from "./numbers/bigints";
-export { f16, 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 { taggedUnion } from "./containers/taggedUnion";
-export { exhuastiveArray } from "./containers/exhuastiveArray";
-export { bytes } from "./values/bytes";
-export { sizedBytes } from "./values/sizedbytes";
-export { string } from "./values/string";
+export { u64Bigint, s64Bigint } from "./numbers/bigints.js";
+export { f16, f32, f64 } from "./numbers/floats.js";
+export { s8, s16, s32, s64 } from "./numbers/sints.js";
+export { u8, u16, u32, u64 } from "./numbers/uints.js";
+export { array } from "./containers/array.js";
+export { fastObject } from "./containers/fastObject.js";
+export { object } from "./containers/object.js";
+export { list } from "./containers/list.js";
+export { taggedUnion } from "./containers/taggedUnion.js";
+export { exhuastiveArray } from "./containers/exhuastiveArray.js";
+export { bytes } from "./values/bytes.js";
+export { sizedBytes } from "./values/sizedbytes.js";
+export { string } from "./values/string.js";

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

@@ -1,4 +1,4 @@
-import type { Serializer } from "../../types";
+import type { Serializer } from "../../types.js";
 /**
  * 64bit unsigned interger
  *

package/dist/datatypes/numbers/bigints.js

@@ -13,7 +13,7 @@ export function u64Bigint(endian = "little") {
         size: 8,
         write: (ctx, value) => {
             checkValue(value, 0n, 2n ** 64n);
-            ctx.alloc(8);
+            ctx.reserve(8);
             ctx.view.setBigUint64(ctx.offset, BigInt(value), endian === "little");
             ctx.offset += 8;
         },
@@ -34,7 +34,7 @@ export function s64Bigint(endian = "little") {
         size: 8,
         write: (ctx, value) => {
             checkValue(value, -(2n ** 63n), 2n ** 63n);
-            ctx.alloc(8);
+            ctx.reserve(8);
             ctx.view.setBigInt64(ctx.offset, BigInt(value), endian === "little");
             ctx.offset += 8;
         },

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

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "bun:test";
-import { encodeTest, encodeSnapshotTest, randbigint, encodeFailTest } from "../../utils.test";
-import * as st from "../../index";
+import { encodeTest, encodeSnapshotTest, randbigint, encodeFailTest } from "../../utils.test.js";
+import * as st from "../../index.js";
 function test_bigint(options) {
     const { name, range: [start, end], serializer, size, } = options;
     describe(name, () => {

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

@@ -1,4 +1,4 @@
-import type { Serializer } from "../../types";
+import type { Serializer } from "../../types.js";
 /** 16bit float */
 export declare function f16(endian?: "little" | "big"): Serializer<number>;
 /** 32bit float */

package/dist/datatypes/numbers/floats.js

@@ -1,14 +1,15 @@
 /** 16bit float */
 export function f16(endian = "little") {
+    const littleEndian = endian === "little";
     return {
         size: 2,
         write: (ctx, value) => {
-            ctx.alloc(2);
-            ctx.view.setFloat16(ctx.offset, value, endian === "little");
+            ctx.reserve(2);
+            ctx.view.setFloat16(ctx.offset, value, littleEndian);
             ctx.offset += 2;
         },
         read: (ctx) => {
-            const value = ctx.view.getFloat16(ctx.offset, endian === "little");
+            const value = ctx.view.getFloat16(ctx.offset, littleEndian);
             ctx.offset += 2;
             return value;
         },
@@ -16,15 +17,16 @@ export function f16(endian = "little") {
 }
 /** 32bit float */
 export function f32(endian = "little") {
+    const littleEndian = endian === "little";
     return {
         size: 4,
         write: (ctx, value) => {
-            ctx.alloc(4);
-            ctx.view.setFloat32(ctx.offset, value, endian === "little");
+            ctx.reserve(4);
+            ctx.view.setFloat32(ctx.offset, value, littleEndian);
             ctx.offset += 4;
         },
         read: (ctx) => {
-            const value = ctx.view.getFloat32(ctx.offset, endian === "little");
+            const value = ctx.view.getFloat32(ctx.offset, littleEndian);
             ctx.offset += 4;
             return value;
         },
@@ -32,15 +34,16 @@ export function f32(endian = "little") {
 }
 /** 64bit float */
 export function f64(endian = "little") {
+    const littleEndian = endian === "little";
     return {
         size: 8,
         write: (ctx, value) => {
-            ctx.alloc(8);
-            ctx.view.setFloat64(ctx.offset, value, endian === "little");
+            ctx.reserve(8);
+            ctx.view.setFloat64(ctx.offset, value, littleEndian);
             ctx.offset += 8;
         },
         read: (ctx) => {
-            const value = ctx.view.getFloat64(ctx.offset, endian === "little");
+            const value = ctx.view.getFloat64(ctx.offset, littleEndian);
             ctx.offset += 8;
             return value;
         },

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

@@ -1,7 +1,7 @@
 //@ts-ignore TODO
 import { describe, it, expect } from "bun:test";
-import { encodeTest, expectEncodeSize } from "../../utils.test";
-import * as st from "../../index";
+import { encodeTest, expectEncodeSize } from "../../utils.test.js";
+import * as st from "../../index.js";
 function test_float(options) {
     const { name, serializer, size } = options;
     const expectEncodeApproximately = (value) => {

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

@@ -1,4 +1,4 @@
-import type { Serializer } from "../../types";
+import type { Serializer } from "../../types.js";
 /** 8bit signed integer */
 export declare function s8(): Serializer<number>;
 /** 16bit signed integer */

package/dist/datatypes/numbers/sints.js

@@ -12,7 +12,7 @@ export function s8() {
         size: 1,
         write: (ctx, value) => {
             checkValue(value, -(2 ** 7), 2 ** 7);
-            ctx.alloc(1);
+            ctx.reserve(1);
             ctx.view.setInt8(ctx.offset, value);
             ctx.offset += 1;
         },
@@ -25,16 +25,17 @@ export function s8() {
 }
 /** 16bit signed integer */
 export function s16(endian = "little") {
+    const littleEndian = 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.reserve(2);
+            ctx.view.setInt16(ctx.offset, value, littleEndian);
             ctx.offset += 2;
         },
         read: (ctx) => {
-            const value = ctx.view.getInt16(ctx.offset, endian === "little");
+            const value = ctx.view.getInt16(ctx.offset, littleEndian);
             ctx.offset += 2;
             return value;
         },
@@ -42,16 +43,17 @@ export function s16(endian = "little") {
 }
 /** 32bit signed integer */
 export function s32(endian = "little") {
+    const littleEndian = 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.reserve(4);
+            ctx.view.setInt32(ctx.offset, value, littleEndian);
             ctx.offset += 4;
         },
         read: (ctx) => {
-            const value = ctx.view.getInt32(ctx.offset, endian === "little");
+            const value = ctx.view.getInt32(ctx.offset, littleEndian);
             ctx.offset += 4;
             return value;
         },
@@ -59,16 +61,17 @@ export function s32(endian = "little") {
 }
 /** 64bit signed integer */
 export function s64(endian = "little") {
+    const littleEndian = 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.reserve(8);
+            ctx.view.setBigInt64(ctx.offset, BigInt(value), littleEndian);
             ctx.offset += 8;
         },
         read: (ctx) => {
-            const value = Number(ctx.view.getBigInt64(ctx.offset, endian === "little"));
+            const value = Number(ctx.view.getBigInt64(ctx.offset, littleEndian));
             ctx.offset += 8;
             return value;
         },

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

@@ -1,7 +1,7 @@
 //@ts-ignore TODO
 import { describe, it, expect } from "bun:test";
-import { encodeTest, encodeSnapshotTest, expectError, randint, encodeFailTest, } from "../../utils.test";
-import * as st from "../../index";
+import { encodeTest, encodeSnapshotTest, expectError, randint, encodeFailTest, } from "../../utils.test.js";
+import * as st from "../../index.js";
 function test_sint(options) {
     const { name, range: [start, end], serializer, size, disableRangeCheck, } = options;
     describe(name, () => {

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

@@ -1,4 +1,4 @@
-import type { Serializer } from "../../types";
+import type { Serializer } from "../../types.js";
 /** 8bit unsigned integer */
 export declare function u8(): Serializer<number>;
 /** 16bit unsigned integer */

package/dist/datatypes/numbers/uints.js

@@ -7,7 +7,7 @@ export function u8() {
                 throw new Error("Not Integer");
             if (value < 0 || value >= 2 ** 8)
                 throw new Error("Out of Range");
-            ctx.alloc(1);
+            ctx.reserve(1);
             ctx.view.setUint8(ctx.offset, value);
             ctx.offset += 1;
         },
@@ -20,6 +20,7 @@ export function u8() {
 }
 /** 16bit unsigned integer */
 export function u16(endian = "little") {
+    const littleEndian = endian === "little";
     return {
         size: 2,
         write: (ctx, value) => {
@@ -27,12 +28,12 @@ export function u16(endian = "little") {
                 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.reserve(2);
+            ctx.view.setUint16(ctx.offset, value, littleEndian);
             ctx.offset += 2;
         },
         read: (ctx) => {
-            const value = ctx.view.getUint16(ctx.offset, endian === "little");
+            const value = ctx.view.getUint16(ctx.offset, littleEndian);
             ctx.offset += 2;
             return value;
         },
@@ -40,6 +41,7 @@ export function u16(endian = "little") {
 }
 /** 32bit unsigned integer */
 export function u32(endian = "little") {
+    const littleEndian = endian === "little";
     return {
         size: 4,
         write: (ctx, value) => {
@@ -47,12 +49,12 @@ export function u32(endian = "little") {
                 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.reserve(4);
+            ctx.view.setUint32(ctx.offset, value, littleEndian);
             ctx.offset += 4;
         },
         read: (ctx) => {
-            const value = ctx.view.getUint32(ctx.offset, endian === "little");
+            const value = ctx.view.getUint32(ctx.offset, littleEndian);
             ctx.offset += 4;
             return value;
         },
@@ -60,6 +62,7 @@ export function u32(endian = "little") {
 }
 /** 64bit unsigned integer */
 export function u64(endian = "little") {
+    const littleEndian = endian === "little";
     return {
         size: 8,
         write: (ctx, value) => {
@@ -67,12 +70,12 @@ export function u64(endian = "little") {
                 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.reserve(8);
+            ctx.view.setBigUint64(ctx.offset, BigInt(value), littleEndian);
             ctx.offset += 8;
         },
         read: (ctx) => {
-            const value = Number(ctx.view.getBigUint64(ctx.offset, endian === "little"));
+            const value = Number(ctx.view.getBigUint64(ctx.offset, littleEndian));
             ctx.offset += 8;
             return value;
         },

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

@@ -1,7 +1,7 @@
 //@ts-ignore TODO
 import { describe, it, expect } from "bun:test";
-import { encodeTest, encodeSnapshotTest, expectError, randint, encodeFailTest, } from "../../utils.test";
-import * as st from "../../index";
+import { encodeTest, encodeSnapshotTest, expectError, randint, encodeFailTest, } from "../../utils.test.js";
+import * as st from "../../index.js";
 function test_uint(options) {
     const { name, range: [start, end], serializer, size, disableMaxCheck, } = options;
     describe(name, () => {