@chr33s/pdf-restructure 5.0.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Andrew Dillon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,323 @@
+# @chr33s/pdf-restructure
+
+> Declarative binary encoding and decoding primitives packaged as modern ES modules.
+
+`@chr33s/pdf-restructure` lives in the [`chr33s/pdf`](https://github.com/chr33s/pdf) monorepo and carries forward the
+[`Hopding/restructure`](https://github.com/Hopding/restructure) fork of Devon Govett’s original project. This edition provides:
+
+- native ES modules targeting NodeNext (Node.js 18+ or a modern bundler required),
+- TypeScript sources with generated declaration files for first-class editor support, and
+- updated test coverage powered by Vitest.
+
+## Installation
+
+```bash
+npm install @chr33s/pdf-restructure
+```
+
+Use Node.js 18+ or configure your bundler to resolve NodeNext-style ES modules.
+
+## Overview
+
+Restructure allows you to declaratively encode and decode binary data.
+It supports a wide variety of types to enable you to express a multitude
+of binary formats without writing any parsing code.
+
+Some of the supported features are C-like structures, versioned structures,
+pointers, arrays of any type, strings of a large number of encodings, enums,
+bitfields, and more.  See the documentation below for more details.
+
+## Example
+
+This is just a small example of what Restructure can do. Check out the API documentation
+below for more information.
+
+```ts
+import fs from "node:fs";
+import {
+  DecodeStream,
+  EncodeStream,
+  Struct,
+  String,
+  uint8,
+} from "@chr33s/pdf-restructure";
+
+const Person = new Struct({
+  name: new String(uint8, "utf8"),
+  age: uint8,
+});
+
+// decode a person from a buffer
+const decodeStream = new DecodeStream(buffer);
+const person = Person.decode(decodeStream);
+
+// encode a person back to a stream
+const encodeStream = new EncodeStream();
+encodeStream.pipe(fs.createWriteStream("out.bin"));
+
+Person.encode(encodeStream, person);
+encodeStream.end();
+```
+
+
+## API
+
+All of the following types support three standard methods:
+
+* `decode(stream)` - decodes an instance of the type from the given DecodeStream
+* `size(value)` - returns the amount of space the value would take if encoded
+* `encode(stream, value)` - encodes the given value into the given EncodeStream
+
+Restructure supports a wide variety of types, but if you need to write your own for
+some custom use that cannot be represented by them, you can do so by just implementing
+the above methods. Then you can use your type just as you would any other type, in structures
+and whatnot.
+
+### Number Types
+
+The following built-in number types are available:
+
+```javascript
+uint8, uint16, uint24, uint32, int8, int16, int24, int32, float, double, fixed16, fixed32
+```
+
+Numbers are big-endian (network order) by default, but little-endian is supported, too:
+
+```javascript
+uint16le, uint24le, uint32le, int16le, int24le, int32le, floatle, doublele, fixed16le, fixed32le
+```
+
+To avoid ambiguity, big-endian may be used explicitly:
+
+```javascript
+uint16be, uint24be, uint32be, int16be, int24be, int32be, floatbe, doublebe, fixed16be, fixed32be
+```
+
+### Boolean
+
+Booleans are encoded as `0` or `1` using one of the above number types.
+
+```javascript
+let bool = new r.Boolean(r.uint32);
+```
+
+### Reserved
+
+The `Reserved` type simply skips data in a structure, where there are reserved fields.
+Encoding produces zeros.
+
+```javascript
+// 10 reserved uint8s (default is 1)
+let reserved = new r.Reserved(r.uint8, 10);
+```
+
+### Optional
+
+The `Optional` type only encodes or decodes when given condition is truthy.
+
+```javascript
+// includes field
+let optional = new r.Optional(r.uint8, true);
+
+// excludes field
+let optional = new r.Optional(r.uint8, false);
+
+// determine whether field is to be included at runtime with a function
+let optional = new r.Optional(r.uint8, function() {
+  return this.flags & 0x50;
+});
+```
+
+### Enum
+
+The `Enum` type maps a number to the value at that index in an array.
+
+```javascript
+let color = new r.Enum(r.uint8, ['red', 'orange', 'yellow', 'green', 'blue', 'purple']);
+```
+
+### Bitfield
+
+The `Bitfield` type maps a number to an object with boolean keys mapping to each bit in that number,
+as defined in an array.
+
+```javascript
+let bitfield = new r.Bitfield(r.uint8, ['Jack', 'Kack', 'Lack', 'Mack', 'Nack', 'Oack', 'Pack', 'Quack']);
+bitfield.decode(stream);
+
+let result = {
+  Jack: true,
+  Kack: false,
+  Lack: false,
+  Mack: true,
+  Nack: true,
+  Oack: false,
+  Pack: true,
+  Quack: true
+};
+
+bitfield.encode(stream, result);
+```
+
+### Buffer
+
+Extracts a slice of the buffer to a Node `Buffer`.  The length can be a constant, or taken from
+a previous field in the parent structure.
+
+```javascript
+// fixed length
+let buf = new r.Buffer(2);
+
+// length from parent structure
+let struct = new r.Struct({
+  bufLen: r.uint8,
+  buf: new r.Buffer('bufLen')
+});
+```
+
+### String
+
+A `String` maps a JavaScript string to and from binary encodings.  The length can be a constant, taken
+from a previous field in the parent structure, or encoded using a number type immediately before the string.
+
+Supported encodings include `'ascii'`, `'utf8'`, `'ucs2'`, `'utf16le'`, `'utf16be'`, and if you also install
+[iconv-lite](https://github.com/ashtuchkin/iconv-lite), many other legacy codecs.
+
+```javascript
+// fixed length, ascii encoding by default
+let str = new r.String(2);
+
+// length encoded as number before the string, utf8 encoding
+let str = new r.String(r.uint8, 'utf8');
+
+// length from parent structure
+let struct = new r.Struct({
+  len: r.uint8,
+  str: new r.String('len', 'utf16be')
+});
+
+// null-terminated string (also known as C string)
+let str = new r.String(null, 'utf8')
+```
+
+### Array
+
+An `Array` maps to and from a JavaScript array containing instances of a sub-type. The length can be a constant,
+taken from a previous field in the parent structure, encoded using a number type immediately
+before the string, or computed by a function.
+
+```javascript
+// fixed length, containing numbers
+let arr = new r.Array(r.uint16, 2);
+
+// length encoded as number before the array containing strings
+let arr = new r.Array(new r.String(10), r.uint8);
+
+// length computed by a function
+let arr = new r.Array(r.uint8, function() { return 5 });
+
+// length from parent structure
+let struct = new r.Struct({
+  len: r.uint8,
+  arr: new r.Array(r.uint8, 'len')
+});
+
+// treat as amount of bytes instead (may be used in all the above scenarios)
+let arr = new r.Array(r.uint16, 6, 'bytes');
+```
+
+### LazyArray
+
+The `LazyArray` type extends from the `Array` type, and is useful for large arrays that you do not need to access sequentially.
+It avoids decoding the entire array upfront, and instead only decodes and caches individual items as needed. It only works when
+the elements inside the array have a fixed size.
+
+Instead of returning a JavaScript array, the `LazyArray` type returns a custom object that can be used to access the elements.
+
+```javascript
+let arr = new r.LazyArray(r.uint16, 2048);
+let res = arr.decode(stream);
+
+// get a single element
+let el = res.get(2);
+
+// convert to a normal array (decode all elements)
+let array = res.toArray();
+```
+
+### Struct
+
+A `Struct` maps to and from JavaScript objects, containing keys of various previously discussed types. Sub structures,
+arrays of structures, and pointers to other types (discussed below) are supported.
+
+```javascript
+let Person = new r.Struct({
+  name: new r.String(r.uint8, 'utf8'),
+  age: r.uint8
+});
+```
+
+### VersionedStruct
+
+A `VersionedStruct` is a `Struct` that has multiple versions. The version is typically encoded at
+the beginning of the structure, or as a field in a parent structure. There is an optional `header`
+common to all versions, and separate fields listed for each version number.
+
+```javascript
+// the version is read as a uint8 in this example
+// you could also get the version from a key on the parent struct
+let Person = new r.VersionedStruct(r.uint8, {
+  // optional header common to all versions
+  header: {
+    name: new r.String(r.uint8, 'utf8')
+  },
+  0: {
+    age: r.uint8
+  },
+  1: {
+    hairColor: r.Enum(r.uint8, ['black', 'brown', 'blonde'])
+  }
+});
+```
+
+### Pointer
+
+Pointers map an address or offset encoded as a number, to a value encoded elsewhere in the buffer.
+There are a few options you can use: `type`, `relativeTo`, `allowNull`, and `nullValue`.
+The `type` option has these possible values:
+
+* `local` (default) - the encoded offset is relative to the start of the containing structure
+* `immediate` - the encoded offset is relative to the position of the pointer itself
+* `parent` - the encoded offset is relative to the parent structure of the immediate container
+* `global` - the encoded offset is global to the start of the file
+
+The `relativeTo` option specifies that the encoded offset is relative to a field on the containing structure.
+By default, pointers are relative to the start of the containing structure (`local`).
+
+The `allowNull` option lets you specify whether zero offsets are allowed or should produce `null`. This is
+set to `true` by default. The `nullValue` option is related, and lets you override the encoded value that
+represents `null`. By default, the `nullValue` is zero.
+
+The `lazy` option allows lazy decoding of the pointer's value by defining a getter on the parent object.
+This only works when the pointer is contained within a Struct, but can be used to speed up decoding
+quite a bit when not all of the data is needed right away.
+
+```javascript
+let Address = new r.Struct({
+  street: new r.String(r.uint8),
+  zip: new r.String(5)
+});
+
+let Person = new r.Struct({
+  name: new r.String(r.uint8, 'utf8'),
+  age: r.uint8,
+  ptrStart: r.uint8,
+  address: new r.Pointer(r.uint8, Address)
+});
+```
+
+If the type of a pointer is set to 'void', it is not decoded and the computed address in the buffer
+is simply returned. To encode a void pointer, create a `new r.VoidPointer(type, value)`.
+
+## License
+[MIT](https://choosealicense.com/licenses/mit/)

package/dist/array.d.ts

@@ -0,0 +1,15 @@
+import Base from "./base.js";
+import type DecodeStream from "./decode-stream.js";
+import type EncodeStream from "./encode-stream.js";
+import { type LengthLike } from "./utils.js";
+type LengthType = "count" | "bytes";
+export default class ArrayT<T = unknown, TResult = T[]> extends Base<TResult> {
+    type: any;
+    length?: LengthLike;
+    lengthType: LengthType;
+    constructor(type: any, length?: LengthLike, lengthType?: LengthType);
+    decode(stream: DecodeStream, parent?: any): TResult;
+    size(array?: T[], ctx?: any, includePointers?: boolean): number;
+    encode(stream: EncodeStream, array: T[], parent?: any): void;
+}
+export {};

package/dist/array.js

@@ -0,0 +1,95 @@
+import Base from "./base.js";
+import { Number as NumberT } from "./number.js";
+import { resolveLength } from "./utils.js";
+export default class ArrayT extends Base {
+    type;
+    length;
+    lengthType;
+    constructor(type, length, lengthType = "count") {
+        super();
+        this.type = type;
+        this.length = length;
+        this.lengthType = lengthType;
+    }
+    decode(stream, parent) {
+        const pos = stream.pos;
+        const result = [];
+        let ctx = parent;
+        let length;
+        if (typeof this.length !== "undefined") {
+            length = resolveLength(this.length, stream, parent);
+        }
+        if (this.length instanceof NumberT) {
+            Object.defineProperties(result, {
+                parent: { value: parent },
+                _startOffset: { value: pos },
+                _currentOffset: { value: 0, writable: true },
+                _length: { value: length },
+            });
+            ctx = result;
+        }
+        if (typeof length === "undefined" || this.lengthType === "bytes") {
+            let target;
+            if (typeof length === "number") {
+                target = stream.pos + length;
+            }
+            else if (parent?._length) {
+                target = parent._startOffset + parent._length;
+            }
+            else {
+                target = stream.length;
+            }
+            while (stream.pos < target) {
+                result.push(this.type.decode(stream, ctx));
+            }
+        }
+        else {
+            for (let i = 0; i < length; i += 1) {
+                result.push(this.type.decode(stream, ctx));
+            }
+        }
+        return result;
+    }
+    size(array, ctx, includePointers = true) {
+        if (!array) {
+            return this.type.size(null, ctx) * resolveLength(this.length, undefined, ctx);
+        }
+        let total = 0;
+        let context = ctx;
+        if (this.length instanceof NumberT) {
+            total += this.length.size();
+            context = { parent: ctx, pointerSize: 0 };
+        }
+        for (const item of array) {
+            total += this.type.size(item, context);
+        }
+        if (includePointers && this.length instanceof NumberT && context) {
+            total += context.pointerSize ?? 0;
+        }
+        return total;
+    }
+    encode(stream, array, parent) {
+        let ctx = parent;
+        if (this.length instanceof NumberT) {
+            ctx = {
+                pointers: [],
+                startOffset: stream.pos,
+                parent,
+                pointerSize: 0,
+            };
+            ctx.pointerOffset = stream.pos + this.size(array, ctx, false);
+            this.length.encode(stream, array.length);
+        }
+        for (const item of array) {
+            this.type.encode(stream, item, ctx);
+        }
+        if (this.length instanceof NumberT) {
+            let i = 0;
+            while (i < ctx.pointers.length) {
+                const ptr = ctx.pointers[i++];
+                ptr.type.encode(stream, ptr.val, ptr.parent);
+            }
+        }
+    }
+}
+//# sourceMappingURL=array.js.map

package/dist/array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.js","sourceRoot":"","sources":["../src/array.ts"],"names":[],"mappings":"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"}

package/dist/base.d.ts

@@ -0,0 +1,4 @@
+export default abstract class Base<T = unknown> {
+    fromBuffer(buffer: Uint8Array): T;
+    toBuffer(value: T): Uint8Array;
+}

package/dist/base.js

@@ -0,0 +1,16 @@
+import DecodeStream from "./decode-stream.js";
+import EncodeStream from "./encode-stream.js";
+export default class Base {
+    fromBuffer(buffer) {
+        const stream = new DecodeStream(buffer);
+        return this.decode(stream);
+    }
+    toBuffer(value) {
+        const size = typeof this.size === "function" ? this.size(value) : 0;
+        const buffer = new Uint8Array(size);
+        const stream = new EncodeStream(buffer);
+        this.encode(stream, value);
+        return buffer;
+    }
+}
+//# sourceMappingURL=base.js.map

package/dist/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../src/base.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAC9C,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAE9C,MAAM,CAAC,OAAO,OAAgB,IAAI;IAChC,UAAU,CAAC,MAAkB;QAC3B,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,CAAC;QACxC,OAAQ,IAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;IAED,QAAQ,CAAC,KAAQ;QACf,MAAM,IAAI,GAAG,OAAQ,IAAY,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC,CAAE,IAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACtF,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC;QACpC,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,CAAC;QACvC,IAAY,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QACpC,OAAO,MAAM,CAAC;IAChB,CAAC;CACF"}

package/dist/bitfield.d.ts

@@ -0,0 +1,11 @@
+import Base from "./base.js";
+import type DecodeStream from "./decode-stream.js";
+import type EncodeStream from "./encode-stream.js";
+export default class Bitfield extends Base<Record<string, boolean>> {
+    type: any;
+    flags: Array<string | null | undefined>;
+    constructor(type: any, flags?: Array<string | null | undefined>);
+    decode(stream: DecodeStream): Record<string, boolean>;
+    size(): number;
+    encode(stream: EncodeStream, keys: Record<string, boolean>): void;
+}

package/dist/bitfield.js

@@ -0,0 +1,37 @@
+import Base from "./base.js";
+export default class Bitfield extends Base {
+    type;
+    flags;
+    constructor(type, flags = []) {
+        super();
+        this.type = type;
+        this.flags = flags;
+    }
+    decode(stream) {
+        const value = this.type.decode(stream);
+        const result = {};
+        this.flags.forEach((flag, index) => {
+            if (!flag) {
+                return;
+            }
+            result[flag] = Boolean(value & (1 << index));
+        });
+        return result;
+    }
+    size() {
+        return this.type.size();
+    }
+    encode(stream, keys) {
+        let value = 0;
+        this.flags.forEach((flag, index) => {
+            if (!flag) {
+                return;
+            }
+            if (keys[flag]) {
+                value |= 1 << index;
+            }
+        });
+        this.type.encode(stream, value);
+    }
+}
+//# sourceMappingURL=bitfield.js.map

package/dist/bitfield.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitfield.js","sourceRoot":"","sources":["../src/bitfield.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAI7B,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,IAA6B;IAC1D,IAAI,CAAM;IACV,KAAK,CAAmC;IAE/C,YAAY,IAAS,EAAE,QAA0C,EAAE;QACjE,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED,MAAM,CAAC,MAAoB;QACzB,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACvC,MAAM,MAAM,GAA4B,EAAE,CAAC;QAE3C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;YACjC,IAAI,CAAC,IAAI,EAAE,CAAC;gBACV,OAAO;YACT,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,IAAI;QACF,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;IAC1B,CAAC;IAED,MAAM,CAAC,MAAoB,EAAE,IAA6B;QACxD,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;YACjC,IAAI,CAAC,IAAI,EAAE,CAAC;gBACV,OAAO;YACT,CAAC;YACD,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;gBACf,KAAK,IAAI,CAAC,IAAI,KAAK,CAAC;YACtB,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAClC,CAAC;CACF"}

package/dist/boolean.d.ts

@@ -0,0 +1,10 @@
+import Base from "./base.js";
+import type DecodeStream from "./decode-stream.js";
+import type EncodeStream from "./encode-stream.js";
+export default class BooleanT extends Base<boolean> {
+    type: any;
+    constructor(type: any);
+    decode(stream: DecodeStream, parent?: any): boolean;
+    size(value?: any, parent?: any): number;
+    encode(stream: EncodeStream, value: boolean, parent?: any): void;
+}

package/dist/boolean.js

@@ -0,0 +1,18 @@
+import Base from "./base.js";
+export default class BooleanT extends Base {
+    type;
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+    decode(stream, parent) {
+        return Boolean(this.type.decode(stream, parent));
+    }
+    size(value, parent) {
+        return this.type.size(value, parent);
+    }
+    encode(stream, value, parent) {
+        this.type.encode(stream, Number(value), parent);
+    }
+}
+//# sourceMappingURL=boolean.js.map

package/dist/boolean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.js","sourceRoot":"","sources":["../src/boolean.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAI7B,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,IAAa;IAC1C,IAAI,CAAM;IAEjB,YAAY,IAAS;QACnB,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED,MAAM,CAAC,MAAoB,EAAE,MAAY;QACvC,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,CAAC;IAED,IAAI,CAAC,KAAW,EAAE,MAAY;QAC5B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACvC,CAAC;IAED,MAAM,CAAC,MAAoB,EAAE,KAAc,EAAE,MAAY;QACvD,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,CAAC;IAClD,CAAC;CACF"}

package/dist/buffer.d.ts

@@ -0,0 +1,11 @@
+import Base from "./base.js";
+import type DecodeStream from "./decode-stream.js";
+import type EncodeStream from "./encode-stream.js";
+import { type LengthLike } from "./utils.js";
+export default class BufferT extends Base<Uint8Array> {
+    length: LengthLike;
+    constructor(length: LengthLike);
+    decode(stream: DecodeStream, parent?: any): Uint8Array;
+    size(value?: Uint8Array, parent?: any): number;
+    encode(stream: EncodeStream, value: Uint8Array, _parent?: any): void;
+}

package/dist/buffer.js

@@ -0,0 +1,31 @@
+import Base from "./base.js";
+import { Number as NumberT } from "./number.js";
+import { resolveLength } from "./utils.js";
+export default class BufferT extends Base {
+    length;
+    constructor(length) {
+        super();
+        this.length = length;
+    }
+    decode(stream, parent) {
+        const length = resolveLength(this.length, stream, parent);
+        return stream.readBuffer(length);
+    }
+    size(value, parent) {
+        if (value == null) {
+            return resolveLength(this.length, undefined, parent);
+        }
+        let length = value.length;
+        if (this.length instanceof NumberT) {
+            length += this.length.size();
+        }
+        return length;
+    }
+    encode(stream, value, _parent) {
+        if (this.length instanceof NumberT) {
+            this.length.encode(stream, value.length);
+        }
+        stream.writeBuffer(value);
+    }
+}
+//# sourceMappingURL=buffer.js.map

package/dist/buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.js","sourceRoot":"","sources":["../src/buffer.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAG7B,OAAO,EAAE,MAAM,IAAI,OAAO,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,aAAa,EAAmB,MAAM,YAAY,CAAC;AAE5D,MAAM,CAAC,OAAO,OAAO,OAAQ,SAAQ,IAAgB;IAC5C,MAAM,CAAa;IAE1B,YAAY,MAAkB;QAC5B,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED,MAAM,CAAC,MAAoB,EAAE,MAAY;QACvC,MAAM,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAC1D,OAAO,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED,IAAI,CAAC,KAAkB,EAAE,MAAY;QACnC,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;YAClB,OAAO,aAAa,CAAC,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;QACvD,CAAC;QAED,IAAI,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QAC1B,IAAI,IAAI,CAAC,MAAM,YAAY,OAAO,EAAE,CAAC;YACnC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QAC/B,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,CAAC,MAAoB,EAAE,KAAiB,EAAE,OAAa;QAC3D,IAAI,IAAI,CAAC,MAAM,YAAY,OAAO,EAAE,CAAC;YACnC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QAC3C,CAAC;QAED,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;CACF"}

package/dist/decode-stream.d.ts

@@ -0,0 +1,26 @@
+export default class DecodeStream {
+    static readonly TYPES: {
+        readonly UInt8: 1;
+        readonly UInt16: 2;
+        readonly UInt24: 3;
+        readonly UInt32: 4;
+        readonly Int8: 1;
+        readonly Int16: 2;
+        readonly Int24: 3;
+        readonly Int32: 4;
+        readonly Float: 4;
+        readonly Double: 8;
+    };
+    pos: number;
+    length: number;
+    buffer: Uint8Array;
+    view: DataView;
+    [key: string]: any;
+    constructor(buffer: Uint8Array | Buffer);
+    readString(length: number, encoding?: string): string | Uint8Array;
+    readBuffer(length: number): Uint8Array;
+    readUInt24BE(): number;
+    readUInt24LE(): number;
+    readInt24BE(): number;
+    readInt24LE(): number;
+}