@nnilky/structo 1.0.5 → 1.0.8

package/dist/transforms/offset.js

@@ -0,0 +1,20 @@
+export function offset(behaviour, offset) {
+    return (type) => ({
+        size: type.size,
+        read: (ctx) => {
+            let start = ctx.offset;
+            const offsetValue = typeof offset === "number" ? offset : offset.read(ctx);
+            ctx.offset = behaviour === "absolute" ? offsetValue : ctx.offset + offsetValue;
+            const value = type.read(ctx);
+            ctx.offset = start;
+            return value;
+        },
+        write: (ctx, value) => {
+            let start = ctx.offset;
+            const offsetValue = typeof offset === "number" ? offset : offset.read(ctx);
+            ctx.offset = behaviour === "absolute" ? offsetValue : ctx.offset + offsetValue;
+            type.write(ctx, value);
+            ctx.offset = start;
+        },
+    });
+}

package/dist/transforms/offset.test.d.ts

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

package/dist/transforms/offset.test.js

@@ -0,0 +1,39 @@
+import { describe, it } from "bun:test";
+import { encodeTest } from "../utils.test";
+import * as st from "../index";
+describe("st.offset(relative)", () => {
+    it("encodes correctly with fixed offset", () => {
+        const spec = st.object({
+            foo: st.u32(),
+            bar: st.pipe(st.u32(), st.offset("relative", -4)),
+        });
+        encodeTest(spec, { foo: 1, bar: 5 }, { foo: 5, bar: 5 });
+    });
+    it("encodes correctly with read offset", () => {
+        const offset = st.createRememberedValue();
+        const spec = st.object({
+            foo: st.u32(),
+            offset: offset.save(st.s16()),
+            bar: st.pipe(st.u32(), st.offset("relative", offset.load())),
+        });
+        encodeTest(spec, { foo: 0, offset: -6, bar: 5 }, { foo: 5, offset: -6, bar: 5 });
+    });
+});
+describe("st.offset(absolute)", () => {
+    it("encodes correctly with fixed offset", () => {
+        const spec = st.object({
+            foo: st.u32(),
+            bar: st.pipe(st.u32(), st.offset("absolute", 0)),
+        });
+        encodeTest(spec, { foo: 0, bar: 5 }, { foo: 5, bar: 5 });
+    });
+    it("encodes correctly with read offset", () => {
+        const offset = st.createRememberedValue();
+        const spec = st.object({
+            foo: st.u32(),
+            offset: offset.save(st.u32()),
+            bar: st.pipe(st.u32(), st.offset("absolute", offset.load())),
+        });
+        encodeTest(spec, { foo: 0, offset: 0, bar: 5 }, { foo: 5, offset: 0, bar: 5 });
+    });
+});

package/dist/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/transforms/pipe.js

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

package/dist/transforms/toAscii.d.ts

@@ -0,0 +1 @@
+export declare function toAscii(): import("./pipe").Transform<string, ArrayBuffer>;

package/dist/transforms/toAscii.js

@@ -0,0 +1,14 @@
+import { encode } from "./encode";
+export function toAscii() {
+    return encode({
+        encode: (v) => new Uint8Array(Array.from(v).map((char) => validateAscii(char.charCodeAt(0)))).buffer,
+        decode: (v) => Array.from(new Uint8Array(v))
+            .map((v) => String.fromCharCode(v))
+            .join(""),
+    });
+}
+const validateAscii = (v) => {
+    if (v >= 0 && v <= 127)
+        return v;
+    throw new Error(`Invalid value: ${v}`);
+};

package/dist/transforms/toAscii.test.d.ts

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

package/dist/transforms/toAscii.test.js

@@ -0,0 +1,25 @@
+import { describe, it } from "bun:test";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test";
+import * as st from "../index";
+describe("st.toAscii", () => {
+    it("encode correctly", () => {
+        encodeTest(st.pipe(st.bytes(5), st.toAscii()), //
+        "a6534");
+        encodeTest(st.pipe(st.bytes(3), st.toAscii()), //
+        "-as");
+    });
+    it("invalid length throws error", () => {
+        encodeFailTest(st.pipe(st.bytes(4), st.toAscii()), //
+        "asd");
+    });
+    it("invalid character throws error", () => {
+        encodeFailTest(st.pipe(st.bytes(4), st.toAscii()), //
+        "asdé");
+    });
+    it("snapshots", () => {
+        encodeSnapshotTest(st.pipe(st.bytes(4), st.toAscii()), //
+        "634f");
+        encodeSnapshotTest(st.pipe(st.bytes(6), st.toAscii()), //
+        "hdjdp_");
+    });
+});

package/dist/transforms/toBase64.d.ts

@@ -0,0 +1 @@
+export declare function toBase64(): import("./pipe").Transform<string, ArrayBuffer>;

package/dist/transforms/toBase64.js

@@ -0,0 +1,7 @@
+import { encode } from "./encode";
+export function toBase64() {
+    return encode({
+        encode: (v) => Uint8Array.fromBase64(v).buffer,
+        decode: (v) => new Uint8Array(v).toBase64(),
+    });
+}

package/dist/transforms/toBase64.test.d.ts

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

package/dist/transforms/toBase64.test.js

@@ -0,0 +1,27 @@
+import { describe, it } from "bun:test";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test";
+import * as st from "../index";
+describe("st.toBase64", () => {
+    it("encode correctly", () => {
+        encodeTest(st.pipe(st.bytes(1), st.toBase64()), //
+        "rw==");
+        encodeTest(st.pipe(st.bytes(2), st.toBase64()), //
+        "rx8=");
+        encodeTest(st.pipe(st.bytes(3), st.toBase64()), //
+        "rx9K");
+    });
+    it("invalid character error", () => {
+        encodeFailTest(st.pipe(st.bytes(3), st.toBase64()), //
+        "rx9-");
+    });
+    it("invalid length error", () => {
+        encodeFailTest(st.pipe(st.bytes(4), st.toBase64()), //
+        "rx9L");
+    });
+    it("snapshots", () => {
+        encodeSnapshotTest(st.pipe(st.bytes(3), st.toBase64()), //
+        "rx9K");
+        encodeSnapshotTest(st.pipe(st.bytes(6), st.toBase64()), //
+        "fR9KIj8V");
+    });
+});

package/dist/transforms/toBytes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts an ArrayBuffer to the byte digits
+ *
+ * ```ts
+ * st.pipe(
+ *     st.bytes(3),
+ *     st.toBytes()
+ * )
+ * ```
+ *
+ * `ArrayBuffer([0, 255, c])` => `[0, 255, ArrayBuffer([0, 255, 0])]`
+ */
+export declare function toBytes(): import("./pipe").Transform<number[], ArrayBuffer>;

package/dist/transforms/toBytes.js

@@ -0,0 +1,24 @@
+import { encode } from "./encode";
+/**
+ * Converts an ArrayBuffer to the byte digits
+ *
+ * ```ts
+ * st.pipe(
+ *     st.bytes(3),
+ *     st.toBytes()
+ * )
+ * ```
+ *
+ * `ArrayBuffer([0, 255, c])` => `[0, 255, ArrayBuffer([0, 255, 0])]`
+ */
+export function toBytes() {
+    return encode({
+        encode: (v) => new Uint8Array(v.map(validateByte)).buffer,
+        decode: (v) => Array.from(new Uint8Array(v)),
+    });
+}
+const validateByte = (v) => {
+    if (v >= 0 && v <= 255)
+        return v;
+    throw new Error(`Invalid value: ${v}`);
+};

package/dist/transforms/toBytes.test.d.ts

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

package/dist/transforms/toBytes.test.js

@@ -0,0 +1,27 @@
+import { describe, it } from "bun:test";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test";
+import * as st from "../index";
+describe("st.toBytes", () => {
+    it("encode correctly", () => {
+        encodeTest(st.pipe(st.bytes(3), st.toBytes()), //
+        [0, 1, 2]);
+        encodeTest(st.pipe(st.bytes(3), st.toBytes()), //
+        [255, 0, 127]);
+    });
+    it("invalid length throws error", () => {
+        encodeFailTest(st.pipe(st.bytes(3), st.toBytes()), //
+        [0, 1]);
+    });
+    it("invalid values throws error", () => {
+        encodeFailTest(st.pipe(st.bytes(3), st.toBytes()), //
+        [256, 1, 1]);
+        encodeFailTest(st.pipe(st.bytes(3), st.toBytes()), //
+        [-1, 1, 1]);
+    });
+    it("snapshots", () => {
+        encodeSnapshotTest(st.pipe(st.bytes(3), st.toBytes()), //
+        [73, 12, 3]);
+        encodeSnapshotTest(st.pipe(st.bytes(6), st.toBytes()), //
+        [34, 10, 0, 74, 31, 23]);
+    });
+});

package/dist/transforms/toHex.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts an ArrayBuffer to uppercase hex
+ *
+ * ```ts
+ * st.pipe(
+ *     st.bytes(3),
+ *     st.toHex()
+ * )
+ * ```
+ *
+ * `ArrayBuffer([0, 255, 0])` => `00FF00`
+ */
+export declare function toHex(): import("./pipe").Transform<string, ArrayBuffer>;

package/dist/transforms/toHex.js

@@ -0,0 +1,19 @@
+import { encode } from "./encode";
+/**
+ * Converts an ArrayBuffer to uppercase hex
+ *
+ * ```ts
+ * st.pipe(
+ *     st.bytes(3),
+ *     st.toHex()
+ * )
+ * ```
+ *
+ * `ArrayBuffer([0, 255, 0])` => `00FF00`
+ */
+export function toHex() {
+    return encode({
+        encode: (v) => Uint8Array.fromHex(v).buffer,
+        decode: (v) => new Uint8Array(v).toHex().toUpperCase(),
+    });
+}

package/dist/transforms/toHex.test.d.ts

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

package/dist/transforms/toHex.test.js

@@ -0,0 +1,23 @@
+import { describe, it } from "bun:test";
+import { encodeTest, encodeSnapshotTest, encodeFailTest } from "../utils.test";
+import * as st from "../index";
+describe("st.toHex", () => {
+    it("encode correctly", () => {
+        encodeTest(st.pipe(st.bytes(3), st.toHex()), //
+        "FFAB01");
+    });
+    it("invalid digits error", () => {
+        encodeFailTest(st.pipe(st.bytes(3), st.toHex()), //
+        "00000G");
+    });
+    it("invalid length error", () => {
+        encodeFailTest(st.pipe(st.bytes(3), st.toHex()), //
+        "0000");
+    });
+    it("snapshots", () => {
+        encodeSnapshotTest(st.pipe(st.bytes(3), st.toHex()), //
+        "FFAB01");
+        encodeSnapshotTest(st.pipe(st.bytes(5), st.toHex()), //
+        "0000000000");
+    });
+});

package/dist/transforms/toTypedArray.d.ts

@@ -0,0 +1,16 @@
+type TypedArray = {
+    buffer: ArrayBuffer;
+};
+type TypedArrayConstructor<T extends TypedArray> = new (array: ArrayBuffer) => T;
+/**
+ * Converts an `ArrayBuffer` to a `TypedArray`
+ *
+ * ```
+ * st.pipe(
+ *     st.bytes(16),
+ *     toTypedArray(Uint8Array),
+ * )
+ * ```
+ */
+export declare function toTypedArray<T extends TypedArray>(arrayType: TypedArrayConstructor<T>): import("./pipe").Transform<T, ArrayBuffer>;
+export {};

package/dist/transforms/toTypedArray.js

@@ -0,0 +1,17 @@
+import { encode } from "./encode";
+/**
+ * Converts an `ArrayBuffer` to a `TypedArray`
+ *
+ * ```
+ * st.pipe(
+ *     st.bytes(16),
+ *     toTypedArray(Uint8Array),
+ * )
+ * ```
+ */
+export function toTypedArray(arrayType) {
+    return encode({
+        encode: (v) => v.buffer,
+        decode: (v) => new arrayType(v),
+    });
+}

package/dist/transforms/toTypedArray.test.d.ts

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

package/dist/transforms/toTypedArray.test.js

@@ -0,0 +1,29 @@
+import { describe, it } from "bun:test";
+import { encodeTest, encodeSnapshotTest, expectError } from "../utils.test";
+import * as st from "../index";
+describe("st.toArrayBuffer", () => {
+    it("encode correctly", () => {
+        encodeTest(st.pipe(st.bytes(6), //
+        st.toTypedArray(Uint8Array)), new Uint8Array([1, 2, 3, 4, 5, 6]));
+    });
+    it("encode different types correctly", () => {
+        encodeTest(st.pipe(st.bytes(3), //
+        st.toTypedArray(Uint8Array)), new Uint8Array([1, 2, 3]));
+        encodeTest(st.pipe(st.bytes(5 * 2), //
+        st.toTypedArray(Uint16Array)), new Uint16Array([1, 2, 3, 63, 74]));
+        encodeTest(st.pipe(st.bytes(3 * 8), //
+        st.toTypedArray(Float64Array)), new Float64Array([Math.random(), Math.random(), Math.random()]));
+    });
+    it("errors on different types", () => {
+        expectError(() => {
+            st.write(st.pipe(st.bytes(3), //
+            st.toTypedArray(Uint16Array)), new Uint16Array([1]));
+        });
+    });
+    it("snapshot tests", () => {
+        encodeSnapshotTest(st.pipe(st.bytes(4 * 2), //
+        st.toTypedArray(Uint16Array)), new Uint16Array([1, 6, 3, 12]));
+        encodeSnapshotTest(st.pipe(st.bytes(3 * 8), //
+        st.toTypedArray(Float64Array)), new Float64Array([1.52, 0.3523, 0.152]));
+    });
+});

package/dist/types.d.ts

@@ -3,13 +3,16 @@ export type Serializer<TIn, TOut = TIn> = {
     write: (ctx: WriterContext, value: TIn) => void;
     read: (ctx: ReaderContext) => TOut;
 };
+export type SerializationContext = WriterContext | ReaderContext;
 export interface WriterContext {
+    stack: string[];
     buffer: ArrayBuffer;
     view: DataView;
     offset: number;
     alloc: (length: number) => void;
 }
 export interface ReaderContext {
+    stack: string[];
     buffer: ArrayBuffer;
     view: DataView;
     offset: number;

package/dist/utilities/index.d.ts

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

package/dist/utilities/index.js

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

package/dist/utilities/lazy.d.ts

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

package/dist/utilities/lazy.js

@@ -0,0 +1,25 @@
+export function lazy(type) {
+    let _size;
+    let resolve = () => {
+        resolve = () => { };
+        const { size, write, read } = type();
+        _size = size ?? undefined;
+        serializer.read = read;
+        serializer.write = write;
+    };
+    const serializer = {
+        get size() {
+            resolve();
+            return _size;
+        },
+        read(ctx) {
+            resolve();
+            return this.read(ctx);
+        },
+        write(ctx, value) {
+            resolve();
+            return this.write(ctx, value);
+        },
+    };
+    return serializer;
+}

package/dist/utilities/lazy.test.d.ts

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

package/dist/utilities/lazy.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "bun:test";
+import { encodeTest } from "../utils.test";
+import * as st from "../index";
+describe("st.lazy", () => {
+    it("encodes correctly", () => {
+        const spec = st.lazy(() => st.object({
+            a: st.array(4, st.u8()),
+            b: st.u16(),
+        }));
+        encodeTest(spec, {
+            a: [1, 2, 3, 4],
+            b: 2,
+        });
+    });
+    it("nested objects function", () => {
+        const spec = st.object({
+            a: st.array(4, st.u8()),
+            b: st.lazy(() => st.object({
+                a: st.lazy(() => st.u16()),
+            })),
+        });
+        encodeTest(spec, {
+            a: [1, 2, 3, 4],
+            b: { a: 1 },
+        });
+    });
+    it("size is calculated correctly", () => {
+        const spec = st.lazy(() => st.object({
+            b: st.lazy(() => st.object({
+                a: st.u32(),
+                b: st.u8(),
+            })),
+        }));
+        expect(spec.size).toBe(5);
+    });
+});

package/dist/utilities/reference.d.ts

@@ -0,0 +1,18 @@
+import type { Serializer } from "../types";
+/**
+ * createReference lets you defer writing a value until later, useful for lengths and sizes
+ *
+ * ---
+ * ```
+ * const length = st.createReference<number>()
+ * st.object({
+ *   length: length.pointer(st.u32()),
+ *   type: st.u8(),
+ *   data: st.sizedBytes(length.deref())
+ * })
+ * ```
+ */
+export declare function createReference<T>(): {
+    pointer: (serializer: Serializer<T>) => Serializer<T>;
+    deref: () => Serializer<T>;
+};

package/dist/utilities/reference.js

@@ -0,0 +1,91 @@
+/**
+ * createReference lets you defer writing a value until later, useful for lengths and sizes
+ *
+ * ---
+ * ```
+ * const length = st.createReference<number>()
+ * st.object({
+ *   length: length.pointer(st.u32()),
+ *   type: st.u8(),
+ *   data: st.sizedBytes(length.deref())
+ * })
+ * ```
+ */
+export function createReference() {
+    const readStack = [];
+    const writeStack = [];
+    /**
+     * When reading: reads the value normal and saves it for later
+     *
+     * When writing: omits this value, it is written by deref
+     *
+     * ---
+     * ```
+     * const length = st.createReference<number>()
+     * st.object({
+     *   length: length.pointer(st.u32()),
+     *   type: st.u8(),
+     *   data: st.sizedBytes(length.deref())
+     * })
+     * ```
+     */
+    function pointer(serializer) {
+        const size = serializer.size;
+        if (size === undefined)
+            throw new Error("Serializer must be sized");
+        return {
+            size,
+            read: (ctx) => {
+                const value = serializer.read(ctx);
+                readStack.push(value);
+                return value;
+            },
+            write: (ctx, value) => {
+                writeStack.push({
+                    offset: ctx.offset,
+                    serializer,
+                });
+                ctx.offset += size;
+                return value;
+            },
+        };
+    }
+    /**
+     * When reading: gets the value stored in pointer
+     *
+     * When writing: saves the value into the pointer
+     *
+     * By default the value is removed from the pointer,
+     * but you can retain it to ensure the next value is
+     *
+     * ---
+     * ```
+     * const length = st.createReference<number>()
+     * st.object({
+     *   length: length.pointer(st.u32()),
+     *   type: st.u8(),
+     *   data: st.sizedBytes(length.deref())
+     * })
+     * ```
+     */
+    function deref() {
+        return {
+            size: 0,
+            read: () => {
+                if (readStack.length === 0)
+                    throw new Error("Read Stack Empty");
+                return readStack.pop();
+            },
+            write: (ctx, value) => {
+                if (writeStack.length === 0)
+                    throw new Error("Write Stack is emtpy");
+                const { offset, serializer } = writeStack.pop();
+                const start = ctx.offset;
+                ctx.offset = offset;
+                serializer.write(ctx, value);
+                ctx.offset = start;
+            },
+        };
+    }
+    return { pointer, deref };
+}

package/dist/utilities/reference.test.d.ts

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

package/dist/utilities/reference.test.js

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "bun:test";
+import { encodeTest, encodeSnapshotTest, expectError } from "../utils.test";
+import * as st from "../index";
+describe("st.createReference", () => {
+    it("encodes correctly", () => {
+        const length = st.createReference();
+        const spec = st.object({
+            length: length.pointer(st.u32()),
+            numbers: st.list(length.deref(), st.u8()),
+        });
+        expect(spec.size).toBe(undefined);
+        encodeTest(spec, //
+        { length: 0, numbers: [1, 3, 4] }, { length: 3, numbers: [1, 3, 4] });
+    });
+    it("cant create reference to pointer", () => {
+        const length = st.createReference();
+        expectError(() => {
+            length.pointer(st.sizedBytes(st.u8()));
+        });
+    });
+    it("multiple runs function", () => {
+        const v = st.createReference();
+        const spec = st.object({
+            a: v.pointer(st.u32()),
+            b: st.list(v.deref(), st.u8()),
+        });
+        for (let i = 0; i < 3; i++) {
+            encodeTest(spec, //
+            { a: NaN, b: [1, 3, 4] }, { a: 3, b: [1, 3, 4] });
+        }
+    });
+    it("handles recursive objects", () => {
+        const size = st.createReference();
+        //@ts-expect-error, recursive types
+        const Node = st.lazy(() => st.object({
+            size: size.pointer(st.u32()),
+            children: st.list(size.deref(), Node),
+        }));
+        encodeTest(Node, {
+            size: NaN,
+            children: [
+                { size: NaN, children: [] },
+                { size: NaN, children: [{ size: NaN, children: [] }] },
+            ],
+        }, {
+            size: 2,
+            children: [
+                { size: 0, children: [] },
+                { size: 1, children: [{ size: 0, children: [] }] },
+            ],
+        });
+    });
+    it("snapshots are correct", () => {
+        const v = st.createReference();
+        encodeSnapshotTest(st.object({
+            a: v.pointer(st.u32()),
+            b: st.list(v.deref(), st.u8()),
+        }), {
+            a: 3,
+            b: [1, 3, 4],
+        });
+    });
+});