@nnilky/structo 1.0.9 → 1.1.0

package/dist/transforms/toHex.js

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

package/dist/transforms/toTypedArray.d.ts

@@ -1,16 +1,21 @@
-type TypedArray = {
-    buffer: ArrayBuffer;
+type TypedArrayLike = {
+    buffer: ArrayBuffer | SharedArrayBuffer;
+    byteOffset: number;
+    byteLength: number;
+    BYTES_PER_ELEMENT: number;
 };
-type TypedArrayConstructor<T extends TypedArray> = new (array: ArrayBuffer) => T;
+type TypedArray<T extends TypedArrayLike> = {
+    BYTES_PER_ELEMENT: number;
+} & (new (array: ArrayBuffer | SharedArrayBuffer, offset?: number, length?: number) => T);
 /**
- * Converts an `ArrayBuffer` to a `TypedArray`
+ * Converts a `Uint8Array` into the provided `TypedArray`, etc Float64Arrayt
  *
  * ```
  * st.pipe(
  *     st.bytes(16),
- *     toTypedArray(Uint8Array),
+ *     toTypedArray(Float32Array),
  * )
  * ```
  */
-export declare function toTypedArray<T extends TypedArray>(arrayType: TypedArrayConstructor<T>): import("./pipe.js").Transform<T, ArrayBuffer>;
+export declare function toTypedArray<T extends TypedArrayLike>(Array: TypedArray<T>): import("./pipe.ts").Transform<T, Uint8Array<ArrayBufferLike>>;
 export {};

package/dist/transforms/toTypedArray.js

@@ -1,17 +1,22 @@
 import { encode } from "./encode.js";
 /**
- * Converts an `ArrayBuffer` to a `TypedArray`
+ * Converts a `Uint8Array` into the provided `TypedArray`, etc Float64Arrayt
  *
  * ```
  * st.pipe(
  *     st.bytes(16),
- *     toTypedArray(Uint8Array),
+ *     toTypedArray(Float32Array),
  * )
  * ```
  */
-export function toTypedArray(arrayType) {
+export function toTypedArray(Array) {
     return encode({
-        encode: (v) => v.buffer,
-        decode: (v) => new arrayType(v),
+        encode: (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength / Uint8Array.BYTES_PER_ELEMENT),
+        decode: (bytes) => {
+            if (bytes.byteLength % Array.BYTES_PER_ELEMENT !== 0) {
+                throw new Error(`Provided a ${bytes.byteLength} buffer to a TypedArray that uses ${bytes.BYTES_PER_ELEMENT} bytes per element`);
+            }
+            return new Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / Array.BYTES_PER_ELEMENT);
+        },
     });
 }

package/dist/transforms/toTypedArray.test.js

@@ -1,23 +1,32 @@
 import { describe, it } from "bun:test";
 import { encodeTest, encodeSnapshotTest, expectError } from "../utils.test.js";
 import * as st from "../index.js";
-describe("st.toArrayBuffer", () => {
+describe("st.toTypedArray", () => {
     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()]));
+        encodeTest(st.object({
+            padding: st.u64(),
+            data: st.pipe(st.bytes(3), //
+            st.toTypedArray(Uint8Array)),
+        }), { padding: 0, data: new Uint8Array([1, 2, 3]) });
+        encodeTest(st.object({
+            padding: st.u64(),
+            data: st.pipe(st.bytes(5 * 2), //
+            st.toTypedArray(Uint16Array)),
+        }), { padding: 0, data: new Uint16Array([1, 2, 3, 63, 74]) });
+        encodeTest(st.object({
+            padding: st.u64(),
+            data: st.pipe(st.bytes(3 * 8), //
+            st.toTypedArray(Float64Array)),
+        }), { padding: 0, data: new Float64Array([Math.random(), Math.random(), Math.random()]) });
     });
-    it("errors on different types", () => {
+    it("errors when non-standard size", () => {
         expectError(() => {
             st.write(st.pipe(st.bytes(3), //
-            st.toTypedArray(Uint16Array)), new Uint16Array([1]));
+            st.toTypedArray(Uint16Array)), new Uint16Array([1, 2]));
         });
     });
     it("snapshot tests", () => {

package/dist/types.d.ts

@@ -4,18 +4,20 @@ export type Serializer<TIn, TOut = TIn> = {
     read: (ctx: ReaderContext) => TOut;
 };
 export type SerializationContext = WriterContext | ReaderContext;
-export interface WriterContext {
-    stack: string[];
-    buffer: ArrayBuffer;
-    view: DataView;
+export interface WriterContext<TBuffer extends ArrayBuffer | SharedArrayBuffer = ArrayBuffer | SharedArrayBuffer> {
     offset: number;
-    alloc: (length: number) => void;
-}
-export interface ReaderContext {
-    stack: string[];
-    buffer: ArrayBuffer;
+    buffer: TBuffer;
     view: DataView;
+    bytes: Uint8Array;
+    path: string[];
+    reserve: (length: number) => void;
+}
+export interface ReaderContext<TBuffer extends ArrayBuffer | SharedArrayBuffer = ArrayBuffer | SharedArrayBuffer> {
     offset: number;
+    buffer: TBuffer;
+    view: DataView;
+    bytes: Uint8Array;
+    path: string[];
 }
 export type InferInput<T> = T extends Serializer<infer V> ? V : never;
 export type InferOutput<T> = T extends Serializer<any, infer V> ? V : never;

package/dist/utilities/remember.d.ts

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

package/dist/utilities/remember.js

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

package/dist/utils.test.d.ts

@@ -6,4 +6,4 @@ export declare const encodeFailTest: <TIn, TOut>(serializer: st.Serializer<TIn,
 export declare const expectEncodeSize: <TIn, TOut>(serializer: st.Serializer<TIn, TOut>, size: number, value: TIn) => void;
 export declare const encodeSnapshotTest: <T>(serializer: st.Serializer<T>, value: T) => void;
 export declare const expectError: (callback: () => void) => void;
-export declare const bytes: (bytes: number[]) => ArrayBuffer;
+export declare const bytes: (bytes: number[]) => Uint8Array<ArrayBuffer>;

package/dist/utils.test.js

@@ -37,6 +37,4 @@ export const expectError = (callback) => {
     }
     throw new Error("Expected Error");
 };
-export const bytes = (bytes) => {
-    return new Uint8Array(bytes).buffer;
-};
+export const bytes = (bytes) => new Uint8Array(bytes);

package/dist/write.d.ts

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

package/dist/write.js

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

package/package.json

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

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

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

package/dist/datatypes/containers/sizedbytes.js

@@ -1,17 +0,0 @@
-export function sizedBytes(length) {
-    return {
-        write: (ctx, value) => {
-            length.write(ctx, value.byteLength);
-            const bytes = new Uint8Array(value);
-            ctx.alloc(value.byteLength);
-            new Uint8Array(ctx.view.buffer).set(bytes, ctx.offset);
-            ctx.offset += value.byteLength;
-        },
-        read: (ctx) => {
-            const size = length.read(ctx);
-            const slice = ctx.buffer.slice(ctx.offset, ctx.offset + size);
-            ctx.offset += size;
-            return slice;
-        },
-    };
-}

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

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

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

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

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

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

package/dist/datatypes/containers/string.js

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

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

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

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

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

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

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

package/dist/datatypes/transforms/encode.js

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

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

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

package/dist/datatypes/transforms/fixedOffset.js

@@ -1,18 +0,0 @@
-export function fixedOffset(delta) {
-    return (type) => ({
-        size: type.size,
-        read: (ctx) => {
-            let start = ctx.offset;
-            ctx.offset += delta;
-            const value = type.read(ctx);
-            ctx.offset = start;
-            return value;
-        },
-        write: (ctx, value) => {
-            let start = ctx.offset;
-            ctx.offset += delta;
-            type.write(ctx, value);
-            ctx.offset = start;
-        },
-    });
-}

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

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

package/dist/datatypes/transforms/modify.js

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

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

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

package/dist/datatypes/transforms/noAdvance.js

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

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

@@ -1,11 +0,0 @@
-import type { Serializer } from "../../types";
-export type Transform<T = any, TNext = T> = (type: Serializer<TNext>) => Serializer<T>;
-export declare function pipe<TStart, T1>(type: Serializer<TStart>, p1: Transform<T1, TStart>): Serializer<T1>;
-export declare function pipe<TStart, T1, T2>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>): Serializer<T2>;
-export declare function pipe<TStart, T1, T2, T3>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>): Serializer<T3>;
-export declare function pipe<TStart, T1, T2, T3, T4>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>): Serializer<T4>;
-export declare function pipe<TStart, T1, T2, T3, T4, T5>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>, p5: Transform<T5, T4>): Serializer<T5>;
-export declare function pipe<TStart, T1, T2, T3, T4, T5, T6>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>, p5: Transform<T5, T6>): Serializer<T6>;
-export declare function pipe<TStart, T1, T2, T3, T4, T5, T6, T7>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>, p5: Transform<T5, T6>, p6: Transform<T6, T7>): Serializer<T7>;
-export declare function pipe<TStart, T1, T2, T3, T4, T5, T6, T7, T8>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>, p5: Transform<T5, T6>, p6: Transform<T6, T7>, p7: Transform<T7, T8>): Serializer<T8>;
-export declare function pipe<TStart, T1, T2, T3, T4, T5, T6, T7, T8, T9>(type: Serializer<TStart>, p1: Transform<T1, TStart>, p2: Transform<T2, T1>, p3: Transform<T3, T2>, p4: Transform<T4, T3>, p5: Transform<T5, T6>, p6: Transform<T6, T7>, p7: Transform<T7, T8>, p8: Transform<T8, T9>): Serializer<T9>;

package/dist/datatypes/transforms/pipe.js

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

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

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

package/dist/datatypes/utilities/remember.js

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

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

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