@nnilky/structo 1.0.7 → 1.0.9

package/README.md

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

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

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

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

package/dist/datatypes/containers/exhuastiveArray.js

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

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

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

package/dist/datatypes/containers/fastObject.js

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

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

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

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

@@ -1,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

@@ -21,19 +21,19 @@ export function object(definition) {
             if (size)
                 ctx.alloc(size);
             for (let i = 0; i < entires.length; i++) {
-                const key = entires[i][0];
-                try {
-                    entires[i][1].write(ctx, value[key]);
-                }
-                catch (e) {
-                    throw new Error(`Failed to encode key '${key}'`, { cause: e });
-                }
+                const [key, serializer] = entires[i];
+                ctx.stack.push(`.${key}`);
+                serializer.write(ctx, value[key]);
+                ctx.stack.pop();
             }
         },
         read: (ctx) => {
             const output = new Array(entires.length);
             for (let i = 0; i < entires.length; i++) {
-                output[i] = [entires[i][0], entires[i][1].read(ctx)];
+                const [key, serializer] = entires[i];
+                ctx.stack.push(`.${key}`);
+                output[i] = [key, serializer.read(ctx)];
+                ctx.stack.pop();
             }
             return Object.fromEntries(output);
         },

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

@@ -1,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.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.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.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.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, () => {

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

@@ -1,4 +1,4 @@
-import type { Serializer } from "../../types";
+import type { Serializer } from "../../types.js";
 /**
  * Fixed length bytes
  *

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import type { Serializer } from "../../types";
+import type { Serializer } from "../../types.js";
 /**
  * `st.json` stores string data by writing/reading the length and then reading that many bytes
  *

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

@@ -1,6 +1,6 @@
 import { describe, it } from "bun:test";
-import { encodeFailTest, encodeTest } from "../../utils.test";
-import * as st from "../../index";
+import { encodeFailTest, encodeTest } from "../../utils.test.js";
+import * as st from "../../index.js";
 describe("st.string", () => {
     it("encode correctly", () => {
         encodeTest(st.string(st.u8()), "foo");
@@ -12,6 +12,9 @@ describe("st.string", () => {
         //@ts-expect-error, intentional mistake
         encodeFailTest(st.string(st.u8()), 8);
     });
+    it("works on long strings", () => {
+        encodeTest(st.string(st.u32()), "A".repeat(2 ** 24));
+    });
     it("errors on too long strings", () => {
         encodeFailTest(st.string(st.u8()), "A".repeat(256));
     });

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/read.d.ts

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

package/dist/read.js

@@ -1,8 +1,16 @@
 export function read(serializer, buffer) {
-    return serializer.read(createReaderContext(buffer));
+    const ctx = createReaderContext(buffer);
+    try {
+        return serializer.read(ctx);
+    }
+    catch (e) {
+        const path = ctx.stack.join("") ?? "root";
+        throw new Error(`Deserialization error at serializer${path}`, { cause: e });
+    }
 }
 export function createReaderContext(buffer) {
     return {
+        stack: [],
         offset: 0,
         buffer,
         view: new DataView(buffer),

package/dist/transforms/encode.d.ts

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

package/dist/transforms/encode.js

@@ -1,4 +1,5 @@
-export function encode(encode, decode) {
+export function encode(options) {
+    const { encode, decode } = options;
     return (type) => ({
         size: type.size,
         read: (ctx) => decode(type.read(ctx)),

package/dist/transforms/enum.d.ts

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

package/dist/transforms/enum.js

@@ -1,13 +1,16 @@
-import { encode } from "./encode";
+import { encode } from "./encode.js";
 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;
+    return encode({
+        encode: (v) => {
+            if (!values.includes(v))
+                throw new Error(`Invalid enum variant: ${v}`);
+            return v;
+        },
+        decode: (v) => {
+            if (!values.includes(v))
+                throw new Error(`Invalid enum variant: ${v}`);
+            return v;
+        },
     });
 }
 export { enum_ as enum };

package/dist/transforms/enum.test.js

@@ -1,6 +1,6 @@
 import { describe, it } from "node:test";
-import * as st from "../index";
-import { encodeTest, encodeFailTest } from "../utils.test";
+import * as st from "../index.js";
+import { encodeTest, encodeFailTest } from "../utils.test.js";
 describe("st.enum", () => {
     it("encode correctly", () => {
         encodeTest(st.pipe(st.u8(), st.enum([0, 1, 2])), //

package/dist/transforms/index.d.ts

@@ -1,12 +1,11 @@
-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";
+export { type Transform as Pipeline, pipe } from "./pipe.js";
+export { encode } from "./encode.js";
+export { modify } from "./modify.js";
+export { literal } from "./literal.js";
+export { enum } from "./enum.js";
+export { offset } from "./offset.js";
+export { toAscii } from "./toAscii.js";
+export { toBytes } from "./toBytes.js";
+export { toHex } from "./toHex.js";
+export { toBase64 } from "./toBase64.js";
+export { toTypedArray } from "./toTypedArray.js";