@nnilky/structo 1.0.4 → 1.0.7

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

@@ -0,0 +1,9 @@
+import type { Serializer } from "../../types";
+/**
+ * Fixed length bytes
+ *
+ * ```
+ * st.bytes(4)
+ * ```
+ */
+export declare function bytes(size: number): Serializer<ArrayBuffer>;

package/dist/datatypes/values/{buffer.js → bytes.js}

@@ -1,4 +1,11 @@
-export function buffer(size) {
+/**
+ * Fixed length bytes
+ *
+ * ```
+ * st.bytes(4)
+ * ```
+ */
+export function bytes(size) {
     return {
         size,
         write: (ctx, value) => {

package/dist/datatypes/values/bytes.test.d.ts

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

package/dist/datatypes/values/{buffer.test.js → bytes.test.js}

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

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

@@ -0,0 +1,10 @@
+import type { Serializer } from "../../types";
+/**
+ * `st.json` stores JSON data using a string serializer
+ *
+ * ```
+ * st.json(st.string(st.u32()))
+ * ```
+ *
+ */
+export declare function json(type: Serializer<string>): Serializer<any>;

package/dist/datatypes/values/json.js

@@ -0,0 +1,21 @@
+/**
+ * `st.json` stores JSON data using a string serializer
+ *
+ * ```
+ * st.json(st.string(st.u32()))
+ * ```
+ *
+ */
+export function json(type) {
+    return {
+        size: type.size,
+        write: (ctx, value) => {
+            const json = JSON.stringify(value);
+            type.write(ctx, json);
+        },
+        read: (ctx) => {
+            const value = type.read(ctx);
+            return JSON.parse(value);
+        },
+    };
+}

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

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

package/dist/datatypes/values/sizedbytes.js

@@ -0,0 +1,17 @@
+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/values/sizedbytes.test.d.ts

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

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

@@ -0,0 +1,25 @@
+import { describe, it } from "bun:test";
+import { bytes, encodeFailTest, encodeTest } from "../../utils.test";
+import * as st from "../../index";
+describe("st.sizedBytes", () => {
+    it("encode correctly", () => {
+        const buffer = st.sizedBytes(st.u8());
+        encodeTest(buffer, bytes([1, 2]));
+    });
+    it("encodes empty correctly", () => {
+        const spec = st.sizedBytes(st.u8());
+        encodeTest(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);
+        encodeTest(spec, data.buffer);
+    });
+    it("errors on invalid length", () => {
+        encodeFailTest(st.sizedBytes(st.u8()), //
+        bytes(Array.from({ length: 256 }, () => 0)));
+    });
+});

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

@@ -1,2 +1,14 @@
 import type { Serializer } from "../../types";
+/**
+ * `st.json` stores string data by writing/reading the length and then reading that many bytes
+ *
+ * The type passed in is the type used to store it's length
+ *
+ * Note: The length stored is the byte length, not string length
+ *
+ * ```
+ * st.string(st.u32())
+ * ```
+ *
+ */
 export declare function string(length: Serializer<number>): Serializer<string>;

package/dist/datatypes/values/string.js

@@ -1,21 +1,35 @@
+/**
+ * `st.json` stores string data by writing/reading the length and then reading that many bytes
+ *
+ * The type passed in is the type used to store it's length
+ *
+ * Note: The length stored is the byte length, not string length
+ *
+ * ```
+ * st.string(st.u32())
+ * ```
+ *
+ */
 export function string(length) {
-    const { read: readLength, write: writeLength, size: lengthSize = 0 } = 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");
             const bytes = encoder.encode(value);
-            const length = bytes.byteLength;
-            ctx.alloc(length + lengthSize);
-            writeLength(ctx, length);
+            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 += length;
+            ctx.offset += size;
         },
         read: (ctx) => {
-            const length = readLength(ctx);
-            const section = ctx.buffer.slice(ctx.offset, ctx.offset + length);
-            ctx.offset += length;
+            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/values/string.test.js

@@ -1,18 +1,18 @@
 import { describe, it } from "bun:test";
-import { expectEncode, expectError } from "../utils.test";
+import { encodeFailTest, encodeTest } 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");
+        encodeTest(st.string(st.u8()), "foo");
     });
     it("works on empty strings", () => {
-        expectEncode(string_u32, "");
+        encodeTest(st.string(st.u32()), "");
+    });
+    it("errors on numbers", () => {
+        //@ts-expect-error, intentional mistake
+        encodeFailTest(st.string(st.u8()), 8);
     });
     it("errors on too long strings", () => {
-        expectError(() => {
-            st.write(string_u8, "A".repeat(256));
-        });
+        encodeFailTest(st.string(st.u8()), "A".repeat(256));
     });
 });

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export type { InferInput as Infer, InferInput, InferOutput, ReaderContext, WriterContext, Serializer, } from "./types";
-export * from "./datatypes";
 export { read, createReaderContext } from "./read";
 export { write, createdWriterContext } from "./write";
+export * from "./datatypes/index";
+export * from "./transforms/index";
+export * from "./utilities/index";

package/dist/index.js

@@ -1,3 +1,5 @@
-export * from "./datatypes";
 export { read, createReaderContext } from "./read";
 export { write, createdWriterContext } from "./write";
+export * from "./datatypes/index";
+export * from "./transforms/index";
+export * from "./utilities/index";

package/dist/read.d.ts

@@ -1,5 +1,5 @@
 import type { Serializer } from "./types";
-export declare function read<T>(serializer: Serializer<T>, buffer: ArrayBuffer): T;
+export declare function read<TIn, TOut>(serializer: Serializer<TIn, TOut>, buffer: ArrayBuffer): TOut;
 export declare function createReaderContext(buffer: ArrayBuffer): {
     offset: number;
     buffer: ArrayBuffer;

package/dist/transforms/encode.d.ts

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

package/dist/transforms/encode.js

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

package/dist/transforms/enum.d.ts

@@ -0,0 +1,2 @@
+export declare function enum_<const T>(values: T[]): import("./pipe").Transform<T, any>;
+export { enum_ as enum };

package/dist/transforms/enum.js

@@ -0,0 +1,13 @@
+import { encode } from "./encode";
+export function enum_(values) {
+    return encode((v) => {
+        if (!values.includes(v))
+            throw new Error(`Invalid enum variant: ${v}`);
+        return v;
+    }, (v) => {
+        if (!values.includes(v))
+            throw new Error(`Invalid enum variant: ${v}`);
+        return v;
+    });
+}
+export { enum_ as enum };

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

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

package/dist/transforms/enum.test.js

@@ -0,0 +1,21 @@
+import { describe, it } from "node:test";
+import * as st from "../index";
+import { encodeTest, encodeFailTest } from "../utils.test";
+describe("st.enum", () => {
+    it("encode correctly", () => {
+        encodeTest(st.pipe(st.u8(), st.enum([0, 1, 2])), //
+        1);
+        encodeTest(st.pipe(st.string(st.u8()), st.enum(["foo", "bar", "woof"])), //
+        "foo");
+    });
+    it("invalid union variants error", () => {
+        //@ts-expect-error
+        encodeFailTest(st.pipe(st.u8(), st.enum([0, 1, 2])), 4);
+        //@ts-expect-error
+        encodeFailTest(st.pipe(st.string(st.u8()), st.enum(["A", "B", "C"])), "D");
+    });
+    () => {
+        //@ts-expect-error, invalid union variant
+        st.write(st.pipe(st.u8(), st.enum([0, 1, 2])), 4);
+    };
+});

package/dist/transforms/fixedOffset.d.ts

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

package/dist/transforms/fixedOffset.js

@@ -0,0 +1,18 @@
+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/transforms/index.d.ts

@@ -0,0 +1,12 @@
+export { type Transform as Pipeline, pipe } from "./pipe";
+export { encode } from "./encode";
+export { modify } from "./modify";
+export { literal } from "./literal";
+export { enum } from "./enum";
+export { fixedOffset } from "./fixedOffset";
+export { noAdvance } from "./noAdvance";
+export { toAscii } from "./toAscii";
+export { toBytes } from "./toBytes";
+export { toHex } from "./toHex";
+export { toBase64 } from "./toBase64";
+export { toTypedArray } from "./toTypedArray";

package/dist/transforms/index.js

@@ -0,0 +1,12 @@
+export { pipe } from "./pipe";
+export { encode } from "./encode";
+export { modify } from "./modify";
+export { literal } from "./literal";
+export { enum } from "./enum";
+export { fixedOffset } from "./fixedOffset";
+export { noAdvance } from "./noAdvance";
+export { toAscii } from "./toAscii";
+export { toBytes } from "./toBytes";
+export { toHex } from "./toHex";
+export { toBase64 } from "./toBase64";
+export { toTypedArray } from "./toTypedArray";

package/dist/transforms/literal.d.ts

@@ -0,0 +1 @@
+export declare function literal<const T>(value: T): import("./pipe").Transform<T, any>;

package/dist/transforms/literal.js

@@ -0,0 +1,12 @@
+import { encode } from "./encode";
+export function literal(value) {
+    return encode((v) => {
+        if (v !== value)
+            throw new Error(`Invalid literal variant: ${v}`);
+        return v;
+    }, (v) => {
+        if (v !== value)
+            throw new Error(`Invalid literal variant: ${v}`);
+        return v;
+    });
+}

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

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

package/dist/transforms/literal.test.js

@@ -0,0 +1,23 @@
+import { describe, it } from "node:test";
+import * as st from "../index";
+import { encodeTest, encodeFailTest } from "../utils.test";
+describe("st.literal", () => {
+    it("encode correctly", () => {
+        encodeTest(st.pipe(st.u8(), st.literal(0)), //
+        0);
+        encodeTest(st.pipe(st.string(st.u8()), st.literal("foo")), //
+        "foo");
+    });
+    it("invalid literal errors", () => {
+        //@ts-expect-error
+        encodeFailTest(st.pipe(st.u8(), st.literal(0)), 2);
+        //@ts-expect-error
+        encodeFailTest(st.pipe(st.string(st.u8()), st.literal("A")), "B");
+    });
+    () => {
+        //@ts-expect-error, invalid union variant
+        st.write(st.pipe(st.u8(), st.literal(0)), 1);
+        //@ts-expect-error, invalid union variant
+        st.write(st.pipe(st.u8(), st.literal("foo")), "bar");
+    };
+});

package/dist/transforms/modify.d.ts

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

package/dist/transforms/modify.js

@@ -0,0 +1,7 @@
+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/transforms/noAdvance.d.ts

@@ -0,0 +1,16 @@
+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/transforms/noAdvance.js

@@ -0,0 +1,30 @@
+/**
+ * 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/transforms/noAdvance.test.d.ts

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

package/dist/transforms/noAdvance.test.js

@@ -0,0 +1,17 @@
+import { describe, it } from "node:test";
+import * as st from "../index";
+import { encodeTest } from "../utils.test";
+describe("st.noAdvance", () => {
+    it("encode correctly", () => {
+        encodeTest(st.object({
+            length: st.pipe(st.u8(), st.noAdvance()),
+            text: st.string(st.u8()),
+        }), //
+        { length: 3, text: "foo" });
+        encodeTest(st.object({
+            a: st.pipe(st.u16(), st.noAdvance()),
+            b: st.f16(),
+        }), //
+        { a: 0, b: 1 }, { a: 15360, b: 1 });
+    });
+});

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(-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,11 @@
+import { encode } from "./encode";
+export function toAscii() {
+    return encode((v) => new Uint8Array(Array.from(v).map((char) => validateAscii(char.charCodeAt(0)))).buffer, (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,4 @@
+import { encode } from "./encode";
+export function toBase64() {
+    return encode((v) => Uint8Array.fromBase64(v).buffer, (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");
+    });
+});